blob: fdc729b91546c860af7da8a31f24090e575bf40d [file] [log] [blame]
sfricke-samsung11ea8ed2020-01-07 22:24:56 -08001/* Copyright (c) 2015-2020 The Khronos Group Inc.
2 * Copyright (c) 2015-2020 Valve Corporation
3 * Copyright (c) 2015-2020 LunarG, Inc.
4 * Copyright (C) 2015-2020 Google Inc.
Mark Lobodzinskid4950072017-08-01 13:02:20 -06005 *
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at
9 *
10 * http://www.apache.org/licenses/LICENSE-2.0
11 *
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
17 *
18 * Author: Mark Lobodzinski <mark@LunarG.com>
John Zulaufa999d1b2018-11-29 13:38:40 -070019 * Author: John Zulauf <jzulauf@lunarg.com>
Mark Lobodzinskid4950072017-08-01 13:02:20 -060020 */
21
orbea80ddc062019-09-10 10:33:19 -070022#include <cmath>
Shahbaz Youssefi6be11412019-01-10 15:29:30 -050023
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -070024#include "chassis.h"
25#include "stateless_validation.h"
Mark Lobodzinskie514d1a2019-03-12 08:47:45 -060026#include "layer_chassis_dispatch.h"
Tobias Hectord942eb92018-10-22 15:18:56 +010027
Mark Lobodzinskid4950072017-08-01 13:02:20 -060028static const int MaxParamCheckerStringLength = 256;
29
John Zulauf71968502017-10-26 13:51:15 -060030template <typename T>
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -070031inline bool in_inclusive_range(const T &value, const T &min, const T &max) {
John Zulauf71968502017-10-26 13:51:15 -060032 // Using only < for generality and || for early abort
33 return !((value < min) || (max < value));
34}
35
Mark Lobodzinskibf599b92018-12-31 12:15:55 -070036bool StatelessValidation::validate_string(const char *apiName, const ParameterName &stringName, const std::string &vuid,
Jeff Bolz46c0ea02019-10-09 13:06:29 -050037 const char *validateString) const {
Mark Lobodzinskid4950072017-08-01 13:02:20 -060038 bool skip = false;
39
40 VkStringErrorFlags result = vk_string_validate(MaxParamCheckerStringLength, validateString);
41
42 if (result == VK_STRING_ERROR_NONE) {
43 return skip;
44 } else if (result & VK_STRING_ERROR_LENGTH) {
Mark Lobodzinskiebee3552018-05-29 09:55:54 -060045 skip = log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, vuid,
46 "%s: string %s exceeds max length %d", apiName, stringName.get_name().c_str(), MaxParamCheckerStringLength);
Mark Lobodzinskid4950072017-08-01 13:02:20 -060047 } else if (result & VK_STRING_ERROR_BAD_DATA) {
Mark Lobodzinskiebee3552018-05-29 09:55:54 -060048 skip = log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, vuid,
49 "%s: string %s contains invalid characters or is badly formed", apiName, stringName.get_name().c_str());
Mark Lobodzinskid4950072017-08-01 13:02:20 -060050 }
51 return skip;
52}
53
Jeff Bolz46c0ea02019-10-09 13:06:29 -050054bool StatelessValidation::validate_api_version(uint32_t api_version, uint32_t effective_api_version) const {
John Zulauf620755c2018-04-16 11:00:43 -060055 bool skip = false;
56 uint32_t api_version_nopatch = VK_MAKE_VERSION(VK_VERSION_MAJOR(api_version), VK_VERSION_MINOR(api_version), 0);
57 if (api_version_nopatch != effective_api_version) {
58 if (api_version_nopatch < VK_API_VERSION_1_0) {
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -070059 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT,
60 HandleToUint64(instance), kVUIDUndefined,
John Zulauf620755c2018-04-16 11:00:43 -060061 "Invalid CreateInstance->pCreateInfo->pApplicationInfo.apiVersion number (0x%08x). "
62 "Using VK_API_VERSION_%" PRIu32 "_%" PRIu32 ".",
63 api_version, VK_VERSION_MAJOR(effective_api_version), VK_VERSION_MINOR(effective_api_version));
64 } else {
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -070065 skip |= log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT,
66 HandleToUint64(instance), kVUIDUndefined,
John Zulauf620755c2018-04-16 11:00:43 -060067 "Unrecognized CreateInstance->pCreateInfo->pApplicationInfo.apiVersion number (0x%08x). "
68 "Assuming VK_API_VERSION_%" PRIu32 "_%" PRIu32 ".",
69 api_version, VK_VERSION_MAJOR(effective_api_version), VK_VERSION_MINOR(effective_api_version));
70 }
71 }
72 return skip;
73}
74
Jeff Bolz46c0ea02019-10-09 13:06:29 -050075bool StatelessValidation::validate_instance_extensions(const VkInstanceCreateInfo *pCreateInfo) const {
John Zulauf620755c2018-04-16 11:00:43 -060076 bool skip = false;
Mark Lobodzinski05cce202019-08-27 10:28:37 -060077 // Create and use a local instance extension object, as an actual instance has not been created yet
78 uint32_t specified_version = (pCreateInfo->pApplicationInfo ? pCreateInfo->pApplicationInfo->apiVersion : VK_API_VERSION_1_0);
79 InstanceExtensions local_instance_extensions;
80 local_instance_extensions.InitFromInstanceCreateInfo(specified_version, pCreateInfo);
81
John Zulauf620755c2018-04-16 11:00:43 -060082 for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) {
Mark Lobodzinski05cce202019-08-27 10:28:37 -060083 skip |= validate_extension_reqs(local_instance_extensions, "VUID-vkCreateInstance-ppEnabledExtensionNames-01388",
84 "instance", pCreateInfo->ppEnabledExtensionNames[i]);
John Zulauf620755c2018-04-16 11:00:43 -060085 }
86
87 return skip;
88}
89
John Zulauf620755c2018-04-16 11:00:43 -060090template <typename ExtensionState>
Tony-LunarG2ec96bb2019-11-26 13:43:02 -070091ExtEnabled extension_state_by_name(const ExtensionState &extensions, const char *extension_name) {
92 if (!extension_name) return kNotEnabled; // null strings specify nothing
John Zulauf620755c2018-04-16 11:00:43 -060093 auto info = ExtensionState::get_info(extension_name);
Tony-LunarG2ec96bb2019-11-26 13:43:02 -070094 ExtEnabled state =
95 info.state ? extensions.*(info.state) : kNotEnabled; // unknown extensions can't be enabled in extension struct
John Zulauf620755c2018-04-16 11:00:43 -060096 return state;
97}
98
Mark Lobodzinskibf599b92018-12-31 12:15:55 -070099bool StatelessValidation::manual_PreCallValidateCreateInstance(const VkInstanceCreateInfo *pCreateInfo,
Jeff Bolz5c801d12019-10-09 10:38:45 -0500100 const VkAllocationCallbacks *pAllocator,
101 VkInstance *pInstance) const {
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -0700102 bool skip = false;
103 // Note: From the spec--
104 // Providing a NULL VkInstanceCreateInfo::pApplicationInfo or providing an apiVersion of 0 is equivalent to providing
105 // an apiVersion of VK_MAKE_VERSION(1, 0, 0). (a.k.a. VK_API_VERSION_1_0)
106 uint32_t local_api_version = (pCreateInfo->pApplicationInfo && pCreateInfo->pApplicationInfo->apiVersion)
Mark Lobodzinskibf599b92018-12-31 12:15:55 -0700107 ? pCreateInfo->pApplicationInfo->apiVersion
108 : VK_API_VERSION_1_0;
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -0700109 skip |= validate_api_version(local_api_version, api_version);
110 skip |= validate_instance_extensions(pCreateInfo);
111 return skip;
112}
113
Mark Lobodzinskibf599b92018-12-31 12:15:55 -0700114void StatelessValidation::PostCallRecordCreateInstance(const VkInstanceCreateInfo *pCreateInfo,
Mark Lobodzinskicd05c1e2019-01-17 15:33:46 -0700115 const VkAllocationCallbacks *pAllocator, VkInstance *pInstance,
116 VkResult result) {
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -0700117 auto instance_data = GetLayerDataPtr(get_dispatch_key(*pInstance), layer_data_map);
118 // Copy extension data into local object
Mark Lobodzinskicd05c1e2019-01-17 15:33:46 -0700119 if (result != VK_SUCCESS) return;
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -0700120 this->instance_extensions = instance_data->instance_extensions;
121}
122
locke-lunargb1909cd2019-08-01 23:40:05 -0600123void StatelessValidation::PostCallRecordQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR *pPresentInfo, VkResult result) {
124 for (uint32_t i = 0; i < pPresentInfo->swapchainCount; ++i) {
125 auto swapchains_result = pPresentInfo->pResults ? pPresentInfo->pResults[i] : result;
126 if (swapchains_result == VK_SUBOPTIMAL_KHR) {
127 log_msg(report_data, VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT,
128 HandleToUint64(pPresentInfo->pSwapchains[i]), kVUID_PVPerfWarn_SuboptimalSwapchain,
129 "vkQueuePresentKHR: %s :VK_SUBOPTIMAL_KHR was returned. VK_SUBOPTIMAL_KHR - Presentation will still succeed, "
130 "subject to the window resize behavior, but the swapchain is no longer configured optimally for the surface it "
131 "targets. Applications should query updated surface information and recreate their swapchain at the next "
132 "convenient opportunity.",
133 report_data->FormatHandle(pPresentInfo->pSwapchains[i]).c_str());
134 }
135 }
136}
137
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -0700138void StatelessValidation::PostCallRecordCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo,
Mark Lobodzinskicd05c1e2019-01-17 15:33:46 -0700139 const VkAllocationCallbacks *pAllocator, VkDevice *pDevice, VkResult result) {
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -0700140 auto device_data = GetLayerDataPtr(get_dispatch_key(*pDevice), layer_data_map);
Mark Lobodzinskicd05c1e2019-01-17 15:33:46 -0700141 if (result != VK_SUCCESS) return;
Mark Lobodzinskibf599b92018-12-31 12:15:55 -0700142 ValidationObject *validation_data = GetValidationObject(device_data->object_dispatch, LayerObjectTypeParameterValidation);
143 StatelessValidation *stateless_validation = static_cast<StatelessValidation *>(validation_data);
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -0700144
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -0700145 // Parmeter validation also uses extension data
146 stateless_validation->device_extensions = this->device_extensions;
147
148 VkPhysicalDeviceProperties device_properties = {};
149 // Need to get instance and do a getlayerdata call...
Tony-LunarG152a88b2019-03-20 15:42:24 -0600150 DispatchGetPhysicalDeviceProperties(physicalDevice, &device_properties);
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -0700151 memcpy(&stateless_validation->device_limits, &device_properties.limits, sizeof(VkPhysicalDeviceLimits));
152
153 if (device_extensions.vk_nv_shading_rate_image) {
154 // Get the needed shading rate image limits
155 auto shading_rate_image_props = lvl_init_struct<VkPhysicalDeviceShadingRateImagePropertiesNV>();
156 auto prop2 = lvl_init_struct<VkPhysicalDeviceProperties2KHR>(&shading_rate_image_props);
Tony-LunarG152a88b2019-03-20 15:42:24 -0600157 DispatchGetPhysicalDeviceProperties2KHR(physicalDevice, &prop2);
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -0700158 phys_dev_ext_props.shading_rate_image_props = shading_rate_image_props;
159 }
160
161 if (device_extensions.vk_nv_mesh_shader) {
162 // Get the needed mesh shader limits
163 auto mesh_shader_props = lvl_init_struct<VkPhysicalDeviceMeshShaderPropertiesNV>();
164 auto prop2 = lvl_init_struct<VkPhysicalDeviceProperties2KHR>(&mesh_shader_props);
Tony-LunarG152a88b2019-03-20 15:42:24 -0600165 DispatchGetPhysicalDeviceProperties2KHR(physicalDevice, &prop2);
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -0700166 phys_dev_ext_props.mesh_shader_props = mesh_shader_props;
167 }
168
Jason Macnak5c954952019-07-09 15:46:12 -0700169 if (device_extensions.vk_nv_ray_tracing) {
170 // Get the needed ray tracing limits
171 auto ray_tracing_props = lvl_init_struct<VkPhysicalDeviceRayTracingPropertiesNV>();
172 auto prop2 = lvl_init_struct<VkPhysicalDeviceProperties2KHR>(&ray_tracing_props);
173 DispatchGetPhysicalDeviceProperties2KHR(physicalDevice, &prop2);
174 phys_dev_ext_props.ray_tracing_props = ray_tracing_props;
175 }
176
Mark Lobodzinski953b7bc2019-12-19 13:50:10 -0700177 if (device_extensions.vk_ext_transform_feedback) {
178 // Get the needed transform feedback limits
179 auto transform_feedback_props = lvl_init_struct<VkPhysicalDeviceTransformFeedbackPropertiesEXT>();
180 auto prop2 = lvl_init_struct<VkPhysicalDeviceProperties2KHR>(&transform_feedback_props);
181 DispatchGetPhysicalDeviceProperties2KHR(physicalDevice, &prop2);
182 phys_dev_ext_props.transform_feedback_props = transform_feedback_props;
183 }
184
Jasper St. Pierrea49b4be2019-02-05 17:48:57 -0800185 stateless_validation->phys_dev_ext_props = this->phys_dev_ext_props;
186
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -0700187 // Save app-enabled features in this device's validation object
188 // The enabled features can come from either pEnabledFeatures, or from the pNext chain
Petr Kraus715bcc72019-08-15 17:17:33 +0200189 const auto *features2 = lvl_find_in_chain<VkPhysicalDeviceFeatures2>(pCreateInfo->pNext);
190 safe_VkPhysicalDeviceFeatures2 tmp_features2_state;
191 tmp_features2_state.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
192 if (features2) {
193 tmp_features2_state.features = features2->features;
194 } else if (pCreateInfo->pEnabledFeatures) {
195 tmp_features2_state.features = *pCreateInfo->pEnabledFeatures;
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -0700196 } else {
Petr Kraus715bcc72019-08-15 17:17:33 +0200197 tmp_features2_state.features = {};
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -0700198 }
Petr Kraus715bcc72019-08-15 17:17:33 +0200199 // Use pCreateInfo->pNext to get full chain
Tony-LunarG6c3c5452019-12-13 10:37:38 -0700200 stateless_validation->device_createinfo_pnext = SafePnextCopy(pCreateInfo->pNext);
Petr Kraus715bcc72019-08-15 17:17:33 +0200201 stateless_validation->physical_device_features2 = tmp_features2_state;
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -0700202}
203
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -0700204bool StatelessValidation::manual_PreCallValidateCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo,
Jeff Bolz5c801d12019-10-09 10:38:45 -0500205 const VkAllocationCallbacks *pAllocator, VkDevice *pDevice) const {
Mark Lobodzinskid4950072017-08-01 13:02:20 -0600206 bool skip = false;
207
Petr Kraus6c4bdce2019-08-27 17:35:01 +0200208 for (size_t i = 0; i < pCreateInfo->enabledLayerCount; i++) {
209 skip |= validate_string("vkCreateDevice", "pCreateInfo->ppEnabledLayerNames",
210 "VUID-VkDeviceCreateInfo-ppEnabledLayerNames-parameter", pCreateInfo->ppEnabledLayerNames[i]);
Mark Lobodzinskid4950072017-08-01 13:02:20 -0600211 }
212
Petr Kraus6c4bdce2019-08-27 17:35:01 +0200213 for (size_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) {
214 skip |=
215 validate_string("vkCreateDevice", "pCreateInfo->ppEnabledExtensionNames",
216 "VUID-VkDeviceCreateInfo-ppEnabledExtensionNames-parameter", pCreateInfo->ppEnabledExtensionNames[i]);
217 skip |= validate_extension_reqs(device_extensions, "VUID-vkCreateDevice-ppEnabledExtensionNames-01387", "device",
218 pCreateInfo->ppEnabledExtensionNames[i]);
Mark Lobodzinskid4950072017-08-01 13:02:20 -0600219 }
220
Petr Kraus6c4bdce2019-08-27 17:35:01 +0200221 {
Tony-LunarG2ec96bb2019-11-26 13:43:02 -0700222 bool maint1 = IsExtEnabled(extension_state_by_name(device_extensions, VK_KHR_MAINTENANCE1_EXTENSION_NAME));
223 bool negative_viewport =
224 IsExtEnabled(extension_state_by_name(device_extensions, VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_EXTENSION_NAME));
Petr Kraus6c4bdce2019-08-27 17:35:01 +0200225 if (maint1 && negative_viewport) {
226 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
227 "VUID-VkDeviceCreateInfo-ppEnabledExtensionNames-00374",
228 "VkDeviceCreateInfo->ppEnabledExtensionNames must not simultaneously include VK_KHR_maintenance1 and "
229 "VK_AMD_negative_viewport_height.");
230 }
Mark Lobodzinskid4950072017-08-01 13:02:20 -0600231 }
232
Jeff Bolz4563f2a2019-12-10 13:30:30 -0600233 {
234 bool khr_bda = IsExtEnabled(extension_state_by_name(device_extensions, VK_KHR_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME));
235 bool ext_bda = IsExtEnabled(extension_state_by_name(device_extensions, VK_EXT_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME));
236 if (khr_bda && ext_bda) {
237 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
238 "VUID-VkDeviceCreateInfo-ppEnabledExtensionNames-03328",
239 "VkDeviceCreateInfo->ppEnabledExtensionNames must not contain both VK_KHR_buffer_device_address and "
240 "VK_EXT_buffer_device_address.");
241 }
242 }
243
Mark Lobodzinskid4950072017-08-01 13:02:20 -0600244 if (pCreateInfo->pNext != NULL && pCreateInfo->pEnabledFeatures) {
245 // Check for get_physical_device_properties2 struct
John Zulaufde972ac2017-10-26 12:07:05 -0600246 const auto *features2 = lvl_find_in_chain<VkPhysicalDeviceFeatures2KHR>(pCreateInfo->pNext);
247 if (features2) {
248 // Cannot include VkPhysicalDeviceFeatures2KHR and have non-null pEnabledFeatures
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -0700249 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Dave Houlton413a6782018-05-22 13:01:54 -0600250 kVUID_PVError_InvalidUsage,
John Zulaufde972ac2017-10-26 12:07:05 -0600251 "VkDeviceCreateInfo->pNext includes a VkPhysicalDeviceFeatures2KHR struct when "
252 "pCreateInfo->pEnabledFeatures is non-NULL.");
Mark Lobodzinskid4950072017-08-01 13:02:20 -0600253 }
254 }
255
Locke77fad1c2019-04-16 13:09:03 -0600256 auto features2 = lvl_find_in_chain<VkPhysicalDeviceFeatures2>(pCreateInfo->pNext);
257 if (features2) {
258 if (!instance_extensions.vk_khr_get_physical_device_properties_2) {
259 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
260 kVUID_PVError_ExtensionNotEnabled,
261 "VkDeviceCreateInfo->pNext includes a VkPhysicalDeviceFeatures2 struct, "
262 "VK_KHR_get_physical_device_properties2 must be enabled when it creates an instance.");
263 }
264 }
265
266 auto vertex_attribute_divisor_features =
267 lvl_find_in_chain<VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT>(pCreateInfo->pNext);
268 if (vertex_attribute_divisor_features) {
269 bool extension_found = false;
270 for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; ++i) {
271 if (0 == strncmp(pCreateInfo->ppEnabledExtensionNames[i], VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME,
272 VK_MAX_EXTENSION_NAME_SIZE)) {
273 extension_found = true;
274 break;
275 }
276 }
277 if (!extension_found) {
278 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
279 kVUID_PVError_ExtensionNotEnabled,
280 "VkDeviceCreateInfo->pNext includes a VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT "
281 "struct, VK_EXT_vertex_attribute_divisor must be enabled when it creates a device.");
282 }
283 }
284
Tony-LunarG28017bc2020-01-23 14:40:25 -0700285 const auto *vulkan_11_features = lvl_find_in_chain<VkPhysicalDeviceVulkan11Features>(pCreateInfo->pNext);
286 if (vulkan_11_features) {
287 const VkBaseOutStructure *current = reinterpret_cast<const VkBaseOutStructure *>(pCreateInfo->pNext);
288 while (current) {
289 if (current->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES ||
290 current->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES ||
291 current->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES ||
292 current->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES ||
293 current->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES ||
294 current->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES) {
295 skip |= log_msg(
296 report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
297 "VUID-VkDeviceCreateInfo-pNext-02829",
298 "If the pNext chain includes a VkPhysicalDeviceVulkan11Features structure, then it must not include a "
299 "VkPhysicalDevice16BitStorageFeatures, VkPhysicalDeviceMultiviewFeatures, "
300 "VkPhysicalDeviceVariablePointersFeatures, VkPhysicalDeviceProtectedMemoryFeatures, "
301 "VkPhysicalDeviceSamplerYcbcrConversionFeatures, or VkPhysicalDeviceShaderDrawParametersFeatures structure");
302 break;
303 }
304 current = reinterpret_cast<const VkBaseOutStructure *>(current->pNext);
305 }
306 }
307
308 const auto *vulkan_12_features = lvl_find_in_chain<VkPhysicalDeviceVulkan12Features>(pCreateInfo->pNext);
309 if (vulkan_12_features) {
310 const VkBaseOutStructure *current = reinterpret_cast<const VkBaseOutStructure *>(pCreateInfo->pNext);
311 while (current) {
312 if (current->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES ||
313 current->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES ||
314 current->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES ||
315 current->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES ||
316 current->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES ||
317 current->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES ||
318 current->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES ||
319 current->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES ||
320 current->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES ||
321 current->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES ||
322 current->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES ||
323 current->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES ||
324 current->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES) {
325 skip |= log_msg(
326 report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
327 "VUID-VkDeviceCreateInfo-pNext-02830",
328 "If the pNext chain includes a VkPhysicalDeviceVulkan12Features structure, then it must not include a "
329 "VkPhysicalDevice8BitStorageFeatures, VkPhysicalDeviceShaderAtomicInt64Features, "
330 "VkPhysicalDeviceShaderFloat16Int8Features, VkPhysicalDeviceDescriptorIndexingFeatures, "
331 "VkPhysicalDeviceScalarBlockLayoutFeatures, VkPhysicalDeviceImagelessFramebufferFeatures, "
332 "VkPhysicalDeviceUniformBufferStandardLayoutFeatures, VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures, "
333 "VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures, VkPhysicalDeviceHostQueryResetFeatures, "
334 "VkPhysicalDeviceTimelineSemaphoreFeatures, VkPhysicalDeviceBufferDeviceAddressFeatures, or "
335 "VkPhysicalDeviceVulkanMemoryModelFeatures structure");
336 break;
337 }
338 current = reinterpret_cast<const VkBaseOutStructure *>(current->pNext);
339 }
340 }
341
Mark Lobodzinskid4950072017-08-01 13:02:20 -0600342 // Validate pCreateInfo->pQueueCreateInfos
343 if (pCreateInfo->pQueueCreateInfos) {
344 std::unordered_set<uint32_t> set;
345
346 for (uint32_t i = 0; i < pCreateInfo->queueCreateInfoCount; ++i) {
347 const uint32_t requested_queue_family = pCreateInfo->pQueueCreateInfos[i].queueFamilyIndex;
348 if (requested_queue_family == VK_QUEUE_FAMILY_IGNORED) {
Mark Lobodzinskibf599b92018-12-31 12:15:55 -0700349 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT,
350 HandleToUint64(physicalDevice), "VUID-VkDeviceQueueCreateInfo-queueFamilyIndex-00381",
Mark Lobodzinskid4950072017-08-01 13:02:20 -0600351 "vkCreateDevice: pCreateInfo->pQueueCreateInfos[%" PRIu32
Dave Houltona9df0ce2018-02-07 10:51:23 -0700352 "].queueFamilyIndex is VK_QUEUE_FAMILY_IGNORED, but it is required to provide a valid queue family "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -0600353 "index value.",
354 i);
Mark Lobodzinskid4950072017-08-01 13:02:20 -0600355 } else if (set.count(requested_queue_family)) {
Mark Lobodzinskibf599b92018-12-31 12:15:55 -0700356 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT,
357 HandleToUint64(physicalDevice), "VUID-VkDeviceCreateInfo-queueFamilyIndex-00372",
Mark Lobodzinskid4950072017-08-01 13:02:20 -0600358 "vkCreateDevice: pCreateInfo->pQueueCreateInfos[%" PRIu32 "].queueFamilyIndex (=%" PRIu32
Mark Lobodzinski487a0d12018-03-30 10:09:03 -0600359 ") is not unique within pCreateInfo->pQueueCreateInfos array.",
360 i, requested_queue_family);
Mark Lobodzinskid4950072017-08-01 13:02:20 -0600361 } else {
362 set.insert(requested_queue_family);
363 }
364
365 if (pCreateInfo->pQueueCreateInfos[i].pQueuePriorities != nullptr) {
366 for (uint32_t j = 0; j < pCreateInfo->pQueueCreateInfos[i].queueCount; ++j) {
367 const float queue_priority = pCreateInfo->pQueueCreateInfos[i].pQueuePriorities[j];
368 if (!(queue_priority >= 0.f) || !(queue_priority <= 1.f)) {
Mark Lobodzinskibf599b92018-12-31 12:15:55 -0700369 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT,
370 HandleToUint64(physicalDevice), "VUID-VkDeviceQueueCreateInfo-pQueuePriorities-00383",
Mark Lobodzinskid4950072017-08-01 13:02:20 -0600371 "vkCreateDevice: pCreateInfo->pQueueCreateInfos[%" PRIu32 "].pQueuePriorities[%" PRIu32
Mark Lobodzinski487a0d12018-03-30 10:09:03 -0600372 "] (=%f) is not between 0 and 1 (inclusive).",
373 i, j, queue_priority);
Mark Lobodzinskid4950072017-08-01 13:02:20 -0600374 }
375 }
376 }
377 }
378 }
379
380 return skip;
381}
382
Jeff Bolz46c0ea02019-10-09 13:06:29 -0500383bool StatelessValidation::require_device_extension(bool flag, char const *function_name, char const *extension_name) const {
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -0700384 if (!flag) {
385 return log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
386 kVUID_PVError_ExtensionNotEnabled,
387 "%s() called even though the %s extension was not enabled for this VkDevice.", function_name,
388 extension_name);
Mark Lobodzinskid4950072017-08-01 13:02:20 -0600389 }
390
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -0700391 return false;
Mark Lobodzinskid4950072017-08-01 13:02:20 -0600392}
393
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -0700394bool StatelessValidation::manual_PreCallValidateCreateBuffer(VkDevice device, const VkBufferCreateInfo *pCreateInfo,
Jeff Bolz5c801d12019-10-09 10:38:45 -0500395 const VkAllocationCallbacks *pAllocator, VkBuffer *pBuffer) const {
Petr Krause91f7a12017-12-14 20:57:36 +0100396 bool skip = false;
397
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -0700398 const LogMiscParams log_misc{VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, VK_NULL_HANDLE, "vkCreateBuffer"};
Petr Krause5c37652018-01-05 04:05:12 +0100399
Mark Lobodzinskid4950072017-08-01 13:02:20 -0600400 if (pCreateInfo != nullptr) {
Dave Houlton413a6782018-05-22 13:01:54 -0600401 skip |= ValidateGreaterThanZero(pCreateInfo->size, "pCreateInfo->size", "VUID-VkBufferCreateInfo-size-00912", log_misc);
Mark Lobodzinskid4950072017-08-01 13:02:20 -0600402
403 // Validation for parameters excluded from the generated validation code due to a 'noautovalidity' tag in vk.xml
404 if (pCreateInfo->sharingMode == VK_SHARING_MODE_CONCURRENT) {
405 // If sharingMode is VK_SHARING_MODE_CONCURRENT, queueFamilyIndexCount must be greater than 1
406 if (pCreateInfo->queueFamilyIndexCount <= 1) {
Mark Lobodzinskib1fd9d12018-03-30 14:26:00 -0600407 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Dave Houlton413a6782018-05-22 13:01:54 -0600408 "VUID-VkBufferCreateInfo-sharingMode-00914",
Mark Lobodzinskid4950072017-08-01 13:02:20 -0600409 "vkCreateBuffer: if pCreateInfo->sharingMode is VK_SHARING_MODE_CONCURRENT, "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -0600410 "pCreateInfo->queueFamilyIndexCount must be greater than 1.");
Mark Lobodzinskid4950072017-08-01 13:02:20 -0600411 }
412
413 // If sharingMode is VK_SHARING_MODE_CONCURRENT, pQueueFamilyIndices must be a pointer to an array of
414 // queueFamilyIndexCount uint32_t values
415 if (pCreateInfo->pQueueFamilyIndices == nullptr) {
Mark Lobodzinskib1fd9d12018-03-30 14:26:00 -0600416 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Dave Houlton413a6782018-05-22 13:01:54 -0600417 "VUID-VkBufferCreateInfo-sharingMode-00913",
Mark Lobodzinskid4950072017-08-01 13:02:20 -0600418 "vkCreateBuffer: if pCreateInfo->sharingMode is VK_SHARING_MODE_CONCURRENT, "
419 "pCreateInfo->pQueueFamilyIndices must be a pointer to an array of "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -0600420 "pCreateInfo->queueFamilyIndexCount uint32_t values.");
Mark Lobodzinskid4950072017-08-01 13:02:20 -0600421 }
422 }
423
424 // If flags contains VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT or VK_BUFFER_CREATE_SPARSE_ALIASED_BIT, it must also contain
425 // VK_BUFFER_CREATE_SPARSE_BINDING_BIT
426 if (((pCreateInfo->flags & (VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT | VK_BUFFER_CREATE_SPARSE_ALIASED_BIT)) != 0) &&
427 ((pCreateInfo->flags & VK_BUFFER_CREATE_SPARSE_BINDING_BIT) != VK_BUFFER_CREATE_SPARSE_BINDING_BIT)) {
Mark Lobodzinskib1fd9d12018-03-30 14:26:00 -0600428 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Dave Houlton413a6782018-05-22 13:01:54 -0600429 "VUID-VkBufferCreateInfo-flags-00918",
Mark Lobodzinskid4950072017-08-01 13:02:20 -0600430 "vkCreateBuffer: if pCreateInfo->flags contains VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT or "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -0600431 "VK_BUFFER_CREATE_SPARSE_ALIASED_BIT, it must also contain VK_BUFFER_CREATE_SPARSE_BINDING_BIT.");
Mark Lobodzinskid4950072017-08-01 13:02:20 -0600432 }
433 }
434
435 return skip;
436}
437
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -0700438bool StatelessValidation::manual_PreCallValidateCreateImage(VkDevice device, const VkImageCreateInfo *pCreateInfo,
Jeff Bolz5c801d12019-10-09 10:38:45 -0500439 const VkAllocationCallbacks *pAllocator, VkImage *pImage) const {
Mark Lobodzinskid4950072017-08-01 13:02:20 -0600440 bool skip = false;
Mark Lobodzinskid4950072017-08-01 13:02:20 -0600441
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -0700442 const LogMiscParams log_misc{VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, VK_NULL_HANDLE, "vkCreateImage"};
Petr Krause5c37652018-01-05 04:05:12 +0100443
Mark Lobodzinskid4950072017-08-01 13:02:20 -0600444 if (pCreateInfo != nullptr) {
Mark Lobodzinskid4950072017-08-01 13:02:20 -0600445 // Validation for parameters excluded from the generated validation code due to a 'noautovalidity' tag in vk.xml
446 if (pCreateInfo->sharingMode == VK_SHARING_MODE_CONCURRENT) {
447 // If sharingMode is VK_SHARING_MODE_CONCURRENT, queueFamilyIndexCount must be greater than 1
448 if (pCreateInfo->queueFamilyIndexCount <= 1) {
Mark Lobodzinskib1fd9d12018-03-30 14:26:00 -0600449 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Dave Houlton413a6782018-05-22 13:01:54 -0600450 "VUID-VkImageCreateInfo-sharingMode-00942",
Mark Lobodzinskid4950072017-08-01 13:02:20 -0600451 "vkCreateImage(): if pCreateInfo->sharingMode is VK_SHARING_MODE_CONCURRENT, "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -0600452 "pCreateInfo->queueFamilyIndexCount must be greater than 1.");
Mark Lobodzinskid4950072017-08-01 13:02:20 -0600453 }
454
455 // If sharingMode is VK_SHARING_MODE_CONCURRENT, pQueueFamilyIndices must be a pointer to an array of
456 // queueFamilyIndexCount uint32_t values
457 if (pCreateInfo->pQueueFamilyIndices == nullptr) {
Mark Lobodzinskib1fd9d12018-03-30 14:26:00 -0600458 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Dave Houlton413a6782018-05-22 13:01:54 -0600459 "VUID-VkImageCreateInfo-sharingMode-00941",
Mark Lobodzinskid4950072017-08-01 13:02:20 -0600460 "vkCreateImage(): if pCreateInfo->sharingMode is VK_SHARING_MODE_CONCURRENT, "
461 "pCreateInfo->pQueueFamilyIndices must be a pointer to an array of "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -0600462 "pCreateInfo->queueFamilyIndexCount uint32_t values.");
Mark Lobodzinskid4950072017-08-01 13:02:20 -0600463 }
464 }
465
Dave Houlton413a6782018-05-22 13:01:54 -0600466 skip |= ValidateGreaterThanZero(pCreateInfo->extent.width, "pCreateInfo->extent.width",
467 "VUID-VkImageCreateInfo-extent-00944", log_misc);
468 skip |= ValidateGreaterThanZero(pCreateInfo->extent.height, "pCreateInfo->extent.height",
469 "VUID-VkImageCreateInfo-extent-00945", log_misc);
470 skip |= ValidateGreaterThanZero(pCreateInfo->extent.depth, "pCreateInfo->extent.depth",
471 "VUID-VkImageCreateInfo-extent-00946", log_misc);
Mark Lobodzinskid4950072017-08-01 13:02:20 -0600472
Dave Houlton413a6782018-05-22 13:01:54 -0600473 skip |= ValidateGreaterThanZero(pCreateInfo->mipLevels, "pCreateInfo->mipLevels", "VUID-VkImageCreateInfo-mipLevels-00947",
474 log_misc);
475 skip |= ValidateGreaterThanZero(pCreateInfo->arrayLayers, "pCreateInfo->arrayLayers",
476 "VUID-VkImageCreateInfo-arrayLayers-00948", log_misc);
Mark Lobodzinskid4950072017-08-01 13:02:20 -0600477
Dave Houlton130c0212018-01-29 13:39:56 -0700478 // InitialLayout must be PREINITIALIZED or UNDEFINED
Dave Houltone19e20d2018-02-02 16:32:41 -0700479 if ((pCreateInfo->initialLayout != VK_IMAGE_LAYOUT_UNDEFINED) &&
480 (pCreateInfo->initialLayout != VK_IMAGE_LAYOUT_PREINITIALIZED)) {
481 skip |= log_msg(
Dave Houlton413a6782018-05-22 13:01:54 -0600482 report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
483 "VUID-VkImageCreateInfo-initialLayout-00993",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -0600484 "vkCreateImage(): initialLayout is %s, must be VK_IMAGE_LAYOUT_UNDEFINED or VK_IMAGE_LAYOUT_PREINITIALIZED.",
485 string_VkImageLayout(pCreateInfo->initialLayout));
Dave Houlton130c0212018-01-29 13:39:56 -0700486 }
487
Mark Lobodzinskid4950072017-08-01 13:02:20 -0600488 // If imageType is VK_IMAGE_TYPE_1D, both extent.height and extent.depth must be 1
Petr Kraus3ac9e812018-03-13 12:31:08 +0100489 if ((pCreateInfo->imageType == VK_IMAGE_TYPE_1D) &&
490 ((pCreateInfo->extent.height != 1) || (pCreateInfo->extent.depth != 1))) {
Mark Lobodzinskib1fd9d12018-03-30 14:26:00 -0600491 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Dave Houlton413a6782018-05-22 13:01:54 -0600492 "VUID-VkImageCreateInfo-imageType-00956",
Dave Houltona9df0ce2018-02-07 10:51:23 -0700493 "vkCreateImage(): if pCreateInfo->imageType is VK_IMAGE_TYPE_1D, both pCreateInfo->extent.height and "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -0600494 "pCreateInfo->extent.depth must be 1.");
Mark Lobodzinskid4950072017-08-01 13:02:20 -0600495 }
496
497 if (pCreateInfo->imageType == VK_IMAGE_TYPE_2D) {
Petr Kraus3f433212018-03-13 12:31:27 +0100498 if (pCreateInfo->flags & VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT) {
499 if (pCreateInfo->extent.width != pCreateInfo->extent.height) {
Mark Lobodzinski487a0d12018-03-30 10:09:03 -0600500 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Dave Houlton413a6782018-05-22 13:01:54 -0600501 VK_NULL_HANDLE, "VUID-VkImageCreateInfo-imageType-00954",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -0600502 "vkCreateImage(): pCreateInfo->flags contains VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT, but "
503 "pCreateInfo->extent.width (=%" PRIu32 ") and pCreateInfo->extent.height (=%" PRIu32
504 ") are not equal.",
505 pCreateInfo->extent.width, pCreateInfo->extent.height);
Petr Kraus3f433212018-03-13 12:31:27 +0100506 }
507
508 if (pCreateInfo->arrayLayers < 6) {
509 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
Dave Houlton413a6782018-05-22 13:01:54 -0600510 VK_NULL_HANDLE, "VUID-VkImageCreateInfo-imageType-00954",
Petr Kraus3f433212018-03-13 12:31:27 +0100511 "vkCreateImage(): pCreateInfo->flags contains VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT, but "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -0600512 "pCreateInfo->arrayLayers (=%" PRIu32 ") is not greater than or equal to 6.",
513 pCreateInfo->arrayLayers);
Petr Kraus3f433212018-03-13 12:31:27 +0100514 }
Mark Lobodzinskid4950072017-08-01 13:02:20 -0600515 }
516
517 if (pCreateInfo->extent.depth != 1) {
Mark Lobodzinski88529492018-04-01 10:38:15 -0600518 skip |=
519 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Dave Houlton413a6782018-05-22 13:01:54 -0600520 "VUID-VkImageCreateInfo-imageType-00957",
Mark Lobodzinski88529492018-04-01 10:38:15 -0600521 "vkCreateImage(): if pCreateInfo->imageType is VK_IMAGE_TYPE_2D, pCreateInfo->extent.depth must be 1.");
Mark Lobodzinskid4950072017-08-01 13:02:20 -0600522 }
523 }
524
Dave Houlton130c0212018-01-29 13:39:56 -0700525 // 3D image may have only 1 layer
526 if ((pCreateInfo->imageType == VK_IMAGE_TYPE_3D) && (pCreateInfo->arrayLayers != 1)) {
Mark Lobodzinski88529492018-04-01 10:38:15 -0600527 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Dave Houlton413a6782018-05-22 13:01:54 -0600528 "VUID-VkImageCreateInfo-imageType-00961",
Mark Lobodzinski88529492018-04-01 10:38:15 -0600529 "vkCreateImage(): if pCreateInfo->imageType is VK_IMAGE_TYPE_3D, pCreateInfo->arrayLayers must be 1.");
Dave Houlton130c0212018-01-29 13:39:56 -0700530 }
531
532 // If multi-sample, validate type, usage, tiling and mip levels.
533 if ((pCreateInfo->samples != VK_SAMPLE_COUNT_1_BIT) &&
534 ((pCreateInfo->imageType != VK_IMAGE_TYPE_2D) || (pCreateInfo->flags & VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT) ||
Shannon McPhersona886c2a2018-10-12 14:38:20 -0600535 (pCreateInfo->mipLevels != 1) || (pCreateInfo->tiling != VK_IMAGE_TILING_OPTIMAL))) {
Mark Lobodzinskib1fd9d12018-03-30 14:26:00 -0600536 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Shannon McPhersona886c2a2018-10-12 14:38:20 -0600537 "VUID-VkImageCreateInfo-samples-02257",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -0600538 "vkCreateImage(): Multi-sample image with incompatible type, usage, tiling, or mips.");
Dave Houlton130c0212018-01-29 13:39:56 -0700539 }
540
541 if (0 != (pCreateInfo->usage & VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT)) {
542 VkImageUsageFlags legal_flags = (VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT |
543 VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT);
544 // At least one of the legal attachment bits must be set
545 if (0 == (pCreateInfo->usage & legal_flags)) {
Mark Lobodzinskib1fd9d12018-03-30 14:26:00 -0600546 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Dave Houlton413a6782018-05-22 13:01:54 -0600547 "VUID-VkImageCreateInfo-usage-00966",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -0600548 "vkCreateImage(): Transient attachment image without a compatible attachment flag set.");
Dave Houlton130c0212018-01-29 13:39:56 -0700549 }
550 // No flags other than the legal attachment bits may be set
551 legal_flags |= VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT;
552 if (0 != (pCreateInfo->usage & ~legal_flags)) {
Mark Lobodzinskib1fd9d12018-03-30 14:26:00 -0600553 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Dave Houlton413a6782018-05-22 13:01:54 -0600554 "VUID-VkImageCreateInfo-usage-00963",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -0600555 "vkCreateImage(): Transient attachment image with incompatible usage flags set.");
Dave Houlton130c0212018-01-29 13:39:56 -0700556 }
557 }
558
Jeff Bolzef40fec2018-09-01 22:04:34 -0500559 // mipLevels must be less than or equal to the number of levels in the complete mipmap chain
Mark Lobodzinskid4950072017-08-01 13:02:20 -0600560 uint32_t maxDim = std::max(std::max(pCreateInfo->extent.width, pCreateInfo->extent.height), pCreateInfo->extent.depth);
Jeff Bolzef40fec2018-09-01 22:04:34 -0500561 // Max mip levels is different for corner-sampled images vs normal images.
Dave Houlton142c4cb2018-10-17 15:04:41 -0600562 uint32_t maxMipLevels = (pCreateInfo->flags & VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV) ? (uint32_t)(ceil(log2(maxDim)))
563 : (uint32_t)(floor(log2(maxDim)) + 1);
Jeff Bolzef40fec2018-09-01 22:04:34 -0500564 if (maxDim > 0 && pCreateInfo->mipLevels > maxMipLevels) {
Dave Houlton413a6782018-05-22 13:01:54 -0600565 skip |=
566 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
567 "VUID-VkImageCreateInfo-mipLevels-00958",
568 "vkCreateImage(): pCreateInfo->mipLevels must be less than or equal to "
569 "floor(log2(max(pCreateInfo->extent.width, pCreateInfo->extent.height, pCreateInfo->extent.depth)))+1.");
Mark Lobodzinskid4950072017-08-01 13:02:20 -0600570 }
571
Mark Lobodzinski69259c52018-09-18 15:14:58 -0600572 if ((pCreateInfo->flags & VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT) && (pCreateInfo->imageType != VK_IMAGE_TYPE_3D)) {
573 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, VK_NULL_HANDLE,
574 "VUID-VkImageCreateInfo-flags-00950",
575 "vkCreateImage(): pCreateInfo->flags contains VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT but "
576 "pCreateInfo->imageType is not VK_IMAGE_TYPE_3D.");
577 }
578
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -0700579 if ((pCreateInfo->flags & VK_IMAGE_CREATE_SPARSE_BINDING_BIT) && (!physical_device_features.sparseBinding)) {
Petr Krausb6f97802018-03-13 12:31:39 +0100580 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, VK_NULL_HANDLE,
Dave Houlton413a6782018-05-22 13:01:54 -0600581 "VUID-VkImageCreateInfo-flags-00969",
Petr Krausb6f97802018-03-13 12:31:39 +0100582 "vkCreateImage(): pCreateInfo->flags contains VK_IMAGE_CREATE_SPARSE_BINDING_BIT, but the "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -0600583 "VkPhysicalDeviceFeatures::sparseBinding feature is disabled.");
Petr Krausb6f97802018-03-13 12:31:39 +0100584 }
585
Mark Lobodzinskid4950072017-08-01 13:02:20 -0600586 // If flags contains VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT or VK_IMAGE_CREATE_SPARSE_ALIASED_BIT, it must also contain
587 // VK_IMAGE_CREATE_SPARSE_BINDING_BIT
588 if (((pCreateInfo->flags & (VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT | VK_IMAGE_CREATE_SPARSE_ALIASED_BIT)) != 0) &&
589 ((pCreateInfo->flags & VK_IMAGE_CREATE_SPARSE_BINDING_BIT) != VK_IMAGE_CREATE_SPARSE_BINDING_BIT)) {
Mark Lobodzinskib1fd9d12018-03-30 14:26:00 -0600590 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Dave Houlton413a6782018-05-22 13:01:54 -0600591 "VUID-VkImageCreateInfo-flags-00987",
Mark Lobodzinskid4950072017-08-01 13:02:20 -0600592 "vkCreateImage: if pCreateInfo->flags contains VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT or "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -0600593 "VK_IMAGE_CREATE_SPARSE_ALIASED_BIT, it must also contain VK_IMAGE_CREATE_SPARSE_BINDING_BIT.");
Mark Lobodzinskid4950072017-08-01 13:02:20 -0600594 }
595
596 // Check for combinations of attributes that are incompatible with having VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT set
597 if ((pCreateInfo->flags & VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT) != 0) {
598 // Linear tiling is unsupported
599 if (VK_IMAGE_TILING_LINEAR == pCreateInfo->tiling) {
Dave Houlton413a6782018-05-22 13:01:54 -0600600 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
601 kVUID_PVError_InvalidUsage,
602 "vkCreateImage: if pCreateInfo->flags contains VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT then image "
603 "tiling of VK_IMAGE_TILING_LINEAR is not supported");
Mark Lobodzinskid4950072017-08-01 13:02:20 -0600604 }
605
606 // Sparse 1D image isn't valid
607 if (VK_IMAGE_TYPE_1D == pCreateInfo->imageType) {
Mark Lobodzinskib1fd9d12018-03-30 14:26:00 -0600608 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Dave Houlton413a6782018-05-22 13:01:54 -0600609 "VUID-VkImageCreateInfo-imageType-00970",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -0600610 "vkCreateImage: cannot specify VK_IMAGE_CREATE_SPARSE_BINDING_BIT for 1D image.");
Mark Lobodzinskid4950072017-08-01 13:02:20 -0600611 }
612
613 // Sparse 2D image when device doesn't support it
Mark Lobodzinskibf599b92018-12-31 12:15:55 -0700614 if ((VK_FALSE == physical_device_features.sparseResidencyImage2D) && (VK_IMAGE_TYPE_2D == pCreateInfo->imageType)) {
Mark Lobodzinskib1fd9d12018-03-30 14:26:00 -0600615 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Dave Houlton413a6782018-05-22 13:01:54 -0600616 "VUID-VkImageCreateInfo-imageType-00971",
Mark Lobodzinskid4950072017-08-01 13:02:20 -0600617 "vkCreateImage: cannot specify VK_IMAGE_CREATE_SPARSE_BINDING_BIT for 2D image if corresponding "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -0600618 "feature is not enabled on the device.");
Mark Lobodzinskid4950072017-08-01 13:02:20 -0600619 }
620
621 // Sparse 3D image when device doesn't support it
Mark Lobodzinskibf599b92018-12-31 12:15:55 -0700622 if ((VK_FALSE == physical_device_features.sparseResidencyImage3D) && (VK_IMAGE_TYPE_3D == pCreateInfo->imageType)) {
Mark Lobodzinskib1fd9d12018-03-30 14:26:00 -0600623 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Dave Houlton413a6782018-05-22 13:01:54 -0600624 "VUID-VkImageCreateInfo-imageType-00972",
Mark Lobodzinskid4950072017-08-01 13:02:20 -0600625 "vkCreateImage: cannot specify VK_IMAGE_CREATE_SPARSE_BINDING_BIT for 3D image if corresponding "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -0600626 "feature is not enabled on the device.");
Mark Lobodzinskid4950072017-08-01 13:02:20 -0600627 }
628
629 // Multi-sample 2D image when device doesn't support it
630 if (VK_IMAGE_TYPE_2D == pCreateInfo->imageType) {
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -0700631 if ((VK_FALSE == physical_device_features.sparseResidency2Samples) &&
Mark Lobodzinskid4950072017-08-01 13:02:20 -0600632 (VK_SAMPLE_COUNT_2_BIT == pCreateInfo->samples)) {
Dave Houltona9df0ce2018-02-07 10:51:23 -0700633 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Dave Houlton413a6782018-05-22 13:01:54 -0600634 "VUID-VkImageCreateInfo-imageType-00973",
Dave Houltona9df0ce2018-02-07 10:51:23 -0700635 "vkCreateImage: cannot specify VK_IMAGE_CREATE_SPARSE_BINDING_BIT for 2-sample image if "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -0600636 "corresponding feature is not enabled on the device.");
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -0700637 } else if ((VK_FALSE == physical_device_features.sparseResidency4Samples) &&
Mark Lobodzinskid4950072017-08-01 13:02:20 -0600638 (VK_SAMPLE_COUNT_4_BIT == pCreateInfo->samples)) {
Dave Houltona9df0ce2018-02-07 10:51:23 -0700639 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Dave Houlton413a6782018-05-22 13:01:54 -0600640 "VUID-VkImageCreateInfo-imageType-00974",
Dave Houltona9df0ce2018-02-07 10:51:23 -0700641 "vkCreateImage: cannot specify VK_IMAGE_CREATE_SPARSE_BINDING_BIT for 4-sample image if "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -0600642 "corresponding feature is not enabled on the device.");
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -0700643 } else if ((VK_FALSE == physical_device_features.sparseResidency8Samples) &&
Mark Lobodzinskid4950072017-08-01 13:02:20 -0600644 (VK_SAMPLE_COUNT_8_BIT == pCreateInfo->samples)) {
Dave Houltona9df0ce2018-02-07 10:51:23 -0700645 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Dave Houlton413a6782018-05-22 13:01:54 -0600646 "VUID-VkImageCreateInfo-imageType-00975",
Dave Houltona9df0ce2018-02-07 10:51:23 -0700647 "vkCreateImage: cannot specify VK_IMAGE_CREATE_SPARSE_BINDING_BIT for 8-sample image if "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -0600648 "corresponding feature is not enabled on the device.");
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -0700649 } else if ((VK_FALSE == physical_device_features.sparseResidency16Samples) &&
Mark Lobodzinskid4950072017-08-01 13:02:20 -0600650 (VK_SAMPLE_COUNT_16_BIT == pCreateInfo->samples)) {
Dave Houltona9df0ce2018-02-07 10:51:23 -0700651 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Dave Houlton413a6782018-05-22 13:01:54 -0600652 "VUID-VkImageCreateInfo-imageType-00976",
Dave Houltona9df0ce2018-02-07 10:51:23 -0700653 "vkCreateImage: cannot specify VK_IMAGE_CREATE_SPARSE_BINDING_BIT for 16-sample image if "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -0600654 "corresponding feature is not enabled on the device.");
Mark Lobodzinskid4950072017-08-01 13:02:20 -0600655 }
656 }
657 }
Jeff Bolzef40fec2018-09-01 22:04:34 -0500658
Jeff Bolz9af91c52018-09-01 21:53:57 -0500659 if (pCreateInfo->usage & VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV) {
660 if (pCreateInfo->imageType != VK_IMAGE_TYPE_2D) {
661 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
662 "VUID-VkImageCreateInfo-imageType-02082",
663 "vkCreateImage: if usage includes VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV, "
664 "imageType must be VK_IMAGE_TYPE_2D.");
665 }
666 if (pCreateInfo->samples != VK_SAMPLE_COUNT_1_BIT) {
667 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
668 "VUID-VkImageCreateInfo-samples-02083",
669 "vkCreateImage: if usage includes VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV, "
670 "samples must be VK_SAMPLE_COUNT_1_BIT.");
671 }
672 if (pCreateInfo->tiling != VK_IMAGE_TILING_OPTIMAL) {
673 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
674 "VUID-VkImageCreateInfo-tiling-02084",
675 "vkCreateImage: if usage includes VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV, "
676 "tiling must be VK_IMAGE_TILING_OPTIMAL.");
677 }
678 }
Jeff Bolzef40fec2018-09-01 22:04:34 -0500679
680 if (pCreateInfo->flags & VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV) {
Dave Houlton142c4cb2018-10-17 15:04:41 -0600681 if (pCreateInfo->imageType != VK_IMAGE_TYPE_2D && pCreateInfo->imageType != VK_IMAGE_TYPE_3D) {
Jeff Bolzef40fec2018-09-01 22:04:34 -0500682 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
683 "VUID-VkImageCreateInfo-flags-02050",
684 "vkCreateImage: If flags contains VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV, "
685 "imageType must be VK_IMAGE_TYPE_2D or VK_IMAGE_TYPE_3D.");
686 }
687
Dave Houlton142c4cb2018-10-17 15:04:41 -0600688 if ((pCreateInfo->flags & VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT) || FormatIsDepthOrStencil(pCreateInfo->format)) {
Jeff Bolzef40fec2018-09-01 22:04:34 -0500689 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
690 "VUID-VkImageCreateInfo-flags-02051",
691 "vkCreateImage: If flags contains VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV, "
692 "it must not also contain VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT and format must "
693 "not be a depth/stencil format.");
694 }
695
Dave Houlton142c4cb2018-10-17 15:04:41 -0600696 if (pCreateInfo->imageType == VK_IMAGE_TYPE_2D && (pCreateInfo->extent.width == 1 || pCreateInfo->extent.height == 1)) {
Jeff Bolzef40fec2018-09-01 22:04:34 -0500697 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
698 "VUID-VkImageCreateInfo-flags-02052",
699 "vkCreateImage: If flags contains VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV and "
700 "imageType is VK_IMAGE_TYPE_2D, extent.width and extent.height must be "
701 "greater than 1.");
Jeff Bolzb8a8dd02018-09-18 02:39:24 -0500702 } else if (pCreateInfo->imageType == VK_IMAGE_TYPE_3D &&
Dave Houlton142c4cb2018-10-17 15:04:41 -0600703 (pCreateInfo->extent.width == 1 || pCreateInfo->extent.height == 1 || pCreateInfo->extent.depth == 1)) {
Jeff Bolzef40fec2018-09-01 22:04:34 -0500704 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
705 "VUID-VkImageCreateInfo-flags-02053",
706 "vkCreateImage: If flags contains VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV and "
707 "imageType is VK_IMAGE_TYPE_3D, extent.width, extent.height, and extent.depth "
708 "must be greater than 1.");
Jeff Bolzef40fec2018-09-01 22:04:34 -0500709 }
710 }
Andrew Fobel3abeb992020-01-20 16:33:22 -0500711
712 const auto image_stencil_struct = lvl_find_in_chain<VkImageStencilUsageCreateInfoEXT>(pCreateInfo->pNext);
713 if (image_stencil_struct != nullptr) {
714 if ((image_stencil_struct->stencilUsage & VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT) != 0) {
715 VkImageUsageFlags legal_flags = (VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT);
716 // No flags other than the legal attachment bits may be set
717 legal_flags |= VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT;
718 if ((image_stencil_struct->stencilUsage & ~legal_flags) != 0) {
719 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, 0,
720 "VUID-VkImageStencilUsageCreateInfo-stencilUsage-02539",
721 "vkCreateImage(): in pNext chain, VkImageStencilUsageCreateInfo::stencilUsage includes "
722 "VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT, it must not include bits other than "
723 "VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT");
724 }
725 }
726
727 if (FormatIsDepthOrStencil(pCreateInfo->format)) {
728 if ((image_stencil_struct->stencilUsage & VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT) != 0) {
729 if (pCreateInfo->extent.width > device_limits.maxFramebufferWidth) {
730 skip |=
731 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, 0,
732 "VUID-VkImageCreateInfo-Format-02536",
733 "vkCreateImage(): Depth-stencil image contains VkImageStencilUsageCreateInfo structure with "
734 "stencilUsage including VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT and image width exceeds device "
735 "maxFramebufferWidth");
736 }
737
738 if (pCreateInfo->extent.height > device_limits.maxFramebufferHeight) {
739 skip |=
740 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, 0,
741 "VUID-VkImageCreateInfo-format-02537",
742 "vkCreateImage(): Depth-stencil image contains VkImageStencilUsageCreateInfo structure with "
743 "stencilUsage including VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT and image height exceeds device "
744 "maxFramebufferHeight");
745 }
746 }
747
748 if (!physical_device_features.shaderStorageImageMultisample &&
749 ((image_stencil_struct->stencilUsage & VK_IMAGE_USAGE_STORAGE_BIT) != 0) &&
750 (pCreateInfo->samples != VK_SAMPLE_COUNT_1_BIT)) {
751 skip |=
752 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, 0,
753 "VUID-VkImageCreateInfo-format-02538",
754 "vkCreateImage(): Depth-stencil image contains VkImageStencilUsageCreateInfo structure with "
755 "stencilUsage including VK_IMAGE_USAGE_STORAGE_BIT and the multisampled storage images feature is "
756 "not enabled, image samples must be VK_SAMPLE_COUNT_1_BIT");
757 }
758
759 if (((pCreateInfo->usage & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) != 0) &&
760 ((image_stencil_struct->stencilUsage & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) == 0)) {
761 skip |= log_msg(
762 report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, 0,
763 "VUID-VkImageCreateInfo-format-02795",
764 "vkCreateImage(): Depth-stencil image in which usage includes VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT "
765 "contains VkImageStencilUsageCreateInfo structure, VkImageStencilUsageCreateInfo::stencilUsage must "
766 "also include VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT");
767 } else if (((pCreateInfo->usage & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) == 0) &&
768 ((image_stencil_struct->stencilUsage & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) != 0)) {
769 skip |= log_msg(
770 report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, 0,
771 "VUID-VkImageCreateInfo-format-02796",
772 "vkCreateImage(): Depth-stencil image in which usage does not include "
773 "VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT "
774 "contains VkImageStencilUsageCreateInfo structure, VkImageStencilUsageCreateInfo::stencilUsage must "
775 "also not include VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT");
776 }
777
778 if (((pCreateInfo->usage & VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT) != 0) &&
779 ((image_stencil_struct->stencilUsage & VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT) == 0)) {
780 skip |= log_msg(
781 report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, 0,
782 "VUID-VkImageCreateInfo-format-02797",
783 "vkCreateImage(): Depth-stencil image in which usage includes VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT "
784 "contains VkImageStencilUsageCreateInfo structure, VkImageStencilUsageCreateInfo::stencilUsage must "
785 "also include VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT");
786 } else if (((pCreateInfo->usage & VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT) == 0) &&
787 ((image_stencil_struct->stencilUsage & VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT) != 0)) {
788 skip |= log_msg(
789 report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, 0,
790 "VUID-VkImageCreateInfo-format-02798",
791 "vkCreateImage(): Depth-stencil image in which usage does not include "
792 "VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT "
793 "contains VkImageStencilUsageCreateInfo structure, VkImageStencilUsageCreateInfo::stencilUsage must "
794 "also not include VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT");
795 }
796 }
797 }
Mark Lobodzinskid4950072017-08-01 13:02:20 -0600798 }
Jeff Bolzef40fec2018-09-01 22:04:34 -0500799
Mark Lobodzinskid4950072017-08-01 13:02:20 -0600800 return skip;
801}
802
Jeff Bolz6d3beaa2019-02-09 21:00:05 -0600803bool StatelessValidation::manual_PreCallValidateViewport(const VkViewport &viewport, const char *fn_name,
804 const ParameterName &parameter_name,
Jeff Bolz5c801d12019-10-09 10:38:45 -0500805 VkDebugReportObjectTypeEXT object_type, uint64_t object = 0) const {
Petr Krausb3fcdb42018-01-09 22:09:09 +0100806 bool skip = false;
Petr Krausb3fcdb42018-01-09 22:09:09 +0100807
808 // Note: for numerical correctness
809 // - float comparisons should expect NaN (comparison always false).
810 // - VkPhysicalDeviceLimits::maxViewportDimensions is uint32_t, not float -> careful.
811
812 const auto f_lte_u32_exact = [](const float v1_f, const uint32_t v2_u32) {
John Zulaufac0876c2018-02-19 10:09:35 -0700813 if (std::isnan(v1_f)) return false;
Petr Krausb3fcdb42018-01-09 22:09:09 +0100814 if (v1_f <= 0.0f) return true;
815
816 float intpart;
817 const float fract = modff(v1_f, &intpart);
818
819 assert(std::numeric_limits<float>::radix == 2);
820 const float u32_max_plus1 = ldexpf(1.0f, 32); // hopefully exact
821 if (intpart >= u32_max_plus1) return false;
822
823 uint32_t v1_u32 = static_cast<uint32_t>(intpart);
824 if (v1_u32 < v2_u32)
825 return true;
826 else if (v1_u32 == v2_u32 && fract == 0.0f)
827 return true;
828 else
829 return false;
830 };
831
832 const auto f_lte_u32_direct = [](const float v1_f, const uint32_t v2_u32) {
833 const float v2_f = static_cast<float>(v2_u32); // not accurate for > radix^digits; and undefined rounding mode
834 return (v1_f <= v2_f);
835 };
836
837 // width
838 bool width_healthy = true;
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -0700839 const auto max_w = device_limits.maxViewportDimensions[0];
Petr Krausb3fcdb42018-01-09 22:09:09 +0100840
841 if (!(viewport.width > 0.0f)) {
842 width_healthy = false;
Dave Houlton413a6782018-05-22 13:01:54 -0600843 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, object_type, object, "VUID-VkViewport-width-01770",
Jeff Bolz6d3beaa2019-02-09 21:00:05 -0600844 "%s: %s.width (=%f) is not greater than 0.0.", fn_name, parameter_name.get_name().c_str(), viewport.width);
Petr Krausb3fcdb42018-01-09 22:09:09 +0100845 } else if (!(f_lte_u32_exact(viewport.width, max_w) || f_lte_u32_direct(viewport.width, max_w))) {
846 width_healthy = false;
Dave Houlton413a6782018-05-22 13:01:54 -0600847 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, object_type, object, "VUID-VkViewport-width-01771",
Mark Lobodzinski88529492018-04-01 10:38:15 -0600848 "%s: %s.width (=%f) exceeds VkPhysicalDeviceLimits::maxViewportDimensions[0] (=%" PRIu32 ").", fn_name,
Jeff Bolz6d3beaa2019-02-09 21:00:05 -0600849 parameter_name.get_name().c_str(), viewport.width, max_w);
Petr Krausb3fcdb42018-01-09 22:09:09 +0100850 } else if (!f_lte_u32_exact(viewport.width, max_w) && f_lte_u32_direct(viewport.width, max_w)) {
Dave Houlton413a6782018-05-22 13:01:54 -0600851 skip |= log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, object_type, object, kVUID_PVError_NONE,
Petr Krausb3fcdb42018-01-09 22:09:09 +0100852 "%s: %s.width (=%f) technically exceeds VkPhysicalDeviceLimits::maxViewportDimensions[0] (=%" PRIu32
Mark Lobodzinski487a0d12018-03-30 10:09:03 -0600853 "), but it is within the static_cast<float>(maxViewportDimensions[0]) limit.",
Jeff Bolz6d3beaa2019-02-09 21:00:05 -0600854 fn_name, parameter_name.get_name().c_str(), viewport.width, max_w);
Petr Krausb3fcdb42018-01-09 22:09:09 +0100855 }
856
857 // height
858 bool height_healthy = true;
Mark Lobodzinskibf599b92018-12-31 12:15:55 -0700859 const bool negative_height_enabled = api_version >= VK_API_VERSION_1_1 || device_extensions.vk_khr_maintenance1 ||
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -0700860 device_extensions.vk_amd_negative_viewport_height;
861 const auto max_h = device_limits.maxViewportDimensions[1];
Petr Krausb3fcdb42018-01-09 22:09:09 +0100862
863 if (!negative_height_enabled && !(viewport.height > 0.0f)) {
864 height_healthy = false;
Dave Houlton413a6782018-05-22 13:01:54 -0600865 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, object_type, object, "VUID-VkViewport-height-01772",
Jeff Bolz6d3beaa2019-02-09 21:00:05 -0600866 "%s: %s.height (=%f) is not greater 0.0.", fn_name, parameter_name.get_name().c_str(), viewport.height);
Petr Krausb3fcdb42018-01-09 22:09:09 +0100867 } else if (!(f_lte_u32_exact(fabsf(viewport.height), max_h) || f_lte_u32_direct(fabsf(viewport.height), max_h))) {
868 height_healthy = false;
869
Dave Houlton413a6782018-05-22 13:01:54 -0600870 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, object_type, object, "VUID-VkViewport-height-01773",
Mark Lobodzinski88529492018-04-01 10:38:15 -0600871 "%s: Absolute value of %s.height (=%f) exceeds VkPhysicalDeviceLimits::maxViewportDimensions[1] (=%" PRIu32
872 ").",
Jeff Bolz6d3beaa2019-02-09 21:00:05 -0600873 fn_name, parameter_name.get_name().c_str(), viewport.height, max_h);
Petr Krausb3fcdb42018-01-09 22:09:09 +0100874 } else if (!f_lte_u32_exact(fabsf(viewport.height), max_h) && f_lte_u32_direct(fabsf(viewport.height), max_h)) {
875 height_healthy = false;
876
877 skip |= log_msg(
Dave Houlton413a6782018-05-22 13:01:54 -0600878 report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, object_type, object, kVUID_PVError_NONE,
Petr Krausb3fcdb42018-01-09 22:09:09 +0100879 "%s: Absolute value of %s.height (=%f) technically exceeds VkPhysicalDeviceLimits::maxViewportDimensions[1] (=%" PRIu32
Mark Lobodzinski487a0d12018-03-30 10:09:03 -0600880 "), but it is within the static_cast<float>(maxViewportDimensions[1]) limit.",
Jeff Bolz6d3beaa2019-02-09 21:00:05 -0600881 fn_name, parameter_name.get_name().c_str(), viewport.height, max_h);
Petr Krausb3fcdb42018-01-09 22:09:09 +0100882 }
883
884 // x
885 bool x_healthy = true;
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -0700886 if (!(viewport.x >= device_limits.viewportBoundsRange[0])) {
Petr Krausb3fcdb42018-01-09 22:09:09 +0100887 x_healthy = false;
Dave Houlton413a6782018-05-22 13:01:54 -0600888 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, object_type, object, "VUID-VkViewport-x-01774",
Jeff Bolz6d3beaa2019-02-09 21:00:05 -0600889 "%s: %s.x (=%f) is less than VkPhysicalDeviceLimits::viewportBoundsRange[0] (=%f).", fn_name,
890 parameter_name.get_name().c_str(), viewport.x, device_limits.viewportBoundsRange[0]);
Petr Krausb3fcdb42018-01-09 22:09:09 +0100891 }
892
893 // x + width
894 if (x_healthy && width_healthy) {
895 const float right_bound = viewport.x + viewport.width;
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -0700896 if (!(right_bound <= device_limits.viewportBoundsRange[1])) {
Jeff Bolz6d3beaa2019-02-09 21:00:05 -0600897 skip |=
898 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, object_type, object, "VUID-VkViewport-x-01232",
899 "%s: %s.x + %s.width (=%f + %f = %f) is greater than VkPhysicalDeviceLimits::viewportBoundsRange[1] (=%f).",
900 fn_name, parameter_name.get_name().c_str(), parameter_name.get_name().c_str(), viewport.x, viewport.width,
901 right_bound, device_limits.viewportBoundsRange[1]);
Petr Krausb3fcdb42018-01-09 22:09:09 +0100902 }
903 }
904
905 // y
906 bool y_healthy = true;
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -0700907 if (!(viewport.y >= device_limits.viewportBoundsRange[0])) {
Petr Krausb3fcdb42018-01-09 22:09:09 +0100908 y_healthy = false;
Dave Houlton413a6782018-05-22 13:01:54 -0600909 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, object_type, object, "VUID-VkViewport-y-01775",
Jeff Bolz6d3beaa2019-02-09 21:00:05 -0600910 "%s: %s.y (=%f) is less than VkPhysicalDeviceLimits::viewportBoundsRange[0] (=%f).", fn_name,
911 parameter_name.get_name().c_str(), viewport.y, device_limits.viewportBoundsRange[0]);
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -0700912 } else if (negative_height_enabled && !(viewport.y <= device_limits.viewportBoundsRange[1])) {
Petr Krausb3fcdb42018-01-09 22:09:09 +0100913 y_healthy = false;
Dave Houlton413a6782018-05-22 13:01:54 -0600914 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, object_type, object, "VUID-VkViewport-y-01776",
Jeff Bolz6d3beaa2019-02-09 21:00:05 -0600915 "%s: %s.y (=%f) exceeds VkPhysicalDeviceLimits::viewportBoundsRange[1] (=%f).", fn_name,
916 parameter_name.get_name().c_str(), viewport.y, device_limits.viewportBoundsRange[1]);
Petr Krausb3fcdb42018-01-09 22:09:09 +0100917 }
918
919 // y + height
920 if (y_healthy && height_healthy) {
921 const float boundary = viewport.y + viewport.height;
922
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -0700923 if (!(boundary <= device_limits.viewportBoundsRange[1])) {
Dave Houlton413a6782018-05-22 13:01:54 -0600924 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, object_type, object, "VUID-VkViewport-y-01233",
Mark Lobodzinski88529492018-04-01 10:38:15 -0600925 "%s: %s.y + %s.height (=%f + %f = %f) exceeds VkPhysicalDeviceLimits::viewportBoundsRange[1] (=%f).",
Jeff Bolz6d3beaa2019-02-09 21:00:05 -0600926 fn_name, parameter_name.get_name().c_str(), parameter_name.get_name().c_str(), viewport.y,
927 viewport.height, boundary, device_limits.viewportBoundsRange[1]);
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -0700928 } else if (negative_height_enabled && !(boundary >= device_limits.viewportBoundsRange[0])) {
Jeff Bolz6d3beaa2019-02-09 21:00:05 -0600929 skip |=
930 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, object_type, object, "VUID-VkViewport-y-01777",
931 "%s: %s.y + %s.height (=%f + %f = %f) is less than VkPhysicalDeviceLimits::viewportBoundsRange[0] (=%f).",
932 fn_name, parameter_name.get_name().c_str(), parameter_name.get_name().c_str(), viewport.y, viewport.height,
933 boundary, device_limits.viewportBoundsRange[0]);
Petr Krausb3fcdb42018-01-09 22:09:09 +0100934 }
935 }
936
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -0700937 if (!device_extensions.vk_ext_depth_range_unrestricted) {
Petr Krausb3fcdb42018-01-09 22:09:09 +0100938 // minDepth
939 if (!(viewport.minDepth >= 0.0) || !(viewport.minDepth <= 1.0)) {
Dave Houlton413a6782018-05-22 13:01:54 -0600940 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, object_type, object, "VUID-VkViewport-minDepth-01234",
Mark Lobodzinski88529492018-04-01 10:38:15 -0600941
Petr Krausb3fcdb42018-01-09 22:09:09 +0100942 "%s: VK_EXT_depth_range_unrestricted extension is not enabled and %s.minDepth (=%f) is not within the "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -0600943 "[0.0, 1.0] range.",
Jeff Bolz6d3beaa2019-02-09 21:00:05 -0600944 fn_name, parameter_name.get_name().c_str(), viewport.minDepth);
Petr Krausb3fcdb42018-01-09 22:09:09 +0100945 }
946
947 // maxDepth
948 if (!(viewport.maxDepth >= 0.0) || !(viewport.maxDepth <= 1.0)) {
Dave Houlton413a6782018-05-22 13:01:54 -0600949 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, object_type, object, "VUID-VkViewport-maxDepth-01235",
Mark Lobodzinski88529492018-04-01 10:38:15 -0600950
Petr Krausb3fcdb42018-01-09 22:09:09 +0100951 "%s: VK_EXT_depth_range_unrestricted extension is not enabled and %s.maxDepth (=%f) is not within the "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -0600952 "[0.0, 1.0] range.",
Jeff Bolz6d3beaa2019-02-09 21:00:05 -0600953 fn_name, parameter_name.get_name().c_str(), viewport.maxDepth);
Petr Krausb3fcdb42018-01-09 22:09:09 +0100954 }
955 }
956
957 return skip;
958}
959
Dave Houlton142c4cb2018-10-17 15:04:41 -0600960struct SampleOrderInfo {
Jeff Bolz9af91c52018-09-01 21:53:57 -0500961 VkShadingRatePaletteEntryNV shadingRate;
962 uint32_t width;
963 uint32_t height;
964};
965
966// All palette entries with more than one pixel per fragment
Dave Houlton142c4cb2018-10-17 15:04:41 -0600967static SampleOrderInfo sampleOrderInfos[] = {
968 {VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_1X2_PIXELS_NV, 1, 2},
969 {VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X1_PIXELS_NV, 2, 1},
970 {VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X2_PIXELS_NV, 2, 2},
971 {VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X2_PIXELS_NV, 4, 2},
972 {VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X4_PIXELS_NV, 2, 4},
973 {VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X4_PIXELS_NV, 4, 4},
Jeff Bolz9af91c52018-09-01 21:53:57 -0500974};
975
Jeff Bolz46c0ea02019-10-09 13:06:29 -0500976bool StatelessValidation::ValidateCoarseSampleOrderCustomNV(const VkCoarseSampleOrderCustomNV *order) const {
Jeff Bolz9af91c52018-09-01 21:53:57 -0500977 bool skip = false;
Jeff Bolz9af91c52018-09-01 21:53:57 -0500978
Jeff Bolz45bf7d62018-09-18 15:39:58 -0500979 SampleOrderInfo *sampleOrderInfo;
Jeff Bolz9af91c52018-09-01 21:53:57 -0500980 uint32_t infoIdx = 0;
Jeff Bolz45bf7d62018-09-18 15:39:58 -0500981 for (sampleOrderInfo = nullptr; infoIdx < ARRAY_SIZE(sampleOrderInfos); ++infoIdx) {
Jeff Bolz9af91c52018-09-01 21:53:57 -0500982 if (sampleOrderInfos[infoIdx].shadingRate == order->shadingRate) {
Jeff Bolzb8a8dd02018-09-18 02:39:24 -0500983 sampleOrderInfo = &sampleOrderInfos[infoIdx];
Jeff Bolz9af91c52018-09-01 21:53:57 -0500984 break;
985 }
986 }
987
Jeff Bolzb8a8dd02018-09-18 02:39:24 -0500988 if (sampleOrderInfo == nullptr) {
Jeff Bolz9af91c52018-09-01 21:53:57 -0500989 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
990 "VUID-VkCoarseSampleOrderCustomNV-shadingRate-02073",
991 "VkCoarseSampleOrderCustomNV shadingRate must be a shading rate "
992 "that generates fragments with more than one pixel.");
993 return skip;
994 }
995
Dave Houlton142c4cb2018-10-17 15:04:41 -0600996 if (order->sampleCount == 0 || (order->sampleCount & (order->sampleCount - 1)) ||
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -0700997 !(order->sampleCount & device_limits.framebufferNoAttachmentsSampleCounts)) {
Jeff Bolz9af91c52018-09-01 21:53:57 -0500998 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
999 "VUID-VkCoarseSampleOrderCustomNV-sampleCount-02074",
Dave Houlton142c4cb2018-10-17 15:04:41 -06001000 "VkCoarseSampleOrderCustomNV sampleCount (=%" PRIu32
1001 ") must "
Jeff Bolz9af91c52018-09-01 21:53:57 -05001002 "correspond to a sample count enumerated in VkSampleCountFlags whose corresponding bit "
1003 "is set in framebufferNoAttachmentsSampleCounts.",
1004 order->sampleCount);
1005 }
1006
Jeff Bolz9af91c52018-09-01 21:53:57 -05001007 if (order->sampleLocationCount != order->sampleCount * sampleOrderInfo->width * sampleOrderInfo->height) {
1008 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
1009 "VUID-VkCoarseSampleOrderCustomNV-sampleLocationCount-02075",
Dave Houlton142c4cb2018-10-17 15:04:41 -06001010 "VkCoarseSampleOrderCustomNV sampleLocationCount (=%" PRIu32
1011 ") must "
1012 "be equal to the product of sampleCount (=%" PRIu32
1013 "), the fragment width for shadingRate "
Jeff Bolz9af91c52018-09-01 21:53:57 -05001014 "(=%" PRIu32 "), and the fragment height for shadingRate (=%" PRIu32 ").",
1015 order->sampleLocationCount, order->sampleCount, sampleOrderInfo->width, sampleOrderInfo->height);
1016 }
1017
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07001018 if (order->sampleLocationCount > phys_dev_ext_props.shading_rate_image_props.shadingRateMaxCoarseSamples) {
Dave Houlton142c4cb2018-10-17 15:04:41 -06001019 skip |= log_msg(
1020 report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
1021 "VUID-VkCoarseSampleOrderCustomNV-sampleLocationCount-02076",
1022 "VkCoarseSampleOrderCustomNV sampleLocationCount (=%" PRIu32
1023 ") must "
1024 "be less than or equal to VkPhysicalDeviceShadingRateImagePropertiesNV shadingRateMaxCoarseSamples (=%" PRIu32 ").",
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07001025 order->sampleLocationCount, phys_dev_ext_props.shading_rate_image_props.shadingRateMaxCoarseSamples);
Jeff Bolz9af91c52018-09-01 21:53:57 -05001026 }
Jeff Bolz9af91c52018-09-01 21:53:57 -05001027
1028 // Accumulate a bitmask tracking which (x,y,sample) tuples are seen. Expect
Jeff Bolzb8a8dd02018-09-18 02:39:24 -05001029 // the first width*height*sampleCount bits to all be set. Note: There is no
1030 // guarantee that 64 bits is enough, but practically it's unlikely for an
1031 // implementation to support more than 32 bits for samplemask.
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07001032 assert(phys_dev_ext_props.shading_rate_image_props.shadingRateMaxCoarseSamples <= 64);
Jeff Bolz9af91c52018-09-01 21:53:57 -05001033 uint64_t sampleLocationsMask = 0;
1034 for (uint32_t i = 0; i < order->sampleLocationCount; ++i) {
1035 const VkCoarseSampleLocationNV *sampleLoc = &order->pSampleLocations[i];
1036 if (sampleLoc->pixelX >= sampleOrderInfo->width) {
1037 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
1038 "VUID-VkCoarseSampleLocationNV-pixelX-02078",
1039 "pixelX must be less than the width (in pixels) of the fragment.");
1040 }
1041 if (sampleLoc->pixelY >= sampleOrderInfo->height) {
1042 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
1043 "VUID-VkCoarseSampleLocationNV-pixelY-02079",
1044 "pixelY must be less than the height (in pixels) of the fragment.");
1045 }
1046 if (sampleLoc->sample >= order->sampleCount) {
1047 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
1048 "VUID-VkCoarseSampleLocationNV-sample-02080",
1049 "sample must be less than the number of coverage samples in each pixel belonging to the fragment.");
1050 }
1051 uint32_t idx = sampleLoc->sample + order->sampleCount * (sampleLoc->pixelX + sampleOrderInfo->width * sampleLoc->pixelY);
1052 sampleLocationsMask |= 1ULL << idx;
1053 }
1054
1055 uint64_t expectedMask = (order->sampleLocationCount == 64) ? ~0ULL : ((1ULL << order->sampleLocationCount) - 1);
1056 if (sampleLocationsMask != expectedMask) {
Dave Houlton142c4cb2018-10-17 15:04:41 -06001057 skip |= log_msg(
1058 report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
1059 "VUID-VkCoarseSampleOrderCustomNV-pSampleLocations-02077",
1060 "The array pSampleLocations must contain exactly one entry for "
1061 "every combination of valid values for pixelX, pixelY, and sample in the structure VkCoarseSampleOrderCustomNV.");
Jeff Bolz9af91c52018-09-01 21:53:57 -05001062 }
1063
1064 return skip;
1065}
1066
Mark Lobodzinskibf599b92018-12-31 12:15:55 -07001067bool StatelessValidation::manual_PreCallValidateCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache,
1068 uint32_t createInfoCount,
1069 const VkGraphicsPipelineCreateInfo *pCreateInfos,
1070 const VkAllocationCallbacks *pAllocator,
Jeff Bolz5c801d12019-10-09 10:38:45 -05001071 VkPipeline *pPipelines) const {
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001072 bool skip = false;
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001073
1074 if (pCreateInfos != nullptr) {
1075 for (uint32_t i = 0; i < createInfoCount; ++i) {
Petr Kraus299ba622017-11-24 03:09:03 +01001076 bool has_dynamic_viewport = false;
1077 bool has_dynamic_scissor = false;
1078 bool has_dynamic_line_width = false;
Jeremy Kniager71fd5f02017-11-15 13:27:03 -07001079 bool has_dynamic_viewport_w_scaling_nv = false;
1080 bool has_dynamic_discard_rectangle_ext = false;
1081 bool has_dynamic_sample_locations_ext = false;
Jeff Bolz3e71f782018-08-29 23:15:45 -05001082 bool has_dynamic_exclusive_scissor_nv = false;
Jeff Bolz9af91c52018-09-01 21:53:57 -05001083 bool has_dynamic_shading_rate_palette_nv = false;
Jeff Bolz8125a8b2019-08-16 16:29:45 -05001084 bool has_dynamic_line_stipple = false;
Petr Kraus299ba622017-11-24 03:09:03 +01001085 if (pCreateInfos[i].pDynamicState != nullptr) {
1086 const auto &dynamic_state_info = *pCreateInfos[i].pDynamicState;
1087 for (uint32_t state_index = 0; state_index < dynamic_state_info.dynamicStateCount; ++state_index) {
1088 const auto &dynamic_state = dynamic_state_info.pDynamicStates[state_index];
1089 if (dynamic_state == VK_DYNAMIC_STATE_VIEWPORT) has_dynamic_viewport = true;
1090 if (dynamic_state == VK_DYNAMIC_STATE_SCISSOR) has_dynamic_scissor = true;
1091 if (dynamic_state == VK_DYNAMIC_STATE_LINE_WIDTH) has_dynamic_line_width = true;
Jeremy Kniager71fd5f02017-11-15 13:27:03 -07001092 if (dynamic_state == VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV) has_dynamic_viewport_w_scaling_nv = true;
1093 if (dynamic_state == VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT) has_dynamic_discard_rectangle_ext = true;
1094 if (dynamic_state == VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT) has_dynamic_sample_locations_ext = true;
Jeff Bolz3e71f782018-08-29 23:15:45 -05001095 if (dynamic_state == VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV) has_dynamic_exclusive_scissor_nv = true;
Dave Houlton142c4cb2018-10-17 15:04:41 -06001096 if (dynamic_state == VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV)
1097 has_dynamic_shading_rate_palette_nv = true;
Jeff Bolz8125a8b2019-08-16 16:29:45 -05001098 if (dynamic_state == VK_DYNAMIC_STATE_LINE_STIPPLE_EXT) has_dynamic_line_stipple = true;
Petr Kraus299ba622017-11-24 03:09:03 +01001099 }
1100 }
1101
Peter Chen85366392019-05-14 15:20:11 -04001102 auto feedback_struct = lvl_find_in_chain<VkPipelineCreationFeedbackCreateInfoEXT>(pCreateInfos[i].pNext);
1103 if ((feedback_struct != nullptr) &&
1104 (feedback_struct->pipelineStageCreationFeedbackCount != pCreateInfos[i].stageCount)) {
1105 skip |=
1106 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, VK_NULL_HANDLE,
1107 "VUID-VkPipelineCreationFeedbackCreateInfoEXT-pipelineStageCreationFeedbackCount-02668",
1108 "vkCreateGraphicsPipelines(): in pCreateInfo[%" PRIu32
1109 "], VkPipelineCreationFeedbackEXT::pipelineStageCreationFeedbackCount"
1110 "(=%" PRIu32 ") must equal VkGraphicsPipelineCreateInfo::stageCount(=%" PRIu32 ").",
1111 i, feedback_struct->pipelineStageCreationFeedbackCount, pCreateInfos[i].stageCount);
1112 }
1113
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001114 // Validation for parameters excluded from the generated validation code due to a 'noautovalidity' tag in vk.xml
Mark Lobodzinski876d5b52019-08-06 16:32:27 -06001115
1116 // Collect active stages
1117 uint32_t active_shaders = 0;
1118 for (uint32_t stages = 0; stages < pCreateInfos[i].stageCount; stages++) {
Spencer Fricked84808f2020-01-20 06:08:01 -08001119 active_shaders |= pCreateInfos[i].pStages[stages].stage;
Mark Lobodzinski876d5b52019-08-06 16:32:27 -06001120 }
1121
1122 if ((active_shaders & VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT) &&
1123 (active_shaders & VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT) && (pCreateInfos[i].pTessellationState != nullptr)) {
1124 skip |= validate_struct_type("vkCreateGraphicsPipelines", "pCreateInfos[i].pTessellationState",
1125 "VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO",
1126 pCreateInfos[i].pTessellationState,
1127 VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO, false, kVUIDUndefined,
1128 "VUID-VkPipelineTessellationStateCreateInfo-sType-sType");
1129
1130 const VkStructureType allowed_structs_VkPipelineTessellationStateCreateInfo[] = {
1131 VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO};
1132
1133 skip |= validate_struct_pnext("vkCreateGraphicsPipelines", "pCreateInfos[i].pTessellationState->pNext",
1134 "VkPipelineTessellationDomainOriginStateCreateInfo",
1135 pCreateInfos[i].pTessellationState->pNext,
1136 ARRAY_SIZE(allowed_structs_VkPipelineTessellationStateCreateInfo),
1137 allowed_structs_VkPipelineTessellationStateCreateInfo, GeneratedVulkanHeaderVersion,
1138 "VUID-VkPipelineTessellationStateCreateInfo-pNext-pNext");
1139
1140 skip |= validate_reserved_flags("vkCreateGraphicsPipelines", "pCreateInfos[i].pTessellationState->flags",
1141 pCreateInfos[i].pTessellationState->flags,
1142 "VUID-VkPipelineTessellationStateCreateInfo-flags-zerobitmask");
1143 }
1144
1145 if (!(active_shaders & VK_SHADER_STAGE_MESH_BIT_NV) && (pCreateInfos[i].pInputAssemblyState != nullptr)) {
1146 skip |= validate_struct_type("vkCreateGraphicsPipelines", "pCreateInfos[i].pInputAssemblyState",
1147 "VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO",
1148 pCreateInfos[i].pInputAssemblyState,
1149 VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, false, kVUIDUndefined,
1150 "VUID-VkPipelineInputAssemblyStateCreateInfo-sType-sType");
1151
1152 skip |= validate_struct_pnext("vkCreateGraphicsPipelines", "pCreateInfos[i].pInputAssemblyState->pNext", NULL,
1153 pCreateInfos[i].pInputAssemblyState->pNext, 0, NULL, GeneratedVulkanHeaderVersion,
1154 "VUID-VkPipelineInputAssemblyStateCreateInfo-pNext-pNext");
1155
1156 skip |= validate_reserved_flags("vkCreateGraphicsPipelines", "pCreateInfos[i].pInputAssemblyState->flags",
1157 pCreateInfos[i].pInputAssemblyState->flags,
1158 "VUID-VkPipelineInputAssemblyStateCreateInfo-flags-zerobitmask");
1159
1160 skip |= validate_ranged_enum("vkCreateGraphicsPipelines", "pCreateInfos[i].pInputAssemblyState->topology",
1161 "VkPrimitiveTopology", AllVkPrimitiveTopologyEnums,
1162 pCreateInfos[i].pInputAssemblyState->topology,
1163 "VUID-VkPipelineInputAssemblyStateCreateInfo-topology-parameter");
1164
1165 skip |= validate_bool32("vkCreateGraphicsPipelines", "pCreateInfos[i].pInputAssemblyState->primitiveRestartEnable",
1166 pCreateInfos[i].pInputAssemblyState->primitiveRestartEnable);
1167 }
1168
1169 if (!(active_shaders & VK_SHADER_STAGE_MESH_BIT_NV) && (pCreateInfos[i].pVertexInputState != nullptr)) {
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001170 auto const &vertex_input_state = pCreateInfos[i].pVertexInputState;
Peter Kohautc7d9d392018-07-15 00:34:07 +02001171
Mark Lobodzinski876d5b52019-08-06 16:32:27 -06001172 if (pCreateInfos[i].pVertexInputState->flags != 0) {
1173 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
1174 "VUID-VkPipelineVertexInputStateCreateInfo-flags-zerobitmask",
1175 "vkCreateGraphicsPipelines: pararameter "
1176 "pCreateInfos[%d].pVertexInputState->flags (%u) is reserved and must be zero.",
1177 i, vertex_input_state->flags);
1178 }
1179
1180 const VkStructureType allowed_structs_VkPipelineVertexInputStateCreateInfo[] = {
1181 VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT};
1182 skip |= validate_struct_pnext("vkCreateGraphicsPipelines", "pCreateInfos[i].pVertexInputState->pNext",
1183 "VkPipelineVertexInputDivisorStateCreateInfoEXT",
1184 pCreateInfos[i].pVertexInputState->pNext, 1,
1185 allowed_structs_VkPipelineVertexInputStateCreateInfo, GeneratedVulkanHeaderVersion,
1186 "VUID-VkPipelineVertexInputStateCreateInfo-pNext-pNext");
1187 skip |= validate_struct_type("vkCreateGraphicsPipelines", "pCreateInfos[i].pVertexInputState",
1188 "VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO", vertex_input_state,
Shannon McPherson3cc90bc2019-08-13 11:28:22 -06001189 VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, false, kVUIDUndefined,
Mark Lobodzinski876d5b52019-08-06 16:32:27 -06001190 "VUID-VkPipelineVertexInputStateCreateInfo-sType-sType");
1191 skip |=
1192 validate_array("vkCreateGraphicsPipelines", "pCreateInfos[i].pVertexInputState->vertexBindingDescriptionCount",
1193 "pCreateInfos[i].pVertexInputState->pVertexBindingDescriptions",
1194 pCreateInfos[i].pVertexInputState->vertexBindingDescriptionCount,
1195 &pCreateInfos[i].pVertexInputState->pVertexBindingDescriptions, false, true, kVUIDUndefined,
1196 "VUID-VkPipelineVertexInputStateCreateInfo-pVertexBindingDescriptions-parameter");
1197
1198 skip |= validate_array(
1199 "vkCreateGraphicsPipelines", "pCreateInfos[i].pVertexInputState->vertexAttributeDescriptionCount",
1200 "pCreateInfos[i]->pVertexAttributeDescriptions", vertex_input_state->vertexAttributeDescriptionCount,
1201 &vertex_input_state->pVertexAttributeDescriptions, false, true, kVUIDUndefined,
1202 "VUID-VkPipelineVertexInputStateCreateInfo-pVertexAttributeDescriptions-parameter");
1203
1204 if (pCreateInfos[i].pVertexInputState->pVertexBindingDescriptions != NULL) {
1205 for (uint32_t vertexBindingDescriptionIndex = 0;
1206 vertexBindingDescriptionIndex < pCreateInfos[i].pVertexInputState->vertexBindingDescriptionCount;
1207 ++vertexBindingDescriptionIndex) {
1208 skip |= validate_ranged_enum(
1209 "vkCreateGraphicsPipelines",
1210 "pCreateInfos[i].pVertexInputState->pVertexBindingDescriptions[j].inputRate", "VkVertexInputRate",
1211 AllVkVertexInputRateEnums,
1212 pCreateInfos[i].pVertexInputState->pVertexBindingDescriptions[vertexBindingDescriptionIndex].inputRate,
1213 "VUID-VkVertexInputBindingDescription-inputRate-parameter");
1214 }
1215 }
1216
1217 if (pCreateInfos[i].pVertexInputState->pVertexAttributeDescriptions != NULL) {
1218 for (uint32_t vertexAttributeDescriptionIndex = 0;
1219 vertexAttributeDescriptionIndex < pCreateInfos[i].pVertexInputState->vertexAttributeDescriptionCount;
1220 ++vertexAttributeDescriptionIndex) {
1221 skip |= validate_ranged_enum(
1222 "vkCreateGraphicsPipelines",
1223 "pCreateInfos[i].pVertexInputState->pVertexAttributeDescriptions[i].format", "VkFormat",
1224 AllVkFormatEnums,
1225 pCreateInfos[i].pVertexInputState->pVertexAttributeDescriptions[vertexAttributeDescriptionIndex].format,
1226 "VUID-VkVertexInputAttributeDescription-format-parameter");
1227 }
1228 }
1229
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07001230 if (vertex_input_state->vertexBindingDescriptionCount > device_limits.maxVertexInputBindings) {
Peter Kohautc7d9d392018-07-15 00:34:07 +02001231 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
1232 "VUID-VkPipelineVertexInputStateCreateInfo-vertexBindingDescriptionCount-00613",
1233 "vkCreateGraphicsPipelines: pararameter "
1234 "pCreateInfo[%d].pVertexInputState->vertexBindingDescriptionCount (%u) is "
1235 "greater than VkPhysicalDeviceLimits::maxVertexInputBindings (%u).",
Mark Lobodzinskibf599b92018-12-31 12:15:55 -07001236 i, vertex_input_state->vertexBindingDescriptionCount, device_limits.maxVertexInputBindings);
Peter Kohautc7d9d392018-07-15 00:34:07 +02001237 }
1238
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07001239 if (vertex_input_state->vertexAttributeDescriptionCount > device_limits.maxVertexInputAttributes) {
Peter Kohautc7d9d392018-07-15 00:34:07 +02001240 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
1241 "VUID-VkPipelineVertexInputStateCreateInfo-vertexAttributeDescriptionCount-00614",
1242 "vkCreateGraphicsPipelines: pararameter "
Peter Kohaut9e92c5c2018-07-17 10:32:17 +02001243 "pCreateInfo[%d].pVertexInputState->vertexAttributeDescriptionCount (%u) is "
Peter Kohautc7d9d392018-07-15 00:34:07 +02001244 "greater than VkPhysicalDeviceLimits::maxVertexInputAttributes (%u).",
Mark Lobodzinskib41e1652019-04-18 08:30:27 -06001245 i, vertex_input_state->vertexAttributeDescriptionCount, device_limits.maxVertexInputAttributes);
Peter Kohautc7d9d392018-07-15 00:34:07 +02001246 }
1247
1248 std::unordered_set<uint32_t> vertex_bindings(vertex_input_state->vertexBindingDescriptionCount);
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001249 for (uint32_t d = 0; d < vertex_input_state->vertexBindingDescriptionCount; ++d) {
1250 auto const &vertex_bind_desc = vertex_input_state->pVertexBindingDescriptions[d];
Peter Kohautc7d9d392018-07-15 00:34:07 +02001251 auto const &binding_it = vertex_bindings.find(vertex_bind_desc.binding);
1252 if (binding_it != vertex_bindings.cend()) {
1253 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
1254 "VUID-VkPipelineVertexInputStateCreateInfo-pVertexBindingDescriptions-00616",
1255 "vkCreateGraphicsPipelines: parameter "
1256 "pCreateInfo[%d].pVertexInputState->pVertexBindingDescription[%d].binding "
1257 "(%" PRIu32 ") is not distinct.",
1258 i, d, vertex_bind_desc.binding);
1259 }
1260 vertex_bindings.insert(vertex_bind_desc.binding);
1261
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07001262 if (vertex_bind_desc.binding >= device_limits.maxVertexInputBindings) {
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001263 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Dave Houlton413a6782018-05-22 13:01:54 -06001264 "VUID-VkVertexInputBindingDescription-binding-00618",
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001265 "vkCreateGraphicsPipelines: parameter "
1266 "pCreateInfos[%u].pVertexInputState->pVertexBindingDescriptions[%u].binding (%u) is "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06001267 "greater than or equal to VkPhysicalDeviceLimits::maxVertexInputBindings (%u).",
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07001268 i, d, vertex_bind_desc.binding, device_limits.maxVertexInputBindings);
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001269 }
1270
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07001271 if (vertex_bind_desc.stride > device_limits.maxVertexInputBindingStride) {
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001272 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Dave Houlton413a6782018-05-22 13:01:54 -06001273 "VUID-VkVertexInputBindingDescription-stride-00619",
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001274 "vkCreateGraphicsPipelines: parameter "
1275 "pCreateInfos[%u].pVertexInputState->pVertexBindingDescriptions[%u].stride (%u) is greater "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06001276 "than VkPhysicalDeviceLimits::maxVertexInputBindingStride (%u).",
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07001277 i, d, vertex_bind_desc.stride, device_limits.maxVertexInputBindingStride);
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001278 }
1279 }
1280
Peter Kohautc7d9d392018-07-15 00:34:07 +02001281 std::unordered_set<uint32_t> attribute_locations(vertex_input_state->vertexAttributeDescriptionCount);
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001282 for (uint32_t d = 0; d < vertex_input_state->vertexAttributeDescriptionCount; ++d) {
1283 auto const &vertex_attrib_desc = vertex_input_state->pVertexAttributeDescriptions[d];
Peter Kohautc7d9d392018-07-15 00:34:07 +02001284 auto const &location_it = attribute_locations.find(vertex_attrib_desc.location);
1285 if (location_it != attribute_locations.cend()) {
1286 skip |= log_msg(
1287 report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
1288 "VUID-VkPipelineVertexInputStateCreateInfo-pVertexAttributeDescriptions-00617",
1289 "vkCreateGraphicsPipelines: parameter "
1290 "pCreateInfo[%d].pVertexInputState->vertexAttributeDescriptions[%d].location (%u) is not distinct.",
1291 i, d, vertex_attrib_desc.location);
1292 }
1293 attribute_locations.insert(vertex_attrib_desc.location);
1294
1295 auto const &binding_it = vertex_bindings.find(vertex_attrib_desc.binding);
1296 if (binding_it == vertex_bindings.cend()) {
1297 skip |= log_msg(
1298 report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
1299 "VUID-VkPipelineVertexInputStateCreateInfo-binding-00615",
1300 "vkCreateGraphicsPipelines: parameter "
1301 " pCreateInfo[%d].pVertexInputState->vertexAttributeDescriptions[%d].binding (%u) does not exist "
1302 "in any pCreateInfo[%d].pVertexInputState->pVertexBindingDescription.",
1303 i, d, vertex_attrib_desc.binding, i);
1304 }
1305
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07001306 if (vertex_attrib_desc.location >= device_limits.maxVertexInputAttributes) {
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001307 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Dave Houlton413a6782018-05-22 13:01:54 -06001308 "VUID-VkVertexInputAttributeDescription-location-00620",
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001309 "vkCreateGraphicsPipelines: parameter "
1310 "pCreateInfos[%u].pVertexInputState->pVertexAttributeDescriptions[%u].location (%u) is "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06001311 "greater than or equal to VkPhysicalDeviceLimits::maxVertexInputAttributes (%u).",
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07001312 i, d, vertex_attrib_desc.location, device_limits.maxVertexInputAttributes);
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001313 }
1314
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07001315 if (vertex_attrib_desc.binding >= device_limits.maxVertexInputBindings) {
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001316 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Dave Houlton413a6782018-05-22 13:01:54 -06001317 "VUID-VkVertexInputAttributeDescription-binding-00621",
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001318 "vkCreateGraphicsPipelines: parameter "
1319 "pCreateInfos[%u].pVertexInputState->pVertexAttributeDescriptions[%u].binding (%u) is "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06001320 "greater than or equal to VkPhysicalDeviceLimits::maxVertexInputBindings (%u).",
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07001321 i, d, vertex_attrib_desc.binding, device_limits.maxVertexInputBindings);
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001322 }
1323
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07001324 if (vertex_attrib_desc.offset > device_limits.maxVertexInputAttributeOffset) {
Mark Lobodzinski88529492018-04-01 10:38:15 -06001325 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Dave Houlton413a6782018-05-22 13:01:54 -06001326 "VUID-VkVertexInputAttributeDescription-offset-00622",
Mark Lobodzinski88529492018-04-01 10:38:15 -06001327 "vkCreateGraphicsPipelines: parameter "
1328 "pCreateInfos[%u].pVertexInputState->pVertexAttributeDescriptions[%u].offset (%u) is "
1329 "greater than VkPhysicalDeviceLimits::maxVertexInputAttributeOffset (%u).",
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07001330 i, d, vertex_attrib_desc.offset, device_limits.maxVertexInputAttributeOffset);
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001331 }
1332 }
1333 }
1334
1335 if (pCreateInfos[i].pStages != nullptr) {
1336 bool has_control = false;
1337 bool has_eval = false;
1338
1339 for (uint32_t stage_index = 0; stage_index < pCreateInfos[i].stageCount; ++stage_index) {
1340 if (pCreateInfos[i].pStages[stage_index].stage == VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT) {
1341 has_control = true;
1342 } else if (pCreateInfos[i].pStages[stage_index].stage == VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT) {
1343 has_eval = true;
1344 }
1345 }
1346
1347 // pTessellationState is ignored without both tessellation control and tessellation evaluation shaders stages
1348 if (has_control && has_eval) {
1349 if (pCreateInfos[i].pTessellationState == nullptr) {
1350 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Dave Houlton413a6782018-05-22 13:01:54 -06001351 "VUID-VkGraphicsPipelineCreateInfo-pStages-00731",
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001352 "vkCreateGraphicsPipelines: if pCreateInfos[%d].pStages includes a tessellation control "
1353 "shader stage and a tessellation evaluation shader stage, "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06001354 "pCreateInfos[%d].pTessellationState must not be NULL.",
1355 i, i);
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001356 } else {
Lockee04009e2019-03-08 12:22:35 -07001357 const VkStructureType allowed_type =
1358 VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO;
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001359 skip |= validate_struct_pnext(
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07001360 "vkCreateGraphicsPipelines",
Lockee04009e2019-03-08 12:22:35 -07001361 ParameterName("pCreateInfos[%i].pTessellationState->pNext", ParameterName::IndexVector{i}),
1362 "VkPipelineTessellationDomainOriginStateCreateInfo", pCreateInfos[i].pTessellationState->pNext, 1,
1363 &allowed_type, GeneratedVulkanHeaderVersion, "VUID-VkGraphicsPipelineCreateInfo-pNext-pNext");
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001364
1365 skip |= validate_reserved_flags(
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07001366 "vkCreateGraphicsPipelines",
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001367 ParameterName("pCreateInfos[%i].pTessellationState->flags", ParameterName::IndexVector{i}),
Dave Houlton413a6782018-05-22 13:01:54 -06001368 pCreateInfos[i].pTessellationState->flags,
1369 "VUID-VkPipelineTessellationStateCreateInfo-flags-zerobitmask");
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001370
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001371 if (pCreateInfos[i].pTessellationState->patchControlPoints == 0 ||
Mark Lobodzinskibf599b92018-12-31 12:15:55 -07001372 pCreateInfos[i].pTessellationState->patchControlPoints > device_limits.maxTessellationPatchSize) {
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001373 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Dave Houlton413a6782018-05-22 13:01:54 -06001374 "VUID-VkPipelineTessellationStateCreateInfo-patchControlPoints-01214",
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001375 "vkCreateGraphicsPipelines: invalid parameter "
1376 "pCreateInfos[%d].pTessellationState->patchControlPoints value %u. patchControlPoints "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06001377 "should be >0 and <=%u.",
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001378 i, pCreateInfos[i].pTessellationState->patchControlPoints,
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07001379 device_limits.maxTessellationPatchSize);
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001380 }
1381 }
1382 }
1383 }
1384
1385 // pViewportState, pMultisampleState, pDepthStencilState, and pColorBlendState ignored when rasterization is disabled
1386 if ((pCreateInfos[i].pRasterizationState != nullptr) &&
1387 (pCreateInfos[i].pRasterizationState->rasterizerDiscardEnable == VK_FALSE)) {
1388 if (pCreateInfos[i].pViewportState == nullptr) {
Petr Krausa6103552017-11-16 21:21:58 +01001389 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT,
Dave Houlton413a6782018-05-22 13:01:54 -06001390 VK_NULL_HANDLE, "VUID-VkGraphicsPipelineCreateInfo-rasterizerDiscardEnable-00750",
Petr Krausa6103552017-11-16 21:21:58 +01001391 "vkCreateGraphicsPipelines: Rasterization is enabled (pCreateInfos[%" PRIu32
1392 "].pRasterizationState->rasterizerDiscardEnable is VK_FALSE), but pCreateInfos[%" PRIu32
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06001393 "].pViewportState (=NULL) is not a valid pointer.",
1394 i, i);
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001395 } else {
Petr Krausa6103552017-11-16 21:21:58 +01001396 const auto &viewport_state = *pCreateInfos[i].pViewportState;
1397
1398 if (viewport_state.sType != VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO) {
1399 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT,
Dave Houlton413a6782018-05-22 13:01:54 -06001400 VK_NULL_HANDLE, "VUID-VkPipelineViewportStateCreateInfo-sType-sType",
Petr Krausa6103552017-11-16 21:21:58 +01001401 "vkCreateGraphicsPipelines: pCreateInfos[%" PRIu32
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06001402 "].pViewportState->sType is not VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO.",
1403 i);
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001404 }
1405
Petr Krausa6103552017-11-16 21:21:58 +01001406 const VkStructureType allowed_structs_VkPipelineViewportStateCreateInfo[] = {
1407 VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV,
Jeff Bolz3e71f782018-08-29 23:15:45 -05001408 VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV,
1409 VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV,
Jeff Bolz9af91c52018-09-01 21:53:57 -05001410 VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV,
1411 VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV,
Jeff Bolz3e71f782018-08-29 23:15:45 -05001412 };
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001413 skip |= validate_struct_pnext(
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07001414 "vkCreateGraphicsPipelines",
Petr Krausa6103552017-11-16 21:21:58 +01001415 ParameterName("pCreateInfos[%i].pViewportState->pNext", ParameterName::IndexVector{i}),
Jeff Bolz9af91c52018-09-01 21:53:57 -05001416 "VkPipelineViewportSwizzleStateCreateInfoNV, VkPipelineViewportWScalingStateCreateInfoNV, "
Jeff Bolzb8a8dd02018-09-18 02:39:24 -05001417 "VkPipelineViewportExclusiveScissorStateCreateInfoNV, VkPipelineViewportShadingRateImageStateCreateInfoNV, "
1418 "VkPipelineViewportCoarseSampleOrderStateCreateInfoNV",
Petr Krausa6103552017-11-16 21:21:58 +01001419 viewport_state.pNext, ARRAY_SIZE(allowed_structs_VkPipelineViewportStateCreateInfo),
Dave Houlton413a6782018-05-22 13:01:54 -06001420 allowed_structs_VkPipelineViewportStateCreateInfo, 65,
1421 "VUID-VkPipelineViewportStateCreateInfo-pNext-pNext");
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001422
1423 skip |= validate_reserved_flags(
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07001424 "vkCreateGraphicsPipelines",
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001425 ParameterName("pCreateInfos[%i].pViewportState->flags", ParameterName::IndexVector{i}),
Dave Houlton413a6782018-05-22 13:01:54 -06001426 viewport_state.flags, "VUID-VkPipelineViewportStateCreateInfo-flags-zerobitmask");
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001427
Dave Houlton142c4cb2018-10-17 15:04:41 -06001428 auto exclusive_scissor_struct = lvl_find_in_chain<VkPipelineViewportExclusiveScissorStateCreateInfoNV>(
1429 pCreateInfos[i].pViewportState->pNext);
1430 auto shading_rate_image_struct = lvl_find_in_chain<VkPipelineViewportShadingRateImageStateCreateInfoNV>(
1431 pCreateInfos[i].pViewportState->pNext);
1432 auto coarse_sample_order_struct = lvl_find_in_chain<VkPipelineViewportCoarseSampleOrderStateCreateInfoNV>(
1433 pCreateInfos[i].pViewportState->pNext);
Chris Mayer328d8212018-12-11 14:16:18 +01001434 const auto vp_swizzle_struct =
1435 lvl_find_in_chain<VkPipelineViewportSwizzleStateCreateInfoNV>(pCreateInfos[i].pViewportState->pNext);
Chris Mayer9ded5eb2019-09-19 16:33:26 +02001436 const auto vp_w_scaling_struct =
1437 lvl_find_in_chain<VkPipelineViewportWScalingStateCreateInfoNV>(pCreateInfos[i].pViewportState->pNext);
Jeff Bolz3e71f782018-08-29 23:15:45 -05001438
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07001439 if (!physical_device_features.multiViewport) {
Petr Krausa6103552017-11-16 21:21:58 +01001440 if (viewport_state.viewportCount != 1) {
1441 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT,
Dave Houlton413a6782018-05-22 13:01:54 -06001442 VK_NULL_HANDLE, "VUID-VkPipelineViewportStateCreateInfo-viewportCount-01216",
Petr Krausa6103552017-11-16 21:21:58 +01001443 "vkCreateGraphicsPipelines: The VkPhysicalDeviceFeatures::multiViewport feature is "
1444 "disabled, but pCreateInfos[%" PRIu32 "].pViewportState->viewportCount (=%" PRIu32
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06001445 ") is not 1.",
1446 i, viewport_state.viewportCount);
Petr Krausa6103552017-11-16 21:21:58 +01001447 }
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001448
Petr Krausa6103552017-11-16 21:21:58 +01001449 if (viewport_state.scissorCount != 1) {
1450 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT,
Dave Houlton413a6782018-05-22 13:01:54 -06001451 VK_NULL_HANDLE, "VUID-VkPipelineViewportStateCreateInfo-scissorCount-01217",
Petr Krausa6103552017-11-16 21:21:58 +01001452 "vkCreateGraphicsPipelines: The VkPhysicalDeviceFeatures::multiViewport feature is "
1453 "disabled, but pCreateInfos[%" PRIu32 "].pViewportState->scissorCount (=%" PRIu32
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06001454 ") is not 1.",
1455 i, viewport_state.scissorCount);
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001456 }
Jeff Bolz3e71f782018-08-29 23:15:45 -05001457
Dave Houlton142c4cb2018-10-17 15:04:41 -06001458 if (exclusive_scissor_struct && (exclusive_scissor_struct->exclusiveScissorCount != 0 &&
1459 exclusive_scissor_struct->exclusiveScissorCount != 1)) {
1460 skip |=
1461 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT,
1462 VK_NULL_HANDLE,
1463 "VUID-VkPipelineViewportExclusiveScissorStateCreateInfoNV-exclusiveScissorCount-02027",
1464 "vkCreateGraphicsPipelines: The VkPhysicalDeviceFeatures::multiViewport feature is "
1465 "disabled, but pCreateInfos[%" PRIu32
1466 "] VkPipelineViewportExclusiveScissorStateCreateInfoNV::exclusiveScissorCount (=%" PRIu32
1467 ") is not 1.",
1468 i, exclusive_scissor_struct->exclusiveScissorCount);
Jeff Bolz3e71f782018-08-29 23:15:45 -05001469 }
1470
Jeff Bolz9af91c52018-09-01 21:53:57 -05001471 if (shading_rate_image_struct &&
1472 (shading_rate_image_struct->viewportCount != 0 && shading_rate_image_struct->viewportCount != 1)) {
1473 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT,
Dave Houlton142c4cb2018-10-17 15:04:41 -06001474 VK_NULL_HANDLE,
1475 "VUID-VkPipelineViewportShadingRateImageStateCreateInfoNV-viewportCount-02054",
Jeff Bolz9af91c52018-09-01 21:53:57 -05001476 "vkCreateGraphicsPipelines: The VkPhysicalDeviceFeatures::multiViewport feature is "
Dave Houlton142c4cb2018-10-17 15:04:41 -06001477 "disabled, but pCreateInfos[%" PRIu32
1478 "] VkPipelineViewportShadingRateImageStateCreateInfoNV::viewportCount (=%" PRIu32
Jeff Bolzb8a8dd02018-09-18 02:39:24 -05001479 ") is neither 0 nor 1.",
Jeff Bolz9af91c52018-09-01 21:53:57 -05001480 i, shading_rate_image_struct->viewportCount);
Jeff Bolz9af91c52018-09-01 21:53:57 -05001481 }
1482
Petr Krausa6103552017-11-16 21:21:58 +01001483 } else { // multiViewport enabled
1484 if (viewport_state.viewportCount == 0) {
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06001485 skip |= log_msg(
1486 report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT,
Dave Houlton413a6782018-05-22 13:01:54 -06001487 VK_NULL_HANDLE, "VUID-VkPipelineViewportStateCreateInfo-viewportCount-arraylength",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06001488 "vkCreateGraphicsPipelines: pCreateInfos[%" PRIu32 "].pViewportState->viewportCount is 0.", i);
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07001489 } else if (viewport_state.viewportCount > device_limits.maxViewports) {
Petr Krausa6103552017-11-16 21:21:58 +01001490 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT,
Dave Houlton413a6782018-05-22 13:01:54 -06001491 VK_NULL_HANDLE, "VUID-VkPipelineViewportStateCreateInfo-viewportCount-01218",
Petr Krausa6103552017-11-16 21:21:58 +01001492 "vkCreateGraphicsPipelines: pCreateInfos[%" PRIu32
1493 "].pViewportState->viewportCount (=%" PRIu32
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06001494 ") is greater than VkPhysicalDeviceLimits::maxViewports (=%" PRIu32 ").",
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07001495 i, viewport_state.viewportCount, device_limits.maxViewports);
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001496 }
Petr Krausa6103552017-11-16 21:21:58 +01001497
1498 if (viewport_state.scissorCount == 0) {
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06001499 skip |= log_msg(
1500 report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT,
Dave Houlton413a6782018-05-22 13:01:54 -06001501 VK_NULL_HANDLE, "VUID-VkPipelineViewportStateCreateInfo-scissorCount-arraylength",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06001502 "vkCreateGraphicsPipelines: pCreateInfos[%" PRIu32 "].pViewportState->scissorCount is 0.", i);
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07001503 } else if (viewport_state.scissorCount > device_limits.maxViewports) {
Petr Krausa6103552017-11-16 21:21:58 +01001504 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT,
Dave Houlton413a6782018-05-22 13:01:54 -06001505 VK_NULL_HANDLE, "VUID-VkPipelineViewportStateCreateInfo-scissorCount-01219",
Petr Krausa6103552017-11-16 21:21:58 +01001506 "vkCreateGraphicsPipelines: pCreateInfos[%" PRIu32
1507 "].pViewportState->scissorCount (=%" PRIu32
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06001508 ") is greater than VkPhysicalDeviceLimits::maxViewports (=%" PRIu32 ").",
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07001509 i, viewport_state.scissorCount, device_limits.maxViewports);
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001510 }
1511 }
1512
Mark Lobodzinskibf599b92018-12-31 12:15:55 -07001513 if (exclusive_scissor_struct && exclusive_scissor_struct->exclusiveScissorCount > device_limits.maxViewports) {
1514 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT,
1515 VK_NULL_HANDLE,
1516 "VUID-VkPipelineViewportExclusiveScissorStateCreateInfoNV-exclusiveScissorCount-02028",
1517 "vkCreateGraphicsPipelines: pCreateInfos[%" PRIu32 "] exclusiveScissorCount (=%" PRIu32
1518 ") is greater than VkPhysicalDeviceLimits::maxViewports (=%" PRIu32 ").",
1519 i, exclusive_scissor_struct->exclusiveScissorCount, device_limits.maxViewports);
Jeff Bolz3e71f782018-08-29 23:15:45 -05001520 }
1521
Mark Lobodzinskibf599b92018-12-31 12:15:55 -07001522 if (shading_rate_image_struct && shading_rate_image_struct->viewportCount > device_limits.maxViewports) {
Dave Houlton142c4cb2018-10-17 15:04:41 -06001523 skip |=
1524 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT,
1525 VK_NULL_HANDLE, "VUID-VkPipelineViewportShadingRateImageStateCreateInfoNV-viewportCount-02055",
1526 "vkCreateGraphicsPipelines: pCreateInfos[%" PRIu32
1527 "] VkPipelineViewportShadingRateImageStateCreateInfoNV viewportCount (=%" PRIu32
1528 ") is greater than VkPhysicalDeviceLimits::maxViewports (=%" PRIu32 ").",
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07001529 i, shading_rate_image_struct->viewportCount, device_limits.maxViewports);
Jeff Bolz9af91c52018-09-01 21:53:57 -05001530 }
1531
Petr Krausa6103552017-11-16 21:21:58 +01001532 if (viewport_state.scissorCount != viewport_state.viewportCount) {
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06001533 skip |=
1534 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT,
Dave Houlton413a6782018-05-22 13:01:54 -06001535 VK_NULL_HANDLE, "VUID-VkPipelineViewportStateCreateInfo-scissorCount-01220",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06001536 "vkCreateGraphicsPipelines: pCreateInfos[%" PRIu32 "].pViewportState->scissorCount (=%" PRIu32
1537 ") is not identical to pCreateInfos[%" PRIu32 "].pViewportState->viewportCount (=%" PRIu32 ").",
1538 i, viewport_state.scissorCount, i, viewport_state.viewportCount);
Petr Krausa6103552017-11-16 21:21:58 +01001539 }
1540
Dave Houlton142c4cb2018-10-17 15:04:41 -06001541 if (exclusive_scissor_struct && exclusive_scissor_struct->exclusiveScissorCount != 0 &&
Jeff Bolz3e71f782018-08-29 23:15:45 -05001542 exclusive_scissor_struct->exclusiveScissorCount != viewport_state.viewportCount) {
Dave Houlton142c4cb2018-10-17 15:04:41 -06001543 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT,
1544 VK_NULL_HANDLE,
1545 "VUID-VkPipelineViewportExclusiveScissorStateCreateInfoNV-exclusiveScissorCount-02029",
1546 "vkCreateGraphicsPipelines: pCreateInfos[%" PRIu32 "] exclusiveScissorCount (=%" PRIu32
1547 ") must be zero or identical to pCreateInfos[%" PRIu32
1548 "].pViewportState->viewportCount (=%" PRIu32 ").",
1549 i, exclusive_scissor_struct->exclusiveScissorCount, i, viewport_state.viewportCount);
Jeff Bolz3e71f782018-08-29 23:15:45 -05001550 }
1551
Dave Houlton142c4cb2018-10-17 15:04:41 -06001552 if (shading_rate_image_struct && shading_rate_image_struct->shadingRateImageEnable &&
Jeff Bolz9af91c52018-09-01 21:53:57 -05001553 shading_rate_image_struct->viewportCount != viewport_state.viewportCount) {
Dave Houlton142c4cb2018-10-17 15:04:41 -06001554 skip |= log_msg(
1555 report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, VK_NULL_HANDLE,
1556 "VUID-VkPipelineViewportShadingRateImageStateCreateInfoNV-shadingRateImageEnable-02056",
1557 "vkCreateGraphicsPipelines: If shadingRateImageEnable is enabled, pCreateInfos[%" PRIu32
1558 "] "
1559 "VkPipelineViewportShadingRateImageStateCreateInfoNV viewportCount (=%" PRIu32
1560 ") must identical to pCreateInfos[%" PRIu32 "].pViewportState->viewportCount (=%" PRIu32 ").",
1561 i, shading_rate_image_struct->viewportCount, i, viewport_state.viewportCount);
Jeff Bolz9af91c52018-09-01 21:53:57 -05001562 }
1563
Petr Krausa6103552017-11-16 21:21:58 +01001564 if (!has_dynamic_viewport && viewport_state.viewportCount > 0 && viewport_state.pViewports == nullptr) {
1565 skip |= log_msg(
1566 report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, VK_NULL_HANDLE,
Dave Houlton413a6782018-05-22 13:01:54 -06001567 "VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-00747",
Petr Krausa6103552017-11-16 21:21:58 +01001568 "vkCreateGraphicsPipelines: The viewport state is static (pCreateInfos[%" PRIu32
1569 "].pDynamicState->pDynamicStates does not contain VK_DYNAMIC_STATE_VIEWPORT), but pCreateInfos[%" PRIu32
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06001570 "].pViewportState->pViewports (=NULL) is an invalid pointer.",
1571 i, i);
Petr Krausa6103552017-11-16 21:21:58 +01001572 }
1573
1574 if (!has_dynamic_scissor && viewport_state.scissorCount > 0 && viewport_state.pScissors == nullptr) {
1575 skip |= log_msg(
1576 report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, VK_NULL_HANDLE,
Dave Houlton413a6782018-05-22 13:01:54 -06001577 "VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-00748",
Petr Krausa6103552017-11-16 21:21:58 +01001578 "vkCreateGraphicsPipelines: The scissor state is static (pCreateInfos[%" PRIu32
1579 "].pDynamicState->pDynamicStates does not contain VK_DYNAMIC_STATE_SCISSOR), but pCreateInfos[%" PRIu32
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06001580 "].pViewportState->pScissors (=NULL) is an invalid pointer.",
1581 i, i);
Petr Krausa6103552017-11-16 21:21:58 +01001582 }
1583
Jeff Bolz3e71f782018-08-29 23:15:45 -05001584 if (!has_dynamic_exclusive_scissor_nv && exclusive_scissor_struct &&
Dave Houlton142c4cb2018-10-17 15:04:41 -06001585 exclusive_scissor_struct->exclusiveScissorCount > 0 &&
1586 exclusive_scissor_struct->pExclusiveScissors == nullptr) {
1587 skip |=
1588 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT,
1589 VK_NULL_HANDLE, "VUID-VkPipelineViewportExclusiveScissorStateCreateInfoNV-pDynamicStates-02030",
1590 "vkCreateGraphicsPipelines: The exclusive scissor state is static (pCreateInfos[%" PRIu32
1591 "].pDynamicState->pDynamicStates does not contain VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV), but "
1592 "pCreateInfos[%" PRIu32 "] pExclusiveScissors (=NULL) is an invalid pointer.",
1593 i, i);
Jeff Bolz3e71f782018-08-29 23:15:45 -05001594 }
1595
Jeff Bolz9af91c52018-09-01 21:53:57 -05001596 if (!has_dynamic_shading_rate_palette_nv && shading_rate_image_struct &&
Dave Houlton142c4cb2018-10-17 15:04:41 -06001597 shading_rate_image_struct->viewportCount > 0 &&
1598 shading_rate_image_struct->pShadingRatePalettes == nullptr) {
Jeff Bolz9af91c52018-09-01 21:53:57 -05001599 skip |= log_msg(
1600 report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, VK_NULL_HANDLE,
1601 "VUID-VkPipelineViewportShadingRateImageStateCreateInfoNV-pDynamicStates-02057",
1602 "vkCreateGraphicsPipelines: The shading rate palette state is static (pCreateInfos[%" PRIu32
Dave Houlton142c4cb2018-10-17 15:04:41 -06001603 "].pDynamicState->pDynamicStates does not contain VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV), "
1604 "but pCreateInfos[%" PRIu32 "] pShadingRatePalettes (=NULL) is an invalid pointer.",
Jeff Bolz9af91c52018-09-01 21:53:57 -05001605 i, i);
1606 }
1607
Chris Mayer328d8212018-12-11 14:16:18 +01001608 if (vp_swizzle_struct) {
1609 if (vp_swizzle_struct->viewportCount != viewport_state.viewportCount) {
1610 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT,
1611 VK_NULL_HANDLE, "VUID-VkPipelineViewportSwizzleStateCreateInfoNV-viewportCount-01215",
1612 "vkCreateGraphicsPipelines: The viewport swizzle state vieport count of %" PRIu32
1613 " does "
1614 "not match the viewport count of %" PRIu32 " in VkPipelineViewportStateCreateInfo.",
1615 vp_swizzle_struct->viewportCount, viewport_state.viewportCount);
1616 }
1617 }
1618
Petr Krausb3fcdb42018-01-09 22:09:09 +01001619 // validate the VkViewports
1620 if (!has_dynamic_viewport && viewport_state.pViewports) {
1621 for (uint32_t viewport_i = 0; viewport_i < viewport_state.viewportCount; ++viewport_i) {
1622 const auto &viewport = viewport_state.pViewports[viewport_i]; // will crash on invalid ptr
Jeff Bolz6d3beaa2019-02-09 21:00:05 -06001623 const char *fn_name = "vkCreateGraphicsPipelines";
1624 skip |= manual_PreCallValidateViewport(viewport, fn_name,
1625 ParameterName("pCreateInfos[%i].pViewportState->pViewports[%i]",
1626 ParameterName::IndexVector{i, viewport_i}),
Mark Lobodzinskibf599b92018-12-31 12:15:55 -07001627 VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT);
Petr Krausb3fcdb42018-01-09 22:09:09 +01001628 }
1629 }
Jeremy Kniager71fd5f02017-11-15 13:27:03 -07001630
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07001631 if (has_dynamic_viewport_w_scaling_nv && !device_extensions.vk_nv_clip_space_w_scaling) {
Jeremy Kniager71fd5f02017-11-15 13:27:03 -07001632 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT,
Dave Houlton413a6782018-05-22 13:01:54 -06001633 VK_NULL_HANDLE, kVUID_PVError_ExtensionNotEnabled,
Jeremy Kniager71fd5f02017-11-15 13:27:03 -07001634 "vkCreateGraphicsPipelines: pCreateInfos[%" PRIu32
Dave Houltona9df0ce2018-02-07 10:51:23 -07001635 "].pDynamicState->pDynamicStates contains VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV, but "
Jeremy Kniager71fd5f02017-11-15 13:27:03 -07001636 "VK_NV_clip_space_w_scaling extension is not enabled.",
1637 i);
1638 }
1639
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07001640 if (has_dynamic_discard_rectangle_ext && !device_extensions.vk_ext_discard_rectangles) {
Jeremy Kniager71fd5f02017-11-15 13:27:03 -07001641 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT,
Dave Houlton413a6782018-05-22 13:01:54 -06001642 VK_NULL_HANDLE, kVUID_PVError_ExtensionNotEnabled,
Jeremy Kniager71fd5f02017-11-15 13:27:03 -07001643 "vkCreateGraphicsPipelines: pCreateInfos[%" PRIu32
Dave Houltona9df0ce2018-02-07 10:51:23 -07001644 "].pDynamicState->pDynamicStates contains VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT, but "
Jeremy Kniager71fd5f02017-11-15 13:27:03 -07001645 "VK_EXT_discard_rectangles extension is not enabled.",
1646 i);
1647 }
1648
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07001649 if (has_dynamic_sample_locations_ext && !device_extensions.vk_ext_sample_locations) {
Jeremy Kniager71fd5f02017-11-15 13:27:03 -07001650 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT,
Dave Houlton413a6782018-05-22 13:01:54 -06001651 VK_NULL_HANDLE, kVUID_PVError_ExtensionNotEnabled,
Jeremy Kniager71fd5f02017-11-15 13:27:03 -07001652 "vkCreateGraphicsPipelines: pCreateInfos[%" PRIu32
Dave Houltona9df0ce2018-02-07 10:51:23 -07001653 "].pDynamicState->pDynamicStates contains VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT, but "
Jeremy Kniager71fd5f02017-11-15 13:27:03 -07001654 "VK_EXT_sample_locations extension is not enabled.",
1655 i);
1656 }
Jeff Bolz3e71f782018-08-29 23:15:45 -05001657
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07001658 if (has_dynamic_exclusive_scissor_nv && !device_extensions.vk_nv_scissor_exclusive) {
Jeff Bolz3e71f782018-08-29 23:15:45 -05001659 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT,
1660 VK_NULL_HANDLE, kVUID_PVError_ExtensionNotEnabled,
1661 "vkCreateGraphicsPipelines: pCreateInfos[%" PRIu32
1662 "].pDynamicState->pDynamicStates contains VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV, but "
1663 "VK_NV_scissor_exclusive extension is not enabled.",
1664 i);
1665 }
Jeff Bolz9af91c52018-09-01 21:53:57 -05001666
1667 if (coarse_sample_order_struct &&
1668 coarse_sample_order_struct->sampleOrderType != VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV &&
1669 coarse_sample_order_struct->customSampleOrderCount != 0) {
Dave Houlton142c4cb2018-10-17 15:04:41 -06001670 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT,
1671 VK_NULL_HANDLE,
1672 "VUID-VkPipelineViewportCoarseSampleOrderStateCreateInfoNV-sampleOrderType-02072",
1673 "vkCreateGraphicsPipelines: pCreateInfos[%" PRIu32
1674 "] "
1675 "VkPipelineViewportCoarseSampleOrderStateCreateInfoNV sampleOrderType is not "
1676 "VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV and customSampleOrderCount is not 0.",
1677 i);
Jeff Bolz9af91c52018-09-01 21:53:57 -05001678 }
1679
1680 if (coarse_sample_order_struct) {
1681 for (uint32_t order_i = 0; order_i < coarse_sample_order_struct->customSampleOrderCount; ++order_i) {
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07001682 skip |= ValidateCoarseSampleOrderCustomNV(&coarse_sample_order_struct->pCustomSampleOrders[order_i]);
Jeff Bolz9af91c52018-09-01 21:53:57 -05001683 }
1684 }
Chris Mayer9ded5eb2019-09-19 16:33:26 +02001685
1686 if (vp_w_scaling_struct && (vp_w_scaling_struct->viewportWScalingEnable == VK_TRUE)) {
1687 if (vp_w_scaling_struct->viewportCount != viewport_state.viewportCount) {
1688 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT,
1689 VK_NULL_HANDLE, "VUID-VkPipelineViewportStateCreateInfo-viewportWScalingEnable-01726",
1690 "vkCreateGraphicsPipelines: pCreateInfos[%" PRIu32
1691 "] "
1692 "VkPipelineViewportWScalingStateCreateInfoNV.viewportCount (=%" PRIu32
1693 ") "
1694 "is not equal to VkPipelineViewportStateCreateInfo.viewportCount (=%" PRIu32 ").",
1695 i, vp_w_scaling_struct->viewportCount, viewport_state.viewportCount);
1696 }
1697 if (!has_dynamic_viewport_w_scaling_nv && !vp_w_scaling_struct->pViewportWScalings) {
1698 skip |= log_msg(
1699 report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT,
1700 VK_NULL_HANDLE, "VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-01715",
1701 "vkCreateGraphicsPipelines: pCreateInfos[%" PRIu32
1702 "] "
1703 "VkPipelineViewportWScalingStateCreateInfoNV.pViewportWScalings (=NULL) is not a valid array.",
1704 i);
1705 }
1706 }
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001707 }
1708
1709 if (pCreateInfos[i].pMultisampleState == nullptr) {
1710 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Dave Houlton413a6782018-05-22 13:01:54 -06001711 "VUID-VkGraphicsPipelineCreateInfo-rasterizerDiscardEnable-00751",
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001712 "vkCreateGraphicsPipelines: if pCreateInfos[%d].pRasterizationState->rasterizerDiscardEnable "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06001713 "is VK_FALSE, pCreateInfos[%d].pMultisampleState must not be NULL.",
1714 i, i);
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001715 } else {
Dave Houltonb3bbec72018-01-17 10:13:33 -07001716 const VkStructureType valid_next_stypes[] = {LvlTypeMap<VkPipelineCoverageModulationStateCreateInfoNV>::kSType,
1717 LvlTypeMap<VkPipelineCoverageToColorStateCreateInfoNV>::kSType,
1718 LvlTypeMap<VkPipelineSampleLocationsStateCreateInfoEXT>::kSType};
Mike Schuchardt97662b02017-12-06 13:31:29 -07001719 const char *valid_struct_names =
Dave Houltona9df0ce2018-02-07 10:51:23 -07001720 "VkPipelineCoverageModulationStateCreateInfoNV, VkPipelineCoverageToColorStateCreateInfoNV, "
John Zulauf96b0e422017-11-14 11:43:19 -07001721 "VkPipelineSampleLocationsStateCreateInfoEXT";
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001722 skip |= validate_struct_pnext(
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07001723 "vkCreateGraphicsPipelines",
John Zulauf96b0e422017-11-14 11:43:19 -07001724 ParameterName("pCreateInfos[%i].pMultisampleState->pNext", ParameterName::IndexVector{i}),
Mark Lobodzinskibf599b92018-12-31 12:15:55 -07001725 valid_struct_names, pCreateInfos[i].pMultisampleState->pNext, 3, valid_next_stypes,
1726 GeneratedVulkanHeaderVersion, "VUID-VkPipelineMultisampleStateCreateInfo-pNext-pNext");
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001727
1728 skip |= validate_reserved_flags(
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07001729 "vkCreateGraphicsPipelines",
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001730 ParameterName("pCreateInfos[%i].pMultisampleState->flags", ParameterName::IndexVector{i}),
Dave Houlton413a6782018-05-22 13:01:54 -06001731 pCreateInfos[i].pMultisampleState->flags, "VUID-VkPipelineMultisampleStateCreateInfo-flags-zerobitmask");
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001732
1733 skip |= validate_bool32(
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07001734 "vkCreateGraphicsPipelines",
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001735 ParameterName("pCreateInfos[%i].pMultisampleState->sampleShadingEnable", ParameterName::IndexVector{i}),
1736 pCreateInfos[i].pMultisampleState->sampleShadingEnable);
1737
1738 skip |= validate_array(
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07001739 "vkCreateGraphicsPipelines",
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001740 ParameterName("pCreateInfos[%i].pMultisampleState->rasterizationSamples", ParameterName::IndexVector{i}),
1741 ParameterName("pCreateInfos[%i].pMultisampleState->pSampleMask", ParameterName::IndexVector{i}),
Gabríel Arthúr Pétursson092b29b2018-03-21 22:44:11 +00001742 pCreateInfos[i].pMultisampleState->rasterizationSamples, &pCreateInfos[i].pMultisampleState->pSampleMask,
Dave Houlton413a6782018-05-22 13:01:54 -06001743 true, false, kVUIDUndefined, kVUIDUndefined);
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001744
Mark Lobodzinski876d5b52019-08-06 16:32:27 -06001745 skip |= validate_flags(
1746 "vkCreateGraphicsPipelines",
1747 ParameterName("pCreateInfos[%i].pMultisampleState->rasterizationSamples", ParameterName::IndexVector{i}),
1748 "VkSampleCountFlagBits", AllVkSampleCountFlagBits, pCreateInfos[i].pMultisampleState->rasterizationSamples,
Petr Kraus52758be2019-08-12 00:53:58 +02001749 kRequiredSingleBit, "VUID-VkPipelineMultisampleStateCreateInfo-rasterizationSamples-parameter");
Mark Lobodzinski876d5b52019-08-06 16:32:27 -06001750
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001751 skip |= validate_bool32(
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07001752 "vkCreateGraphicsPipelines",
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001753 ParameterName("pCreateInfos[%i].pMultisampleState->alphaToCoverageEnable", ParameterName::IndexVector{i}),
1754 pCreateInfos[i].pMultisampleState->alphaToCoverageEnable);
1755
1756 skip |= validate_bool32(
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07001757 "vkCreateGraphicsPipelines",
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001758 ParameterName("pCreateInfos[%i].pMultisampleState->alphaToOneEnable", ParameterName::IndexVector{i}),
1759 pCreateInfos[i].pMultisampleState->alphaToOneEnable);
1760
1761 if (pCreateInfos[i].pMultisampleState->sType != VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO) {
1762 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Dave Houlton413a6782018-05-22 13:01:54 -06001763 kVUID_PVError_InvalidStructSType,
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001764 "vkCreateGraphicsPipelines: parameter pCreateInfos[%d].pMultisampleState->sType must be "
1765 "VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO",
1766 i);
1767 }
John Zulauf7acac592017-11-06 11:15:53 -07001768 if (pCreateInfos[i].pMultisampleState->sampleShadingEnable == VK_TRUE) {
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07001769 if (!physical_device_features.sampleRateShading) {
John Zulauf7acac592017-11-06 11:15:53 -07001770 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Dave Houlton413a6782018-05-22 13:01:54 -06001771 "VUID-VkPipelineMultisampleStateCreateInfo-sampleShadingEnable-00784",
John Zulauf7acac592017-11-06 11:15:53 -07001772 "vkCreateGraphicsPipelines(): parameter "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06001773 "pCreateInfos[%d].pMultisampleState->sampleShadingEnable.",
1774 i);
John Zulauf7acac592017-11-06 11:15:53 -07001775 }
1776 // TODO Add documentation issue about when minSampleShading must be in range and when it is ignored
1777 // For now a "least noise" test *only* when sampleShadingEnable is VK_TRUE.
1778 if (!in_inclusive_range(pCreateInfos[i].pMultisampleState->minSampleShading, 0.F, 1.0F)) {
1779 skip |= log_msg(
Mark Lobodzinskib1fd9d12018-03-30 14:26:00 -06001780 report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Dave Houlton413a6782018-05-22 13:01:54 -06001781 "VUID-VkPipelineMultisampleStateCreateInfo-minSampleShading-00786",
Mark Lobodzinski88529492018-04-01 10:38:15 -06001782 "vkCreateGraphicsPipelines(): parameter pCreateInfos[%d].pMultisampleState->minSampleShading.", i);
John Zulauf7acac592017-11-06 11:15:53 -07001783 }
1784 }
Jeff Bolz8125a8b2019-08-16 16:29:45 -05001785
1786 const auto *line_state = lvl_find_in_chain<VkPipelineRasterizationLineStateCreateInfoEXT>(
1787 pCreateInfos[i].pRasterizationState->pNext);
1788
1789 if (line_state) {
1790 if ((line_state->lineRasterizationMode == VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT ||
1791 line_state->lineRasterizationMode == VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT)) {
1792 if (pCreateInfos[i].pMultisampleState->alphaToCoverageEnable) {
1793 skip |=
1794 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
1795 "VUID-VkGraphicsPipelineCreateInfo-lineRasterizationMode-02766",
1796 "vkCreateGraphicsPipelines(): Bresenham/Smooth line rasterization not supported with "
1797 "pCreateInfos[%d].pMultisampleState->alphaToCoverageEnable == VK_TRUE.",
1798 i);
1799 }
1800 if (pCreateInfos[i].pMultisampleState->alphaToOneEnable) {
1801 skip |=
1802 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
1803 "VUID-VkGraphicsPipelineCreateInfo-lineRasterizationMode-02766",
1804 "vkCreateGraphicsPipelines(): Bresenham/Smooth line rasterization not supported with "
1805 "pCreateInfos[%d].pMultisampleState->alphaToOneEnable == VK_TRUE.",
1806 i);
1807 }
1808 if (pCreateInfos[i].pMultisampleState->sampleShadingEnable) {
1809 skip |=
1810 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
1811 "VUID-VkGraphicsPipelineCreateInfo-lineRasterizationMode-02766",
1812 "vkCreateGraphicsPipelines(): Bresenham/Smooth line rasterization not supported with "
1813 "pCreateInfos[%d].pMultisampleState->sampleShadingEnable == VK_TRUE.",
1814 i);
1815 }
1816 }
1817 if (line_state->stippledLineEnable && !has_dynamic_line_stipple) {
1818 if (line_state->lineStippleFactor < 1 || line_state->lineStippleFactor > 256) {
1819 skip |=
1820 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
1821 "VUID-VkGraphicsPipelineCreateInfo-stippledLineEnable-02767",
1822 "vkCreateGraphicsPipelines(): pCreateInfos[%d] lineStippleFactor = %d must be in the "
1823 "range [1,256].",
1824 i, line_state->lineStippleFactor);
1825 }
1826 }
1827 const auto *line_features =
Tony-LunarG6c3c5452019-12-13 10:37:38 -07001828 lvl_find_in_chain<VkPhysicalDeviceLineRasterizationFeaturesEXT>(device_createinfo_pnext);
Jeff Bolz8125a8b2019-08-16 16:29:45 -05001829 if (line_state->lineRasterizationMode == VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT &&
1830 (!line_features || !line_features->rectangularLines)) {
1831 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
1832 "VUID-VkPipelineRasterizationLineStateCreateInfoEXT-lineRasterizationMode-02768",
1833 "vkCreateGraphicsPipelines(): pCreateInfos[%d] lineRasterizationMode = "
1834 "VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT requires the rectangularLines feature.",
1835 i);
1836 }
1837 if (line_state->lineRasterizationMode == VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT &&
1838 (!line_features || !line_features->bresenhamLines)) {
1839 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
1840 "VUID-VkPipelineRasterizationLineStateCreateInfoEXT-lineRasterizationMode-02769",
1841 "vkCreateGraphicsPipelines(): pCreateInfos[%d] lineRasterizationMode = "
1842 "VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT requires the bresenhamLines feature.",
1843 i);
1844 }
1845 if (line_state->lineRasterizationMode == VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT &&
1846 (!line_features || !line_features->smoothLines)) {
1847 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
1848 "VUID-VkPipelineRasterizationLineStateCreateInfoEXT-lineRasterizationMode-02770",
1849 "vkCreateGraphicsPipelines(): pCreateInfos[%d] lineRasterizationMode = "
1850 "VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT requires the smoothLines feature.",
1851 i);
1852 }
1853 if (line_state->stippledLineEnable) {
1854 if (line_state->lineRasterizationMode == VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT &&
1855 (!line_features || !line_features->stippledRectangularLines)) {
1856 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT,
1857 0, "VUID-VkPipelineRasterizationLineStateCreateInfoEXT-stippledLineEnable-02771",
1858 "vkCreateGraphicsPipelines(): pCreateInfos[%d] lineRasterizationMode = "
1859 "VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT with stipple requires the "
1860 "stippledRectangularLines feature.",
1861 i);
1862 }
1863 if (line_state->lineRasterizationMode == VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT &&
1864 (!line_features || !line_features->stippledBresenhamLines)) {
1865 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT,
1866 0, "VUID-VkPipelineRasterizationLineStateCreateInfoEXT-stippledLineEnable-02772",
1867 "vkCreateGraphicsPipelines(): pCreateInfos[%d] lineRasterizationMode = "
1868 "VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT with stipple requires the "
1869 "stippledBresenhamLines feature.",
1870 i);
1871 }
1872 if (line_state->lineRasterizationMode == VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT &&
1873 (!line_features || !line_features->stippledSmoothLines)) {
1874 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT,
1875 0, "VUID-VkPipelineRasterizationLineStateCreateInfoEXT-stippledLineEnable-02773",
1876 "vkCreateGraphicsPipelines(): pCreateInfos[%d] lineRasterizationMode = "
1877 "VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT with stipple requires the "
1878 "stippledSmoothLines feature.",
1879 i);
1880 }
1881 if (line_state->lineRasterizationMode == VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT &&
1882 (!line_features || !line_features->stippledSmoothLines || !device_limits.strictLines)) {
1883 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT,
1884 0, "VUID-VkPipelineRasterizationLineStateCreateInfoEXT-stippledLineEnable-02774",
1885 "vkCreateGraphicsPipelines(): pCreateInfos[%d] lineRasterizationMode = "
1886 "VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT with stipple requires the "
1887 "stippledRectangularLines and strictLines features.",
1888 i);
1889 }
1890 }
1891 }
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001892 }
1893
Petr Krause91f7a12017-12-14 20:57:36 +01001894 bool uses_color_attachment = false;
1895 bool uses_depthstencil_attachment = false;
1896 {
Mark Lobodzinskif27a6bc2019-02-04 13:00:49 -07001897 std::unique_lock<std::mutex> lock(renderpass_map_mutex);
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07001898 const auto subpasses_uses_it = renderpasses_states.find(pCreateInfos[i].renderPass);
1899 if (subpasses_uses_it != renderpasses_states.end()) {
Petr Krause91f7a12017-12-14 20:57:36 +01001900 const auto &subpasses_uses = subpasses_uses_it->second;
1901 if (subpasses_uses.subpasses_using_color_attachment.count(pCreateInfos[i].subpass))
1902 uses_color_attachment = true;
1903 if (subpasses_uses.subpasses_using_depthstencil_attachment.count(pCreateInfos[i].subpass))
1904 uses_depthstencil_attachment = true;
1905 }
Mark Lobodzinskif27a6bc2019-02-04 13:00:49 -07001906 lock.unlock();
Petr Krause91f7a12017-12-14 20:57:36 +01001907 }
1908
1909 if (pCreateInfos[i].pDepthStencilState != nullptr && uses_depthstencil_attachment) {
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001910 skip |= validate_struct_pnext(
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07001911 "vkCreateGraphicsPipelines",
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001912 ParameterName("pCreateInfos[%i].pDepthStencilState->pNext", ParameterName::IndexVector{i}), NULL,
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07001913 pCreateInfos[i].pDepthStencilState->pNext, 0, NULL, GeneratedVulkanHeaderVersion,
Dave Houlton413a6782018-05-22 13:01:54 -06001914 "VUID-VkPipelineDepthStencilStateCreateInfo-pNext-pNext");
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001915
1916 skip |= validate_reserved_flags(
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07001917 "vkCreateGraphicsPipelines",
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001918 ParameterName("pCreateInfos[%i].pDepthStencilState->flags", ParameterName::IndexVector{i}),
Dave Houlton413a6782018-05-22 13:01:54 -06001919 pCreateInfos[i].pDepthStencilState->flags, "VUID-VkPipelineDepthStencilStateCreateInfo-flags-zerobitmask");
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001920
1921 skip |= validate_bool32(
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07001922 "vkCreateGraphicsPipelines",
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001923 ParameterName("pCreateInfos[%i].pDepthStencilState->depthTestEnable", ParameterName::IndexVector{i}),
1924 pCreateInfos[i].pDepthStencilState->depthTestEnable);
1925
1926 skip |= validate_bool32(
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07001927 "vkCreateGraphicsPipelines",
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001928 ParameterName("pCreateInfos[%i].pDepthStencilState->depthWriteEnable", ParameterName::IndexVector{i}),
1929 pCreateInfos[i].pDepthStencilState->depthWriteEnable);
1930
1931 skip |= validate_ranged_enum(
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07001932 "vkCreateGraphicsPipelines",
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001933 ParameterName("pCreateInfos[%i].pDepthStencilState->depthCompareOp", ParameterName::IndexVector{i}),
1934 "VkCompareOp", AllVkCompareOpEnums, pCreateInfos[i].pDepthStencilState->depthCompareOp,
Dave Houlton413a6782018-05-22 13:01:54 -06001935 "VUID-VkPipelineDepthStencilStateCreateInfo-depthCompareOp-parameter");
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001936
1937 skip |= validate_bool32(
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07001938 "vkCreateGraphicsPipelines",
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001939 ParameterName("pCreateInfos[%i].pDepthStencilState->depthBoundsTestEnable", ParameterName::IndexVector{i}),
1940 pCreateInfos[i].pDepthStencilState->depthBoundsTestEnable);
1941
1942 skip |= validate_bool32(
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07001943 "vkCreateGraphicsPipelines",
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001944 ParameterName("pCreateInfos[%i].pDepthStencilState->stencilTestEnable", ParameterName::IndexVector{i}),
1945 pCreateInfos[i].pDepthStencilState->stencilTestEnable);
1946
1947 skip |= validate_ranged_enum(
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07001948 "vkCreateGraphicsPipelines",
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001949 ParameterName("pCreateInfos[%i].pDepthStencilState->front.failOp", ParameterName::IndexVector{i}),
1950 "VkStencilOp", AllVkStencilOpEnums, pCreateInfos[i].pDepthStencilState->front.failOp,
Dave Houlton413a6782018-05-22 13:01:54 -06001951 "VUID-VkStencilOpState-failOp-parameter");
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001952
1953 skip |= validate_ranged_enum(
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07001954 "vkCreateGraphicsPipelines",
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001955 ParameterName("pCreateInfos[%i].pDepthStencilState->front.passOp", ParameterName::IndexVector{i}),
1956 "VkStencilOp", AllVkStencilOpEnums, pCreateInfos[i].pDepthStencilState->front.passOp,
Dave Houlton413a6782018-05-22 13:01:54 -06001957 "VUID-VkStencilOpState-passOp-parameter");
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001958
1959 skip |= validate_ranged_enum(
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07001960 "vkCreateGraphicsPipelines",
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001961 ParameterName("pCreateInfos[%i].pDepthStencilState->front.depthFailOp", ParameterName::IndexVector{i}),
1962 "VkStencilOp", AllVkStencilOpEnums, pCreateInfos[i].pDepthStencilState->front.depthFailOp,
Dave Houlton413a6782018-05-22 13:01:54 -06001963 "VUID-VkStencilOpState-depthFailOp-parameter");
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001964
1965 skip |= validate_ranged_enum(
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07001966 "vkCreateGraphicsPipelines",
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001967 ParameterName("pCreateInfos[%i].pDepthStencilState->front.compareOp", ParameterName::IndexVector{i}),
1968 "VkCompareOp", AllVkCompareOpEnums, pCreateInfos[i].pDepthStencilState->front.compareOp,
Dave Houlton413a6782018-05-22 13:01:54 -06001969 "VUID-VkPipelineDepthStencilStateCreateInfo-depthCompareOp-parameter");
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001970
1971 skip |= validate_ranged_enum(
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07001972 "vkCreateGraphicsPipelines",
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001973 ParameterName("pCreateInfos[%i].pDepthStencilState->back.failOp", ParameterName::IndexVector{i}),
1974 "VkStencilOp", AllVkStencilOpEnums, pCreateInfos[i].pDepthStencilState->back.failOp,
Dave Houlton413a6782018-05-22 13:01:54 -06001975 "VUID-VkStencilOpState-failOp-parameter");
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001976
1977 skip |= validate_ranged_enum(
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07001978 "vkCreateGraphicsPipelines",
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001979 ParameterName("pCreateInfos[%i].pDepthStencilState->back.passOp", ParameterName::IndexVector{i}),
1980 "VkStencilOp", AllVkStencilOpEnums, pCreateInfos[i].pDepthStencilState->back.passOp,
Dave Houlton413a6782018-05-22 13:01:54 -06001981 "VUID-VkStencilOpState-passOp-parameter");
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001982
1983 skip |= validate_ranged_enum(
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07001984 "vkCreateGraphicsPipelines",
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001985 ParameterName("pCreateInfos[%i].pDepthStencilState->back.depthFailOp", ParameterName::IndexVector{i}),
1986 "VkStencilOp", AllVkStencilOpEnums, pCreateInfos[i].pDepthStencilState->back.depthFailOp,
Dave Houlton413a6782018-05-22 13:01:54 -06001987 "VUID-VkStencilOpState-depthFailOp-parameter");
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001988
1989 skip |= validate_ranged_enum(
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07001990 "vkCreateGraphicsPipelines",
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001991 ParameterName("pCreateInfos[%i].pDepthStencilState->back.compareOp", ParameterName::IndexVector{i}),
1992 "VkCompareOp", AllVkCompareOpEnums, pCreateInfos[i].pDepthStencilState->back.compareOp,
Dave Houlton413a6782018-05-22 13:01:54 -06001993 "VUID-VkPipelineDepthStencilStateCreateInfo-depthCompareOp-parameter");
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001994
1995 if (pCreateInfos[i].pDepthStencilState->sType != VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO) {
1996 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Dave Houlton413a6782018-05-22 13:01:54 -06001997 kVUID_PVError_InvalidStructSType,
Mark Lobodzinskid4950072017-08-01 13:02:20 -06001998 "vkCreateGraphicsPipelines: parameter pCreateInfos[%d].pDepthStencilState->sType must be "
1999 "VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO",
2000 i);
2001 }
2002 }
2003
Shannon McPherson9b9532b2018-10-24 12:00:09 -06002004 const VkStructureType allowed_structs_VkPipelineColorBlendStateCreateInfo[] = {
2005 VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT};
2006
Petr Krause91f7a12017-12-14 20:57:36 +01002007 if (pCreateInfos[i].pColorBlendState != nullptr && uses_color_attachment) {
Mark Lobodzinski876d5b52019-08-06 16:32:27 -06002008 skip |= validate_struct_type("vkCreateGraphicsPipelines",
2009 ParameterName("pCreateInfos[%i].pColorBlendState", ParameterName::IndexVector{i}),
2010 "VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO",
2011 pCreateInfos[i].pColorBlendState,
2012 VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, false, kVUIDUndefined,
2013 "VUID-VkPipelineColorBlendStateCreateInfo-sType-sType");
2014
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002015 skip |= validate_struct_pnext(
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07002016 "vkCreateGraphicsPipelines",
Shannon McPherson9b9532b2018-10-24 12:00:09 -06002017 ParameterName("pCreateInfos[%i].pColorBlendState->pNext", ParameterName::IndexVector{i}),
2018 "VkPipelineColorBlendAdvancedStateCreateInfoEXT", pCreateInfos[i].pColorBlendState->pNext,
2019 ARRAY_SIZE(allowed_structs_VkPipelineColorBlendStateCreateInfo),
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07002020 allowed_structs_VkPipelineColorBlendStateCreateInfo, GeneratedVulkanHeaderVersion,
Dave Houlton413a6782018-05-22 13:01:54 -06002021 "VUID-VkPipelineColorBlendStateCreateInfo-pNext-pNext");
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002022
2023 skip |= validate_reserved_flags(
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07002024 "vkCreateGraphicsPipelines",
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002025 ParameterName("pCreateInfos[%i].pColorBlendState->flags", ParameterName::IndexVector{i}),
Dave Houlton413a6782018-05-22 13:01:54 -06002026 pCreateInfos[i].pColorBlendState->flags, "VUID-VkPipelineColorBlendStateCreateInfo-flags-zerobitmask");
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002027
2028 skip |= validate_bool32(
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07002029 "vkCreateGraphicsPipelines",
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002030 ParameterName("pCreateInfos[%i].pColorBlendState->logicOpEnable", ParameterName::IndexVector{i}),
2031 pCreateInfos[i].pColorBlendState->logicOpEnable);
2032
2033 skip |= validate_array(
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07002034 "vkCreateGraphicsPipelines",
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002035 ParameterName("pCreateInfos[%i].pColorBlendState->attachmentCount", ParameterName::IndexVector{i}),
2036 ParameterName("pCreateInfos[%i].pColorBlendState->pAttachments", ParameterName::IndexVector{i}),
Gabríel Arthúr Pétursson092b29b2018-03-21 22:44:11 +00002037 pCreateInfos[i].pColorBlendState->attachmentCount, &pCreateInfos[i].pColorBlendState->pAttachments, false,
Dave Houlton413a6782018-05-22 13:01:54 -06002038 true, kVUIDUndefined, kVUIDUndefined);
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002039
2040 if (pCreateInfos[i].pColorBlendState->pAttachments != NULL) {
2041 for (uint32_t attachmentIndex = 0; attachmentIndex < pCreateInfos[i].pColorBlendState->attachmentCount;
2042 ++attachmentIndex) {
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07002043 skip |= validate_bool32("vkCreateGraphicsPipelines",
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002044 ParameterName("pCreateInfos[%i].pColorBlendState->pAttachments[%i].blendEnable",
2045 ParameterName::IndexVector{i, attachmentIndex}),
2046 pCreateInfos[i].pColorBlendState->pAttachments[attachmentIndex].blendEnable);
2047
2048 skip |= validate_ranged_enum(
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07002049 "vkCreateGraphicsPipelines",
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002050 ParameterName("pCreateInfos[%i].pColorBlendState->pAttachments[%i].srcColorBlendFactor",
2051 ParameterName::IndexVector{i, attachmentIndex}),
2052 "VkBlendFactor", AllVkBlendFactorEnums,
2053 pCreateInfos[i].pColorBlendState->pAttachments[attachmentIndex].srcColorBlendFactor,
Dave Houlton413a6782018-05-22 13:01:54 -06002054 "VUID-VkPipelineColorBlendAttachmentState-srcColorBlendFactor-parameter");
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002055
2056 skip |= validate_ranged_enum(
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07002057 "vkCreateGraphicsPipelines",
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002058 ParameterName("pCreateInfos[%i].pColorBlendState->pAttachments[%i].dstColorBlendFactor",
2059 ParameterName::IndexVector{i, attachmentIndex}),
2060 "VkBlendFactor", AllVkBlendFactorEnums,
2061 pCreateInfos[i].pColorBlendState->pAttachments[attachmentIndex].dstColorBlendFactor,
Dave Houlton413a6782018-05-22 13:01:54 -06002062 "VUID-VkPipelineColorBlendAttachmentState-dstColorBlendFactor-parameter");
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002063
2064 skip |= validate_ranged_enum(
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07002065 "vkCreateGraphicsPipelines",
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002066 ParameterName("pCreateInfos[%i].pColorBlendState->pAttachments[%i].colorBlendOp",
2067 ParameterName::IndexVector{i, attachmentIndex}),
2068 "VkBlendOp", AllVkBlendOpEnums,
2069 pCreateInfos[i].pColorBlendState->pAttachments[attachmentIndex].colorBlendOp,
Dave Houlton413a6782018-05-22 13:01:54 -06002070 "VUID-VkPipelineColorBlendAttachmentState-colorBlendOp-parameter");
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002071
2072 skip |= validate_ranged_enum(
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07002073 "vkCreateGraphicsPipelines",
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002074 ParameterName("pCreateInfos[%i].pColorBlendState->pAttachments[%i].srcAlphaBlendFactor",
2075 ParameterName::IndexVector{i, attachmentIndex}),
2076 "VkBlendFactor", AllVkBlendFactorEnums,
2077 pCreateInfos[i].pColorBlendState->pAttachments[attachmentIndex].srcAlphaBlendFactor,
Dave Houlton413a6782018-05-22 13:01:54 -06002078 "VUID-VkPipelineColorBlendAttachmentState-srcAlphaBlendFactor-parameter");
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002079
2080 skip |= validate_ranged_enum(
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07002081 "vkCreateGraphicsPipelines",
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002082 ParameterName("pCreateInfos[%i].pColorBlendState->pAttachments[%i].dstAlphaBlendFactor",
2083 ParameterName::IndexVector{i, attachmentIndex}),
2084 "VkBlendFactor", AllVkBlendFactorEnums,
2085 pCreateInfos[i].pColorBlendState->pAttachments[attachmentIndex].dstAlphaBlendFactor,
Dave Houlton413a6782018-05-22 13:01:54 -06002086 "VUID-VkPipelineColorBlendAttachmentState-dstAlphaBlendFactor-parameter");
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002087
2088 skip |= validate_ranged_enum(
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07002089 "vkCreateGraphicsPipelines",
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002090 ParameterName("pCreateInfos[%i].pColorBlendState->pAttachments[%i].alphaBlendOp",
2091 ParameterName::IndexVector{i, attachmentIndex}),
2092 "VkBlendOp", AllVkBlendOpEnums,
2093 pCreateInfos[i].pColorBlendState->pAttachments[attachmentIndex].alphaBlendOp,
Dave Houlton413a6782018-05-22 13:01:54 -06002094 "VUID-VkPipelineColorBlendAttachmentState-alphaBlendOp-parameter");
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002095
2096 skip |=
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07002097 validate_flags("vkCreateGraphicsPipelines",
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002098 ParameterName("pCreateInfos[%i].pColorBlendState->pAttachments[%i].colorWriteMask",
2099 ParameterName::IndexVector{i, attachmentIndex}),
2100 "VkColorComponentFlagBits", AllVkColorComponentFlagBits,
2101 pCreateInfos[i].pColorBlendState->pAttachments[attachmentIndex].colorWriteMask,
Petr Kraus52758be2019-08-12 00:53:58 +02002102 kOptionalFlags, "VUID-VkPipelineColorBlendAttachmentState-colorWriteMask-parameter");
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002103 }
2104 }
2105
2106 if (pCreateInfos[i].pColorBlendState->sType != VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO) {
2107 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Dave Houlton413a6782018-05-22 13:01:54 -06002108 kVUID_PVError_InvalidStructSType,
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002109 "vkCreateGraphicsPipelines: parameter pCreateInfos[%d].pColorBlendState->sType must be "
2110 "VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO",
2111 i);
2112 }
2113
2114 // If logicOpEnable is VK_TRUE, logicOp must be a valid VkLogicOp value
2115 if (pCreateInfos[i].pColorBlendState->logicOpEnable == VK_TRUE) {
2116 skip |= validate_ranged_enum(
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07002117 "vkCreateGraphicsPipelines",
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002118 ParameterName("pCreateInfos[%i].pColorBlendState->logicOp", ParameterName::IndexVector{i}), "VkLogicOp",
Dave Houlton413a6782018-05-22 13:01:54 -06002119 AllVkLogicOpEnums, pCreateInfos[i].pColorBlendState->logicOp,
2120 "VUID-VkPipelineColorBlendStateCreateInfo-logicOpEnable-00607");
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002121 }
2122 }
2123 }
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002124
Petr Kraus9752aae2017-11-24 03:05:50 +01002125 if (pCreateInfos[i].flags & VK_PIPELINE_CREATE_DERIVATIVE_BIT) {
2126 if (pCreateInfos[i].basePipelineIndex != -1) {
2127 if (pCreateInfos[i].basePipelineHandle != VK_NULL_HANDLE) {
Dave Houltona9df0ce2018-02-07 10:51:23 -07002128 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Dave Houlton413a6782018-05-22 13:01:54 -06002129 "VUID-VkGraphicsPipelineCreateInfo-flags-00724",
Dave Houltona9df0ce2018-02-07 10:51:23 -07002130 "vkCreateGraphicsPipelines parameter, pCreateInfos->basePipelineHandle, must be "
2131 "VK_NULL_HANDLE if pCreateInfos->flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002132 "and pCreateInfos->basePipelineIndex is not -1.");
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002133 }
2134 }
2135
Petr Kraus9752aae2017-11-24 03:05:50 +01002136 if (pCreateInfos[i].basePipelineHandle != VK_NULL_HANDLE) {
2137 if (pCreateInfos[i].basePipelineIndex != -1) {
Dave Houltona9df0ce2018-02-07 10:51:23 -07002138 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Dave Houlton413a6782018-05-22 13:01:54 -06002139 "VUID-VkGraphicsPipelineCreateInfo-flags-00725",
Dave Houltona9df0ce2018-02-07 10:51:23 -07002140 "vkCreateGraphicsPipelines parameter, pCreateInfos->basePipelineIndex, must be -1 if "
2141 "pCreateInfos->flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag and "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002142 "pCreateInfos->basePipelineHandle is not VK_NULL_HANDLE.");
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002143 }
Mark Lobodzinski4dfeb942019-09-13 12:11:13 -06002144 } else {
2145 if (static_cast<const uint32_t>(pCreateInfos[i].basePipelineIndex) >= createInfoCount) {
2146 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
2147 "VUID-VkGraphicsPipelineCreateInfo-flags-00723",
2148 "vkCreateGraphicsPipelines parameter pCreateInfos->basePipelineIndex (%d) must be a valid"
2149 "index into the pCreateInfos array, of size %d.",
2150 pCreateInfos[i].basePipelineIndex, createInfoCount);
2151 }
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002152 }
2153 }
2154
Petr Kraus9752aae2017-11-24 03:05:50 +01002155 if (pCreateInfos[i].pRasterizationState) {
Chris Mayer840b2c42019-08-22 18:12:22 +02002156 if (!device_extensions.vk_nv_fill_rectangle) {
2157 if (pCreateInfos[i].pRasterizationState->polygonMode == VK_POLYGON_MODE_FILL_RECTANGLE_NV) {
2158 skip |=
2159 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
2160 "VUID-VkPipelineRasterizationStateCreateInfo-polygonMode-01414",
Dave Houltona9df0ce2018-02-07 10:51:23 -07002161 "vkCreateGraphicsPipelines parameter, VkPolygonMode "
Chris Mayer840b2c42019-08-22 18:12:22 +02002162 "pCreateInfos->pRasterizationState->polygonMode cannot be VK_POLYGON_MODE_FILL_RECTANGLE_NV "
2163 "if the extension VK_NV_fill_rectangle is not enabled.");
2164 } else if ((pCreateInfos[i].pRasterizationState->polygonMode != VK_POLYGON_MODE_FILL) &&
2165 (physical_device_features.fillModeNonSolid == false)) {
2166 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
2167 kVUID_PVError_DeviceFeature,
2168 "vkCreateGraphicsPipelines parameter, VkPolygonMode "
2169 "pCreateInfos->pRasterizationState->polygonMode cannot be VK_POLYGON_MODE_POINT or "
2170 "VK_POLYGON_MODE_LINE if VkPhysicalDeviceFeatures->fillModeNonSolid is false.");
2171 }
2172 } else {
2173 if ((pCreateInfos[i].pRasterizationState->polygonMode != VK_POLYGON_MODE_FILL) &&
2174 (pCreateInfos[i].pRasterizationState->polygonMode != VK_POLYGON_MODE_FILL_RECTANGLE_NV) &&
2175 (physical_device_features.fillModeNonSolid == false)) {
2176 skip |=
2177 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
2178 "VUID-VkPipelineRasterizationStateCreateInfo-polygonMode-01507",
2179 "vkCreateGraphicsPipelines parameter, VkPolygonMode "
2180 "pCreateInfos->pRasterizationState->polygonMode must be VK_POLYGON_MODE_FILL or "
2181 "VK_POLYGON_MODE_FILL_RECTANGLE_NV if VkPhysicalDeviceFeatures->fillModeNonSolid is false.");
2182 }
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002183 }
Petr Kraus299ba622017-11-24 03:09:03 +01002184
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07002185 if (!has_dynamic_line_width && !physical_device_features.wideLines &&
Petr Kraus299ba622017-11-24 03:09:03 +01002186 (pCreateInfos[i].pRasterizationState->lineWidth != 1.0f)) {
Mark Lobodzinskibf599b92018-12-31 12:15:55 -07002187 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, 0,
2188 "VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-00749",
2189 "The line width state is static (pCreateInfos[%" PRIu32
2190 "].pDynamicState->pDynamicStates does not contain VK_DYNAMIC_STATE_LINE_WIDTH) and "
2191 "VkPhysicalDeviceFeatures::wideLines is disabled, but pCreateInfos[%" PRIu32
2192 "].pRasterizationState->lineWidth (=%f) is not 1.0.",
2193 i, i, pCreateInfos[i].pRasterizationState->lineWidth);
Petr Kraus299ba622017-11-24 03:09:03 +01002194 }
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002195 }
2196
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002197 for (size_t j = 0; j < pCreateInfos[i].stageCount; j++) {
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07002198 skip |= validate_string("vkCreateGraphicsPipelines",
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002199 ParameterName("pCreateInfos[%i].pStages[%i].pName", ParameterName::IndexVector{i, j}),
Mark Lobodzinskiebee3552018-05-29 09:55:54 -06002200 "VUID-VkGraphicsPipelineCreateInfo-pStages-parameter", pCreateInfos[i].pStages[j].pName);
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002201 }
2202 }
2203 }
2204
2205 return skip;
2206}
2207
Mark Lobodzinskibf599b92018-12-31 12:15:55 -07002208bool StatelessValidation::manual_PreCallValidateCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache,
2209 uint32_t createInfoCount,
2210 const VkComputePipelineCreateInfo *pCreateInfos,
2211 const VkAllocationCallbacks *pAllocator,
Jeff Bolz5c801d12019-10-09 10:38:45 -05002212 VkPipeline *pPipelines) const {
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002213 bool skip = false;
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002214 for (uint32_t i = 0; i < createInfoCount; i++) {
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07002215 skip |= validate_string("vkCreateComputePipelines",
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002216 ParameterName("pCreateInfos[%i].stage.pName", ParameterName::IndexVector{i}),
Mark Lobodzinskiebee3552018-05-29 09:55:54 -06002217 "VUID-VkPipelineShaderStageCreateInfo-pName-parameter", pCreateInfos[i].stage.pName);
Peter Chen85366392019-05-14 15:20:11 -04002218 auto feedback_struct = lvl_find_in_chain<VkPipelineCreationFeedbackCreateInfoEXT>(pCreateInfos[i].pNext);
2219 if ((feedback_struct != nullptr) && (feedback_struct->pipelineStageCreationFeedbackCount != 1)) {
2220 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, VK_NULL_HANDLE,
2221 "VUID-VkPipelineCreationFeedbackCreateInfoEXT-pipelineStageCreationFeedbackCount-02669",
2222 "vkCreateComputePipelines(): in pCreateInfo[%" PRIu32
2223 "], VkPipelineCreationFeedbackEXT::pipelineStageCreationFeedbackCount must equal 1, found %" PRIu32 ".",
2224 i, feedback_struct->pipelineStageCreationFeedbackCount);
2225 }
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002226 }
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002227 return skip;
2228}
2229
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07002230bool StatelessValidation::manual_PreCallValidateCreateSampler(VkDevice device, const VkSamplerCreateInfo *pCreateInfo,
Jeff Bolz5c801d12019-10-09 10:38:45 -05002231 const VkAllocationCallbacks *pAllocator, VkSampler *pSampler) const {
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002232 bool skip = false;
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002233
2234 if (pCreateInfo != nullptr) {
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07002235 const auto &features = physical_device_features;
2236 const auto &limits = device_limits;
Jesse Hallcc1fbef2018-06-03 15:58:56 -07002237
John Zulauf71968502017-10-26 13:51:15 -06002238 if (pCreateInfo->anisotropyEnable == VK_TRUE) {
2239 if (!in_inclusive_range(pCreateInfo->maxAnisotropy, 1.0F, limits.maxSamplerAnisotropy)) {
Mark Lobodzinskib1fd9d12018-03-30 14:26:00 -06002240 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Dave Houlton413a6782018-05-22 13:01:54 -06002241 "VUID-VkSamplerCreateInfo-anisotropyEnable-01071",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002242 "vkCreateSampler(): value of %s must be in range [1.0, %f] %s, but %f found.",
John Zulauf71968502017-10-26 13:51:15 -06002243 "pCreateInfo->maxAnisotropy", limits.maxSamplerAnisotropy,
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002244 "VkPhysicalDeviceLimits::maxSamplerAnistropy", pCreateInfo->maxAnisotropy);
John Zulauf71968502017-10-26 13:51:15 -06002245 }
2246
2247 // Anistropy cannot be enabled in sampler unless enabled as a feature
2248 if (features.samplerAnisotropy == VK_FALSE) {
Mark Lobodzinskib1fd9d12018-03-30 14:26:00 -06002249 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Dave Houlton413a6782018-05-22 13:01:54 -06002250 "VUID-VkSamplerCreateInfo-anisotropyEnable-01070",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002251 "vkCreateSampler(): Anisotropic sampling feature is not enabled, %s must be VK_FALSE.",
2252 "pCreateInfo->anisotropyEnable");
John Zulauf71968502017-10-26 13:51:15 -06002253 }
Jesse Hallcc1fbef2018-06-03 15:58:56 -07002254 }
John Zulauf71968502017-10-26 13:51:15 -06002255
Jesse Hallcc1fbef2018-06-03 15:58:56 -07002256 if (pCreateInfo->unnormalizedCoordinates == VK_TRUE) {
2257 if (pCreateInfo->minFilter != pCreateInfo->magFilter) {
2258 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
2259 "VUID-VkSamplerCreateInfo-unnormalizedCoordinates-01072",
2260 "vkCreateSampler(): when pCreateInfo->unnormalizedCoordinates is VK_TRUE, "
2261 "pCreateInfo->minFilter (%s) and pCreateInfo->magFilter (%s) must be equal.",
2262 string_VkFilter(pCreateInfo->minFilter), string_VkFilter(pCreateInfo->magFilter));
2263 }
2264 if (pCreateInfo->mipmapMode != VK_SAMPLER_MIPMAP_MODE_NEAREST) {
2265 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
2266 "VUID-VkSamplerCreateInfo-unnormalizedCoordinates-01073",
2267 "vkCreateSampler(): when pCreateInfo->unnormalizedCoordinates is VK_TRUE, "
2268 "pCreateInfo->mipmapMode (%s) must be VK_SAMPLER_MIPMAP_MODE_NEAREST.",
2269 string_VkSamplerMipmapMode(pCreateInfo->mipmapMode));
2270 }
2271 if (pCreateInfo->minLod != 0.0f || pCreateInfo->maxLod != 0.0f) {
2272 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
2273 "VUID-VkSamplerCreateInfo-unnormalizedCoordinates-01074",
2274 "vkCreateSampler(): when pCreateInfo->unnormalizedCoordinates is VK_TRUE, "
2275 "pCreateInfo->minLod (%f) and pCreateInfo->maxLod (%f) must both be zero.",
2276 pCreateInfo->minLod, pCreateInfo->maxLod);
2277 }
2278 if ((pCreateInfo->addressModeU != VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE &&
2279 pCreateInfo->addressModeU != VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER) ||
2280 (pCreateInfo->addressModeV != VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE &&
2281 pCreateInfo->addressModeV != VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER)) {
2282 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
2283 "VUID-VkSamplerCreateInfo-unnormalizedCoordinates-01075",
2284 "vkCreateSampler(): when pCreateInfo->unnormalizedCoordinates is VK_TRUE, "
2285 "pCreateInfo->addressModeU (%s) and pCreateInfo->addressModeV (%s) must both be "
2286 "VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE or VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER.",
2287 string_VkSamplerAddressMode(pCreateInfo->addressModeU),
2288 string_VkSamplerAddressMode(pCreateInfo->addressModeV));
2289 }
2290 if (pCreateInfo->anisotropyEnable == VK_TRUE) {
Mark Lobodzinskib1fd9d12018-03-30 14:26:00 -06002291 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Dave Houlton413a6782018-05-22 13:01:54 -06002292 "VUID-VkSamplerCreateInfo-unnormalizedCoordinates-01076",
Dave Houltona9df0ce2018-02-07 10:51:23 -07002293 "vkCreateSampler(): pCreateInfo->anisotropyEnable and pCreateInfo->unnormalizedCoordinates must "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002294 "not both be VK_TRUE.");
John Zulauf71968502017-10-26 13:51:15 -06002295 }
Jesse Hallcc1fbef2018-06-03 15:58:56 -07002296 if (pCreateInfo->compareEnable == VK_TRUE) {
2297 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
2298 "VUID-VkSamplerCreateInfo-unnormalizedCoordinates-01077",
2299 "vkCreateSampler(): pCreateInfo->compareEnable and pCreateInfo->unnormalizedCoordinates must "
2300 "not both be VK_TRUE.");
2301 }
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002302 }
2303
2304 // If compareEnable is VK_TRUE, compareOp must be a valid VkCompareOp value
2305 if (pCreateInfo->compareEnable == VK_TRUE) {
Mark Lobodzinskibf599b92018-12-31 12:15:55 -07002306 skip |= validate_ranged_enum("vkCreateSampler", "pCreateInfo->compareOp", "VkCompareOp", AllVkCompareOpEnums,
2307 pCreateInfo->compareOp, "VUID-VkSamplerCreateInfo-compareEnable-01080");
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002308 }
2309
2310 // If any of addressModeU, addressModeV or addressModeW are VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER, borderColor must be a
2311 // valid VkBorderColor value
2312 if ((pCreateInfo->addressModeU == VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER) ||
2313 (pCreateInfo->addressModeV == VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER) ||
2314 (pCreateInfo->addressModeW == VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER)) {
Mark Lobodzinskibf599b92018-12-31 12:15:55 -07002315 skip |= validate_ranged_enum("vkCreateSampler", "pCreateInfo->borderColor", "VkBorderColor", AllVkBorderColorEnums,
2316 pCreateInfo->borderColor, "VUID-VkSamplerCreateInfo-addressModeU-01078");
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002317 }
2318
2319 // If any of addressModeU, addressModeV or addressModeW are VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE, the
2320 // VK_KHR_sampler_mirror_clamp_to_edge extension must be enabled
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07002321 if (!device_extensions.vk_khr_sampler_mirror_clamp_to_edge &&
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002322 ((pCreateInfo->addressModeU == VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE) ||
2323 (pCreateInfo->addressModeV == VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE) ||
2324 (pCreateInfo->addressModeW == VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE))) {
Dave Houlton413a6782018-05-22 13:01:54 -06002325 skip |=
2326 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
2327 "VUID-VkSamplerCreateInfo-addressModeU-01079",
2328 "vkCreateSampler(): A VkSamplerAddressMode value is set to VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE "
2329 "but the VK_KHR_sampler_mirror_clamp_to_edge extension has not been enabled.");
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002330 }
John Zulauf275805c2017-10-26 15:34:49 -06002331
2332 // Checks for the IMG cubic filtering extension
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07002333 if (device_extensions.vk_img_filter_cubic) {
John Zulauf275805c2017-10-26 15:34:49 -06002334 if ((pCreateInfo->anisotropyEnable == VK_TRUE) &&
2335 ((pCreateInfo->minFilter == VK_FILTER_CUBIC_IMG) || (pCreateInfo->magFilter == VK_FILTER_CUBIC_IMG))) {
Mark Lobodzinskib1fd9d12018-03-30 14:26:00 -06002336 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Dave Houlton413a6782018-05-22 13:01:54 -06002337 "VUID-VkSamplerCreateInfo-magFilter-01081",
Dave Houltona9df0ce2018-02-07 10:51:23 -07002338 "vkCreateSampler(): Anisotropic sampling must not be VK_TRUE when either minFilter or magFilter "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002339 "are VK_FILTER_CUBIC_IMG.");
John Zulauf275805c2017-10-26 15:34:49 -06002340 }
2341 }
Mark Lobodzinski61992fc2020-01-14 14:00:08 -07002342
2343 const auto *sampler_conversion = lvl_find_in_chain<VkSamplerYcbcrConversionInfo>(pCreateInfo->pNext);
2344 if (sampler_conversion != nullptr) {
2345 if ((pCreateInfo->addressModeU != VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE) ||
2346 (pCreateInfo->addressModeV != VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE) ||
2347 (pCreateInfo->addressModeW != VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE) ||
2348 (pCreateInfo->anisotropyEnable != VK_FALSE) || (pCreateInfo->unnormalizedCoordinates != VK_FALSE)) {
2349 skip |= log_msg(
2350 report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
2351 "VUID-VkSamplerCreateInfo-addressModeU-01646",
2352 "vkCreateSampler(): SamplerYCbCrConversion is enabled: "
2353 "addressModeU (%s), addressModeV (%s), addressModeW (%s) must be CLAMP_TO_EDGE, and anisotropyEnable (%s) "
2354 "and unnormalizedCoordinates (%s) must be VK_FALSE.",
2355 string_VkSamplerAddressMode(pCreateInfo->addressModeU), string_VkSamplerAddressMode(pCreateInfo->addressModeV),
2356 string_VkSamplerAddressMode(pCreateInfo->addressModeW), pCreateInfo->anisotropyEnable ? "VK_TRUE" : "VK_FALSE",
2357 pCreateInfo->unnormalizedCoordinates ? "VK_TRUE" : "VK_FALSE");
2358 }
2359 }
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002360 }
2361
2362 return skip;
2363}
2364
Mark Lobodzinskibf599b92018-12-31 12:15:55 -07002365bool StatelessValidation::manual_PreCallValidateCreateDescriptorSetLayout(VkDevice device,
2366 const VkDescriptorSetLayoutCreateInfo *pCreateInfo,
2367 const VkAllocationCallbacks *pAllocator,
Jeff Bolz5c801d12019-10-09 10:38:45 -05002368 VkDescriptorSetLayout *pSetLayout) const {
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002369 bool skip = false;
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002370
2371 // Validation for parameters excluded from the generated validation code due to a 'noautovalidity' tag in vk.xml
2372 if ((pCreateInfo != nullptr) && (pCreateInfo->pBindings != nullptr)) {
2373 for (uint32_t i = 0; i < pCreateInfo->bindingCount; ++i) {
2374 if (pCreateInfo->pBindings[i].descriptorCount != 0) {
2375 // If descriptorType is VK_DESCRIPTOR_TYPE_SAMPLER or VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, and descriptorCount
2376 // is not 0 and pImmutableSamplers is not NULL, pImmutableSamplers must be a pointer to an array of descriptorCount
2377 // valid VkSampler handles
2378 if (((pCreateInfo->pBindings[i].descriptorType == VK_DESCRIPTOR_TYPE_SAMPLER) ||
2379 (pCreateInfo->pBindings[i].descriptorType == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER)) &&
2380 (pCreateInfo->pBindings[i].pImmutableSamplers != nullptr)) {
2381 for (uint32_t descriptor_index = 0; descriptor_index < pCreateInfo->pBindings[i].descriptorCount;
2382 ++descriptor_index) {
2383 if (pCreateInfo->pBindings[i].pImmutableSamplers[descriptor_index] == VK_NULL_HANDLE) {
2384 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Dave Houlton413a6782018-05-22 13:01:54 -06002385 kVUID_PVError_RequiredParameter,
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002386 "vkCreateDescriptorSetLayout: required parameter "
Dave Houltona9df0ce2018-02-07 10:51:23 -07002387 "pCreateInfo->pBindings[%d].pImmutableSamplers[%d] specified as VK_NULL_HANDLE",
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002388 i, descriptor_index);
2389 }
2390 }
2391 }
2392
2393 // If descriptorCount is not 0, stageFlags must be a valid combination of VkShaderStageFlagBits values
2394 if ((pCreateInfo->pBindings[i].stageFlags != 0) &&
2395 ((pCreateInfo->pBindings[i].stageFlags & (~AllVkShaderStageFlagBits)) != 0)) {
Dave Houltona9df0ce2018-02-07 10:51:23 -07002396 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Dave Houlton413a6782018-05-22 13:01:54 -06002397 "VUID-VkDescriptorSetLayoutBinding-descriptorCount-00283",
Dave Houltona9df0ce2018-02-07 10:51:23 -07002398 "vkCreateDescriptorSetLayout(): if pCreateInfo->pBindings[%d].descriptorCount is not 0, "
2399 "pCreateInfo->pBindings[%d].stageFlags must be a valid combination of VkShaderStageFlagBits "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002400 "values.",
2401 i, i);
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002402 }
2403 }
2404 }
2405 }
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002406 return skip;
2407}
2408
Mark Lobodzinskibf599b92018-12-31 12:15:55 -07002409bool StatelessValidation::manual_PreCallValidateFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool,
2410 uint32_t descriptorSetCount,
Jeff Bolz5c801d12019-10-09 10:38:45 -05002411 const VkDescriptorSet *pDescriptorSets) const {
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002412 // Validation for parameters excluded from the generated validation code due to a 'noautovalidity' tag in vk.xml
2413 // This is an array of handles, where the elements are allowed to be VK_NULL_HANDLE, and does not require any validation beyond
2414 // validate_array()
Mark Lobodzinskibf599b92018-12-31 12:15:55 -07002415 return validate_array("vkFreeDescriptorSets", "descriptorSetCount", "pDescriptorSets", descriptorSetCount, &pDescriptorSets,
2416 true, true, kVUIDUndefined, kVUIDUndefined);
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002417}
2418
Jeremy Hayes390ff6f2020-02-10 13:48:57 -07002419bool StatelessValidation::validate_WriteDescriptorSet(const char *vkCallingFunction, const uint32_t descriptorWriteCount,
2420 const VkWriteDescriptorSet *pDescriptorWrites,
2421 const bool validateDstSet) const {
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002422 bool skip = false;
Jeremy Hayes390ff6f2020-02-10 13:48:57 -07002423
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002424 if (pDescriptorWrites != NULL) {
2425 for (uint32_t i = 0; i < descriptorWriteCount; ++i) {
2426 // descriptorCount must be greater than 0
2427 if (pDescriptorWrites[i].descriptorCount == 0) {
2428 skip |=
Mark Lobodzinskib1fd9d12018-03-30 14:26:00 -06002429 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Dave Houlton413a6782018-05-22 13:01:54 -06002430 "VUID-VkWriteDescriptorSet-descriptorCount-arraylength",
Jeremy Hayes390ff6f2020-02-10 13:48:57 -07002431 "%s(): parameter pDescriptorWrites[%d].descriptorCount must be greater than 0.", vkCallingFunction, i);
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002432 }
2433
Jeremy Hayes390ff6f2020-02-10 13:48:57 -07002434 // If called from vkCmdPushDescriptorSetKHR, the dstSet member is ignored.
2435 if (validateDstSet) {
2436 // dstSet must be a valid VkDescriptorSet handle
2437 skip |= validate_required_handle(vkCallingFunction,
2438 ParameterName("pDescriptorWrites[%i].dstSet", ParameterName::IndexVector{i}),
2439 pDescriptorWrites[i].dstSet);
2440 }
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002441
2442 if ((pDescriptorWrites[i].descriptorType == VK_DESCRIPTOR_TYPE_SAMPLER) ||
2443 (pDescriptorWrites[i].descriptorType == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER) ||
2444 (pDescriptorWrites[i].descriptorType == VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE) ||
2445 (pDescriptorWrites[i].descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_IMAGE) ||
2446 (pDescriptorWrites[i].descriptorType == VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT)) {
2447 // If descriptorType is VK_DESCRIPTOR_TYPE_SAMPLER, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
2448 // VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE or VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT,
2449 // pImageInfo must be a pointer to an array of descriptorCount valid VkDescriptorImageInfo structures
2450 if (pDescriptorWrites[i].pImageInfo == nullptr) {
2451 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Dave Houlton413a6782018-05-22 13:01:54 -06002452 "VUID-VkWriteDescriptorSet-descriptorType-00322",
Jeremy Hayes390ff6f2020-02-10 13:48:57 -07002453 "%s(): if pDescriptorWrites[%d].descriptorType is "
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002454 "VK_DESCRIPTOR_TYPE_SAMPLER, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, "
2455 "VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE or "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002456 "VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, pDescriptorWrites[%d].pImageInfo must not be NULL.",
Jeremy Hayes390ff6f2020-02-10 13:48:57 -07002457 vkCallingFunction, i, i);
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002458 } else if (pDescriptorWrites[i].descriptorType != VK_DESCRIPTOR_TYPE_SAMPLER) {
2459 // If descriptorType is VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
2460 // VK_DESCRIPTOR_TYPE_STORAGE_IMAGE or VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, the imageView and imageLayout
2461 // members of any given element of pImageInfo must be a valid VkImageView and VkImageLayout, respectively
2462 for (uint32_t descriptor_index = 0; descriptor_index < pDescriptorWrites[i].descriptorCount;
2463 ++descriptor_index) {
Jeremy Hayes390ff6f2020-02-10 13:48:57 -07002464 skip |= validate_required_handle(vkCallingFunction,
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002465 ParameterName("pDescriptorWrites[%i].pImageInfo[%i].imageView",
2466 ParameterName::IndexVector{i, descriptor_index}),
2467 pDescriptorWrites[i].pImageInfo[descriptor_index].imageView);
Jeremy Hayes390ff6f2020-02-10 13:48:57 -07002468 skip |= validate_ranged_enum(vkCallingFunction,
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002469 ParameterName("pDescriptorWrites[%i].pImageInfo[%i].imageLayout",
2470 ParameterName::IndexVector{i, descriptor_index}),
2471 "VkImageLayout", AllVkImageLayoutEnums,
Dave Houlton413a6782018-05-22 13:01:54 -06002472 pDescriptorWrites[i].pImageInfo[descriptor_index].imageLayout, kVUIDUndefined);
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002473 }
2474 }
2475 } else if ((pDescriptorWrites[i].descriptorType == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER) ||
2476 (pDescriptorWrites[i].descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER) ||
2477 (pDescriptorWrites[i].descriptorType == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC) ||
2478 (pDescriptorWrites[i].descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC)) {
2479 // If descriptorType is VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
2480 // VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, pBufferInfo must be a
2481 // pointer to an array of descriptorCount valid VkDescriptorBufferInfo structures
2482 if (pDescriptorWrites[i].pBufferInfo == nullptr) {
2483 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Dave Houlton413a6782018-05-22 13:01:54 -06002484 "VUID-VkWriteDescriptorSet-descriptorType-00324",
Jeremy Hayes390ff6f2020-02-10 13:48:57 -07002485 "%s(): if pDescriptorWrites[%d].descriptorType is "
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002486 "VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, "
2487 "VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002488 "pDescriptorWrites[%d].pBufferInfo must not be NULL.",
Jeremy Hayes390ff6f2020-02-10 13:48:57 -07002489 vkCallingFunction, i, i);
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002490 } else {
2491 for (uint32_t descriptorIndex = 0; descriptorIndex < pDescriptorWrites[i].descriptorCount; ++descriptorIndex) {
Jeremy Hayes390ff6f2020-02-10 13:48:57 -07002492 skip |= validate_required_handle(vkCallingFunction,
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002493 ParameterName("pDescriptorWrites[%i].pBufferInfo[%i].buffer",
2494 ParameterName::IndexVector{i, descriptorIndex}),
2495 pDescriptorWrites[i].pBufferInfo[descriptorIndex].buffer);
2496 }
2497 }
2498 } else if ((pDescriptorWrites[i].descriptorType == VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER) ||
2499 (pDescriptorWrites[i].descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER)) {
2500 // If descriptorType is VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER or VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER,
2501 // pTexelBufferView must be a pointer to an array of descriptorCount valid VkBufferView handles
2502 if (pDescriptorWrites[i].pTexelBufferView == nullptr) {
2503 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Dave Houlton413a6782018-05-22 13:01:54 -06002504 "VUID-VkWriteDescriptorSet-descriptorType-00323",
Jeremy Hayes390ff6f2020-02-10 13:48:57 -07002505 "%s(): if pDescriptorWrites[%d].descriptorType is "
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002506 "VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER or VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002507 "pDescriptorWrites[%d].pTexelBufferView must not be NULL.",
Jeremy Hayes390ff6f2020-02-10 13:48:57 -07002508 vkCallingFunction, i, i);
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002509 } else {
2510 for (uint32_t descriptor_index = 0; descriptor_index < pDescriptorWrites[i].descriptorCount;
2511 ++descriptor_index) {
Jeremy Hayes390ff6f2020-02-10 13:48:57 -07002512 skip |= validate_required_handle(vkCallingFunction,
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002513 ParameterName("pDescriptorWrites[%i].pTexelBufferView[%i]",
2514 ParameterName::IndexVector{i, descriptor_index}),
2515 pDescriptorWrites[i].pTexelBufferView[descriptor_index]);
2516 }
2517 }
2518 }
2519
2520 if ((pDescriptorWrites[i].descriptorType == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER) ||
2521 (pDescriptorWrites[i].descriptorType == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC)) {
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07002522 VkDeviceSize uniformAlignment = device_limits.minUniformBufferOffsetAlignment;
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002523 for (uint32_t j = 0; j < pDescriptorWrites[i].descriptorCount; j++) {
2524 if (pDescriptorWrites[i].pBufferInfo != NULL) {
2525 if (SafeModulo(pDescriptorWrites[i].pBufferInfo[j].offset, uniformAlignment) != 0) {
Mark Lobodzinski88529492018-04-01 10:38:15 -06002526 skip |=
Mark Lobodzinskibf599b92018-12-31 12:15:55 -07002527 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT,
2528 0, "VUID-VkWriteDescriptorSet-descriptorType-00327",
Jeremy Hayes390ff6f2020-02-10 13:48:57 -07002529 "%s(): pDescriptorWrites[%d].pBufferInfo[%d].offset (0x%" PRIxLEAST64
Mark Lobodzinski88529492018-04-01 10:38:15 -06002530 ") must be a multiple of device limit minUniformBufferOffsetAlignment 0x%" PRIxLEAST64 ".",
Jeremy Hayes390ff6f2020-02-10 13:48:57 -07002531 vkCallingFunction, i, j, pDescriptorWrites[i].pBufferInfo[j].offset, uniformAlignment);
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002532 }
2533 }
2534 }
2535 } else if ((pDescriptorWrites[i].descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER) ||
2536 (pDescriptorWrites[i].descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC)) {
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07002537 VkDeviceSize storageAlignment = device_limits.minStorageBufferOffsetAlignment;
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002538 for (uint32_t j = 0; j < pDescriptorWrites[i].descriptorCount; j++) {
2539 if (pDescriptorWrites[i].pBufferInfo != NULL) {
2540 if (SafeModulo(pDescriptorWrites[i].pBufferInfo[j].offset, storageAlignment) != 0) {
Mark Lobodzinski88529492018-04-01 10:38:15 -06002541 skip |=
Mark Lobodzinskibf599b92018-12-31 12:15:55 -07002542 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT,
2543 0, "VUID-VkWriteDescriptorSet-descriptorType-00328",
Jeremy Hayes390ff6f2020-02-10 13:48:57 -07002544 "%s(): pDescriptorWrites[%d].pBufferInfo[%d].offset (0x%" PRIxLEAST64
Mark Lobodzinski88529492018-04-01 10:38:15 -06002545 ") must be a multiple of device limit minStorageBufferOffsetAlignment 0x%" PRIxLEAST64 ".",
Jeremy Hayes390ff6f2020-02-10 13:48:57 -07002546 vkCallingFunction, i, j, pDescriptorWrites[i].pBufferInfo[j].offset, storageAlignment);
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002547 }
2548 }
2549 }
2550 }
2551 }
2552 }
Jeremy Hayes390ff6f2020-02-10 13:48:57 -07002553
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002554 return skip;
2555}
2556
Jeremy Hayes390ff6f2020-02-10 13:48:57 -07002557bool StatelessValidation::manual_PreCallValidateUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount,
2558 const VkWriteDescriptorSet *pDescriptorWrites,
2559 uint32_t descriptorCopyCount,
2560 const VkCopyDescriptorSet *pDescriptorCopies) const {
2561 return validate_WriteDescriptorSet("vkUpdateDescriptorSets", descriptorWriteCount, pDescriptorWrites);
2562}
2563
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07002564bool StatelessValidation::manual_PreCallValidateCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo *pCreateInfo,
Mark Lobodzinskibf599b92018-12-31 12:15:55 -07002565 const VkAllocationCallbacks *pAllocator,
Jeff Bolz5c801d12019-10-09 10:38:45 -05002566 VkRenderPass *pRenderPass) const {
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07002567 return CreateRenderPassGeneric(device, pCreateInfo, pAllocator, pRenderPass, RENDER_PASS_VERSION_1);
2568}
2569
2570bool StatelessValidation::manual_PreCallValidateCreateRenderPass2KHR(VkDevice device, const VkRenderPassCreateInfo2KHR *pCreateInfo,
Mark Lobodzinskibf599b92018-12-31 12:15:55 -07002571 const VkAllocationCallbacks *pAllocator,
Jeff Bolz5c801d12019-10-09 10:38:45 -05002572 VkRenderPass *pRenderPass) const {
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07002573 return CreateRenderPassGeneric(device, pCreateInfo, pAllocator, pRenderPass, RENDER_PASS_VERSION_2);
2574}
2575
Mark Lobodzinskibf599b92018-12-31 12:15:55 -07002576bool StatelessValidation::manual_PreCallValidateFreeCommandBuffers(VkDevice device, VkCommandPool commandPool,
2577 uint32_t commandBufferCount,
Jeff Bolz5c801d12019-10-09 10:38:45 -05002578 const VkCommandBuffer *pCommandBuffers) const {
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002579 bool skip = false;
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002580
2581 // Validation for parameters excluded from the generated validation code due to a 'noautovalidity' tag in vk.xml
2582 // This is an array of handles, where the elements are allowed to be VK_NULL_HANDLE, and does not require any validation beyond
2583 // validate_array()
Mark Lobodzinskibf599b92018-12-31 12:15:55 -07002584 skip |= validate_array("vkFreeCommandBuffers", "commandBufferCount", "pCommandBuffers", commandBufferCount, &pCommandBuffers,
2585 true, true, kVUIDUndefined, kVUIDUndefined);
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002586 return skip;
2587}
2588
Mark Lobodzinskibf599b92018-12-31 12:15:55 -07002589bool StatelessValidation::manual_PreCallValidateBeginCommandBuffer(VkCommandBuffer commandBuffer,
Jeff Bolz5c801d12019-10-09 10:38:45 -05002590 const VkCommandBufferBeginInfo *pBeginInfo) const {
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002591 bool skip = false;
Petr Krause7bb9e82019-08-11 21:34:43 +02002592
2593 // VkCommandBufferInheritanceInfo validation, due to a 'noautovalidity' of pBeginInfo->pInheritanceInfo in vkBeginCommandBuffer
2594 const char *cmd_name = "vkBeginCommandBuffer";
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002595 const VkCommandBufferInheritanceInfo *pInfo = pBeginInfo->pInheritanceInfo;
2596
Petr Krause7bb9e82019-08-11 21:34:43 +02002597 // Implicit VUs
2598 // validate only sType here; pointer has to be validated in core_validation
2599 const bool kNotRequired = false;
2600 const char *kNoVUID = nullptr;
2601 skip |= validate_struct_type(cmd_name, "pBeginInfo->pInheritanceInfo", "VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO",
2602 pInfo, VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO, kNotRequired, kNoVUID,
2603 "VUID-VkCommandBufferInheritanceInfo-sType-sType");
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002604
Petr Krause7bb9e82019-08-11 21:34:43 +02002605 if (pInfo) {
2606 const VkStructureType allowed_structs_VkCommandBufferInheritanceInfo[] = {
2607 VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT};
2608 skip |= validate_struct_pnext(
2609 cmd_name, "pBeginInfo->pInheritanceInfo->pNext", "VkCommandBufferInheritanceConditionalRenderingInfoEXT", pInfo->pNext,
2610 ARRAY_SIZE(allowed_structs_VkCommandBufferInheritanceInfo), allowed_structs_VkCommandBufferInheritanceInfo,
2611 GeneratedVulkanHeaderVersion, "VUID-VkCommandBufferInheritanceInfo-pNext-pNext");
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002612
Petr Krause7bb9e82019-08-11 21:34:43 +02002613 skip |= validate_bool32(cmd_name, "pBeginInfo->pInheritanceInfo->occlusionQueryEnable", pInfo->occlusionQueryEnable);
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002614
Petr Krause7bb9e82019-08-11 21:34:43 +02002615 // Explicit VUs
2616 if (!physical_device_features.inheritedQueries && pInfo->occlusionQueryEnable == VK_TRUE) {
2617 skip |= log_msg(
2618 report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
2619 HandleToUint64(commandBuffer), "VUID-VkCommandBufferInheritanceInfo-occlusionQueryEnable-00056",
2620 "%s: Inherited queries feature is disabled, but pBeginInfo->pInheritanceInfo->occlusionQueryEnable is VK_TRUE.",
2621 cmd_name);
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002622 }
Petr Krause7bb9e82019-08-11 21:34:43 +02002623
2624 if (physical_device_features.inheritedQueries) {
2625 skip |= validate_flags(cmd_name, "pBeginInfo->pInheritanceInfo->queryFlags", "VkQueryControlFlagBits",
Petr Kraus52758be2019-08-12 00:53:58 +02002626 AllVkQueryControlFlagBits, pInfo->queryFlags, kOptionalFlags,
Dave Houlton413a6782018-05-22 13:01:54 -06002627 "VUID-VkCommandBufferInheritanceInfo-queryFlags-00057");
Petr Krause7bb9e82019-08-11 21:34:43 +02002628 } else { // !inheritedQueries
Petr Krause7bb9e82019-08-11 21:34:43 +02002629 skip |= validate_reserved_flags(cmd_name, "pBeginInfo->pInheritanceInfo->queryFlags", pInfo->queryFlags,
Petr Kraus43aed2c2019-08-18 13:59:16 +02002630 "VUID-VkCommandBufferInheritanceInfo-queryFlags-02788");
Petr Krause7bb9e82019-08-11 21:34:43 +02002631 }
2632
2633 if (physical_device_features.pipelineStatisticsQuery) {
Petr Krause7bb9e82019-08-11 21:34:43 +02002634 skip |= validate_flags(cmd_name, "pBeginInfo->pInheritanceInfo->pipelineStatistics", "VkQueryPipelineStatisticFlagBits",
Petr Kraus52758be2019-08-12 00:53:58 +02002635 AllVkQueryPipelineStatisticFlagBits, pInfo->pipelineStatistics, kOptionalFlags,
Petr Kraus43aed2c2019-08-18 13:59:16 +02002636 "VUID-VkCommandBufferInheritanceInfo-pipelineStatistics-02789");
Petr Krause7bb9e82019-08-11 21:34:43 +02002637 } else { // !pipelineStatisticsQuery
2638 skip |= validate_reserved_flags(cmd_name, "pBeginInfo->pInheritanceInfo->pipelineStatistics", pInfo->pipelineStatistics,
2639 "VUID-VkCommandBufferInheritanceInfo-pipelineStatistics-00058");
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002640 }
Petr Kraus139757b2019-08-15 17:19:33 +02002641
2642 const auto *conditional_rendering = lvl_find_in_chain<VkCommandBufferInheritanceConditionalRenderingInfoEXT>(pInfo->pNext);
2643 if (conditional_rendering) {
Tony-LunarG6c3c5452019-12-13 10:37:38 -07002644 const auto *cr_features = lvl_find_in_chain<VkPhysicalDeviceConditionalRenderingFeaturesEXT>(device_createinfo_pnext);
Petr Kraus139757b2019-08-15 17:19:33 +02002645 const auto inherited_conditional_rendering = cr_features && cr_features->inheritedConditionalRendering;
2646 if (!inherited_conditional_rendering && conditional_rendering->conditionalRenderingEnable == VK_TRUE) {
2647 skip |= log_msg(
2648 report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
2649 HandleToUint64(commandBuffer),
2650 "VUID-VkCommandBufferInheritanceConditionalRenderingInfoEXT-conditionalRenderingEnable-01977",
2651 "vkBeginCommandBuffer: Inherited conditional rendering is disabled, but "
2652 "pBeginInfo->pInheritanceInfo->pNext<VkCommandBufferInheritanceConditionalRenderingInfoEXT> is VK_TRUE.");
2653 }
2654 }
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002655 }
2656
2657 return skip;
2658}
2659
Mark Lobodzinskibf599b92018-12-31 12:15:55 -07002660bool StatelessValidation::manual_PreCallValidateCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport,
Jeff Bolz5c801d12019-10-09 10:38:45 -05002661 uint32_t viewportCount, const VkViewport *pViewports) const {
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002662 bool skip = false;
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002663
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07002664 if (!physical_device_features.multiViewport) {
Petr Krausd55e77c2018-01-09 22:09:25 +01002665 if (firstViewport != 0) {
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07002666 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Dave Houlton413a6782018-05-22 13:01:54 -06002667 HandleToUint64(commandBuffer), "VUID-vkCmdSetViewport-firstViewport-01224",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002668 "vkCmdSetViewport: The multiViewport feature is disabled, but firstViewport (=%" PRIu32 ") is not 0.",
2669 firstViewport);
Petr Krausd55e77c2018-01-09 22:09:25 +01002670 }
2671 if (viewportCount > 1) {
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07002672 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Dave Houlton413a6782018-05-22 13:01:54 -06002673 HandleToUint64(commandBuffer), "VUID-vkCmdSetViewport-viewportCount-01225",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002674 "vkCmdSetViewport: The multiViewport feature is disabled, but viewportCount (=%" PRIu32 ") is not 1.",
2675 viewportCount);
Petr Krausd55e77c2018-01-09 22:09:25 +01002676 }
2677 } else { // multiViewport enabled
Petr Kraus7dfeed12018-02-27 20:51:20 +01002678 const uint64_t sum = static_cast<uint64_t>(firstViewport) + static_cast<uint64_t>(viewportCount);
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07002679 if (sum > device_limits.maxViewports) {
2680 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Dave Houlton413a6782018-05-22 13:01:54 -06002681 HandleToUint64(commandBuffer), "VUID-vkCmdSetViewport-firstViewport-01223",
Petr Krausd55e77c2018-01-09 22:09:25 +01002682 "vkCmdSetViewport: firstViewport + viewportCount (=%" PRIu32 " + %" PRIu32 " = %" PRIu64
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002683 ") is greater than VkPhysicalDeviceLimits::maxViewports (=%" PRIu32 ").",
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07002684 firstViewport, viewportCount, sum, device_limits.maxViewports);
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002685 }
2686 }
Petr Krausb3fcdb42018-01-09 22:09:09 +01002687
2688 if (pViewports) {
2689 for (uint32_t viewport_i = 0; viewport_i < viewportCount; ++viewport_i) {
2690 const auto &viewport = pViewports[viewport_i]; // will crash on invalid ptr
Jeff Bolz6d3beaa2019-02-09 21:00:05 -06002691 const char *fn_name = "vkCmdSetViewport";
2692 skip |= manual_PreCallValidateViewport(viewport, fn_name,
2693 ParameterName("pViewports[%i]", ParameterName::IndexVector{viewport_i}),
Mark Lobodzinskibf599b92018-12-31 12:15:55 -07002694 VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, HandleToUint64(commandBuffer));
Petr Krausb3fcdb42018-01-09 22:09:09 +01002695 }
2696 }
2697
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002698 return skip;
2699}
2700
Mark Lobodzinskibf599b92018-12-31 12:15:55 -07002701bool StatelessValidation::manual_PreCallValidateCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor,
Jeff Bolz5c801d12019-10-09 10:38:45 -05002702 uint32_t scissorCount, const VkRect2D *pScissors) const {
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002703 bool skip = false;
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002704
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07002705 if (!physical_device_features.multiViewport) {
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002706 if (firstScissor != 0) {
Petr Kraus6260f0a2018-02-27 21:15:55 +01002707 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Dave Houlton413a6782018-05-22 13:01:54 -06002708 HandleToUint64(commandBuffer), "VUID-vkCmdSetScissor-firstScissor-00593",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002709 "vkCmdSetScissor: The multiViewport feature is disabled, but firstScissor (=%" PRIu32 ") is not 0.",
2710 firstScissor);
Petr Kraus6260f0a2018-02-27 21:15:55 +01002711 }
2712 if (scissorCount > 1) {
2713 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Dave Houlton413a6782018-05-22 13:01:54 -06002714 HandleToUint64(commandBuffer), "VUID-vkCmdSetScissor-scissorCount-00594",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002715 "vkCmdSetScissor: The multiViewport feature is disabled, but scissorCount (=%" PRIu32 ") is not 1.",
2716 scissorCount);
Petr Kraus6260f0a2018-02-27 21:15:55 +01002717 }
2718 } else { // multiViewport enabled
2719 const uint64_t sum = static_cast<uint64_t>(firstScissor) + static_cast<uint64_t>(scissorCount);
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07002720 if (sum > device_limits.maxViewports) {
2721 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Dave Houlton413a6782018-05-22 13:01:54 -06002722 HandleToUint64(commandBuffer), "VUID-vkCmdSetScissor-firstScissor-00592",
Petr Kraus6260f0a2018-02-27 21:15:55 +01002723 "vkCmdSetScissor: firstScissor + scissorCount (=%" PRIu32 " + %" PRIu32 " = %" PRIu64
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002724 ") is greater than VkPhysicalDeviceLimits::maxViewports (=%" PRIu32 ").",
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07002725 firstScissor, scissorCount, sum, device_limits.maxViewports);
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002726 }
2727 }
2728
Petr Kraus6260f0a2018-02-27 21:15:55 +01002729 if (pScissors) {
2730 for (uint32_t scissor_i = 0; scissor_i < scissorCount; ++scissor_i) {
2731 const auto &scissor = pScissors[scissor_i]; // will crash on invalid ptr
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002732
Petr Kraus6260f0a2018-02-27 21:15:55 +01002733 if (scissor.offset.x < 0) {
2734 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Dave Houlton413a6782018-05-22 13:01:54 -06002735 HandleToUint64(commandBuffer), "VUID-vkCmdSetScissor-x-00595",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002736 "vkCmdSetScissor: pScissors[%" PRIu32 "].offset.x (=%" PRIi32 ") is negative.", scissor_i,
2737 scissor.offset.x);
Petr Kraus6260f0a2018-02-27 21:15:55 +01002738 }
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002739
Petr Kraus6260f0a2018-02-27 21:15:55 +01002740 if (scissor.offset.y < 0) {
2741 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Dave Houlton413a6782018-05-22 13:01:54 -06002742 HandleToUint64(commandBuffer), "VUID-vkCmdSetScissor-x-00595",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002743 "vkCmdSetScissor: pScissors[%" PRIu32 "].offset.y (=%" PRIi32 ") is negative.", scissor_i,
2744 scissor.offset.y);
Petr Kraus6260f0a2018-02-27 21:15:55 +01002745 }
2746
2747 const int64_t x_sum = static_cast<int64_t>(scissor.offset.x) + static_cast<int64_t>(scissor.extent.width);
2748 if (x_sum > INT32_MAX) {
2749 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Dave Houlton413a6782018-05-22 13:01:54 -06002750 HandleToUint64(commandBuffer), "VUID-vkCmdSetScissor-offset-00596",
Petr Kraus6260f0a2018-02-27 21:15:55 +01002751 "vkCmdSetScissor: offset.x + extent.width (=%" PRIi32 " + %" PRIu32 " = %" PRIi64
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002752 ") of pScissors[%" PRIu32 "] will overflow int32_t.",
2753 scissor.offset.x, scissor.extent.width, x_sum, scissor_i);
Petr Kraus6260f0a2018-02-27 21:15:55 +01002754 }
2755
2756 const int64_t y_sum = static_cast<int64_t>(scissor.offset.y) + static_cast<int64_t>(scissor.extent.height);
2757 if (y_sum > INT32_MAX) {
2758 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Dave Houlton413a6782018-05-22 13:01:54 -06002759 HandleToUint64(commandBuffer), "VUID-vkCmdSetScissor-offset-00597",
Petr Kraus6260f0a2018-02-27 21:15:55 +01002760 "vkCmdSetScissor: offset.y + extent.height (=%" PRIi32 " + %" PRIu32 " = %" PRIi64
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002761 ") of pScissors[%" PRIu32 "] will overflow int32_t.",
2762 scissor.offset.y, scissor.extent.height, y_sum, scissor_i);
Petr Kraus6260f0a2018-02-27 21:15:55 +01002763 }
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002764 }
2765 }
Petr Kraus6260f0a2018-02-27 21:15:55 +01002766
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002767 return skip;
2768}
2769
Jeff Bolz5c801d12019-10-09 10:38:45 -05002770bool StatelessValidation::manual_PreCallValidateCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth) const {
Petr Kraus299ba622017-11-24 03:09:03 +01002771 bool skip = false;
Petr Kraus299ba622017-11-24 03:09:03 +01002772
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07002773 if (!physical_device_features.wideLines && (lineWidth != 1.0f)) {
Petr Kraus299ba622017-11-24 03:09:03 +01002774 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Dave Houlton413a6782018-05-22 13:01:54 -06002775 HandleToUint64(commandBuffer), "VUID-vkCmdSetLineWidth-lineWidth-00788",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002776 "VkPhysicalDeviceFeatures::wideLines is disabled, but lineWidth (=%f) is not 1.0.", lineWidth);
Petr Kraus299ba622017-11-24 03:09:03 +01002777 }
2778
2779 return skip;
2780}
2781
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07002782bool StatelessValidation::manual_PreCallValidateCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount,
Jeff Bolz5c801d12019-10-09 10:38:45 -05002783 uint32_t firstVertex, uint32_t firstInstance) const {
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002784 bool skip = false;
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002785 if (vertexCount == 0) {
2786 // TODO: Verify against Valid Usage section. I don't see a non-zero vertexCount listed, may need to add that and make
2787 // this an error or leave as is.
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07002788 skip |= log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Dave Houlton413a6782018-05-22 13:01:54 -06002789 kVUID_PVError_RequiredParameter, "vkCmdDraw parameter, uint32_t vertexCount, is 0");
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002790 }
2791
2792 if (instanceCount == 0) {
2793 // TODO: Verify against Valid Usage section. I don't see a non-zero instanceCount listed, may need to add that and make
2794 // this an error or leave as is.
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07002795 skip |= log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Dave Houlton413a6782018-05-22 13:01:54 -06002796 kVUID_PVError_RequiredParameter, "vkCmdDraw parameter, uint32_t instanceCount, is 0");
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002797 }
2798 return skip;
2799}
2800
Mark Lobodzinskibf599b92018-12-31 12:15:55 -07002801bool StatelessValidation::manual_PreCallValidateCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
Jeff Bolz5c801d12019-10-09 10:38:45 -05002802 uint32_t count, uint32_t stride) const {
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002803 bool skip = false;
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002804
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07002805 if (!physical_device_features.multiDrawIndirect && ((count > 1))) {
2806 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Dave Houlton413a6782018-05-22 13:01:54 -06002807 kVUID_PVError_DeviceFeature,
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002808 "CmdDrawIndirect(): Device feature multiDrawIndirect disabled: count must be 0 or 1 but is %d", count);
2809 }
2810 return skip;
2811}
2812
Mark Lobodzinskibf599b92018-12-31 12:15:55 -07002813bool StatelessValidation::manual_PreCallValidateCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer,
Jeff Bolz5c801d12019-10-09 10:38:45 -05002814 VkDeviceSize offset, uint32_t count, uint32_t stride) const {
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002815 bool skip = false;
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07002816 if (!physical_device_features.multiDrawIndirect && ((count > 1))) {
Mark Lobodzinskibf599b92018-12-31 12:15:55 -07002817 skip |= log_msg(
2818 report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, kVUID_PVError_DeviceFeature,
2819 "CmdDrawIndexedIndirect(): Device feature multiDrawIndirect disabled: count must be 0 or 1 but is %d", count);
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002820 }
2821 return skip;
2822}
2823
Mark Lobodzinskif77a4ac2019-06-27 15:30:51 -06002824bool StatelessValidation::manual_PreCallValidateCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount,
2825 const VkClearAttachment *pAttachments, uint32_t rectCount,
Jeff Bolz5c801d12019-10-09 10:38:45 -05002826 const VkClearRect *pRects) const {
Mark Lobodzinskif77a4ac2019-06-27 15:30:51 -06002827 bool skip = false;
2828 for (uint32_t rect = 0; rect < rectCount; rect++) {
2829 if (pRects[rect].layerCount == 0) {
2830 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
2831 HandleToUint64(commandBuffer), "VUID-vkCmdClearAttachments-layerCount-01934",
2832 "CmdClearAttachments(): pRects[%d].layerCount is zero.", rect);
2833 }
2834 }
2835 return skip;
2836}
2837
Andrew Fobel3abeb992020-01-20 16:33:22 -05002838bool StatelessValidation::ValidateGetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice,
2839 const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo,
2840 VkImageFormatProperties2 *pImageFormatProperties,
2841 const char *apiName) const {
2842 bool skip = false;
2843
2844 if (pImageFormatInfo != nullptr) {
2845 const auto image_stencil_struct = lvl_find_in_chain<VkImageStencilUsageCreateInfoEXT>(pImageFormatInfo->pNext);
2846 if (image_stencil_struct != nullptr) {
2847 if ((image_stencil_struct->stencilUsage & VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT) != 0) {
2848 VkImageUsageFlags legal_flags = (VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT);
2849 // No flags other than the legal attachment bits may be set
2850 legal_flags |= VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT;
2851 if ((image_stencil_struct->stencilUsage & ~legal_flags) != 0) {
2852 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, 0,
2853 "VUID-VkImageStencilUsageCreateInfo-stencilUsage-02539",
2854 "%s(): in pNext chain, VkImageStencilUsageCreateInfo::stencilUsage "
2855 "includes VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT, it must not include bits other than "
2856 "VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT",
2857 apiName);
2858 }
2859 }
2860 }
2861 }
2862
2863 return skip;
2864}
2865
2866bool StatelessValidation::manual_PreCallValidateGetPhysicalDeviceImageFormatProperties2(
2867 VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo,
2868 VkImageFormatProperties2 *pImageFormatProperties) const {
2869 return ValidateGetPhysicalDeviceImageFormatProperties2(physicalDevice, pImageFormatInfo, pImageFormatProperties,
2870 "vkGetPhysicalDeviceImageFormatProperties2");
2871}
2872
2873bool StatelessValidation::manual_PreCallValidateGetPhysicalDeviceImageFormatProperties2KHR(
2874 VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo,
2875 VkImageFormatProperties2 *pImageFormatProperties) const {
2876 return ValidateGetPhysicalDeviceImageFormatProperties2(physicalDevice, pImageFormatInfo, pImageFormatProperties,
2877 "vkGetPhysicalDeviceImageFormatProperties2KHR");
2878}
2879
Mark Lobodzinskibf599b92018-12-31 12:15:55 -07002880bool StatelessValidation::manual_PreCallValidateCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage,
2881 VkImageLayout srcImageLayout, VkImage dstImage,
2882 VkImageLayout dstImageLayout, uint32_t regionCount,
Jeff Bolz5c801d12019-10-09 10:38:45 -05002883 const VkImageCopy *pRegions) const {
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002884 bool skip = false;
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002885
Dave Houltonf5217612018-02-02 16:18:52 -07002886 VkImageAspectFlags legal_aspect_flags =
2887 VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_METADATA_BIT;
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07002888 if (device_extensions.vk_khr_sampler_ycbcr_conversion) {
Dave Houltonf5217612018-02-02 16:18:52 -07002889 legal_aspect_flags |= (VK_IMAGE_ASPECT_PLANE_0_BIT_KHR | VK_IMAGE_ASPECT_PLANE_1_BIT_KHR | VK_IMAGE_ASPECT_PLANE_2_BIT_KHR);
2890 }
2891
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002892 if (pRegions != nullptr) {
Dave Houltonf5217612018-02-02 16:18:52 -07002893 if ((pRegions->srcSubresource.aspectMask & legal_aspect_flags) == 0) {
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002894 skip |= log_msg(
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07002895 report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Dave Houlton413a6782018-05-22 13:01:54 -06002896 "VUID-VkImageSubresourceLayers-aspectMask-parameter",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002897 "vkCmdCopyImage() parameter, VkImageAspect pRegions->srcSubresource.aspectMask, is an unrecognized enumerator.");
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002898 }
Dave Houltonf5217612018-02-02 16:18:52 -07002899 if ((pRegions->dstSubresource.aspectMask & legal_aspect_flags) == 0) {
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002900 skip |= log_msg(
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07002901 report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Dave Houlton413a6782018-05-22 13:01:54 -06002902 "VUID-VkImageSubresourceLayers-aspectMask-parameter",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06002903 "vkCmdCopyImage() parameter, VkImageAspect pRegions->dstSubresource.aspectMask, is an unrecognized enumerator.");
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002904 }
2905 }
2906 return skip;
2907}
2908
Mark Lobodzinskibf599b92018-12-31 12:15:55 -07002909bool StatelessValidation::manual_PreCallValidateCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage,
2910 VkImageLayout srcImageLayout, VkImage dstImage,
2911 VkImageLayout dstImageLayout, uint32_t regionCount,
Jeff Bolz5c801d12019-10-09 10:38:45 -05002912 const VkImageBlit *pRegions, VkFilter filter) const {
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002913 bool skip = false;
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002914
Dave Houltonf5217612018-02-02 16:18:52 -07002915 VkImageAspectFlags legal_aspect_flags =
2916 VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_METADATA_BIT;
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07002917 if (device_extensions.vk_khr_sampler_ycbcr_conversion) {
Dave Houltonf5217612018-02-02 16:18:52 -07002918 legal_aspect_flags |= (VK_IMAGE_ASPECT_PLANE_0_BIT_KHR | VK_IMAGE_ASPECT_PLANE_1_BIT_KHR | VK_IMAGE_ASPECT_PLANE_2_BIT_KHR);
2919 }
2920
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002921 if (pRegions != nullptr) {
Dave Houltonf5217612018-02-02 16:18:52 -07002922 if ((pRegions->srcSubresource.aspectMask & legal_aspect_flags) == 0) {
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002923 skip |= log_msg(
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07002924 report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Dave Houlton413a6782018-05-22 13:01:54 -06002925 kVUID_PVError_UnrecognizedValue,
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002926 "vkCmdBlitImage() parameter, VkImageAspect pRegions->srcSubresource.aspectMask, is an unrecognized enumerator");
2927 }
Dave Houltonf5217612018-02-02 16:18:52 -07002928 if ((pRegions->dstSubresource.aspectMask & legal_aspect_flags) == 0) {
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002929 skip |= log_msg(
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07002930 report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Dave Houlton413a6782018-05-22 13:01:54 -06002931 kVUID_PVError_UnrecognizedValue,
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002932 "vkCmdBlitImage() parameter, VkImageAspect pRegions->dstSubresource.aspectMask, is an unrecognized enumerator");
2933 }
2934 }
2935 return skip;
2936}
2937
sfricke-samsung3999ef62020-02-09 17:05:59 -08002938bool StatelessValidation::manual_PreCallValidateCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer,
2939 uint32_t regionCount, const VkBufferCopy *pRegions) const {
2940 bool skip = false;
2941
2942 if (pRegions != nullptr) {
2943 for (uint32_t i = 0; i < regionCount; i++) {
2944 if (pRegions[i].size == 0) {
2945 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
2946 "VUID-VkBufferCopy-size-01988", "vkCmdCopyBuffer() pRegions[%u].size must be greater than zero", i);
2947 }
2948 }
2949 }
2950 return skip;
2951}
2952
Mark Lobodzinskibf599b92018-12-31 12:15:55 -07002953bool StatelessValidation::manual_PreCallValidateCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer,
2954 VkImage dstImage, VkImageLayout dstImageLayout,
Jeff Bolz5c801d12019-10-09 10:38:45 -05002955 uint32_t regionCount,
2956 const VkBufferImageCopy *pRegions) const {
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002957 bool skip = false;
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002958
Dave Houltonf5217612018-02-02 16:18:52 -07002959 VkImageAspectFlags legal_aspect_flags =
2960 VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_METADATA_BIT;
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07002961 if (device_extensions.vk_khr_sampler_ycbcr_conversion) {
Dave Houltonf5217612018-02-02 16:18:52 -07002962 legal_aspect_flags |= (VK_IMAGE_ASPECT_PLANE_0_BIT_KHR | VK_IMAGE_ASPECT_PLANE_1_BIT_KHR | VK_IMAGE_ASPECT_PLANE_2_BIT_KHR);
2963 }
2964
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002965 if (pRegions != nullptr) {
Dave Houltonf5217612018-02-02 16:18:52 -07002966 if ((pRegions->imageSubresource.aspectMask & legal_aspect_flags) == 0) {
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07002967 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Dave Houlton413a6782018-05-22 13:01:54 -06002968 kVUID_PVError_UnrecognizedValue,
Dave Houltona9df0ce2018-02-07 10:51:23 -07002969 "vkCmdCopyBufferToImage() parameter, VkImageAspect pRegions->imageSubresource.aspectMask, is an "
2970 "unrecognized enumerator");
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002971 }
2972 }
2973 return skip;
2974}
2975
Mark Lobodzinskibf599b92018-12-31 12:15:55 -07002976bool StatelessValidation::manual_PreCallValidateCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage,
2977 VkImageLayout srcImageLayout, VkBuffer dstBuffer,
Jeff Bolz5c801d12019-10-09 10:38:45 -05002978 uint32_t regionCount,
2979 const VkBufferImageCopy *pRegions) const {
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002980 bool skip = false;
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002981
Dave Houltonf5217612018-02-02 16:18:52 -07002982 VkImageAspectFlags legal_aspect_flags =
2983 VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_METADATA_BIT;
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07002984 if (device_extensions.vk_khr_sampler_ycbcr_conversion) {
Dave Houltonf5217612018-02-02 16:18:52 -07002985 legal_aspect_flags |= (VK_IMAGE_ASPECT_PLANE_0_BIT_KHR | VK_IMAGE_ASPECT_PLANE_1_BIT_KHR | VK_IMAGE_ASPECT_PLANE_2_BIT_KHR);
2986 }
2987
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002988 if (pRegions != nullptr) {
Dave Houltonf5217612018-02-02 16:18:52 -07002989 if ((pRegions->imageSubresource.aspectMask & legal_aspect_flags) == 0) {
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07002990 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Dave Houlton413a6782018-05-22 13:01:54 -06002991 kVUID_PVError_UnrecognizedValue,
Mark Lobodzinskid4950072017-08-01 13:02:20 -06002992 "vkCmdCopyImageToBuffer parameter, VkImageAspect pRegions->imageSubresource.aspectMask, is an unrecognized "
2993 "enumerator");
2994 }
2995 }
2996 return skip;
2997}
2998
Mark Lobodzinskibf599b92018-12-31 12:15:55 -07002999bool StatelessValidation::manual_PreCallValidateCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer,
Jeff Bolz5c801d12019-10-09 10:38:45 -05003000 VkDeviceSize dstOffset, VkDeviceSize dataSize,
3001 const void *pData) const {
Mark Lobodzinskid4950072017-08-01 13:02:20 -06003002 bool skip = false;
Mark Lobodzinskid4950072017-08-01 13:02:20 -06003003
3004 if (dstOffset & 3) {
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07003005 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Dave Houlton413a6782018-05-22 13:01:54 -06003006 "VUID-vkCmdUpdateBuffer-dstOffset-00036",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06003007 "vkCmdUpdateBuffer() parameter, VkDeviceSize dstOffset (0x%" PRIxLEAST64 "), is not a multiple of 4.",
3008 dstOffset);
Mark Lobodzinskid4950072017-08-01 13:02:20 -06003009 }
3010
3011 if ((dataSize <= 0) || (dataSize > 65536)) {
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07003012 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Dave Houlton413a6782018-05-22 13:01:54 -06003013 "VUID-vkCmdUpdateBuffer-dataSize-00037",
Mark Lobodzinskid4950072017-08-01 13:02:20 -06003014 "vkCmdUpdateBuffer() parameter, VkDeviceSize dataSize (0x%" PRIxLEAST64
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06003015 "), must be greater than zero and less than or equal to 65536.",
3016 dataSize);
Mark Lobodzinskid4950072017-08-01 13:02:20 -06003017 } else if (dataSize & 3) {
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06003018 skip |=
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07003019 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Dave Houlton413a6782018-05-22 13:01:54 -06003020 "VUID-vkCmdUpdateBuffer-dataSize-00038",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06003021 "vkCmdUpdateBuffer() parameter, VkDeviceSize dataSize (0x%" PRIxLEAST64 "), is not a multiple of 4.", dataSize);
Mark Lobodzinskid4950072017-08-01 13:02:20 -06003022 }
3023 return skip;
3024}
3025
Mark Lobodzinskibf599b92018-12-31 12:15:55 -07003026bool StatelessValidation::manual_PreCallValidateCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer,
Jeff Bolz5c801d12019-10-09 10:38:45 -05003027 VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) const {
Mark Lobodzinskid4950072017-08-01 13:02:20 -06003028 bool skip = false;
Mark Lobodzinskid4950072017-08-01 13:02:20 -06003029
3030 if (dstOffset & 3) {
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06003031 skip |=
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07003032 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Dave Houlton413a6782018-05-22 13:01:54 -06003033 "VUID-vkCmdFillBuffer-dstOffset-00025",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06003034 "vkCmdFillBuffer() parameter, VkDeviceSize dstOffset (0x%" PRIxLEAST64 "), is not a multiple of 4.", dstOffset);
Mark Lobodzinskid4950072017-08-01 13:02:20 -06003035 }
3036
3037 if (size != VK_WHOLE_SIZE) {
3038 if (size <= 0) {
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06003039 skip |=
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07003040 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Dave Houlton413a6782018-05-22 13:01:54 -06003041 "VUID-vkCmdFillBuffer-size-00026",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06003042 "vkCmdFillBuffer() parameter, VkDeviceSize size (0x%" PRIxLEAST64 "), must be greater than zero.", size);
Mark Lobodzinskid4950072017-08-01 13:02:20 -06003043 } else if (size & 3) {
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07003044 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Dave Houlton413a6782018-05-22 13:01:54 -06003045 "VUID-vkCmdFillBuffer-size-00028",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06003046 "vkCmdFillBuffer() parameter, VkDeviceSize size (0x%" PRIxLEAST64 "), is not a multiple of 4.", size);
Mark Lobodzinskid4950072017-08-01 13:02:20 -06003047 }
3048 }
3049 return skip;
3050}
3051
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07003052bool StatelessValidation::manual_PreCallValidateCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR *pCreateInfo,
Mark Lobodzinskibf599b92018-12-31 12:15:55 -07003053 const VkAllocationCallbacks *pAllocator,
Jeff Bolz5c801d12019-10-09 10:38:45 -05003054 VkSwapchainKHR *pSwapchain) const {
Mark Lobodzinskid4950072017-08-01 13:02:20 -06003055 bool skip = false;
Mark Lobodzinskid4950072017-08-01 13:02:20 -06003056
Mark Lobodzinskibf599b92018-12-31 12:15:55 -07003057 const LogMiscParams log_misc{VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT, VK_NULL_HANDLE, "vkCreateSwapchainKHR"};
Petr Krause5c37652018-01-05 04:05:12 +01003058
Mark Lobodzinskid4950072017-08-01 13:02:20 -06003059 if (pCreateInfo != nullptr) {
Mark Lobodzinskid4950072017-08-01 13:02:20 -06003060 // Validation for parameters excluded from the generated validation code due to a 'noautovalidity' tag in vk.xml
3061 if (pCreateInfo->imageSharingMode == VK_SHARING_MODE_CONCURRENT) {
3062 // If imageSharingMode is VK_SHARING_MODE_CONCURRENT, queueFamilyIndexCount must be greater than 1
3063 if (pCreateInfo->queueFamilyIndexCount <= 1) {
Mark Lobodzinskib1fd9d12018-03-30 14:26:00 -06003064 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Dave Houlton413a6782018-05-22 13:01:54 -06003065 "VUID-VkSwapchainCreateInfoKHR-imageSharingMode-01278",
Mark Lobodzinskid4950072017-08-01 13:02:20 -06003066 "vkCreateSwapchainKHR(): if pCreateInfo->imageSharingMode is VK_SHARING_MODE_CONCURRENT, "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06003067 "pCreateInfo->queueFamilyIndexCount must be greater than 1.");
Mark Lobodzinskid4950072017-08-01 13:02:20 -06003068 }
3069
3070 // If imageSharingMode is VK_SHARING_MODE_CONCURRENT, pQueueFamilyIndices must be a pointer to an array of
3071 // queueFamilyIndexCount uint32_t values
3072 if (pCreateInfo->pQueueFamilyIndices == nullptr) {
Mark Lobodzinskib1fd9d12018-03-30 14:26:00 -06003073 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Dave Houlton413a6782018-05-22 13:01:54 -06003074 "VUID-VkSwapchainCreateInfoKHR-imageSharingMode-01277",
Mark Lobodzinskid4950072017-08-01 13:02:20 -06003075 "vkCreateSwapchainKHR(): if pCreateInfo->imageSharingMode is VK_SHARING_MODE_CONCURRENT, "
3076 "pCreateInfo->pQueueFamilyIndices must be a pointer to an array of "
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06003077 "pCreateInfo->queueFamilyIndexCount uint32_t values.");
Mark Lobodzinskid4950072017-08-01 13:02:20 -06003078 }
3079 }
3080
Dave Houlton413a6782018-05-22 13:01:54 -06003081 skip |= ValidateGreaterThanZero(pCreateInfo->imageArrayLayers, "pCreateInfo->imageArrayLayers",
3082 "VUID-VkSwapchainCreateInfoKHR-imageArrayLayers-01275", log_misc);
Mark Lobodzinskid4950072017-08-01 13:02:20 -06003083 }
3084
3085 return skip;
3086}
3087
Jeff Bolz5c801d12019-10-09 10:38:45 -05003088bool StatelessValidation::manual_PreCallValidateQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR *pPresentInfo) const {
Mark Lobodzinskid4950072017-08-01 13:02:20 -06003089 bool skip = false;
Mark Lobodzinskid4950072017-08-01 13:02:20 -06003090
3091 if (pPresentInfo && pPresentInfo->pNext) {
John Zulaufde972ac2017-10-26 12:07:05 -06003092 const auto *present_regions = lvl_find_in_chain<VkPresentRegionsKHR>(pPresentInfo->pNext);
3093 if (present_regions) {
3094 // TODO: This and all other pNext extension dependencies should be added to code-generation
Tony-LunarG2ec96bb2019-11-26 13:43:02 -07003095 skip |= require_device_extension(IsExtEnabled(device_extensions.vk_khr_incremental_present), "vkQueuePresentKHR",
John Zulaufde972ac2017-10-26 12:07:05 -06003096 VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME);
3097 if (present_regions->swapchainCount != pPresentInfo->swapchainCount) {
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07003098 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Dave Houlton413a6782018-05-22 13:01:54 -06003099 kVUID_PVError_InvalidUsage,
Dave Houltona9df0ce2018-02-07 10:51:23 -07003100 "QueuePresentKHR(): pPresentInfo->swapchainCount has a value of %i but VkPresentRegionsKHR "
3101 "extension swapchainCount is %i. These values must be equal.",
John Zulaufde972ac2017-10-26 12:07:05 -06003102 pPresentInfo->swapchainCount, present_regions->swapchainCount);
3103 }
Mark Lobodzinskibf599b92018-12-31 12:15:55 -07003104 skip |= validate_struct_pnext("QueuePresentKHR", "pCreateInfo->pNext->pNext", NULL, present_regions->pNext, 0, NULL,
3105 GeneratedVulkanHeaderVersion, "VUID-VkPresentInfoKHR-pNext-pNext");
3106 skip |= validate_array("QueuePresentKHR", "pCreateInfo->pNext->swapchainCount", "pCreateInfo->pNext->pRegions",
3107 present_regions->swapchainCount, &present_regions->pRegions, true, false, kVUIDUndefined,
3108 kVUIDUndefined);
John Zulaufde972ac2017-10-26 12:07:05 -06003109 for (uint32_t i = 0; i < present_regions->swapchainCount; ++i) {
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07003110 skip |= validate_array("QueuePresentKHR", "pCreateInfo->pNext->pRegions[].rectangleCount",
Mark Lobodzinskid4950072017-08-01 13:02:20 -06003111 "pCreateInfo->pNext->pRegions[].pRectangles", present_regions->pRegions[i].rectangleCount,
Dave Houlton413a6782018-05-22 13:01:54 -06003112 &present_regions->pRegions[i].pRectangles, true, false, kVUIDUndefined, kVUIDUndefined);
Mark Lobodzinskid4950072017-08-01 13:02:20 -06003113 }
Mark Lobodzinskid4950072017-08-01 13:02:20 -06003114 }
3115 }
3116
3117 return skip;
3118}
3119
3120#ifdef VK_USE_PLATFORM_WIN32_KHR
Mark Lobodzinskibf599b92018-12-31 12:15:55 -07003121bool StatelessValidation::manual_PreCallValidateCreateWin32SurfaceKHR(VkInstance instance,
3122 const VkWin32SurfaceCreateInfoKHR *pCreateInfo,
3123 const VkAllocationCallbacks *pAllocator,
Jeff Bolz5c801d12019-10-09 10:38:45 -05003124 VkSurfaceKHR *pSurface) const {
Mark Lobodzinskid4950072017-08-01 13:02:20 -06003125 bool skip = false;
3126
3127 if (pCreateInfo->hwnd == nullptr) {
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07003128 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
Dave Houlton413a6782018-05-22 13:01:54 -06003129 "VUID-VkWin32SurfaceCreateInfoKHR-hwnd-01308",
3130 "vkCreateWin32SurfaceKHR(): hwnd must be a valid Win32 HWND but hwnd is NULL.");
Mark Lobodzinskid4950072017-08-01 13:02:20 -06003131 }
3132
3133 return skip;
3134}
3135#endif // VK_USE_PLATFORM_WIN32_KHR
3136
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07003137bool StatelessValidation::manual_PreCallValidateCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo *pCreateInfo,
Mark Lobodzinskibf599b92018-12-31 12:15:55 -07003138 const VkAllocationCallbacks *pAllocator,
Jeff Bolz5c801d12019-10-09 10:38:45 -05003139 VkDescriptorPool *pDescriptorPool) const {
Petr Krausc8655be2017-09-27 18:56:51 +02003140 bool skip = false;
3141
3142 if (pCreateInfo) {
3143 if (pCreateInfo->maxSets <= 0) {
Mark Lobodzinskibf599b92018-12-31 12:15:55 -07003144 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT,
3145 VK_NULL_HANDLE, "VUID-VkDescriptorPoolCreateInfo-maxSets-00301",
3146 "vkCreateDescriptorPool(): pCreateInfo->maxSets is not greater than 0.");
Petr Krausc8655be2017-09-27 18:56:51 +02003147 }
3148
3149 if (pCreateInfo->pPoolSizes) {
3150 for (uint32_t i = 0; i < pCreateInfo->poolSizeCount; ++i) {
3151 if (pCreateInfo->pPoolSizes[i].descriptorCount <= 0) {
3152 skip |= log_msg(
Mark Lobodzinskibf599b92018-12-31 12:15:55 -07003153 report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT, VK_NULL_HANDLE,
3154 "VUID-VkDescriptorPoolSize-descriptorCount-00302",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06003155 "vkCreateDescriptorPool(): pCreateInfo->pPoolSizes[%" PRIu32 "].descriptorCount is not greater than 0.", i);
Petr Krausc8655be2017-09-27 18:56:51 +02003156 }
Jeff Bolze54ae892018-09-08 12:16:29 -05003157 if (pCreateInfo->pPoolSizes[i].type == VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT &&
3158 (pCreateInfo->pPoolSizes[i].descriptorCount % 4) != 0) {
Mark Lobodzinskibf599b92018-12-31 12:15:55 -07003159 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT,
3160 VK_NULL_HANDLE, "VUID-VkDescriptorPoolSize-type-02218",
Dave Houlton142c4cb2018-10-17 15:04:41 -06003161 "vkCreateDescriptorPool(): pCreateInfo->pPoolSizes[%" PRIu32
3162 "].type is VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT "
3163 " and pCreateInfo->pPoolSizes[%" PRIu32 "].descriptorCount is not a multiple of 4.",
3164 i, i);
Jeff Bolze54ae892018-09-08 12:16:29 -05003165 }
Petr Krausc8655be2017-09-27 18:56:51 +02003166 }
3167 }
3168 }
3169
3170 return skip;
3171}
3172
Mark Lobodzinskibf599b92018-12-31 12:15:55 -07003173bool StatelessValidation::manual_PreCallValidateCmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCountX,
Jeff Bolz5c801d12019-10-09 10:38:45 -05003174 uint32_t groupCountY, uint32_t groupCountZ) const {
Dave Houltonbb7d3fe2018-01-11 17:09:16 -07003175 bool skip = false;
Dave Houltonbb7d3fe2018-01-11 17:09:16 -07003176
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07003177 if (groupCountX > device_limits.maxComputeWorkGroupCount[0]) {
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06003178 skip |=
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07003179 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Dave Houlton413a6782018-05-22 13:01:54 -06003180 HandleToUint64(commandBuffer), "VUID-vkCmdDispatch-groupCountX-00386",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06003181 "vkCmdDispatch(): groupCountX (%" PRIu32 ") exceeds device limit maxComputeWorkGroupCount[0] (%" PRIu32 ").",
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07003182 groupCountX, device_limits.maxComputeWorkGroupCount[0]);
Dave Houltonbb7d3fe2018-01-11 17:09:16 -07003183 }
3184
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07003185 if (groupCountY > device_limits.maxComputeWorkGroupCount[1]) {
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06003186 skip |=
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07003187 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Dave Houlton413a6782018-05-22 13:01:54 -06003188 HandleToUint64(commandBuffer), "VUID-vkCmdDispatch-groupCountY-00387",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06003189 "vkCmdDispatch(): groupCountY (%" PRIu32 ") exceeds device limit maxComputeWorkGroupCount[1] (%" PRIu32 ").",
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07003190 groupCountY, device_limits.maxComputeWorkGroupCount[1]);
Dave Houltonbb7d3fe2018-01-11 17:09:16 -07003191 }
3192
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07003193 if (groupCountZ > device_limits.maxComputeWorkGroupCount[2]) {
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06003194 skip |=
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07003195 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Dave Houlton413a6782018-05-22 13:01:54 -06003196 HandleToUint64(commandBuffer), "VUID-vkCmdDispatch-groupCountZ-00388",
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06003197 "vkCmdDispatch(): groupCountZ (%" PRIu32 ") exceeds device limit maxComputeWorkGroupCount[2] (%" PRIu32 ").",
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07003198 groupCountZ, device_limits.maxComputeWorkGroupCount[2]);
Dave Houltonbb7d3fe2018-01-11 17:09:16 -07003199 }
3200
3201 return skip;
3202}
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07003203
Mark Lobodzinskibf599b92018-12-31 12:15:55 -07003204bool StatelessValidation::manual_PreCallValidateCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer,
Jeff Bolz5c801d12019-10-09 10:38:45 -05003205 VkDeviceSize offset) const {
John Zulaufa999d1b2018-11-29 13:38:40 -07003206 bool skip = false;
John Zulaufa999d1b2018-11-29 13:38:40 -07003207
3208 if ((offset % 4) != 0) {
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07003209 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Shannon McPhersonde3eeba2019-04-30 16:53:59 -06003210 HandleToUint64(commandBuffer), "VUID-vkCmdDispatchIndirect-offset-02710",
John Zulaufa999d1b2018-11-29 13:38:40 -07003211 "vkCmdDispatchIndirect(): offset (%" PRIu64 ") must be a multiple of 4.", offset);
3212 }
3213 return skip;
3214}
Dave Houltonbb7d3fe2018-01-11 17:09:16 -07003215
Mark Lobodzinskibf599b92018-12-31 12:15:55 -07003216bool StatelessValidation::manual_PreCallValidateCmdDispatchBaseKHR(VkCommandBuffer commandBuffer, uint32_t baseGroupX,
3217 uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX,
Jeff Bolz5c801d12019-10-09 10:38:45 -05003218 uint32_t groupCountY, uint32_t groupCountZ) const {
Dave Houltonbb7d3fe2018-01-11 17:09:16 -07003219 bool skip = false;
Dave Houltonbb7d3fe2018-01-11 17:09:16 -07003220
3221 // Paired if {} else if {} tests used to avoid any possible uint underflow
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07003222 uint32_t limit = device_limits.maxComputeWorkGroupCount[0];
Dave Houltonbb7d3fe2018-01-11 17:09:16 -07003223 if (baseGroupX >= limit) {
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07003224 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Dave Houlton413a6782018-05-22 13:01:54 -06003225 HandleToUint64(commandBuffer), "VUID-vkCmdDispatchBase-baseGroupX-00421",
Dave Houltonbb7d3fe2018-01-11 17:09:16 -07003226 "vkCmdDispatch(): baseGroupX (%" PRIu32
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06003227 ") equals or exceeds device limit maxComputeWorkGroupCount[0] (%" PRIu32 ").",
3228 baseGroupX, limit);
Dave Houltonbb7d3fe2018-01-11 17:09:16 -07003229 } else if (groupCountX > (limit - baseGroupX)) {
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07003230 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Dave Houlton413a6782018-05-22 13:01:54 -06003231 HandleToUint64(commandBuffer), "VUID-vkCmdDispatchBase-groupCountX-00424",
Mark Lobodzinskibf973a12018-03-01 08:50:21 -07003232 "vkCmdDispatchBaseKHR(): baseGroupX (%" PRIu32 ") + groupCountX (%" PRIu32
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06003233 ") exceeds device limit maxComputeWorkGroupCount[0] (%" PRIu32 ").",
3234 baseGroupX, groupCountX, limit);
Dave Houltonbb7d3fe2018-01-11 17:09:16 -07003235 }
3236
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07003237 limit = device_limits.maxComputeWorkGroupCount[1];
Dave Houltonbb7d3fe2018-01-11 17:09:16 -07003238 if (baseGroupY >= limit) {
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07003239 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Dave Houlton413a6782018-05-22 13:01:54 -06003240 HandleToUint64(commandBuffer), "VUID-vkCmdDispatchBase-baseGroupX-00422",
Dave Houltonbb7d3fe2018-01-11 17:09:16 -07003241 "vkCmdDispatch(): baseGroupY (%" PRIu32
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06003242 ") equals or exceeds device limit maxComputeWorkGroupCount[1] (%" PRIu32 ").",
3243 baseGroupY, limit);
Dave Houltonbb7d3fe2018-01-11 17:09:16 -07003244 } else if (groupCountY > (limit - baseGroupY)) {
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07003245 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Dave Houlton413a6782018-05-22 13:01:54 -06003246 HandleToUint64(commandBuffer), "VUID-vkCmdDispatchBase-groupCountY-00425",
Mark Lobodzinskibf973a12018-03-01 08:50:21 -07003247 "vkCmdDispatchBaseKHR(): baseGroupY (%" PRIu32 ") + groupCountY (%" PRIu32
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06003248 ") exceeds device limit maxComputeWorkGroupCount[1] (%" PRIu32 ").",
3249 baseGroupY, groupCountY, limit);
Dave Houltonbb7d3fe2018-01-11 17:09:16 -07003250 }
3251
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07003252 limit = device_limits.maxComputeWorkGroupCount[2];
Dave Houltonbb7d3fe2018-01-11 17:09:16 -07003253 if (baseGroupZ >= limit) {
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07003254 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Dave Houlton413a6782018-05-22 13:01:54 -06003255 HandleToUint64(commandBuffer), "VUID-vkCmdDispatchBase-baseGroupZ-00423",
Dave Houltonbb7d3fe2018-01-11 17:09:16 -07003256 "vkCmdDispatch(): baseGroupZ (%" PRIu32
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06003257 ") equals or exceeds device limit maxComputeWorkGroupCount[2] (%" PRIu32 ").",
3258 baseGroupZ, limit);
Dave Houltonbb7d3fe2018-01-11 17:09:16 -07003259 } else if (groupCountZ > (limit - baseGroupZ)) {
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07003260 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Dave Houlton413a6782018-05-22 13:01:54 -06003261 HandleToUint64(commandBuffer), "VUID-vkCmdDispatchBase-groupCountZ-00426",
Mark Lobodzinskibf973a12018-03-01 08:50:21 -07003262 "vkCmdDispatchBaseKHR(): baseGroupZ (%" PRIu32 ") + groupCountZ (%" PRIu32
Mark Lobodzinski487a0d12018-03-30 10:09:03 -06003263 ") exceeds device limit maxComputeWorkGroupCount[2] (%" PRIu32 ").",
3264 baseGroupZ, groupCountZ, limit);
Dave Houltonbb7d3fe2018-01-11 17:09:16 -07003265 }
3266
3267 return skip;
3268}
3269
Jeremy Hayes390ff6f2020-02-10 13:48:57 -07003270bool StatelessValidation::manual_PreCallValidateCmdPushDescriptorSetKHR(VkCommandBuffer commandBuffer,
3271 VkPipelineBindPoint pipelineBindPoint,
3272 VkPipelineLayout layout, uint32_t set,
3273 uint32_t descriptorWriteCount,
3274 const VkWriteDescriptorSet *pDescriptorWrites) const {
3275 return validate_WriteDescriptorSet("vkCmdPushDescriptorSetKHR", descriptorWriteCount, pDescriptorWrites, false);
3276}
3277
Mark Lobodzinskibf599b92018-12-31 12:15:55 -07003278bool StatelessValidation::manual_PreCallValidateCmdSetExclusiveScissorNV(VkCommandBuffer commandBuffer,
3279 uint32_t firstExclusiveScissor,
3280 uint32_t exclusiveScissorCount,
Jeff Bolz5c801d12019-10-09 10:38:45 -05003281 const VkRect2D *pExclusiveScissors) const {
Jeff Bolz3e71f782018-08-29 23:15:45 -05003282 bool skip = false;
3283
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07003284 if (!physical_device_features.multiViewport) {
Jeff Bolz3e71f782018-08-29 23:15:45 -05003285 if (firstExclusiveScissor != 0) {
Dave Houlton142c4cb2018-10-17 15:04:41 -06003286 skip |=
3287 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
3288 HandleToUint64(commandBuffer), "VUID-vkCmdSetExclusiveScissorNV-firstExclusiveScissor-02035",
3289 "vkCmdSetExclusiveScissorNV: The multiViewport feature is disabled, but firstExclusiveScissor (=%" PRIu32
3290 ") is not 0.",
3291 firstExclusiveScissor);
Jeff Bolz3e71f782018-08-29 23:15:45 -05003292 }
3293 if (exclusiveScissorCount > 1) {
Dave Houlton142c4cb2018-10-17 15:04:41 -06003294 skip |=
3295 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
3296 HandleToUint64(commandBuffer), "VUID-vkCmdSetExclusiveScissorNV-exclusiveScissorCount-02036",
3297 "vkCmdSetExclusiveScissorNV: The multiViewport feature is disabled, but exclusiveScissorCount (=%" PRIu32
3298 ") is not 1.",
3299 exclusiveScissorCount);
Jeff Bolz3e71f782018-08-29 23:15:45 -05003300 }
3301 } else { // multiViewport enabled
3302 const uint64_t sum = static_cast<uint64_t>(firstExclusiveScissor) + static_cast<uint64_t>(exclusiveScissorCount);
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07003303 if (sum > device_limits.maxViewports) {
3304 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Jeff Bolz3e71f782018-08-29 23:15:45 -05003305 HandleToUint64(commandBuffer), "VUID-vkCmdSetExclusiveScissorNV-firstExclusiveScissor-02034",
Dave Houlton142c4cb2018-10-17 15:04:41 -06003306 "vkCmdSetExclusiveScissorNV: firstExclusiveScissor + exclusiveScissorCount (=%" PRIu32 " + %" PRIu32
3307 " = %" PRIu64 ") is greater than VkPhysicalDeviceLimits::maxViewports (=%" PRIu32 ").",
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07003308 firstExclusiveScissor, exclusiveScissorCount, sum, device_limits.maxViewports);
Jeff Bolz3e71f782018-08-29 23:15:45 -05003309 }
3310 }
3311
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07003312 if (firstExclusiveScissor >= device_limits.maxViewports) {
Jeff Bolz3e71f782018-08-29 23:15:45 -05003313 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
3314 HandleToUint64(commandBuffer), "VUID-vkCmdSetExclusiveScissorNV-firstExclusiveScissor-02033",
Dave Houlton142c4cb2018-10-17 15:04:41 -06003315 "vkCmdSetExclusiveScissorNV: firstExclusiveScissor (=%" PRIu32 ") must be less than maxViewports (=%" PRIu32
3316 ").",
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07003317 firstExclusiveScissor, device_limits.maxViewports);
Jeff Bolz3e71f782018-08-29 23:15:45 -05003318 }
3319
3320 if (pExclusiveScissors) {
3321 for (uint32_t scissor_i = 0; scissor_i < exclusiveScissorCount; ++scissor_i) {
3322 const auto &scissor = pExclusiveScissors[scissor_i]; // will crash on invalid ptr
3323
3324 if (scissor.offset.x < 0) {
3325 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
3326 HandleToUint64(commandBuffer), "VUID-vkCmdSetExclusiveScissorNV-x-02037",
Dave Houlton142c4cb2018-10-17 15:04:41 -06003327 "vkCmdSetExclusiveScissorNV: pScissors[%" PRIu32 "].offset.x (=%" PRIi32 ") is negative.",
3328 scissor_i, scissor.offset.x);
Jeff Bolz3e71f782018-08-29 23:15:45 -05003329 }
3330
3331 if (scissor.offset.y < 0) {
3332 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
3333 HandleToUint64(commandBuffer), "VUID-vkCmdSetExclusiveScissorNV-x-02037",
Dave Houlton142c4cb2018-10-17 15:04:41 -06003334 "vkCmdSetExclusiveScissorNV: pScissors[%" PRIu32 "].offset.y (=%" PRIi32 ") is negative.",
3335 scissor_i, scissor.offset.y);
Jeff Bolz3e71f782018-08-29 23:15:45 -05003336 }
3337
3338 const int64_t x_sum = static_cast<int64_t>(scissor.offset.x) + static_cast<int64_t>(scissor.extent.width);
3339 if (x_sum > INT32_MAX) {
3340 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
3341 HandleToUint64(commandBuffer), "VUID-vkCmdSetExclusiveScissorNV-offset-02038",
3342 "vkCmdSetExclusiveScissorNV: offset.x + extent.width (=%" PRIi32 " + %" PRIu32 " = %" PRIi64
3343 ") of pScissors[%" PRIu32 "] will overflow int32_t.",
3344 scissor.offset.x, scissor.extent.width, x_sum, scissor_i);
3345 }
3346
3347 const int64_t y_sum = static_cast<int64_t>(scissor.offset.y) + static_cast<int64_t>(scissor.extent.height);
3348 if (y_sum > INT32_MAX) {
3349 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
3350 HandleToUint64(commandBuffer), "VUID-vkCmdSetExclusiveScissorNV-offset-02039",
3351 "vkCmdSetExclusiveScissorNV: offset.y + extent.height (=%" PRIi32 " + %" PRIu32 " = %" PRIi64
3352 ") of pScissors[%" PRIu32 "] will overflow int32_t.",
3353 scissor.offset.y, scissor.extent.height, y_sum, scissor_i);
3354 }
3355 }
3356 }
3357
3358 return skip;
3359}
3360
Chris Mayer9ded5eb2019-09-19 16:33:26 +02003361bool StatelessValidation::manual_PreCallValidateCmdSetViewportWScalingNV(VkCommandBuffer commandBuffer, uint32_t firstViewport,
3362 uint32_t viewportCount,
Jeff Bolz5c801d12019-10-09 10:38:45 -05003363 const VkViewportWScalingNV *pViewportWScalings) const {
Chris Mayer9ded5eb2019-09-19 16:33:26 +02003364 bool skip = false;
3365 if (firstViewport >= device_limits.maxViewports) {
3366 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
3367 HandleToUint64(commandBuffer), "VUID-vkCmdSetViewportWScalingNV-firstViewport-01323",
3368 "vkCmdSetViewportWScalingNV: firstViewport (=%" PRIu32 ") must be less than maxViewports (=%" PRIu32 ").",
3369 firstViewport, device_limits.maxViewports);
3370 } else {
3371 const uint64_t sum = static_cast<uint64_t>(firstViewport) + static_cast<uint64_t>(viewportCount);
3372 if ((sum < 1) || (sum > device_limits.maxViewports)) {
3373 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
3374 HandleToUint64(commandBuffer), "VUID-vkCmdSetViewportWScalingNV-firstViewport-01324",
3375 "vkCmdSetViewportWScalingNV: firstViewport + viewportCount (=%" PRIu32 " + %" PRIu32 " = %" PRIu64
3376 ") must be between 1 and VkPhysicalDeviceLimits::maxViewports (=%" PRIu32 "), inculsive.",
3377 firstViewport, viewportCount, sum, device_limits.maxViewports);
3378 }
3379 }
3380
3381 return skip;
3382}
3383
Mark Lobodzinskibf599b92018-12-31 12:15:55 -07003384bool StatelessValidation::manual_PreCallValidateCmdSetViewportShadingRatePaletteNV(
3385 VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount,
Jeff Bolz5c801d12019-10-09 10:38:45 -05003386 const VkShadingRatePaletteNV *pShadingRatePalettes) const {
Jeff Bolz9af91c52018-09-01 21:53:57 -05003387 bool skip = false;
3388
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07003389 if (!physical_device_features.multiViewport) {
Jeff Bolz9af91c52018-09-01 21:53:57 -05003390 if (firstViewport != 0) {
Dave Houlton142c4cb2018-10-17 15:04:41 -06003391 skip |=
3392 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
3393 HandleToUint64(commandBuffer), "VUID-vkCmdSetViewportShadingRatePaletteNV-firstViewport-02068",
3394 "vkCmdSetViewportShadingRatePaletteNV: The multiViewport feature is disabled, but firstViewport (=%" PRIu32
3395 ") is not 0.",
3396 firstViewport);
Jeff Bolz9af91c52018-09-01 21:53:57 -05003397 }
3398 if (viewportCount > 1) {
Dave Houlton142c4cb2018-10-17 15:04:41 -06003399 skip |=
3400 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
3401 HandleToUint64(commandBuffer), "VUID-vkCmdSetViewportShadingRatePaletteNV-viewportCount-02069",
3402 "vkCmdSetViewportShadingRatePaletteNV: The multiViewport feature is disabled, but viewportCount (=%" PRIu32
3403 ") is not 1.",
3404 viewportCount);
Jeff Bolz9af91c52018-09-01 21:53:57 -05003405 }
3406 }
3407
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07003408 if (firstViewport >= device_limits.maxViewports) {
Jeff Bolz9af91c52018-09-01 21:53:57 -05003409 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
3410 HandleToUint64(commandBuffer), "VUID-vkCmdSetViewportShadingRatePaletteNV-firstViewport-02066",
Dave Houlton142c4cb2018-10-17 15:04:41 -06003411 "vkCmdSetViewportShadingRatePaletteNV: firstViewport (=%" PRIu32
3412 ") must be less than maxViewports (=%" PRIu32 ").",
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07003413 firstViewport, device_limits.maxViewports);
Jeff Bolz9af91c52018-09-01 21:53:57 -05003414 }
3415
3416 const uint64_t sum = static_cast<uint64_t>(firstViewport) + static_cast<uint64_t>(viewportCount);
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07003417 if (sum > device_limits.maxViewports) {
3418 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Jeff Bolz9af91c52018-09-01 21:53:57 -05003419 HandleToUint64(commandBuffer), "VUID-vkCmdSetViewportShadingRatePaletteNV-firstViewport-02067",
3420 "vkCmdSetViewportShadingRatePaletteNV: firstViewport + viewportCount (=%" PRIu32 " + %" PRIu32 " = %" PRIu64
3421 ") is greater than VkPhysicalDeviceLimits::maxViewports (=%" PRIu32 ").",
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07003422 firstViewport, viewportCount, sum, device_limits.maxViewports);
Jeff Bolz9af91c52018-09-01 21:53:57 -05003423 }
3424
3425 return skip;
3426}
3427
Jeff Bolz5c801d12019-10-09 10:38:45 -05003428bool StatelessValidation::manual_PreCallValidateCmdSetCoarseSampleOrderNV(
3429 VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount,
3430 const VkCoarseSampleOrderCustomNV *pCustomSampleOrders) const {
Jeff Bolz9af91c52018-09-01 21:53:57 -05003431 bool skip = false;
3432
Dave Houlton142c4cb2018-10-17 15:04:41 -06003433 if (sampleOrderType != VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV && customSampleOrderCount != 0) {
Jeff Bolz9af91c52018-09-01 21:53:57 -05003434 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
3435 HandleToUint64(commandBuffer), "VUID-vkCmdSetCoarseSampleOrderNV-sampleOrderType-02081",
3436 "vkCmdSetCoarseSampleOrderNV: If sampleOrderType is not VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV, "
3437 "customSampleOrderCount must be 0.");
3438 }
3439
3440 for (uint32_t order_i = 0; order_i < customSampleOrderCount; ++order_i) {
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07003441 skip |= ValidateCoarseSampleOrderCustomNV(&pCustomSampleOrders[order_i]);
Jeff Bolz9af91c52018-09-01 21:53:57 -05003442 }
3443
3444 return skip;
3445}
3446
Mark Lobodzinskibf599b92018-12-31 12:15:55 -07003447bool StatelessValidation::manual_PreCallValidateCmdDrawMeshTasksNV(VkCommandBuffer commandBuffer, uint32_t taskCount,
Jeff Bolz5c801d12019-10-09 10:38:45 -05003448 uint32_t firstTask) const {
Jeff Bolz45bf7d62018-09-18 15:39:58 -05003449 bool skip = false;
3450
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07003451 if (taskCount > phys_dev_ext_props.mesh_shader_props.maxDrawMeshTasksCount) {
Dave Houlton142c4cb2018-10-17 15:04:41 -06003452 skip |= log_msg(
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07003453 report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Dave Houlton142c4cb2018-10-17 15:04:41 -06003454 HandleToUint64(commandBuffer), "VUID-vkCmdDrawMeshTasksNV-taskCount-02119",
3455 "vkCmdDrawMeshTasksNV() parameter, uint32_t taskCount (0x%" PRIxLEAST32
3456 "), must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesNV::maxDrawMeshTasksCount (0x%" PRIxLEAST32 ").",
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07003457 taskCount, phys_dev_ext_props.mesh_shader_props.maxDrawMeshTasksCount);
Jeff Bolz45bf7d62018-09-18 15:39:58 -05003458 }
3459
3460 return skip;
3461}
3462
Mark Lobodzinskibf599b92018-12-31 12:15:55 -07003463bool StatelessValidation::manual_PreCallValidateCmdDrawMeshTasksIndirectNV(VkCommandBuffer commandBuffer, VkBuffer buffer,
3464 VkDeviceSize offset, uint32_t drawCount,
Jeff Bolz5c801d12019-10-09 10:38:45 -05003465 uint32_t stride) const {
Jeff Bolz45bf7d62018-09-18 15:39:58 -05003466 bool skip = false;
Lockee1c22882019-06-10 16:02:54 -06003467 static const int condition_multiples = 0b0011;
3468 if (offset & condition_multiples) {
Dave Houlton142c4cb2018-10-17 15:04:41 -06003469 skip |= log_msg(
3470 report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Shannon McPhersonde3eeba2019-04-30 16:53:59 -06003471 HandleToUint64(commandBuffer), "VUID-vkCmdDrawMeshTasksIndirectNV-offset-02710",
Dave Houlton142c4cb2018-10-17 15:04:41 -06003472 "vkCmdDrawMeshTasksIndirectNV() parameter, VkDeviceSize offset (0x%" PRIxLEAST64 "), is not a multiple of 4.", offset);
Jeff Bolz45bf7d62018-09-18 15:39:58 -05003473 }
Lockee1c22882019-06-10 16:02:54 -06003474 if (drawCount > 1 && ((stride & condition_multiples) || stride < sizeof(VkDrawMeshTasksIndirectCommandNV))) {
3475 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
3476 HandleToUint64(commandBuffer), "VUID-vkCmdDrawMeshTasksIndirectNV-drawCount-02146",
3477 "vkCmdDrawMeshTasksIndirectNV() parameter, uint32_t stride (0x%" PRIxLEAST32
3478 "), is not a multiple of 4 or smaller than sizeof (VkDrawMeshTasksIndirectCommandNV).",
3479 stride);
3480 }
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07003481 if (!physical_device_features.multiDrawIndirect && ((drawCount > 1))) {
Jeff Bolzb574c342018-11-08 15:36:57 -06003482 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Shannon McPhersonde3eeba2019-04-30 16:53:59 -06003483 HandleToUint64(commandBuffer), "VUID-vkCmdDrawMeshTasksIndirectNV-drawCount-02718",
Jeff Bolzb574c342018-11-08 15:36:57 -06003484 "vkCmdDrawMeshTasksIndirectNV(): Device feature multiDrawIndirect disabled: count must be 0 or 1 but is %d",
3485 drawCount);
3486 }
3487
Jeff Bolz45bf7d62018-09-18 15:39:58 -05003488 return skip;
3489}
3490
Mark Lobodzinskibf599b92018-12-31 12:15:55 -07003491bool StatelessValidation::manual_PreCallValidateCmdDrawMeshTasksIndirectCountNV(VkCommandBuffer commandBuffer, VkBuffer buffer,
3492 VkDeviceSize offset, VkBuffer countBuffer,
3493 VkDeviceSize countBufferOffset,
Jeff Bolz5c801d12019-10-09 10:38:45 -05003494 uint32_t maxDrawCount, uint32_t stride) const {
Jeff Bolz45bf7d62018-09-18 15:39:58 -05003495 bool skip = false;
3496
Jeff Bolz45bf7d62018-09-18 15:39:58 -05003497 if (offset & 3) {
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07003498 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Shannon McPhersonde3eeba2019-04-30 16:53:59 -06003499 HandleToUint64(commandBuffer), "VUID-vkCmdDrawMeshTasksIndirectCountNV-offset-02710",
Jeff Bolz45bf7d62018-09-18 15:39:58 -05003500 "vkCmdDrawMeshTasksIndirectCountNV() parameter, VkDeviceSize offset (0x%" PRIxLEAST64
3501 "), is not a multiple of 4.",
3502 offset);
3503 }
3504
3505 if (countBufferOffset & 3) {
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07003506 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
Shannon McPhersonde3eeba2019-04-30 16:53:59 -06003507 HandleToUint64(commandBuffer), "VUID-vkCmdDrawMeshTasksIndirectCountNV-countBufferOffset-02716",
Jeff Bolz45bf7d62018-09-18 15:39:58 -05003508 "vkCmdDrawMeshTasksIndirectCountNV() parameter, VkDeviceSize countBufferOffset (0x%" PRIxLEAST64
3509 "), is not a multiple of 4.",
3510 countBufferOffset);
3511 }
3512
Jeff Bolz45bf7d62018-09-18 15:39:58 -05003513 return skip;
3514}
3515
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07003516bool StatelessValidation::manual_PreCallValidateCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo *pCreateInfo,
Jeff Bolz5c801d12019-10-09 10:38:45 -05003517 const VkAllocationCallbacks *pAllocator,
3518 VkQueryPool *pQueryPool) const {
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07003519 bool skip = false;
3520
3521 // Validation for parameters excluded from the generated validation code due to a 'noautovalidity' tag in vk.xml
3522 if (pCreateInfo != nullptr) {
3523 // If queryType is VK_QUERY_TYPE_PIPELINE_STATISTICS, pipelineStatistics must be a valid combination of
3524 // VkQueryPipelineStatisticFlagBits values
3525 if ((pCreateInfo->queryType == VK_QUERY_TYPE_PIPELINE_STATISTICS) && (pCreateInfo->pipelineStatistics != 0) &&
3526 ((pCreateInfo->pipelineStatistics & (~AllVkQueryPipelineStatisticFlagBits)) != 0)) {
3527 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
3528 "VUID-VkQueryPoolCreateInfo-queryType-00792",
3529 "vkCreateQueryPool(): if pCreateInfo->queryType is VK_QUERY_TYPE_PIPELINE_STATISTICS, "
3530 "pCreateInfo->pipelineStatistics must be a valid combination of VkQueryPipelineStatisticFlagBits "
3531 "values.");
3532 }
Mark Lobodzinskib7a26382018-07-02 13:14:26 -06003533 }
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07003534 return skip;
Mark Lobodzinskid4950072017-08-01 13:02:20 -06003535}
3536
Mark Lobodzinskibf599b92018-12-31 12:15:55 -07003537bool StatelessValidation::manual_PreCallValidateEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice,
3538 const char *pLayerName, uint32_t *pPropertyCount,
Jeff Bolz5c801d12019-10-09 10:38:45 -05003539 VkExtensionProperties *pProperties) const {
Mark Lobodzinskibf599b92018-12-31 12:15:55 -07003540 return validate_array("vkEnumerateDeviceExtensionProperties", "pPropertyCount", "pProperties", pPropertyCount, &pProperties,
3541 true, false, false, kVUIDUndefined, "VUID-vkEnumerateDeviceExtensionProperties-pProperties-parameter");
Mark Lobodzinskid4950072017-08-01 13:02:20 -06003542}
3543
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07003544void StatelessValidation::PostCallRecordCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo *pCreateInfo,
Mark Lobodzinskicd05c1e2019-01-17 15:33:46 -07003545 const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass,
3546 VkResult result) {
3547 if (result != VK_SUCCESS) return;
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07003548 RecordRenderPass(*pRenderPass, pCreateInfo);
Mark Lobodzinskid4950072017-08-01 13:02:20 -06003549}
3550
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07003551void StatelessValidation::PostCallRecordCreateRenderPass2KHR(VkDevice device, const VkRenderPassCreateInfo2KHR *pCreateInfo,
Mark Lobodzinskicd05c1e2019-01-17 15:33:46 -07003552 const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass,
3553 VkResult result) {
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07003554 // Track the state necessary for checking vkCreateGraphicsPipeline (subpass usage of depth and color attachments)
Mark Lobodzinskicd05c1e2019-01-17 15:33:46 -07003555 if (result != VK_SUCCESS) return;
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07003556 RecordRenderPass(*pRenderPass, pCreateInfo);
Mark Lobodzinskid4950072017-08-01 13:02:20 -06003557}
3558
Mark Lobodzinskibf599b92018-12-31 12:15:55 -07003559void StatelessValidation::PostCallRecordDestroyRenderPass(VkDevice device, VkRenderPass renderPass,
3560 const VkAllocationCallbacks *pAllocator) {
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07003561 // Track the state necessary for checking vkCreateGraphicsPipeline (subpass usage of depth and color attachments)
Mark Lobodzinskif27a6bc2019-02-04 13:00:49 -07003562 std::unique_lock<std::mutex> lock(renderpass_map_mutex);
Mark Lobodzinskiaf7c0382018-12-18 11:55:55 -07003563 renderpasses_states.erase(renderPass);
Mark Lobodzinskid4950072017-08-01 13:02:20 -06003564}
Jeff Bolz7e7e6e02019-01-11 22:53:41 -06003565
3566bool StatelessValidation::manual_PreCallValidateAllocateMemory(VkDevice device, const VkMemoryAllocateInfo *pAllocateInfo,
Jeff Bolz5c801d12019-10-09 10:38:45 -05003567 const VkAllocationCallbacks *pAllocator,
3568 VkDeviceMemory *pMemory) const {
Jeff Bolz7e7e6e02019-01-11 22:53:41 -06003569 bool skip = false;
3570
3571 if (pAllocateInfo) {
3572 auto chained_prio_struct = lvl_find_in_chain<VkMemoryPriorityAllocateInfoEXT>(pAllocateInfo->pNext);
3573 if (chained_prio_struct && (chained_prio_struct->priority < 0.0f || chained_prio_struct->priority > 1.0f)) {
3574 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
3575 "VUID-VkMemoryPriorityAllocateInfoEXT-priority-02602",
3576 "priority (=%f) must be between `0` and `1`, inclusive.", chained_prio_struct->priority);
3577 }
Jeff Bolz4563f2a2019-12-10 13:30:30 -06003578
3579 VkMemoryAllocateFlags flags = 0;
3580 auto flags_info = lvl_find_in_chain<VkMemoryAllocateFlagsInfo>(pAllocateInfo->pNext);
3581 if (flags_info) {
3582 flags = flags_info->flags;
3583 }
3584
3585 auto opaque_alloc_info = lvl_find_in_chain<VkMemoryOpaqueCaptureAddressAllocateInfoKHR>(pAllocateInfo->pNext);
3586 if (opaque_alloc_info && opaque_alloc_info->opaqueCaptureAddress != 0) {
3587 if (!(flags & VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR)) {
3588 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
3589 "VUID-VkMemoryAllocateInfo-opaqueCaptureAddress-03329",
3590 "If opaqueCaptureAddress is non-zero, VkMemoryAllocateFlagsInfo::flags must include "
3591 "VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR.");
3592 }
3593
3594#ifdef VK_USE_PLATFORM_WIN32_KHR
3595 auto import_memory_win32_handle = lvl_find_in_chain<VkImportMemoryWin32HandleInfoKHR>(pAllocateInfo->pNext);
3596#endif
3597 auto import_memory_fd = lvl_find_in_chain<VkImportMemoryFdInfoKHR>(pAllocateInfo->pNext);
3598 auto import_memory_host_pointer = lvl_find_in_chain<VkImportMemoryHostPointerInfoEXT>(pAllocateInfo->pNext);
3599#ifdef VK_USE_PLATFORM_ANDROID_KHR
3600 auto import_memory_ahb = lvl_find_in_chain<VkImportAndroidHardwareBufferInfoANDROID>(pAllocateInfo->pNext);
3601#endif
3602
3603 if (import_memory_host_pointer) {
3604 skip |= log_msg(
3605 report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
3606 "VUID-VkMemoryAllocateInfo-pNext-03332",
3607 "If the pNext chain includes a VkImportMemoryHostPointerInfoEXT structure, opaqueCaptureAddress must be zero.");
3608 }
3609 if (
3610#ifdef VK_USE_PLATFORM_WIN32_KHR
3611 (import_memory_win32_handle && import_memory_win32_handle->handleType) ||
3612#endif
3613 (import_memory_fd && import_memory_fd->handleType) ||
3614#ifdef VK_USE_PLATFORM_ANDROID_KHR
3615 (import_memory_ahb && import_memory_ahb->buffer) ||
3616#endif
3617 (import_memory_host_pointer && import_memory_host_pointer->handleType)) {
3618 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
3619 "VUID-VkMemoryAllocateInfo-opaqueCaptureAddress-03333",
3620 "If the parameters define an import operation, opaqueCaptureAddress must be zero.");
3621 }
3622 }
3623
3624 if (flags) {
Tony-LunarGa74d3fe2019-11-22 15:43:20 -07003625 VkBool32 capture_replay = false;
3626 VkBool32 buffer_device_address = false;
3627 const auto *vulkan_12_features = lvl_find_in_chain<VkPhysicalDeviceVulkan12Features>(device_createinfo_pnext);
3628 if (vulkan_12_features) {
3629 capture_replay = vulkan_12_features->bufferDeviceAddressCaptureReplay;
3630 buffer_device_address = vulkan_12_features->bufferDeviceAddress;
3631 } else {
3632 const auto *bda_features =
3633 lvl_find_in_chain<VkPhysicalDeviceBufferDeviceAddressFeaturesKHR>(device_createinfo_pnext);
3634 if (bda_features) {
3635 capture_replay = bda_features->bufferDeviceAddressCaptureReplay;
3636 buffer_device_address = bda_features->bufferDeviceAddress;
3637 }
3638 }
3639 if ((flags & VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR) && !capture_replay) {
Jeff Bolz4563f2a2019-12-10 13:30:30 -06003640 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
3641 "VUID-VkMemoryAllocateInfo-flags-03330",
3642 "If VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR is set, "
3643 "bufferDeviceAddressCaptureReplay must be enabled.");
3644 }
Tony-LunarGa74d3fe2019-11-22 15:43:20 -07003645 if ((flags & VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT_KHR) && !buffer_device_address) {
Jeff Bolz4563f2a2019-12-10 13:30:30 -06003646 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
3647 "VUID-VkMemoryAllocateInfo-flags-03331",
3648 "If VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT_KHR is set, bufferDeviceAddress must be enabled.");
3649 }
3650 }
Jeff Bolz7e7e6e02019-01-11 22:53:41 -06003651 }
3652 return skip;
3653}
Ricardo Garciaa4935972019-02-21 17:43:18 +01003654
Jason Macnak192fa0e2019-07-26 15:07:16 -07003655bool StatelessValidation::ValidateGeometryTrianglesNV(const VkGeometryTrianglesNV &triangles,
3656 VkDebugReportObjectTypeEXT object_type, uint64_t object_handle,
3657 const char *func_name) const {
3658 bool skip = false;
3659
3660 if (triangles.vertexFormat != VK_FORMAT_R32G32B32_SFLOAT && triangles.vertexFormat != VK_FORMAT_R16G16B16_SFLOAT &&
3661 triangles.vertexFormat != VK_FORMAT_R16G16B16_SNORM && triangles.vertexFormat != VK_FORMAT_R32G32_SFLOAT &&
3662 triangles.vertexFormat != VK_FORMAT_R16G16_SFLOAT && triangles.vertexFormat != VK_FORMAT_R16G16_SNORM) {
3663 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, object_type, object_handle,
3664 "VUID-VkGeometryTrianglesNV-vertexFormat-02430", "%s", func_name);
3665 } else {
3666 uint32_t vertex_component_size = 0;
3667 if (triangles.vertexFormat == VK_FORMAT_R32G32B32_SFLOAT || triangles.vertexFormat == VK_FORMAT_R32G32_SFLOAT) {
3668 vertex_component_size = 4;
3669 } else if (triangles.vertexFormat == VK_FORMAT_R16G16B16_SFLOAT || triangles.vertexFormat == VK_FORMAT_R16G16B16_SNORM ||
3670 triangles.vertexFormat == VK_FORMAT_R16G16_SFLOAT || triangles.vertexFormat == VK_FORMAT_R16G16_SNORM) {
3671 vertex_component_size = 2;
3672 }
3673 if (vertex_component_size > 0 && SafeModulo(triangles.vertexOffset, vertex_component_size) != 0) {
3674 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, object_type, object_handle,
3675 "VUID-VkGeometryTrianglesNV-vertexOffset-02429", "%s", func_name);
3676 }
3677 }
3678
3679 if (triangles.indexType != VK_INDEX_TYPE_UINT32 && triangles.indexType != VK_INDEX_TYPE_UINT16 &&
3680 triangles.indexType != VK_INDEX_TYPE_NONE_NV) {
3681 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, object_type, object_handle,
3682 "VUID-VkGeometryTrianglesNV-indexType-02433", "%s", func_name);
3683 } else {
3684 uint32_t index_element_size = 0;
3685 if (triangles.indexType == VK_INDEX_TYPE_UINT32) {
3686 index_element_size = 4;
3687 } else if (triangles.indexType == VK_INDEX_TYPE_UINT16) {
3688 index_element_size = 2;
3689 }
3690 if (index_element_size > 0 && SafeModulo(triangles.indexOffset, index_element_size) != 0) {
3691 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, object_type, object_handle,
3692 "VUID-VkGeometryTrianglesNV-indexOffset-02432", "%s", func_name);
3693 }
3694 }
3695 if (triangles.indexType == VK_INDEX_TYPE_NONE_NV) {
3696 if (triangles.indexCount != 0) {
3697 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, object_type, object_handle,
3698 "VUID-VkGeometryTrianglesNV-indexCount-02436", "%s", func_name);
3699 }
3700 if (triangles.indexData != VK_NULL_HANDLE) {
3701 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, object_type, object_handle,
3702 "VUID-VkGeometryTrianglesNV-indexData-02434", "%s", func_name);
3703 }
3704 }
3705
3706 if (SafeModulo(triangles.transformOffset, 16) != 0) {
3707 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, object_type, object_handle,
3708 "VUID-VkGeometryTrianglesNV-transformOffset-02438", "%s", func_name);
3709 }
3710
3711 return skip;
3712}
3713
3714bool StatelessValidation::ValidateGeometryAABBNV(const VkGeometryAABBNV &aabbs, VkDebugReportObjectTypeEXT object_type,
3715 uint64_t object_handle, const char *func_name) const {
3716 bool skip = false;
3717
3718 if (SafeModulo(aabbs.offset, 8) != 0) {
3719 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, object_type, object_handle,
3720 "VUID-VkGeometryAABBNV-offset-02440", "%s", func_name);
3721 }
3722 if (SafeModulo(aabbs.stride, 8) != 0) {
3723 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, object_type, object_handle,
3724 "VUID-VkGeometryAABBNV-stride-02441", "%s", func_name);
3725 }
3726
3727 return skip;
3728}
3729
3730bool StatelessValidation::ValidateGeometryNV(const VkGeometryNV &geometry, VkDebugReportObjectTypeEXT object_type,
3731 uint64_t object_handle, const char *func_name) const {
3732 bool skip = false;
3733 if (geometry.geometryType == VK_GEOMETRY_TYPE_TRIANGLES_NV) {
3734 skip = ValidateGeometryTrianglesNV(geometry.geometry.triangles, object_type, object_handle, func_name);
3735 } else if (geometry.geometryType == VK_GEOMETRY_TYPE_AABBS_NV) {
3736 skip = ValidateGeometryAABBNV(geometry.geometry.aabbs, object_type, object_handle, func_name);
3737 }
3738 return skip;
3739}
3740
3741bool StatelessValidation::ValidateAccelerationStructureInfoNV(const VkAccelerationStructureInfoNV &info,
3742 VkDebugReportObjectTypeEXT object_type, uint64_t object_handle,
3743 const char *func_name) const {
Jason Macnak5c954952019-07-09 15:46:12 -07003744 bool skip = false;
3745 if (info.type == VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV && info.geometryCount != 0) {
Jason Macnak192fa0e2019-07-26 15:07:16 -07003746 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, object_type, object_handle,
Jason Macnak5c954952019-07-09 15:46:12 -07003747 "VUID-VkAccelerationStructureInfoNV-type-02425",
3748 "VkAccelerationStructureInfoNV: If type is VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV then "
3749 "geometryCount must be 0.");
3750 }
3751 if (info.type == VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV && info.instanceCount != 0) {
Jason Macnak192fa0e2019-07-26 15:07:16 -07003752 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, object_type, object_handle,
Jason Macnak5c954952019-07-09 15:46:12 -07003753 "VUID-VkAccelerationStructureInfoNV-type-02426",
3754 "VkAccelerationStructureInfoNV: If type is VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV then "
3755 "instanceCount must be 0.");
3756 }
3757 if (info.flags & VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_NV &&
3758 info.flags & VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_NV) {
Jason Macnak192fa0e2019-07-26 15:07:16 -07003759 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, object_type, object_handle,
Jason Macnak5c954952019-07-09 15:46:12 -07003760 "VUID-VkAccelerationStructureInfoNV-flags-02592",
3761 "VkAccelerationStructureInfoNV: If flags has the VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_NV"
3762 "bit set, then it must not have the VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_NV bit set.");
3763 }
3764 if (info.geometryCount > phys_dev_ext_props.ray_tracing_props.maxGeometryCount) {
Jason Macnak192fa0e2019-07-26 15:07:16 -07003765 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, object_type, object_handle,
Jason Macnak5c954952019-07-09 15:46:12 -07003766 "VUID-VkAccelerationStructureInfoNV-geometryCount-02422",
3767 "VkAccelerationStructureInfoNV: geometryCount must be less than or equal to "
3768 "VkPhysicalDeviceRayTracingPropertiesNV::maxGeometryCount.");
3769 }
3770 if (info.instanceCount > phys_dev_ext_props.ray_tracing_props.maxInstanceCount) {
Jason Macnak192fa0e2019-07-26 15:07:16 -07003771 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, object_type, object_handle,
Jason Macnak5c954952019-07-09 15:46:12 -07003772 "VUID-VkAccelerationStructureInfoNV-instanceCount-02423",
3773 "VkAccelerationStructureInfoNV: instanceCount must be less than or equal to "
3774 "VkPhysicalDeviceRayTracingPropertiesNV::maxInstanceCount.");
3775 }
Jason Macnak21ba97e2019-08-09 12:57:44 -07003776 if (info.type == VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV && info.geometryCount > 0) {
Jason Macnak5c954952019-07-09 15:46:12 -07003777 uint64_t total_triangle_count = 0;
3778 for (uint32_t i = 0; i < info.geometryCount; i++) {
3779 const VkGeometryNV &geometry = info.pGeometries[i];
Jason Macnak192fa0e2019-07-26 15:07:16 -07003780
3781 skip |= ValidateGeometryNV(geometry, object_type, object_handle, func_name);
3782
Jason Macnak5c954952019-07-09 15:46:12 -07003783 if (geometry.geometryType != VK_GEOMETRY_TYPE_TRIANGLES_NV) {
3784 continue;
3785 }
3786 total_triangle_count += geometry.geometry.triangles.indexCount / 3;
3787 }
3788 if (total_triangle_count > phys_dev_ext_props.ray_tracing_props.maxTriangleCount) {
Jason Macnak192fa0e2019-07-26 15:07:16 -07003789 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, object_type, object_handle,
3790 "VUID-VkAccelerationStructureInfoNV-maxTriangleCount-02424",
Jason Macnak5c954952019-07-09 15:46:12 -07003791 "VkAccelerationStructureInfoNV: The total number of triangles in all geometries must be less than "
3792 "or equal to VkPhysicalDeviceRayTracingPropertiesNV::maxTriangleCount.");
3793 }
3794 }
Jason Macnak21ba97e2019-08-09 12:57:44 -07003795 if (info.type == VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV && info.geometryCount > 1) {
3796 const VkGeometryTypeNV first_geometry_type = info.pGeometries[0].geometryType;
3797 for (uint32_t i = 1; i < info.geometryCount; i++) {
3798 const VkGeometryNV &geometry = info.pGeometries[i];
3799 if (geometry.geometryType != first_geometry_type) {
3800 // TODO: update fake VUID below with the real one once it is generated.
3801 skip |=
3802 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT,
3803 0, "UNASSIGNED-VkAccelerationStructureInfoNV-pGeometries-XXXX",
3804 "VkAccelerationStructureInfoNV: info.pGeometries[%d].geometryType does not match "
3805 "info.pGeometries[0].geometryType.",
3806 i);
3807 }
3808 }
3809 }
Jason Macnak5c954952019-07-09 15:46:12 -07003810 return skip;
3811}
3812
Ricardo Garciaa4935972019-02-21 17:43:18 +01003813bool StatelessValidation::manual_PreCallValidateCreateAccelerationStructureNV(
3814 VkDevice device, const VkAccelerationStructureCreateInfoNV *pCreateInfo, const VkAllocationCallbacks *pAllocator,
Jeff Bolz5c801d12019-10-09 10:38:45 -05003815 VkAccelerationStructureNV *pAccelerationStructure) const {
Ricardo Garciaa4935972019-02-21 17:43:18 +01003816 bool skip = false;
3817
3818 if (pCreateInfo) {
3819 if ((pCreateInfo->compactedSize != 0) &&
3820 ((pCreateInfo->info.geometryCount != 0) || (pCreateInfo->info.instanceCount != 0))) {
3821 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
3822 "VUID-VkAccelerationStructureCreateInfoNV-compactedSize-02421",
3823 "vkCreateAccelerationStructureNV(): pCreateInfo->compactedSize nonzero (%" PRIu64
3824 ") with info.geometryCount (%" PRIu32 ") or info.instanceCount (%" PRIu32 ") nonzero.",
3825 pCreateInfo->compactedSize, pCreateInfo->info.geometryCount, pCreateInfo->info.instanceCount);
3826 }
Jason Macnak5c954952019-07-09 15:46:12 -07003827
Jason Macnak192fa0e2019-07-26 15:07:16 -07003828 skip |= ValidateAccelerationStructureInfoNV(pCreateInfo->info, VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT, 0,
3829 "vkCreateAccelerationStructureNV()");
Ricardo Garciaa4935972019-02-21 17:43:18 +01003830 }
3831
3832 return skip;
3833}
Mike Schuchardt21638df2019-03-16 10:52:02 -07003834
Jeff Bolz5c801d12019-10-09 10:38:45 -05003835bool StatelessValidation::manual_PreCallValidateCmdBuildAccelerationStructureNV(VkCommandBuffer commandBuffer,
3836 const VkAccelerationStructureInfoNV *pInfo,
3837 VkBuffer instanceData, VkDeviceSize instanceOffset,
3838 VkBool32 update, VkAccelerationStructureNV dst,
3839 VkAccelerationStructureNV src, VkBuffer scratch,
3840 VkDeviceSize scratchOffset) const {
Jason Macnak5c954952019-07-09 15:46:12 -07003841 bool skip = false;
3842
3843 if (pInfo != nullptr) {
Jason Macnak192fa0e2019-07-26 15:07:16 -07003844 skip |= ValidateAccelerationStructureInfoNV(*pInfo, VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT,
3845 HandleToUint64(dst), "vkCmdBuildAccelerationStructureNV()");
Jason Macnak5c954952019-07-09 15:46:12 -07003846 }
3847
3848 return skip;
3849}
3850
3851bool StatelessValidation::manual_PreCallValidateGetAccelerationStructureHandleNV(VkDevice device,
3852 VkAccelerationStructureNV accelerationStructure,
Jeff Bolz5c801d12019-10-09 10:38:45 -05003853 size_t dataSize, void *pData) const {
Jason Macnak5c954952019-07-09 15:46:12 -07003854 bool skip = false;
3855 if (dataSize < 8) {
3856 skip = log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT,
3857 HandleToUint64(accelerationStructure), "VUID-vkGetAccelerationStructureHandleNV-dataSize-02240",
3858 "vkGetAccelerationStructureHandleNV(): dataSize must be greater than or equal to 8.");
3859 }
3860 return skip;
3861}
3862
Peter Chen85366392019-05-14 15:20:11 -04003863bool StatelessValidation::manual_PreCallValidateCreateRayTracingPipelinesNV(VkDevice device, VkPipelineCache pipelineCache,
3864 uint32_t createInfoCount,
3865 const VkRayTracingPipelineCreateInfoNV *pCreateInfos,
3866 const VkAllocationCallbacks *pAllocator,
Jeff Bolz5c801d12019-10-09 10:38:45 -05003867 VkPipeline *pPipelines) const {
Peter Chen85366392019-05-14 15:20:11 -04003868 bool skip = false;
3869
3870 for (uint32_t i = 0; i < createInfoCount; i++) {
3871 auto feedback_struct = lvl_find_in_chain<VkPipelineCreationFeedbackCreateInfoEXT>(pCreateInfos[i].pNext);
3872 if ((feedback_struct != nullptr) && (feedback_struct->pipelineStageCreationFeedbackCount != pCreateInfos[i].stageCount)) {
3873 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, VK_NULL_HANDLE,
3874 "VUID-VkPipelineCreationFeedbackCreateInfoEXT-pipelineStageCreationFeedbackCount-02670",
3875 "vkCreateRayTracingPipelinesNV(): in pCreateInfo[%" PRIu32
3876 "], VkPipelineCreationFeedbackEXT::pipelineStageCreationFeedbackCount"
3877 "(=%" PRIu32 ") must equal VkRayTracingPipelineCreateInfoNV::stageCount(=%" PRIu32 ").",
3878 i, feedback_struct->pipelineStageCreationFeedbackCount, pCreateInfos[i].stageCount);
3879 }
3880 }
3881
3882 return skip;
3883}
3884
Mike Schuchardt21638df2019-03-16 10:52:02 -07003885#ifdef VK_USE_PLATFORM_WIN32_KHR
3886bool StatelessValidation::PreCallValidateGetDeviceGroupSurfacePresentModes2EXT(VkDevice device,
3887 const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo,
Jeff Bolz5c801d12019-10-09 10:38:45 -05003888 VkDeviceGroupPresentModeFlagsKHR *pModes) const {
Mike Schuchardt21638df2019-03-16 10:52:02 -07003889 bool skip = false;
3890 if (!device_extensions.vk_khr_swapchain)
3891 skip |= OutputExtensionError("vkGetDeviceGroupSurfacePresentModes2EXT", VK_KHR_SWAPCHAIN_EXTENSION_NAME);
3892 if (!device_extensions.vk_khr_get_surface_capabilities_2)
3893 skip |= OutputExtensionError("vkGetDeviceGroupSurfacePresentModes2EXT", VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME);
3894 if (!device_extensions.vk_khr_surface)
3895 skip |= OutputExtensionError("vkGetDeviceGroupSurfacePresentModes2EXT", VK_KHR_SURFACE_EXTENSION_NAME);
3896 if (!device_extensions.vk_khr_get_physical_device_properties_2)
3897 skip |=
3898 OutputExtensionError("vkGetDeviceGroupSurfacePresentModes2EXT", VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
3899 if (!device_extensions.vk_ext_full_screen_exclusive)
3900 skip |= OutputExtensionError("vkGetDeviceGroupSurfacePresentModes2EXT", VK_EXT_FULL_SCREEN_EXCLUSIVE_EXTENSION_NAME);
3901 skip |= validate_struct_type(
3902 "vkGetDeviceGroupSurfacePresentModes2EXT", "pSurfaceInfo", "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR",
3903 pSurfaceInfo, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR, true,
3904 "VUID-vkGetDeviceGroupSurfacePresentModes2EXT-pSurfaceInfo-parameter", "VUID-VkPhysicalDeviceSurfaceInfo2KHR-sType-sType");
3905 if (pSurfaceInfo != NULL) {
3906 const VkStructureType allowed_structs_VkPhysicalDeviceSurfaceInfo2KHR[] = {
3907 VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT,
3908 VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT};
3909
3910 skip |= validate_struct_pnext("vkGetDeviceGroupSurfacePresentModes2EXT", "pSurfaceInfo->pNext",
3911 "VkSurfaceFullScreenExclusiveInfoEXT, VkSurfaceFullScreenExclusiveWin32InfoEXT",
3912 pSurfaceInfo->pNext, ARRAY_SIZE(allowed_structs_VkPhysicalDeviceSurfaceInfo2KHR),
3913 allowed_structs_VkPhysicalDeviceSurfaceInfo2KHR, GeneratedVulkanHeaderVersion,
3914 "VUID-VkPhysicalDeviceSurfaceInfo2KHR-pNext-pNext");
3915
3916 skip |= validate_required_handle("vkGetDeviceGroupSurfacePresentModes2EXT", "pSurfaceInfo->surface", pSurfaceInfo->surface);
3917 }
3918 return skip;
3919}
3920#endif
Tobias Hectorebb855f2019-07-23 12:17:33 +01003921
3922bool StatelessValidation::manual_PreCallValidateCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo *pCreateInfo,
3923 const VkAllocationCallbacks *pAllocator,
Jeff Bolz5c801d12019-10-09 10:38:45 -05003924 VkFramebuffer *pFramebuffer) const {
Tobias Hectorebb855f2019-07-23 12:17:33 +01003925 // Validation for pAttachments which is excluded from the generated validation code due to a 'noautovalidity' tag in vk.xml
3926 bool skip = false;
3927 if ((pCreateInfo->flags & VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR) == 0) {
3928 skip |= validate_array("vkCreateFramebuffer", "attachmentCount", "pAttachments", pCreateInfo->attachmentCount,
3929 &pCreateInfo->pAttachments, false, true, kVUIDUndefined, kVUIDUndefined);
3930 }
3931 return skip;
3932}
Jeff Bolz8125a8b2019-08-16 16:29:45 -05003933
3934bool StatelessValidation::manual_PreCallValidateCmdSetLineStippleEXT(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor,
Jeff Bolz5c801d12019-10-09 10:38:45 -05003935 uint16_t lineStipplePattern) const {
Jeff Bolz8125a8b2019-08-16 16:29:45 -05003936 bool skip = false;
3937
3938 if (lineStippleFactor < 1 || lineStippleFactor > 256) {
3939 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
3940 HandleToUint64(commandBuffer), "VUID-vkCmdSetLineStippleEXT-lineStippleFactor-02776",
3941 "vkCmdSetLineStippleEXT::lineStippleFactor=%d is not in [1,256].", lineStippleFactor);
3942 }
3943
3944 return skip;
3945}
Piers Daniell8fd03f52019-08-21 12:07:53 -06003946
3947bool StatelessValidation::manual_PreCallValidateCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer,
Jeff Bolz5c801d12019-10-09 10:38:45 -05003948 VkDeviceSize offset, VkIndexType indexType) const {
Piers Daniell8fd03f52019-08-21 12:07:53 -06003949 bool skip = false;
3950
3951 if (indexType == VK_INDEX_TYPE_NONE_NV) {
3952 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
3953 HandleToUint64(commandBuffer), "VUID-vkCmdBindIndexBuffer-indexType-02507",
3954 "vkCmdBindIndexBuffer() indexType must not be VK_INDEX_TYPE_NONE_NV.");
3955 }
3956
Tony-LunarG6c3c5452019-12-13 10:37:38 -07003957 const auto *index_type_uint8_features = lvl_find_in_chain<VkPhysicalDeviceIndexTypeUint8FeaturesEXT>(device_createinfo_pnext);
Piers Daniell8fd03f52019-08-21 12:07:53 -06003958 if (indexType == VK_INDEX_TYPE_UINT8_EXT && !index_type_uint8_features->indexTypeUint8) {
3959 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
3960 HandleToUint64(commandBuffer), "VUID-vkCmdBindIndexBuffer-indexType-02765",
3961 "vkCmdBindIndexBuffer() indexType is VK_INDEX_TYPE_UINT8_EXT but indexTypeUint8 feature is not enabled.");
3962 }
3963
3964 return skip;
3965}
Mark Lobodzinski84988402019-09-11 15:27:30 -06003966
3967bool StatelessValidation::manual_PreCallValidateSetDebugUtilsObjectNameEXT(VkDevice device,
Jeff Bolz5c801d12019-10-09 10:38:45 -05003968 const VkDebugUtilsObjectNameInfoEXT *pNameInfo) const {
Mark Lobodzinski84988402019-09-11 15:27:30 -06003969 bool skip = false;
3970 if (pNameInfo->objectType == VK_OBJECT_TYPE_UNKNOWN) {
3971 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, HandleToUint64(device),
3972 "VUID-VkDebugUtilsObjectNameInfoEXT-objectType-02589",
3973 "vkSetDebugUtilsObjectNameEXT() pNameInfo->objectType cannot be VK_OBJECT_TYPE_UNKNOWN.");
3974 }
3975 return skip;
3976}
3977
3978bool StatelessValidation::manual_PreCallValidateSetDebugUtilsObjectTagEXT(VkDevice device,
Jeff Bolz5c801d12019-10-09 10:38:45 -05003979 const VkDebugUtilsObjectTagInfoEXT *pTagInfo) const {
Mark Lobodzinski84988402019-09-11 15:27:30 -06003980 bool skip = false;
3981 if (pTagInfo->objectType == VK_OBJECT_TYPE_UNKNOWN) {
3982 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, HandleToUint64(device),
3983 "VUID-VkDebugUtilsObjectTagInfoEXT-objectType-01908",
3984 "vkSetDebugUtilsObjectTagEXT() pTagInfo->objectType cannot be VK_OBJECT_TYPE_UNKNOWN.");
3985 }
3986 return skip;
3987}
Petr Kraus3d720392019-11-13 02:52:39 +01003988
3989bool StatelessValidation::manual_PreCallValidateAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout,
3990 VkSemaphore semaphore, VkFence fence,
3991 uint32_t *pImageIndex) const {
3992 bool skip = false;
3993
3994 if (semaphore == VK_NULL_HANDLE && fence == VK_NULL_HANDLE) {
3995 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT,
3996 HandleToUint64(swapchain), "VUID-vkAcquireNextImageKHR-semaphore-01780",
3997 "vkAcquireNextImageKHR: semaphore and fence are both VK_NULL_HANDLE.");
3998 }
3999
4000 return skip;
4001}
4002
4003bool StatelessValidation::manual_PreCallValidateAcquireNextImage2KHR(VkDevice device, const VkAcquireNextImageInfoKHR *pAcquireInfo,
4004 uint32_t *pImageIndex) const {
4005 bool skip = false;
4006
4007 if (pAcquireInfo->semaphore == VK_NULL_HANDLE && pAcquireInfo->fence == VK_NULL_HANDLE) {
4008 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT,
4009 HandleToUint64(pAcquireInfo->swapchain), "VUID-VkAcquireNextImageInfoKHR-semaphore-01782",
4010 "vkAcquireNextImage2KHR: pAcquireInfo->semaphore and pAcquireInfo->fence are both VK_NULL_HANDLE.");
4011 }
4012
4013 return skip;
4014}
Mark Lobodzinski953b7bc2019-12-19 13:50:10 -07004015
4016bool StatelessValidation::manual_PreCallValidateCmdDrawIndirectByteCountEXT(VkCommandBuffer commandBuffer, uint32_t instanceCount,
4017 uint32_t firstInstance, VkBuffer counterBuffer,
4018 VkDeviceSize counterBufferOffset,
4019 uint32_t counterOffset, uint32_t vertexStride) const {
4020 bool skip = false;
4021
4022 if ((vertexStride <= 0) || (vertexStride > phys_dev_ext_props.transform_feedback_props.maxTransformFeedbackBufferDataStride)) {
4023 skip |= log_msg(
4024 report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, HandleToUint64(counterBuffer),
4025 "VUID-vkCmdDrawIndirectByteCountEXT-vertexStride-02289",
4026 "vkCmdDrawIndirectByteCountEXT: vertexStride (%d) must be between 0 and maxTransformFeedbackBufferDataStride (%d).",
4027 vertexStride, phys_dev_ext_props.transform_feedback_props.maxTransformFeedbackBufferDataStride);
4028 }
4029
4030 return skip;
4031}
sfricke-samsung11ea8ed2020-01-07 22:24:56 -08004032
4033bool StatelessValidation::ValidateCreateSamplerYcbcrConversion(VkDevice device,
4034 const VkSamplerYcbcrConversionCreateInfo *pCreateInfo,
4035 const VkAllocationCallbacks *pAllocator,
4036 VkSamplerYcbcrConversion *pYcbcrConversion,
4037 const char *apiName) const {
4038 bool skip = false;
4039
4040 // Check samplerYcbcrConversion feature is set
Tony-LunarG6c3c5452019-12-13 10:37:38 -07004041 const auto *ycbcr_features = lvl_find_in_chain<VkPhysicalDeviceSamplerYcbcrConversionFeatures>(device_createinfo_pnext);
sfricke-samsung11ea8ed2020-01-07 22:24:56 -08004042 if ((ycbcr_features == nullptr) || (ycbcr_features->samplerYcbcrConversion == VK_FALSE)) {
4043 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
4044 "VUID-vkCreateSamplerYcbcrConversion-None-01648", "samplerYcbcrConversion must be enabled to call %s.",
4045 apiName);
4046 }
4047 return skip;
4048}
4049
4050bool StatelessValidation::manual_PreCallValidateCreateSamplerYcbcrConversion(VkDevice device,
4051 const VkSamplerYcbcrConversionCreateInfo *pCreateInfo,
4052 const VkAllocationCallbacks *pAllocator,
4053 VkSamplerYcbcrConversion *pYcbcrConversion) const {
4054 return ValidateCreateSamplerYcbcrConversion(device, pCreateInfo, pAllocator, pYcbcrConversion,
4055 "vkCreateSamplerYcbcrConversion");
4056}
4057
4058bool StatelessValidation::manual_PreCallValidateCreateSamplerYcbcrConversionKHR(
4059 VkDevice device, const VkSamplerYcbcrConversionCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator,
4060 VkSamplerYcbcrConversion *pYcbcrConversion) const {
4061 return ValidateCreateSamplerYcbcrConversion(device, pCreateInfo, pAllocator, pYcbcrConversion,
4062 "vkCreateSamplerYcbcrConversionKHR");
4063}
sfricke-samsung1708a8c2020-02-10 00:35:06 -08004064
4065bool StatelessValidation::manual_PreCallValidateImportSemaphoreFdKHR(
4066 VkDevice device, const VkImportSemaphoreFdInfoKHR *pImportSemaphoreFdInfo) const {
4067 bool skip = false;
4068 VkExternalSemaphoreHandleTypeFlags supported_handle_types =
4069 VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT | VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT;
4070
4071 if (0 == (pImportSemaphoreFdInfo->handleType & supported_handle_types)) {
4072 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT, 0,
4073 "VUID-VkImportSemaphoreFdInfoKHR-handleType-01143",
4074 "vkImportSemaphoreFdKHR() to semaphore %s handleType %s is not one of the supported handleTypes (%s).",
4075 report_data->FormatHandle(pImportSemaphoreFdInfo->semaphore).c_str(),
4076 string_VkExternalSemaphoreHandleTypeFlagBits(pImportSemaphoreFdInfo->handleType),
4077 string_VkExternalSemaphoreHandleTypeFlags(supported_handle_types).c_str());
4078 }
4079 return skip;
4080}