layers:Migrate to new validation error IDs
Migrate valid usage IDs to new numbers based on the string IDs that are
integrated into the spec build process.
The formula for mapping the string ID to the new VALIDATION_ERROR enum
value is in vuid_mapping.py script.
The mapping between the old IDs and the new IDs is in the file
"old_vuid_to_new_mapping.txt."
The vk_validation_error_database.txt file has the new IDs as well as
the string-based ID for each element and a column indicating if the
valid usage is in the core spec or if it requires extension(s) and is
therefore in the extension spec.
The error messages were shortened and no longer include a section
reference. Now the link goes directly to the line in the spec where
the valid usage text occurs. The base of the spec link is the core spec
unless the VU requires an extension in which case the spec with all
extensions is used as the base.
diff --git a/layers/object_tracker.cpp b/layers/object_tracker.cpp
index f167f18..cf5a878 100644
--- a/layers/object_tracker.cpp
+++ b/layers/object_tracker.cpp
@@ -109,9 +109,9 @@
if ((instance_data->queue_family_properties[pQueueInfo->queue_node_index].queueFlags & VK_QUEUE_SPARSE_BINDING_BIT) ==
0) {
log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT,
- HandleToUint64(queue), __LINE__, VALIDATION_ERROR_01651, LayerName,
+ HandleToUint64(queue), __LINE__, VALIDATION_ERROR_31600011, LayerName,
"Attempting %s on a non-memory-management capable queue -- VK_QUEUE_SPARSE_BINDING_BIT not set. %s",
- function, validation_error_map[VALIDATION_ERROR_01651]);
+ function, validation_error_map[VALIDATION_ERROR_31600011]);
}
}
}
@@ -150,16 +150,17 @@
if (pNode->parent_object != HandleToUint64(command_pool)) {
skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
- object_handle, __LINE__, VALIDATION_ERROR_00102, LayerName,
+ object_handle, __LINE__, VALIDATION_ERROR_28411407, LayerName,
"FreeCommandBuffers is attempting to free Command Buffer 0x%" PRIxLEAST64
" belonging to Command Pool 0x%" PRIxLEAST64 " from pool 0x%" PRIxLEAST64 "). %s",
HandleToUint64(command_buffer), pNode->parent_object, HandleToUint64(command_pool),
- validation_error_map[VALIDATION_ERROR_00102]);
+ validation_error_map[VALIDATION_ERROR_28411407]);
}
} else {
- skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
- object_handle, __LINE__, VALIDATION_ERROR_00097, LayerName, "Invalid %s Object 0x%" PRIxLEAST64 ". %s",
- object_string[kVulkanObjectTypeCommandBuffer], object_handle, validation_error_map[VALIDATION_ERROR_00097]);
+ skip |=
+ log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
+ object_handle, __LINE__, VALIDATION_ERROR_28400060, LayerName, "Invalid %s Object 0x%" PRIxLEAST64 ". %s",
+ object_string[kVulkanObjectTypeCommandBuffer], object_handle, validation_error_map[VALIDATION_ERROR_28400060]);
}
return skip;
}
@@ -192,16 +193,17 @@
if (pNode->parent_object != HandleToUint64(descriptor_pool)) {
skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT,
- object_handle, __LINE__, VALIDATION_ERROR_00927, LayerName,
+ object_handle, __LINE__, VALIDATION_ERROR_28613007, LayerName,
"FreeDescriptorSets is attempting to free descriptorSet 0x%" PRIxLEAST64
" belonging to Descriptor Pool 0x%" PRIxLEAST64 " from pool 0x%" PRIxLEAST64 "). %s",
HandleToUint64(descriptor_set), pNode->parent_object, HandleToUint64(descriptor_pool),
- validation_error_map[VALIDATION_ERROR_00927]);
+ validation_error_map[VALIDATION_ERROR_28613007]);
}
} else {
- skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT,
- object_handle, __LINE__, VALIDATION_ERROR_00920, LayerName, "Invalid %s Object 0x%" PRIxLEAST64 ". %s",
- object_string[kVulkanObjectTypeDescriptorSet], object_handle, validation_error_map[VALIDATION_ERROR_00920]);
+ skip |=
+ log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT,
+ object_handle, __LINE__, VALIDATION_ERROR_2860026c, LayerName, "Invalid %s Object 0x%" PRIxLEAST64 ". %s",
+ object_string[kVulkanObjectTypeDescriptorSet], object_handle, validation_error_map[VALIDATION_ERROR_2860026c]);
}
return skip;
}
@@ -393,9 +395,9 @@
}
// TODO: The instance handle can not be validated here. The loader will likely have to validate it.
- ValidateObject(instance, instance, kVulkanObjectTypeInstance, true, VALIDATION_ERROR_00021, VALIDATION_ERROR_UNDEFINED);
+ ValidateObject(instance, instance, kVulkanObjectTypeInstance, true, VALIDATION_ERROR_2580bc01, VALIDATION_ERROR_UNDEFINED);
- DestroyObject(instance, instance, kVulkanObjectTypeInstance, pAllocator, VALIDATION_ERROR_00019, VALIDATION_ERROR_00020);
+ DestroyObject(instance, instance, kVulkanObjectTypeInstance, pAllocator, VALIDATION_ERROR_258004ec, VALIDATION_ERROR_258004ee);
// Report any remaining objects in LL
for (auto iit = instance_data->object_map[kVulkanObjectTypeDevice].begin();
@@ -408,35 +410,35 @@
log_msg(instance_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, debug_object_type, pNode->handle, __LINE__,
OBJTRACK_OBJECT_LEAK, LayerName, "OBJ ERROR : %s object 0x%" PRIxLEAST64 " has not been destroyed.",
string_VkDebugReportObjectTypeEXT(debug_object_type), pNode->handle);
- DeviceReportUndestroyedObjects(device, kVulkanObjectTypeCommandBuffer, VALIDATION_ERROR_00018);
- DeviceReportUndestroyedObjects(device, kVulkanObjectTypeSemaphore, VALIDATION_ERROR_00018);
- DeviceReportUndestroyedObjects(device, kVulkanObjectTypeFence, VALIDATION_ERROR_00018);
- DeviceReportUndestroyedObjects(device, kVulkanObjectTypeDeviceMemory, VALIDATION_ERROR_00018);
- DeviceReportUndestroyedObjects(device, kVulkanObjectTypeBuffer, VALIDATION_ERROR_00018);
- DeviceReportUndestroyedObjects(device, kVulkanObjectTypeImage, VALIDATION_ERROR_00018);
- DeviceReportUndestroyedObjects(device, kVulkanObjectTypeEvent, VALIDATION_ERROR_00018);
- DeviceReportUndestroyedObjects(device, kVulkanObjectTypeQueryPool, VALIDATION_ERROR_00018);
- DeviceReportUndestroyedObjects(device, kVulkanObjectTypeBufferView, VALIDATION_ERROR_00018);
- DeviceReportUndestroyedObjects(device, kVulkanObjectTypeImageView, VALIDATION_ERROR_00018);
- DeviceReportUndestroyedObjects(device, kVulkanObjectTypeShaderModule, VALIDATION_ERROR_00018);
- DeviceReportUndestroyedObjects(device, kVulkanObjectTypePipelineCache, VALIDATION_ERROR_00018);
- DeviceReportUndestroyedObjects(device, kVulkanObjectTypePipelineLayout, VALIDATION_ERROR_00018);
- DeviceReportUndestroyedObjects(device, kVulkanObjectTypeRenderPass, VALIDATION_ERROR_00018);
- DeviceReportUndestroyedObjects(device, kVulkanObjectTypePipeline, VALIDATION_ERROR_00018);
- DeviceReportUndestroyedObjects(device, kVulkanObjectTypeDescriptorSetLayout, VALIDATION_ERROR_00018);
- DeviceReportUndestroyedObjects(device, kVulkanObjectTypeSampler, VALIDATION_ERROR_00018);
- DeviceReportUndestroyedObjects(device, kVulkanObjectTypeDescriptorPool, VALIDATION_ERROR_00018);
- DeviceReportUndestroyedObjects(device, kVulkanObjectTypeDescriptorSet, VALIDATION_ERROR_00018);
- DeviceReportUndestroyedObjects(device, kVulkanObjectTypeFramebuffer, VALIDATION_ERROR_00018);
- DeviceReportUndestroyedObjects(device, kVulkanObjectTypeCommandPool, VALIDATION_ERROR_00018);
- DeviceReportUndestroyedObjects(device, kVulkanObjectTypeSurfaceKHR, VALIDATION_ERROR_00018);
- DeviceReportUndestroyedObjects(device, kVulkanObjectTypeSwapchainKHR, VALIDATION_ERROR_00018);
- DeviceReportUndestroyedObjects(device, kVulkanObjectTypeDisplayKHR, VALIDATION_ERROR_00018);
- DeviceReportUndestroyedObjects(device, kVulkanObjectTypeDisplayModeKHR, VALIDATION_ERROR_00018);
- DeviceReportUndestroyedObjects(device, kVulkanObjectTypeDescriptorUpdateTemplateKHR, VALIDATION_ERROR_00018);
- DeviceReportUndestroyedObjects(device, kVulkanObjectTypeDebugReportCallbackEXT, VALIDATION_ERROR_00018);
- DeviceReportUndestroyedObjects(device, kVulkanObjectTypeObjectTableNVX, VALIDATION_ERROR_00018);
- DeviceReportUndestroyedObjects(device, kVulkanObjectTypeIndirectCommandsLayoutNVX, VALIDATION_ERROR_00018);
+ DeviceReportUndestroyedObjects(device, kVulkanObjectTypeCommandBuffer, VALIDATION_ERROR_258004ea);
+ DeviceReportUndestroyedObjects(device, kVulkanObjectTypeSemaphore, VALIDATION_ERROR_258004ea);
+ DeviceReportUndestroyedObjects(device, kVulkanObjectTypeFence, VALIDATION_ERROR_258004ea);
+ DeviceReportUndestroyedObjects(device, kVulkanObjectTypeDeviceMemory, VALIDATION_ERROR_258004ea);
+ DeviceReportUndestroyedObjects(device, kVulkanObjectTypeBuffer, VALIDATION_ERROR_258004ea);
+ DeviceReportUndestroyedObjects(device, kVulkanObjectTypeImage, VALIDATION_ERROR_258004ea);
+ DeviceReportUndestroyedObjects(device, kVulkanObjectTypeEvent, VALIDATION_ERROR_258004ea);
+ DeviceReportUndestroyedObjects(device, kVulkanObjectTypeQueryPool, VALIDATION_ERROR_258004ea);
+ DeviceReportUndestroyedObjects(device, kVulkanObjectTypeBufferView, VALIDATION_ERROR_258004ea);
+ DeviceReportUndestroyedObjects(device, kVulkanObjectTypeImageView, VALIDATION_ERROR_258004ea);
+ DeviceReportUndestroyedObjects(device, kVulkanObjectTypeShaderModule, VALIDATION_ERROR_258004ea);
+ DeviceReportUndestroyedObjects(device, kVulkanObjectTypePipelineCache, VALIDATION_ERROR_258004ea);
+ DeviceReportUndestroyedObjects(device, kVulkanObjectTypePipelineLayout, VALIDATION_ERROR_258004ea);
+ DeviceReportUndestroyedObjects(device, kVulkanObjectTypeRenderPass, VALIDATION_ERROR_258004ea);
+ DeviceReportUndestroyedObjects(device, kVulkanObjectTypePipeline, VALIDATION_ERROR_258004ea);
+ DeviceReportUndestroyedObjects(device, kVulkanObjectTypeDescriptorSetLayout, VALIDATION_ERROR_258004ea);
+ DeviceReportUndestroyedObjects(device, kVulkanObjectTypeSampler, VALIDATION_ERROR_258004ea);
+ DeviceReportUndestroyedObjects(device, kVulkanObjectTypeDescriptorPool, VALIDATION_ERROR_258004ea);
+ DeviceReportUndestroyedObjects(device, kVulkanObjectTypeDescriptorSet, VALIDATION_ERROR_258004ea);
+ DeviceReportUndestroyedObjects(device, kVulkanObjectTypeFramebuffer, VALIDATION_ERROR_258004ea);
+ DeviceReportUndestroyedObjects(device, kVulkanObjectTypeCommandPool, VALIDATION_ERROR_258004ea);
+ DeviceReportUndestroyedObjects(device, kVulkanObjectTypeSurfaceKHR, VALIDATION_ERROR_258004ea);
+ DeviceReportUndestroyedObjects(device, kVulkanObjectTypeSwapchainKHR, VALIDATION_ERROR_258004ea);
+ DeviceReportUndestroyedObjects(device, kVulkanObjectTypeDisplayKHR, VALIDATION_ERROR_258004ea);
+ DeviceReportUndestroyedObjects(device, kVulkanObjectTypeDisplayModeKHR, VALIDATION_ERROR_258004ea);
+ DeviceReportUndestroyedObjects(device, kVulkanObjectTypeDescriptorUpdateTemplateKHR, VALIDATION_ERROR_258004ea);
+ DeviceReportUndestroyedObjects(device, kVulkanObjectTypeDebugReportCallbackEXT, VALIDATION_ERROR_258004ea);
+ DeviceReportUndestroyedObjects(device, kVulkanObjectTypeObjectTableNVX, VALIDATION_ERROR_258004ea);
+ DeviceReportUndestroyedObjects(device, kVulkanObjectTypeIndirectCommandsLayoutNVX, VALIDATION_ERROR_258004ea);
}
instance_data->object_map[kVulkanObjectTypeDevice].clear();
@@ -469,38 +471,38 @@
VKAPI_ATTR void VKAPI_CALL DestroyDevice(VkDevice device, const VkAllocationCallbacks *pAllocator) {
std::unique_lock<std::mutex> lock(global_lock);
- ValidateObject(device, device, kVulkanObjectTypeDevice, true, VALIDATION_ERROR_00052, VALIDATION_ERROR_UNDEFINED);
- DestroyObject(device, device, kVulkanObjectTypeDevice, pAllocator, VALIDATION_ERROR_00050, VALIDATION_ERROR_00051);
+ ValidateObject(device, device, kVulkanObjectTypeDevice, true, VALIDATION_ERROR_24a05601, VALIDATION_ERROR_UNDEFINED);
+ DestroyObject(device, device, kVulkanObjectTypeDevice, pAllocator, VALIDATION_ERROR_24a002f6, VALIDATION_ERROR_24a002f8);
// Report any remaining objects associated with this VkDevice object in LL
- DeviceReportUndestroyedObjects(device, kVulkanObjectTypeSemaphore, VALIDATION_ERROR_00049);
- DeviceReportUndestroyedObjects(device, kVulkanObjectTypeFence, VALIDATION_ERROR_00049);
- DeviceReportUndestroyedObjects(device, kVulkanObjectTypeDeviceMemory, VALIDATION_ERROR_00049);
- DeviceReportUndestroyedObjects(device, kVulkanObjectTypeBuffer, VALIDATION_ERROR_00049);
- DeviceReportUndestroyedObjects(device, kVulkanObjectTypeImage, VALIDATION_ERROR_00049);
- DeviceReportUndestroyedObjects(device, kVulkanObjectTypeEvent, VALIDATION_ERROR_00049);
- DeviceReportUndestroyedObjects(device, kVulkanObjectTypeQueryPool, VALIDATION_ERROR_00049);
- DeviceReportUndestroyedObjects(device, kVulkanObjectTypeBufferView, VALIDATION_ERROR_00049);
- DeviceReportUndestroyedObjects(device, kVulkanObjectTypeImageView, VALIDATION_ERROR_00049);
- DeviceReportUndestroyedObjects(device, kVulkanObjectTypeShaderModule, VALIDATION_ERROR_00049);
- DeviceReportUndestroyedObjects(device, kVulkanObjectTypePipelineCache, VALIDATION_ERROR_00049);
- DeviceReportUndestroyedObjects(device, kVulkanObjectTypePipelineLayout, VALIDATION_ERROR_00049);
- DeviceReportUndestroyedObjects(device, kVulkanObjectTypeRenderPass, VALIDATION_ERROR_00049);
- DeviceReportUndestroyedObjects(device, kVulkanObjectTypePipeline, VALIDATION_ERROR_00049);
- DeviceReportUndestroyedObjects(device, kVulkanObjectTypeDescriptorSetLayout, VALIDATION_ERROR_00049);
- DeviceReportUndestroyedObjects(device, kVulkanObjectTypeSampler, VALIDATION_ERROR_00049);
- DeviceReportUndestroyedObjects(device, kVulkanObjectTypeDescriptorPool, VALIDATION_ERROR_00049);
- DeviceReportUndestroyedObjects(device, kVulkanObjectTypeDescriptorSet, VALIDATION_ERROR_00049);
- DeviceReportUndestroyedObjects(device, kVulkanObjectTypeFramebuffer, VALIDATION_ERROR_00049);
- DeviceReportUndestroyedObjects(device, kVulkanObjectTypeCommandPool, VALIDATION_ERROR_00049);
- DeviceReportUndestroyedObjects(device, kVulkanObjectTypeSurfaceKHR, VALIDATION_ERROR_00049);
- DeviceReportUndestroyedObjects(device, kVulkanObjectTypeSwapchainKHR, VALIDATION_ERROR_00049);
- DeviceReportUndestroyedObjects(device, kVulkanObjectTypeDisplayKHR, VALIDATION_ERROR_00049);
- DeviceReportUndestroyedObjects(device, kVulkanObjectTypeDisplayModeKHR, VALIDATION_ERROR_00049);
- DeviceReportUndestroyedObjects(device, kVulkanObjectTypeDescriptorUpdateTemplateKHR, VALIDATION_ERROR_00049);
- DeviceReportUndestroyedObjects(device, kVulkanObjectTypeDebugReportCallbackEXT, VALIDATION_ERROR_00049);
- DeviceReportUndestroyedObjects(device, kVulkanObjectTypeObjectTableNVX, VALIDATION_ERROR_00049);
- DeviceReportUndestroyedObjects(device, kVulkanObjectTypeIndirectCommandsLayoutNVX, VALIDATION_ERROR_00049);
+ DeviceReportUndestroyedObjects(device, kVulkanObjectTypeSemaphore, VALIDATION_ERROR_24a002f4);
+ DeviceReportUndestroyedObjects(device, kVulkanObjectTypeFence, VALIDATION_ERROR_24a002f4);
+ DeviceReportUndestroyedObjects(device, kVulkanObjectTypeDeviceMemory, VALIDATION_ERROR_24a002f4);
+ DeviceReportUndestroyedObjects(device, kVulkanObjectTypeBuffer, VALIDATION_ERROR_24a002f4);
+ DeviceReportUndestroyedObjects(device, kVulkanObjectTypeImage, VALIDATION_ERROR_24a002f4);
+ DeviceReportUndestroyedObjects(device, kVulkanObjectTypeEvent, VALIDATION_ERROR_24a002f4);
+ DeviceReportUndestroyedObjects(device, kVulkanObjectTypeQueryPool, VALIDATION_ERROR_24a002f4);
+ DeviceReportUndestroyedObjects(device, kVulkanObjectTypeBufferView, VALIDATION_ERROR_24a002f4);
+ DeviceReportUndestroyedObjects(device, kVulkanObjectTypeImageView, VALIDATION_ERROR_24a002f4);
+ DeviceReportUndestroyedObjects(device, kVulkanObjectTypeShaderModule, VALIDATION_ERROR_24a002f4);
+ DeviceReportUndestroyedObjects(device, kVulkanObjectTypePipelineCache, VALIDATION_ERROR_24a002f4);
+ DeviceReportUndestroyedObjects(device, kVulkanObjectTypePipelineLayout, VALIDATION_ERROR_24a002f4);
+ DeviceReportUndestroyedObjects(device, kVulkanObjectTypeRenderPass, VALIDATION_ERROR_24a002f4);
+ DeviceReportUndestroyedObjects(device, kVulkanObjectTypePipeline, VALIDATION_ERROR_24a002f4);
+ DeviceReportUndestroyedObjects(device, kVulkanObjectTypeDescriptorSetLayout, VALIDATION_ERROR_24a002f4);
+ DeviceReportUndestroyedObjects(device, kVulkanObjectTypeSampler, VALIDATION_ERROR_24a002f4);
+ DeviceReportUndestroyedObjects(device, kVulkanObjectTypeDescriptorPool, VALIDATION_ERROR_24a002f4);
+ DeviceReportUndestroyedObjects(device, kVulkanObjectTypeDescriptorSet, VALIDATION_ERROR_24a002f4);
+ DeviceReportUndestroyedObjects(device, kVulkanObjectTypeFramebuffer, VALIDATION_ERROR_24a002f4);
+ DeviceReportUndestroyedObjects(device, kVulkanObjectTypeCommandPool, VALIDATION_ERROR_24a002f4);
+ DeviceReportUndestroyedObjects(device, kVulkanObjectTypeSurfaceKHR, VALIDATION_ERROR_24a002f4);
+ DeviceReportUndestroyedObjects(device, kVulkanObjectTypeSwapchainKHR, VALIDATION_ERROR_24a002f4);
+ DeviceReportUndestroyedObjects(device, kVulkanObjectTypeDisplayKHR, VALIDATION_ERROR_24a002f4);
+ DeviceReportUndestroyedObjects(device, kVulkanObjectTypeDisplayModeKHR, VALIDATION_ERROR_24a002f4);
+ DeviceReportUndestroyedObjects(device, kVulkanObjectTypeDescriptorUpdateTemplateKHR, VALIDATION_ERROR_24a002f4);
+ DeviceReportUndestroyedObjects(device, kVulkanObjectTypeDebugReportCallbackEXT, VALIDATION_ERROR_24a002f4);
+ DeviceReportUndestroyedObjects(device, kVulkanObjectTypeObjectTableNVX, VALIDATION_ERROR_24a002f4);
+ DeviceReportUndestroyedObjects(device, kVulkanObjectTypeIndirectCommandsLayoutNVX, VALIDATION_ERROR_24a002f4);
// Clean up Queue's MemRef Linked Lists
DestroyQueueDataStructures(device);
@@ -517,7 +519,7 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_01679,
+ skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_2c016e01,
VALIDATION_ERROR_UNDEFINED);
}
if (skip) {
@@ -531,7 +533,7 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_01683,
+ skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_2c427a01,
VALIDATION_ERROR_UNDEFINED);
}
if (skip) {
@@ -548,7 +550,7 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_01686,
+ skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_2ca27a01,
VALIDATION_ERROR_UNDEFINED);
}
if (skip) {
@@ -564,7 +566,7 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_00026,
+ skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_2d627a01,
VALIDATION_ERROR_UNDEFINED);
}
if (skip) {
@@ -578,7 +580,7 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_00609,
+ skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_2ce27a01,
VALIDATION_ERROR_UNDEFINED);
}
if (skip) {
@@ -605,31 +607,32 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(queue, fence, kVulkanObjectTypeFence, true, VALIDATION_ERROR_00130, VALIDATION_ERROR_00131);
+ skip |= ValidateObject(queue, fence, kVulkanObjectTypeFence, true, VALIDATION_ERROR_31a08801, VALIDATION_ERROR_31a00009);
if (pSubmits) {
for (uint32_t idx0 = 0; idx0 < submitCount; ++idx0) {
if (pSubmits[idx0].pCommandBuffers) {
for (uint32_t idx1 = 0; idx1 < pSubmits[idx0].commandBufferCount; ++idx1) {
skip |= ValidateObject(queue, pSubmits[idx0].pCommandBuffers[idx1], kVulkanObjectTypeCommandBuffer, false,
- VALIDATION_ERROR_00149, VALIDATION_ERROR_00151);
+ VALIDATION_ERROR_13c11401, VALIDATION_ERROR_13c00009);
}
}
if (pSubmits[idx0].pSignalSemaphores) {
for (uint32_t idx2 = 0; idx2 < pSubmits[idx0].signalSemaphoreCount; ++idx2) {
skip |= ValidateObject(queue, pSubmits[idx0].pSignalSemaphores[idx2], kVulkanObjectTypeSemaphore, false,
- VALIDATION_ERROR_00150, VALIDATION_ERROR_00151);
+ VALIDATION_ERROR_13c23401, VALIDATION_ERROR_13c00009);
}
}
if (pSubmits[idx0].pWaitSemaphores) {
for (uint32_t idx3 = 0; idx3 < pSubmits[idx0].waitSemaphoreCount; ++idx3) {
skip |= ValidateObject(queue, pSubmits[idx0].pWaitSemaphores[idx3], kVulkanObjectTypeSemaphore, false,
- VALIDATION_ERROR_00146, VALIDATION_ERROR_00151);
+ VALIDATION_ERROR_13c27601, VALIDATION_ERROR_13c00009);
}
}
}
}
if (queue) {
- skip |= ValidateObject(queue, queue, kVulkanObjectTypeQueue, false, VALIDATION_ERROR_00128, VALIDATION_ERROR_00131);
+ skip |=
+ ValidateObject(queue, queue, kVulkanObjectTypeQueue, false, VALIDATION_ERROR_31a29c01, VALIDATION_ERROR_31a00009);
}
}
if (skip) {
@@ -643,7 +646,7 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(queue, queue, kVulkanObjectTypeQueue, false, VALIDATION_ERROR_00317, VALIDATION_ERROR_UNDEFINED);
+ skip |= ValidateObject(queue, queue, kVulkanObjectTypeQueue, false, VALIDATION_ERROR_31c29c01, VALIDATION_ERROR_UNDEFINED);
}
if (skip) {
return VK_ERROR_VALIDATION_FAILED_EXT;
@@ -656,7 +659,8 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_00318, VALIDATION_ERROR_UNDEFINED);
+ skip |=
+ ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_27005601, VALIDATION_ERROR_UNDEFINED);
}
if (skip) {
return VK_ERROR_VALIDATION_FAILED_EXT;
@@ -670,7 +674,8 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_00612, VALIDATION_ERROR_UNDEFINED);
+ skip |=
+ ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_16c05601, VALIDATION_ERROR_UNDEFINED);
}
if (skip) {
return VK_ERROR_VALIDATION_FAILED_EXT;
@@ -690,12 +695,13 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_00635, VALIDATION_ERROR_UNDEFINED);
+ skip |=
+ ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_28205601, VALIDATION_ERROR_UNDEFINED);
if (pMemoryRanges) {
for (uint32_t idx0 = 0; idx0 < memoryRangeCount; ++idx0) {
if (pMemoryRanges[idx0].memory) {
skip |= ValidateObject(device, pMemoryRanges[idx0].memory, kVulkanObjectTypeDeviceMemory, false,
- VALIDATION_ERROR_00648, VALIDATION_ERROR_UNDEFINED);
+ VALIDATION_ERROR_0c20c601, VALIDATION_ERROR_UNDEFINED);
}
}
}
@@ -713,12 +719,13 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_00638, VALIDATION_ERROR_UNDEFINED);
+ skip |=
+ ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_31005601, VALIDATION_ERROR_UNDEFINED);
if (pMemoryRanges) {
for (uint32_t idx0 = 0; idx0 < memoryRangeCount; ++idx0) {
if (pMemoryRanges[idx0].memory) {
skip |= ValidateObject(device, pMemoryRanges[idx0].memory, kVulkanObjectTypeDeviceMemory, false,
- VALIDATION_ERROR_00648, VALIDATION_ERROR_UNDEFINED);
+ VALIDATION_ERROR_0c20c601, VALIDATION_ERROR_UNDEFINED);
}
}
}
@@ -736,9 +743,10 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_00654, VALIDATION_ERROR_UNDEFINED);
skip |=
- ValidateObject(device, memory, kVulkanObjectTypeDeviceMemory, false, VALIDATION_ERROR_00655, VALIDATION_ERROR_00657);
+ ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_29205601, VALIDATION_ERROR_UNDEFINED);
+ skip |= ValidateObject(device, memory, kVulkanObjectTypeDeviceMemory, false, VALIDATION_ERROR_2920c601,
+ VALIDATION_ERROR_2920c607);
}
if (skip) {
return;
@@ -751,10 +759,12 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_00798, VALIDATION_ERROR_UNDEFINED);
- skip |= ValidateObject(device, buffer, kVulkanObjectTypeBuffer, false, VALIDATION_ERROR_00799, VALIDATION_ERROR_00801);
skip |=
- ValidateObject(device, memory, kVulkanObjectTypeDeviceMemory, false, VALIDATION_ERROR_00800, VALIDATION_ERROR_00802);
+ ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_17005601, VALIDATION_ERROR_UNDEFINED);
+ skip |=
+ ValidateObject(device, buffer, kVulkanObjectTypeBuffer, false, VALIDATION_ERROR_17001a01, VALIDATION_ERROR_17001a07);
+ skip |= ValidateObject(device, memory, kVulkanObjectTypeDeviceMemory, false, VALIDATION_ERROR_1700c601,
+ VALIDATION_ERROR_1700c607);
}
if (skip) {
return VK_ERROR_VALIDATION_FAILED_EXT;
@@ -767,10 +777,11 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_00807, VALIDATION_ERROR_UNDEFINED);
- skip |= ValidateObject(device, image, kVulkanObjectTypeImage, false, VALIDATION_ERROR_00808, VALIDATION_ERROR_00810);
skip |=
- ValidateObject(device, memory, kVulkanObjectTypeDeviceMemory, false, VALIDATION_ERROR_00809, VALIDATION_ERROR_00811);
+ ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_17405601, VALIDATION_ERROR_UNDEFINED);
+ skip |= ValidateObject(device, image, kVulkanObjectTypeImage, false, VALIDATION_ERROR_1740a001, VALIDATION_ERROR_1740a007);
+ skip |= ValidateObject(device, memory, kVulkanObjectTypeDeviceMemory, false, VALIDATION_ERROR_1740c601,
+ VALIDATION_ERROR_1740c607);
}
if (skip) {
return VK_ERROR_VALIDATION_FAILED_EXT;
@@ -784,8 +795,10 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_00783, VALIDATION_ERROR_UNDEFINED);
- skip |= ValidateObject(device, buffer, kVulkanObjectTypeBuffer, false, VALIDATION_ERROR_00784, VALIDATION_ERROR_00786);
+ skip |=
+ ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_28a05601, VALIDATION_ERROR_UNDEFINED);
+ skip |=
+ ValidateObject(device, buffer, kVulkanObjectTypeBuffer, false, VALIDATION_ERROR_28a01a01, VALIDATION_ERROR_28a01a07);
}
if (skip) {
return;
@@ -797,8 +810,9 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_00787, VALIDATION_ERROR_UNDEFINED);
- skip |= ValidateObject(device, image, kVulkanObjectTypeImage, false, VALIDATION_ERROR_00788, VALIDATION_ERROR_00790);
+ skip |=
+ ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_2a205601, VALIDATION_ERROR_UNDEFINED);
+ skip |= ValidateObject(device, image, kVulkanObjectTypeImage, false, VALIDATION_ERROR_2a20a001, VALIDATION_ERROR_2a20a007);
}
if (skip) {
return;
@@ -811,8 +825,9 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_01610, VALIDATION_ERROR_UNDEFINED);
- skip |= ValidateObject(device, image, kVulkanObjectTypeImage, false, VALIDATION_ERROR_01611, VALIDATION_ERROR_01614);
+ skip |=
+ ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_2a405601, VALIDATION_ERROR_UNDEFINED);
+ skip |= ValidateObject(device, image, kVulkanObjectTypeImage, false, VALIDATION_ERROR_2a40a001, VALIDATION_ERROR_2a40a007);
}
if (skip) {
return;
@@ -829,7 +844,7 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_01601,
+ skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_2de27a01,
VALIDATION_ERROR_UNDEFINED);
}
if (skip) {
@@ -845,7 +860,8 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_00166, VALIDATION_ERROR_UNDEFINED);
+ skip |=
+ ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_20405601, VALIDATION_ERROR_UNDEFINED);
}
if (skip) {
return VK_ERROR_VALIDATION_FAILED_EXT;
@@ -864,15 +880,16 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_00176, VALIDATION_ERROR_UNDEFINED);
- skip |= ValidateObject(device, fence, kVulkanObjectTypeFence, true, VALIDATION_ERROR_00177, VALIDATION_ERROR_00179);
+ skip |=
+ ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_24e05601, VALIDATION_ERROR_UNDEFINED);
+ skip |= ValidateObject(device, fence, kVulkanObjectTypeFence, true, VALIDATION_ERROR_24e08801, VALIDATION_ERROR_24e08807);
}
if (skip) {
return;
}
{
std::lock_guard<std::mutex> lock(global_lock);
- DestroyObject(device, fence, kVulkanObjectTypeFence, pAllocator, VALIDATION_ERROR_00174, VALIDATION_ERROR_00175);
+ DestroyObject(device, fence, kVulkanObjectTypeFence, pAllocator, VALIDATION_ERROR_24e008c2, VALIDATION_ERROR_24e008c4);
}
get_dispatch_table(ot_device_table_map, device)->DestroyFence(device, fence, pAllocator);
}
@@ -881,11 +898,12 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_00184, VALIDATION_ERROR_UNDEFINED);
+ skip |=
+ ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_32e05601, VALIDATION_ERROR_UNDEFINED);
if (pFences) {
for (uint32_t idx0 = 0; idx0 < fenceCount; ++idx0) {
- skip |= ValidateObject(device, pFences[idx0], kVulkanObjectTypeFence, false, VALIDATION_ERROR_00185,
- VALIDATION_ERROR_00187);
+ skip |= ValidateObject(device, pFences[idx0], kVulkanObjectTypeFence, false, VALIDATION_ERROR_32e17201,
+ VALIDATION_ERROR_32e17207);
}
}
}
@@ -900,8 +918,9 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_00180, VALIDATION_ERROR_UNDEFINED);
- skip |= ValidateObject(device, fence, kVulkanObjectTypeFence, false, VALIDATION_ERROR_00181, VALIDATION_ERROR_00182);
+ skip |=
+ ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_2a005601, VALIDATION_ERROR_UNDEFINED);
+ skip |= ValidateObject(device, fence, kVulkanObjectTypeFence, false, VALIDATION_ERROR_2a008801, VALIDATION_ERROR_2a008807);
}
if (skip) {
return VK_ERROR_VALIDATION_FAILED_EXT;
@@ -915,11 +934,12 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_00188, VALIDATION_ERROR_UNDEFINED);
+ skip |=
+ ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_33e05601, VALIDATION_ERROR_UNDEFINED);
if (pFences) {
for (uint32_t idx0 = 0; idx0 < fenceCount; ++idx0) {
- skip |= ValidateObject(device, pFences[idx0], kVulkanObjectTypeFence, false, VALIDATION_ERROR_00189,
- VALIDATION_ERROR_00191);
+ skip |= ValidateObject(device, pFences[idx0], kVulkanObjectTypeFence, false, VALIDATION_ERROR_33e17201,
+ VALIDATION_ERROR_33e17207);
}
}
}
@@ -935,7 +955,8 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_00192, VALIDATION_ERROR_UNDEFINED);
+ skip |=
+ ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_22405601, VALIDATION_ERROR_UNDEFINED);
}
if (skip) {
return VK_ERROR_VALIDATION_FAILED_EXT;
@@ -954,15 +975,18 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_00202, VALIDATION_ERROR_UNDEFINED);
- skip |= ValidateObject(device, semaphore, kVulkanObjectTypeSemaphore, true, VALIDATION_ERROR_00203, VALIDATION_ERROR_00205);
+ skip |=
+ ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_26805601, VALIDATION_ERROR_UNDEFINED);
+ skip |= ValidateObject(device, semaphore, kVulkanObjectTypeSemaphore, true, VALIDATION_ERROR_2682b801,
+ VALIDATION_ERROR_2682b807);
}
if (skip) {
return;
}
{
std::lock_guard<std::mutex> lock(global_lock);
- DestroyObject(device, semaphore, kVulkanObjectTypeSemaphore, pAllocator, VALIDATION_ERROR_00200, VALIDATION_ERROR_00201);
+ DestroyObject(device, semaphore, kVulkanObjectTypeSemaphore, pAllocator, VALIDATION_ERROR_268008e4,
+ VALIDATION_ERROR_268008e6);
}
get_dispatch_table(ot_device_table_map, device)->DestroySemaphore(device, semaphore, pAllocator);
}
@@ -972,7 +996,8 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_00206, VALIDATION_ERROR_UNDEFINED);
+ skip |=
+ ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_20205601, VALIDATION_ERROR_UNDEFINED);
}
if (skip) {
return VK_ERROR_VALIDATION_FAILED_EXT;
@@ -991,15 +1016,16 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_00216, VALIDATION_ERROR_UNDEFINED);
- skip |= ValidateObject(device, event, kVulkanObjectTypeEvent, true, VALIDATION_ERROR_00217, VALIDATION_ERROR_00219);
+ skip |=
+ ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_24c05601, VALIDATION_ERROR_UNDEFINED);
+ skip |= ValidateObject(device, event, kVulkanObjectTypeEvent, true, VALIDATION_ERROR_24c07e01, VALIDATION_ERROR_24c07e07);
}
if (skip) {
return;
}
{
std::lock_guard<std::mutex> lock(global_lock);
- DestroyObject(device, event, kVulkanObjectTypeEvent, pAllocator, VALIDATION_ERROR_00214, VALIDATION_ERROR_00215);
+ DestroyObject(device, event, kVulkanObjectTypeEvent, pAllocator, VALIDATION_ERROR_24c008f4, VALIDATION_ERROR_24c008f6);
}
get_dispatch_table(ot_device_table_map, device)->DestroyEvent(device, event, pAllocator);
}
@@ -1008,8 +1034,9 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_00220, VALIDATION_ERROR_UNDEFINED);
- skip |= ValidateObject(device, event, kVulkanObjectTypeEvent, false, VALIDATION_ERROR_00221, VALIDATION_ERROR_00222);
+ skip |=
+ ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_29e05601, VALIDATION_ERROR_UNDEFINED);
+ skip |= ValidateObject(device, event, kVulkanObjectTypeEvent, false, VALIDATION_ERROR_29e07e01, VALIDATION_ERROR_29e07e07);
}
if (skip) {
return VK_ERROR_VALIDATION_FAILED_EXT;
@@ -1022,8 +1049,9 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_00223, VALIDATION_ERROR_UNDEFINED);
- skip |= ValidateObject(device, event, kVulkanObjectTypeEvent, false, VALIDATION_ERROR_00224, VALIDATION_ERROR_00225);
+ skip |=
+ ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_33005601, VALIDATION_ERROR_UNDEFINED);
+ skip |= ValidateObject(device, event, kVulkanObjectTypeEvent, false, VALIDATION_ERROR_33007e01, VALIDATION_ERROR_33007e07);
}
if (skip) {
return VK_ERROR_VALIDATION_FAILED_EXT;
@@ -1036,8 +1064,9 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_00227, VALIDATION_ERROR_UNDEFINED);
- skip |= ValidateObject(device, event, kVulkanObjectTypeEvent, false, VALIDATION_ERROR_00228, VALIDATION_ERROR_00229);
+ skip |=
+ ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_32c05601, VALIDATION_ERROR_UNDEFINED);
+ skip |= ValidateObject(device, event, kVulkanObjectTypeEvent, false, VALIDATION_ERROR_32c07e01, VALIDATION_ERROR_32c07e07);
}
if (skip) {
return VK_ERROR_VALIDATION_FAILED_EXT;
@@ -1051,7 +1080,8 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_01002, VALIDATION_ERROR_UNDEFINED);
+ skip |=
+ ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_21e05601, VALIDATION_ERROR_UNDEFINED);
}
if (skip) {
return VK_ERROR_VALIDATION_FAILED_EXT;
@@ -1070,15 +1100,18 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_01015, VALIDATION_ERROR_UNDEFINED);
- skip |= ValidateObject(device, queryPool, kVulkanObjectTypeQueryPool, true, VALIDATION_ERROR_01016, VALIDATION_ERROR_01018);
+ skip |=
+ ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_26205601, VALIDATION_ERROR_UNDEFINED);
+ skip |= ValidateObject(device, queryPool, kVulkanObjectTypeQueryPool, true, VALIDATION_ERROR_26229801,
+ VALIDATION_ERROR_26229807);
}
if (skip) {
return;
}
{
std::lock_guard<std::mutex> lock(global_lock);
- DestroyObject(device, queryPool, kVulkanObjectTypeQueryPool, pAllocator, VALIDATION_ERROR_01013, VALIDATION_ERROR_01014);
+ DestroyObject(device, queryPool, kVulkanObjectTypeQueryPool, pAllocator, VALIDATION_ERROR_26200634,
+ VALIDATION_ERROR_26200636);
}
get_dispatch_table(ot_device_table_map, device)->DestroyQueryPool(device, queryPool, pAllocator);
}
@@ -1088,9 +1121,10 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_01054, VALIDATION_ERROR_UNDEFINED);
skip |=
- ValidateObject(device, queryPool, kVulkanObjectTypeQueryPool, false, VALIDATION_ERROR_01055, VALIDATION_ERROR_01059);
+ ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_2fa05601, VALIDATION_ERROR_UNDEFINED);
+ skip |= ValidateObject(device, queryPool, kVulkanObjectTypeQueryPool, false, VALIDATION_ERROR_2fa29801,
+ VALIDATION_ERROR_2fa29807);
}
if (skip) {
return VK_ERROR_VALIDATION_FAILED_EXT;
@@ -1105,7 +1139,8 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_00659, VALIDATION_ERROR_UNDEFINED);
+ skip |=
+ ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_1ec05601, VALIDATION_ERROR_UNDEFINED);
}
if (skip) {
return VK_ERROR_VALIDATION_FAILED_EXT;
@@ -1124,15 +1159,16 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_00679, VALIDATION_ERROR_UNDEFINED);
- skip |= ValidateObject(device, buffer, kVulkanObjectTypeBuffer, true, VALIDATION_ERROR_00680, VALIDATION_ERROR_00682);
+ skip |=
+ ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_23c05601, VALIDATION_ERROR_UNDEFINED);
+ skip |= ValidateObject(device, buffer, kVulkanObjectTypeBuffer, true, VALIDATION_ERROR_23c01a01, VALIDATION_ERROR_23c01a07);
}
if (skip) {
return;
}
{
std::lock_guard<std::mutex> lock(global_lock);
- DestroyObject(device, buffer, kVulkanObjectTypeBuffer, pAllocator, VALIDATION_ERROR_00677, VALIDATION_ERROR_00678);
+ DestroyObject(device, buffer, kVulkanObjectTypeBuffer, pAllocator, VALIDATION_ERROR_23c00736, VALIDATION_ERROR_23c00738);
}
get_dispatch_table(ot_device_table_map, device)->DestroyBuffer(device, buffer, pAllocator);
}
@@ -1142,9 +1178,10 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_00683, VALIDATION_ERROR_UNDEFINED);
+ skip |=
+ ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_1ee05601, VALIDATION_ERROR_UNDEFINED);
if (pCreateInfo) {
- skip |= ValidateObject(device, pCreateInfo->buffer, kVulkanObjectTypeBuffer, false, VALIDATION_ERROR_00699,
+ skip |= ValidateObject(device, pCreateInfo->buffer, kVulkanObjectTypeBuffer, false, VALIDATION_ERROR_01a01a01,
VALIDATION_ERROR_UNDEFINED);
}
}
@@ -1165,16 +1202,18 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_00704, VALIDATION_ERROR_UNDEFINED);
skip |=
- ValidateObject(device, bufferView, kVulkanObjectTypeBufferView, true, VALIDATION_ERROR_00705, VALIDATION_ERROR_00707);
+ ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_23e05601, VALIDATION_ERROR_UNDEFINED);
+ skip |= ValidateObject(device, bufferView, kVulkanObjectTypeBufferView, true, VALIDATION_ERROR_23e01c01,
+ VALIDATION_ERROR_23e01c07);
}
if (skip) {
return;
}
{
std::lock_guard<std::mutex> lock(global_lock);
- DestroyObject(device, bufferView, kVulkanObjectTypeBufferView, pAllocator, VALIDATION_ERROR_00702, VALIDATION_ERROR_00703);
+ DestroyObject(device, bufferView, kVulkanObjectTypeBufferView, pAllocator, VALIDATION_ERROR_23e00752,
+ VALIDATION_ERROR_23e00754);
}
get_dispatch_table(ot_device_table_map, device)->DestroyBufferView(device, bufferView, pAllocator);
}
@@ -1184,7 +1223,8 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_00709, VALIDATION_ERROR_UNDEFINED);
+ skip |=
+ ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_20c05601, VALIDATION_ERROR_UNDEFINED);
}
if (skip) {
return VK_ERROR_VALIDATION_FAILED_EXT;
@@ -1203,15 +1243,16 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_00746, VALIDATION_ERROR_UNDEFINED);
- skip |= ValidateObject(device, image, kVulkanObjectTypeImage, true, VALIDATION_ERROR_00747, VALIDATION_ERROR_00749);
+ skip |=
+ ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_25205601, VALIDATION_ERROR_UNDEFINED);
+ skip |= ValidateObject(device, image, kVulkanObjectTypeImage, true, VALIDATION_ERROR_2520a001, VALIDATION_ERROR_2520a007);
}
if (skip) {
return;
}
{
std::lock_guard<std::mutex> lock(global_lock);
- DestroyObject(device, image, kVulkanObjectTypeImage, pAllocator, VALIDATION_ERROR_00744, VALIDATION_ERROR_00745);
+ DestroyObject(device, image, kVulkanObjectTypeImage, pAllocator, VALIDATION_ERROR_252007d2, VALIDATION_ERROR_252007d4);
}
get_dispatch_table(ot_device_table_map, device)->DestroyImage(device, image, pAllocator);
}
@@ -1221,8 +1262,9 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_00734, VALIDATION_ERROR_UNDEFINED);
- skip |= ValidateObject(device, image, kVulkanObjectTypeImage, false, VALIDATION_ERROR_00735, VALIDATION_ERROR_00738);
+ skip |=
+ ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_2a605601, VALIDATION_ERROR_UNDEFINED);
+ skip |= ValidateObject(device, image, kVulkanObjectTypeImage, false, VALIDATION_ERROR_2a60a001, VALIDATION_ERROR_2a60a007);
}
if (skip) {
return;
@@ -1235,9 +1277,10 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_00750, VALIDATION_ERROR_UNDEFINED);
+ skip |=
+ ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_20e05601, VALIDATION_ERROR_UNDEFINED);
if (pCreateInfo) {
- skip |= ValidateObject(device, pCreateInfo->image, kVulkanObjectTypeImage, false, VALIDATION_ERROR_00763,
+ skip |= ValidateObject(device, pCreateInfo->image, kVulkanObjectTypeImage, false, VALIDATION_ERROR_0ac0a001,
VALIDATION_ERROR_UNDEFINED);
}
}
@@ -1258,15 +1301,18 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_00779, VALIDATION_ERROR_UNDEFINED);
- skip |= ValidateObject(device, imageView, kVulkanObjectTypeImageView, true, VALIDATION_ERROR_00780, VALIDATION_ERROR_00782);
+ skip |=
+ ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_25405601, VALIDATION_ERROR_UNDEFINED);
+ skip |= ValidateObject(device, imageView, kVulkanObjectTypeImageView, true, VALIDATION_ERROR_2540b001,
+ VALIDATION_ERROR_2540b007);
}
if (skip) {
return;
}
{
std::lock_guard<std::mutex> lock(global_lock);
- DestroyObject(device, imageView, kVulkanObjectTypeImageView, pAllocator, VALIDATION_ERROR_00777, VALIDATION_ERROR_00778);
+ DestroyObject(device, imageView, kVulkanObjectTypeImageView, pAllocator, VALIDATION_ERROR_25400806,
+ VALIDATION_ERROR_25400808);
}
get_dispatch_table(ot_device_table_map, device)->DestroyImageView(device, imageView, pAllocator);
}
@@ -1276,7 +1322,8 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_00466, VALIDATION_ERROR_UNDEFINED);
+ skip |=
+ ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_22605601, VALIDATION_ERROR_UNDEFINED);
}
if (skip) {
return VK_ERROR_VALIDATION_FAILED_EXT;
@@ -1297,17 +1344,18 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_00481, VALIDATION_ERROR_UNDEFINED);
- skip |= ValidateObject(device, shaderModule, kVulkanObjectTypeShaderModule, true, VALIDATION_ERROR_00482,
- VALIDATION_ERROR_00484);
+ skip |=
+ ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_26a05601, VALIDATION_ERROR_UNDEFINED);
+ skip |= ValidateObject(device, shaderModule, kVulkanObjectTypeShaderModule, true, VALIDATION_ERROR_26a2be01,
+ VALIDATION_ERROR_26a2be07);
}
if (skip) {
return;
}
{
std::lock_guard<std::mutex> lock(global_lock);
- DestroyObject(device, shaderModule, kVulkanObjectTypeShaderModule, pAllocator, VALIDATION_ERROR_00479,
- VALIDATION_ERROR_00480);
+ DestroyObject(device, shaderModule, kVulkanObjectTypeShaderModule, pAllocator, VALIDATION_ERROR_26a00888,
+ VALIDATION_ERROR_26a0088a);
}
get_dispatch_table(ot_device_table_map, device)->DestroyShaderModule(device, shaderModule, pAllocator);
}
@@ -1317,7 +1365,8 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_00562, VALIDATION_ERROR_UNDEFINED);
+ skip |=
+ ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_21a05601, VALIDATION_ERROR_UNDEFINED);
}
if (skip) {
return VK_ERROR_VALIDATION_FAILED_EXT;
@@ -1338,17 +1387,18 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_00585, VALIDATION_ERROR_UNDEFINED);
- skip |= ValidateObject(device, pipelineCache, kVulkanObjectTypePipelineCache, true, VALIDATION_ERROR_00586,
- VALIDATION_ERROR_00588);
+ skip |=
+ ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_25e05601, VALIDATION_ERROR_UNDEFINED);
+ skip |= ValidateObject(device, pipelineCache, kVulkanObjectTypePipelineCache, true, VALIDATION_ERROR_25e28001,
+ VALIDATION_ERROR_25e28007);
}
if (skip) {
return;
}
{
std::lock_guard<std::mutex> lock(global_lock);
- DestroyObject(device, pipelineCache, kVulkanObjectTypePipelineCache, pAllocator, VALIDATION_ERROR_00583,
- VALIDATION_ERROR_00584);
+ DestroyObject(device, pipelineCache, kVulkanObjectTypePipelineCache, pAllocator, VALIDATION_ERROR_25e00606,
+ VALIDATION_ERROR_25e00608);
}
get_dispatch_table(ot_device_table_map, device)->DestroyPipelineCache(device, pipelineCache, pAllocator);
}
@@ -1358,9 +1408,10 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_00578, VALIDATION_ERROR_UNDEFINED);
- skip |= ValidateObject(device, pipelineCache, kVulkanObjectTypePipelineCache, false, VALIDATION_ERROR_00579,
- VALIDATION_ERROR_00582);
+ skip |=
+ ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_2f805601, VALIDATION_ERROR_UNDEFINED);
+ skip |= ValidateObject(device, pipelineCache, kVulkanObjectTypePipelineCache, false, VALIDATION_ERROR_2f828001,
+ VALIDATION_ERROR_2f828007);
}
if (skip) {
return VK_ERROR_VALIDATION_FAILED_EXT;
@@ -1375,13 +1426,14 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_00572, VALIDATION_ERROR_UNDEFINED);
skip |=
- ValidateObject(device, dstCache, kVulkanObjectTypePipelineCache, false, VALIDATION_ERROR_00573, VALIDATION_ERROR_00576);
+ ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_31405601, VALIDATION_ERROR_UNDEFINED);
+ skip |= ValidateObject(device, dstCache, kVulkanObjectTypePipelineCache, false, VALIDATION_ERROR_31406e01,
+ VALIDATION_ERROR_31406e07);
if (pSrcCaches) {
for (uint32_t idx0 = 0; idx0 < srcCacheCount; ++idx0) {
- skip |= ValidateObject(device, pSrcCaches[idx0], kVulkanObjectTypePipelineCache, false, VALIDATION_ERROR_00574,
- VALIDATION_ERROR_00577);
+ skip |= ValidateObject(device, pSrcCaches[idx0], kVulkanObjectTypePipelineCache, false, VALIDATION_ERROR_31423c01,
+ VALIDATION_ERROR_31423c07);
}
}
}
@@ -1397,15 +1449,18 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_00558, VALIDATION_ERROR_UNDEFINED);
- skip |= ValidateObject(device, pipeline, kVulkanObjectTypePipeline, true, VALIDATION_ERROR_00559, VALIDATION_ERROR_00561);
+ skip |=
+ ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_25c05601, VALIDATION_ERROR_UNDEFINED);
+ skip |=
+ ValidateObject(device, pipeline, kVulkanObjectTypePipeline, true, VALIDATION_ERROR_25c27c01, VALIDATION_ERROR_25c27c07);
}
if (skip) {
return;
}
{
std::lock_guard<std::mutex> lock(global_lock);
- DestroyObject(device, pipeline, kVulkanObjectTypePipeline, pAllocator, VALIDATION_ERROR_00556, VALIDATION_ERROR_00557);
+ DestroyObject(device, pipeline, kVulkanObjectTypePipeline, pAllocator, VALIDATION_ERROR_25c005fc,
+ VALIDATION_ERROR_25c005fe);
}
get_dispatch_table(ot_device_table_map, device)->DestroyPipeline(device, pipeline, pAllocator);
}
@@ -1415,12 +1470,13 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_00861, VALIDATION_ERROR_UNDEFINED);
+ skip |=
+ ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_21c05601, VALIDATION_ERROR_UNDEFINED);
if (pCreateInfo) {
if (pCreateInfo->pSetLayouts) {
for (uint32_t idx0 = 0; idx0 < pCreateInfo->setLayoutCount; ++idx0) {
skip |= ValidateObject(device, pCreateInfo->pSetLayouts[idx0], kVulkanObjectTypeDescriptorSetLayout, false,
- VALIDATION_ERROR_00875, VALIDATION_ERROR_UNDEFINED);
+ VALIDATION_ERROR_0fe22c01, VALIDATION_ERROR_UNDEFINED);
}
}
}
@@ -1444,17 +1500,18 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_00885, VALIDATION_ERROR_UNDEFINED);
- skip |= ValidateObject(device, pipelineLayout, kVulkanObjectTypePipelineLayout, true, VALIDATION_ERROR_00886,
- VALIDATION_ERROR_00888);
+ skip |=
+ ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_26005601, VALIDATION_ERROR_UNDEFINED);
+ skip |= ValidateObject(device, pipelineLayout, kVulkanObjectTypePipelineLayout, true, VALIDATION_ERROR_26028201,
+ VALIDATION_ERROR_26028207);
}
if (skip) {
return;
}
{
std::lock_guard<std::mutex> lock(global_lock);
- DestroyObject(device, pipelineLayout, kVulkanObjectTypePipelineLayout, pAllocator, VALIDATION_ERROR_00883,
- VALIDATION_ERROR_00884);
+ DestroyObject(device, pipelineLayout, kVulkanObjectTypePipelineLayout, pAllocator, VALIDATION_ERROR_26000256,
+ VALIDATION_ERROR_26000258);
}
get_dispatch_table(ot_device_table_map, device)->DestroyPipelineLayout(device, pipelineLayout, pAllocator);
}
@@ -1464,7 +1521,8 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_00812, VALIDATION_ERROR_UNDEFINED);
+ skip |=
+ ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_22205601, VALIDATION_ERROR_UNDEFINED);
}
if (skip) {
return VK_ERROR_VALIDATION_FAILED_EXT;
@@ -1483,15 +1541,17 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_00840, VALIDATION_ERROR_UNDEFINED);
- skip |= ValidateObject(device, sampler, kVulkanObjectTypeSampler, true, VALIDATION_ERROR_00841, VALIDATION_ERROR_00843);
+ skip |=
+ ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_26605601, VALIDATION_ERROR_UNDEFINED);
+ skip |=
+ ValidateObject(device, sampler, kVulkanObjectTypeSampler, true, VALIDATION_ERROR_2662b201, VALIDATION_ERROR_2662b207);
}
if (skip) {
return;
}
{
std::lock_guard<std::mutex> lock(global_lock);
- DestroyObject(device, sampler, kVulkanObjectTypeSampler, pAllocator, VALIDATION_ERROR_00838, VALIDATION_ERROR_00839);
+ DestroyObject(device, sampler, kVulkanObjectTypeSampler, pAllocator, VALIDATION_ERROR_26600876, VALIDATION_ERROR_26600878);
}
get_dispatch_table(ot_device_table_map, device)->DestroySampler(device, sampler, pAllocator);
}
@@ -1502,7 +1562,8 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_00844, VALIDATION_ERROR_UNDEFINED);
+ skip |=
+ ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_1f805601, VALIDATION_ERROR_UNDEFINED);
if (pCreateInfo) {
if (pCreateInfo->pBindings) {
for (uint32_t idx0 = 0; idx0 < pCreateInfo->bindingCount; ++idx0) {
@@ -1511,7 +1572,7 @@
if (pCreateInfo->pBindings[idx0].pImmutableSamplers) {
for (uint32_t idx1 = 0; idx1 < pCreateInfo->pBindings[idx0].descriptorCount; ++idx1) {
skip |= ValidateObject(device, pCreateInfo->pBindings[idx0].pImmutableSamplers[idx1],
- kVulkanObjectTypeSampler, false, VALIDATION_ERROR_00852,
+ kVulkanObjectTypeSampler, false, VALIDATION_ERROR_04e00234,
VALIDATION_ERROR_UNDEFINED);
}
}
@@ -1539,17 +1600,18 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_00857, VALIDATION_ERROR_UNDEFINED);
- skip |= ValidateObject(device, descriptorSetLayout, kVulkanObjectTypeDescriptorSetLayout, true, VALIDATION_ERROR_00858,
- VALIDATION_ERROR_00860);
+ skip |=
+ ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_24605601, VALIDATION_ERROR_UNDEFINED);
+ skip |= ValidateObject(device, descriptorSetLayout, kVulkanObjectTypeDescriptorSetLayout, true, VALIDATION_ERROR_24604c01,
+ VALIDATION_ERROR_24604c07);
}
if (skip) {
return;
}
{
std::lock_guard<std::mutex> lock(global_lock);
- DestroyObject(device, descriptorSetLayout, kVulkanObjectTypeDescriptorSetLayout, pAllocator, VALIDATION_ERROR_00855,
- VALIDATION_ERROR_00856);
+ DestroyObject(device, descriptorSetLayout, kVulkanObjectTypeDescriptorSetLayout, pAllocator, VALIDATION_ERROR_24600238,
+ VALIDATION_ERROR_2460023a);
}
get_dispatch_table(ot_device_table_map, device)->DestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator);
}
@@ -1559,7 +1621,8 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_00889, VALIDATION_ERROR_UNDEFINED);
+ skip |=
+ ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_1f605601, VALIDATION_ERROR_UNDEFINED);
}
if (skip) {
return VK_ERROR_VALIDATION_FAILED_EXT;
@@ -1580,9 +1643,9 @@
bool skip = false;
std::unique_lock<std::mutex> lock(global_lock);
layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_00929, VALIDATION_ERROR_UNDEFINED);
- skip |= ValidateObject(device, descriptorPool, kVulkanObjectTypeDescriptorPool, false, VALIDATION_ERROR_00930,
- VALIDATION_ERROR_00932);
+ skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_32a05601, VALIDATION_ERROR_UNDEFINED);
+ skip |= ValidateObject(device, descriptorPool, kVulkanObjectTypeDescriptorPool, false, VALIDATION_ERROR_32a04601,
+ VALIDATION_ERROR_32a04607);
if (skip) {
return VK_ERROR_VALIDATION_FAILED_EXT;
}
@@ -1608,16 +1671,17 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_00933, VALIDATION_ERROR_UNDEFINED);
+ skip |=
+ ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_33c05601, VALIDATION_ERROR_UNDEFINED);
if (pDescriptorCopies) {
for (uint32_t idx0 = 0; idx0 < descriptorCopyCount; ++idx0) {
if (pDescriptorCopies[idx0].dstSet) {
skip |= ValidateObject(device, pDescriptorCopies[idx0].dstSet, kVulkanObjectTypeDescriptorSet, false,
- VALIDATION_ERROR_00972, VALIDATION_ERROR_00973);
+ VALIDATION_ERROR_03207601, VALIDATION_ERROR_03200009);
}
if (pDescriptorCopies[idx0].srcSet) {
skip |= ValidateObject(device, pDescriptorCopies[idx0].srcSet, kVulkanObjectTypeDescriptorSet, false,
- VALIDATION_ERROR_00971, VALIDATION_ERROR_00973);
+ VALIDATION_ERROR_0322d201, VALIDATION_ERROR_03200009);
}
}
}
@@ -1625,13 +1689,13 @@
for (uint32_t idx1 = 0; idx1 < descriptorWriteCount; ++idx1) {
if (pDescriptorWrites[idx1].dstSet) {
skip |= ValidateObject(device, pDescriptorWrites[idx1].dstSet, kVulkanObjectTypeDescriptorSet, false,
- VALIDATION_ERROR_00955, VALIDATION_ERROR_00958);
+ VALIDATION_ERROR_15c00280, VALIDATION_ERROR_15c00009);
}
if ((pDescriptorWrites[idx1].descriptorType == VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER) ||
(pDescriptorWrites[idx1].descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER)) {
for (uint32_t idx2 = 0; idx2 < pDescriptorWrites[idx1].descriptorCount; ++idx2) {
skip |= ValidateObject(device, pDescriptorWrites[idx1].pTexelBufferView[idx2], kVulkanObjectTypeBufferView,
- false, VALIDATION_ERROR_00940, VALIDATION_ERROR_00958);
+ false, VALIDATION_ERROR_15c00286, VALIDATION_ERROR_15c00009);
}
}
if ((pDescriptorWrites[idx1].descriptorType == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER) ||
@@ -1639,8 +1703,9 @@
(pDescriptorWrites[idx1].descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_IMAGE) ||
(pDescriptorWrites[idx1].descriptorType == VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT)) {
for (uint32_t idx3 = 0; idx3 < pDescriptorWrites[idx1].descriptorCount; ++idx3) {
- skip |= ValidateObject(device, pDescriptorWrites[idx1].pImageInfo[idx3].imageView,
- kVulkanObjectTypeImageView, false, VALIDATION_ERROR_00943, VALIDATION_ERROR_00963);
+ skip |=
+ ValidateObject(device, pDescriptorWrites[idx1].pImageInfo[idx3].imageView, kVulkanObjectTypeImageView,
+ false, VALIDATION_ERROR_15c0028c, VALIDATION_ERROR_04600009);
}
}
if ((pDescriptorWrites[idx1].descriptorType == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER) ||
@@ -1651,7 +1716,7 @@
if (pDescriptorWrites[idx1].pBufferInfo[idx4].buffer) {
skip |=
ValidateObject(device, pDescriptorWrites[idx1].pBufferInfo[idx4].buffer, kVulkanObjectTypeBuffer,
- false, VALIDATION_ERROR_00962, VALIDATION_ERROR_UNDEFINED);
+ false, VALIDATION_ERROR_04401a01, VALIDATION_ERROR_UNDEFINED);
}
}
}
@@ -1670,17 +1735,18 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_00400, VALIDATION_ERROR_UNDEFINED);
+ skip |=
+ ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_20605601, VALIDATION_ERROR_UNDEFINED);
if (pCreateInfo) {
if (pCreateInfo->pAttachments) {
for (uint32_t idx0 = 0; idx0 < pCreateInfo->attachmentCount; ++idx0) {
skip |= ValidateObject(device, pCreateInfo->pAttachments[idx0], kVulkanObjectTypeImageView, false,
- VALIDATION_ERROR_00420, VALIDATION_ERROR_00421);
+ VALIDATION_ERROR_0940f201, VALIDATION_ERROR_09400009);
}
}
if (pCreateInfo->renderPass) {
- skip |= ValidateObject(device, pCreateInfo->renderPass, kVulkanObjectTypeRenderPass, false, VALIDATION_ERROR_00419,
- VALIDATION_ERROR_00421);
+ skip |= ValidateObject(device, pCreateInfo->renderPass, kVulkanObjectTypeRenderPass, false,
+ VALIDATION_ERROR_0942ae01, VALIDATION_ERROR_09400009);
}
}
}
@@ -1702,17 +1768,18 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_00425, VALIDATION_ERROR_UNDEFINED);
skip |=
- ValidateObject(device, framebuffer, kVulkanObjectTypeFramebuffer, true, VALIDATION_ERROR_00426, VALIDATION_ERROR_00428);
+ ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_25005601, VALIDATION_ERROR_UNDEFINED);
+ skip |= ValidateObject(device, framebuffer, kVulkanObjectTypeFramebuffer, true, VALIDATION_ERROR_25009401,
+ VALIDATION_ERROR_25009407);
}
if (skip) {
return;
}
{
std::lock_guard<std::mutex> lock(global_lock);
- DestroyObject(device, framebuffer, kVulkanObjectTypeFramebuffer, pAllocator, VALIDATION_ERROR_00423,
- VALIDATION_ERROR_00424);
+ DestroyObject(device, framebuffer, kVulkanObjectTypeFramebuffer, pAllocator, VALIDATION_ERROR_250006fa,
+ VALIDATION_ERROR_250006fc);
}
get_dispatch_table(ot_device_table_map, device)->DestroyFramebuffer(device, framebuffer, pAllocator);
}
@@ -1722,7 +1789,8 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_00319, VALIDATION_ERROR_UNDEFINED);
+ skip |=
+ ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_22005601, VALIDATION_ERROR_UNDEFINED);
}
if (skip) {
return VK_ERROR_VALIDATION_FAILED_EXT;
@@ -1742,16 +1810,18 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_00396, VALIDATION_ERROR_UNDEFINED);
skip |=
- ValidateObject(device, renderPass, kVulkanObjectTypeRenderPass, true, VALIDATION_ERROR_00397, VALIDATION_ERROR_00399);
+ ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_26405601, VALIDATION_ERROR_UNDEFINED);
+ skip |= ValidateObject(device, renderPass, kVulkanObjectTypeRenderPass, true, VALIDATION_ERROR_2642ae01,
+ VALIDATION_ERROR_2642ae07);
}
if (skip) {
return;
}
{
std::lock_guard<std::mutex> lock(global_lock);
- DestroyObject(device, renderPass, kVulkanObjectTypeRenderPass, pAllocator, VALIDATION_ERROR_00394, VALIDATION_ERROR_00395);
+ DestroyObject(device, renderPass, kVulkanObjectTypeRenderPass, pAllocator, VALIDATION_ERROR_264006d4,
+ VALIDATION_ERROR_264006d6);
}
get_dispatch_table(ot_device_table_map, device)->DestroyRenderPass(device, renderPass, pAllocator);
}
@@ -1760,9 +1830,10 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_00449, VALIDATION_ERROR_UNDEFINED);
skip |=
- ValidateObject(device, renderPass, kVulkanObjectTypeRenderPass, false, VALIDATION_ERROR_00450, VALIDATION_ERROR_00452);
+ ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_30005601, VALIDATION_ERROR_UNDEFINED);
+ skip |= ValidateObject(device, renderPass, kVulkanObjectTypeRenderPass, false, VALIDATION_ERROR_3002ae01,
+ VALIDATION_ERROR_3002ae07);
}
if (skip) {
return;
@@ -1775,7 +1846,8 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_00064, VALIDATION_ERROR_UNDEFINED);
+ skip |=
+ ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_1f005601, VALIDATION_ERROR_UNDEFINED);
}
if (skip) {
return VK_ERROR_VALIDATION_FAILED_EXT;
@@ -1795,9 +1867,10 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_00073, VALIDATION_ERROR_UNDEFINED);
- skip |= ValidateObject(device, commandPool, kVulkanObjectTypeCommandPool, false, VALIDATION_ERROR_00074,
- VALIDATION_ERROR_00076);
+ skip |=
+ ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_32805601, VALIDATION_ERROR_UNDEFINED);
+ skip |= ValidateObject(device, commandPool, kVulkanObjectTypeCommandPool, false, VALIDATION_ERROR_32802801,
+ VALIDATION_ERROR_32802807);
}
if (skip) {
return VK_ERROR_VALIDATION_FAILED_EXT;
@@ -1811,16 +1884,16 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(command_buffer, command_buffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_00108,
+ skip |= ValidateObject(command_buffer, command_buffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_16e02401,
VALIDATION_ERROR_UNDEFINED);
if (begin_info) {
OBJTRACK_NODE *pNode = device_data->object_map[kVulkanObjectTypeCommandBuffer][HandleToUint64(command_buffer)];
if ((begin_info->pInheritanceInfo) && (pNode->status & OBJSTATUS_COMMAND_BUFFER_SECONDARY) &&
(begin_info->flags & VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT)) {
skip |= ValidateObject(command_buffer, begin_info->pInheritanceInfo->framebuffer, kVulkanObjectTypeFramebuffer,
- true, VALIDATION_ERROR_00112, VALIDATION_ERROR_00121);
+ true, VALIDATION_ERROR_0280006e, VALIDATION_ERROR_02a00009);
skip |= ValidateObject(command_buffer, begin_info->pInheritanceInfo->renderPass, kVulkanObjectTypeRenderPass, false,
- VALIDATION_ERROR_00110, VALIDATION_ERROR_00121);
+ VALIDATION_ERROR_0280006a, VALIDATION_ERROR_02a00009);
}
}
}
@@ -1835,7 +1908,7 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_00125,
+ skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_27402401,
VALIDATION_ERROR_UNDEFINED);
}
if (skip) {
@@ -1849,7 +1922,7 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_00094,
+ skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_32602401,
VALIDATION_ERROR_UNDEFINED);
}
if (skip) {
@@ -1864,10 +1937,10 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_00599,
+ skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_18002401,
VALIDATION_ERROR_UNDEFINED);
- skip |= ValidateObject(commandBuffer, pipeline, kVulkanObjectTypePipeline, false, VALIDATION_ERROR_00601,
- VALIDATION_ERROR_00604);
+ skip |= ValidateObject(commandBuffer, pipeline, kVulkanObjectTypePipeline, false, VALIDATION_ERROR_18027c01,
+ VALIDATION_ERROR_18000009);
}
if (skip) {
return;
@@ -1880,7 +1953,7 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_01443,
+ skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_1e002401,
VALIDATION_ERROR_UNDEFINED);
}
if (skip) {
@@ -1894,7 +1967,7 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_01492,
+ skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_1d802401,
VALIDATION_ERROR_UNDEFINED);
}
if (skip) {
@@ -1907,7 +1980,7 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_01478,
+ skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_1d602401,
VALIDATION_ERROR_UNDEFINED);
}
if (skip) {
@@ -1921,7 +1994,7 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_01483,
+ skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_1cc02401,
VALIDATION_ERROR_UNDEFINED);
}
if (skip) {
@@ -1935,7 +2008,7 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_01551,
+ skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_1ca02401,
VALIDATION_ERROR_UNDEFINED);
}
if (skip) {
@@ -1948,7 +2021,7 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_01507,
+ skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_1ce02401,
VALIDATION_ERROR_UNDEFINED);
}
if (skip) {
@@ -1962,7 +2035,7 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_01515,
+ skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_1da02401,
VALIDATION_ERROR_UNDEFINED);
}
if (skip) {
@@ -1975,7 +2048,7 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_01521,
+ skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_1de02401,
VALIDATION_ERROR_UNDEFINED);
}
if (skip) {
@@ -1988,7 +2061,7 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_01527,
+ skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_1dc02401,
VALIDATION_ERROR_UNDEFINED);
}
if (skip) {
@@ -2004,14 +2077,14 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_00979,
+ skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_17c02401,
VALIDATION_ERROR_UNDEFINED);
- skip |= ValidateObject(commandBuffer, layout, kVulkanObjectTypePipelineLayout, false, VALIDATION_ERROR_00981,
- VALIDATION_ERROR_00987);
+ skip |= ValidateObject(commandBuffer, layout, kVulkanObjectTypePipelineLayout, false, VALIDATION_ERROR_17c0be01,
+ VALIDATION_ERROR_17c00009);
if (pDescriptorSets) {
for (uint32_t idx0 = 0; idx0 < descriptorSetCount; ++idx0) {
skip |= ValidateObject(commandBuffer, pDescriptorSets[idx0], kVulkanObjectTypeDescriptorSet, false,
- VALIDATION_ERROR_00982, VALIDATION_ERROR_00987);
+ VALIDATION_ERROR_17c13001, VALIDATION_ERROR_17c00009);
}
}
}
@@ -2028,10 +2101,10 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_01353,
+ skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_17e02401,
VALIDATION_ERROR_UNDEFINED);
- skip |=
- ValidateObject(commandBuffer, buffer, kVulkanObjectTypeBuffer, false, VALIDATION_ERROR_01354, VALIDATION_ERROR_01358);
+ skip |= ValidateObject(commandBuffer, buffer, kVulkanObjectTypeBuffer, false, VALIDATION_ERROR_17e01a01,
+ VALIDATION_ERROR_17e00009);
}
if (skip) {
return;
@@ -2044,12 +2117,12 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_01419,
+ skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_18202401,
VALIDATION_ERROR_UNDEFINED);
if (pBuffers) {
for (uint32_t idx0 = 0; idx0 < bindingCount; ++idx0) {
- skip |= ValidateObject(commandBuffer, pBuffers[idx0], kVulkanObjectTypeBuffer, false, VALIDATION_ERROR_01420,
- VALIDATION_ERROR_01425);
+ skip |= ValidateObject(commandBuffer, pBuffers[idx0], kVulkanObjectTypeBuffer, false, VALIDATION_ERROR_18210601,
+ VALIDATION_ERROR_18200009);
}
}
}
@@ -2065,7 +2138,7 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_01362,
+ skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_1a202401,
VALIDATION_ERROR_UNDEFINED);
}
if (skip) {
@@ -2080,7 +2153,7 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_01369,
+ skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_1a402401,
VALIDATION_ERROR_UNDEFINED);
}
if (skip) {
@@ -2095,10 +2168,10 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_01377,
+ skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_1aa02401,
VALIDATION_ERROR_UNDEFINED);
- skip |=
- ValidateObject(commandBuffer, buffer, kVulkanObjectTypeBuffer, false, VALIDATION_ERROR_01378, VALIDATION_ERROR_01382);
+ skip |= ValidateObject(commandBuffer, buffer, kVulkanObjectTypeBuffer, false, VALIDATION_ERROR_1aa01a01,
+ VALIDATION_ERROR_1aa00009);
}
if (skip) {
return;
@@ -2111,10 +2184,10 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_01389,
+ skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_1a602401,
VALIDATION_ERROR_UNDEFINED);
- skip |=
- ValidateObject(commandBuffer, buffer, kVulkanObjectTypeBuffer, false, VALIDATION_ERROR_01390, VALIDATION_ERROR_01394);
+ skip |= ValidateObject(commandBuffer, buffer, kVulkanObjectTypeBuffer, false, VALIDATION_ERROR_1a601a01,
+ VALIDATION_ERROR_1a600009);
}
if (skip) {
return;
@@ -2127,7 +2200,7 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_01559,
+ skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_19c02401,
VALIDATION_ERROR_UNDEFINED);
}
if (skip) {
@@ -2140,9 +2213,9 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |=
- ValidateObject(commandBuffer, buffer, kVulkanObjectTypeBuffer, false, VALIDATION_ERROR_01566, VALIDATION_ERROR_01570);
- skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_01565,
+ skip |= ValidateObject(commandBuffer, buffer, kVulkanObjectTypeBuffer, false, VALIDATION_ERROR_1a001a01,
+ VALIDATION_ERROR_1a000009);
+ skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_1a002401,
VALIDATION_ERROR_UNDEFINED);
}
if (skip) {
@@ -2156,12 +2229,12 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_01166,
+ skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_18c02401,
VALIDATION_ERROR_UNDEFINED);
- skip |= ValidateObject(commandBuffer, dstBuffer, kVulkanObjectTypeBuffer, false, VALIDATION_ERROR_01168,
- VALIDATION_ERROR_01174);
- skip |= ValidateObject(commandBuffer, srcBuffer, kVulkanObjectTypeBuffer, false, VALIDATION_ERROR_01167,
- VALIDATION_ERROR_01174);
+ skip |= ValidateObject(commandBuffer, dstBuffer, kVulkanObjectTypeBuffer, false, VALIDATION_ERROR_18c06c01,
+ VALIDATION_ERROR_18c00009);
+ skip |= ValidateObject(commandBuffer, srcBuffer, kVulkanObjectTypeBuffer, false, VALIDATION_ERROR_18c2c801,
+ VALIDATION_ERROR_18c00009);
}
if (skip) {
return;
@@ -2176,12 +2249,12 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_01186,
+ skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_19002401,
VALIDATION_ERROR_UNDEFINED);
- skip |=
- ValidateObject(commandBuffer, dstImage, kVulkanObjectTypeImage, false, VALIDATION_ERROR_01189, VALIDATION_ERROR_01196);
- skip |=
- ValidateObject(commandBuffer, srcImage, kVulkanObjectTypeImage, false, VALIDATION_ERROR_01187, VALIDATION_ERROR_01196);
+ skip |= ValidateObject(commandBuffer, dstImage, kVulkanObjectTypeImage, false, VALIDATION_ERROR_19007201,
+ VALIDATION_ERROR_19000009);
+ skip |= ValidateObject(commandBuffer, srcImage, kVulkanObjectTypeImage, false, VALIDATION_ERROR_1902ce01,
+ VALIDATION_ERROR_19000009);
}
if (skip) {
return;
@@ -2196,12 +2269,12 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_01291,
+ skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_18402401,
VALIDATION_ERROR_UNDEFINED);
- skip |=
- ValidateObject(commandBuffer, dstImage, kVulkanObjectTypeImage, false, VALIDATION_ERROR_01294, VALIDATION_ERROR_01302);
- skip |=
- ValidateObject(commandBuffer, srcImage, kVulkanObjectTypeImage, false, VALIDATION_ERROR_01292, VALIDATION_ERROR_01302);
+ skip |= ValidateObject(commandBuffer, dstImage, kVulkanObjectTypeImage, false, VALIDATION_ERROR_18407201,
+ VALIDATION_ERROR_18400009);
+ skip |= ValidateObject(commandBuffer, srcImage, kVulkanObjectTypeImage, false, VALIDATION_ERROR_1842ce01,
+ VALIDATION_ERROR_18400009);
}
if (skip) {
return;
@@ -2216,12 +2289,12 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_01235,
+ skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_18e02401,
VALIDATION_ERROR_UNDEFINED);
- skip |=
- ValidateObject(commandBuffer, dstImage, kVulkanObjectTypeImage, false, VALIDATION_ERROR_01237, VALIDATION_ERROR_01244);
- skip |= ValidateObject(commandBuffer, srcBuffer, kVulkanObjectTypeBuffer, false, VALIDATION_ERROR_01236,
- VALIDATION_ERROR_01244);
+ skip |= ValidateObject(commandBuffer, dstImage, kVulkanObjectTypeImage, false, VALIDATION_ERROR_18e07201,
+ VALIDATION_ERROR_18e00009);
+ skip |= ValidateObject(commandBuffer, srcBuffer, kVulkanObjectTypeBuffer, false, VALIDATION_ERROR_18e2c801,
+ VALIDATION_ERROR_18e00009);
}
if (skip) {
return;
@@ -2235,12 +2308,12 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_01253,
+ skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_19202401,
VALIDATION_ERROR_UNDEFINED);
- skip |= ValidateObject(commandBuffer, dstBuffer, kVulkanObjectTypeBuffer, false, VALIDATION_ERROR_01256,
- VALIDATION_ERROR_01262);
- skip |=
- ValidateObject(commandBuffer, srcImage, kVulkanObjectTypeImage, false, VALIDATION_ERROR_01254, VALIDATION_ERROR_01262);
+ skip |= ValidateObject(commandBuffer, dstBuffer, kVulkanObjectTypeBuffer, false, VALIDATION_ERROR_19206c01,
+ VALIDATION_ERROR_19200009);
+ skip |= ValidateObject(commandBuffer, srcImage, kVulkanObjectTypeImage, false, VALIDATION_ERROR_1922ce01,
+ VALIDATION_ERROR_19200009);
}
if (skip) {
return;
@@ -2254,10 +2327,10 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_01150,
+ skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_1e402401,
VALIDATION_ERROR_UNDEFINED);
- skip |= ValidateObject(commandBuffer, dstBuffer, kVulkanObjectTypeBuffer, false, VALIDATION_ERROR_01151,
- VALIDATION_ERROR_01157);
+ skip |= ValidateObject(commandBuffer, dstBuffer, kVulkanObjectTypeBuffer, false, VALIDATION_ERROR_1e406c01,
+ VALIDATION_ERROR_1e400009);
}
if (skip) {
return;
@@ -2270,10 +2343,10 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_01138,
+ skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_1b402401,
VALIDATION_ERROR_UNDEFINED);
- skip |= ValidateObject(commandBuffer, dstBuffer, kVulkanObjectTypeBuffer, false, VALIDATION_ERROR_01139,
- VALIDATION_ERROR_01143);
+ skip |= ValidateObject(commandBuffer, dstBuffer, kVulkanObjectTypeBuffer, false, VALIDATION_ERROR_1b406c01,
+ VALIDATION_ERROR_1b400009);
}
if (skip) {
return;
@@ -2287,9 +2360,10 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_01089,
+ skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_18802401,
VALIDATION_ERROR_UNDEFINED);
- skip |= ValidateObject(commandBuffer, image, kVulkanObjectTypeImage, false, VALIDATION_ERROR_01090, VALIDATION_ERROR_01098);
+ skip |= ValidateObject(commandBuffer, image, kVulkanObjectTypeImage, false, VALIDATION_ERROR_1880a001,
+ VALIDATION_ERROR_18800009);
}
if (skip) {
return;
@@ -2304,9 +2378,10 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_01104,
+ skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_18a02401,
VALIDATION_ERROR_UNDEFINED);
- skip |= ValidateObject(commandBuffer, image, kVulkanObjectTypeImage, false, VALIDATION_ERROR_01105, VALIDATION_ERROR_01113);
+ skip |= ValidateObject(commandBuffer, image, kVulkanObjectTypeImage, false, VALIDATION_ERROR_18a0a001,
+ VALIDATION_ERROR_18a00009);
}
if (skip) {
return;
@@ -2321,7 +2396,7 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_01117,
+ skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_18602401,
VALIDATION_ERROR_UNDEFINED);
}
if (skip) {
@@ -2337,12 +2412,12 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_01327,
+ skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_1c802401,
VALIDATION_ERROR_UNDEFINED);
- skip |=
- ValidateObject(commandBuffer, dstImage, kVulkanObjectTypeImage, false, VALIDATION_ERROR_01330, VALIDATION_ERROR_01337);
- skip |=
- ValidateObject(commandBuffer, srcImage, kVulkanObjectTypeImage, false, VALIDATION_ERROR_01328, VALIDATION_ERROR_01337);
+ skip |= ValidateObject(commandBuffer, dstImage, kVulkanObjectTypeImage, false, VALIDATION_ERROR_1c807201,
+ VALIDATION_ERROR_1c800009);
+ skip |= ValidateObject(commandBuffer, srcImage, kVulkanObjectTypeImage, false, VALIDATION_ERROR_1c82ce01,
+ VALIDATION_ERROR_1c800009);
}
if (skip) {
return;
@@ -2355,9 +2430,10 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_00232,
+ skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_1d402401,
VALIDATION_ERROR_UNDEFINED);
- skip |= ValidateObject(commandBuffer, event, kVulkanObjectTypeEvent, false, VALIDATION_ERROR_00233, VALIDATION_ERROR_00239);
+ skip |= ValidateObject(commandBuffer, event, kVulkanObjectTypeEvent, false, VALIDATION_ERROR_1d407e01,
+ VALIDATION_ERROR_1d400009);
}
if (skip) {
return;
@@ -2369,9 +2445,10 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_00243,
+ skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_1c402401,
VALIDATION_ERROR_UNDEFINED);
- skip |= ValidateObject(commandBuffer, event, kVulkanObjectTypeEvent, false, VALIDATION_ERROR_00244, VALIDATION_ERROR_00250);
+ skip |= ValidateObject(commandBuffer, event, kVulkanObjectTypeEvent, false, VALIDATION_ERROR_1c407e01,
+ VALIDATION_ERROR_1c400009);
}
if (skip) {
return;
@@ -2387,27 +2464,27 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_00252,
+ skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_1e602401,
VALIDATION_ERROR_UNDEFINED);
if (pBufferMemoryBarriers) {
for (uint32_t idx0 = 0; idx0 < bufferMemoryBarrierCount; ++idx0) {
if (pBufferMemoryBarriers[idx0].buffer) {
skip |= ValidateObject(commandBuffer, pBufferMemoryBarriers[idx0].buffer, kVulkanObjectTypeBuffer, false,
- VALIDATION_ERROR_00259, VALIDATION_ERROR_UNDEFINED);
+ VALIDATION_ERROR_1e610401, VALIDATION_ERROR_UNDEFINED);
}
}
}
if (pEvents) {
for (uint32_t idx1 = 0; idx1 < eventCount; ++idx1) {
- skip |= ValidateObject(commandBuffer, pEvents[idx1], kVulkanObjectTypeEvent, false, VALIDATION_ERROR_00253,
- VALIDATION_ERROR_00264);
+ skip |= ValidateObject(commandBuffer, pEvents[idx1], kVulkanObjectTypeEvent, false, VALIDATION_ERROR_1e616001,
+ VALIDATION_ERROR_1e600009);
}
}
if (pImageMemoryBarriers) {
for (uint32_t idx2 = 0; idx2 < imageMemoryBarrierCount; ++idx2) {
if (pImageMemoryBarriers[idx2].image) {
skip |= ValidateObject(commandBuffer, pImageMemoryBarriers[idx2].image, kVulkanObjectTypeImage, false,
- VALIDATION_ERROR_00260, VALIDATION_ERROR_UNDEFINED);
+ VALIDATION_ERROR_1e618a01, VALIDATION_ERROR_UNDEFINED);
}
}
}
@@ -2428,13 +2505,13 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_00270,
+ skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_1b802401,
VALIDATION_ERROR_UNDEFINED);
if (pBufferMemoryBarriers) {
for (uint32_t idx0 = 0; idx0 < bufferMemoryBarrierCount; ++idx0) {
if (pBufferMemoryBarriers[idx0].buffer) {
skip |= ValidateObject(commandBuffer, pBufferMemoryBarriers[idx0].buffer, kVulkanObjectTypeBuffer, false,
- VALIDATION_ERROR_00277, VALIDATION_ERROR_UNDEFINED);
+ VALIDATION_ERROR_1b810401, VALIDATION_ERROR_UNDEFINED);
}
}
}
@@ -2442,7 +2519,7 @@
for (uint32_t idx1 = 0; idx1 < imageMemoryBarrierCount; ++idx1) {
if (pImageMemoryBarriers[idx1].image) {
skip |= ValidateObject(commandBuffer, pImageMemoryBarriers[idx1].image, kVulkanObjectTypeImage, false,
- VALIDATION_ERROR_00278, VALIDATION_ERROR_UNDEFINED);
+ VALIDATION_ERROR_1b818a01, VALIDATION_ERROR_UNDEFINED);
}
}
}
@@ -2460,10 +2537,10 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_01035,
+ skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_17802401,
VALIDATION_ERROR_UNDEFINED);
- skip |= ValidateObject(commandBuffer, queryPool, kVulkanObjectTypeQueryPool, false, VALIDATION_ERROR_01036,
- VALIDATION_ERROR_01040);
+ skip |= ValidateObject(commandBuffer, queryPool, kVulkanObjectTypeQueryPool, false, VALIDATION_ERROR_17829801,
+ VALIDATION_ERROR_17800009);
}
if (skip) {
return;
@@ -2475,10 +2552,10 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_01043,
+ skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_1ae02401,
VALIDATION_ERROR_UNDEFINED);
- skip |= ValidateObject(commandBuffer, queryPool, kVulkanObjectTypeQueryPool, false, VALIDATION_ERROR_01044,
- VALIDATION_ERROR_01047);
+ skip |= ValidateObject(commandBuffer, queryPool, kVulkanObjectTypeQueryPool, false, VALIDATION_ERROR_1ae29801,
+ VALIDATION_ERROR_1ae00009);
}
if (skip) {
return;
@@ -2491,10 +2568,10 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_01021,
+ skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_1c602401,
VALIDATION_ERROR_UNDEFINED);
- skip |= ValidateObject(commandBuffer, queryPool, kVulkanObjectTypeQueryPool, false, VALIDATION_ERROR_01022,
- VALIDATION_ERROR_01026);
+ skip |= ValidateObject(commandBuffer, queryPool, kVulkanObjectTypeQueryPool, false, VALIDATION_ERROR_1c629801,
+ VALIDATION_ERROR_1c600009);
}
if (skip) {
return;
@@ -2507,10 +2584,10 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_01078,
+ skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_1e802401,
VALIDATION_ERROR_UNDEFINED);
- skip |= ValidateObject(commandBuffer, queryPool, kVulkanObjectTypeQueryPool, false, VALIDATION_ERROR_01080,
- VALIDATION_ERROR_01083);
+ skip |= ValidateObject(commandBuffer, queryPool, kVulkanObjectTypeQueryPool, false, VALIDATION_ERROR_1e829801,
+ VALIDATION_ERROR_1e800009);
}
if (skip) {
return;
@@ -2524,12 +2601,12 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_01068,
+ skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_19402401,
VALIDATION_ERROR_UNDEFINED);
- skip |= ValidateObject(commandBuffer, dstBuffer, kVulkanObjectTypeBuffer, false, VALIDATION_ERROR_01070,
- VALIDATION_ERROR_01075);
- skip |= ValidateObject(commandBuffer, queryPool, kVulkanObjectTypeQueryPool, false, VALIDATION_ERROR_01069,
- VALIDATION_ERROR_01075);
+ skip |= ValidateObject(commandBuffer, dstBuffer, kVulkanObjectTypeBuffer, false, VALIDATION_ERROR_19406c01,
+ VALIDATION_ERROR_19400009);
+ skip |= ValidateObject(commandBuffer, queryPool, kVulkanObjectTypeQueryPool, false, VALIDATION_ERROR_19429801,
+ VALIDATION_ERROR_19400009);
}
if (skip) {
return;
@@ -2543,10 +2620,10 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_00993,
+ skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_1bc02401,
VALIDATION_ERROR_UNDEFINED);
- skip |= ValidateObject(commandBuffer, layout, kVulkanObjectTypePipelineLayout, false, VALIDATION_ERROR_00994,
- VALIDATION_ERROR_01001);
+ skip |= ValidateObject(commandBuffer, layout, kVulkanObjectTypePipelineLayout, false, VALIDATION_ERROR_1bc0be01,
+ VALIDATION_ERROR_1bc00009);
}
if (skip) {
return;
@@ -2560,13 +2637,13 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_00435,
+ skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_17a02401,
VALIDATION_ERROR_UNDEFINED);
if (pRenderPassBegin) {
skip |= ValidateObject(commandBuffer, pRenderPassBegin->framebuffer, kVulkanObjectTypeFramebuffer, false,
- VALIDATION_ERROR_00446, VALIDATION_ERROR_00448);
+ VALIDATION_ERROR_12009401, VALIDATION_ERROR_12000009);
skip |= ValidateObject(commandBuffer, pRenderPassBegin->renderPass, kVulkanObjectTypeRenderPass, false,
- VALIDATION_ERROR_00445, VALIDATION_ERROR_00448);
+ VALIDATION_ERROR_1202ae01, VALIDATION_ERROR_12000009);
}
}
if (skip) {
@@ -2579,7 +2656,7 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_00454,
+ skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_1b602401,
VALIDATION_ERROR_UNDEFINED);
}
if (skip) {
@@ -2592,7 +2669,7 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_00461,
+ skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_1b002401,
VALIDATION_ERROR_UNDEFINED);
}
if (skip) {
@@ -2606,12 +2683,12 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_00159,
+ skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_1b202401,
VALIDATION_ERROR_UNDEFINED);
if (pCommandBuffers) {
for (uint32_t idx0 = 0; idx0 < commandBufferCount; ++idx0) {
skip |= ValidateObject(commandBuffer, pCommandBuffers[idx0], kVulkanObjectTypeCommandBuffer, false,
- VALIDATION_ERROR_00160, VALIDATION_ERROR_00165);
+ VALIDATION_ERROR_1b211401, VALIDATION_ERROR_1b200009);
}
}
}
@@ -2625,9 +2702,9 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(instance, instance, kVulkanObjectTypeInstance, false, VALIDATION_ERROR_01847,
+ skip |= ValidateObject(instance, instance, kVulkanObjectTypeInstance, false, VALIDATION_ERROR_26c0bc01,
VALIDATION_ERROR_UNDEFINED);
- skip |= ValidateObject(instance, surface, kVulkanObjectTypeSurfaceKHR, true, VALIDATION_ERROR_01848,
+ skip |= ValidateObject(instance, surface, kVulkanObjectTypeSurfaceKHR, true, VALIDATION_ERROR_26c2ec01,
VALIDATION_ERROR_UNDEFINED);
}
if (skip) {
@@ -2635,7 +2712,8 @@
}
{
std::lock_guard<std::mutex> lock(global_lock);
- DestroyObject(instance, surface, kVulkanObjectTypeSurfaceKHR, pAllocator, VALIDATION_ERROR_01845, VALIDATION_ERROR_01846);
+ DestroyObject(instance, surface, kVulkanObjectTypeSurfaceKHR, pAllocator, VALIDATION_ERROR_26c009e6,
+ VALIDATION_ERROR_26c009e8);
}
get_dispatch_table(ot_instance_table_map, instance)->DestroySurfaceKHR(instance, surface, pAllocator);
}
@@ -2645,9 +2723,9 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_01890,
+ skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_2ee27a01,
VALIDATION_ERROR_UNDEFINED);
- skip |= ValidateObject(physicalDevice, surface, kVulkanObjectTypeSurfaceKHR, false, VALIDATION_ERROR_01891,
+ skip |= ValidateObject(physicalDevice, surface, kVulkanObjectTypeSurfaceKHR, false, VALIDATION_ERROR_2ee2ec01,
VALIDATION_ERROR_UNDEFINED);
}
if (skip) {
@@ -2663,9 +2741,9 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_01907,
+ skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_2e627a01,
VALIDATION_ERROR_UNDEFINED);
- skip |= ValidateObject(physicalDevice, surface, kVulkanObjectTypeSurfaceKHR, false, VALIDATION_ERROR_01908,
+ skip |= ValidateObject(physicalDevice, surface, kVulkanObjectTypeSurfaceKHR, false, VALIDATION_ERROR_2e62ec01,
VALIDATION_ERROR_UNDEFINED);
}
if (skip) {
@@ -2682,9 +2760,9 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_01910,
+ skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_2ea27a01,
VALIDATION_ERROR_UNDEFINED);
- skip |= ValidateObject(physicalDevice, surface, kVulkanObjectTypeSurfaceKHR, false, VALIDATION_ERROR_01911,
+ skip |= ValidateObject(physicalDevice, surface, kVulkanObjectTypeSurfaceKHR, false, VALIDATION_ERROR_2ea2ec01,
VALIDATION_ERROR_UNDEFINED);
}
if (skip) {
@@ -2701,9 +2779,9 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_01914,
+ skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_2ec27a01,
VALIDATION_ERROR_UNDEFINED);
- skip |= ValidateObject(physicalDevice, surface, kVulkanObjectTypeSurfaceKHR, false, VALIDATION_ERROR_01915,
+ skip |= ValidateObject(physicalDevice, surface, kVulkanObjectTypeSurfaceKHR, false, VALIDATION_ERROR_2ec2ec01,
VALIDATION_ERROR_UNDEFINED);
}
if (skip) {
@@ -2719,13 +2797,14 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_01918, VALIDATION_ERROR_UNDEFINED);
+ skip |=
+ ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_22a05601, VALIDATION_ERROR_UNDEFINED);
if (pCreateInfo) {
- skip |= ValidateObject(device, pCreateInfo->oldSwapchain, kVulkanObjectTypeSwapchainKHR, true, VALIDATION_ERROR_01935,
- VALIDATION_ERROR_UNDEFINED);
+ skip |= ValidateObject(device, pCreateInfo->oldSwapchain, kVulkanObjectTypeSwapchainKHR, true,
+ VALIDATION_ERROR_1460de01, VALIDATION_ERROR_UNDEFINED);
layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
skip |= ValidateObject(device_data->physical_device, pCreateInfo->surface, kVulkanObjectTypeSurfaceKHR, false,
- VALIDATION_ERROR_01926, VALIDATION_ERROR_UNDEFINED);
+ VALIDATION_ERROR_1462ec01, VALIDATION_ERROR_UNDEFINED);
}
}
if (skip) {
@@ -2747,10 +2826,12 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_01954, VALIDATION_ERROR_UNDEFINED);
- skip |= ValidateObject(device, fence, kVulkanObjectTypeFence, true, VALIDATION_ERROR_01957, VALIDATION_ERROR_01960);
- skip |= ValidateObject(device, semaphore, kVulkanObjectTypeSemaphore, true, VALIDATION_ERROR_01956, VALIDATION_ERROR_01959);
- skip |= ValidateObject(device, swapchain, kVulkanObjectTypeSwapchainKHR, false, VALIDATION_ERROR_01955,
+ skip |=
+ ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_16405601, VALIDATION_ERROR_UNDEFINED);
+ skip |= ValidateObject(device, fence, kVulkanObjectTypeFence, true, VALIDATION_ERROR_16408801, VALIDATION_ERROR_16408807);
+ skip |= ValidateObject(device, semaphore, kVulkanObjectTypeSemaphore, true, VALIDATION_ERROR_1642b801,
+ VALIDATION_ERROR_1642b807);
+ skip |= ValidateObject(device, swapchain, kVulkanObjectTypeSwapchainKHR, false, VALIDATION_ERROR_1642f001,
VALIDATION_ERROR_UNDEFINED);
}
if (skip) {
@@ -2769,17 +2850,17 @@
if (pPresentInfo->pSwapchains) {
for (uint32_t idx0 = 0; idx0 < pPresentInfo->swapchainCount; ++idx0) {
skip |= ValidateObject(queue, pPresentInfo->pSwapchains[idx0], kVulkanObjectTypeSwapchainKHR, false,
- VALIDATION_ERROR_01969, VALIDATION_ERROR_UNDEFINED);
+ VALIDATION_ERROR_11225801, VALIDATION_ERROR_UNDEFINED);
}
}
if (pPresentInfo->pWaitSemaphores) {
for (uint32_t idx1 = 0; idx1 < pPresentInfo->waitSemaphoreCount; ++idx1) {
skip |= ValidateObject(queue, pPresentInfo->pWaitSemaphores[idx1], kVulkanObjectTypeSemaphore, false,
- VALIDATION_ERROR_01968, VALIDATION_ERROR_UNDEFINED);
+ VALIDATION_ERROR_11227601, VALIDATION_ERROR_UNDEFINED);
}
}
}
- skip |= ValidateObject(queue, queue, kVulkanObjectTypeQueue, false, VALIDATION_ERROR_01962, VALIDATION_ERROR_UNDEFINED);
+ skip |= ValidateObject(queue, queue, kVulkanObjectTypeQueue, false, VALIDATION_ERROR_31829c01, VALIDATION_ERROR_UNDEFINED);
}
if (skip) {
return VK_ERROR_VALIDATION_FAILED_EXT;
@@ -2794,7 +2875,7 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(instance, instance, kVulkanObjectTypeInstance, false, VALIDATION_ERROR_01820,
+ skip |= ValidateObject(instance, instance, kVulkanObjectTypeInstance, false, VALIDATION_ERROR_2300bc01,
VALIDATION_ERROR_UNDEFINED);
}
if (skip) {
@@ -2816,7 +2897,7 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_01900,
+ skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_2f227a01,
VALIDATION_ERROR_UNDEFINED);
}
if (skip) {
@@ -2834,7 +2915,7 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(instance, instance, kVulkanObjectTypeInstance, false, VALIDATION_ERROR_01827,
+ skip |= ValidateObject(instance, instance, kVulkanObjectTypeInstance, false, VALIDATION_ERROR_2320bc01,
VALIDATION_ERROR_UNDEFINED);
}
if (skip) {
@@ -2857,7 +2938,7 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_01902,
+ skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_2f427a01,
VALIDATION_ERROR_UNDEFINED);
}
if (skip) {
@@ -2875,7 +2956,7 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(instance, instance, kVulkanObjectTypeInstance, false, VALIDATION_ERROR_01836,
+ skip |= ValidateObject(instance, instance, kVulkanObjectTypeInstance, false, VALIDATION_ERROR_2340bc01,
VALIDATION_ERROR_UNDEFINED);
}
if (skip) {
@@ -2898,7 +2979,7 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_01905,
+ skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_2f627a01,
VALIDATION_ERROR_UNDEFINED);
}
if (skip) {
@@ -2916,7 +2997,7 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(instance, instance, kVulkanObjectTypeInstance, false, VALIDATION_ERROR_01802,
+ skip |= ValidateObject(instance, instance, kVulkanObjectTypeInstance, false, VALIDATION_ERROR_2160bc01,
VALIDATION_ERROR_UNDEFINED);
}
if (skip) {
@@ -2938,7 +3019,7 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_01894,
+ skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_2d227a01,
VALIDATION_ERROR_UNDEFINED);
}
if (skip) {
@@ -2956,7 +3037,7 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(instance, instance, kVulkanObjectTypeInstance, false, VALIDATION_ERROR_01811,
+ skip |= ValidateObject(instance, instance, kVulkanObjectTypeInstance, false, VALIDATION_ERROR_22e0bc01,
VALIDATION_ERROR_UNDEFINED);
}
if (skip) {
@@ -2979,7 +3060,7 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_01897,
+ skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_2f027a01,
VALIDATION_ERROR_UNDEFINED);
}
if (skip) {
@@ -2997,7 +3078,7 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(instance, instance, kVulkanObjectTypeInstance, false, VALIDATION_ERROR_01794,
+ skip |= ValidateObject(instance, instance, kVulkanObjectTypeInstance, false, VALIDATION_ERROR_1ea0bc01,
VALIDATION_ERROR_UNDEFINED);
}
if (skip) {
@@ -3088,14 +3169,15 @@
uint32_t i = 0;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_01943, VALIDATION_ERROR_UNDEFINED);
+ skip |=
+ ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_22805601, VALIDATION_ERROR_UNDEFINED);
if (NULL != pCreateInfos) {
for (i = 0; i < swapchainCount; i++) {
skip |= ValidateObject(device, pCreateInfos[i].oldSwapchain, kVulkanObjectTypeSwapchainKHR, true,
- VALIDATION_ERROR_01935, VALIDATION_ERROR_UNDEFINED);
+ VALIDATION_ERROR_1460de01, VALIDATION_ERROR_UNDEFINED);
layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
skip |= ValidateObject(device_data->physical_device, pCreateInfos[i].surface, kVulkanObjectTypeSurfaceKHR, false,
- VALIDATION_ERROR_01926, VALIDATION_ERROR_UNDEFINED);
+ VALIDATION_ERROR_1462ec01, VALIDATION_ERROR_UNDEFINED);
}
}
}
@@ -3135,8 +3217,8 @@
pInstanceTable->DestroyDebugReportCallbackEXT(instance, msgCallback, pAllocator);
layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map);
layer_destroy_msg_callback(instance_data->report_data, msgCallback, pAllocator);
- DestroyObject(instance, msgCallback, kVulkanObjectTypeDebugReportCallbackEXT, pAllocator, VALIDATION_ERROR_02049,
- VALIDATION_ERROR_02050);
+ DestroyObject(instance, msgCallback, kVulkanObjectTypeDebugReportCallbackEXT, pAllocator, VALIDATION_ERROR_242009b4,
+ VALIDATION_ERROR_242009b6);
}
VKAPI_ATTR void VKAPI_CALL DebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags,
@@ -3392,7 +3474,7 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_00028,
+ skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_2da27a01,
VALIDATION_ERROR_UNDEFINED);
}
if (skip) {
@@ -3457,7 +3539,7 @@
bool skip = VK_FALSE;
std::unique_lock<std::mutex> lock(global_lock);
skip |=
- ValidateObject(instance, instance, kVulkanObjectTypeInstance, false, VALIDATION_ERROR_00023, VALIDATION_ERROR_UNDEFINED);
+ ValidateObject(instance, instance, kVulkanObjectTypeInstance, false, VALIDATION_ERROR_2800bc01, VALIDATION_ERROR_UNDEFINED);
lock.unlock();
if (skip) {
return VK_ERROR_VALIDATION_FAILED_EXT;
@@ -3478,7 +3560,7 @@
VKAPI_ATTR void VKAPI_CALL GetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue *pQueue) {
std::unique_lock<std::mutex> lock(global_lock);
- ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_00062, VALIDATION_ERROR_UNDEFINED);
+ ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_29605601, VALIDATION_ERROR_UNDEFINED);
lock.unlock();
get_dispatch_table(ot_device_table_map, device)->GetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue);
@@ -3492,8 +3574,9 @@
VKAPI_ATTR void VKAPI_CALL FreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks *pAllocator) {
bool skip = false;
std::unique_lock<std::mutex> lock(global_lock);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_00621, VALIDATION_ERROR_UNDEFINED);
- skip |= ValidateObject(device, memory, kVulkanObjectTypeDeviceMemory, true, VALIDATION_ERROR_00622, VALIDATION_ERROR_00624);
+ skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_28805601, VALIDATION_ERROR_UNDEFINED);
+ skip |=
+ ValidateObject(device, memory, kVulkanObjectTypeDeviceMemory, true, VALIDATION_ERROR_2880c601, VALIDATION_ERROR_2880c607);
lock.unlock();
if (!skip) {
get_dispatch_table(ot_device_table_map, device)->FreeMemory(device, memory, pAllocator);
@@ -3508,8 +3591,9 @@
VkMemoryMapFlags flags, void **ppData) {
bool skip = VK_FALSE;
std::unique_lock<std::mutex> lock(global_lock);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_00630, VALIDATION_ERROR_UNDEFINED);
- skip |= ValidateObject(device, memory, kVulkanObjectTypeDeviceMemory, false, VALIDATION_ERROR_00631, VALIDATION_ERROR_00634);
+ skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_31205601, VALIDATION_ERROR_UNDEFINED);
+ skip |=
+ ValidateObject(device, memory, kVulkanObjectTypeDeviceMemory, false, VALIDATION_ERROR_3120c601, VALIDATION_ERROR_3120c607);
lock.unlock();
if (skip == VK_TRUE) {
return VK_ERROR_VALIDATION_FAILED_EXT;
@@ -3521,8 +3605,9 @@
VKAPI_ATTR void VKAPI_CALL UnmapMemory(VkDevice device, VkDeviceMemory memory) {
bool skip = VK_FALSE;
std::unique_lock<std::mutex> lock(global_lock);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_00650, VALIDATION_ERROR_UNDEFINED);
- skip |= ValidateObject(device, memory, kVulkanObjectTypeDeviceMemory, false, VALIDATION_ERROR_00651, VALIDATION_ERROR_00652);
+ skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_33605601, VALIDATION_ERROR_UNDEFINED);
+ skip |=
+ ValidateObject(device, memory, kVulkanObjectTypeDeviceMemory, false, VALIDATION_ERROR_3360c601, VALIDATION_ERROR_3360c607);
lock.unlock();
if (skip == VK_TRUE) {
return;
@@ -3535,29 +3620,29 @@
std::unique_lock<std::mutex> lock(global_lock);
ValidateQueueFlags(queue, "QueueBindSparse");
- ValidateObject(queue, queue, kVulkanObjectTypeQueue, false, VALIDATION_ERROR_01648, VALIDATION_ERROR_UNDEFINED);
- ValidateObject(queue, fence, kVulkanObjectTypeFence, true, VALIDATION_ERROR_01650, VALIDATION_ERROR_01652);
+ ValidateObject(queue, queue, kVulkanObjectTypeQueue, false, VALIDATION_ERROR_31629c01, VALIDATION_ERROR_UNDEFINED);
+ ValidateObject(queue, fence, kVulkanObjectTypeFence, true, VALIDATION_ERROR_31608801, VALIDATION_ERROR_31600009);
for (uint32_t i = 0; i < bindInfoCount; i++) {
for (uint32_t j = 0; j < pBindInfo[i].bufferBindCount; j++) {
- ValidateObject(queue, pBindInfo[i].pBufferBinds[j].buffer, kVulkanObjectTypeBuffer, false, VALIDATION_ERROR_01656,
+ ValidateObject(queue, pBindInfo[i].pBufferBinds[j].buffer, kVulkanObjectTypeBuffer, false, VALIDATION_ERROR_01210201,
VALIDATION_ERROR_UNDEFINED);
}
for (uint32_t j = 0; j < pBindInfo[i].imageOpaqueBindCount; j++) {
- ValidateObject(queue, pBindInfo[i].pImageOpaqueBinds[j].image, kVulkanObjectTypeImage, false, VALIDATION_ERROR_01657,
+ ValidateObject(queue, pBindInfo[i].pImageOpaqueBinds[j].image, kVulkanObjectTypeImage, false, VALIDATION_ERROR_01218c01,
VALIDATION_ERROR_UNDEFINED);
}
for (uint32_t j = 0; j < pBindInfo[i].imageBindCount; j++) {
- ValidateObject(queue, pBindInfo[i].pImageBinds[j].image, kVulkanObjectTypeImage, false, VALIDATION_ERROR_01658,
+ ValidateObject(queue, pBindInfo[i].pImageBinds[j].image, kVulkanObjectTypeImage, false, VALIDATION_ERROR_01218001,
VALIDATION_ERROR_UNDEFINED);
}
for (uint32_t j = 0; j < pBindInfo[i].waitSemaphoreCount; j++) {
- ValidateObject(queue, pBindInfo[i].pWaitSemaphores[j], kVulkanObjectTypeSemaphore, false, VALIDATION_ERROR_01655,
- VALIDATION_ERROR_01660);
+ ValidateObject(queue, pBindInfo[i].pWaitSemaphores[j], kVulkanObjectTypeSemaphore, false, VALIDATION_ERROR_01227601,
+ VALIDATION_ERROR_01200009);
}
for (uint32_t j = 0; j < pBindInfo[i].signalSemaphoreCount; j++) {
- ValidateObject(queue, pBindInfo[i].pSignalSemaphores[j], kVulkanObjectTypeSemaphore, false, VALIDATION_ERROR_01659,
- VALIDATION_ERROR_01660);
+ ValidateObject(queue, pBindInfo[i].pSignalSemaphores[j], kVulkanObjectTypeSemaphore, false, VALIDATION_ERROR_01223401,
+ VALIDATION_ERROR_01200009);
}
}
lock.unlock();
@@ -3570,8 +3655,8 @@
VkCommandBuffer *pCommandBuffers) {
bool skip = VK_FALSE;
std::unique_lock<std::mutex> lock(global_lock);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_00084, VALIDATION_ERROR_UNDEFINED);
- skip |= ValidateObject(device, pAllocateInfo->commandPool, kVulkanObjectTypeCommandPool, false, VALIDATION_ERROR_00090,
+ skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_16805601, VALIDATION_ERROR_UNDEFINED);
+ skip |= ValidateObject(device, pAllocateInfo->commandPool, kVulkanObjectTypeCommandPool, false, VALIDATION_ERROR_02602801,
VALIDATION_ERROR_UNDEFINED);
lock.unlock();
@@ -3595,12 +3680,12 @@
VkDescriptorSet *pDescriptorSets) {
bool skip = VK_FALSE;
std::unique_lock<std::mutex> lock(global_lock);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_00908, VALIDATION_ERROR_UNDEFINED);
- skip |= ValidateObject(device, pAllocateInfo->descriptorPool, kVulkanObjectTypeDescriptorPool, false, VALIDATION_ERROR_00915,
- VALIDATION_ERROR_00918);
+ skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_16a05601, VALIDATION_ERROR_UNDEFINED);
+ skip |= ValidateObject(device, pAllocateInfo->descriptorPool, kVulkanObjectTypeDescriptorPool, false, VALIDATION_ERROR_04c04601,
+ VALIDATION_ERROR_04c00009);
for (uint32_t i = 0; i < pAllocateInfo->descriptorSetCount; i++) {
skip |= ValidateObject(device, pAllocateInfo->pSetLayouts[i], kVulkanObjectTypeDescriptorSetLayout, false,
- VALIDATION_ERROR_00916, VALIDATION_ERROR_00918);
+ VALIDATION_ERROR_04c22c01, VALIDATION_ERROR_04c00009);
}
lock.unlock();
if (skip) {
@@ -3625,8 +3710,8 @@
const VkCommandBuffer *pCommandBuffers) {
bool skip = false;
std::unique_lock<std::mutex> lock(global_lock);
- ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_00098, VALIDATION_ERROR_UNDEFINED);
- ValidateObject(device, commandPool, kVulkanObjectTypeCommandPool, false, VALIDATION_ERROR_00099, VALIDATION_ERROR_00101);
+ ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_28405601, VALIDATION_ERROR_UNDEFINED);
+ ValidateObject(device, commandPool, kVulkanObjectTypeCommandPool, false, VALIDATION_ERROR_28402801, VALIDATION_ERROR_28402807);
for (uint32_t i = 0; i < commandBufferCount; i++) {
if (pCommandBuffers[i] != VK_NULL_HANDLE) {
skip |= ValidateCommandBuffer(device, commandPool, pCommandBuffers[i]);
@@ -3660,7 +3745,8 @@
++itr;
}
}
- DestroyObject(device, swapchain, kVulkanObjectTypeSwapchainKHR, pAllocator, VALIDATION_ERROR_01938, VALIDATION_ERROR_01939);
+ DestroyObject(device, swapchain, kVulkanObjectTypeSwapchainKHR, pAllocator, VALIDATION_ERROR_26e00a06,
+ VALIDATION_ERROR_26e00a08);
lock.unlock();
get_dispatch_table(ot_device_table_map, device)->DestroySwapchainKHR(device, swapchain, pAllocator);
@@ -3671,9 +3757,9 @@
bool skip = false;
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
std::unique_lock<std::mutex> lock(global_lock);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_00923, VALIDATION_ERROR_UNDEFINED);
- skip |= ValidateObject(device, descriptorPool, kVulkanObjectTypeDescriptorPool, false, VALIDATION_ERROR_00924,
- VALIDATION_ERROR_00926);
+ skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_28605601, VALIDATION_ERROR_UNDEFINED);
+ skip |= ValidateObject(device, descriptorPool, kVulkanObjectTypeDescriptorPool, false, VALIDATION_ERROR_28604601,
+ VALIDATION_ERROR_28604607);
for (uint32_t i = 0; i < descriptorSetCount; i++) {
if (pDescriptorSets[i] != VK_NULL_HANDLE) {
skip |= ValidateDescriptorSet(device, descriptorPool, pDescriptorSets[i]);
@@ -3698,9 +3784,9 @@
bool skip = VK_FALSE;
layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_00904, VALIDATION_ERROR_UNDEFINED);
- skip |= ValidateObject(device, descriptorPool, kVulkanObjectTypeDescriptorPool, true, VALIDATION_ERROR_00905,
- VALIDATION_ERROR_00907);
+ skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_24405601, VALIDATION_ERROR_UNDEFINED);
+ skip |= ValidateObject(device, descriptorPool, kVulkanObjectTypeDescriptorPool, true, VALIDATION_ERROR_24404601,
+ VALIDATION_ERROR_24404607);
lock.unlock();
if (skip) {
return;
@@ -3717,8 +3803,8 @@
VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED);
}
}
- DestroyObject(device, descriptorPool, kVulkanObjectTypeDescriptorPool, pAllocator, VALIDATION_ERROR_00902,
- VALIDATION_ERROR_00903);
+ DestroyObject(device, descriptorPool, kVulkanObjectTypeDescriptorPool, pAllocator, VALIDATION_ERROR_24400260,
+ VALIDATION_ERROR_24400262);
lock.unlock();
get_dispatch_table(ot_device_table_map, device)->DestroyDescriptorPool(device, descriptorPool, pAllocator);
}
@@ -3727,8 +3813,9 @@
layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
bool skip = false;
std::unique_lock<std::mutex> lock(global_lock);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_00080, VALIDATION_ERROR_UNDEFINED);
- skip |= ValidateObject(device, commandPool, kVulkanObjectTypeCommandPool, true, VALIDATION_ERROR_00081, VALIDATION_ERROR_00083);
+ skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_24005601, VALIDATION_ERROR_UNDEFINED);
+ skip |= ValidateObject(device, commandPool, kVulkanObjectTypeCommandPool, true, VALIDATION_ERROR_24002801,
+ VALIDATION_ERROR_24002807);
lock.unlock();
if (skip) {
return;
@@ -3747,7 +3834,8 @@
VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED);
}
}
- DestroyObject(device, commandPool, kVulkanObjectTypeCommandPool, pAllocator, VALIDATION_ERROR_00078, VALIDATION_ERROR_00079);
+ DestroyObject(device, commandPool, kVulkanObjectTypeCommandPool, pAllocator, VALIDATION_ERROR_24000054,
+ VALIDATION_ERROR_24000056);
lock.unlock();
get_dispatch_table(ot_device_table_map, device)->DestroyCommandPool(device, commandPool, pAllocator);
}
@@ -3756,7 +3844,7 @@
VkImage *pSwapchainImages) {
bool skip = VK_FALSE;
std::unique_lock<std::mutex> lock(global_lock);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_01948, VALIDATION_ERROR_UNDEFINED);
+ skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_30805601, VALIDATION_ERROR_UNDEFINED);
lock.unlock();
if (skip) {
return VK_ERROR_VALIDATION_FAILED_EXT;
@@ -3778,34 +3866,34 @@
const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines) {
bool skip = VK_FALSE;
std::unique_lock<std::mutex> lock(global_lock);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_00519, VALIDATION_ERROR_UNDEFINED);
+ skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_20805601, VALIDATION_ERROR_UNDEFINED);
if (pCreateInfos) {
for (uint32_t idx0 = 0; idx0 < createInfoCount; ++idx0) {
if (pCreateInfos[idx0].basePipelineHandle) {
skip |= ValidateObject(device, pCreateInfos[idx0].basePipelineHandle, kVulkanObjectTypePipeline, true,
- VALIDATION_ERROR_00529, VALIDATION_ERROR_00549);
+ VALIDATION_ERROR_096005a4, VALIDATION_ERROR_09600009);
}
if (pCreateInfos[idx0].layout) {
skip |= ValidateObject(device, pCreateInfos[idx0].layout, kVulkanObjectTypePipelineLayout, false,
- VALIDATION_ERROR_00546, VALIDATION_ERROR_00549);
+ VALIDATION_ERROR_0960be01, VALIDATION_ERROR_09600009);
}
if (pCreateInfos[idx0].pStages) {
for (uint32_t idx1 = 0; idx1 < pCreateInfos[idx0].stageCount; ++idx1) {
if (pCreateInfos[idx0].pStages[idx1].module) {
skip |= ValidateObject(device, pCreateInfos[idx0].pStages[idx1].module, kVulkanObjectTypeShaderModule,
- false, VALIDATION_ERROR_00515, VALIDATION_ERROR_UNDEFINED);
+ false, VALIDATION_ERROR_1060d201, VALIDATION_ERROR_UNDEFINED);
}
}
}
if (pCreateInfos[idx0].renderPass) {
skip |= ValidateObject(device, pCreateInfos[idx0].renderPass, kVulkanObjectTypeRenderPass, false,
- VALIDATION_ERROR_00547, VALIDATION_ERROR_00549);
+ VALIDATION_ERROR_0962ae01, VALIDATION_ERROR_09600009);
}
}
}
if (pipelineCache) {
- skip |= ValidateObject(device, pipelineCache, kVulkanObjectTypePipelineCache, true, VALIDATION_ERROR_00520,
- VALIDATION_ERROR_00525);
+ skip |= ValidateObject(device, pipelineCache, kVulkanObjectTypePipelineCache, true, VALIDATION_ERROR_20828001,
+ VALIDATION_ERROR_20828007);
}
lock.unlock();
if (skip) {
@@ -3831,26 +3919,26 @@
const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines) {
bool skip = VK_FALSE;
std::unique_lock<std::mutex> lock(global_lock);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_00486, VALIDATION_ERROR_UNDEFINED);
+ skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_1f205601, VALIDATION_ERROR_UNDEFINED);
if (pCreateInfos) {
for (uint32_t idx0 = 0; idx0 < createInfoCount; ++idx0) {
if (pCreateInfos[idx0].basePipelineHandle) {
skip |= ValidateObject(device, pCreateInfos[idx0].basePipelineHandle, kVulkanObjectTypePipeline, true,
- VALIDATION_ERROR_00496, VALIDATION_ERROR_00506);
+ VALIDATION_ERROR_03000572, VALIDATION_ERROR_03000009);
}
if (pCreateInfos[idx0].layout) {
skip |= ValidateObject(device, pCreateInfos[idx0].layout, kVulkanObjectTypePipelineLayout, false,
- VALIDATION_ERROR_00505, VALIDATION_ERROR_00506);
+ VALIDATION_ERROR_0300be01, VALIDATION_ERROR_03000009);
}
if (pCreateInfos[idx0].stage.module) {
skip |= ValidateObject(device, pCreateInfos[idx0].stage.module, kVulkanObjectTypeShaderModule, false,
- VALIDATION_ERROR_00515, VALIDATION_ERROR_UNDEFINED);
+ VALIDATION_ERROR_1060d201, VALIDATION_ERROR_UNDEFINED);
}
}
}
if (pipelineCache) {
- skip |= ValidateObject(device, pipelineCache, kVulkanObjectTypePipelineCache, true, VALIDATION_ERROR_00487,
- VALIDATION_ERROR_00492);
+ skip |= ValidateObject(device, pipelineCache, kVulkanObjectTypePipelineCache, true, VALIDATION_ERROR_1f228001,
+ VALIDATION_ERROR_1f228007);
}
lock.unlock();
if (skip) {
@@ -3878,7 +3966,7 @@
bool skip = false;
{
std::unique_lock<std::mutex> lock(global_lock);
- skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_01851,
+ skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_2b827a01,
VALIDATION_ERROR_UNDEFINED);
}
if (!skip) {
@@ -3894,7 +3982,7 @@
bool skip = false;
{
std::unique_lock<std::mutex> lock(global_lock);
- skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_01854,
+ skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_2b627a01,
VALIDATION_ERROR_UNDEFINED);
}
if (!skip) {
@@ -3910,7 +3998,7 @@
bool skip = false;
{
std::unique_lock<std::mutex> lock(global_lock);
- skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_01858,
+ skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_29c27a01,
VALIDATION_ERROR_UNDEFINED);
}
result = get_dispatch_table(ot_instance_table_map, physicalDevice)
@@ -3930,9 +4018,9 @@
bool skip = false;
{
std::unique_lock<std::mutex> lock(global_lock);
- skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_01861,
+ skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_29827a01,
VALIDATION_ERROR_UNDEFINED);
- skip |= ValidateObject(physicalDevice, display, kVulkanObjectTypeDisplayKHR, false, VALIDATION_ERROR_01862,
+ skip |= ValidateObject(physicalDevice, display, kVulkanObjectTypeDisplayKHR, false, VALIDATION_ERROR_29806001,
VALIDATION_ERROR_UNDEFINED);
}
result = get_dispatch_table(ot_instance_table_map, physicalDevice)
@@ -3948,9 +4036,9 @@
bool skip = false;
{
std::unique_lock<std::mutex> lock(global_lock);
- skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_01865,
+ skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_1fe27a01,
VALIDATION_ERROR_UNDEFINED);
- skip |= ValidateObject(physicalDevice, display, kVulkanObjectTypeDisplayKHR, false, VALIDATION_ERROR_01866,
+ skip |= ValidateObject(physicalDevice, display, kVulkanObjectTypeDisplayKHR, false, VALIDATION_ERROR_1fe06001,
VALIDATION_ERROR_UNDEFINED);
}
result = get_dispatch_table(ot_instance_table_map, physicalDevice)
@@ -3970,9 +4058,9 @@
bool skip = false;
{
std::unique_lock<std::mutex> lock(global_lock);
- skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_01875,
+ skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_29a27a01,
VALIDATION_ERROR_UNDEFINED);
- skip |= ValidateObject(physicalDevice, mode, kVulkanObjectTypeDisplayModeKHR, false, VALIDATION_ERROR_01876,
+ skip |= ValidateObject(physicalDevice, mode, kVulkanObjectTypeDisplayModeKHR, false, VALIDATION_ERROR_29a0ce01,
VALIDATION_ERROR_UNDEFINED);
}
result = get_dispatch_table(ot_instance_table_map, physicalDevice)
@@ -3986,10 +4074,10 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(instance, instance, kVulkanObjectTypeInstance, false, VALIDATION_ERROR_01878,
+ skip |= ValidateObject(instance, instance, kVulkanObjectTypeInstance, false, VALIDATION_ERROR_2000bc01,
VALIDATION_ERROR_UNDEFINED);
- skip |= ValidateObject(instance, pCreateInfo->displayMode, kVulkanObjectTypeDisplayModeKHR, false, VALIDATION_ERROR_01886,
- VALIDATION_ERROR_UNDEFINED);
+ skip |= ValidateObject(instance, pCreateInfo->displayMode, kVulkanObjectTypeDisplayModeKHR, false,
+ VALIDATION_ERROR_07806401, VALIDATION_ERROR_UNDEFINED);
}
if (skip) {
return VK_ERROR_VALIDATION_FAILED_EXT;
@@ -4575,7 +4663,7 @@
VKAPI_ATTR VkResult VKAPI_CALL DebugMarkerSetObjectTagEXT(VkDevice device, VkDebugMarkerObjectTagInfoEXT *pTagInfo) {
bool skip = VK_FALSE;
std::unique_lock<std::mutex> lock(global_lock);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_02007, VALIDATION_ERROR_UNDEFINED);
+ skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_23805601, VALIDATION_ERROR_UNDEFINED);
lock.unlock();
if (skip) {
return VK_ERROR_VALIDATION_FAILED_EXT;
@@ -4588,7 +4676,7 @@
VKAPI_ATTR VkResult VKAPI_CALL DebugMarkerSetObjectNameEXT(VkDevice device, VkDebugMarkerObjectNameInfoEXT *pNameInfo) {
bool skip = VK_FALSE;
std::unique_lock<std::mutex> lock(global_lock);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_01999, VALIDATION_ERROR_UNDEFINED);
+ skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_23605601, VALIDATION_ERROR_UNDEFINED);
lock.unlock();
if (skip) {
return VK_ERROR_VALIDATION_FAILED_EXT;
@@ -4601,7 +4689,7 @@
VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerBeginEXT(VkCommandBuffer commandBuffer, VkDebugMarkerMarkerInfoEXT *pMarkerInfo) {
bool skip = VK_FALSE;
std::unique_lock<std::mutex> lock(global_lock);
- skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_02014,
+ skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_19602401,
VALIDATION_ERROR_UNDEFINED);
lock.unlock();
layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
@@ -4613,7 +4701,7 @@
VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerEndEXT(VkCommandBuffer commandBuffer) {
bool skip = VK_FALSE;
std::unique_lock<std::mutex> lock(global_lock);
- skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_02022,
+ skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_19802401,
VALIDATION_ERROR_UNDEFINED);
lock.unlock();
layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
@@ -4625,7 +4713,7 @@
VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerInsertEXT(VkCommandBuffer commandBuffer, VkDebugMarkerMarkerInfoEXT *pMarkerInfo) {
bool skip = VK_FALSE;
std::unique_lock<std::mutex> lock(global_lock);
- skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_02025,
+ skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_19a02401,
VALIDATION_ERROR_UNDEFINED);
lock.unlock();
layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
@@ -4761,13 +4849,14 @@
uint32_t stride) {
bool skip = VK_FALSE;
std::unique_lock<std::mutex> lock(global_lock);
- skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_01771,
+ skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_1ac02401,
VALIDATION_ERROR_UNDEFINED);
- skip |= ValidateObject(commandBuffer, buffer, kVulkanObjectTypeBuffer, false, VALIDATION_ERROR_01772, VALIDATION_ERROR_01777);
skip |=
- ValidateObject(commandBuffer, countBuffer, kVulkanObjectTypeBuffer, false, VALIDATION_ERROR_01773, VALIDATION_ERROR_01777);
- skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeBuffer, false, VALIDATION_ERROR_01774,
- VALIDATION_ERROR_01777);
+ ValidateObject(commandBuffer, buffer, kVulkanObjectTypeBuffer, false, VALIDATION_ERROR_1ac01a01, VALIDATION_ERROR_1ac00009);
+ skip |= ValidateObject(commandBuffer, countBuffer, kVulkanObjectTypeBuffer, false, VALIDATION_ERROR_1ac03401,
+ VALIDATION_ERROR_1ac00009);
+ skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeBuffer, false, VALIDATION_ERROR_1ac02413,
+ VALIDATION_ERROR_1ac00009);
lock.unlock();
if (!skip) {
get_dispatch_table(ot_device_table_map, commandBuffer)
@@ -4780,13 +4869,14 @@
uint32_t maxDrawCount, uint32_t stride) {
bool skip = VK_FALSE;
std::unique_lock<std::mutex> lock(global_lock);
- skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_01783,
+ skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_1a802401,
VALIDATION_ERROR_UNDEFINED);
- skip |= ValidateObject(commandBuffer, buffer, kVulkanObjectTypeBuffer, false, VALIDATION_ERROR_01784, VALIDATION_ERROR_01789);
skip |=
- ValidateObject(commandBuffer, countBuffer, kVulkanObjectTypeBuffer, false, VALIDATION_ERROR_01785, VALIDATION_ERROR_01789);
- skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeBuffer, false, VALIDATION_ERROR_01786,
- VALIDATION_ERROR_01789);
+ ValidateObject(commandBuffer, buffer, kVulkanObjectTypeBuffer, false, VALIDATION_ERROR_1a801a01, VALIDATION_ERROR_1a800009);
+ skip |= ValidateObject(commandBuffer, countBuffer, kVulkanObjectTypeBuffer, false, VALIDATION_ERROR_1a803401,
+ VALIDATION_ERROR_1a800009);
+ skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeBuffer, false, VALIDATION_ERROR_1a802413,
+ VALIDATION_ERROR_1a800009);
lock.unlock();
if (!skip) {
get_dispatch_table(ot_device_table_map, commandBuffer)
@@ -4816,7 +4906,7 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_01980,
+ skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_2bc27a01,
VALIDATION_ERROR_UNDEFINED);
}
if (skip) {
@@ -4834,8 +4924,9 @@
VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE *pHandle) {
bool skip = VK_FALSE;
std::unique_lock<std::mutex> lock(global_lock);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_01725, VALIDATION_ERROR_UNDEFINED);
- skip |= ValidateObject(device, memory, kVulkanObjectTypeDeviceMemory, false, VALIDATION_ERROR_01726, VALIDATION_ERROR_01730);
+ skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_2b005601, VALIDATION_ERROR_UNDEFINED);
+ skip |=
+ ValidateObject(device, memory, kVulkanObjectTypeDeviceMemory, false, VALIDATION_ERROR_2b00c601, VALIDATION_ERROR_2b00c607);
lock.unlock();
if (skip) {
return VK_ERROR_VALIDATION_FAILED_EXT;
@@ -4980,8 +5071,9 @@
bool skip = false;
{
std::unique_lock<std::mutex> lock(global_lock);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_03181, VALIDATION_ERROR_UNDEFINED);
- skip |= ValidateObject(device, swapchain, kVulkanObjectTypeSwapchainKHR, false, VALIDATION_ERROR_03182,
+ skip |=
+ ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_2b405601, VALIDATION_ERROR_UNDEFINED);
+ skip |= ValidateObject(device, swapchain, kVulkanObjectTypeSwapchainKHR, false, VALIDATION_ERROR_2b42f001,
VALIDATION_ERROR_UNDEFINED);
}
@@ -4998,8 +5090,9 @@
bool skip = false;
{
std::unique_lock<std::mutex> lock(global_lock);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_03178, VALIDATION_ERROR_UNDEFINED);
- skip |= ValidateObject(device, swapchain, kVulkanObjectTypeSwapchainKHR, false, VALIDATION_ERROR_03179,
+ skip |=
+ ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_2fe05601, VALIDATION_ERROR_UNDEFINED);
+ skip |= ValidateObject(device, swapchain, kVulkanObjectTypeSwapchainKHR, false, VALIDATION_ERROR_2fe2f001,
VALIDATION_ERROR_UNDEFINED);
}
@@ -5033,8 +5126,9 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_03293, VALIDATION_ERROR_UNDEFINED);
- skip |= ValidateObject(device, swapchain, kVulkanObjectTypeSwapchainKHR, false, VALIDATION_ERROR_03294,
+ skip |=
+ ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_30a05601, VALIDATION_ERROR_UNDEFINED);
+ skip |= ValidateObject(device, swapchain, kVulkanObjectTypeSwapchainKHR, false, VALIDATION_ERROR_30a2f001,
VALIDATION_ERROR_UNDEFINED);
}
if (skip) {
@@ -5050,9 +5144,9 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_03283,
+ skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_2e427a01,
VALIDATION_ERROR_UNDEFINED);
- skip |= ValidateObject(physicalDevice, pSurfaceInfo->surface, kVulkanObjectTypeSurfaceKHR, false, VALIDATION_ERROR_03288,
+ skip |= ValidateObject(physicalDevice, pSurfaceInfo->surface, kVulkanObjectTypeSurfaceKHR, false, VALIDATION_ERROR_0ee2ec01,
VALIDATION_ERROR_UNDEFINED);
}
if (skip) {
@@ -5070,7 +5164,7 @@
bool skip = false;
{
std::lock_guard<std::mutex> lock(global_lock);
- skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_03289,
+ skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_2e827a01,
VALIDATION_ERROR_UNDEFINED);
}
if (skip) {