} VkDebugReportCallbackCreateInfoEXT;
#define VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT ((VkStructureType) 1000010000)
-#define VK_ERROR_VALIDATION_FAILED ((VkResult) -1000010001)
+#define VK_ERROR_VALIDATION_FAILED_EXT ((VkResult) -1000010001)
typedef VkResult (VKAPI_PTR *PFN_vkCreateDebugReportCallbackEXT)(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback);
typedef void (VKAPI_PTR *PFN_vkDestroyDebugReportCallbackEXT)(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator);
my_data->instanceState->vkEnumeratePhysicalDevicesState = QUERY_DETAILS;
}
if (skipCall)
- return VK_ERROR_VALIDATION_FAILED;
+ return VK_ERROR_VALIDATION_FAILED_EXT;
VkResult result = my_data->instance_dispatch_table->EnumeratePhysicalDevices(instance, pPhysicalDeviceCount, pPhysicalDevices);
if (NULL == pPhysicalDevices) {
my_data->instanceState->physicalDevicesCount = *pPhysicalDeviceCount;
log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT, 0, 0, DEVLIMITS_INVALID_INSTANCE, "DL",
"Invalid instance (%#" PRIxLEAST64 ") passed into vkEnumeratePhysicalDevices().", (uint64_t)instance);
}
- return VK_ERROR_VALIDATION_FAILED;
+ return VK_ERROR_VALIDATION_FAILED_EXT;
}
VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures)
skipCall |= validate_features_request(phy_dev_data);
}
if (skipCall)
- return VK_ERROR_VALIDATION_FAILED;
+ return VK_ERROR_VALIDATION_FAILED_EXT;
layer_data *my_device_data = get_my_data_ptr(get_dispatch_key(*pDevice), layer_data_map);
VkResult result = my_device_data->device_dispatch_table->CreateDevice(gpu, pCreateInfo, pAllocator, pDevice);
}
break;
default:
- return VK_ERROR_VALIDATION_FAILED;
+ return VK_ERROR_VALIDATION_FAILED_EXT;
break;
}
break;
skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, 0, 0, DRAWSTATE_NO_END_COMMAND_BUFFER, "DS",
"You must call vkEndCommandBuffer() on CB %#" PRIxLEAST64 " before this call to vkQueueSubmit()!", reinterpret_cast<uint64_t>(pCB->commandBuffer));
loader_platform_thread_unlock_mutex(&globalLock);
- return VK_ERROR_VALIDATION_FAILED;
+ return VK_ERROR_VALIDATION_FAILED_EXT;
}
loader_platform_thread_unlock_mutex(&globalLock);
}
}
if (VK_FALSE == skipCall)
return dev_data->device_dispatch_table->QueueSubmit(queue, submitCount, pSubmits, fence);
- return VK_ERROR_VALIDATION_FAILED;
+ return VK_ERROR_VALIDATION_FAILED_EXT;
}
VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator)
VkCommandPoolResetFlags flags)
{
layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
- VkResult result = VK_ERROR_VALIDATION_FAILED;
+ VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
result = dev_data->device_dispatch_table->ResetCommandPool(device, commandPool, flags);
// Reset all of the CBs allocated from this pool
delete pPipeNode[i];
}
}
- return VK_ERROR_VALIDATION_FAILED;
+ return VK_ERROR_VALIDATION_FAILED_EXT;
}
return result;
}
delete pPipeNode[i];
}
}
- return VK_ERROR_VALIDATION_FAILED;
+ return VK_ERROR_VALIDATION_FAILED_EXT;
}
return result;
}
if (NULL == pNewNode) {
if (log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT, (uint64_t) *pSetLayout, 0, DRAWSTATE_OUT_OF_MEMORY, "DS",
"Out of memory while attempting to allocate LAYOUT_NODE in vkCreateDescriptorSetLayout()"))
- return VK_ERROR_VALIDATION_FAILED;
+ return VK_ERROR_VALIDATION_FAILED_EXT;
}
memcpy((void*)&pNewNode->createInfo, pCreateInfo, sizeof(VkDescriptorSetLayoutCreateInfo));
pNewNode->createInfo.pBinding = new VkDescriptorSetLayoutBinding[pCreateInfo->bindingCount];
if (!pNewNode->bindings.insert(pCreateInfo->pBinding[i].binding).second) {
if (log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT, (uint64_t) *pSetLayout, 0, DRAWSTATE_INVALID_LAYOUT, "DS",
"duplicated binding number in VkDescriptorSetLayoutBinding"))
- return VK_ERROR_VALIDATION_FAILED;
+ return VK_ERROR_VALIDATION_FAILED_EXT;
}
totalCount += pCreateInfo->pBinding[i].descriptorCount;
// Insert this pool into Global Pool LL at head
if (log_msg(dev_data->report_data, VK_DEBUG_REPORT_INFO_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT, (uint64_t) *pDescriptorPool, 0, DRAWSTATE_OUT_OF_MEMORY, "DS",
"Created Descriptor Pool %#" PRIxLEAST64, (uint64_t) *pDescriptorPool))
- return VK_ERROR_VALIDATION_FAILED;
+ return VK_ERROR_VALIDATION_FAILED_EXT;
loader_platform_thread_lock_mutex(&globalLock);
DESCRIPTOR_POOL_NODE* pNewNode = new DESCRIPTOR_POOL_NODE(*pDescriptorPool, pCreateInfo);
if (NULL == pNewNode) {
if (log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT, (uint64_t) *pDescriptorPool, 0, DRAWSTATE_OUT_OF_MEMORY, "DS",
"Out of memory while attempting to allocate DESCRIPTOR_POOL_NODE in vkCreateDescriptorPool()"))
- return VK_ERROR_VALIDATION_FAILED;
+ return VK_ERROR_VALIDATION_FAILED_EXT;
} else {
dev_data->descriptorPoolMap[*pDescriptorPool] = pNewNode;
}
skipCall |= validate_descriptor_availability_in_pool(dev_data, pPoolNode, pAllocateInfo->setLayoutCount, pAllocateInfo->pSetLayouts);
}
if (skipCall)
- return VK_ERROR_VALIDATION_FAILED;
+ return VK_ERROR_VALIDATION_FAILED_EXT;
VkResult result = dev_data->device_dispatch_table->AllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets);
if (VK_SUCCESS == result) {
DESCRIPTOR_POOL_NODE *pPoolNode = getPoolNode(dev_data, pAllocateInfo->descriptorPool);
if (NULL == pNewNode) {
if (log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT, (uint64_t) pDescriptorSets[i], 0, DRAWSTATE_OUT_OF_MEMORY, "DS",
"Out of memory while attempting to allocate SET_NODE in vkAllocateDescriptorSets()"))
- return VK_ERROR_VALIDATION_FAILED;
+ return VK_ERROR_VALIDATION_FAILED_EXT;
} else {
memset(pNewNode, 0, sizeof(SET_NODE));
// TODO : Pool should store a total count of each type of Descriptor available
if (NULL == pLayout) {
if (log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT, (uint64_t) pAllocateInfo->pSetLayouts[i], 0, DRAWSTATE_INVALID_LAYOUT, "DS",
"Unable to find set layout node for layout %#" PRIxLEAST64 " specified in vkAllocateDescriptorSets() call", (uint64_t) pAllocateInfo->pSetLayouts[i]))
- return VK_ERROR_VALIDATION_FAILED;
+ return VK_ERROR_VALIDATION_FAILED_EXT;
}
pNewNode->pLayout = pLayout;
pNewNode->pool = pAllocateInfo->descriptorPool;
"It is invalid to call vkFreeDescriptorSets() with a pool created without setting VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT.");
}
if (skipCall)
- return VK_ERROR_VALIDATION_FAILED;
+ return VK_ERROR_VALIDATION_FAILED_EXT;
VkResult result = dev_data->device_dispatch_table->FreeDescriptorSets(device, descriptorPool, count, pDescriptorSets);
if (VK_SUCCESS == result) {
// For each freed descriptor add it back into the pool as available
"In vkBeginCommandBuffer() and unable to find CommandBuffer Node for CB %p!", (void*)commandBuffer);
}
if (skipCall) {
- return VK_ERROR_VALIDATION_FAILED;
+ return VK_ERROR_VALIDATION_FAILED_EXT;
}
VkResult result = dev_data->device_dispatch_table->BeginCommandBuffer(commandBuffer, pBeginInfo);
if ((VK_SUCCESS == result) && (pCB != NULL)) {
printCB(dev_data, commandBuffer);
}
} else {
- result = VK_ERROR_VALIDATION_FAILED;
+ result = VK_ERROR_VALIDATION_FAILED_EXT;
}
return result;
}
(uint64_t) commandBuffer, (uint64_t) cmdPool);
}
if (skipCall)
- return VK_ERROR_VALIDATION_FAILED;
+ return VK_ERROR_VALIDATION_FAILED_EXT;
VkResult result = dev_data->device_dispatch_table->ResetCommandBuffer(commandBuffer, flags);
if (VK_SUCCESS == result) {
resetCB(dev_data, commandBuffer);
}
if (skip_call)
- return VK_ERROR_VALIDATION_FAILED;
+ return VK_ERROR_VALIDATION_FAILED_EXT;
VkResult res = my_data->device_dispatch_table->CreateShaderModule(device, pCreateInfo, pAllocator, pShaderModule);
skip_call |= ValidateDependencies(dev_data, device, pCreateInfo, subpass_to_node);
skip_call |= ValidateLayouts(dev_data, device, pCreateInfo);
if (skip_call) {
- return VK_ERROR_VALIDATION_FAILED;
+ return VK_ERROR_VALIDATION_FAILED_EXT;
}
VkResult result = dev_data->device_dispatch_table->CreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass);
if (VK_SUCCESS == result) {
if (VK_FALSE == skip_call) {
return dev_data->device_dispatch_table->MapMemory(device, mem, offset, size, flags, ppData);
}
- return VK_ERROR_VALIDATION_FAILED;
+ return VK_ERROR_VALIDATION_FAILED_EXT;
}
VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory(
if (VK_FALSE == skip_call)
return dev_data->device_dispatch_table->QueuePresentKHR(queue, pPresentInfo);
- return VK_ERROR_VALIDATION_FAILED;
+ return VK_ERROR_VALIDATION_FAILED_EXT;
}
VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugReportCallbackEXT(
VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage)
{
VkBool32 skipCall = VK_FALSE;
- VkResult result = VK_ERROR_VALIDATION_FAILED;
+ VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
VkImageFormatProperties ImageFormatProperties = {0};
layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
}
}
if (skipCall)
- return VK_ERROR_VALIDATION_FAILED;
+ return VK_ERROR_VALIDATION_FAILED_EXT;
VkResult result = my_data->device_dispatch_table->CreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass);
}
if (skipCall)
- return VK_ERROR_VALIDATION_FAILED;
+ return VK_ERROR_VALIDATION_FAILED_EXT;
VkResult result = device_data->device_dispatch_table->CreateImageView(device, pCreateInfo, pAllocator, pView);
return result;
VkFence fence)
{
layer_data *my_data = get_my_data_ptr(get_dispatch_key(queue), layer_data_map);
- VkResult result = VK_ERROR_VALIDATION_FAILED;
+ VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
loader_platform_thread_lock_mutex(&globalLock);
// TODO : Need to track fence and clear mem references when fence clears
{
layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
VkBool32 skipCall = VK_FALSE;
- VkResult result = VK_ERROR_VALIDATION_FAILED;
+ VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
loader_platform_thread_lock_mutex(&globalLock);
MT_MEM_OBJ_INFO *pMemObj = get_mem_obj_info(my_data, mem);
uint32_t memRangeCount,
const VkMappedMemoryRange *pMemRanges)
{
- VkResult result = VK_ERROR_VALIDATION_FAILED;
+ VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
VkBool32 skipCall = VK_FALSE;
layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
uint32_t memRangeCount,
const VkMappedMemoryRange *pMemRanges)
{
- VkResult result = VK_ERROR_VALIDATION_FAILED;
+ VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
VkBool32 skipCall = VK_FALSE;
layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
VkDeviceSize memoryOffset)
{
layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
- VkResult result = VK_ERROR_VALIDATION_FAILED;
+ VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
loader_platform_thread_lock_mutex(&globalLock);
// Track objects tied to memory
VkBool32 skipCall = set_mem_binding(my_data, device, mem, (uint64_t)buffer, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, "vkBindBufferMemory");
VkDeviceSize memoryOffset)
{
layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
- VkResult result = VK_ERROR_VALIDATION_FAILED;
+ VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
loader_platform_thread_lock_mutex(&globalLock);
// Track objects tied to memory
VkBool32 skipCall = set_mem_binding(my_data, device, mem, (uint64_t)image, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, "vkBindImageMemory");
VkFence fence)
{
layer_data *my_data = get_my_data_ptr(get_dispatch_key(queue), layer_data_map);
- VkResult result = VK_ERROR_VALIDATION_FAILED;
+ VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
VkBool32 skipCall = VK_FALSE;
loader_platform_thread_lock_mutex(&globalLock);
const VkFence *pFences)
{
layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
- VkResult result = VK_ERROR_VALIDATION_FAILED;
+ VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
VkBool32 skipCall = VK_FALSE;
loader_platform_thread_lock_mutex(&globalLock);
layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
VkBool32 skipCall = verifyFenceStatus(device, fence, "vkGetFenceStatus");
if (skipCall)
- return VK_ERROR_VALIDATION_FAILED;
+ return VK_ERROR_VALIDATION_FAILED_EXT;
VkResult result = my_data->device_dispatch_table->GetFenceStatus(device, fence);
if (VK_SUCCESS == result) {
loader_platform_thread_lock_mutex(&globalLock);
skipCall |= verifyFenceStatus(device, pFences[i], "vkWaitForFences");
}
if (skipCall)
- return VK_ERROR_VALIDATION_FAILED;
+ return VK_ERROR_VALIDATION_FAILED_EXT;
VkResult result = my_data->device_dispatch_table->WaitForFences(device, fenceCount, pFences, waitAll, timeout);
loader_platform_thread_lock_mutex(&globalLock);
layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
VkBool32 commandBufferComplete = VK_FALSE;
VkBool32 skipCall = VK_FALSE;
- VkResult result = VK_ERROR_VALIDATION_FAILED;
+ VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
auto it = my_data->commandPoolMap[commandPool].pCommandBuffers.begin();
// Verify that CB's in pool are complete (not in-flight)
const VkCommandBufferBeginInfo *pBeginInfo)
{
layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
- VkResult result = VK_ERROR_VALIDATION_FAILED;
+ VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
VkBool32 skipCall = VK_FALSE;
VkBool32 commandBufferComplete = VK_FALSE;
loader_platform_thread_lock_mutex(&globalLock);
VkCommandBufferResetFlags flags)
{
layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
- VkResult result = VK_ERROR_VALIDATION_FAILED;
+ VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
VkBool32 skipCall = VK_FALSE;
VkBool32 commandBufferComplete = VK_FALSE;
loader_platform_thread_lock_mutex(&globalLock);
uint32_t *pImageIndex)
{
layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
- VkResult result = VK_ERROR_VALIDATION_FAILED;
+ VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
VkBool32 skipCall = VK_FALSE;
loader_platform_thread_lock_mutex(&globalLock);
skipCall |= validate_instance(instance, instance);
loader_platform_thread_unlock_mutex(&objLock);
if (skipCall)
- return VK_ERROR_VALIDATION_FAILED;
+ return VK_ERROR_VALIDATION_FAILED_EXT;
VkResult result = get_dispatch_table(ObjectTracker_instance_table_map, instance)->EnumeratePhysicalDevices(instance, pPhysicalDeviceCount, pPhysicalDevices);
loader_platform_thread_lock_mutex(&objLock);
if (result == VK_SUCCESS) {
skipCall |= validate_device(device, device);
loader_platform_thread_unlock_mutex(&objLock);
if (skipCall == VK_TRUE)
- return VK_ERROR_VALIDATION_FAILED;
+ return VK_ERROR_VALIDATION_FAILED_EXT;
VkResult result = get_dispatch_table(ObjectTracker_device_table_map, device)->MapMemory(device, mem, offset, size, flags, ppData);
loader_platform_thread_unlock_mutex(&objLock);
if (skipCall) {
- return VK_ERROR_VALIDATION_FAILED;
+ return VK_ERROR_VALIDATION_FAILED_EXT;
}
VkResult result = get_dispatch_table(ObjectTracker_device_table_map, device)->AllocateCommandBuffers(
}
loader_platform_thread_unlock_mutex(&objLock);
if (skipCall)
- return VK_ERROR_VALIDATION_FAILED;
+ return VK_ERROR_VALIDATION_FAILED_EXT;
VkResult result = get_dispatch_table(ObjectTracker_device_table_map, device)->AllocateDescriptorSets(
device, pAllocateInfo, pDescriptorSets);
skipCall |= validate_device(device, device);
loader_platform_thread_unlock_mutex(&objLock);
if (skipCall)
- return VK_ERROR_VALIDATION_FAILED;
+ return VK_ERROR_VALIDATION_FAILED_EXT;
VkResult result = get_dispatch_table(ObjectTracker_device_table_map, device)->GetSwapchainImagesKHR(device, swapchain, pCount, pSwapchainImages);
return result;
}
- return VK_ERROR_VALIDATION_FAILED;
+ return VK_ERROR_VALIDATION_FAILED_EXT;
}
VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice)
}
if (VK_TRUE == skipCall)
- return VK_ERROR_VALIDATION_FAILED;
+ return VK_ERROR_VALIDATION_FAILED_EXT;
layer_data *my_device_data = get_my_data_ptr(get_dispatch_key(*pDevice), layer_data_map);
// Call down the call chain:
return result;
}
- return VK_ERROR_VALIDATION_FAILED;
+ return VK_ERROR_VALIDATION_FAILED_EXT;
}
VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
return result;
}
- return VK_ERROR_VALIDATION_FAILED;
+ return VK_ERROR_VALIDATION_FAILED_EXT;
}
VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormatsKHR(
return result;
}
- return VK_ERROR_VALIDATION_FAILED;
+ return VK_ERROR_VALIDATION_FAILED_EXT;
}
VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModesKHR(
return result;
}
- return VK_ERROR_VALIDATION_FAILED;
+ return VK_ERROR_VALIDATION_FAILED_EXT;
}
// This function does the up-front validation work for vkCreateSwapchainKHR(),
return result;
}
- return VK_ERROR_VALIDATION_FAILED;
+ return VK_ERROR_VALIDATION_FAILED_EXT;
}
VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroySwapchainKHR(
return result;
}
- return VK_ERROR_VALIDATION_FAILED;
+ return VK_ERROR_VALIDATION_FAILED_EXT;
}
VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImageKHR(
return result;
}
- return VK_ERROR_VALIDATION_FAILED;
+ return VK_ERROR_VALIDATION_FAILED_EXT;
}
VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkQueuePresentKHR(
return result;
}
- return VK_ERROR_VALIDATION_FAILED;
+ return VK_ERROR_VALIDATION_FAILED_EXT;
}
static inline PFN_vkVoidFunction layer_intercept_proc(const char *name)
if len(loop_params) > 0:
using_line += ' if (skipCall)\n'
if proto.ret != "void":
- using_line += ' return VK_ERROR_VALIDATION_FAILED;\n'
+ using_line += ' return VK_ERROR_VALIDATION_FAILED_EXT;\n'
else:
using_line += ' return;\n'
ret_val = ''
projects / platform / upstream / Vulkan-Tools.git / commitdiff