You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
5146 lines
268 KiB
5146 lines
268 KiB
// *** THIS FILE IS GENERATED - DO NOT EDIT ***
|
|
// See object_tracker_generator.py for modifications
|
|
|
|
|
|
/***************************************************************************
|
|
*
|
|
* Copyright (c) 2015-2019 The Khronos Group Inc.
|
|
* Copyright (c) 2015-2019 Valve Corporation
|
|
* Copyright (c) 2015-2019 LunarG, Inc.
|
|
* Copyright (c) 2015-2019 Google Inc.
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*
|
|
* Author: Mark Lobodzinski <mark@lunarg.com>
|
|
* Author: Dave Houlton <daveh@lunarg.com>
|
|
*
|
|
****************************************************************************/
|
|
|
|
|
|
#include "chassis.h"
|
|
#include "object_lifetime_validation.h"
|
|
|
|
|
|
|
|
// ObjectTracker undestroyed objects validation function
|
|
bool ObjectLifetimes::ReportUndestroyedObjects(VkDevice device, const std::string& error_code) {
|
|
bool skip = false;
|
|
skip |= DeviceReportUndestroyedObjects(device, kVulkanObjectTypeCommandBuffer, error_code);
|
|
skip |= DeviceReportUndestroyedObjects(device, kVulkanObjectTypeSemaphore, error_code);
|
|
skip |= DeviceReportUndestroyedObjects(device, kVulkanObjectTypeFence, error_code);
|
|
skip |= DeviceReportUndestroyedObjects(device, kVulkanObjectTypeDeviceMemory, error_code);
|
|
skip |= DeviceReportUndestroyedObjects(device, kVulkanObjectTypeBuffer, error_code);
|
|
skip |= DeviceReportUndestroyedObjects(device, kVulkanObjectTypeImage, error_code);
|
|
skip |= DeviceReportUndestroyedObjects(device, kVulkanObjectTypeEvent, error_code);
|
|
skip |= DeviceReportUndestroyedObjects(device, kVulkanObjectTypeQueryPool, error_code);
|
|
skip |= DeviceReportUndestroyedObjects(device, kVulkanObjectTypeBufferView, error_code);
|
|
skip |= DeviceReportUndestroyedObjects(device, kVulkanObjectTypeImageView, error_code);
|
|
skip |= DeviceReportUndestroyedObjects(device, kVulkanObjectTypeShaderModule, error_code);
|
|
skip |= DeviceReportUndestroyedObjects(device, kVulkanObjectTypePipelineCache, error_code);
|
|
skip |= DeviceReportUndestroyedObjects(device, kVulkanObjectTypePipelineLayout, error_code);
|
|
skip |= DeviceReportUndestroyedObjects(device, kVulkanObjectTypeRenderPass, error_code);
|
|
skip |= DeviceReportUndestroyedObjects(device, kVulkanObjectTypePipeline, error_code);
|
|
skip |= DeviceReportUndestroyedObjects(device, kVulkanObjectTypeDescriptorSetLayout, error_code);
|
|
skip |= DeviceReportUndestroyedObjects(device, kVulkanObjectTypeSampler, error_code);
|
|
skip |= DeviceReportUndestroyedObjects(device, kVulkanObjectTypeDescriptorPool, error_code);
|
|
skip |= DeviceReportUndestroyedObjects(device, kVulkanObjectTypeDescriptorSet, error_code);
|
|
skip |= DeviceReportUndestroyedObjects(device, kVulkanObjectTypeFramebuffer, error_code);
|
|
skip |= DeviceReportUndestroyedObjects(device, kVulkanObjectTypeCommandPool, error_code);
|
|
skip |= DeviceReportUndestroyedObjects(device, kVulkanObjectTypeSamplerYcbcrConversion, error_code);
|
|
skip |= DeviceReportUndestroyedObjects(device, kVulkanObjectTypeDescriptorUpdateTemplate, error_code);
|
|
skip |= DeviceReportUndestroyedObjects(device, kVulkanObjectTypeSurfaceKHR, error_code);
|
|
skip |= DeviceReportUndestroyedObjects(device, kVulkanObjectTypeSwapchainKHR, error_code);
|
|
skip |= DeviceReportUndestroyedObjects(device, kVulkanObjectTypeDisplayKHR, error_code);
|
|
skip |= DeviceReportUndestroyedObjects(device, kVulkanObjectTypeDisplayModeKHR, error_code);
|
|
skip |= DeviceReportUndestroyedObjects(device, kVulkanObjectTypeDebugReportCallbackEXT, error_code);
|
|
skip |= DeviceReportUndestroyedObjects(device, kVulkanObjectTypeObjectTableNVX, error_code);
|
|
skip |= DeviceReportUndestroyedObjects(device, kVulkanObjectTypeIndirectCommandsLayoutNVX, error_code);
|
|
skip |= DeviceReportUndestroyedObjects(device, kVulkanObjectTypeDebugUtilsMessengerEXT, error_code);
|
|
skip |= DeviceReportUndestroyedObjects(device, kVulkanObjectTypeValidationCacheEXT, error_code);
|
|
skip |= DeviceReportUndestroyedObjects(device, kVulkanObjectTypeAccelerationStructureNV, error_code);
|
|
skip |= DeviceReportUndestroyedObjects(device, kVulkanObjectTypePerformanceConfigurationINTEL, error_code);
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::DestroyUndestroyedObjects(VkDevice device) {
|
|
DeviceDestroyUndestroyedObjects(device, kVulkanObjectTypeCommandBuffer);
|
|
DeviceDestroyUndestroyedObjects(device, kVulkanObjectTypeSemaphore);
|
|
DeviceDestroyUndestroyedObjects(device, kVulkanObjectTypeFence);
|
|
DeviceDestroyUndestroyedObjects(device, kVulkanObjectTypeDeviceMemory);
|
|
DeviceDestroyUndestroyedObjects(device, kVulkanObjectTypeBuffer);
|
|
DeviceDestroyUndestroyedObjects(device, kVulkanObjectTypeImage);
|
|
DeviceDestroyUndestroyedObjects(device, kVulkanObjectTypeEvent);
|
|
DeviceDestroyUndestroyedObjects(device, kVulkanObjectTypeQueryPool);
|
|
DeviceDestroyUndestroyedObjects(device, kVulkanObjectTypeBufferView);
|
|
DeviceDestroyUndestroyedObjects(device, kVulkanObjectTypeImageView);
|
|
DeviceDestroyUndestroyedObjects(device, kVulkanObjectTypeShaderModule);
|
|
DeviceDestroyUndestroyedObjects(device, kVulkanObjectTypePipelineCache);
|
|
DeviceDestroyUndestroyedObjects(device, kVulkanObjectTypePipelineLayout);
|
|
DeviceDestroyUndestroyedObjects(device, kVulkanObjectTypeRenderPass);
|
|
DeviceDestroyUndestroyedObjects(device, kVulkanObjectTypePipeline);
|
|
DeviceDestroyUndestroyedObjects(device, kVulkanObjectTypeDescriptorSetLayout);
|
|
DeviceDestroyUndestroyedObjects(device, kVulkanObjectTypeSampler);
|
|
DeviceDestroyUndestroyedObjects(device, kVulkanObjectTypeDescriptorPool);
|
|
DeviceDestroyUndestroyedObjects(device, kVulkanObjectTypeDescriptorSet);
|
|
DeviceDestroyUndestroyedObjects(device, kVulkanObjectTypeFramebuffer);
|
|
DeviceDestroyUndestroyedObjects(device, kVulkanObjectTypeCommandPool);
|
|
DeviceDestroyUndestroyedObjects(device, kVulkanObjectTypeSamplerYcbcrConversion);
|
|
DeviceDestroyUndestroyedObjects(device, kVulkanObjectTypeDescriptorUpdateTemplate);
|
|
DeviceDestroyUndestroyedObjects(device, kVulkanObjectTypeSurfaceKHR);
|
|
DeviceDestroyUndestroyedObjects(device, kVulkanObjectTypeSwapchainKHR);
|
|
DeviceDestroyUndestroyedObjects(device, kVulkanObjectTypeDisplayKHR);
|
|
DeviceDestroyUndestroyedObjects(device, kVulkanObjectTypeDisplayModeKHR);
|
|
DeviceDestroyUndestroyedObjects(device, kVulkanObjectTypeDebugReportCallbackEXT);
|
|
DeviceDestroyUndestroyedObjects(device, kVulkanObjectTypeObjectTableNVX);
|
|
DeviceDestroyUndestroyedObjects(device, kVulkanObjectTypeIndirectCommandsLayoutNVX);
|
|
DeviceDestroyUndestroyedObjects(device, kVulkanObjectTypeDebugUtilsMessengerEXT);
|
|
DeviceDestroyUndestroyedObjects(device, kVulkanObjectTypeValidationCacheEXT);
|
|
DeviceDestroyUndestroyedObjects(device, kVulkanObjectTypeAccelerationStructureNV);
|
|
DeviceDestroyUndestroyedObjects(device, kVulkanObjectTypePerformanceConfigurationINTEL);
|
|
}
|
|
|
|
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceFeatures(
|
|
VkPhysicalDevice physicalDevice,
|
|
VkPhysicalDeviceFeatures* pFeatures) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceFeatures-physicalDevice-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceFormatProperties(
|
|
VkPhysicalDevice physicalDevice,
|
|
VkFormat format,
|
|
VkFormatProperties* pFormatProperties) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceFormatProperties-physicalDevice-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceImageFormatProperties(
|
|
VkPhysicalDevice physicalDevice,
|
|
VkFormat format,
|
|
VkImageType type,
|
|
VkImageTiling tiling,
|
|
VkImageUsageFlags usage,
|
|
VkImageCreateFlags flags,
|
|
VkImageFormatProperties* pImageFormatProperties) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceImageFormatProperties-physicalDevice-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceProperties(
|
|
VkPhysicalDevice physicalDevice,
|
|
VkPhysicalDeviceProperties* pProperties) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceProperties-physicalDevice-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceMemoryProperties(
|
|
VkPhysicalDevice physicalDevice,
|
|
VkPhysicalDeviceMemoryProperties* pMemoryProperties) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceMemoryProperties-physicalDevice-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetInstanceProcAddr(
|
|
VkInstance instance,
|
|
const char* pName) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(instance, instance, kVulkanObjectTypeInstance, true, "VUID-vkGetInstanceProcAddr-instance-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetDeviceProcAddr(
|
|
VkDevice device,
|
|
const char* pName) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkGetDeviceProcAddr-device-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCreateDevice(
|
|
VkPhysicalDevice physicalDevice,
|
|
const VkDeviceCreateInfo* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkDevice* pDevice) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkCreateDevice-physicalDevice-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PostCallRecordCreateDevice(
|
|
VkPhysicalDevice physicalDevice,
|
|
const VkDeviceCreateInfo* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkDevice* pDevice,
|
|
VkResult result) {
|
|
if (result != VK_SUCCESS) return;
|
|
CreateObject(physicalDevice, *pDevice, kVulkanObjectTypeDevice, pAllocator);
|
|
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateEnumerateDeviceExtensionProperties(
|
|
VkPhysicalDevice physicalDevice,
|
|
const char* pLayerName,
|
|
uint32_t* pPropertyCount,
|
|
VkExtensionProperties* pProperties) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkEnumerateDeviceExtensionProperties-physicalDevice-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateEnumerateDeviceLayerProperties(
|
|
VkPhysicalDevice physicalDevice,
|
|
uint32_t* pPropertyCount,
|
|
VkLayerProperties* pProperties) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkEnumerateDeviceLayerProperties-physicalDevice-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateQueueSubmit(
|
|
VkQueue queue,
|
|
uint32_t submitCount,
|
|
const VkSubmitInfo* pSubmits,
|
|
VkFence fence) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(queue, queue, kVulkanObjectTypeQueue, false, "VUID-vkQueueSubmit-queue-parameter", "VUID-vkQueueSubmit-commonparent");
|
|
if (pSubmits) {
|
|
for (uint32_t index0 = 0; index0 < submitCount; ++index0) {
|
|
if (pSubmits[index0].pWaitSemaphores) {
|
|
for (uint32_t index1 = 0; index1 < pSubmits[index0].waitSemaphoreCount; ++index1) {
|
|
skip |= ValidateObject(queue, pSubmits[index0].pWaitSemaphores[index1], kVulkanObjectTypeSemaphore, false, "VUID-VkSubmitInfo-pWaitSemaphores-parameter", "VUID-VkSubmitInfo-commonparent");
|
|
}
|
|
}
|
|
if (pSubmits[index0].pCommandBuffers) {
|
|
for (uint32_t index1 = 0; index1 < pSubmits[index0].commandBufferCount; ++index1) {
|
|
skip |= ValidateObject(queue, pSubmits[index0].pCommandBuffers[index1], kVulkanObjectTypeCommandBuffer, false, "VUID-VkSubmitInfo-pCommandBuffers-parameter", "VUID-VkSubmitInfo-commonparent");
|
|
}
|
|
}
|
|
if (pSubmits[index0].pSignalSemaphores) {
|
|
for (uint32_t index1 = 0; index1 < pSubmits[index0].signalSemaphoreCount; ++index1) {
|
|
skip |= ValidateObject(queue, pSubmits[index0].pSignalSemaphores[index1], kVulkanObjectTypeSemaphore, false, "VUID-VkSubmitInfo-pSignalSemaphores-parameter", "VUID-VkSubmitInfo-commonparent");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
skip |= ValidateObject(queue, fence, kVulkanObjectTypeFence, true, "VUID-vkQueueSubmit-fence-parameter", "VUID-vkQueueSubmit-commonparent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateQueueWaitIdle(
|
|
VkQueue queue) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(queue, queue, kVulkanObjectTypeQueue, false, "VUID-vkQueueWaitIdle-queue-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateDeviceWaitIdle(
|
|
VkDevice device) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkDeviceWaitIdle-device-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateAllocateMemory(
|
|
VkDevice device,
|
|
const VkMemoryAllocateInfo* pAllocateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkDeviceMemory* pMemory) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkAllocateMemory-device-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PostCallRecordAllocateMemory(
|
|
VkDevice device,
|
|
const VkMemoryAllocateInfo* pAllocateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkDeviceMemory* pMemory,
|
|
VkResult result) {
|
|
if (result != VK_SUCCESS) return;
|
|
CreateObject(device, *pMemory, kVulkanObjectTypeDeviceMemory, pAllocator);
|
|
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateFreeMemory(
|
|
VkDevice device,
|
|
VkDeviceMemory memory,
|
|
const VkAllocationCallbacks* pAllocator) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkFreeMemory-device-parameter", kVUIDUndefined);
|
|
skip |= ValidateObject(device, memory, kVulkanObjectTypeDeviceMemory, true, "VUID-vkFreeMemory-memory-parameter", "VUID-vkFreeMemory-memory-parent");
|
|
skip |= ValidateDestroyObject(device, memory, kVulkanObjectTypeDeviceMemory, pAllocator, kVUIDUndefined, kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PreCallRecordFreeMemory(
|
|
VkDevice device,
|
|
VkDeviceMemory memory,
|
|
const VkAllocationCallbacks* pAllocator) {
|
|
RecordDestroyObject(device, memory, kVulkanObjectTypeDeviceMemory);
|
|
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateMapMemory(
|
|
VkDevice device,
|
|
VkDeviceMemory memory,
|
|
VkDeviceSize offset,
|
|
VkDeviceSize size,
|
|
VkMemoryMapFlags flags,
|
|
void** ppData) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkMapMemory-device-parameter", kVUIDUndefined);
|
|
skip |= ValidateObject(device, memory, kVulkanObjectTypeDeviceMemory, false, "VUID-vkMapMemory-memory-parameter", "VUID-vkMapMemory-memory-parent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateUnmapMemory(
|
|
VkDevice device,
|
|
VkDeviceMemory memory) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkUnmapMemory-device-parameter", kVUIDUndefined);
|
|
skip |= ValidateObject(device, memory, kVulkanObjectTypeDeviceMemory, false, "VUID-vkUnmapMemory-memory-parameter", "VUID-vkUnmapMemory-memory-parent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateFlushMappedMemoryRanges(
|
|
VkDevice device,
|
|
uint32_t memoryRangeCount,
|
|
const VkMappedMemoryRange* pMemoryRanges) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkFlushMappedMemoryRanges-device-parameter", kVUIDUndefined);
|
|
if (pMemoryRanges) {
|
|
for (uint32_t index0 = 0; index0 < memoryRangeCount; ++index0) {
|
|
skip |= ValidateObject(device, pMemoryRanges[index0].memory, kVulkanObjectTypeDeviceMemory, false, "VUID-VkMappedMemoryRange-memory-parameter", kVUIDUndefined);
|
|
}
|
|
}
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateInvalidateMappedMemoryRanges(
|
|
VkDevice device,
|
|
uint32_t memoryRangeCount,
|
|
const VkMappedMemoryRange* pMemoryRanges) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkInvalidateMappedMemoryRanges-device-parameter", kVUIDUndefined);
|
|
if (pMemoryRanges) {
|
|
for (uint32_t index0 = 0; index0 < memoryRangeCount; ++index0) {
|
|
skip |= ValidateObject(device, pMemoryRanges[index0].memory, kVulkanObjectTypeDeviceMemory, false, "VUID-VkMappedMemoryRange-memory-parameter", kVUIDUndefined);
|
|
}
|
|
}
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetDeviceMemoryCommitment(
|
|
VkDevice device,
|
|
VkDeviceMemory memory,
|
|
VkDeviceSize* pCommittedMemoryInBytes) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkGetDeviceMemoryCommitment-device-parameter", kVUIDUndefined);
|
|
skip |= ValidateObject(device, memory, kVulkanObjectTypeDeviceMemory, false, "VUID-vkGetDeviceMemoryCommitment-memory-parameter", "VUID-vkGetDeviceMemoryCommitment-memory-parent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateBindBufferMemory(
|
|
VkDevice device,
|
|
VkBuffer buffer,
|
|
VkDeviceMemory memory,
|
|
VkDeviceSize memoryOffset) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkBindBufferMemory-device-parameter", kVUIDUndefined);
|
|
skip |= ValidateObject(device, buffer, kVulkanObjectTypeBuffer, false, "VUID-vkBindBufferMemory-buffer-parameter", "VUID-vkBindBufferMemory-buffer-parent");
|
|
skip |= ValidateObject(device, memory, kVulkanObjectTypeDeviceMemory, false, "VUID-vkBindBufferMemory-memory-parameter", "VUID-vkBindBufferMemory-memory-parent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateBindImageMemory(
|
|
VkDevice device,
|
|
VkImage image,
|
|
VkDeviceMemory memory,
|
|
VkDeviceSize memoryOffset) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkBindImageMemory-device-parameter", kVUIDUndefined);
|
|
skip |= ValidateObject(device, image, kVulkanObjectTypeImage, false, "VUID-vkBindImageMemory-image-parameter", "VUID-vkBindImageMemory-image-parent");
|
|
skip |= ValidateObject(device, memory, kVulkanObjectTypeDeviceMemory, false, "VUID-vkBindImageMemory-memory-parameter", "VUID-vkBindImageMemory-memory-parent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetBufferMemoryRequirements(
|
|
VkDevice device,
|
|
VkBuffer buffer,
|
|
VkMemoryRequirements* pMemoryRequirements) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkGetBufferMemoryRequirements-device-parameter", kVUIDUndefined);
|
|
skip |= ValidateObject(device, buffer, kVulkanObjectTypeBuffer, false, "VUID-vkGetBufferMemoryRequirements-buffer-parameter", "VUID-vkGetBufferMemoryRequirements-buffer-parent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetImageMemoryRequirements(
|
|
VkDevice device,
|
|
VkImage image,
|
|
VkMemoryRequirements* pMemoryRequirements) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkGetImageMemoryRequirements-device-parameter", kVUIDUndefined);
|
|
skip |= ValidateObject(device, image, kVulkanObjectTypeImage, false, "VUID-vkGetImageMemoryRequirements-image-parameter", "VUID-vkGetImageMemoryRequirements-image-parent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetImageSparseMemoryRequirements(
|
|
VkDevice device,
|
|
VkImage image,
|
|
uint32_t* pSparseMemoryRequirementCount,
|
|
VkSparseImageMemoryRequirements* pSparseMemoryRequirements) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkGetImageSparseMemoryRequirements-device-parameter", kVUIDUndefined);
|
|
skip |= ValidateObject(device, image, kVulkanObjectTypeImage, false, "VUID-vkGetImageSparseMemoryRequirements-image-parameter", "VUID-vkGetImageSparseMemoryRequirements-image-parent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceSparseImageFormatProperties(
|
|
VkPhysicalDevice physicalDevice,
|
|
VkFormat format,
|
|
VkImageType type,
|
|
VkSampleCountFlagBits samples,
|
|
VkImageUsageFlags usage,
|
|
VkImageTiling tiling,
|
|
uint32_t* pPropertyCount,
|
|
VkSparseImageFormatProperties* pProperties) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceSparseImageFormatProperties-physicalDevice-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateQueueBindSparse(
|
|
VkQueue queue,
|
|
uint32_t bindInfoCount,
|
|
const VkBindSparseInfo* pBindInfo,
|
|
VkFence fence) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(queue, queue, kVulkanObjectTypeQueue, false, "VUID-vkQueueBindSparse-queue-parameter", "VUID-vkQueueBindSparse-commonparent");
|
|
if (pBindInfo) {
|
|
for (uint32_t index0 = 0; index0 < bindInfoCount; ++index0) {
|
|
if (pBindInfo[index0].pWaitSemaphores) {
|
|
for (uint32_t index1 = 0; index1 < pBindInfo[index0].waitSemaphoreCount; ++index1) {
|
|
skip |= ValidateObject(queue, pBindInfo[index0].pWaitSemaphores[index1], kVulkanObjectTypeSemaphore, false, "VUID-VkBindSparseInfo-pWaitSemaphores-parameter", "VUID-VkBindSparseInfo-commonparent");
|
|
}
|
|
}
|
|
if (pBindInfo[index0].pBufferBinds) {
|
|
for (uint32_t index1 = 0; index1 < pBindInfo[index0].bufferBindCount; ++index1) {
|
|
skip |= ValidateObject(queue, pBindInfo[index0].pBufferBinds[index1].buffer, kVulkanObjectTypeBuffer, false, "VUID-VkSparseBufferMemoryBindInfo-buffer-parameter", kVUIDUndefined);
|
|
if (pBindInfo[index0].pBufferBinds[index1].pBinds) {
|
|
for (uint32_t index2 = 0; index2 < pBindInfo[index0].pBufferBinds[index1].bindCount; ++index2) {
|
|
skip |= ValidateObject(queue, pBindInfo[index0].pBufferBinds[index1].pBinds[index2].memory, kVulkanObjectTypeDeviceMemory, true, "VUID-VkSparseMemoryBind-memory-parameter", kVUIDUndefined);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (pBindInfo[index0].pImageOpaqueBinds) {
|
|
for (uint32_t index1 = 0; index1 < pBindInfo[index0].imageOpaqueBindCount; ++index1) {
|
|
skip |= ValidateObject(queue, pBindInfo[index0].pImageOpaqueBinds[index1].image, kVulkanObjectTypeImage, false, "VUID-VkSparseImageOpaqueMemoryBindInfo-image-parameter", kVUIDUndefined);
|
|
if (pBindInfo[index0].pImageOpaqueBinds[index1].pBinds) {
|
|
for (uint32_t index2 = 0; index2 < pBindInfo[index0].pImageOpaqueBinds[index1].bindCount; ++index2) {
|
|
skip |= ValidateObject(queue, pBindInfo[index0].pImageOpaqueBinds[index1].pBinds[index2].memory, kVulkanObjectTypeDeviceMemory, true, "VUID-VkSparseMemoryBind-memory-parameter", kVUIDUndefined);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (pBindInfo[index0].pImageBinds) {
|
|
for (uint32_t index1 = 0; index1 < pBindInfo[index0].imageBindCount; ++index1) {
|
|
skip |= ValidateObject(queue, pBindInfo[index0].pImageBinds[index1].image, kVulkanObjectTypeImage, false, "VUID-VkSparseImageMemoryBindInfo-image-parameter", kVUIDUndefined);
|
|
if (pBindInfo[index0].pImageBinds[index1].pBinds) {
|
|
for (uint32_t index2 = 0; index2 < pBindInfo[index0].pImageBinds[index1].bindCount; ++index2) {
|
|
skip |= ValidateObject(queue, pBindInfo[index0].pImageBinds[index1].pBinds[index2].memory, kVulkanObjectTypeDeviceMemory, true, "VUID-VkSparseImageMemoryBind-memory-parameter", kVUIDUndefined);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (pBindInfo[index0].pSignalSemaphores) {
|
|
for (uint32_t index1 = 0; index1 < pBindInfo[index0].signalSemaphoreCount; ++index1) {
|
|
skip |= ValidateObject(queue, pBindInfo[index0].pSignalSemaphores[index1], kVulkanObjectTypeSemaphore, false, "VUID-VkBindSparseInfo-pSignalSemaphores-parameter", "VUID-VkBindSparseInfo-commonparent");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
skip |= ValidateObject(queue, fence, kVulkanObjectTypeFence, true, "VUID-vkQueueBindSparse-fence-parameter", "VUID-vkQueueBindSparse-commonparent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCreateFence(
|
|
VkDevice device,
|
|
const VkFenceCreateInfo* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkFence* pFence) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkCreateFence-device-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PostCallRecordCreateFence(
|
|
VkDevice device,
|
|
const VkFenceCreateInfo* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkFence* pFence,
|
|
VkResult result) {
|
|
if (result != VK_SUCCESS) return;
|
|
CreateObject(device, *pFence, kVulkanObjectTypeFence, pAllocator);
|
|
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateDestroyFence(
|
|
VkDevice device,
|
|
VkFence fence,
|
|
const VkAllocationCallbacks* pAllocator) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkDestroyFence-device-parameter", kVUIDUndefined);
|
|
skip |= ValidateObject(device, fence, kVulkanObjectTypeFence, true, "VUID-vkDestroyFence-fence-parameter", "VUID-vkDestroyFence-fence-parent");
|
|
skip |= ValidateDestroyObject(device, fence, kVulkanObjectTypeFence, pAllocator, "VUID-vkDestroyFence-fence-01121", "VUID-vkDestroyFence-fence-01122");
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PreCallRecordDestroyFence(
|
|
VkDevice device,
|
|
VkFence fence,
|
|
const VkAllocationCallbacks* pAllocator) {
|
|
RecordDestroyObject(device, fence, kVulkanObjectTypeFence);
|
|
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateResetFences(
|
|
VkDevice device,
|
|
uint32_t fenceCount,
|
|
const VkFence* pFences) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkResetFences-device-parameter", kVUIDUndefined);
|
|
if (pFences) {
|
|
for (uint32_t index0 = 0; index0 < fenceCount; ++index0) {
|
|
skip |= ValidateObject(device, pFences[index0], kVulkanObjectTypeFence, false, "VUID-vkResetFences-pFences-parameter", "VUID-vkResetFences-pFences-parent");
|
|
}
|
|
}
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetFenceStatus(
|
|
VkDevice device,
|
|
VkFence fence) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkGetFenceStatus-device-parameter", kVUIDUndefined);
|
|
skip |= ValidateObject(device, fence, kVulkanObjectTypeFence, false, "VUID-vkGetFenceStatus-fence-parameter", "VUID-vkGetFenceStatus-fence-parent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateWaitForFences(
|
|
VkDevice device,
|
|
uint32_t fenceCount,
|
|
const VkFence* pFences,
|
|
VkBool32 waitAll,
|
|
uint64_t timeout) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkWaitForFences-device-parameter", kVUIDUndefined);
|
|
if (pFences) {
|
|
for (uint32_t index0 = 0; index0 < fenceCount; ++index0) {
|
|
skip |= ValidateObject(device, pFences[index0], kVulkanObjectTypeFence, false, "VUID-vkWaitForFences-pFences-parameter", "VUID-vkWaitForFences-pFences-parent");
|
|
}
|
|
}
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCreateSemaphore(
|
|
VkDevice device,
|
|
const VkSemaphoreCreateInfo* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkSemaphore* pSemaphore) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkCreateSemaphore-device-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PostCallRecordCreateSemaphore(
|
|
VkDevice device,
|
|
const VkSemaphoreCreateInfo* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkSemaphore* pSemaphore,
|
|
VkResult result) {
|
|
if (result != VK_SUCCESS) return;
|
|
CreateObject(device, *pSemaphore, kVulkanObjectTypeSemaphore, pAllocator);
|
|
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateDestroySemaphore(
|
|
VkDevice device,
|
|
VkSemaphore semaphore,
|
|
const VkAllocationCallbacks* pAllocator) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkDestroySemaphore-device-parameter", kVUIDUndefined);
|
|
skip |= ValidateObject(device, semaphore, kVulkanObjectTypeSemaphore, true, "VUID-vkDestroySemaphore-semaphore-parameter", "VUID-vkDestroySemaphore-semaphore-parent");
|
|
skip |= ValidateDestroyObject(device, semaphore, kVulkanObjectTypeSemaphore, pAllocator, "VUID-vkDestroySemaphore-semaphore-01138", "VUID-vkDestroySemaphore-semaphore-01139");
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PreCallRecordDestroySemaphore(
|
|
VkDevice device,
|
|
VkSemaphore semaphore,
|
|
const VkAllocationCallbacks* pAllocator) {
|
|
RecordDestroyObject(device, semaphore, kVulkanObjectTypeSemaphore);
|
|
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCreateEvent(
|
|
VkDevice device,
|
|
const VkEventCreateInfo* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkEvent* pEvent) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkCreateEvent-device-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PostCallRecordCreateEvent(
|
|
VkDevice device,
|
|
const VkEventCreateInfo* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkEvent* pEvent,
|
|
VkResult result) {
|
|
if (result != VK_SUCCESS) return;
|
|
CreateObject(device, *pEvent, kVulkanObjectTypeEvent, pAllocator);
|
|
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateDestroyEvent(
|
|
VkDevice device,
|
|
VkEvent event,
|
|
const VkAllocationCallbacks* pAllocator) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkDestroyEvent-device-parameter", kVUIDUndefined);
|
|
skip |= ValidateObject(device, event, kVulkanObjectTypeEvent, true, "VUID-vkDestroyEvent-event-parameter", "VUID-vkDestroyEvent-event-parent");
|
|
skip |= ValidateDestroyObject(device, event, kVulkanObjectTypeEvent, pAllocator, "VUID-vkDestroyEvent-event-01146", "VUID-vkDestroyEvent-event-01147");
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PreCallRecordDestroyEvent(
|
|
VkDevice device,
|
|
VkEvent event,
|
|
const VkAllocationCallbacks* pAllocator) {
|
|
RecordDestroyObject(device, event, kVulkanObjectTypeEvent);
|
|
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetEventStatus(
|
|
VkDevice device,
|
|
VkEvent event) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkGetEventStatus-device-parameter", kVUIDUndefined);
|
|
skip |= ValidateObject(device, event, kVulkanObjectTypeEvent, false, "VUID-vkGetEventStatus-event-parameter", "VUID-vkGetEventStatus-event-parent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateSetEvent(
|
|
VkDevice device,
|
|
VkEvent event) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkSetEvent-device-parameter", kVUIDUndefined);
|
|
skip |= ValidateObject(device, event, kVulkanObjectTypeEvent, false, "VUID-vkSetEvent-event-parameter", "VUID-vkSetEvent-event-parent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateResetEvent(
|
|
VkDevice device,
|
|
VkEvent event) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkResetEvent-device-parameter", kVUIDUndefined);
|
|
skip |= ValidateObject(device, event, kVulkanObjectTypeEvent, false, "VUID-vkResetEvent-event-parameter", "VUID-vkResetEvent-event-parent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCreateQueryPool(
|
|
VkDevice device,
|
|
const VkQueryPoolCreateInfo* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkQueryPool* pQueryPool) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkCreateQueryPool-device-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PostCallRecordCreateQueryPool(
|
|
VkDevice device,
|
|
const VkQueryPoolCreateInfo* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkQueryPool* pQueryPool,
|
|
VkResult result) {
|
|
if (result != VK_SUCCESS) return;
|
|
CreateObject(device, *pQueryPool, kVulkanObjectTypeQueryPool, pAllocator);
|
|
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateDestroyQueryPool(
|
|
VkDevice device,
|
|
VkQueryPool queryPool,
|
|
const VkAllocationCallbacks* pAllocator) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkDestroyQueryPool-device-parameter", kVUIDUndefined);
|
|
skip |= ValidateObject(device, queryPool, kVulkanObjectTypeQueryPool, true, "VUID-vkDestroyQueryPool-queryPool-parameter", "VUID-vkDestroyQueryPool-queryPool-parent");
|
|
skip |= ValidateDestroyObject(device, queryPool, kVulkanObjectTypeQueryPool, pAllocator, "VUID-vkDestroyQueryPool-queryPool-00794", "VUID-vkDestroyQueryPool-queryPool-00795");
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PreCallRecordDestroyQueryPool(
|
|
VkDevice device,
|
|
VkQueryPool queryPool,
|
|
const VkAllocationCallbacks* pAllocator) {
|
|
RecordDestroyObject(device, queryPool, kVulkanObjectTypeQueryPool);
|
|
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetQueryPoolResults(
|
|
VkDevice device,
|
|
VkQueryPool queryPool,
|
|
uint32_t firstQuery,
|
|
uint32_t queryCount,
|
|
size_t dataSize,
|
|
void* pData,
|
|
VkDeviceSize stride,
|
|
VkQueryResultFlags flags) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkGetQueryPoolResults-device-parameter", kVUIDUndefined);
|
|
skip |= ValidateObject(device, queryPool, kVulkanObjectTypeQueryPool, false, "VUID-vkGetQueryPoolResults-queryPool-parameter", "VUID-vkGetQueryPoolResults-queryPool-parent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCreateBuffer(
|
|
VkDevice device,
|
|
const VkBufferCreateInfo* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkBuffer* pBuffer) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkCreateBuffer-device-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PostCallRecordCreateBuffer(
|
|
VkDevice device,
|
|
const VkBufferCreateInfo* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkBuffer* pBuffer,
|
|
VkResult result) {
|
|
if (result != VK_SUCCESS) return;
|
|
CreateObject(device, *pBuffer, kVulkanObjectTypeBuffer, pAllocator);
|
|
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateDestroyBuffer(
|
|
VkDevice device,
|
|
VkBuffer buffer,
|
|
const VkAllocationCallbacks* pAllocator) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkDestroyBuffer-device-parameter", kVUIDUndefined);
|
|
skip |= ValidateObject(device, buffer, kVulkanObjectTypeBuffer, true, "VUID-vkDestroyBuffer-buffer-parameter", "VUID-vkDestroyBuffer-buffer-parent");
|
|
skip |= ValidateDestroyObject(device, buffer, kVulkanObjectTypeBuffer, pAllocator, "VUID-vkDestroyBuffer-buffer-00923", "VUID-vkDestroyBuffer-buffer-00924");
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PreCallRecordDestroyBuffer(
|
|
VkDevice device,
|
|
VkBuffer buffer,
|
|
const VkAllocationCallbacks* pAllocator) {
|
|
RecordDestroyObject(device, buffer, kVulkanObjectTypeBuffer);
|
|
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCreateBufferView(
|
|
VkDevice device,
|
|
const VkBufferViewCreateInfo* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkBufferView* pView) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkCreateBufferView-device-parameter", kVUIDUndefined);
|
|
if (pCreateInfo) {
|
|
skip |= ValidateObject(device, pCreateInfo->buffer, kVulkanObjectTypeBuffer, false, "VUID-VkBufferViewCreateInfo-buffer-parameter", kVUIDUndefined);
|
|
}
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PostCallRecordCreateBufferView(
|
|
VkDevice device,
|
|
const VkBufferViewCreateInfo* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkBufferView* pView,
|
|
VkResult result) {
|
|
if (result != VK_SUCCESS) return;
|
|
CreateObject(device, *pView, kVulkanObjectTypeBufferView, pAllocator);
|
|
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateDestroyBufferView(
|
|
VkDevice device,
|
|
VkBufferView bufferView,
|
|
const VkAllocationCallbacks* pAllocator) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkDestroyBufferView-device-parameter", kVUIDUndefined);
|
|
skip |= ValidateObject(device, bufferView, kVulkanObjectTypeBufferView, true, "VUID-vkDestroyBufferView-bufferView-parameter", "VUID-vkDestroyBufferView-bufferView-parent");
|
|
skip |= ValidateDestroyObject(device, bufferView, kVulkanObjectTypeBufferView, pAllocator, "VUID-vkDestroyBufferView-bufferView-00937", "VUID-vkDestroyBufferView-bufferView-00938");
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PreCallRecordDestroyBufferView(
|
|
VkDevice device,
|
|
VkBufferView bufferView,
|
|
const VkAllocationCallbacks* pAllocator) {
|
|
RecordDestroyObject(device, bufferView, kVulkanObjectTypeBufferView);
|
|
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCreateImage(
|
|
VkDevice device,
|
|
const VkImageCreateInfo* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkImage* pImage) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkCreateImage-device-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PostCallRecordCreateImage(
|
|
VkDevice device,
|
|
const VkImageCreateInfo* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkImage* pImage,
|
|
VkResult result) {
|
|
if (result != VK_SUCCESS) return;
|
|
CreateObject(device, *pImage, kVulkanObjectTypeImage, pAllocator);
|
|
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateDestroyImage(
|
|
VkDevice device,
|
|
VkImage image,
|
|
const VkAllocationCallbacks* pAllocator) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkDestroyImage-device-parameter", kVUIDUndefined);
|
|
skip |= ValidateObject(device, image, kVulkanObjectTypeImage, true, "VUID-vkDestroyImage-image-parameter", "VUID-vkDestroyImage-image-parent");
|
|
skip |= ValidateDestroyObject(device, image, kVulkanObjectTypeImage, pAllocator, "VUID-vkDestroyImage-image-01001", "VUID-vkDestroyImage-image-01002");
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PreCallRecordDestroyImage(
|
|
VkDevice device,
|
|
VkImage image,
|
|
const VkAllocationCallbacks* pAllocator) {
|
|
RecordDestroyObject(device, image, kVulkanObjectTypeImage);
|
|
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetImageSubresourceLayout(
|
|
VkDevice device,
|
|
VkImage image,
|
|
const VkImageSubresource* pSubresource,
|
|
VkSubresourceLayout* pLayout) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkGetImageSubresourceLayout-device-parameter", kVUIDUndefined);
|
|
skip |= ValidateObject(device, image, kVulkanObjectTypeImage, false, "VUID-vkGetImageSubresourceLayout-image-parameter", "VUID-vkGetImageSubresourceLayout-image-parent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCreateImageView(
|
|
VkDevice device,
|
|
const VkImageViewCreateInfo* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkImageView* pView) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkCreateImageView-device-parameter", kVUIDUndefined);
|
|
if (pCreateInfo) {
|
|
skip |= ValidateObject(device, pCreateInfo->image, kVulkanObjectTypeImage, false, "VUID-VkImageViewCreateInfo-image-parameter", kVUIDUndefined);
|
|
}
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PostCallRecordCreateImageView(
|
|
VkDevice device,
|
|
const VkImageViewCreateInfo* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkImageView* pView,
|
|
VkResult result) {
|
|
if (result != VK_SUCCESS) return;
|
|
CreateObject(device, *pView, kVulkanObjectTypeImageView, pAllocator);
|
|
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateDestroyImageView(
|
|
VkDevice device,
|
|
VkImageView imageView,
|
|
const VkAllocationCallbacks* pAllocator) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkDestroyImageView-device-parameter", kVUIDUndefined);
|
|
skip |= ValidateObject(device, imageView, kVulkanObjectTypeImageView, true, "VUID-vkDestroyImageView-imageView-parameter", "VUID-vkDestroyImageView-imageView-parent");
|
|
skip |= ValidateDestroyObject(device, imageView, kVulkanObjectTypeImageView, pAllocator, "VUID-vkDestroyImageView-imageView-01027", "VUID-vkDestroyImageView-imageView-01028");
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PreCallRecordDestroyImageView(
|
|
VkDevice device,
|
|
VkImageView imageView,
|
|
const VkAllocationCallbacks* pAllocator) {
|
|
RecordDestroyObject(device, imageView, kVulkanObjectTypeImageView);
|
|
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCreateShaderModule(
|
|
VkDevice device,
|
|
const VkShaderModuleCreateInfo* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkShaderModule* pShaderModule) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkCreateShaderModule-device-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PostCallRecordCreateShaderModule(
|
|
VkDevice device,
|
|
const VkShaderModuleCreateInfo* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkShaderModule* pShaderModule,
|
|
VkResult result) {
|
|
if (result != VK_SUCCESS) return;
|
|
CreateObject(device, *pShaderModule, kVulkanObjectTypeShaderModule, pAllocator);
|
|
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateDestroyShaderModule(
|
|
VkDevice device,
|
|
VkShaderModule shaderModule,
|
|
const VkAllocationCallbacks* pAllocator) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkDestroyShaderModule-device-parameter", kVUIDUndefined);
|
|
skip |= ValidateObject(device, shaderModule, kVulkanObjectTypeShaderModule, true, "VUID-vkDestroyShaderModule-shaderModule-parameter", "VUID-vkDestroyShaderModule-shaderModule-parent");
|
|
skip |= ValidateDestroyObject(device, shaderModule, kVulkanObjectTypeShaderModule, pAllocator, "VUID-vkDestroyShaderModule-shaderModule-01092", "VUID-vkDestroyShaderModule-shaderModule-01093");
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PreCallRecordDestroyShaderModule(
|
|
VkDevice device,
|
|
VkShaderModule shaderModule,
|
|
const VkAllocationCallbacks* pAllocator) {
|
|
RecordDestroyObject(device, shaderModule, kVulkanObjectTypeShaderModule);
|
|
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCreatePipelineCache(
|
|
VkDevice device,
|
|
const VkPipelineCacheCreateInfo* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkPipelineCache* pPipelineCache) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkCreatePipelineCache-device-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PostCallRecordCreatePipelineCache(
|
|
VkDevice device,
|
|
const VkPipelineCacheCreateInfo* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkPipelineCache* pPipelineCache,
|
|
VkResult result) {
|
|
if (result != VK_SUCCESS) return;
|
|
CreateObject(device, *pPipelineCache, kVulkanObjectTypePipelineCache, pAllocator);
|
|
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateDestroyPipelineCache(
|
|
VkDevice device,
|
|
VkPipelineCache pipelineCache,
|
|
const VkAllocationCallbacks* pAllocator) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkDestroyPipelineCache-device-parameter", kVUIDUndefined);
|
|
skip |= ValidateObject(device, pipelineCache, kVulkanObjectTypePipelineCache, true, "VUID-vkDestroyPipelineCache-pipelineCache-parameter", "VUID-vkDestroyPipelineCache-pipelineCache-parent");
|
|
skip |= ValidateDestroyObject(device, pipelineCache, kVulkanObjectTypePipelineCache, pAllocator, "VUID-vkDestroyPipelineCache-pipelineCache-00771", "VUID-vkDestroyPipelineCache-pipelineCache-00772");
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PreCallRecordDestroyPipelineCache(
|
|
VkDevice device,
|
|
VkPipelineCache pipelineCache,
|
|
const VkAllocationCallbacks* pAllocator) {
|
|
RecordDestroyObject(device, pipelineCache, kVulkanObjectTypePipelineCache);
|
|
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetPipelineCacheData(
|
|
VkDevice device,
|
|
VkPipelineCache pipelineCache,
|
|
size_t* pDataSize,
|
|
void* pData) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkGetPipelineCacheData-device-parameter", kVUIDUndefined);
|
|
skip |= ValidateObject(device, pipelineCache, kVulkanObjectTypePipelineCache, false, "VUID-vkGetPipelineCacheData-pipelineCache-parameter", "VUID-vkGetPipelineCacheData-pipelineCache-parent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateMergePipelineCaches(
|
|
VkDevice device,
|
|
VkPipelineCache dstCache,
|
|
uint32_t srcCacheCount,
|
|
const VkPipelineCache* pSrcCaches) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkMergePipelineCaches-device-parameter", kVUIDUndefined);
|
|
skip |= ValidateObject(device, dstCache, kVulkanObjectTypePipelineCache, false, "VUID-vkMergePipelineCaches-dstCache-parameter", "VUID-vkMergePipelineCaches-dstCache-parent");
|
|
if (pSrcCaches) {
|
|
for (uint32_t index0 = 0; index0 < srcCacheCount; ++index0) {
|
|
skip |= ValidateObject(device, pSrcCaches[index0], kVulkanObjectTypePipelineCache, false, "VUID-vkMergePipelineCaches-pSrcCaches-parameter", "VUID-vkMergePipelineCaches-pSrcCaches-parent");
|
|
}
|
|
}
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCreateGraphicsPipelines(
|
|
VkDevice device,
|
|
VkPipelineCache pipelineCache,
|
|
uint32_t createInfoCount,
|
|
const VkGraphicsPipelineCreateInfo* pCreateInfos,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkPipeline* pPipelines) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkCreateGraphicsPipelines-device-parameter", kVUIDUndefined);
|
|
skip |= ValidateObject(device, pipelineCache, kVulkanObjectTypePipelineCache, true, "VUID-vkCreateGraphicsPipelines-pipelineCache-parameter", "VUID-vkCreateGraphicsPipelines-pipelineCache-parent");
|
|
if (pCreateInfos) {
|
|
for (uint32_t index0 = 0; index0 < createInfoCount; ++index0) {
|
|
if (pCreateInfos[index0].pStages) {
|
|
for (uint32_t index1 = 0; index1 < pCreateInfos[index0].stageCount; ++index1) {
|
|
skip |= ValidateObject(device, pCreateInfos[index0].pStages[index1].module, kVulkanObjectTypeShaderModule, false, "VUID-VkPipelineShaderStageCreateInfo-module-parameter", kVUIDUndefined);
|
|
}
|
|
}
|
|
skip |= ValidateObject(device, pCreateInfos[index0].layout, kVulkanObjectTypePipelineLayout, false, "VUID-VkGraphicsPipelineCreateInfo-layout-parameter", "VUID-VkGraphicsPipelineCreateInfo-commonparent");
|
|
skip |= ValidateObject(device, pCreateInfos[index0].renderPass, kVulkanObjectTypeRenderPass, false, "VUID-VkGraphicsPipelineCreateInfo-renderPass-parameter", "VUID-VkGraphicsPipelineCreateInfo-commonparent");
|
|
skip |= ValidateObject(device, pCreateInfos[index0].basePipelineHandle, kVulkanObjectTypePipeline, true, kVUIDUndefined, "VUID-VkGraphicsPipelineCreateInfo-commonparent");
|
|
}
|
|
}
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PostCallRecordCreateGraphicsPipelines(
|
|
VkDevice device,
|
|
VkPipelineCache pipelineCache,
|
|
uint32_t createInfoCount,
|
|
const VkGraphicsPipelineCreateInfo* pCreateInfos,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkPipeline* pPipelines,
|
|
VkResult result) {
|
|
if (VK_ERROR_VALIDATION_FAILED_EXT == result) return;
|
|
if (pPipelines) {
|
|
for (uint32_t index = 0; index < createInfoCount; index++) {
|
|
if (!pPipelines[index]) continue;
|
|
CreateObject(device, pPipelines[index], kVulkanObjectTypePipeline, pAllocator);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCreateComputePipelines(
|
|
VkDevice device,
|
|
VkPipelineCache pipelineCache,
|
|
uint32_t createInfoCount,
|
|
const VkComputePipelineCreateInfo* pCreateInfos,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkPipeline* pPipelines) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkCreateComputePipelines-device-parameter", kVUIDUndefined);
|
|
skip |= ValidateObject(device, pipelineCache, kVulkanObjectTypePipelineCache, true, "VUID-vkCreateComputePipelines-pipelineCache-parameter", "VUID-vkCreateComputePipelines-pipelineCache-parent");
|
|
if (pCreateInfos) {
|
|
for (uint32_t index0 = 0; index0 < createInfoCount; ++index0) {
|
|
skip |= ValidateObject(device, pCreateInfos[index0].stage.module, kVulkanObjectTypeShaderModule, false, "VUID-VkPipelineShaderStageCreateInfo-module-parameter", kVUIDUndefined);
|
|
skip |= ValidateObject(device, pCreateInfos[index0].layout, kVulkanObjectTypePipelineLayout, false, "VUID-VkComputePipelineCreateInfo-layout-parameter", "VUID-VkComputePipelineCreateInfo-commonparent");
|
|
skip |= ValidateObject(device, pCreateInfos[index0].basePipelineHandle, kVulkanObjectTypePipeline, true, kVUIDUndefined, "VUID-VkComputePipelineCreateInfo-commonparent");
|
|
}
|
|
}
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PostCallRecordCreateComputePipelines(
|
|
VkDevice device,
|
|
VkPipelineCache pipelineCache,
|
|
uint32_t createInfoCount,
|
|
const VkComputePipelineCreateInfo* pCreateInfos,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkPipeline* pPipelines,
|
|
VkResult result) {
|
|
if (VK_ERROR_VALIDATION_FAILED_EXT == result) return;
|
|
if (pPipelines) {
|
|
for (uint32_t index = 0; index < createInfoCount; index++) {
|
|
if (!pPipelines[index]) continue;
|
|
CreateObject(device, pPipelines[index], kVulkanObjectTypePipeline, pAllocator);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateDestroyPipeline(
|
|
VkDevice device,
|
|
VkPipeline pipeline,
|
|
const VkAllocationCallbacks* pAllocator) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkDestroyPipeline-device-parameter", kVUIDUndefined);
|
|
skip |= ValidateObject(device, pipeline, kVulkanObjectTypePipeline, true, "VUID-vkDestroyPipeline-pipeline-parameter", "VUID-vkDestroyPipeline-pipeline-parent");
|
|
skip |= ValidateDestroyObject(device, pipeline, kVulkanObjectTypePipeline, pAllocator, "VUID-vkDestroyPipeline-pipeline-00766", "VUID-vkDestroyPipeline-pipeline-00767");
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PreCallRecordDestroyPipeline(
|
|
VkDevice device,
|
|
VkPipeline pipeline,
|
|
const VkAllocationCallbacks* pAllocator) {
|
|
RecordDestroyObject(device, pipeline, kVulkanObjectTypePipeline);
|
|
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCreatePipelineLayout(
|
|
VkDevice device,
|
|
const VkPipelineLayoutCreateInfo* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkPipelineLayout* pPipelineLayout) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkCreatePipelineLayout-device-parameter", kVUIDUndefined);
|
|
if (pCreateInfo) {
|
|
if (pCreateInfo->pSetLayouts) {
|
|
for (uint32_t index1 = 0; index1 < pCreateInfo->setLayoutCount; ++index1) {
|
|
skip |= ValidateObject(device, pCreateInfo->pSetLayouts[index1], kVulkanObjectTypeDescriptorSetLayout, false, "VUID-VkPipelineLayoutCreateInfo-pSetLayouts-parameter", kVUIDUndefined);
|
|
}
|
|
}
|
|
}
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PostCallRecordCreatePipelineLayout(
|
|
VkDevice device,
|
|
const VkPipelineLayoutCreateInfo* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkPipelineLayout* pPipelineLayout,
|
|
VkResult result) {
|
|
if (result != VK_SUCCESS) return;
|
|
CreateObject(device, *pPipelineLayout, kVulkanObjectTypePipelineLayout, pAllocator);
|
|
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateDestroyPipelineLayout(
|
|
VkDevice device,
|
|
VkPipelineLayout pipelineLayout,
|
|
const VkAllocationCallbacks* pAllocator) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkDestroyPipelineLayout-device-parameter", kVUIDUndefined);
|
|
skip |= ValidateObject(device, pipelineLayout, kVulkanObjectTypePipelineLayout, true, "VUID-vkDestroyPipelineLayout-pipelineLayout-parameter", "VUID-vkDestroyPipelineLayout-pipelineLayout-parent");
|
|
skip |= ValidateDestroyObject(device, pipelineLayout, kVulkanObjectTypePipelineLayout, pAllocator, "VUID-vkDestroyPipelineLayout-pipelineLayout-00299", "VUID-vkDestroyPipelineLayout-pipelineLayout-00300");
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PreCallRecordDestroyPipelineLayout(
|
|
VkDevice device,
|
|
VkPipelineLayout pipelineLayout,
|
|
const VkAllocationCallbacks* pAllocator) {
|
|
RecordDestroyObject(device, pipelineLayout, kVulkanObjectTypePipelineLayout);
|
|
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCreateSampler(
|
|
VkDevice device,
|
|
const VkSamplerCreateInfo* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkSampler* pSampler) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkCreateSampler-device-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PostCallRecordCreateSampler(
|
|
VkDevice device,
|
|
const VkSamplerCreateInfo* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkSampler* pSampler,
|
|
VkResult result) {
|
|
if (result != VK_SUCCESS) return;
|
|
CreateObject(device, *pSampler, kVulkanObjectTypeSampler, pAllocator);
|
|
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateDestroySampler(
|
|
VkDevice device,
|
|
VkSampler sampler,
|
|
const VkAllocationCallbacks* pAllocator) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkDestroySampler-device-parameter", kVUIDUndefined);
|
|
skip |= ValidateObject(device, sampler, kVulkanObjectTypeSampler, true, "VUID-vkDestroySampler-sampler-parameter", "VUID-vkDestroySampler-sampler-parent");
|
|
skip |= ValidateDestroyObject(device, sampler, kVulkanObjectTypeSampler, pAllocator, "VUID-vkDestroySampler-sampler-01083", "VUID-vkDestroySampler-sampler-01084");
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PreCallRecordDestroySampler(
|
|
VkDevice device,
|
|
VkSampler sampler,
|
|
const VkAllocationCallbacks* pAllocator) {
|
|
RecordDestroyObject(device, sampler, kVulkanObjectTypeSampler);
|
|
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateDestroyDescriptorSetLayout(
|
|
VkDevice device,
|
|
VkDescriptorSetLayout descriptorSetLayout,
|
|
const VkAllocationCallbacks* pAllocator) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkDestroyDescriptorSetLayout-device-parameter", kVUIDUndefined);
|
|
skip |= ValidateObject(device, descriptorSetLayout, kVulkanObjectTypeDescriptorSetLayout, true, "VUID-vkDestroyDescriptorSetLayout-descriptorSetLayout-parameter", "VUID-vkDestroyDescriptorSetLayout-descriptorSetLayout-parent");
|
|
skip |= ValidateDestroyObject(device, descriptorSetLayout, kVulkanObjectTypeDescriptorSetLayout, pAllocator, "VUID-vkDestroyDescriptorSetLayout-descriptorSetLayout-00284", "VUID-vkDestroyDescriptorSetLayout-descriptorSetLayout-00285");
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PreCallRecordDestroyDescriptorSetLayout(
|
|
VkDevice device,
|
|
VkDescriptorSetLayout descriptorSetLayout,
|
|
const VkAllocationCallbacks* pAllocator) {
|
|
RecordDestroyObject(device, descriptorSetLayout, kVulkanObjectTypeDescriptorSetLayout);
|
|
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCreateDescriptorPool(
|
|
VkDevice device,
|
|
const VkDescriptorPoolCreateInfo* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkDescriptorPool* pDescriptorPool) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkCreateDescriptorPool-device-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PostCallRecordCreateDescriptorPool(
|
|
VkDevice device,
|
|
const VkDescriptorPoolCreateInfo* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkDescriptorPool* pDescriptorPool,
|
|
VkResult result) {
|
|
if (result != VK_SUCCESS) return;
|
|
CreateObject(device, *pDescriptorPool, kVulkanObjectTypeDescriptorPool, pAllocator);
|
|
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateDestroyFramebuffer(
|
|
VkDevice device,
|
|
VkFramebuffer framebuffer,
|
|
const VkAllocationCallbacks* pAllocator) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkDestroyFramebuffer-device-parameter", kVUIDUndefined);
|
|
skip |= ValidateObject(device, framebuffer, kVulkanObjectTypeFramebuffer, true, "VUID-vkDestroyFramebuffer-framebuffer-parameter", "VUID-vkDestroyFramebuffer-framebuffer-parent");
|
|
skip |= ValidateDestroyObject(device, framebuffer, kVulkanObjectTypeFramebuffer, pAllocator, "VUID-vkDestroyFramebuffer-framebuffer-00893", "VUID-vkDestroyFramebuffer-framebuffer-00894");
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PreCallRecordDestroyFramebuffer(
|
|
VkDevice device,
|
|
VkFramebuffer framebuffer,
|
|
const VkAllocationCallbacks* pAllocator) {
|
|
RecordDestroyObject(device, framebuffer, kVulkanObjectTypeFramebuffer);
|
|
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCreateRenderPass(
|
|
VkDevice device,
|
|
const VkRenderPassCreateInfo* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkRenderPass* pRenderPass) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkCreateRenderPass-device-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PostCallRecordCreateRenderPass(
|
|
VkDevice device,
|
|
const VkRenderPassCreateInfo* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkRenderPass* pRenderPass,
|
|
VkResult result) {
|
|
if (result != VK_SUCCESS) return;
|
|
CreateObject(device, *pRenderPass, kVulkanObjectTypeRenderPass, pAllocator);
|
|
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateDestroyRenderPass(
|
|
VkDevice device,
|
|
VkRenderPass renderPass,
|
|
const VkAllocationCallbacks* pAllocator) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkDestroyRenderPass-device-parameter", kVUIDUndefined);
|
|
skip |= ValidateObject(device, renderPass, kVulkanObjectTypeRenderPass, true, "VUID-vkDestroyRenderPass-renderPass-parameter", "VUID-vkDestroyRenderPass-renderPass-parent");
|
|
skip |= ValidateDestroyObject(device, renderPass, kVulkanObjectTypeRenderPass, pAllocator, "VUID-vkDestroyRenderPass-renderPass-00874", "VUID-vkDestroyRenderPass-renderPass-00875");
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PreCallRecordDestroyRenderPass(
|
|
VkDevice device,
|
|
VkRenderPass renderPass,
|
|
const VkAllocationCallbacks* pAllocator) {
|
|
RecordDestroyObject(device, renderPass, kVulkanObjectTypeRenderPass);
|
|
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetRenderAreaGranularity(
|
|
VkDevice device,
|
|
VkRenderPass renderPass,
|
|
VkExtent2D* pGranularity) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkGetRenderAreaGranularity-device-parameter", kVUIDUndefined);
|
|
skip |= ValidateObject(device, renderPass, kVulkanObjectTypeRenderPass, false, "VUID-vkGetRenderAreaGranularity-renderPass-parameter", "VUID-vkGetRenderAreaGranularity-renderPass-parent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCreateCommandPool(
|
|
VkDevice device,
|
|
const VkCommandPoolCreateInfo* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkCommandPool* pCommandPool) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkCreateCommandPool-device-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PostCallRecordCreateCommandPool(
|
|
VkDevice device,
|
|
const VkCommandPoolCreateInfo* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkCommandPool* pCommandPool,
|
|
VkResult result) {
|
|
if (result != VK_SUCCESS) return;
|
|
CreateObject(device, *pCommandPool, kVulkanObjectTypeCommandPool, pAllocator);
|
|
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateResetCommandPool(
|
|
VkDevice device,
|
|
VkCommandPool commandPool,
|
|
VkCommandPoolResetFlags flags) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkResetCommandPool-device-parameter", kVUIDUndefined);
|
|
skip |= ValidateObject(device, commandPool, kVulkanObjectTypeCommandPool, false, "VUID-vkResetCommandPool-commandPool-parameter", "VUID-vkResetCommandPool-commandPool-parent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateEndCommandBuffer(
|
|
VkCommandBuffer commandBuffer) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkEndCommandBuffer-commandBuffer-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateResetCommandBuffer(
|
|
VkCommandBuffer commandBuffer,
|
|
VkCommandBufferResetFlags flags) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkResetCommandBuffer-commandBuffer-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdBindPipeline(
|
|
VkCommandBuffer commandBuffer,
|
|
VkPipelineBindPoint pipelineBindPoint,
|
|
VkPipeline pipeline) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdBindPipeline-commandBuffer-parameter", "VUID-vkCmdBindPipeline-commonparent");
|
|
skip |= ValidateObject(commandBuffer, pipeline, kVulkanObjectTypePipeline, false, "VUID-vkCmdBindPipeline-pipeline-parameter", "VUID-vkCmdBindPipeline-commonparent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdSetViewport(
|
|
VkCommandBuffer commandBuffer,
|
|
uint32_t firstViewport,
|
|
uint32_t viewportCount,
|
|
const VkViewport* pViewports) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdSetViewport-commandBuffer-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdSetScissor(
|
|
VkCommandBuffer commandBuffer,
|
|
uint32_t firstScissor,
|
|
uint32_t scissorCount,
|
|
const VkRect2D* pScissors) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdSetScissor-commandBuffer-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdSetLineWidth(
|
|
VkCommandBuffer commandBuffer,
|
|
float lineWidth) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdSetLineWidth-commandBuffer-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdSetDepthBias(
|
|
VkCommandBuffer commandBuffer,
|
|
float depthBiasConstantFactor,
|
|
float depthBiasClamp,
|
|
float depthBiasSlopeFactor) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdSetDepthBias-commandBuffer-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdSetBlendConstants(
|
|
VkCommandBuffer commandBuffer,
|
|
const float blendConstants[4]) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdSetBlendConstants-commandBuffer-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdSetDepthBounds(
|
|
VkCommandBuffer commandBuffer,
|
|
float minDepthBounds,
|
|
float maxDepthBounds) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdSetDepthBounds-commandBuffer-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdSetStencilCompareMask(
|
|
VkCommandBuffer commandBuffer,
|
|
VkStencilFaceFlags faceMask,
|
|
uint32_t compareMask) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdSetStencilCompareMask-commandBuffer-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdSetStencilWriteMask(
|
|
VkCommandBuffer commandBuffer,
|
|
VkStencilFaceFlags faceMask,
|
|
uint32_t writeMask) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdSetStencilWriteMask-commandBuffer-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdSetStencilReference(
|
|
VkCommandBuffer commandBuffer,
|
|
VkStencilFaceFlags faceMask,
|
|
uint32_t reference) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdSetStencilReference-commandBuffer-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdBindDescriptorSets(
|
|
VkCommandBuffer commandBuffer,
|
|
VkPipelineBindPoint pipelineBindPoint,
|
|
VkPipelineLayout layout,
|
|
uint32_t firstSet,
|
|
uint32_t descriptorSetCount,
|
|
const VkDescriptorSet* pDescriptorSets,
|
|
uint32_t dynamicOffsetCount,
|
|
const uint32_t* pDynamicOffsets) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdBindDescriptorSets-commandBuffer-parameter", "VUID-vkCmdBindDescriptorSets-commonparent");
|
|
skip |= ValidateObject(commandBuffer, layout, kVulkanObjectTypePipelineLayout, false, "VUID-vkCmdBindDescriptorSets-layout-parameter", "VUID-vkCmdBindDescriptorSets-commonparent");
|
|
if (pDescriptorSets) {
|
|
for (uint32_t index0 = 0; index0 < descriptorSetCount; ++index0) {
|
|
skip |= ValidateObject(commandBuffer, pDescriptorSets[index0], kVulkanObjectTypeDescriptorSet, false, "VUID-vkCmdBindDescriptorSets-pDescriptorSets-parameter", "VUID-vkCmdBindDescriptorSets-commonparent");
|
|
}
|
|
}
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdBindIndexBuffer(
|
|
VkCommandBuffer commandBuffer,
|
|
VkBuffer buffer,
|
|
VkDeviceSize offset,
|
|
VkIndexType indexType) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdBindIndexBuffer-commandBuffer-parameter", "VUID-vkCmdBindIndexBuffer-commonparent");
|
|
skip |= ValidateObject(commandBuffer, buffer, kVulkanObjectTypeBuffer, false, "VUID-vkCmdBindIndexBuffer-buffer-parameter", "VUID-vkCmdBindIndexBuffer-commonparent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdBindVertexBuffers(
|
|
VkCommandBuffer commandBuffer,
|
|
uint32_t firstBinding,
|
|
uint32_t bindingCount,
|
|
const VkBuffer* pBuffers,
|
|
const VkDeviceSize* pOffsets) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdBindVertexBuffers-commandBuffer-parameter", "VUID-vkCmdBindVertexBuffers-commonparent");
|
|
if (pBuffers) {
|
|
for (uint32_t index0 = 0; index0 < bindingCount; ++index0) {
|
|
skip |= ValidateObject(commandBuffer, pBuffers[index0], kVulkanObjectTypeBuffer, false, "VUID-vkCmdBindVertexBuffers-pBuffers-parameter", "VUID-vkCmdBindVertexBuffers-commonparent");
|
|
}
|
|
}
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdDraw(
|
|
VkCommandBuffer commandBuffer,
|
|
uint32_t vertexCount,
|
|
uint32_t instanceCount,
|
|
uint32_t firstVertex,
|
|
uint32_t firstInstance) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdDraw-commandBuffer-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdDrawIndexed(
|
|
VkCommandBuffer commandBuffer,
|
|
uint32_t indexCount,
|
|
uint32_t instanceCount,
|
|
uint32_t firstIndex,
|
|
int32_t vertexOffset,
|
|
uint32_t firstInstance) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdDrawIndexed-commandBuffer-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdDrawIndirect(
|
|
VkCommandBuffer commandBuffer,
|
|
VkBuffer buffer,
|
|
VkDeviceSize offset,
|
|
uint32_t drawCount,
|
|
uint32_t stride) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdDrawIndirect-commandBuffer-parameter", "VUID-vkCmdDrawIndirect-commonparent");
|
|
skip |= ValidateObject(commandBuffer, buffer, kVulkanObjectTypeBuffer, false, "VUID-vkCmdDrawIndirect-buffer-parameter", "VUID-vkCmdDrawIndirect-commonparent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdDrawIndexedIndirect(
|
|
VkCommandBuffer commandBuffer,
|
|
VkBuffer buffer,
|
|
VkDeviceSize offset,
|
|
uint32_t drawCount,
|
|
uint32_t stride) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdDrawIndexedIndirect-commandBuffer-parameter", "VUID-vkCmdDrawIndexedIndirect-commonparent");
|
|
skip |= ValidateObject(commandBuffer, buffer, kVulkanObjectTypeBuffer, false, "VUID-vkCmdDrawIndexedIndirect-buffer-parameter", "VUID-vkCmdDrawIndexedIndirect-commonparent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdDispatch(
|
|
VkCommandBuffer commandBuffer,
|
|
uint32_t groupCountX,
|
|
uint32_t groupCountY,
|
|
uint32_t groupCountZ) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdDispatch-commandBuffer-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdDispatchIndirect(
|
|
VkCommandBuffer commandBuffer,
|
|
VkBuffer buffer,
|
|
VkDeviceSize offset) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdDispatchIndirect-commandBuffer-parameter", "VUID-vkCmdDispatchIndirect-commonparent");
|
|
skip |= ValidateObject(commandBuffer, buffer, kVulkanObjectTypeBuffer, false, "VUID-vkCmdDispatchIndirect-buffer-parameter", "VUID-vkCmdDispatchIndirect-commonparent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdCopyBuffer(
|
|
VkCommandBuffer commandBuffer,
|
|
VkBuffer srcBuffer,
|
|
VkBuffer dstBuffer,
|
|
uint32_t regionCount,
|
|
const VkBufferCopy* pRegions) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdCopyBuffer-commandBuffer-parameter", "VUID-vkCmdCopyBuffer-commonparent");
|
|
skip |= ValidateObject(commandBuffer, srcBuffer, kVulkanObjectTypeBuffer, false, "VUID-vkCmdCopyBuffer-srcBuffer-parameter", "VUID-vkCmdCopyBuffer-commonparent");
|
|
skip |= ValidateObject(commandBuffer, dstBuffer, kVulkanObjectTypeBuffer, false, "VUID-vkCmdCopyBuffer-dstBuffer-parameter", "VUID-vkCmdCopyBuffer-commonparent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdCopyImage(
|
|
VkCommandBuffer commandBuffer,
|
|
VkImage srcImage,
|
|
VkImageLayout srcImageLayout,
|
|
VkImage dstImage,
|
|
VkImageLayout dstImageLayout,
|
|
uint32_t regionCount,
|
|
const VkImageCopy* pRegions) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdCopyImage-commandBuffer-parameter", "VUID-vkCmdCopyImage-commonparent");
|
|
skip |= ValidateObject(commandBuffer, srcImage, kVulkanObjectTypeImage, false, "VUID-vkCmdCopyImage-srcImage-parameter", "VUID-vkCmdCopyImage-commonparent");
|
|
skip |= ValidateObject(commandBuffer, dstImage, kVulkanObjectTypeImage, false, "VUID-vkCmdCopyImage-dstImage-parameter", "VUID-vkCmdCopyImage-commonparent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdBlitImage(
|
|
VkCommandBuffer commandBuffer,
|
|
VkImage srcImage,
|
|
VkImageLayout srcImageLayout,
|
|
VkImage dstImage,
|
|
VkImageLayout dstImageLayout,
|
|
uint32_t regionCount,
|
|
const VkImageBlit* pRegions,
|
|
VkFilter filter) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdBlitImage-commandBuffer-parameter", "VUID-vkCmdBlitImage-commonparent");
|
|
skip |= ValidateObject(commandBuffer, srcImage, kVulkanObjectTypeImage, false, "VUID-vkCmdBlitImage-srcImage-parameter", "VUID-vkCmdBlitImage-commonparent");
|
|
skip |= ValidateObject(commandBuffer, dstImage, kVulkanObjectTypeImage, false, "VUID-vkCmdBlitImage-dstImage-parameter", "VUID-vkCmdBlitImage-commonparent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdCopyBufferToImage(
|
|
VkCommandBuffer commandBuffer,
|
|
VkBuffer srcBuffer,
|
|
VkImage dstImage,
|
|
VkImageLayout dstImageLayout,
|
|
uint32_t regionCount,
|
|
const VkBufferImageCopy* pRegions) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdCopyBufferToImage-commandBuffer-parameter", "VUID-vkCmdCopyBufferToImage-commonparent");
|
|
skip |= ValidateObject(commandBuffer, srcBuffer, kVulkanObjectTypeBuffer, false, "VUID-vkCmdCopyBufferToImage-srcBuffer-parameter", "VUID-vkCmdCopyBufferToImage-commonparent");
|
|
skip |= ValidateObject(commandBuffer, dstImage, kVulkanObjectTypeImage, false, "VUID-vkCmdCopyBufferToImage-dstImage-parameter", "VUID-vkCmdCopyBufferToImage-commonparent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdCopyImageToBuffer(
|
|
VkCommandBuffer commandBuffer,
|
|
VkImage srcImage,
|
|
VkImageLayout srcImageLayout,
|
|
VkBuffer dstBuffer,
|
|
uint32_t regionCount,
|
|
const VkBufferImageCopy* pRegions) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdCopyImageToBuffer-commandBuffer-parameter", "VUID-vkCmdCopyImageToBuffer-commonparent");
|
|
skip |= ValidateObject(commandBuffer, srcImage, kVulkanObjectTypeImage, false, "VUID-vkCmdCopyImageToBuffer-srcImage-parameter", "VUID-vkCmdCopyImageToBuffer-commonparent");
|
|
skip |= ValidateObject(commandBuffer, dstBuffer, kVulkanObjectTypeBuffer, false, "VUID-vkCmdCopyImageToBuffer-dstBuffer-parameter", "VUID-vkCmdCopyImageToBuffer-commonparent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdUpdateBuffer(
|
|
VkCommandBuffer commandBuffer,
|
|
VkBuffer dstBuffer,
|
|
VkDeviceSize dstOffset,
|
|
VkDeviceSize dataSize,
|
|
const void* pData) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdUpdateBuffer-commandBuffer-parameter", "VUID-vkCmdUpdateBuffer-commonparent");
|
|
skip |= ValidateObject(commandBuffer, dstBuffer, kVulkanObjectTypeBuffer, false, "VUID-vkCmdUpdateBuffer-dstBuffer-parameter", "VUID-vkCmdUpdateBuffer-commonparent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdFillBuffer(
|
|
VkCommandBuffer commandBuffer,
|
|
VkBuffer dstBuffer,
|
|
VkDeviceSize dstOffset,
|
|
VkDeviceSize size,
|
|
uint32_t data) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdFillBuffer-commandBuffer-parameter", "VUID-vkCmdFillBuffer-commonparent");
|
|
skip |= ValidateObject(commandBuffer, dstBuffer, kVulkanObjectTypeBuffer, false, "VUID-vkCmdFillBuffer-dstBuffer-parameter", "VUID-vkCmdFillBuffer-commonparent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdClearColorImage(
|
|
VkCommandBuffer commandBuffer,
|
|
VkImage image,
|
|
VkImageLayout imageLayout,
|
|
const VkClearColorValue* pColor,
|
|
uint32_t rangeCount,
|
|
const VkImageSubresourceRange* pRanges) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdClearColorImage-commandBuffer-parameter", "VUID-vkCmdClearColorImage-commonparent");
|
|
skip |= ValidateObject(commandBuffer, image, kVulkanObjectTypeImage, false, "VUID-vkCmdClearColorImage-image-parameter", "VUID-vkCmdClearColorImage-commonparent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdClearDepthStencilImage(
|
|
VkCommandBuffer commandBuffer,
|
|
VkImage image,
|
|
VkImageLayout imageLayout,
|
|
const VkClearDepthStencilValue* pDepthStencil,
|
|
uint32_t rangeCount,
|
|
const VkImageSubresourceRange* pRanges) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdClearDepthStencilImage-commandBuffer-parameter", "VUID-vkCmdClearDepthStencilImage-commonparent");
|
|
skip |= ValidateObject(commandBuffer, image, kVulkanObjectTypeImage, false, "VUID-vkCmdClearDepthStencilImage-image-parameter", "VUID-vkCmdClearDepthStencilImage-commonparent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdClearAttachments(
|
|
VkCommandBuffer commandBuffer,
|
|
uint32_t attachmentCount,
|
|
const VkClearAttachment* pAttachments,
|
|
uint32_t rectCount,
|
|
const VkClearRect* pRects) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdClearAttachments-commandBuffer-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdResolveImage(
|
|
VkCommandBuffer commandBuffer,
|
|
VkImage srcImage,
|
|
VkImageLayout srcImageLayout,
|
|
VkImage dstImage,
|
|
VkImageLayout dstImageLayout,
|
|
uint32_t regionCount,
|
|
const VkImageResolve* pRegions) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdResolveImage-commandBuffer-parameter", "VUID-vkCmdResolveImage-commonparent");
|
|
skip |= ValidateObject(commandBuffer, srcImage, kVulkanObjectTypeImage, false, "VUID-vkCmdResolveImage-srcImage-parameter", "VUID-vkCmdResolveImage-commonparent");
|
|
skip |= ValidateObject(commandBuffer, dstImage, kVulkanObjectTypeImage, false, "VUID-vkCmdResolveImage-dstImage-parameter", "VUID-vkCmdResolveImage-commonparent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdSetEvent(
|
|
VkCommandBuffer commandBuffer,
|
|
VkEvent event,
|
|
VkPipelineStageFlags stageMask) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdSetEvent-commandBuffer-parameter", "VUID-vkCmdSetEvent-commonparent");
|
|
skip |= ValidateObject(commandBuffer, event, kVulkanObjectTypeEvent, false, "VUID-vkCmdSetEvent-event-parameter", "VUID-vkCmdSetEvent-commonparent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdResetEvent(
|
|
VkCommandBuffer commandBuffer,
|
|
VkEvent event,
|
|
VkPipelineStageFlags stageMask) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdResetEvent-commandBuffer-parameter", "VUID-vkCmdResetEvent-commonparent");
|
|
skip |= ValidateObject(commandBuffer, event, kVulkanObjectTypeEvent, false, "VUID-vkCmdResetEvent-event-parameter", "VUID-vkCmdResetEvent-commonparent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdWaitEvents(
|
|
VkCommandBuffer commandBuffer,
|
|
uint32_t eventCount,
|
|
const VkEvent* pEvents,
|
|
VkPipelineStageFlags srcStageMask,
|
|
VkPipelineStageFlags dstStageMask,
|
|
uint32_t memoryBarrierCount,
|
|
const VkMemoryBarrier* pMemoryBarriers,
|
|
uint32_t bufferMemoryBarrierCount,
|
|
const VkBufferMemoryBarrier* pBufferMemoryBarriers,
|
|
uint32_t imageMemoryBarrierCount,
|
|
const VkImageMemoryBarrier* pImageMemoryBarriers) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdWaitEvents-commandBuffer-parameter", "VUID-vkCmdWaitEvents-commonparent");
|
|
if (pEvents) {
|
|
for (uint32_t index0 = 0; index0 < eventCount; ++index0) {
|
|
skip |= ValidateObject(commandBuffer, pEvents[index0], kVulkanObjectTypeEvent, false, "VUID-vkCmdWaitEvents-pEvents-parameter", "VUID-vkCmdWaitEvents-commonparent");
|
|
}
|
|
}
|
|
if (pBufferMemoryBarriers) {
|
|
for (uint32_t index0 = 0; index0 < bufferMemoryBarrierCount; ++index0) {
|
|
skip |= ValidateObject(commandBuffer, pBufferMemoryBarriers[index0].buffer, kVulkanObjectTypeBuffer, false, "VUID-VkBufferMemoryBarrier-buffer-parameter", kVUIDUndefined);
|
|
}
|
|
}
|
|
if (pImageMemoryBarriers) {
|
|
for (uint32_t index0 = 0; index0 < imageMemoryBarrierCount; ++index0) {
|
|
skip |= ValidateObject(commandBuffer, pImageMemoryBarriers[index0].image, kVulkanObjectTypeImage, false, "VUID-VkImageMemoryBarrier-image-parameter", kVUIDUndefined);
|
|
}
|
|
}
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdPipelineBarrier(
|
|
VkCommandBuffer commandBuffer,
|
|
VkPipelineStageFlags srcStageMask,
|
|
VkPipelineStageFlags dstStageMask,
|
|
VkDependencyFlags dependencyFlags,
|
|
uint32_t memoryBarrierCount,
|
|
const VkMemoryBarrier* pMemoryBarriers,
|
|
uint32_t bufferMemoryBarrierCount,
|
|
const VkBufferMemoryBarrier* pBufferMemoryBarriers,
|
|
uint32_t imageMemoryBarrierCount,
|
|
const VkImageMemoryBarrier* pImageMemoryBarriers) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdPipelineBarrier-commandBuffer-parameter", kVUIDUndefined);
|
|
if (pBufferMemoryBarriers) {
|
|
for (uint32_t index0 = 0; index0 < bufferMemoryBarrierCount; ++index0) {
|
|
skip |= ValidateObject(commandBuffer, pBufferMemoryBarriers[index0].buffer, kVulkanObjectTypeBuffer, false, "VUID-VkBufferMemoryBarrier-buffer-parameter", kVUIDUndefined);
|
|
}
|
|
}
|
|
if (pImageMemoryBarriers) {
|
|
for (uint32_t index0 = 0; index0 < imageMemoryBarrierCount; ++index0) {
|
|
skip |= ValidateObject(commandBuffer, pImageMemoryBarriers[index0].image, kVulkanObjectTypeImage, false, "VUID-VkImageMemoryBarrier-image-parameter", kVUIDUndefined);
|
|
}
|
|
}
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdBeginQuery(
|
|
VkCommandBuffer commandBuffer,
|
|
VkQueryPool queryPool,
|
|
uint32_t query,
|
|
VkQueryControlFlags flags) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdBeginQuery-commandBuffer-parameter", "VUID-vkCmdBeginQuery-commonparent");
|
|
skip |= ValidateObject(commandBuffer, queryPool, kVulkanObjectTypeQueryPool, false, "VUID-vkCmdBeginQuery-queryPool-parameter", "VUID-vkCmdBeginQuery-commonparent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdEndQuery(
|
|
VkCommandBuffer commandBuffer,
|
|
VkQueryPool queryPool,
|
|
uint32_t query) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdEndQuery-commandBuffer-parameter", "VUID-vkCmdEndQuery-commonparent");
|
|
skip |= ValidateObject(commandBuffer, queryPool, kVulkanObjectTypeQueryPool, false, "VUID-vkCmdEndQuery-queryPool-parameter", "VUID-vkCmdEndQuery-commonparent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdResetQueryPool(
|
|
VkCommandBuffer commandBuffer,
|
|
VkQueryPool queryPool,
|
|
uint32_t firstQuery,
|
|
uint32_t queryCount) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdResetQueryPool-commandBuffer-parameter", "VUID-vkCmdResetQueryPool-commonparent");
|
|
skip |= ValidateObject(commandBuffer, queryPool, kVulkanObjectTypeQueryPool, false, "VUID-vkCmdResetQueryPool-queryPool-parameter", "VUID-vkCmdResetQueryPool-commonparent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdWriteTimestamp(
|
|
VkCommandBuffer commandBuffer,
|
|
VkPipelineStageFlagBits pipelineStage,
|
|
VkQueryPool queryPool,
|
|
uint32_t query) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdWriteTimestamp-commandBuffer-parameter", "VUID-vkCmdWriteTimestamp-commonparent");
|
|
skip |= ValidateObject(commandBuffer, queryPool, kVulkanObjectTypeQueryPool, false, "VUID-vkCmdWriteTimestamp-queryPool-parameter", "VUID-vkCmdWriteTimestamp-commonparent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdCopyQueryPoolResults(
|
|
VkCommandBuffer commandBuffer,
|
|
VkQueryPool queryPool,
|
|
uint32_t firstQuery,
|
|
uint32_t queryCount,
|
|
VkBuffer dstBuffer,
|
|
VkDeviceSize dstOffset,
|
|
VkDeviceSize stride,
|
|
VkQueryResultFlags flags) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdCopyQueryPoolResults-commandBuffer-parameter", "VUID-vkCmdCopyQueryPoolResults-commonparent");
|
|
skip |= ValidateObject(commandBuffer, queryPool, kVulkanObjectTypeQueryPool, false, "VUID-vkCmdCopyQueryPoolResults-queryPool-parameter", "VUID-vkCmdCopyQueryPoolResults-commonparent");
|
|
skip |= ValidateObject(commandBuffer, dstBuffer, kVulkanObjectTypeBuffer, false, "VUID-vkCmdCopyQueryPoolResults-dstBuffer-parameter", "VUID-vkCmdCopyQueryPoolResults-commonparent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdPushConstants(
|
|
VkCommandBuffer commandBuffer,
|
|
VkPipelineLayout layout,
|
|
VkShaderStageFlags stageFlags,
|
|
uint32_t offset,
|
|
uint32_t size,
|
|
const void* pValues) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdPushConstants-commandBuffer-parameter", "VUID-vkCmdPushConstants-commonparent");
|
|
skip |= ValidateObject(commandBuffer, layout, kVulkanObjectTypePipelineLayout, false, "VUID-vkCmdPushConstants-layout-parameter", "VUID-vkCmdPushConstants-commonparent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdBeginRenderPass(
|
|
VkCommandBuffer commandBuffer,
|
|
const VkRenderPassBeginInfo* pRenderPassBegin,
|
|
VkSubpassContents contents) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdBeginRenderPass-commandBuffer-parameter", kVUIDUndefined);
|
|
if (pRenderPassBegin) {
|
|
skip |= ValidateObject(commandBuffer, pRenderPassBegin->renderPass, kVulkanObjectTypeRenderPass, false, "VUID-VkRenderPassBeginInfo-renderPass-parameter", "VUID-VkRenderPassBeginInfo-commonparent");
|
|
skip |= ValidateObject(commandBuffer, pRenderPassBegin->framebuffer, kVulkanObjectTypeFramebuffer, false, "VUID-VkRenderPassBeginInfo-framebuffer-parameter", "VUID-VkRenderPassBeginInfo-commonparent");
|
|
}
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdNextSubpass(
|
|
VkCommandBuffer commandBuffer,
|
|
VkSubpassContents contents) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdNextSubpass-commandBuffer-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdEndRenderPass(
|
|
VkCommandBuffer commandBuffer) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdEndRenderPass-commandBuffer-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdExecuteCommands(
|
|
VkCommandBuffer commandBuffer,
|
|
uint32_t commandBufferCount,
|
|
const VkCommandBuffer* pCommandBuffers) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdExecuteCommands-commandBuffer-parameter", "VUID-vkCmdExecuteCommands-commonparent");
|
|
if (pCommandBuffers) {
|
|
for (uint32_t index0 = 0; index0 < commandBufferCount; ++index0) {
|
|
skip |= ValidateObject(commandBuffer, pCommandBuffers[index0], kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdExecuteCommands-pCommandBuffers-parameter", "VUID-vkCmdExecuteCommands-commonparent");
|
|
}
|
|
}
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateBindBufferMemory2(
|
|
VkDevice device,
|
|
uint32_t bindInfoCount,
|
|
const VkBindBufferMemoryInfo* pBindInfos) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkBindBufferMemory2-device-parameter", kVUIDUndefined);
|
|
if (pBindInfos) {
|
|
for (uint32_t index0 = 0; index0 < bindInfoCount; ++index0) {
|
|
skip |= ValidateObject(device, pBindInfos[index0].buffer, kVulkanObjectTypeBuffer, false, "VUID-VkBindBufferMemoryInfo-buffer-parameter", "VUID-VkBindBufferMemoryInfo-commonparent");
|
|
skip |= ValidateObject(device, pBindInfos[index0].memory, kVulkanObjectTypeDeviceMemory, false, "VUID-VkBindBufferMemoryInfo-memory-parameter", "VUID-VkBindBufferMemoryInfo-commonparent");
|
|
}
|
|
}
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateBindImageMemory2(
|
|
VkDevice device,
|
|
uint32_t bindInfoCount,
|
|
const VkBindImageMemoryInfo* pBindInfos) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkBindImageMemory2-device-parameter", kVUIDUndefined);
|
|
if (pBindInfos) {
|
|
for (uint32_t index0 = 0; index0 < bindInfoCount; ++index0) {
|
|
skip |= ValidateObject(device, pBindInfos[index0].image, kVulkanObjectTypeImage, false, "VUID-VkBindImageMemoryInfo-image-parameter", "VUID-VkBindImageMemoryInfo-commonparent");
|
|
skip |= ValidateObject(device, pBindInfos[index0].memory, kVulkanObjectTypeDeviceMemory, true, kVUIDUndefined, "VUID-VkBindImageMemoryInfo-commonparent");
|
|
}
|
|
}
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetDeviceGroupPeerMemoryFeatures(
|
|
VkDevice device,
|
|
uint32_t heapIndex,
|
|
uint32_t localDeviceIndex,
|
|
uint32_t remoteDeviceIndex,
|
|
VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkGetDeviceGroupPeerMemoryFeatures-device-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdSetDeviceMask(
|
|
VkCommandBuffer commandBuffer,
|
|
uint32_t deviceMask) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdSetDeviceMask-commandBuffer-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdDispatchBase(
|
|
VkCommandBuffer commandBuffer,
|
|
uint32_t baseGroupX,
|
|
uint32_t baseGroupY,
|
|
uint32_t baseGroupZ,
|
|
uint32_t groupCountX,
|
|
uint32_t groupCountY,
|
|
uint32_t groupCountZ) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdDispatchBase-commandBuffer-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateEnumeratePhysicalDeviceGroups(
|
|
VkInstance instance,
|
|
uint32_t* pPhysicalDeviceGroupCount,
|
|
VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(instance, instance, kVulkanObjectTypeInstance, false, "VUID-vkEnumeratePhysicalDeviceGroups-instance-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetImageMemoryRequirements2(
|
|
VkDevice device,
|
|
const VkImageMemoryRequirementsInfo2* pInfo,
|
|
VkMemoryRequirements2* pMemoryRequirements) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkGetImageMemoryRequirements2-device-parameter", kVUIDUndefined);
|
|
if (pInfo) {
|
|
skip |= ValidateObject(device, pInfo->image, kVulkanObjectTypeImage, false, "VUID-VkImageMemoryRequirementsInfo2-image-parameter", kVUIDUndefined);
|
|
}
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetBufferMemoryRequirements2(
|
|
VkDevice device,
|
|
const VkBufferMemoryRequirementsInfo2* pInfo,
|
|
VkMemoryRequirements2* pMemoryRequirements) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkGetBufferMemoryRequirements2-device-parameter", kVUIDUndefined);
|
|
if (pInfo) {
|
|
skip |= ValidateObject(device, pInfo->buffer, kVulkanObjectTypeBuffer, false, "VUID-VkBufferMemoryRequirementsInfo2-buffer-parameter", kVUIDUndefined);
|
|
}
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetImageSparseMemoryRequirements2(
|
|
VkDevice device,
|
|
const VkImageSparseMemoryRequirementsInfo2* pInfo,
|
|
uint32_t* pSparseMemoryRequirementCount,
|
|
VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkGetImageSparseMemoryRequirements2-device-parameter", kVUIDUndefined);
|
|
if (pInfo) {
|
|
skip |= ValidateObject(device, pInfo->image, kVulkanObjectTypeImage, false, "VUID-VkImageSparseMemoryRequirementsInfo2-image-parameter", kVUIDUndefined);
|
|
}
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceFeatures2(
|
|
VkPhysicalDevice physicalDevice,
|
|
VkPhysicalDeviceFeatures2* pFeatures) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceFeatures2-physicalDevice-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceProperties2(
|
|
VkPhysicalDevice physicalDevice,
|
|
VkPhysicalDeviceProperties2* pProperties) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceProperties2-physicalDevice-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceFormatProperties2(
|
|
VkPhysicalDevice physicalDevice,
|
|
VkFormat format,
|
|
VkFormatProperties2* pFormatProperties) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceFormatProperties2-physicalDevice-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceImageFormatProperties2(
|
|
VkPhysicalDevice physicalDevice,
|
|
const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
|
|
VkImageFormatProperties2* pImageFormatProperties) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceImageFormatProperties2-physicalDevice-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceMemoryProperties2(
|
|
VkPhysicalDevice physicalDevice,
|
|
VkPhysicalDeviceMemoryProperties2* pMemoryProperties) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceMemoryProperties2-physicalDevice-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceSparseImageFormatProperties2(
|
|
VkPhysicalDevice physicalDevice,
|
|
const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
|
|
uint32_t* pPropertyCount,
|
|
VkSparseImageFormatProperties2* pProperties) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceSparseImageFormatProperties2-physicalDevice-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateTrimCommandPool(
|
|
VkDevice device,
|
|
VkCommandPool commandPool,
|
|
VkCommandPoolTrimFlags flags) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkTrimCommandPool-device-parameter", kVUIDUndefined);
|
|
skip |= ValidateObject(device, commandPool, kVulkanObjectTypeCommandPool, false, "VUID-vkTrimCommandPool-commandPool-parameter", "VUID-vkTrimCommandPool-commandPool-parent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCreateSamplerYcbcrConversion(
|
|
VkDevice device,
|
|
const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkSamplerYcbcrConversion* pYcbcrConversion) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkCreateSamplerYcbcrConversion-device-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PostCallRecordCreateSamplerYcbcrConversion(
|
|
VkDevice device,
|
|
const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkSamplerYcbcrConversion* pYcbcrConversion,
|
|
VkResult result) {
|
|
if (result != VK_SUCCESS) return;
|
|
CreateObject(device, *pYcbcrConversion, kVulkanObjectTypeSamplerYcbcrConversion, pAllocator);
|
|
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateDestroySamplerYcbcrConversion(
|
|
VkDevice device,
|
|
VkSamplerYcbcrConversion ycbcrConversion,
|
|
const VkAllocationCallbacks* pAllocator) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkDestroySamplerYcbcrConversion-device-parameter", kVUIDUndefined);
|
|
skip |= ValidateObject(device, ycbcrConversion, kVulkanObjectTypeSamplerYcbcrConversion, true, "VUID-vkDestroySamplerYcbcrConversion-ycbcrConversion-parameter", "VUID-vkDestroySamplerYcbcrConversion-ycbcrConversion-parent");
|
|
skip |= ValidateDestroyObject(device, ycbcrConversion, kVulkanObjectTypeSamplerYcbcrConversion, pAllocator, kVUIDUndefined, kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PreCallRecordDestroySamplerYcbcrConversion(
|
|
VkDevice device,
|
|
VkSamplerYcbcrConversion ycbcrConversion,
|
|
const VkAllocationCallbacks* pAllocator) {
|
|
RecordDestroyObject(device, ycbcrConversion, kVulkanObjectTypeSamplerYcbcrConversion);
|
|
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCreateDescriptorUpdateTemplate(
|
|
VkDevice device,
|
|
const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkCreateDescriptorUpdateTemplate-device-parameter", kVUIDUndefined);
|
|
if (pCreateInfo) {
|
|
skip |= ValidateObject(device, pCreateInfo->descriptorSetLayout, kVulkanObjectTypeDescriptorSetLayout, true, "VUID-VkDescriptorUpdateTemplateCreateInfo-descriptorSetLayout-parameter", "VUID-VkDescriptorUpdateTemplateCreateInfo-commonparent");
|
|
skip |= ValidateObject(device, pCreateInfo->pipelineLayout, kVulkanObjectTypePipelineLayout, true, kVUIDUndefined, "VUID-VkDescriptorUpdateTemplateCreateInfo-commonparent");
|
|
}
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PostCallRecordCreateDescriptorUpdateTemplate(
|
|
VkDevice device,
|
|
const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate,
|
|
VkResult result) {
|
|
if (result != VK_SUCCESS) return;
|
|
CreateObject(device, *pDescriptorUpdateTemplate, kVulkanObjectTypeDescriptorUpdateTemplate, pAllocator);
|
|
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateDestroyDescriptorUpdateTemplate(
|
|
VkDevice device,
|
|
VkDescriptorUpdateTemplate descriptorUpdateTemplate,
|
|
const VkAllocationCallbacks* pAllocator) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkDestroyDescriptorUpdateTemplate-device-parameter", kVUIDUndefined);
|
|
skip |= ValidateObject(device, descriptorUpdateTemplate, kVulkanObjectTypeDescriptorUpdateTemplate, true, "VUID-vkDestroyDescriptorUpdateTemplate-descriptorUpdateTemplate-parameter", "VUID-vkDestroyDescriptorUpdateTemplate-descriptorUpdateTemplate-parent");
|
|
skip |= ValidateDestroyObject(device, descriptorUpdateTemplate, kVulkanObjectTypeDescriptorUpdateTemplate, pAllocator, "VUID-vkDestroyDescriptorUpdateTemplate-descriptorSetLayout-00356", "VUID-vkDestroyDescriptorUpdateTemplate-descriptorSetLayout-00357");
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PreCallRecordDestroyDescriptorUpdateTemplate(
|
|
VkDevice device,
|
|
VkDescriptorUpdateTemplate descriptorUpdateTemplate,
|
|
const VkAllocationCallbacks* pAllocator) {
|
|
RecordDestroyObject(device, descriptorUpdateTemplate, kVulkanObjectTypeDescriptorUpdateTemplate);
|
|
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateUpdateDescriptorSetWithTemplate(
|
|
VkDevice device,
|
|
VkDescriptorSet descriptorSet,
|
|
VkDescriptorUpdateTemplate descriptorUpdateTemplate,
|
|
const void* pData) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkUpdateDescriptorSetWithTemplate-device-parameter", kVUIDUndefined);
|
|
skip |= ValidateObject(device, descriptorSet, kVulkanObjectTypeDescriptorSet, false, "VUID-vkUpdateDescriptorSetWithTemplate-descriptorSet-parameter", kVUIDUndefined);
|
|
skip |= ValidateObject(device, descriptorUpdateTemplate, kVulkanObjectTypeDescriptorUpdateTemplate, false, "VUID-vkUpdateDescriptorSetWithTemplate-descriptorUpdateTemplate-parameter", "VUID-vkUpdateDescriptorSetWithTemplate-descriptorUpdateTemplate-parent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceExternalBufferProperties(
|
|
VkPhysicalDevice physicalDevice,
|
|
const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
|
|
VkExternalBufferProperties* pExternalBufferProperties) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceExternalBufferProperties-physicalDevice-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceExternalFenceProperties(
|
|
VkPhysicalDevice physicalDevice,
|
|
const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
|
|
VkExternalFenceProperties* pExternalFenceProperties) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceExternalFenceProperties-physicalDevice-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceExternalSemaphoreProperties(
|
|
VkPhysicalDevice physicalDevice,
|
|
const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
|
|
VkExternalSemaphoreProperties* pExternalSemaphoreProperties) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceExternalSemaphoreProperties-physicalDevice-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateDestroySurfaceKHR(
|
|
VkInstance instance,
|
|
VkSurfaceKHR surface,
|
|
const VkAllocationCallbacks* pAllocator) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(instance, instance, kVulkanObjectTypeInstance, false, "VUID-vkDestroySurfaceKHR-instance-parameter", kVUIDUndefined);
|
|
skip |= ValidateObject(instance, surface, kVulkanObjectTypeSurfaceKHR, true, "VUID-vkDestroySurfaceKHR-surface-parameter", "VUID-vkDestroySurfaceKHR-surface-parent");
|
|
skip |= ValidateDestroyObject(instance, surface, kVulkanObjectTypeSurfaceKHR, pAllocator, "VUID-vkDestroySurfaceKHR-surface-01267", "VUID-vkDestroySurfaceKHR-surface-01268");
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PreCallRecordDestroySurfaceKHR(
|
|
VkInstance instance,
|
|
VkSurfaceKHR surface,
|
|
const VkAllocationCallbacks* pAllocator) {
|
|
RecordDestroyObject(instance, surface, kVulkanObjectTypeSurfaceKHR);
|
|
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceSurfaceSupportKHR(
|
|
VkPhysicalDevice physicalDevice,
|
|
uint32_t queueFamilyIndex,
|
|
VkSurfaceKHR surface,
|
|
VkBool32* pSupported) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceSurfaceSupportKHR-physicalDevice-parameter", "VUID-vkGetPhysicalDeviceSurfaceSupportKHR-commonparent");
|
|
skip |= ValidateObject(physicalDevice, surface, kVulkanObjectTypeSurfaceKHR, false, "VUID-vkGetPhysicalDeviceSurfaceSupportKHR-surface-parameter", "VUID-vkGetPhysicalDeviceSurfaceSupportKHR-commonparent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceSurfaceCapabilitiesKHR(
|
|
VkPhysicalDevice physicalDevice,
|
|
VkSurfaceKHR surface,
|
|
VkSurfaceCapabilitiesKHR* pSurfaceCapabilities) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceSurfaceCapabilitiesKHR-physicalDevice-parameter", "VUID-vkGetPhysicalDeviceSurfaceCapabilitiesKHR-commonparent");
|
|
skip |= ValidateObject(physicalDevice, surface, kVulkanObjectTypeSurfaceKHR, false, "VUID-vkGetPhysicalDeviceSurfaceCapabilitiesKHR-surface-parameter", "VUID-vkGetPhysicalDeviceSurfaceCapabilitiesKHR-commonparent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceSurfaceFormatsKHR(
|
|
VkPhysicalDevice physicalDevice,
|
|
VkSurfaceKHR surface,
|
|
uint32_t* pSurfaceFormatCount,
|
|
VkSurfaceFormatKHR* pSurfaceFormats) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceSurfaceFormatsKHR-physicalDevice-parameter", "VUID-vkGetPhysicalDeviceSurfaceFormatsKHR-commonparent");
|
|
skip |= ValidateObject(physicalDevice, surface, kVulkanObjectTypeSurfaceKHR, false, "VUID-vkGetPhysicalDeviceSurfaceFormatsKHR-surface-parameter", "VUID-vkGetPhysicalDeviceSurfaceFormatsKHR-commonparent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceSurfacePresentModesKHR(
|
|
VkPhysicalDevice physicalDevice,
|
|
VkSurfaceKHR surface,
|
|
uint32_t* pPresentModeCount,
|
|
VkPresentModeKHR* pPresentModes) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceSurfacePresentModesKHR-physicalDevice-parameter", "VUID-vkGetPhysicalDeviceSurfacePresentModesKHR-commonparent");
|
|
skip |= ValidateObject(physicalDevice, surface, kVulkanObjectTypeSurfaceKHR, false, "VUID-vkGetPhysicalDeviceSurfacePresentModesKHR-surface-parameter", "VUID-vkGetPhysicalDeviceSurfacePresentModesKHR-commonparent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCreateSwapchainKHR(
|
|
VkDevice device,
|
|
const VkSwapchainCreateInfoKHR* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkSwapchainKHR* pSwapchain) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkCreateSwapchainKHR-device-parameter", kVUIDUndefined);
|
|
if (pCreateInfo) {
|
|
skip |= ValidateObject(device, pCreateInfo->surface, kVulkanObjectTypeSurfaceKHR, false, "VUID-VkSwapchainCreateInfoKHR-surface-parameter", "VUID-VkSwapchainCreateInfoKHR-commonparent");
|
|
skip |= ValidateObject(device, pCreateInfo->oldSwapchain, kVulkanObjectTypeSwapchainKHR, true, "VUID-VkSwapchainCreateInfoKHR-oldSwapchain-parameter", "VUID-VkSwapchainCreateInfoKHR-oldSwapchain-parent");
|
|
}
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PostCallRecordCreateSwapchainKHR(
|
|
VkDevice device,
|
|
const VkSwapchainCreateInfoKHR* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkSwapchainKHR* pSwapchain,
|
|
VkResult result) {
|
|
if (result != VK_SUCCESS) return;
|
|
CreateObject(device, *pSwapchain, kVulkanObjectTypeSwapchainKHR, pAllocator);
|
|
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateAcquireNextImageKHR(
|
|
VkDevice device,
|
|
VkSwapchainKHR swapchain,
|
|
uint64_t timeout,
|
|
VkSemaphore semaphore,
|
|
VkFence fence,
|
|
uint32_t* pImageIndex) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkAcquireNextImageKHR-device-parameter", "VUID-vkAcquireNextImageKHR-commonparent");
|
|
skip |= ValidateObject(device, swapchain, kVulkanObjectTypeSwapchainKHR, false, "VUID-vkAcquireNextImageKHR-swapchain-parameter", "VUID-vkAcquireNextImageKHR-commonparent");
|
|
skip |= ValidateObject(device, semaphore, kVulkanObjectTypeSemaphore, true, "VUID-vkAcquireNextImageKHR-semaphore-parameter", "VUID-vkAcquireNextImageKHR-semaphore-parent");
|
|
skip |= ValidateObject(device, fence, kVulkanObjectTypeFence, true, "VUID-vkAcquireNextImageKHR-fence-parameter", "VUID-vkAcquireNextImageKHR-fence-parent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateQueuePresentKHR(
|
|
VkQueue queue,
|
|
const VkPresentInfoKHR* pPresentInfo) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(queue, queue, kVulkanObjectTypeQueue, false, "VUID-vkQueuePresentKHR-queue-parameter", kVUIDUndefined);
|
|
if (pPresentInfo) {
|
|
if (pPresentInfo->pWaitSemaphores) {
|
|
for (uint32_t index1 = 0; index1 < pPresentInfo->waitSemaphoreCount; ++index1) {
|
|
skip |= ValidateObject(queue, pPresentInfo->pWaitSemaphores[index1], kVulkanObjectTypeSemaphore, false, "VUID-VkPresentInfoKHR-pWaitSemaphores-parameter", "VUID-VkPresentInfoKHR-commonparent");
|
|
}
|
|
}
|
|
if (pPresentInfo->pSwapchains) {
|
|
for (uint32_t index1 = 0; index1 < pPresentInfo->swapchainCount; ++index1) {
|
|
skip |= ValidateObject(queue, pPresentInfo->pSwapchains[index1], kVulkanObjectTypeSwapchainKHR, false, "VUID-VkPresentInfoKHR-pSwapchains-parameter", "VUID-VkPresentInfoKHR-commonparent");
|
|
}
|
|
}
|
|
}
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetDeviceGroupPresentCapabilitiesKHR(
|
|
VkDevice device,
|
|
VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkGetDeviceGroupPresentCapabilitiesKHR-device-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetDeviceGroupSurfacePresentModesKHR(
|
|
VkDevice device,
|
|
VkSurfaceKHR surface,
|
|
VkDeviceGroupPresentModeFlagsKHR* pModes) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkGetDeviceGroupSurfacePresentModesKHR-device-parameter", "VUID-vkGetDeviceGroupSurfacePresentModesKHR-commonparent");
|
|
skip |= ValidateObject(device, surface, kVulkanObjectTypeSurfaceKHR, false, "VUID-vkGetDeviceGroupSurfacePresentModesKHR-surface-parameter", "VUID-vkGetDeviceGroupSurfacePresentModesKHR-commonparent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetPhysicalDevicePresentRectanglesKHR(
|
|
VkPhysicalDevice physicalDevice,
|
|
VkSurfaceKHR surface,
|
|
uint32_t* pRectCount,
|
|
VkRect2D* pRects) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDevicePresentRectanglesKHR-physicalDevice-parameter", "VUID-vkGetPhysicalDevicePresentRectanglesKHR-commonparent");
|
|
skip |= ValidateObject(physicalDevice, surface, kVulkanObjectTypeSurfaceKHR, false, "VUID-vkGetPhysicalDevicePresentRectanglesKHR-surface-parameter", "VUID-vkGetPhysicalDevicePresentRectanglesKHR-commonparent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateAcquireNextImage2KHR(
|
|
VkDevice device,
|
|
const VkAcquireNextImageInfoKHR* pAcquireInfo,
|
|
uint32_t* pImageIndex) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkAcquireNextImage2KHR-device-parameter", kVUIDUndefined);
|
|
if (pAcquireInfo) {
|
|
skip |= ValidateObject(device, pAcquireInfo->swapchain, kVulkanObjectTypeSwapchainKHR, false, "VUID-VkAcquireNextImageInfoKHR-swapchain-parameter", "VUID-VkAcquireNextImageInfoKHR-commonparent");
|
|
skip |= ValidateObject(device, pAcquireInfo->semaphore, kVulkanObjectTypeSemaphore, true, "VUID-VkAcquireNextImageInfoKHR-semaphore-parameter", "VUID-VkAcquireNextImageInfoKHR-commonparent");
|
|
skip |= ValidateObject(device, pAcquireInfo->fence, kVulkanObjectTypeFence, true, "VUID-VkAcquireNextImageInfoKHR-fence-parameter", "VUID-VkAcquireNextImageInfoKHR-commonparent");
|
|
}
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceDisplayPlanePropertiesKHR(
|
|
VkPhysicalDevice physicalDevice,
|
|
uint32_t* pPropertyCount,
|
|
VkDisplayPlanePropertiesKHR* pProperties) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceDisplayPlanePropertiesKHR-physicalDevice-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetDisplayPlaneSupportedDisplaysKHR(
|
|
VkPhysicalDevice physicalDevice,
|
|
uint32_t planeIndex,
|
|
uint32_t* pDisplayCount,
|
|
VkDisplayKHR* pDisplays) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetDisplayPlaneSupportedDisplaysKHR-physicalDevice-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PostCallRecordGetDisplayPlaneSupportedDisplaysKHR(
|
|
VkPhysicalDevice physicalDevice,
|
|
uint32_t planeIndex,
|
|
uint32_t* pDisplayCount,
|
|
VkDisplayKHR* pDisplays,
|
|
VkResult result) {
|
|
if (result != VK_SUCCESS) return;
|
|
if (pDisplays) {
|
|
for (uint32_t index = 0; index < *pDisplayCount; index++) {
|
|
CreateObject(physicalDevice, pDisplays[index], kVulkanObjectTypeDisplayKHR, nullptr);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCreateDisplayModeKHR(
|
|
VkPhysicalDevice physicalDevice,
|
|
VkDisplayKHR display,
|
|
const VkDisplayModeCreateInfoKHR* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkDisplayModeKHR* pMode) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkCreateDisplayModeKHR-physicalDevice-parameter", kVUIDUndefined);
|
|
skip |= ValidateObject(physicalDevice, display, kVulkanObjectTypeDisplayKHR, false, "VUID-vkCreateDisplayModeKHR-display-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PostCallRecordCreateDisplayModeKHR(
|
|
VkPhysicalDevice physicalDevice,
|
|
VkDisplayKHR display,
|
|
const VkDisplayModeCreateInfoKHR* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkDisplayModeKHR* pMode,
|
|
VkResult result) {
|
|
if (result != VK_SUCCESS) return;
|
|
CreateObject(physicalDevice, *pMode, kVulkanObjectTypeDisplayModeKHR, pAllocator);
|
|
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetDisplayPlaneCapabilitiesKHR(
|
|
VkPhysicalDevice physicalDevice,
|
|
VkDisplayModeKHR mode,
|
|
uint32_t planeIndex,
|
|
VkDisplayPlaneCapabilitiesKHR* pCapabilities) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetDisplayPlaneCapabilitiesKHR-physicalDevice-parameter", kVUIDUndefined);
|
|
skip |= ValidateObject(physicalDevice, mode, kVulkanObjectTypeDisplayModeKHR, false, "VUID-vkGetDisplayPlaneCapabilitiesKHR-mode-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCreateDisplayPlaneSurfaceKHR(
|
|
VkInstance instance,
|
|
const VkDisplaySurfaceCreateInfoKHR* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkSurfaceKHR* pSurface) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(instance, instance, kVulkanObjectTypeInstance, false, "VUID-vkCreateDisplayPlaneSurfaceKHR-instance-parameter", kVUIDUndefined);
|
|
if (pCreateInfo) {
|
|
skip |= ValidateObject(instance, pCreateInfo->displayMode, kVulkanObjectTypeDisplayModeKHR, false, "VUID-VkDisplaySurfaceCreateInfoKHR-displayMode-parameter", kVUIDUndefined);
|
|
}
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PostCallRecordCreateDisplayPlaneSurfaceKHR(
|
|
VkInstance instance,
|
|
const VkDisplaySurfaceCreateInfoKHR* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkSurfaceKHR* pSurface,
|
|
VkResult result) {
|
|
if (result != VK_SUCCESS) return;
|
|
CreateObject(instance, *pSurface, kVulkanObjectTypeSurfaceKHR, pAllocator);
|
|
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCreateSharedSwapchainsKHR(
|
|
VkDevice device,
|
|
uint32_t swapchainCount,
|
|
const VkSwapchainCreateInfoKHR* pCreateInfos,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkSwapchainKHR* pSwapchains) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkCreateSharedSwapchainsKHR-device-parameter", kVUIDUndefined);
|
|
if (pCreateInfos) {
|
|
for (uint32_t index0 = 0; index0 < swapchainCount; ++index0) {
|
|
skip |= ValidateObject(device, pCreateInfos[index0].surface, kVulkanObjectTypeSurfaceKHR, false, "VUID-VkSwapchainCreateInfoKHR-surface-parameter", "VUID-VkSwapchainCreateInfoKHR-commonparent");
|
|
skip |= ValidateObject(device, pCreateInfos[index0].oldSwapchain, kVulkanObjectTypeSwapchainKHR, true, "VUID-VkSwapchainCreateInfoKHR-oldSwapchain-parameter", "VUID-VkSwapchainCreateInfoKHR-oldSwapchain-parent");
|
|
}
|
|
}
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PostCallRecordCreateSharedSwapchainsKHR(
|
|
VkDevice device,
|
|
uint32_t swapchainCount,
|
|
const VkSwapchainCreateInfoKHR* pCreateInfos,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkSwapchainKHR* pSwapchains,
|
|
VkResult result) {
|
|
if (result != VK_SUCCESS) return;
|
|
if (pSwapchains) {
|
|
for (uint32_t index = 0; index < swapchainCount; index++) {
|
|
CreateObject(device, pSwapchains[index], kVulkanObjectTypeSwapchainKHR, pAllocator);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
#ifdef VK_USE_PLATFORM_XLIB_KHR
|
|
|
|
bool ObjectLifetimes::PreCallValidateCreateXlibSurfaceKHR(
|
|
VkInstance instance,
|
|
const VkXlibSurfaceCreateInfoKHR* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkSurfaceKHR* pSurface) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(instance, instance, kVulkanObjectTypeInstance, false, "VUID-vkCreateXlibSurfaceKHR-instance-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PostCallRecordCreateXlibSurfaceKHR(
|
|
VkInstance instance,
|
|
const VkXlibSurfaceCreateInfoKHR* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkSurfaceKHR* pSurface,
|
|
VkResult result) {
|
|
if (result != VK_SUCCESS) return;
|
|
CreateObject(instance, *pSurface, kVulkanObjectTypeSurfaceKHR, pAllocator);
|
|
|
|
}
|
|
#endif // VK_USE_PLATFORM_XLIB_KHR
|
|
|
|
#ifdef VK_USE_PLATFORM_XLIB_KHR
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceXlibPresentationSupportKHR(
|
|
VkPhysicalDevice physicalDevice,
|
|
uint32_t queueFamilyIndex,
|
|
Display* dpy,
|
|
VisualID visualID) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceXlibPresentationSupportKHR-physicalDevice-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
#endif // VK_USE_PLATFORM_XLIB_KHR
|
|
|
|
#ifdef VK_USE_PLATFORM_XCB_KHR
|
|
|
|
bool ObjectLifetimes::PreCallValidateCreateXcbSurfaceKHR(
|
|
VkInstance instance,
|
|
const VkXcbSurfaceCreateInfoKHR* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkSurfaceKHR* pSurface) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(instance, instance, kVulkanObjectTypeInstance, false, "VUID-vkCreateXcbSurfaceKHR-instance-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PostCallRecordCreateXcbSurfaceKHR(
|
|
VkInstance instance,
|
|
const VkXcbSurfaceCreateInfoKHR* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkSurfaceKHR* pSurface,
|
|
VkResult result) {
|
|
if (result != VK_SUCCESS) return;
|
|
CreateObject(instance, *pSurface, kVulkanObjectTypeSurfaceKHR, pAllocator);
|
|
|
|
}
|
|
#endif // VK_USE_PLATFORM_XCB_KHR
|
|
|
|
#ifdef VK_USE_PLATFORM_XCB_KHR
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceXcbPresentationSupportKHR(
|
|
VkPhysicalDevice physicalDevice,
|
|
uint32_t queueFamilyIndex,
|
|
xcb_connection_t* connection,
|
|
xcb_visualid_t visual_id) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceXcbPresentationSupportKHR-physicalDevice-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
#endif // VK_USE_PLATFORM_XCB_KHR
|
|
|
|
#ifdef VK_USE_PLATFORM_WAYLAND_KHR
|
|
|
|
bool ObjectLifetimes::PreCallValidateCreateWaylandSurfaceKHR(
|
|
VkInstance instance,
|
|
const VkWaylandSurfaceCreateInfoKHR* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkSurfaceKHR* pSurface) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(instance, instance, kVulkanObjectTypeInstance, false, "VUID-vkCreateWaylandSurfaceKHR-instance-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PostCallRecordCreateWaylandSurfaceKHR(
|
|
VkInstance instance,
|
|
const VkWaylandSurfaceCreateInfoKHR* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkSurfaceKHR* pSurface,
|
|
VkResult result) {
|
|
if (result != VK_SUCCESS) return;
|
|
CreateObject(instance, *pSurface, kVulkanObjectTypeSurfaceKHR, pAllocator);
|
|
|
|
}
|
|
#endif // VK_USE_PLATFORM_WAYLAND_KHR
|
|
|
|
#ifdef VK_USE_PLATFORM_WAYLAND_KHR
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceWaylandPresentationSupportKHR(
|
|
VkPhysicalDevice physicalDevice,
|
|
uint32_t queueFamilyIndex,
|
|
struct wl_display* display) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceWaylandPresentationSupportKHR-physicalDevice-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
#endif // VK_USE_PLATFORM_WAYLAND_KHR
|
|
|
|
#ifdef VK_USE_PLATFORM_ANDROID_KHR
|
|
|
|
bool ObjectLifetimes::PreCallValidateCreateAndroidSurfaceKHR(
|
|
VkInstance instance,
|
|
const VkAndroidSurfaceCreateInfoKHR* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkSurfaceKHR* pSurface) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(instance, instance, kVulkanObjectTypeInstance, false, "VUID-vkCreateAndroidSurfaceKHR-instance-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PostCallRecordCreateAndroidSurfaceKHR(
|
|
VkInstance instance,
|
|
const VkAndroidSurfaceCreateInfoKHR* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkSurfaceKHR* pSurface,
|
|
VkResult result) {
|
|
if (result != VK_SUCCESS) return;
|
|
CreateObject(instance, *pSurface, kVulkanObjectTypeSurfaceKHR, pAllocator);
|
|
|
|
}
|
|
#endif // VK_USE_PLATFORM_ANDROID_KHR
|
|
|
|
#ifdef VK_USE_PLATFORM_WIN32_KHR
|
|
|
|
bool ObjectLifetimes::PreCallValidateCreateWin32SurfaceKHR(
|
|
VkInstance instance,
|
|
const VkWin32SurfaceCreateInfoKHR* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkSurfaceKHR* pSurface) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(instance, instance, kVulkanObjectTypeInstance, false, "VUID-vkCreateWin32SurfaceKHR-instance-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PostCallRecordCreateWin32SurfaceKHR(
|
|
VkInstance instance,
|
|
const VkWin32SurfaceCreateInfoKHR* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkSurfaceKHR* pSurface,
|
|
VkResult result) {
|
|
if (result != VK_SUCCESS) return;
|
|
CreateObject(instance, *pSurface, kVulkanObjectTypeSurfaceKHR, pAllocator);
|
|
|
|
}
|
|
#endif // VK_USE_PLATFORM_WIN32_KHR
|
|
|
|
#ifdef VK_USE_PLATFORM_WIN32_KHR
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceWin32PresentationSupportKHR(
|
|
VkPhysicalDevice physicalDevice,
|
|
uint32_t queueFamilyIndex) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceWin32PresentationSupportKHR-physicalDevice-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
#endif // VK_USE_PLATFORM_WIN32_KHR
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceFeatures2KHR(
|
|
VkPhysicalDevice physicalDevice,
|
|
VkPhysicalDeviceFeatures2* pFeatures) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceFeatures2-physicalDevice-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceProperties2KHR(
|
|
VkPhysicalDevice physicalDevice,
|
|
VkPhysicalDeviceProperties2* pProperties) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceProperties2-physicalDevice-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceFormatProperties2KHR(
|
|
VkPhysicalDevice physicalDevice,
|
|
VkFormat format,
|
|
VkFormatProperties2* pFormatProperties) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceFormatProperties2-physicalDevice-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceImageFormatProperties2KHR(
|
|
VkPhysicalDevice physicalDevice,
|
|
const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
|
|
VkImageFormatProperties2* pImageFormatProperties) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceImageFormatProperties2-physicalDevice-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceMemoryProperties2KHR(
|
|
VkPhysicalDevice physicalDevice,
|
|
VkPhysicalDeviceMemoryProperties2* pMemoryProperties) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceMemoryProperties2-physicalDevice-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceSparseImageFormatProperties2KHR(
|
|
VkPhysicalDevice physicalDevice,
|
|
const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
|
|
uint32_t* pPropertyCount,
|
|
VkSparseImageFormatProperties2* pProperties) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceSparseImageFormatProperties2-physicalDevice-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetDeviceGroupPeerMemoryFeaturesKHR(
|
|
VkDevice device,
|
|
uint32_t heapIndex,
|
|
uint32_t localDeviceIndex,
|
|
uint32_t remoteDeviceIndex,
|
|
VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkGetDeviceGroupPeerMemoryFeatures-device-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdSetDeviceMaskKHR(
|
|
VkCommandBuffer commandBuffer,
|
|
uint32_t deviceMask) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdSetDeviceMask-commandBuffer-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdDispatchBaseKHR(
|
|
VkCommandBuffer commandBuffer,
|
|
uint32_t baseGroupX,
|
|
uint32_t baseGroupY,
|
|
uint32_t baseGroupZ,
|
|
uint32_t groupCountX,
|
|
uint32_t groupCountY,
|
|
uint32_t groupCountZ) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdDispatchBase-commandBuffer-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateTrimCommandPoolKHR(
|
|
VkDevice device,
|
|
VkCommandPool commandPool,
|
|
VkCommandPoolTrimFlags flags) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkTrimCommandPool-device-parameter", kVUIDUndefined);
|
|
skip |= ValidateObject(device, commandPool, kVulkanObjectTypeCommandPool, false, "VUID-vkTrimCommandPool-commandPool-parameter", "VUID-vkTrimCommandPool-commandPool-parent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateEnumeratePhysicalDeviceGroupsKHR(
|
|
VkInstance instance,
|
|
uint32_t* pPhysicalDeviceGroupCount,
|
|
VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(instance, instance, kVulkanObjectTypeInstance, false, "VUID-vkEnumeratePhysicalDeviceGroups-instance-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceExternalBufferPropertiesKHR(
|
|
VkPhysicalDevice physicalDevice,
|
|
const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
|
|
VkExternalBufferProperties* pExternalBufferProperties) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceExternalBufferProperties-physicalDevice-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
#ifdef VK_USE_PLATFORM_WIN32_KHR
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetMemoryWin32HandleKHR(
|
|
VkDevice device,
|
|
const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo,
|
|
HANDLE* pHandle) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkGetMemoryWin32HandleKHR-device-parameter", kVUIDUndefined);
|
|
if (pGetWin32HandleInfo) {
|
|
skip |= ValidateObject(device, pGetWin32HandleInfo->memory, kVulkanObjectTypeDeviceMemory, false, "VUID-VkMemoryGetWin32HandleInfoKHR-memory-parameter", kVUIDUndefined);
|
|
}
|
|
|
|
return skip;
|
|
}
|
|
#endif // VK_USE_PLATFORM_WIN32_KHR
|
|
|
|
#ifdef VK_USE_PLATFORM_WIN32_KHR
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetMemoryWin32HandlePropertiesKHR(
|
|
VkDevice device,
|
|
VkExternalMemoryHandleTypeFlagBits handleType,
|
|
HANDLE handle,
|
|
VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkGetMemoryWin32HandlePropertiesKHR-device-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
#endif // VK_USE_PLATFORM_WIN32_KHR
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetMemoryFdKHR(
|
|
VkDevice device,
|
|
const VkMemoryGetFdInfoKHR* pGetFdInfo,
|
|
int* pFd) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkGetMemoryFdKHR-device-parameter", kVUIDUndefined);
|
|
if (pGetFdInfo) {
|
|
skip |= ValidateObject(device, pGetFdInfo->memory, kVulkanObjectTypeDeviceMemory, false, "VUID-VkMemoryGetFdInfoKHR-memory-parameter", kVUIDUndefined);
|
|
}
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetMemoryFdPropertiesKHR(
|
|
VkDevice device,
|
|
VkExternalMemoryHandleTypeFlagBits handleType,
|
|
int fd,
|
|
VkMemoryFdPropertiesKHR* pMemoryFdProperties) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkGetMemoryFdPropertiesKHR-device-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceExternalSemaphorePropertiesKHR(
|
|
VkPhysicalDevice physicalDevice,
|
|
const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
|
|
VkExternalSemaphoreProperties* pExternalSemaphoreProperties) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceExternalSemaphoreProperties-physicalDevice-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
#ifdef VK_USE_PLATFORM_WIN32_KHR
|
|
|
|
bool ObjectLifetimes::PreCallValidateImportSemaphoreWin32HandleKHR(
|
|
VkDevice device,
|
|
const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkImportSemaphoreWin32HandleKHR-device-parameter", kVUIDUndefined);
|
|
if (pImportSemaphoreWin32HandleInfo) {
|
|
skip |= ValidateObject(device, pImportSemaphoreWin32HandleInfo->semaphore, kVulkanObjectTypeSemaphore, false, "VUID-VkImportSemaphoreWin32HandleInfoKHR-semaphore-parameter", kVUIDUndefined);
|
|
}
|
|
|
|
return skip;
|
|
}
|
|
#endif // VK_USE_PLATFORM_WIN32_KHR
|
|
|
|
#ifdef VK_USE_PLATFORM_WIN32_KHR
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetSemaphoreWin32HandleKHR(
|
|
VkDevice device,
|
|
const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo,
|
|
HANDLE* pHandle) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkGetSemaphoreWin32HandleKHR-device-parameter", kVUIDUndefined);
|
|
if (pGetWin32HandleInfo) {
|
|
skip |= ValidateObject(device, pGetWin32HandleInfo->semaphore, kVulkanObjectTypeSemaphore, false, "VUID-VkSemaphoreGetWin32HandleInfoKHR-semaphore-parameter", kVUIDUndefined);
|
|
}
|
|
|
|
return skip;
|
|
}
|
|
#endif // VK_USE_PLATFORM_WIN32_KHR
|
|
|
|
bool ObjectLifetimes::PreCallValidateImportSemaphoreFdKHR(
|
|
VkDevice device,
|
|
const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkImportSemaphoreFdKHR-device-parameter", kVUIDUndefined);
|
|
if (pImportSemaphoreFdInfo) {
|
|
skip |= ValidateObject(device, pImportSemaphoreFdInfo->semaphore, kVulkanObjectTypeSemaphore, false, "VUID-VkImportSemaphoreFdInfoKHR-semaphore-parameter", kVUIDUndefined);
|
|
}
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetSemaphoreFdKHR(
|
|
VkDevice device,
|
|
const VkSemaphoreGetFdInfoKHR* pGetFdInfo,
|
|
int* pFd) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkGetSemaphoreFdKHR-device-parameter", kVUIDUndefined);
|
|
if (pGetFdInfo) {
|
|
skip |= ValidateObject(device, pGetFdInfo->semaphore, kVulkanObjectTypeSemaphore, false, "VUID-VkSemaphoreGetFdInfoKHR-semaphore-parameter", kVUIDUndefined);
|
|
}
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdPushDescriptorSetWithTemplateKHR(
|
|
VkCommandBuffer commandBuffer,
|
|
VkDescriptorUpdateTemplate descriptorUpdateTemplate,
|
|
VkPipelineLayout layout,
|
|
uint32_t set,
|
|
const void* pData) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdPushDescriptorSetWithTemplateKHR-commandBuffer-parameter", "VUID-vkCmdPushDescriptorSetWithTemplateKHR-commonparent");
|
|
skip |= ValidateObject(commandBuffer, descriptorUpdateTemplate, kVulkanObjectTypeDescriptorUpdateTemplate, false, "VUID-vkCmdPushDescriptorSetWithTemplateKHR-descriptorUpdateTemplate-parameter", "VUID-vkCmdPushDescriptorSetWithTemplateKHR-commonparent");
|
|
skip |= ValidateObject(commandBuffer, layout, kVulkanObjectTypePipelineLayout, false, "VUID-vkCmdPushDescriptorSetWithTemplateKHR-layout-parameter", "VUID-vkCmdPushDescriptorSetWithTemplateKHR-commonparent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCreateDescriptorUpdateTemplateKHR(
|
|
VkDevice device,
|
|
const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkCreateDescriptorUpdateTemplate-device-parameter", kVUIDUndefined);
|
|
if (pCreateInfo) {
|
|
skip |= ValidateObject(device, pCreateInfo->descriptorSetLayout, kVulkanObjectTypeDescriptorSetLayout, true, "VUID-VkDescriptorUpdateTemplateCreateInfo-descriptorSetLayout-parameter", "VUID-VkDescriptorUpdateTemplateCreateInfo-commonparent");
|
|
skip |= ValidateObject(device, pCreateInfo->pipelineLayout, kVulkanObjectTypePipelineLayout, true, kVUIDUndefined, "VUID-VkDescriptorUpdateTemplateCreateInfo-commonparent");
|
|
}
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PostCallRecordCreateDescriptorUpdateTemplateKHR(
|
|
VkDevice device,
|
|
const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate,
|
|
VkResult result) {
|
|
if (result != VK_SUCCESS) return;
|
|
CreateObject(device, *pDescriptorUpdateTemplate, kVulkanObjectTypeDescriptorUpdateTemplate, pAllocator);
|
|
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateDestroyDescriptorUpdateTemplateKHR(
|
|
VkDevice device,
|
|
VkDescriptorUpdateTemplate descriptorUpdateTemplate,
|
|
const VkAllocationCallbacks* pAllocator) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkDestroyDescriptorUpdateTemplate-device-parameter", kVUIDUndefined);
|
|
skip |= ValidateObject(device, descriptorUpdateTemplate, kVulkanObjectTypeDescriptorUpdateTemplate, true, "VUID-vkDestroyDescriptorUpdateTemplate-descriptorUpdateTemplate-parameter", "VUID-vkDestroyDescriptorUpdateTemplate-descriptorUpdateTemplate-parent");
|
|
skip |= ValidateDestroyObject(device, descriptorUpdateTemplate, kVulkanObjectTypeDescriptorUpdateTemplate, pAllocator, "VUID-vkDestroyDescriptorUpdateTemplate-descriptorSetLayout-00356", "VUID-vkDestroyDescriptorUpdateTemplate-descriptorSetLayout-00357");
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PreCallRecordDestroyDescriptorUpdateTemplateKHR(
|
|
VkDevice device,
|
|
VkDescriptorUpdateTemplate descriptorUpdateTemplate,
|
|
const VkAllocationCallbacks* pAllocator) {
|
|
RecordDestroyObject(device, descriptorUpdateTemplate, kVulkanObjectTypeDescriptorUpdateTemplate);
|
|
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateUpdateDescriptorSetWithTemplateKHR(
|
|
VkDevice device,
|
|
VkDescriptorSet descriptorSet,
|
|
VkDescriptorUpdateTemplate descriptorUpdateTemplate,
|
|
const void* pData) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkUpdateDescriptorSetWithTemplate-device-parameter", kVUIDUndefined);
|
|
skip |= ValidateObject(device, descriptorSet, kVulkanObjectTypeDescriptorSet, false, "VUID-vkUpdateDescriptorSetWithTemplate-descriptorSet-parameter", kVUIDUndefined);
|
|
skip |= ValidateObject(device, descriptorUpdateTemplate, kVulkanObjectTypeDescriptorUpdateTemplate, false, "VUID-vkUpdateDescriptorSetWithTemplate-descriptorUpdateTemplate-parameter", "VUID-vkUpdateDescriptorSetWithTemplate-descriptorUpdateTemplate-parent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCreateRenderPass2KHR(
|
|
VkDevice device,
|
|
const VkRenderPassCreateInfo2KHR* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkRenderPass* pRenderPass) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkCreateRenderPass2KHR-device-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PostCallRecordCreateRenderPass2KHR(
|
|
VkDevice device,
|
|
const VkRenderPassCreateInfo2KHR* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkRenderPass* pRenderPass,
|
|
VkResult result) {
|
|
if (result != VK_SUCCESS) return;
|
|
CreateObject(device, *pRenderPass, kVulkanObjectTypeRenderPass, pAllocator);
|
|
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdBeginRenderPass2KHR(
|
|
VkCommandBuffer commandBuffer,
|
|
const VkRenderPassBeginInfo* pRenderPassBegin,
|
|
const VkSubpassBeginInfoKHR* pSubpassBeginInfo) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdBeginRenderPass2KHR-commandBuffer-parameter", kVUIDUndefined);
|
|
if (pRenderPassBegin) {
|
|
skip |= ValidateObject(commandBuffer, pRenderPassBegin->renderPass, kVulkanObjectTypeRenderPass, false, "VUID-VkRenderPassBeginInfo-renderPass-parameter", "VUID-VkRenderPassBeginInfo-commonparent");
|
|
skip |= ValidateObject(commandBuffer, pRenderPassBegin->framebuffer, kVulkanObjectTypeFramebuffer, false, "VUID-VkRenderPassBeginInfo-framebuffer-parameter", "VUID-VkRenderPassBeginInfo-commonparent");
|
|
}
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdNextSubpass2KHR(
|
|
VkCommandBuffer commandBuffer,
|
|
const VkSubpassBeginInfoKHR* pSubpassBeginInfo,
|
|
const VkSubpassEndInfoKHR* pSubpassEndInfo) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdNextSubpass2KHR-commandBuffer-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdEndRenderPass2KHR(
|
|
VkCommandBuffer commandBuffer,
|
|
const VkSubpassEndInfoKHR* pSubpassEndInfo) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdEndRenderPass2KHR-commandBuffer-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetSwapchainStatusKHR(
|
|
VkDevice device,
|
|
VkSwapchainKHR swapchain) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkGetSwapchainStatusKHR-device-parameter", "VUID-vkGetSwapchainStatusKHR-commonparent");
|
|
skip |= ValidateObject(device, swapchain, kVulkanObjectTypeSwapchainKHR, false, "VUID-vkGetSwapchainStatusKHR-swapchain-parameter", "VUID-vkGetSwapchainStatusKHR-commonparent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceExternalFencePropertiesKHR(
|
|
VkPhysicalDevice physicalDevice,
|
|
const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
|
|
VkExternalFenceProperties* pExternalFenceProperties) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceExternalFenceProperties-physicalDevice-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
#ifdef VK_USE_PLATFORM_WIN32_KHR
|
|
|
|
bool ObjectLifetimes::PreCallValidateImportFenceWin32HandleKHR(
|
|
VkDevice device,
|
|
const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkImportFenceWin32HandleKHR-device-parameter", kVUIDUndefined);
|
|
if (pImportFenceWin32HandleInfo) {
|
|
skip |= ValidateObject(device, pImportFenceWin32HandleInfo->fence, kVulkanObjectTypeFence, false, "VUID-VkImportFenceWin32HandleInfoKHR-fence-parameter", kVUIDUndefined);
|
|
}
|
|
|
|
return skip;
|
|
}
|
|
#endif // VK_USE_PLATFORM_WIN32_KHR
|
|
|
|
#ifdef VK_USE_PLATFORM_WIN32_KHR
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetFenceWin32HandleKHR(
|
|
VkDevice device,
|
|
const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo,
|
|
HANDLE* pHandle) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkGetFenceWin32HandleKHR-device-parameter", kVUIDUndefined);
|
|
if (pGetWin32HandleInfo) {
|
|
skip |= ValidateObject(device, pGetWin32HandleInfo->fence, kVulkanObjectTypeFence, false, "VUID-VkFenceGetWin32HandleInfoKHR-fence-parameter", kVUIDUndefined);
|
|
}
|
|
|
|
return skip;
|
|
}
|
|
#endif // VK_USE_PLATFORM_WIN32_KHR
|
|
|
|
bool ObjectLifetimes::PreCallValidateImportFenceFdKHR(
|
|
VkDevice device,
|
|
const VkImportFenceFdInfoKHR* pImportFenceFdInfo) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkImportFenceFdKHR-device-parameter", kVUIDUndefined);
|
|
if (pImportFenceFdInfo) {
|
|
skip |= ValidateObject(device, pImportFenceFdInfo->fence, kVulkanObjectTypeFence, false, "VUID-VkImportFenceFdInfoKHR-fence-parameter", kVUIDUndefined);
|
|
}
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetFenceFdKHR(
|
|
VkDevice device,
|
|
const VkFenceGetFdInfoKHR* pGetFdInfo,
|
|
int* pFd) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkGetFenceFdKHR-device-parameter", kVUIDUndefined);
|
|
if (pGetFdInfo) {
|
|
skip |= ValidateObject(device, pGetFdInfo->fence, kVulkanObjectTypeFence, false, "VUID-VkFenceGetFdInfoKHR-fence-parameter", kVUIDUndefined);
|
|
}
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceSurfaceCapabilities2KHR(
|
|
VkPhysicalDevice physicalDevice,
|
|
const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
|
|
VkSurfaceCapabilities2KHR* pSurfaceCapabilities) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceSurfaceCapabilities2KHR-physicalDevice-parameter", kVUIDUndefined);
|
|
if (pSurfaceInfo) {
|
|
skip |= ValidateObject(physicalDevice, pSurfaceInfo->surface, kVulkanObjectTypeSurfaceKHR, false, "VUID-VkPhysicalDeviceSurfaceInfo2KHR-surface-parameter", kVUIDUndefined);
|
|
}
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceSurfaceFormats2KHR(
|
|
VkPhysicalDevice physicalDevice,
|
|
const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
|
|
uint32_t* pSurfaceFormatCount,
|
|
VkSurfaceFormat2KHR* pSurfaceFormats) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceSurfaceFormats2KHR-physicalDevice-parameter", kVUIDUndefined);
|
|
if (pSurfaceInfo) {
|
|
skip |= ValidateObject(physicalDevice, pSurfaceInfo->surface, kVulkanObjectTypeSurfaceKHR, false, "VUID-VkPhysicalDeviceSurfaceInfo2KHR-surface-parameter", kVUIDUndefined);
|
|
}
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceDisplayPlaneProperties2KHR(
|
|
VkPhysicalDevice physicalDevice,
|
|
uint32_t* pPropertyCount,
|
|
VkDisplayPlaneProperties2KHR* pProperties) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceDisplayPlaneProperties2KHR-physicalDevice-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetDisplayPlaneCapabilities2KHR(
|
|
VkPhysicalDevice physicalDevice,
|
|
const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo,
|
|
VkDisplayPlaneCapabilities2KHR* pCapabilities) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetDisplayPlaneCapabilities2KHR-physicalDevice-parameter", kVUIDUndefined);
|
|
if (pDisplayPlaneInfo) {
|
|
skip |= ValidateObject(physicalDevice, pDisplayPlaneInfo->mode, kVulkanObjectTypeDisplayModeKHR, false, "VUID-VkDisplayPlaneInfo2KHR-mode-parameter", kVUIDUndefined);
|
|
}
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetImageMemoryRequirements2KHR(
|
|
VkDevice device,
|
|
const VkImageMemoryRequirementsInfo2* pInfo,
|
|
VkMemoryRequirements2* pMemoryRequirements) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkGetImageMemoryRequirements2-device-parameter", kVUIDUndefined);
|
|
if (pInfo) {
|
|
skip |= ValidateObject(device, pInfo->image, kVulkanObjectTypeImage, false, "VUID-VkImageMemoryRequirementsInfo2-image-parameter", kVUIDUndefined);
|
|
}
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetBufferMemoryRequirements2KHR(
|
|
VkDevice device,
|
|
const VkBufferMemoryRequirementsInfo2* pInfo,
|
|
VkMemoryRequirements2* pMemoryRequirements) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkGetBufferMemoryRequirements2-device-parameter", kVUIDUndefined);
|
|
if (pInfo) {
|
|
skip |= ValidateObject(device, pInfo->buffer, kVulkanObjectTypeBuffer, false, "VUID-VkBufferMemoryRequirementsInfo2-buffer-parameter", kVUIDUndefined);
|
|
}
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetImageSparseMemoryRequirements2KHR(
|
|
VkDevice device,
|
|
const VkImageSparseMemoryRequirementsInfo2* pInfo,
|
|
uint32_t* pSparseMemoryRequirementCount,
|
|
VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkGetImageSparseMemoryRequirements2-device-parameter", kVUIDUndefined);
|
|
if (pInfo) {
|
|
skip |= ValidateObject(device, pInfo->image, kVulkanObjectTypeImage, false, "VUID-VkImageSparseMemoryRequirementsInfo2-image-parameter", kVUIDUndefined);
|
|
}
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCreateSamplerYcbcrConversionKHR(
|
|
VkDevice device,
|
|
const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkSamplerYcbcrConversion* pYcbcrConversion) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkCreateSamplerYcbcrConversion-device-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PostCallRecordCreateSamplerYcbcrConversionKHR(
|
|
VkDevice device,
|
|
const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkSamplerYcbcrConversion* pYcbcrConversion,
|
|
VkResult result) {
|
|
if (result != VK_SUCCESS) return;
|
|
CreateObject(device, *pYcbcrConversion, kVulkanObjectTypeSamplerYcbcrConversion, pAllocator);
|
|
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateDestroySamplerYcbcrConversionKHR(
|
|
VkDevice device,
|
|
VkSamplerYcbcrConversion ycbcrConversion,
|
|
const VkAllocationCallbacks* pAllocator) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkDestroySamplerYcbcrConversion-device-parameter", kVUIDUndefined);
|
|
skip |= ValidateObject(device, ycbcrConversion, kVulkanObjectTypeSamplerYcbcrConversion, true, "VUID-vkDestroySamplerYcbcrConversion-ycbcrConversion-parameter", "VUID-vkDestroySamplerYcbcrConversion-ycbcrConversion-parent");
|
|
skip |= ValidateDestroyObject(device, ycbcrConversion, kVulkanObjectTypeSamplerYcbcrConversion, pAllocator, kVUIDUndefined, kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PreCallRecordDestroySamplerYcbcrConversionKHR(
|
|
VkDevice device,
|
|
VkSamplerYcbcrConversion ycbcrConversion,
|
|
const VkAllocationCallbacks* pAllocator) {
|
|
RecordDestroyObject(device, ycbcrConversion, kVulkanObjectTypeSamplerYcbcrConversion);
|
|
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateBindBufferMemory2KHR(
|
|
VkDevice device,
|
|
uint32_t bindInfoCount,
|
|
const VkBindBufferMemoryInfo* pBindInfos) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkBindBufferMemory2-device-parameter", kVUIDUndefined);
|
|
if (pBindInfos) {
|
|
for (uint32_t index0 = 0; index0 < bindInfoCount; ++index0) {
|
|
skip |= ValidateObject(device, pBindInfos[index0].buffer, kVulkanObjectTypeBuffer, false, "VUID-VkBindBufferMemoryInfo-buffer-parameter", "VUID-VkBindBufferMemoryInfo-commonparent");
|
|
skip |= ValidateObject(device, pBindInfos[index0].memory, kVulkanObjectTypeDeviceMemory, false, "VUID-VkBindBufferMemoryInfo-memory-parameter", "VUID-VkBindBufferMemoryInfo-commonparent");
|
|
}
|
|
}
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateBindImageMemory2KHR(
|
|
VkDevice device,
|
|
uint32_t bindInfoCount,
|
|
const VkBindImageMemoryInfo* pBindInfos) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkBindImageMemory2-device-parameter", kVUIDUndefined);
|
|
if (pBindInfos) {
|
|
for (uint32_t index0 = 0; index0 < bindInfoCount; ++index0) {
|
|
skip |= ValidateObject(device, pBindInfos[index0].image, kVulkanObjectTypeImage, false, "VUID-VkBindImageMemoryInfo-image-parameter", "VUID-VkBindImageMemoryInfo-commonparent");
|
|
skip |= ValidateObject(device, pBindInfos[index0].memory, kVulkanObjectTypeDeviceMemory, true, kVUIDUndefined, "VUID-VkBindImageMemoryInfo-commonparent");
|
|
}
|
|
}
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdDrawIndirectCountKHR(
|
|
VkCommandBuffer commandBuffer,
|
|
VkBuffer buffer,
|
|
VkDeviceSize offset,
|
|
VkBuffer countBuffer,
|
|
VkDeviceSize countBufferOffset,
|
|
uint32_t maxDrawCount,
|
|
uint32_t stride) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdDrawIndirectCountKHR-commandBuffer-parameter", "VUID-vkCmdDrawIndirectCountKHR-commonparent");
|
|
skip |= ValidateObject(commandBuffer, buffer, kVulkanObjectTypeBuffer, false, "VUID-vkCmdDrawIndirectCountKHR-buffer-parameter", "VUID-vkCmdDrawIndirectCountKHR-commonparent");
|
|
skip |= ValidateObject(commandBuffer, countBuffer, kVulkanObjectTypeBuffer, false, "VUID-vkCmdDrawIndirectCountKHR-countBuffer-parameter", "VUID-vkCmdDrawIndirectCountKHR-commonparent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdDrawIndexedIndirectCountKHR(
|
|
VkCommandBuffer commandBuffer,
|
|
VkBuffer buffer,
|
|
VkDeviceSize offset,
|
|
VkBuffer countBuffer,
|
|
VkDeviceSize countBufferOffset,
|
|
uint32_t maxDrawCount,
|
|
uint32_t stride) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdDrawIndexedIndirectCountKHR-commandBuffer-parameter", "VUID-vkCmdDrawIndexedIndirectCountKHR-commonparent");
|
|
skip |= ValidateObject(commandBuffer, buffer, kVulkanObjectTypeBuffer, false, "VUID-vkCmdDrawIndexedIndirectCountKHR-buffer-parameter", "VUID-vkCmdDrawIndexedIndirectCountKHR-commonparent");
|
|
skip |= ValidateObject(commandBuffer, countBuffer, kVulkanObjectTypeBuffer, false, "VUID-vkCmdDrawIndexedIndirectCountKHR-countBuffer-parameter", "VUID-vkCmdDrawIndexedIndirectCountKHR-commonparent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetPipelineExecutablePropertiesKHR(
|
|
VkDevice device,
|
|
const VkPipelineInfoKHR* pPipelineInfo,
|
|
uint32_t* pExecutableCount,
|
|
VkPipelineExecutablePropertiesKHR* pProperties) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkGetPipelineExecutablePropertiesKHR-device-parameter", kVUIDUndefined);
|
|
if (pPipelineInfo) {
|
|
skip |= ValidateObject(device, pPipelineInfo->pipeline, kVulkanObjectTypePipeline, false, "VUID-VkPipelineInfoKHR-pipeline-parameter", kVUIDUndefined);
|
|
}
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetPipelineExecutableStatisticsKHR(
|
|
VkDevice device,
|
|
const VkPipelineExecutableInfoKHR* pExecutableInfo,
|
|
uint32_t* pStatisticCount,
|
|
VkPipelineExecutableStatisticKHR* pStatistics) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkGetPipelineExecutableStatisticsKHR-device-parameter", kVUIDUndefined);
|
|
if (pExecutableInfo) {
|
|
skip |= ValidateObject(device, pExecutableInfo->pipeline, kVulkanObjectTypePipeline, false, "VUID-VkPipelineExecutableInfoKHR-pipeline-parameter", kVUIDUndefined);
|
|
}
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetPipelineExecutableInternalRepresentationsKHR(
|
|
VkDevice device,
|
|
const VkPipelineExecutableInfoKHR* pExecutableInfo,
|
|
uint32_t* pInternalRepresentationCount,
|
|
VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkGetPipelineExecutableInternalRepresentationsKHR-device-parameter", kVUIDUndefined);
|
|
if (pExecutableInfo) {
|
|
skip |= ValidateObject(device, pExecutableInfo->pipeline, kVulkanObjectTypePipeline, false, "VUID-VkPipelineExecutableInfoKHR-pipeline-parameter", kVUIDUndefined);
|
|
}
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCreateDebugReportCallbackEXT(
|
|
VkInstance instance,
|
|
const VkDebugReportCallbackCreateInfoEXT* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkDebugReportCallbackEXT* pCallback) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(instance, instance, kVulkanObjectTypeInstance, false, "VUID-vkCreateDebugReportCallbackEXT-instance-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PostCallRecordCreateDebugReportCallbackEXT(
|
|
VkInstance instance,
|
|
const VkDebugReportCallbackCreateInfoEXT* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkDebugReportCallbackEXT* pCallback,
|
|
VkResult result) {
|
|
if (result != VK_SUCCESS) return;
|
|
CreateObject(instance, *pCallback, kVulkanObjectTypeDebugReportCallbackEXT, pAllocator);
|
|
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateDestroyDebugReportCallbackEXT(
|
|
VkInstance instance,
|
|
VkDebugReportCallbackEXT callback,
|
|
const VkAllocationCallbacks* pAllocator) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(instance, instance, kVulkanObjectTypeInstance, false, "VUID-vkDestroyDebugReportCallbackEXT-instance-parameter", kVUIDUndefined);
|
|
skip |= ValidateObject(instance, callback, kVulkanObjectTypeDebugReportCallbackEXT, false, "VUID-vkDestroyDebugReportCallbackEXT-callback-parameter", "VUID-vkDestroyDebugReportCallbackEXT-callback-parent");
|
|
skip |= ValidateDestroyObject(instance, callback, kVulkanObjectTypeDebugReportCallbackEXT, pAllocator, kVUIDUndefined, kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PreCallRecordDestroyDebugReportCallbackEXT(
|
|
VkInstance instance,
|
|
VkDebugReportCallbackEXT callback,
|
|
const VkAllocationCallbacks* pAllocator) {
|
|
RecordDestroyObject(instance, callback, kVulkanObjectTypeDebugReportCallbackEXT);
|
|
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateDebugReportMessageEXT(
|
|
VkInstance instance,
|
|
VkDebugReportFlagsEXT flags,
|
|
VkDebugReportObjectTypeEXT objectType,
|
|
uint64_t object,
|
|
size_t location,
|
|
int32_t messageCode,
|
|
const char* pLayerPrefix,
|
|
const char* pMessage) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(instance, instance, kVulkanObjectTypeInstance, false, "VUID-vkDebugReportMessageEXT-instance-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateDebugMarkerSetObjectTagEXT(
|
|
VkDevice device,
|
|
const VkDebugMarkerObjectTagInfoEXT* pTagInfo) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkDebugMarkerSetObjectTagEXT-device-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateDebugMarkerSetObjectNameEXT(
|
|
VkDevice device,
|
|
const VkDebugMarkerObjectNameInfoEXT* pNameInfo) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkDebugMarkerSetObjectNameEXT-device-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdDebugMarkerBeginEXT(
|
|
VkCommandBuffer commandBuffer,
|
|
const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdDebugMarkerBeginEXT-commandBuffer-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdDebugMarkerEndEXT(
|
|
VkCommandBuffer commandBuffer) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdDebugMarkerEndEXT-commandBuffer-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdDebugMarkerInsertEXT(
|
|
VkCommandBuffer commandBuffer,
|
|
const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdDebugMarkerInsertEXT-commandBuffer-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdBindTransformFeedbackBuffersEXT(
|
|
VkCommandBuffer commandBuffer,
|
|
uint32_t firstBinding,
|
|
uint32_t bindingCount,
|
|
const VkBuffer* pBuffers,
|
|
const VkDeviceSize* pOffsets,
|
|
const VkDeviceSize* pSizes) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdBindTransformFeedbackBuffersEXT-commandBuffer-parameter", "VUID-vkCmdBindTransformFeedbackBuffersEXT-commonparent");
|
|
if (pBuffers) {
|
|
for (uint32_t index0 = 0; index0 < bindingCount; ++index0) {
|
|
skip |= ValidateObject(commandBuffer, pBuffers[index0], kVulkanObjectTypeBuffer, false, "VUID-vkCmdBindTransformFeedbackBuffersEXT-pBuffers-parameter", "VUID-vkCmdBindTransformFeedbackBuffersEXT-commonparent");
|
|
}
|
|
}
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdBeginTransformFeedbackEXT(
|
|
VkCommandBuffer commandBuffer,
|
|
uint32_t firstCounterBuffer,
|
|
uint32_t counterBufferCount,
|
|
const VkBuffer* pCounterBuffers,
|
|
const VkDeviceSize* pCounterBufferOffsets) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdBeginTransformFeedbackEXT-commandBuffer-parameter", "VUID-vkCmdBeginTransformFeedbackEXT-commonparent");
|
|
if (pCounterBuffers) {
|
|
for (uint32_t index0 = 0; index0 < counterBufferCount; ++index0) {
|
|
skip |= ValidateObject(commandBuffer, pCounterBuffers[index0], kVulkanObjectTypeBuffer, true, kVUIDUndefined, "VUID-vkCmdBeginTransformFeedbackEXT-commonparent");
|
|
}
|
|
}
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdEndTransformFeedbackEXT(
|
|
VkCommandBuffer commandBuffer,
|
|
uint32_t firstCounterBuffer,
|
|
uint32_t counterBufferCount,
|
|
const VkBuffer* pCounterBuffers,
|
|
const VkDeviceSize* pCounterBufferOffsets) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdEndTransformFeedbackEXT-commandBuffer-parameter", "VUID-vkCmdEndTransformFeedbackEXT-commonparent");
|
|
if (pCounterBuffers) {
|
|
for (uint32_t index0 = 0; index0 < counterBufferCount; ++index0) {
|
|
skip |= ValidateObject(commandBuffer, pCounterBuffers[index0], kVulkanObjectTypeBuffer, true, kVUIDUndefined, "VUID-vkCmdEndTransformFeedbackEXT-commonparent");
|
|
}
|
|
}
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdBeginQueryIndexedEXT(
|
|
VkCommandBuffer commandBuffer,
|
|
VkQueryPool queryPool,
|
|
uint32_t query,
|
|
VkQueryControlFlags flags,
|
|
uint32_t index) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdBeginQueryIndexedEXT-commandBuffer-parameter", "VUID-vkCmdBeginQueryIndexedEXT-commonparent");
|
|
skip |= ValidateObject(commandBuffer, queryPool, kVulkanObjectTypeQueryPool, false, "VUID-vkCmdBeginQueryIndexedEXT-queryPool-parameter", "VUID-vkCmdBeginQueryIndexedEXT-commonparent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdEndQueryIndexedEXT(
|
|
VkCommandBuffer commandBuffer,
|
|
VkQueryPool queryPool,
|
|
uint32_t query,
|
|
uint32_t index) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdEndQueryIndexedEXT-commandBuffer-parameter", "VUID-vkCmdEndQueryIndexedEXT-commonparent");
|
|
skip |= ValidateObject(commandBuffer, queryPool, kVulkanObjectTypeQueryPool, false, "VUID-vkCmdEndQueryIndexedEXT-queryPool-parameter", "VUID-vkCmdEndQueryIndexedEXT-commonparent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdDrawIndirectByteCountEXT(
|
|
VkCommandBuffer commandBuffer,
|
|
uint32_t instanceCount,
|
|
uint32_t firstInstance,
|
|
VkBuffer counterBuffer,
|
|
VkDeviceSize counterBufferOffset,
|
|
uint32_t counterOffset,
|
|
uint32_t vertexStride) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdDrawIndirectByteCountEXT-commandBuffer-parameter", "VUID-vkCmdDrawIndirectByteCountEXT-commonparent");
|
|
skip |= ValidateObject(commandBuffer, counterBuffer, kVulkanObjectTypeBuffer, false, "VUID-vkCmdDrawIndirectByteCountEXT-counterBuffer-parameter", "VUID-vkCmdDrawIndirectByteCountEXT-commonparent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetImageViewHandleNVX(
|
|
VkDevice device,
|
|
const VkImageViewHandleInfoNVX* pInfo) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkGetImageViewHandleNVX-device-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdDrawIndirectCountAMD(
|
|
VkCommandBuffer commandBuffer,
|
|
VkBuffer buffer,
|
|
VkDeviceSize offset,
|
|
VkBuffer countBuffer,
|
|
VkDeviceSize countBufferOffset,
|
|
uint32_t maxDrawCount,
|
|
uint32_t stride) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdDrawIndirectCountKHR-commandBuffer-parameter", "VUID-vkCmdDrawIndirectCountKHR-commonparent");
|
|
skip |= ValidateObject(commandBuffer, buffer, kVulkanObjectTypeBuffer, false, "VUID-vkCmdDrawIndirectCountKHR-buffer-parameter", "VUID-vkCmdDrawIndirectCountKHR-commonparent");
|
|
skip |= ValidateObject(commandBuffer, countBuffer, kVulkanObjectTypeBuffer, false, "VUID-vkCmdDrawIndirectCountKHR-countBuffer-parameter", "VUID-vkCmdDrawIndirectCountKHR-commonparent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdDrawIndexedIndirectCountAMD(
|
|
VkCommandBuffer commandBuffer,
|
|
VkBuffer buffer,
|
|
VkDeviceSize offset,
|
|
VkBuffer countBuffer,
|
|
VkDeviceSize countBufferOffset,
|
|
uint32_t maxDrawCount,
|
|
uint32_t stride) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdDrawIndexedIndirectCountKHR-commandBuffer-parameter", "VUID-vkCmdDrawIndexedIndirectCountKHR-commonparent");
|
|
skip |= ValidateObject(commandBuffer, buffer, kVulkanObjectTypeBuffer, false, "VUID-vkCmdDrawIndexedIndirectCountKHR-buffer-parameter", "VUID-vkCmdDrawIndexedIndirectCountKHR-commonparent");
|
|
skip |= ValidateObject(commandBuffer, countBuffer, kVulkanObjectTypeBuffer, false, "VUID-vkCmdDrawIndexedIndirectCountKHR-countBuffer-parameter", "VUID-vkCmdDrawIndexedIndirectCountKHR-commonparent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetShaderInfoAMD(
|
|
VkDevice device,
|
|
VkPipeline pipeline,
|
|
VkShaderStageFlagBits shaderStage,
|
|
VkShaderInfoTypeAMD infoType,
|
|
size_t* pInfoSize,
|
|
void* pInfo) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkGetShaderInfoAMD-device-parameter", kVUIDUndefined);
|
|
skip |= ValidateObject(device, pipeline, kVulkanObjectTypePipeline, false, "VUID-vkGetShaderInfoAMD-pipeline-parameter", "VUID-vkGetShaderInfoAMD-pipeline-parent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
#ifdef VK_USE_PLATFORM_GGP
|
|
|
|
bool ObjectLifetimes::PreCallValidateCreateStreamDescriptorSurfaceGGP(
|
|
VkInstance instance,
|
|
const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkSurfaceKHR* pSurface) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(instance, instance, kVulkanObjectTypeInstance, false, "VUID-vkCreateStreamDescriptorSurfaceGGP-instance-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PostCallRecordCreateStreamDescriptorSurfaceGGP(
|
|
VkInstance instance,
|
|
const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkSurfaceKHR* pSurface,
|
|
VkResult result) {
|
|
if (result != VK_SUCCESS) return;
|
|
CreateObject(instance, *pSurface, kVulkanObjectTypeSurfaceKHR, pAllocator);
|
|
|
|
}
|
|
#endif // VK_USE_PLATFORM_GGP
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceExternalImageFormatPropertiesNV(
|
|
VkPhysicalDevice physicalDevice,
|
|
VkFormat format,
|
|
VkImageType type,
|
|
VkImageTiling tiling,
|
|
VkImageUsageFlags usage,
|
|
VkImageCreateFlags flags,
|
|
VkExternalMemoryHandleTypeFlagsNV externalHandleType,
|
|
VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-physicalDevice-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
#ifdef VK_USE_PLATFORM_WIN32_KHR
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetMemoryWin32HandleNV(
|
|
VkDevice device,
|
|
VkDeviceMemory memory,
|
|
VkExternalMemoryHandleTypeFlagsNV handleType,
|
|
HANDLE* pHandle) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkGetMemoryWin32HandleNV-device-parameter", kVUIDUndefined);
|
|
skip |= ValidateObject(device, memory, kVulkanObjectTypeDeviceMemory, false, "VUID-vkGetMemoryWin32HandleNV-memory-parameter", "VUID-vkGetMemoryWin32HandleNV-memory-parent");
|
|
|
|
return skip;
|
|
}
|
|
#endif // VK_USE_PLATFORM_WIN32_KHR
|
|
|
|
#ifdef VK_USE_PLATFORM_VI_NN
|
|
|
|
bool ObjectLifetimes::PreCallValidateCreateViSurfaceNN(
|
|
VkInstance instance,
|
|
const VkViSurfaceCreateInfoNN* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkSurfaceKHR* pSurface) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(instance, instance, kVulkanObjectTypeInstance, false, "VUID-vkCreateViSurfaceNN-instance-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PostCallRecordCreateViSurfaceNN(
|
|
VkInstance instance,
|
|
const VkViSurfaceCreateInfoNN* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkSurfaceKHR* pSurface,
|
|
VkResult result) {
|
|
if (result != VK_SUCCESS) return;
|
|
CreateObject(instance, *pSurface, kVulkanObjectTypeSurfaceKHR, pAllocator);
|
|
|
|
}
|
|
#endif // VK_USE_PLATFORM_VI_NN
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdBeginConditionalRenderingEXT(
|
|
VkCommandBuffer commandBuffer,
|
|
const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdBeginConditionalRenderingEXT-commandBuffer-parameter", kVUIDUndefined);
|
|
if (pConditionalRenderingBegin) {
|
|
skip |= ValidateObject(commandBuffer, pConditionalRenderingBegin->buffer, kVulkanObjectTypeBuffer, false, "VUID-VkConditionalRenderingBeginInfoEXT-buffer-parameter", kVUIDUndefined);
|
|
}
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdEndConditionalRenderingEXT(
|
|
VkCommandBuffer commandBuffer) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdEndConditionalRenderingEXT-commandBuffer-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdProcessCommandsNVX(
|
|
VkCommandBuffer commandBuffer,
|
|
const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdProcessCommandsNVX-commandBuffer-parameter", kVUIDUndefined);
|
|
if (pProcessCommandsInfo) {
|
|
skip |= ValidateObject(commandBuffer, pProcessCommandsInfo->objectTable, kVulkanObjectTypeObjectTableNVX, false, "VUID-VkCmdProcessCommandsInfoNVX-objectTable-parameter", "VUID-VkCmdProcessCommandsInfoNVX-commonparent");
|
|
skip |= ValidateObject(commandBuffer, pProcessCommandsInfo->indirectCommandsLayout, kVulkanObjectTypeIndirectCommandsLayoutNVX, false, "VUID-VkCmdProcessCommandsInfoNVX-indirectCommandsLayout-parameter", "VUID-VkCmdProcessCommandsInfoNVX-commonparent");
|
|
if (pProcessCommandsInfo->pIndirectCommandsTokens) {
|
|
for (uint32_t index1 = 0; index1 < pProcessCommandsInfo->indirectCommandsTokenCount; ++index1) {
|
|
skip |= ValidateObject(commandBuffer, pProcessCommandsInfo->pIndirectCommandsTokens[index1].buffer, kVulkanObjectTypeBuffer, false, "VUID-VkIndirectCommandsTokenNVX-buffer-parameter", kVUIDUndefined);
|
|
}
|
|
}
|
|
skip |= ValidateObject(commandBuffer, pProcessCommandsInfo->targetCommandBuffer, kVulkanObjectTypeCommandBuffer, true, "VUID-VkCmdProcessCommandsInfoNVX-targetCommandBuffer-parameter", "VUID-VkCmdProcessCommandsInfoNVX-commonparent");
|
|
skip |= ValidateObject(commandBuffer, pProcessCommandsInfo->sequencesCountBuffer, kVulkanObjectTypeBuffer, true, "VUID-VkCmdProcessCommandsInfoNVX-sequencesCountBuffer-parameter", "VUID-VkCmdProcessCommandsInfoNVX-commonparent");
|
|
skip |= ValidateObject(commandBuffer, pProcessCommandsInfo->sequencesIndexBuffer, kVulkanObjectTypeBuffer, true, "VUID-VkCmdProcessCommandsInfoNVX-sequencesIndexBuffer-parameter", "VUID-VkCmdProcessCommandsInfoNVX-commonparent");
|
|
}
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdReserveSpaceForCommandsNVX(
|
|
VkCommandBuffer commandBuffer,
|
|
const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdReserveSpaceForCommandsNVX-commandBuffer-parameter", kVUIDUndefined);
|
|
if (pReserveSpaceInfo) {
|
|
skip |= ValidateObject(commandBuffer, pReserveSpaceInfo->objectTable, kVulkanObjectTypeObjectTableNVX, false, "VUID-VkCmdReserveSpaceForCommandsInfoNVX-objectTable-parameter", "VUID-VkCmdReserveSpaceForCommandsInfoNVX-commonparent");
|
|
skip |= ValidateObject(commandBuffer, pReserveSpaceInfo->indirectCommandsLayout, kVulkanObjectTypeIndirectCommandsLayoutNVX, false, "VUID-VkCmdReserveSpaceForCommandsInfoNVX-indirectCommandsLayout-parameter", "VUID-VkCmdReserveSpaceForCommandsInfoNVX-commonparent");
|
|
}
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCreateIndirectCommandsLayoutNVX(
|
|
VkDevice device,
|
|
const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkCreateIndirectCommandsLayoutNVX-device-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PostCallRecordCreateIndirectCommandsLayoutNVX(
|
|
VkDevice device,
|
|
const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout,
|
|
VkResult result) {
|
|
if (result != VK_SUCCESS) return;
|
|
CreateObject(device, *pIndirectCommandsLayout, kVulkanObjectTypeIndirectCommandsLayoutNVX, pAllocator);
|
|
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateDestroyIndirectCommandsLayoutNVX(
|
|
VkDevice device,
|
|
VkIndirectCommandsLayoutNVX indirectCommandsLayout,
|
|
const VkAllocationCallbacks* pAllocator) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkDestroyIndirectCommandsLayoutNVX-device-parameter", kVUIDUndefined);
|
|
skip |= ValidateObject(device, indirectCommandsLayout, kVulkanObjectTypeIndirectCommandsLayoutNVX, false, "VUID-vkDestroyIndirectCommandsLayoutNVX-indirectCommandsLayout-parameter", "VUID-vkDestroyIndirectCommandsLayoutNVX-indirectCommandsLayout-parent");
|
|
skip |= ValidateDestroyObject(device, indirectCommandsLayout, kVulkanObjectTypeIndirectCommandsLayoutNVX, pAllocator, kVUIDUndefined, kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PreCallRecordDestroyIndirectCommandsLayoutNVX(
|
|
VkDevice device,
|
|
VkIndirectCommandsLayoutNVX indirectCommandsLayout,
|
|
const VkAllocationCallbacks* pAllocator) {
|
|
RecordDestroyObject(device, indirectCommandsLayout, kVulkanObjectTypeIndirectCommandsLayoutNVX);
|
|
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCreateObjectTableNVX(
|
|
VkDevice device,
|
|
const VkObjectTableCreateInfoNVX* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkObjectTableNVX* pObjectTable) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkCreateObjectTableNVX-device-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PostCallRecordCreateObjectTableNVX(
|
|
VkDevice device,
|
|
const VkObjectTableCreateInfoNVX* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkObjectTableNVX* pObjectTable,
|
|
VkResult result) {
|
|
if (result != VK_SUCCESS) return;
|
|
CreateObject(device, *pObjectTable, kVulkanObjectTypeObjectTableNVX, pAllocator);
|
|
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateDestroyObjectTableNVX(
|
|
VkDevice device,
|
|
VkObjectTableNVX objectTable,
|
|
const VkAllocationCallbacks* pAllocator) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkDestroyObjectTableNVX-device-parameter", kVUIDUndefined);
|
|
skip |= ValidateObject(device, objectTable, kVulkanObjectTypeObjectTableNVX, false, "VUID-vkDestroyObjectTableNVX-objectTable-parameter", "VUID-vkDestroyObjectTableNVX-objectTable-parent");
|
|
skip |= ValidateDestroyObject(device, objectTable, kVulkanObjectTypeObjectTableNVX, pAllocator, kVUIDUndefined, kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PreCallRecordDestroyObjectTableNVX(
|
|
VkDevice device,
|
|
VkObjectTableNVX objectTable,
|
|
const VkAllocationCallbacks* pAllocator) {
|
|
RecordDestroyObject(device, objectTable, kVulkanObjectTypeObjectTableNVX);
|
|
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateRegisterObjectsNVX(
|
|
VkDevice device,
|
|
VkObjectTableNVX objectTable,
|
|
uint32_t objectCount,
|
|
const VkObjectTableEntryNVX* const* ppObjectTableEntries,
|
|
const uint32_t* pObjectIndices) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkRegisterObjectsNVX-device-parameter", kVUIDUndefined);
|
|
skip |= ValidateObject(device, objectTable, kVulkanObjectTypeObjectTableNVX, false, "VUID-vkRegisterObjectsNVX-objectTable-parameter", "VUID-vkRegisterObjectsNVX-objectTable-parent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateUnregisterObjectsNVX(
|
|
VkDevice device,
|
|
VkObjectTableNVX objectTable,
|
|
uint32_t objectCount,
|
|
const VkObjectEntryTypeNVX* pObjectEntryTypes,
|
|
const uint32_t* pObjectIndices) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkUnregisterObjectsNVX-device-parameter", kVUIDUndefined);
|
|
skip |= ValidateObject(device, objectTable, kVulkanObjectTypeObjectTableNVX, false, "VUID-vkUnregisterObjectsNVX-objectTable-parameter", "VUID-vkUnregisterObjectsNVX-objectTable-parent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceGeneratedCommandsPropertiesNVX(
|
|
VkPhysicalDevice physicalDevice,
|
|
VkDeviceGeneratedCommandsFeaturesNVX* pFeatures,
|
|
VkDeviceGeneratedCommandsLimitsNVX* pLimits) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX-physicalDevice-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdSetViewportWScalingNV(
|
|
VkCommandBuffer commandBuffer,
|
|
uint32_t firstViewport,
|
|
uint32_t viewportCount,
|
|
const VkViewportWScalingNV* pViewportWScalings) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdSetViewportWScalingNV-commandBuffer-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateReleaseDisplayEXT(
|
|
VkPhysicalDevice physicalDevice,
|
|
VkDisplayKHR display) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkReleaseDisplayEXT-physicalDevice-parameter", kVUIDUndefined);
|
|
skip |= ValidateObject(physicalDevice, display, kVulkanObjectTypeDisplayKHR, false, "VUID-vkReleaseDisplayEXT-display-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
|
|
|
|
bool ObjectLifetimes::PreCallValidateAcquireXlibDisplayEXT(
|
|
VkPhysicalDevice physicalDevice,
|
|
Display* dpy,
|
|
VkDisplayKHR display) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkAcquireXlibDisplayEXT-physicalDevice-parameter", kVUIDUndefined);
|
|
skip |= ValidateObject(physicalDevice, display, kVulkanObjectTypeDisplayKHR, false, "VUID-vkAcquireXlibDisplayEXT-display-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
#endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT
|
|
|
|
#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetRandROutputDisplayEXT(
|
|
VkPhysicalDevice physicalDevice,
|
|
Display* dpy,
|
|
RROutput rrOutput,
|
|
VkDisplayKHR* pDisplay) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetRandROutputDisplayEXT-physicalDevice-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PostCallRecordGetRandROutputDisplayEXT(
|
|
VkPhysicalDevice physicalDevice,
|
|
Display* dpy,
|
|
RROutput rrOutput,
|
|
VkDisplayKHR* pDisplay,
|
|
VkResult result) {
|
|
if (result != VK_SUCCESS) return;
|
|
CreateObject(physicalDevice, *pDisplay, kVulkanObjectTypeDisplayKHR, nullptr);
|
|
|
|
}
|
|
#endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceSurfaceCapabilities2EXT(
|
|
VkPhysicalDevice physicalDevice,
|
|
VkSurfaceKHR surface,
|
|
VkSurfaceCapabilities2EXT* pSurfaceCapabilities) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceSurfaceCapabilities2EXT-physicalDevice-parameter", "VUID-vkGetPhysicalDeviceSurfaceCapabilities2EXT-commonparent");
|
|
skip |= ValidateObject(physicalDevice, surface, kVulkanObjectTypeSurfaceKHR, false, "VUID-vkGetPhysicalDeviceSurfaceCapabilities2EXT-surface-parameter", "VUID-vkGetPhysicalDeviceSurfaceCapabilities2EXT-commonparent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateDisplayPowerControlEXT(
|
|
VkDevice device,
|
|
VkDisplayKHR display,
|
|
const VkDisplayPowerInfoEXT* pDisplayPowerInfo) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkDisplayPowerControlEXT-device-parameter", kVUIDUndefined);
|
|
skip |= ValidateObject(device, display, kVulkanObjectTypeDisplayKHR, false, "VUID-vkDisplayPowerControlEXT-display-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateRegisterDeviceEventEXT(
|
|
VkDevice device,
|
|
const VkDeviceEventInfoEXT* pDeviceEventInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkFence* pFence) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkRegisterDeviceEventEXT-device-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PostCallRecordRegisterDeviceEventEXT(
|
|
VkDevice device,
|
|
const VkDeviceEventInfoEXT* pDeviceEventInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkFence* pFence,
|
|
VkResult result) {
|
|
if (result != VK_SUCCESS) return;
|
|
CreateObject(device, *pFence, kVulkanObjectTypeFence, pAllocator);
|
|
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateRegisterDisplayEventEXT(
|
|
VkDevice device,
|
|
VkDisplayKHR display,
|
|
const VkDisplayEventInfoEXT* pDisplayEventInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkFence* pFence) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkRegisterDisplayEventEXT-device-parameter", kVUIDUndefined);
|
|
skip |= ValidateObject(device, display, kVulkanObjectTypeDisplayKHR, false, "VUID-vkRegisterDisplayEventEXT-display-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PostCallRecordRegisterDisplayEventEXT(
|
|
VkDevice device,
|
|
VkDisplayKHR display,
|
|
const VkDisplayEventInfoEXT* pDisplayEventInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkFence* pFence,
|
|
VkResult result) {
|
|
if (result != VK_SUCCESS) return;
|
|
CreateObject(device, *pFence, kVulkanObjectTypeFence, pAllocator);
|
|
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetSwapchainCounterEXT(
|
|
VkDevice device,
|
|
VkSwapchainKHR swapchain,
|
|
VkSurfaceCounterFlagBitsEXT counter,
|
|
uint64_t* pCounterValue) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkGetSwapchainCounterEXT-device-parameter", "VUID-vkGetSwapchainCounterEXT-commonparent");
|
|
skip |= ValidateObject(device, swapchain, kVulkanObjectTypeSwapchainKHR, false, "VUID-vkGetSwapchainCounterEXT-swapchain-parameter", "VUID-vkGetSwapchainCounterEXT-commonparent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetRefreshCycleDurationGOOGLE(
|
|
VkDevice device,
|
|
VkSwapchainKHR swapchain,
|
|
VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkGetRefreshCycleDurationGOOGLE-device-parameter", "VUID-vkGetRefreshCycleDurationGOOGLE-commonparent");
|
|
skip |= ValidateObject(device, swapchain, kVulkanObjectTypeSwapchainKHR, false, "VUID-vkGetRefreshCycleDurationGOOGLE-swapchain-parameter", "VUID-vkGetRefreshCycleDurationGOOGLE-commonparent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetPastPresentationTimingGOOGLE(
|
|
VkDevice device,
|
|
VkSwapchainKHR swapchain,
|
|
uint32_t* pPresentationTimingCount,
|
|
VkPastPresentationTimingGOOGLE* pPresentationTimings) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkGetPastPresentationTimingGOOGLE-device-parameter", "VUID-vkGetPastPresentationTimingGOOGLE-commonparent");
|
|
skip |= ValidateObject(device, swapchain, kVulkanObjectTypeSwapchainKHR, false, "VUID-vkGetPastPresentationTimingGOOGLE-swapchain-parameter", "VUID-vkGetPastPresentationTimingGOOGLE-commonparent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdSetDiscardRectangleEXT(
|
|
VkCommandBuffer commandBuffer,
|
|
uint32_t firstDiscardRectangle,
|
|
uint32_t discardRectangleCount,
|
|
const VkRect2D* pDiscardRectangles) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdSetDiscardRectangleEXT-commandBuffer-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateSetHdrMetadataEXT(
|
|
VkDevice device,
|
|
uint32_t swapchainCount,
|
|
const VkSwapchainKHR* pSwapchains,
|
|
const VkHdrMetadataEXT* pMetadata) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkSetHdrMetadataEXT-device-parameter", "VUID-vkSetHdrMetadataEXT-commonparent");
|
|
if (pSwapchains) {
|
|
for (uint32_t index0 = 0; index0 < swapchainCount; ++index0) {
|
|
skip |= ValidateObject(device, pSwapchains[index0], kVulkanObjectTypeSwapchainKHR, false, "VUID-vkSetHdrMetadataEXT-pSwapchains-parameter", "VUID-vkSetHdrMetadataEXT-commonparent");
|
|
}
|
|
}
|
|
|
|
return skip;
|
|
}
|
|
|
|
#ifdef VK_USE_PLATFORM_IOS_MVK
|
|
|
|
bool ObjectLifetimes::PreCallValidateCreateIOSSurfaceMVK(
|
|
VkInstance instance,
|
|
const VkIOSSurfaceCreateInfoMVK* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkSurfaceKHR* pSurface) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(instance, instance, kVulkanObjectTypeInstance, false, "VUID-vkCreateIOSSurfaceMVK-instance-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PostCallRecordCreateIOSSurfaceMVK(
|
|
VkInstance instance,
|
|
const VkIOSSurfaceCreateInfoMVK* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkSurfaceKHR* pSurface,
|
|
VkResult result) {
|
|
if (result != VK_SUCCESS) return;
|
|
CreateObject(instance, *pSurface, kVulkanObjectTypeSurfaceKHR, pAllocator);
|
|
|
|
}
|
|
#endif // VK_USE_PLATFORM_IOS_MVK
|
|
|
|
#ifdef VK_USE_PLATFORM_MACOS_MVK
|
|
|
|
bool ObjectLifetimes::PreCallValidateCreateMacOSSurfaceMVK(
|
|
VkInstance instance,
|
|
const VkMacOSSurfaceCreateInfoMVK* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkSurfaceKHR* pSurface) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(instance, instance, kVulkanObjectTypeInstance, false, "VUID-vkCreateMacOSSurfaceMVK-instance-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PostCallRecordCreateMacOSSurfaceMVK(
|
|
VkInstance instance,
|
|
const VkMacOSSurfaceCreateInfoMVK* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkSurfaceKHR* pSurface,
|
|
VkResult result) {
|
|
if (result != VK_SUCCESS) return;
|
|
CreateObject(instance, *pSurface, kVulkanObjectTypeSurfaceKHR, pAllocator);
|
|
|
|
}
|
|
#endif // VK_USE_PLATFORM_MACOS_MVK
|
|
|
|
bool ObjectLifetimes::PreCallValidateSetDebugUtilsObjectNameEXT(
|
|
VkDevice device,
|
|
const VkDebugUtilsObjectNameInfoEXT* pNameInfo) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkSetDebugUtilsObjectNameEXT-device-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateSetDebugUtilsObjectTagEXT(
|
|
VkDevice device,
|
|
const VkDebugUtilsObjectTagInfoEXT* pTagInfo) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkSetDebugUtilsObjectTagEXT-device-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateQueueBeginDebugUtilsLabelEXT(
|
|
VkQueue queue,
|
|
const VkDebugUtilsLabelEXT* pLabelInfo) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(queue, queue, kVulkanObjectTypeQueue, false, "VUID-vkQueueBeginDebugUtilsLabelEXT-queue-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateQueueEndDebugUtilsLabelEXT(
|
|
VkQueue queue) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(queue, queue, kVulkanObjectTypeQueue, false, "VUID-vkQueueEndDebugUtilsLabelEXT-queue-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateQueueInsertDebugUtilsLabelEXT(
|
|
VkQueue queue,
|
|
const VkDebugUtilsLabelEXT* pLabelInfo) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(queue, queue, kVulkanObjectTypeQueue, false, "VUID-vkQueueInsertDebugUtilsLabelEXT-queue-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdBeginDebugUtilsLabelEXT(
|
|
VkCommandBuffer commandBuffer,
|
|
const VkDebugUtilsLabelEXT* pLabelInfo) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdBeginDebugUtilsLabelEXT-commandBuffer-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdEndDebugUtilsLabelEXT(
|
|
VkCommandBuffer commandBuffer) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdEndDebugUtilsLabelEXT-commandBuffer-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdInsertDebugUtilsLabelEXT(
|
|
VkCommandBuffer commandBuffer,
|
|
const VkDebugUtilsLabelEXT* pLabelInfo) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdInsertDebugUtilsLabelEXT-commandBuffer-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCreateDebugUtilsMessengerEXT(
|
|
VkInstance instance,
|
|
const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkDebugUtilsMessengerEXT* pMessenger) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(instance, instance, kVulkanObjectTypeInstance, false, "VUID-vkCreateDebugUtilsMessengerEXT-instance-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PostCallRecordCreateDebugUtilsMessengerEXT(
|
|
VkInstance instance,
|
|
const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkDebugUtilsMessengerEXT* pMessenger,
|
|
VkResult result) {
|
|
if (result != VK_SUCCESS) return;
|
|
CreateObject(instance, *pMessenger, kVulkanObjectTypeDebugUtilsMessengerEXT, pAllocator);
|
|
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateDestroyDebugUtilsMessengerEXT(
|
|
VkInstance instance,
|
|
VkDebugUtilsMessengerEXT messenger,
|
|
const VkAllocationCallbacks* pAllocator) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(instance, instance, kVulkanObjectTypeInstance, false, "VUID-vkDestroyDebugUtilsMessengerEXT-instance-parameter", kVUIDUndefined);
|
|
skip |= ValidateObject(instance, messenger, kVulkanObjectTypeDebugUtilsMessengerEXT, false, "VUID-vkDestroyDebugUtilsMessengerEXT-messenger-parameter", "VUID-vkDestroyDebugUtilsMessengerEXT-messenger-parent");
|
|
skip |= ValidateDestroyObject(instance, messenger, kVulkanObjectTypeDebugUtilsMessengerEXT, pAllocator, kVUIDUndefined, kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PreCallRecordDestroyDebugUtilsMessengerEXT(
|
|
VkInstance instance,
|
|
VkDebugUtilsMessengerEXT messenger,
|
|
const VkAllocationCallbacks* pAllocator) {
|
|
RecordDestroyObject(instance, messenger, kVulkanObjectTypeDebugUtilsMessengerEXT);
|
|
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateSubmitDebugUtilsMessageEXT(
|
|
VkInstance instance,
|
|
VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
|
|
VkDebugUtilsMessageTypeFlagsEXT messageTypes,
|
|
const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(instance, instance, kVulkanObjectTypeInstance, false, "VUID-vkSubmitDebugUtilsMessageEXT-instance-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
#ifdef VK_USE_PLATFORM_ANDROID_KHR
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetAndroidHardwareBufferPropertiesANDROID(
|
|
VkDevice device,
|
|
const struct AHardwareBuffer* buffer,
|
|
VkAndroidHardwareBufferPropertiesANDROID* pProperties) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkGetAndroidHardwareBufferPropertiesANDROID-device-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
#endif // VK_USE_PLATFORM_ANDROID_KHR
|
|
|
|
#ifdef VK_USE_PLATFORM_ANDROID_KHR
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetMemoryAndroidHardwareBufferANDROID(
|
|
VkDevice device,
|
|
const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo,
|
|
struct AHardwareBuffer** pBuffer) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkGetMemoryAndroidHardwareBufferANDROID-device-parameter", kVUIDUndefined);
|
|
if (pInfo) {
|
|
skip |= ValidateObject(device, pInfo->memory, kVulkanObjectTypeDeviceMemory, false, "VUID-VkMemoryGetAndroidHardwareBufferInfoANDROID-memory-parameter", kVUIDUndefined);
|
|
}
|
|
|
|
return skip;
|
|
}
|
|
#endif // VK_USE_PLATFORM_ANDROID_KHR
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdSetSampleLocationsEXT(
|
|
VkCommandBuffer commandBuffer,
|
|
const VkSampleLocationsInfoEXT* pSampleLocationsInfo) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdSetSampleLocationsEXT-commandBuffer-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceMultisamplePropertiesEXT(
|
|
VkPhysicalDevice physicalDevice,
|
|
VkSampleCountFlagBits samples,
|
|
VkMultisamplePropertiesEXT* pMultisampleProperties) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceMultisamplePropertiesEXT-physicalDevice-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetImageDrmFormatModifierPropertiesEXT(
|
|
VkDevice device,
|
|
VkImage image,
|
|
VkImageDrmFormatModifierPropertiesEXT* pProperties) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkGetImageDrmFormatModifierPropertiesEXT-device-parameter", kVUIDUndefined);
|
|
skip |= ValidateObject(device, image, kVulkanObjectTypeImage, false, "VUID-vkGetImageDrmFormatModifierPropertiesEXT-image-parameter", "VUID-vkGetImageDrmFormatModifierPropertiesEXT-image-parent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCreateValidationCacheEXT(
|
|
VkDevice device,
|
|
const VkValidationCacheCreateInfoEXT* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkValidationCacheEXT* pValidationCache) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkCreateValidationCacheEXT-device-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PostCallRecordCreateValidationCacheEXT(
|
|
VkDevice device,
|
|
const VkValidationCacheCreateInfoEXT* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkValidationCacheEXT* pValidationCache,
|
|
VkResult result) {
|
|
if (result != VK_SUCCESS) return;
|
|
CreateObject(device, *pValidationCache, kVulkanObjectTypeValidationCacheEXT, pAllocator);
|
|
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateDestroyValidationCacheEXT(
|
|
VkDevice device,
|
|
VkValidationCacheEXT validationCache,
|
|
const VkAllocationCallbacks* pAllocator) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkDestroyValidationCacheEXT-device-parameter", kVUIDUndefined);
|
|
skip |= ValidateObject(device, validationCache, kVulkanObjectTypeValidationCacheEXT, true, "VUID-vkDestroyValidationCacheEXT-validationCache-parameter", "VUID-vkDestroyValidationCacheEXT-validationCache-parent");
|
|
skip |= ValidateDestroyObject(device, validationCache, kVulkanObjectTypeValidationCacheEXT, pAllocator, kVUIDUndefined, kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PreCallRecordDestroyValidationCacheEXT(
|
|
VkDevice device,
|
|
VkValidationCacheEXT validationCache,
|
|
const VkAllocationCallbacks* pAllocator) {
|
|
RecordDestroyObject(device, validationCache, kVulkanObjectTypeValidationCacheEXT);
|
|
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateMergeValidationCachesEXT(
|
|
VkDevice device,
|
|
VkValidationCacheEXT dstCache,
|
|
uint32_t srcCacheCount,
|
|
const VkValidationCacheEXT* pSrcCaches) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkMergeValidationCachesEXT-device-parameter", kVUIDUndefined);
|
|
skip |= ValidateObject(device, dstCache, kVulkanObjectTypeValidationCacheEXT, false, "VUID-vkMergeValidationCachesEXT-dstCache-parameter", "VUID-vkMergeValidationCachesEXT-dstCache-parent");
|
|
if (pSrcCaches) {
|
|
for (uint32_t index0 = 0; index0 < srcCacheCount; ++index0) {
|
|
skip |= ValidateObject(device, pSrcCaches[index0], kVulkanObjectTypeValidationCacheEXT, false, "VUID-vkMergeValidationCachesEXT-pSrcCaches-parameter", "VUID-vkMergeValidationCachesEXT-pSrcCaches-parent");
|
|
}
|
|
}
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetValidationCacheDataEXT(
|
|
VkDevice device,
|
|
VkValidationCacheEXT validationCache,
|
|
size_t* pDataSize,
|
|
void* pData) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkGetValidationCacheDataEXT-device-parameter", kVUIDUndefined);
|
|
skip |= ValidateObject(device, validationCache, kVulkanObjectTypeValidationCacheEXT, false, "VUID-vkGetValidationCacheDataEXT-validationCache-parameter", "VUID-vkGetValidationCacheDataEXT-validationCache-parent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdBindShadingRateImageNV(
|
|
VkCommandBuffer commandBuffer,
|
|
VkImageView imageView,
|
|
VkImageLayout imageLayout) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdBindShadingRateImageNV-commandBuffer-parameter", "VUID-vkCmdBindShadingRateImageNV-commonparent");
|
|
skip |= ValidateObject(commandBuffer, imageView, kVulkanObjectTypeImageView, true, "VUID-vkCmdBindShadingRateImageNV-imageView-parameter", "VUID-vkCmdBindShadingRateImageNV-commonparent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdSetViewportShadingRatePaletteNV(
|
|
VkCommandBuffer commandBuffer,
|
|
uint32_t firstViewport,
|
|
uint32_t viewportCount,
|
|
const VkShadingRatePaletteNV* pShadingRatePalettes) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdSetViewportShadingRatePaletteNV-commandBuffer-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdSetCoarseSampleOrderNV(
|
|
VkCommandBuffer commandBuffer,
|
|
VkCoarseSampleOrderTypeNV sampleOrderType,
|
|
uint32_t customSampleOrderCount,
|
|
const VkCoarseSampleOrderCustomNV* pCustomSampleOrders) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdSetCoarseSampleOrderNV-commandBuffer-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCreateAccelerationStructureNV(
|
|
VkDevice device,
|
|
const VkAccelerationStructureCreateInfoNV* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkAccelerationStructureNV* pAccelerationStructure) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkCreateAccelerationStructureNV-device-parameter", kVUIDUndefined);
|
|
if (pCreateInfo) {
|
|
if (pCreateInfo->info.pGeometries) {
|
|
for (uint32_t index2 = 0; index2 < pCreateInfo->info.geometryCount; ++index2) {
|
|
skip |= ValidateObject(device, pCreateInfo->info.pGeometries[index2].geometry.triangles.vertexData, kVulkanObjectTypeBuffer, true, "VUID-VkGeometryTrianglesNV-vertexData-parameter", "VUID-VkGeometryTrianglesNV-commonparent");
|
|
skip |= ValidateObject(device, pCreateInfo->info.pGeometries[index2].geometry.triangles.indexData, kVulkanObjectTypeBuffer, true, "VUID-VkGeometryTrianglesNV-indexData-parameter", "VUID-VkGeometryTrianglesNV-commonparent");
|
|
skip |= ValidateObject(device, pCreateInfo->info.pGeometries[index2].geometry.triangles.transformData, kVulkanObjectTypeBuffer, true, "VUID-VkGeometryTrianglesNV-transformData-parameter", "VUID-VkGeometryTrianglesNV-commonparent");
|
|
skip |= ValidateObject(device, pCreateInfo->info.pGeometries[index2].geometry.aabbs.aabbData, kVulkanObjectTypeBuffer, true, "VUID-VkGeometryAABBNV-aabbData-parameter", kVUIDUndefined);
|
|
}
|
|
}
|
|
}
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PostCallRecordCreateAccelerationStructureNV(
|
|
VkDevice device,
|
|
const VkAccelerationStructureCreateInfoNV* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkAccelerationStructureNV* pAccelerationStructure,
|
|
VkResult result) {
|
|
if (result != VK_SUCCESS) return;
|
|
CreateObject(device, *pAccelerationStructure, kVulkanObjectTypeAccelerationStructureNV, pAllocator);
|
|
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateDestroyAccelerationStructureNV(
|
|
VkDevice device,
|
|
VkAccelerationStructureNV accelerationStructure,
|
|
const VkAllocationCallbacks* pAllocator) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkDestroyAccelerationStructureNV-device-parameter", kVUIDUndefined);
|
|
skip |= ValidateObject(device, accelerationStructure, kVulkanObjectTypeAccelerationStructureNV, false, "VUID-vkDestroyAccelerationStructureNV-accelerationStructure-parameter", "VUID-vkDestroyAccelerationStructureNV-accelerationStructure-parent");
|
|
skip |= ValidateDestroyObject(device, accelerationStructure, kVulkanObjectTypeAccelerationStructureNV, pAllocator, kVUIDUndefined, kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PreCallRecordDestroyAccelerationStructureNV(
|
|
VkDevice device,
|
|
VkAccelerationStructureNV accelerationStructure,
|
|
const VkAllocationCallbacks* pAllocator) {
|
|
RecordDestroyObject(device, accelerationStructure, kVulkanObjectTypeAccelerationStructureNV);
|
|
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetAccelerationStructureMemoryRequirementsNV(
|
|
VkDevice device,
|
|
const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo,
|
|
VkMemoryRequirements2KHR* pMemoryRequirements) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkGetAccelerationStructureMemoryRequirementsNV-device-parameter", kVUIDUndefined);
|
|
if (pInfo) {
|
|
skip |= ValidateObject(device, pInfo->accelerationStructure, kVulkanObjectTypeAccelerationStructureNV, false, "VUID-VkAccelerationStructureMemoryRequirementsInfoNV-accelerationStructure-parameter", kVUIDUndefined);
|
|
}
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateBindAccelerationStructureMemoryNV(
|
|
VkDevice device,
|
|
uint32_t bindInfoCount,
|
|
const VkBindAccelerationStructureMemoryInfoNV* pBindInfos) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkBindAccelerationStructureMemoryNV-device-parameter", kVUIDUndefined);
|
|
if (pBindInfos) {
|
|
for (uint32_t index0 = 0; index0 < bindInfoCount; ++index0) {
|
|
skip |= ValidateObject(device, pBindInfos[index0].accelerationStructure, kVulkanObjectTypeAccelerationStructureNV, false, "VUID-VkBindAccelerationStructureMemoryInfoNV-accelerationStructure-parameter", "VUID-VkBindAccelerationStructureMemoryInfoNV-commonparent");
|
|
skip |= ValidateObject(device, pBindInfos[index0].memory, kVulkanObjectTypeDeviceMemory, false, "VUID-VkBindAccelerationStructureMemoryInfoNV-memory-parameter", "VUID-VkBindAccelerationStructureMemoryInfoNV-commonparent");
|
|
}
|
|
}
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdBuildAccelerationStructureNV(
|
|
VkCommandBuffer commandBuffer,
|
|
const VkAccelerationStructureInfoNV* pInfo,
|
|
VkBuffer instanceData,
|
|
VkDeviceSize instanceOffset,
|
|
VkBool32 update,
|
|
VkAccelerationStructureNV dst,
|
|
VkAccelerationStructureNV src,
|
|
VkBuffer scratch,
|
|
VkDeviceSize scratchOffset) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdBuildAccelerationStructureNV-commandBuffer-parameter", "VUID-vkCmdBuildAccelerationStructureNV-commonparent");
|
|
if (pInfo) {
|
|
if (pInfo->pGeometries) {
|
|
for (uint32_t index1 = 0; index1 < pInfo->geometryCount; ++index1) {
|
|
skip |= ValidateObject(commandBuffer, pInfo->pGeometries[index1].geometry.triangles.vertexData, kVulkanObjectTypeBuffer, true, "VUID-VkGeometryTrianglesNV-vertexData-parameter", "VUID-VkGeometryTrianglesNV-commonparent");
|
|
skip |= ValidateObject(commandBuffer, pInfo->pGeometries[index1].geometry.triangles.indexData, kVulkanObjectTypeBuffer, true, "VUID-VkGeometryTrianglesNV-indexData-parameter", "VUID-VkGeometryTrianglesNV-commonparent");
|
|
skip |= ValidateObject(commandBuffer, pInfo->pGeometries[index1].geometry.triangles.transformData, kVulkanObjectTypeBuffer, true, "VUID-VkGeometryTrianglesNV-transformData-parameter", "VUID-VkGeometryTrianglesNV-commonparent");
|
|
skip |= ValidateObject(commandBuffer, pInfo->pGeometries[index1].geometry.aabbs.aabbData, kVulkanObjectTypeBuffer, true, "VUID-VkGeometryAABBNV-aabbData-parameter", kVUIDUndefined);
|
|
}
|
|
}
|
|
}
|
|
skip |= ValidateObject(commandBuffer, instanceData, kVulkanObjectTypeBuffer, true, "VUID-vkCmdBuildAccelerationStructureNV-instanceData-parameter", "VUID-vkCmdBuildAccelerationStructureNV-commonparent");
|
|
skip |= ValidateObject(commandBuffer, dst, kVulkanObjectTypeAccelerationStructureNV, false, "VUID-vkCmdBuildAccelerationStructureNV-dst-parameter", "VUID-vkCmdBuildAccelerationStructureNV-commonparent");
|
|
skip |= ValidateObject(commandBuffer, src, kVulkanObjectTypeAccelerationStructureNV, true, "VUID-vkCmdBuildAccelerationStructureNV-src-parameter", "VUID-vkCmdBuildAccelerationStructureNV-commonparent");
|
|
skip |= ValidateObject(commandBuffer, scratch, kVulkanObjectTypeBuffer, false, "VUID-vkCmdBuildAccelerationStructureNV-scratch-parameter", "VUID-vkCmdBuildAccelerationStructureNV-commonparent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdCopyAccelerationStructureNV(
|
|
VkCommandBuffer commandBuffer,
|
|
VkAccelerationStructureNV dst,
|
|
VkAccelerationStructureNV src,
|
|
VkCopyAccelerationStructureModeNV mode) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdCopyAccelerationStructureNV-commandBuffer-parameter", "VUID-vkCmdCopyAccelerationStructureNV-commonparent");
|
|
skip |= ValidateObject(commandBuffer, dst, kVulkanObjectTypeAccelerationStructureNV, false, "VUID-vkCmdCopyAccelerationStructureNV-dst-parameter", "VUID-vkCmdCopyAccelerationStructureNV-commonparent");
|
|
skip |= ValidateObject(commandBuffer, src, kVulkanObjectTypeAccelerationStructureNV, false, "VUID-vkCmdCopyAccelerationStructureNV-src-parameter", "VUID-vkCmdCopyAccelerationStructureNV-commonparent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdTraceRaysNV(
|
|
VkCommandBuffer commandBuffer,
|
|
VkBuffer raygenShaderBindingTableBuffer,
|
|
VkDeviceSize raygenShaderBindingOffset,
|
|
VkBuffer missShaderBindingTableBuffer,
|
|
VkDeviceSize missShaderBindingOffset,
|
|
VkDeviceSize missShaderBindingStride,
|
|
VkBuffer hitShaderBindingTableBuffer,
|
|
VkDeviceSize hitShaderBindingOffset,
|
|
VkDeviceSize hitShaderBindingStride,
|
|
VkBuffer callableShaderBindingTableBuffer,
|
|
VkDeviceSize callableShaderBindingOffset,
|
|
VkDeviceSize callableShaderBindingStride,
|
|
uint32_t width,
|
|
uint32_t height,
|
|
uint32_t depth) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdTraceRaysNV-commandBuffer-parameter", "VUID-vkCmdTraceRaysNV-commonparent");
|
|
skip |= ValidateObject(commandBuffer, raygenShaderBindingTableBuffer, kVulkanObjectTypeBuffer, false, "VUID-vkCmdTraceRaysNV-raygenShaderBindingTableBuffer-parameter", "VUID-vkCmdTraceRaysNV-commonparent");
|
|
skip |= ValidateObject(commandBuffer, missShaderBindingTableBuffer, kVulkanObjectTypeBuffer, true, "VUID-vkCmdTraceRaysNV-missShaderBindingTableBuffer-parameter", "VUID-vkCmdTraceRaysNV-commonparent");
|
|
skip |= ValidateObject(commandBuffer, hitShaderBindingTableBuffer, kVulkanObjectTypeBuffer, true, "VUID-vkCmdTraceRaysNV-hitShaderBindingTableBuffer-parameter", "VUID-vkCmdTraceRaysNV-commonparent");
|
|
skip |= ValidateObject(commandBuffer, callableShaderBindingTableBuffer, kVulkanObjectTypeBuffer, true, "VUID-vkCmdTraceRaysNV-callableShaderBindingTableBuffer-parameter", "VUID-vkCmdTraceRaysNV-commonparent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCreateRayTracingPipelinesNV(
|
|
VkDevice device,
|
|
VkPipelineCache pipelineCache,
|
|
uint32_t createInfoCount,
|
|
const VkRayTracingPipelineCreateInfoNV* pCreateInfos,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkPipeline* pPipelines) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkCreateRayTracingPipelinesNV-device-parameter", kVUIDUndefined);
|
|
skip |= ValidateObject(device, pipelineCache, kVulkanObjectTypePipelineCache, true, "VUID-vkCreateRayTracingPipelinesNV-pipelineCache-parameter", "VUID-vkCreateRayTracingPipelinesNV-pipelineCache-parent");
|
|
if (pCreateInfos) {
|
|
for (uint32_t index0 = 0; index0 < createInfoCount; ++index0) {
|
|
if (pCreateInfos[index0].pStages) {
|
|
for (uint32_t index1 = 0; index1 < pCreateInfos[index0].stageCount; ++index1) {
|
|
skip |= ValidateObject(device, pCreateInfos[index0].pStages[index1].module, kVulkanObjectTypeShaderModule, false, "VUID-VkPipelineShaderStageCreateInfo-module-parameter", kVUIDUndefined);
|
|
}
|
|
}
|
|
skip |= ValidateObject(device, pCreateInfos[index0].layout, kVulkanObjectTypePipelineLayout, false, "VUID-VkRayTracingPipelineCreateInfoNV-layout-parameter", "VUID-VkRayTracingPipelineCreateInfoNV-commonparent");
|
|
skip |= ValidateObject(device, pCreateInfos[index0].basePipelineHandle, kVulkanObjectTypePipeline, true, kVUIDUndefined, "VUID-VkRayTracingPipelineCreateInfoNV-commonparent");
|
|
}
|
|
}
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PostCallRecordCreateRayTracingPipelinesNV(
|
|
VkDevice device,
|
|
VkPipelineCache pipelineCache,
|
|
uint32_t createInfoCount,
|
|
const VkRayTracingPipelineCreateInfoNV* pCreateInfos,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkPipeline* pPipelines,
|
|
VkResult result) {
|
|
if (VK_ERROR_VALIDATION_FAILED_EXT == result) return;
|
|
if (pPipelines) {
|
|
for (uint32_t index = 0; index < createInfoCount; index++) {
|
|
if (!pPipelines[index]) continue;
|
|
CreateObject(device, pPipelines[index], kVulkanObjectTypePipeline, pAllocator);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetRayTracingShaderGroupHandlesNV(
|
|
VkDevice device,
|
|
VkPipeline pipeline,
|
|
uint32_t firstGroup,
|
|
uint32_t groupCount,
|
|
size_t dataSize,
|
|
void* pData) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkGetRayTracingShaderGroupHandlesNV-device-parameter", kVUIDUndefined);
|
|
skip |= ValidateObject(device, pipeline, kVulkanObjectTypePipeline, false, "VUID-vkGetRayTracingShaderGroupHandlesNV-pipeline-parameter", "VUID-vkGetRayTracingShaderGroupHandlesNV-pipeline-parent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetAccelerationStructureHandleNV(
|
|
VkDevice device,
|
|
VkAccelerationStructureNV accelerationStructure,
|
|
size_t dataSize,
|
|
void* pData) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkGetAccelerationStructureHandleNV-device-parameter", kVUIDUndefined);
|
|
skip |= ValidateObject(device, accelerationStructure, kVulkanObjectTypeAccelerationStructureNV, false, "VUID-vkGetAccelerationStructureHandleNV-accelerationStructure-parameter", "VUID-vkGetAccelerationStructureHandleNV-accelerationStructure-parent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdWriteAccelerationStructuresPropertiesNV(
|
|
VkCommandBuffer commandBuffer,
|
|
uint32_t accelerationStructureCount,
|
|
const VkAccelerationStructureNV* pAccelerationStructures,
|
|
VkQueryType queryType,
|
|
VkQueryPool queryPool,
|
|
uint32_t firstQuery) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdWriteAccelerationStructuresPropertiesNV-commandBuffer-parameter", "VUID-vkCmdWriteAccelerationStructuresPropertiesNV-commonparent");
|
|
if (pAccelerationStructures) {
|
|
for (uint32_t index0 = 0; index0 < accelerationStructureCount; ++index0) {
|
|
skip |= ValidateObject(commandBuffer, pAccelerationStructures[index0], kVulkanObjectTypeAccelerationStructureNV, false, "VUID-vkCmdWriteAccelerationStructuresPropertiesNV-pAccelerationStructures-parameter", "VUID-vkCmdWriteAccelerationStructuresPropertiesNV-commonparent");
|
|
}
|
|
}
|
|
skip |= ValidateObject(commandBuffer, queryPool, kVulkanObjectTypeQueryPool, false, "VUID-vkCmdWriteAccelerationStructuresPropertiesNV-queryPool-parameter", "VUID-vkCmdWriteAccelerationStructuresPropertiesNV-commonparent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCompileDeferredNV(
|
|
VkDevice device,
|
|
VkPipeline pipeline,
|
|
uint32_t shader) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkCompileDeferredNV-device-parameter", kVUIDUndefined);
|
|
skip |= ValidateObject(device, pipeline, kVulkanObjectTypePipeline, false, "VUID-vkCompileDeferredNV-pipeline-parameter", "VUID-vkCompileDeferredNV-pipeline-parent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetMemoryHostPointerPropertiesEXT(
|
|
VkDevice device,
|
|
VkExternalMemoryHandleTypeFlagBits handleType,
|
|
const void* pHostPointer,
|
|
VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkGetMemoryHostPointerPropertiesEXT-device-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdWriteBufferMarkerAMD(
|
|
VkCommandBuffer commandBuffer,
|
|
VkPipelineStageFlagBits pipelineStage,
|
|
VkBuffer dstBuffer,
|
|
VkDeviceSize dstOffset,
|
|
uint32_t marker) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdWriteBufferMarkerAMD-commandBuffer-parameter", "VUID-vkCmdWriteBufferMarkerAMD-commonparent");
|
|
skip |= ValidateObject(commandBuffer, dstBuffer, kVulkanObjectTypeBuffer, false, "VUID-vkCmdWriteBufferMarkerAMD-dstBuffer-parameter", "VUID-vkCmdWriteBufferMarkerAMD-commonparent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceCalibrateableTimeDomainsEXT(
|
|
VkPhysicalDevice physicalDevice,
|
|
uint32_t* pTimeDomainCount,
|
|
VkTimeDomainEXT* pTimeDomains) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceCalibrateableTimeDomainsEXT-physicalDevice-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetCalibratedTimestampsEXT(
|
|
VkDevice device,
|
|
uint32_t timestampCount,
|
|
const VkCalibratedTimestampInfoEXT* pTimestampInfos,
|
|
uint64_t* pTimestamps,
|
|
uint64_t* pMaxDeviation) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkGetCalibratedTimestampsEXT-device-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdDrawMeshTasksNV(
|
|
VkCommandBuffer commandBuffer,
|
|
uint32_t taskCount,
|
|
uint32_t firstTask) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdDrawMeshTasksNV-commandBuffer-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdDrawMeshTasksIndirectNV(
|
|
VkCommandBuffer commandBuffer,
|
|
VkBuffer buffer,
|
|
VkDeviceSize offset,
|
|
uint32_t drawCount,
|
|
uint32_t stride) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdDrawMeshTasksIndirectNV-commandBuffer-parameter", "VUID-vkCmdDrawMeshTasksIndirectNV-commonparent");
|
|
skip |= ValidateObject(commandBuffer, buffer, kVulkanObjectTypeBuffer, false, "VUID-vkCmdDrawMeshTasksIndirectNV-buffer-parameter", "VUID-vkCmdDrawMeshTasksIndirectNV-commonparent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdDrawMeshTasksIndirectCountNV(
|
|
VkCommandBuffer commandBuffer,
|
|
VkBuffer buffer,
|
|
VkDeviceSize offset,
|
|
VkBuffer countBuffer,
|
|
VkDeviceSize countBufferOffset,
|
|
uint32_t maxDrawCount,
|
|
uint32_t stride) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdDrawMeshTasksIndirectCountNV-commandBuffer-parameter", "VUID-vkCmdDrawMeshTasksIndirectCountNV-commonparent");
|
|
skip |= ValidateObject(commandBuffer, buffer, kVulkanObjectTypeBuffer, false, "VUID-vkCmdDrawMeshTasksIndirectCountNV-buffer-parameter", "VUID-vkCmdDrawMeshTasksIndirectCountNV-commonparent");
|
|
skip |= ValidateObject(commandBuffer, countBuffer, kVulkanObjectTypeBuffer, false, "VUID-vkCmdDrawMeshTasksIndirectCountNV-countBuffer-parameter", "VUID-vkCmdDrawMeshTasksIndirectCountNV-commonparent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdSetExclusiveScissorNV(
|
|
VkCommandBuffer commandBuffer,
|
|
uint32_t firstExclusiveScissor,
|
|
uint32_t exclusiveScissorCount,
|
|
const VkRect2D* pExclusiveScissors) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdSetExclusiveScissorNV-commandBuffer-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdSetCheckpointNV(
|
|
VkCommandBuffer commandBuffer,
|
|
const void* pCheckpointMarker) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdSetCheckpointNV-commandBuffer-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetQueueCheckpointDataNV(
|
|
VkQueue queue,
|
|
uint32_t* pCheckpointDataCount,
|
|
VkCheckpointDataNV* pCheckpointData) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(queue, queue, kVulkanObjectTypeQueue, false, "VUID-vkGetQueueCheckpointDataNV-queue-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateInitializePerformanceApiINTEL(
|
|
VkDevice device,
|
|
const VkInitializePerformanceApiInfoINTEL* pInitializeInfo) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkInitializePerformanceApiINTEL-device-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateUninitializePerformanceApiINTEL(
|
|
VkDevice device) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkUninitializePerformanceApiINTEL-device-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdSetPerformanceMarkerINTEL(
|
|
VkCommandBuffer commandBuffer,
|
|
const VkPerformanceMarkerInfoINTEL* pMarkerInfo) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdSetPerformanceMarkerINTEL-commandBuffer-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdSetPerformanceStreamMarkerINTEL(
|
|
VkCommandBuffer commandBuffer,
|
|
const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdSetPerformanceStreamMarkerINTEL-commandBuffer-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdSetPerformanceOverrideINTEL(
|
|
VkCommandBuffer commandBuffer,
|
|
const VkPerformanceOverrideInfoINTEL* pOverrideInfo) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdSetPerformanceOverrideINTEL-commandBuffer-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetPerformanceParameterINTEL(
|
|
VkDevice device,
|
|
VkPerformanceParameterTypeINTEL parameter,
|
|
VkPerformanceValueINTEL* pValue) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkGetPerformanceParameterINTEL-device-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateSetLocalDimmingAMD(
|
|
VkDevice device,
|
|
VkSwapchainKHR swapChain,
|
|
VkBool32 localDimmingEnable) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkSetLocalDimmingAMD-device-parameter", "VUID-vkSetLocalDimmingAMD-commonparent");
|
|
skip |= ValidateObject(device, swapChain, kVulkanObjectTypeSwapchainKHR, false, "VUID-vkSetLocalDimmingAMD-swapChain-parameter", "VUID-vkSetLocalDimmingAMD-commonparent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
#ifdef VK_USE_PLATFORM_FUCHSIA
|
|
|
|
bool ObjectLifetimes::PreCallValidateCreateImagePipeSurfaceFUCHSIA(
|
|
VkInstance instance,
|
|
const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkSurfaceKHR* pSurface) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(instance, instance, kVulkanObjectTypeInstance, false, "VUID-vkCreateImagePipeSurfaceFUCHSIA-instance-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PostCallRecordCreateImagePipeSurfaceFUCHSIA(
|
|
VkInstance instance,
|
|
const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkSurfaceKHR* pSurface,
|
|
VkResult result) {
|
|
if (result != VK_SUCCESS) return;
|
|
CreateObject(instance, *pSurface, kVulkanObjectTypeSurfaceKHR, pAllocator);
|
|
|
|
}
|
|
#endif // VK_USE_PLATFORM_FUCHSIA
|
|
|
|
#ifdef VK_USE_PLATFORM_METAL_EXT
|
|
|
|
bool ObjectLifetimes::PreCallValidateCreateMetalSurfaceEXT(
|
|
VkInstance instance,
|
|
const VkMetalSurfaceCreateInfoEXT* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkSurfaceKHR* pSurface) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(instance, instance, kVulkanObjectTypeInstance, false, "VUID-vkCreateMetalSurfaceEXT-instance-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PostCallRecordCreateMetalSurfaceEXT(
|
|
VkInstance instance,
|
|
const VkMetalSurfaceCreateInfoEXT* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkSurfaceKHR* pSurface,
|
|
VkResult result) {
|
|
if (result != VK_SUCCESS) return;
|
|
CreateObject(instance, *pSurface, kVulkanObjectTypeSurfaceKHR, pAllocator);
|
|
|
|
}
|
|
#endif // VK_USE_PLATFORM_METAL_EXT
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetBufferDeviceAddressEXT(
|
|
VkDevice device,
|
|
const VkBufferDeviceAddressInfoEXT* pInfo) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkGetBufferDeviceAddressEXT-device-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceCooperativeMatrixPropertiesNV(
|
|
VkPhysicalDevice physicalDevice,
|
|
uint32_t* pPropertyCount,
|
|
VkCooperativeMatrixPropertiesNV* pProperties) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceCooperativeMatrixPropertiesNV-physicalDevice-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(
|
|
VkPhysicalDevice physicalDevice,
|
|
uint32_t* pCombinationCount,
|
|
VkFramebufferMixedSamplesCombinationNV* pCombinations) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV-physicalDevice-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
#ifdef VK_USE_PLATFORM_WIN32_KHR
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceSurfacePresentModes2EXT(
|
|
VkPhysicalDevice physicalDevice,
|
|
const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
|
|
uint32_t* pPresentModeCount,
|
|
VkPresentModeKHR* pPresentModes) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, "VUID-vkGetPhysicalDeviceSurfacePresentModes2EXT-physicalDevice-parameter", kVUIDUndefined);
|
|
if (pSurfaceInfo) {
|
|
skip |= ValidateObject(physicalDevice, pSurfaceInfo->surface, kVulkanObjectTypeSurfaceKHR, false, "VUID-VkPhysicalDeviceSurfaceInfo2KHR-surface-parameter", kVUIDUndefined);
|
|
}
|
|
|
|
return skip;
|
|
}
|
|
#endif // VK_USE_PLATFORM_WIN32_KHR
|
|
|
|
#ifdef VK_USE_PLATFORM_WIN32_KHR
|
|
|
|
bool ObjectLifetimes::PreCallValidateAcquireFullScreenExclusiveModeEXT(
|
|
VkDevice device,
|
|
VkSwapchainKHR swapchain) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkAcquireFullScreenExclusiveModeEXT-device-parameter", "VUID-vkAcquireFullScreenExclusiveModeEXT-commonparent");
|
|
skip |= ValidateObject(device, swapchain, kVulkanObjectTypeSwapchainKHR, false, "VUID-vkAcquireFullScreenExclusiveModeEXT-swapchain-parameter", "VUID-vkAcquireFullScreenExclusiveModeEXT-commonparent");
|
|
|
|
return skip;
|
|
}
|
|
#endif // VK_USE_PLATFORM_WIN32_KHR
|
|
|
|
#ifdef VK_USE_PLATFORM_WIN32_KHR
|
|
|
|
bool ObjectLifetimes::PreCallValidateReleaseFullScreenExclusiveModeEXT(
|
|
VkDevice device,
|
|
VkSwapchainKHR swapchain) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, kVUIDUndefined, kVUIDUndefined);
|
|
skip |= ValidateObject(device, swapchain, kVulkanObjectTypeSwapchainKHR, false, kVUIDUndefined, kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
#endif // VK_USE_PLATFORM_WIN32_KHR
|
|
|
|
#ifdef VK_USE_PLATFORM_WIN32_KHR
|
|
|
|
bool ObjectLifetimes::PreCallValidateGetDeviceGroupSurfacePresentModes2EXT(
|
|
VkDevice device,
|
|
const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
|
|
VkDeviceGroupPresentModeFlagsKHR* pModes) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkGetDeviceGroupSurfacePresentModes2EXT-device-parameter", kVUIDUndefined);
|
|
if (pSurfaceInfo) {
|
|
skip |= ValidateObject(device, pSurfaceInfo->surface, kVulkanObjectTypeSurfaceKHR, false, "VUID-VkPhysicalDeviceSurfaceInfo2KHR-surface-parameter", kVUIDUndefined);
|
|
}
|
|
|
|
return skip;
|
|
}
|
|
#endif // VK_USE_PLATFORM_WIN32_KHR
|
|
|
|
bool ObjectLifetimes::PreCallValidateCreateHeadlessSurfaceEXT(
|
|
VkInstance instance,
|
|
const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkSurfaceKHR* pSurface) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(instance, instance, kVulkanObjectTypeInstance, false, "VUID-vkCreateHeadlessSurfaceEXT-instance-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
void ObjectLifetimes::PostCallRecordCreateHeadlessSurfaceEXT(
|
|
VkInstance instance,
|
|
const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkSurfaceKHR* pSurface,
|
|
VkResult result) {
|
|
if (result != VK_SUCCESS) return;
|
|
CreateObject(instance, *pSurface, kVulkanObjectTypeSurfaceKHR, pAllocator);
|
|
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateCmdSetLineStippleEXT(
|
|
VkCommandBuffer commandBuffer,
|
|
uint32_t lineStippleFactor,
|
|
uint16_t lineStipplePattern) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdSetLineStippleEXT-commandBuffer-parameter", kVUIDUndefined);
|
|
|
|
return skip;
|
|
}
|
|
|
|
bool ObjectLifetimes::PreCallValidateResetQueryPoolEXT(
|
|
VkDevice device,
|
|
VkQueryPool queryPool,
|
|
uint32_t firstQuery,
|
|
uint32_t queryCount) {
|
|
bool skip = false;
|
|
skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkResetQueryPoolEXT-device-parameter", kVUIDUndefined);
|
|
skip |= ValidateObject(device, queryPool, kVulkanObjectTypeQueryPool, false, "VUID-vkResetQueryPoolEXT-queryPool-parameter", "VUID-vkResetQueryPoolEXT-queryPool-parent");
|
|
|
|
return skip;
|
|
}
|
|
|
|
|