CGNICO/UnrealEngine
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
c11d382a6f0acddb0bc1e95ab9bc5f8fc3570b55
UnrealEngine/Engine/Source/Runtime/VulkanRHI/Private/VulkanDebug.cpp
Jeffreytsai1004 c11d382a6f ue5-main
2025-05-18 13:04:45 +08:00

4760 lines
167 KiB
C++
Raw Blame History

// Copyright Epic Games, Inc. All Rights Reserved.
/*=============================================================================
VulkanDebug.cpp: Vulkan device RHI implementation.
=============================================================================*/
#include "VulkanRHIPrivate.h"
static FAutoConsoleVariable GCVarUniqueValidationMessages(
TEXT("r.Vulkan.UniqueValidationMessages"),
1,
TEXT("Filter out validation errors with the same code (only when r.Vulkan.EnableValidation is non zero)")
);
#define VULKAN_ENABLE_TRACKING_CALLSTACK 1
#define CREATE_MSG_CALLBACK "vkCreateDebugReportCallbackEXT"
#define DESTROY_MSG_CALLBACK "vkDestroyDebugReportCallbackEXT"
DEFINE_LOG_CATEGORY(LogVulkanRHI);
#if VULKAN_HAS_DEBUGGING_ENABLED
#if PLATFORM_ANDROID
#define VULKAN_REPORT_LOG(Format, ...) UE_LOG(LogVulkanRHI, Warning, Format, __VA_ARGS__)
#else
#define VULKAN_REPORT_LOG(Format, ...) do { if (FPlatformMisc::IsDebuggerPresent()) \
{ \
FPlatformMisc::LowLevelOutputDebugStringf(Format, __VA_ARGS__); FPlatformMisc::LowLevelOutputDebugString(TEXT("\n")); \
} \
UE_LOG(LogVulkanRHI, Warning, Format, __VA_ARGS__); } while (0)
#endif // PLATFORM_ANDROID
extern TAutoConsoleVariable<int32> GValidationCvar;
static VKAPI_ATTR VkBool32 VKAPI_CALL DebugUtilsCallback(VkDebugUtilsMessageSeverityFlagBitsEXT MsgSeverity,
VkDebugUtilsMessageTypeFlagsEXT MsgType, const VkDebugUtilsMessengerCallbackDataEXT* CallbackData, void* UserData)
{
const bool bError = (MsgSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT) != 0;
const bool bWarning = (MsgSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT) != 0;
const TCHAR* Severity = TEXT("");
if (bError)
{
ensure((MsgSeverity & ~VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT) == 0);
Severity = TEXT("Error");
}
else if (bWarning)
{
ensure((MsgSeverity & ~VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT) == 0);
Severity = TEXT("Warning");
}
else if (MsgSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT)
{
ensure((MsgSeverity & ~VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT) == 0);
Severity = TEXT("Info");
}
else if (MsgSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT)
{
ensure((MsgSeverity & ~VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT) == 0);
Severity = TEXT("Verbose");
}
enum class EMsgBucket
{
General,
GeneralValidation,
PerfValidation,
Validation,
Perf,
Count,
};
EMsgBucket MsgBucket = EMsgBucket::Count;
const TCHAR* Type = TEXT("");
if (MsgType & VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT)
{
if (MsgType & VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT)
{
ensure((MsgType & ~(VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT)) == 0);
Type = TEXT(" General/Validation");
MsgBucket = EMsgBucket::GeneralValidation;
}
else
{
ensure((MsgType & ~VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT) == 0);
Type = TEXT(" General");
MsgBucket = EMsgBucket::General;
}
}
else if (MsgType & VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT)
{
if (MsgType & VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT)
{
ensure((MsgType & ~(VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT)) == 0);
Type = TEXT("Perf/Validation");
MsgBucket = EMsgBucket::PerfValidation;
}
else
{
ensure((MsgType & ~VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT) == 0);
Type = TEXT("Validation");
MsgBucket = EMsgBucket::Validation;
}
}
else if (MsgType & VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT)
{
ensure((MsgType & ~VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT) == 0);
Type = TEXT("Perf");
MsgBucket = EMsgBucket::Perf;
}
if (!CallbackData->pMessageIdName)
{
VULKAN_REPORT_LOG(TEXT("*** [%s:%s(NULL)%d] %s"), Severity, Type, CallbackData->messageIdNumber, ANSI_TO_TCHAR(CallbackData->pMessage));
ensure(0);
return VK_FALSE;
}
if (!FCStringAnsi::Strcmp(CallbackData->pMessageIdName, "UNASSIGNED-CoreValidation-Shader-OutputNotConsumed") ||
!FCStringAnsi::Strcmp(CallbackData->pMessageIdName, "Undefined-Value-ShaderOutputNotConsumed"))
{
// Warning: *** [Warning:Validation-1(UNASSIGNED-CoreValidation-Shader-OutputNotConsumed)] fragment shader writes to output location 0 with no matching attachment
return VK_FALSE;
}
else if (!FCStringAnsi::Strcmp(CallbackData->pMessageIdName, "VUID-VkSwapchainCreateInfoKHR-imageExtent-01274")||
!FCStringAnsi::Strcmp(CallbackData->pMessageIdName, "VUID-VkSwapchainCreateInfoKHR-pNext-07781"))
{
// Warning: *** [Error:Validation341838324(VUID-VkSwapchainCreateInfoKHR-imageExtent-01274)] vkCreateSwapChainKHR() called with imageExtent = (8,8), which is outside the bounds returned by vkGetPhysicalDeviceSurfaceCapabilitiesKHR(): currentExtent = (0,0), minImageExtent = (0,0), maxImageExtent = (0,0).
return VK_FALSE;
}
else if (!FCStringAnsi::Strcmp(CallbackData->pMessageIdName, "UNASSIGNED-GPU-Assisted Validation Setup Error."))
{
// *** [Error:Validation(UNASSIGNED-GPU-Assisted Validation Setup Error.)] Unable to reserve descriptor binding slot on a device with only one slot.
return VK_FALSE;
}
else if (!FCStringAnsi::Strcmp(CallbackData->pMessageIdName, "VUID-RuntimeSpirv-Fragment-06427"))
{
// Warning: *** [Error:Validation(VUID-RuntimeSpirv-Fragment-06427)]
// False-positive in validation layers 1.3.250.1, known to be fixed in 1.3.268.0
return VK_FALSE;
}
else if (!FCStringAnsi::Strcmp(CallbackData->pMessageIdName, "UNASSIGNED-BestPractices-vkCreateDevice-deprecated-extension"))
{
// *** CreateDevice(): Attempting to enable deprecated extension VK_KHR_get_memory_requirements2, but this extension has been promoted to VK_VERSION_1_1.
return VK_FALSE;
}
else if (FCStringAnsi::Strstr(CallbackData->pMessage, "SPV_GOOGLE_hlsl_functionality1") != nullptr)
{
// *** [Error:Validation(VUID-VkShaderModuleCreateInfo-pCode-04147)] vkCreateShaderModule(): The SPIR-V Extension (SPV_GOOGLE_hlsl_functionality1) was declared, but none of the requirements were met to use it.
return VK_FALSE;
}
else if (FCStringAnsi::Strstr(CallbackData->pMessage, "SPV_GOOGLE_user_type") != nullptr)
{
// *** [Error:Validation(VUID-VkShaderModuleCreateInfo-pCode-04147)] vkCreateShaderModule(): The SPIR-V Extension (SPV_GOOGLE_user_type) was declared, but none of the requirements were met to use it.
return VK_FALSE;
}
else if (FCStringAnsi::Strstr(CallbackData->pMessage, "Cannot store to OpTypeImage, OpTypeSampler, OpTypeSampledImage, or OpTypeAccelerationStructure") != nullptr)
{
// *** [VUID-StandaloneSpirv-OpTypeImage-06924] Cannot store to OpTypeImage, OpTypeSampler, OpTypeSampledImage, or OpTypeAccelerationStructureKHR objects
// OpStore is called on OpTypeAccelerationStructure when they are used in bindless. Currently no side effects from it, skip until compiler fix is integrated.
return VK_FALSE;
}
static TStaticArray<TSet<uint32>, (int32)EMsgBucket::Count> SeenCodes;
bool bUniqueMessages = GCVarUniqueValidationMessages->GetInt() != 0;
bool bPrintMessage = true;
uint32 CRC = 0;
if (bUniqueMessages)
{
CRC = FCrc::StrCrc32(CallbackData->pMessageIdName);
bPrintMessage = !SeenCodes[(int32)MsgBucket].Contains(CRC);
}
if (bPrintMessage)
{
VULKAN_REPORT_LOG(TEXT("*** [%s:%s(%s)] %s"), Severity, Type, ANSI_TO_TCHAR(CallbackData->pMessageIdName), ANSI_TO_TCHAR(CallbackData->pMessage));
if (bUniqueMessages)
{
SeenCodes[(int32)MsgBucket].Add(CRC);
}
}
return VK_FALSE;
}
void FVulkanDynamicRHI::SetupDebugLayerCallback()
{
if (ActiveDebugLayerExtension == EActiveDebugLayerExtension::DebugUtilsExtension)
{
PFN_vkCreateDebugUtilsMessengerEXT CreateDebugUtilsMessengerEXT = (PFN_vkCreateDebugUtilsMessengerEXT)(void*)VulkanRHI::vkGetInstanceProcAddr(Instance, "vkCreateDebugUtilsMessengerEXT");
if (CreateDebugUtilsMessengerEXT)
{
VkDebugUtilsMessengerCreateInfoEXT CreateInfo;
ZeroVulkanStruct(CreateInfo, VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT);
const int32 CVar = GValidationCvar.GetValueOnRenderThread();
CreateInfo.messageSeverity = (CVar >= 1 ? VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT : 0) |
(CVar >= 2 ? VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT : 0) | (CVar >= 3 ? VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT : 0);
CreateInfo.messageType = (CVar >= 1 ? (VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT) : 0) |
(CVar >= 3 ? VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT : 0);
CreateInfo.pfnUserCallback = DebugUtilsCallback;
VkResult Result = (*CreateDebugUtilsMessengerEXT)(Instance, &CreateInfo, nullptr, &Messenger);
ensure(Result == VK_SUCCESS);
}
}
}
void FVulkanDynamicRHI::RemoveDebugLayerCallback()
{
if (Messenger != VK_NULL_HANDLE)
{
PFN_vkDestroyDebugUtilsMessengerEXT DestroyDebugUtilsMessengerEXT = (PFN_vkDestroyDebugUtilsMessengerEXT)(void*)VulkanRHI::vkGetInstanceProcAddr(Instance, "vkDestroyDebugUtilsMessengerEXT");
if (DestroyDebugUtilsMessengerEXT)
{
(*DestroyDebugUtilsMessengerEXT)(Instance, Messenger, nullptr);
}
}
}
#if VULKAN_ENABLE_TRACKING_LAYER || VULKAN_ENABLE_DUMP_LAYER
template <typename TResourceCreateInfoType>
struct TTrackingResource
{
FString DebugName = TEXT("null");
TResourceCreateInfoType CreateInfo;
#if VULKAN_ENABLE_TRACKING_CALLSTACK
FString CreateCallstack;
#endif
};
static FCriticalSection GTrackingCS;
#if VULKAN_ENABLE_TRACKING_CALLSTACK
#include "HAL/PlatformStackWalk.h"
static FCriticalSection GStackTraceMutex;
static char GStackTrace[65536];
static void CaptureCallStack(FString& OutCallstack, uint32 Delta)
{
FScopeLock ScopeLock(&GStackTraceMutex);
GStackTrace[0] = 0;
FPlatformStackWalk::StackWalkAndDump(GStackTrace, 65535, 3 + Delta);
OutCallstack = ANSI_TO_TCHAR(GStackTrace);
}
#endif
#endif
#if VULKAN_ENABLE_IMAGE_TRACKING_LAYER || VULKAN_ENABLE_DUMP_LAYER
struct FTrackingImage
{
struct
{
FString DebugName = TEXT("null");
VkImageCreateInfo CreateInfo;
bool bFromSwapchain = false;
} Info;
// ArrayLayers[Mips]
TArray<TArray<VkImageLayout>> ArrayLayouts;
#if VULKAN_ENABLE_TRACKING_CALLSTACK
struct FHistoryEntry
{
TArray<TArray<VkImageLayout>> ArrayLayouts;
FString Callstack;
};
TArray<FHistoryEntry> History;
FString CreateCallstack;
#endif
void Setup(uint32 NumArrayLayers, uint32 NumMips, VkImageLayout Layout, bool bFromSwapchain)
{
if (bFromSwapchain)
{
Info.CreateInfo.arrayLayers = 1;
Info.CreateInfo.imageType = VK_IMAGE_TYPE_2D;
Info.CreateInfo.mipLevels = 1;
Info.bFromSwapchain = bFromSwapchain;
}
ensure(NumArrayLayers > 0);
ensure(NumMips > 0);
ArrayLayouts.Empty(0);
ArrayLayouts.AddDefaulted(NumArrayLayers);
for (uint32 Index = 0; Index < NumArrayLayers; ++Index)
{
TArray<VkImageLayout>& MipLayouts = ArrayLayouts[Index];
MipLayouts.Empty(0);
for (uint32 MIndex = 0; MIndex < NumMips; ++MIndex)
{
MipLayouts.Add(Layout);
}
}
}
void Setup(const VkImageCreateInfo& CreateInfo, bool bFromSwapchain)
{
Info.CreateInfo = CreateInfo;
Info.bFromSwapchain = bFromSwapchain;
Setup(CreateInfo.arrayLayers, CreateInfo.mipLevels, CreateInfo.initialLayout, bFromSwapchain);
}
};
static TMap<VkImage, FTrackingImage> GVulkanTrackingImageLayouts;
static TMap<VkImageView, TTrackingResource<VkImageViewCreateInfo>> GVulkanTrackingImageViews;
static VkImage GBreakOnTrackImage = VK_NULL_HANDLE;
static VkImage GDumpTrackImage = VK_NULL_HANDLE;
static FORCEINLINE void BreakOnTrackingImage(VkImage InImage)
{
if (GBreakOnTrackImage != VK_NULL_HANDLE)
{
ensureAlways(InImage != GBreakOnTrackImage);
}
}
static FORCEINLINE bool DumpTrackImage(VkImage InImage)
{
return (GDumpTrackImage != VK_NULL_HANDLE) && (InImage == GDumpTrackImage);
}
static VkImage FindTrackingImage(VkImageView InView)
{
const auto& Found = GVulkanTrackingImageViews.FindChecked(InView);
return Found.CreateInfo.image;
}
static FORCEINLINE void BreakOnTrackingImageView(VkImageView InView)
{
BreakOnTrackingImage(FindTrackingImage(InView));
}
#endif
#if VULKAN_ENABLE_BUFFER_TRACKING_LAYER || VULKAN_ENABLE_DUMP_LAYER || VULKAN_ENABLE_IMAGE_TRACKING_LAYER
static TMap<VkBuffer, TTrackingResource<VkBufferCreateInfo>> GVulkanTrackingBuffers;
static TMap<VkBuffer, TArray<VkBufferView>> GVulkanTrackingBufferToBufferViews;
static TMap<VkBufferView, TTrackingResource<VkBufferViewCreateInfo>> GVulkanTrackingBufferViews;
static VkBuffer FindTrackingBuffer(VkBufferView InView)
{
const auto& Found = GVulkanTrackingBufferViews.FindChecked(InView);
return Found.CreateInfo.buffer;
}
#endif
static void ValidationFail()
{
ensure(0);
}
#if VULKAN_ENABLE_DUMP_LAYER || VULKAN_ENABLE_IMAGE_TRACKING_LAYER
#include "Misc/OutputDeviceRedirector.h"
namespace VulkanRHI
{
static FCriticalSection CS;
struct FMutexString
{
FString Inner;
FMutexString& operator += (const TCHAR* S)
{
FScopeLock Lock(&CS);
Inner += S;
return *this;
}
FMutexString& operator += (const char* S)
{
FScopeLock Lock(&CS);
Inner += ANSI_TO_TCHAR(S);
return *this;
}
FMutexString& operator += (const char S)
{
FScopeLock Lock(&CS);
char T[2] = "\0";
T[0] = S;
Inner += ANSI_TO_TCHAR(T);
return *this;
}
FMutexString& operator = (TCHAR T)
{
FScopeLock Lock(&CS);
Inner = TEXT("");
Inner += T;
return *this;
}
FMutexString& operator = (const TCHAR* S)
{
FScopeLock Lock(&CS);
Inner = S;
return *this;
}
FMutexString& operator += (const FString& S)
{
FScopeLock Lock(&CS);
Inner += S;
return *this;
}
int32 Len() const
{
FScopeLock Lock(&CS);
return Inner.Len();
}
};
static FMutexString DebugLog;
static int32 DebugLine = 1;
static const TCHAR* Tabs = TEXT("\t\t\t\t\t\t\t\t\t");
struct FRenderPassInfo
{
TArray<VkAttachmentDescription> Descriptions;
VkRenderPassCreateInfo Info;
};
static TMap<VkRenderPass, FRenderPassInfo> GRenderPassInfo;
struct FFBInfo
{
TArray<VkImageView> Attachments;
VkFramebufferCreateInfo Info;
};
static TMap<VkFramebuffer, FFBInfo> GFramebufferInfo;
void FlushDebugWrapperLog()
{
if (DebugLog.Len() > 0)
{
VULKAN_REPORT_LOG(TEXT("VULKANRHI: %s"), *DebugLog.Inner);
//GLog->Flush();
//UE_LOG(LogVulkanRHI, Display, TEXT("Vulkan Wrapper Log:\n%s"), *DebugLog);
//GLog->Flush();
DebugLog = TEXT("");
}
}
static void HandleFlushWrapperLog(const TArray<FString>& Args)
{
FlushDebugWrapperLog();
}
static FAutoConsoleCommand CVarVulkanFlushLog(
TEXT("r.Vulkan.FlushLog"),
TEXT("\n"),
FConsoleCommandWithArgsDelegate::CreateStatic(&HandleFlushWrapperLog)
);
static FString GetPipelineBindPointString(VkPipelineBindPoint BindPoint)
{
switch (BindPoint)
{
case VK_PIPELINE_BIND_POINT_GRAPHICS:
return TEXT("GFX");
case VK_PIPELINE_BIND_POINT_COMPUTE:
return TEXT("COMPUTE");
default:
break;
}
return FString::Printf(TEXT("Unknown VkPipelineBindPoint %d"), (int32)BindPoint);
}
static FString GetVkFormatString(VkFormat Format)
{
switch (Format)
{
// + 10 to skip "VK_FORMAT"
#define VKSWITCHCASE(x) case x: return &TEXT(#x)[10];
VKSWITCHCASE(VK_FORMAT_UNDEFINED)
VKSWITCHCASE(VK_FORMAT_R4G4_UNORM_PACK8)
VKSWITCHCASE(VK_FORMAT_R4G4B4A4_UNORM_PACK16)
VKSWITCHCASE(VK_FORMAT_B4G4R4A4_UNORM_PACK16)
VKSWITCHCASE(VK_FORMAT_R5G6B5_UNORM_PACK16)
VKSWITCHCASE(VK_FORMAT_B5G6R5_UNORM_PACK16)
VKSWITCHCASE(VK_FORMAT_R5G5B5A1_UNORM_PACK16)
VKSWITCHCASE(VK_FORMAT_B5G5R5A1_UNORM_PACK16)
VKSWITCHCASE(VK_FORMAT_A1R5G5B5_UNORM_PACK16)
VKSWITCHCASE(VK_FORMAT_R8_UNORM)
VKSWITCHCASE(VK_FORMAT_R8_SNORM)
VKSWITCHCASE(VK_FORMAT_R8_USCALED)
VKSWITCHCASE(VK_FORMAT_R8_SSCALED)
VKSWITCHCASE(VK_FORMAT_R8_UINT)
VKSWITCHCASE(VK_FORMAT_R8_SINT)
VKSWITCHCASE(VK_FORMAT_R8_SRGB)
VKSWITCHCASE(VK_FORMAT_R8G8_UNORM)
VKSWITCHCASE(VK_FORMAT_R8G8_SNORM)
VKSWITCHCASE(VK_FORMAT_R8G8_USCALED)
VKSWITCHCASE(VK_FORMAT_R8G8_SSCALED)
VKSWITCHCASE(VK_FORMAT_R8G8_UINT)
VKSWITCHCASE(VK_FORMAT_R8G8_SINT)
VKSWITCHCASE(VK_FORMAT_R8G8_SRGB)
VKSWITCHCASE(VK_FORMAT_R8G8B8_UNORM)
VKSWITCHCASE(VK_FORMAT_R8G8B8_SNORM)
VKSWITCHCASE(VK_FORMAT_R8G8B8_USCALED)
VKSWITCHCASE(VK_FORMAT_R8G8B8_SSCALED)
VKSWITCHCASE(VK_FORMAT_R8G8B8_UINT)
VKSWITCHCASE(VK_FORMAT_R8G8B8_SINT)
VKSWITCHCASE(VK_FORMAT_R8G8B8_SRGB)
VKSWITCHCASE(VK_FORMAT_B8G8R8_UNORM)
VKSWITCHCASE(VK_FORMAT_B8G8R8_SNORM)
VKSWITCHCASE(VK_FORMAT_B8G8R8_USCALED)
VKSWITCHCASE(VK_FORMAT_B8G8R8_SSCALED)
VKSWITCHCASE(VK_FORMAT_B8G8R8_UINT)
VKSWITCHCASE(VK_FORMAT_B8G8R8_SINT)
VKSWITCHCASE(VK_FORMAT_B8G8R8_SRGB)
VKSWITCHCASE(VK_FORMAT_R8G8B8A8_UNORM)
VKSWITCHCASE(VK_FORMAT_R8G8B8A8_SNORM)
VKSWITCHCASE(VK_FORMAT_R8G8B8A8_USCALED)
VKSWITCHCASE(VK_FORMAT_R8G8B8A8_SSCALED)
VKSWITCHCASE(VK_FORMAT_R8G8B8A8_UINT)
VKSWITCHCASE(VK_FORMAT_R8G8B8A8_SINT)
VKSWITCHCASE(VK_FORMAT_R8G8B8A8_SRGB)
VKSWITCHCASE(VK_FORMAT_B8G8R8A8_UNORM)
VKSWITCHCASE(VK_FORMAT_B8G8R8A8_SNORM)
VKSWITCHCASE(VK_FORMAT_B8G8R8A8_USCALED)
VKSWITCHCASE(VK_FORMAT_B8G8R8A8_SSCALED)
VKSWITCHCASE(VK_FORMAT_B8G8R8A8_UINT)
VKSWITCHCASE(VK_FORMAT_B8G8R8A8_SINT)
VKSWITCHCASE(VK_FORMAT_B8G8R8A8_SRGB)
VKSWITCHCASE(VK_FORMAT_A8B8G8R8_UNORM_PACK32)
VKSWITCHCASE(VK_FORMAT_A8B8G8R8_SNORM_PACK32)
VKSWITCHCASE(VK_FORMAT_A8B8G8R8_USCALED_PACK32)
VKSWITCHCASE(VK_FORMAT_A8B8G8R8_SSCALED_PACK32)
VKSWITCHCASE(VK_FORMAT_A8B8G8R8_UINT_PACK32)
VKSWITCHCASE(VK_FORMAT_A8B8G8R8_SINT_PACK32)
VKSWITCHCASE(VK_FORMAT_A8B8G8R8_SRGB_PACK32)
VKSWITCHCASE(VK_FORMAT_A2R10G10B10_UNORM_PACK32)
VKSWITCHCASE(VK_FORMAT_A2R10G10B10_SNORM_PACK32)
VKSWITCHCASE(VK_FORMAT_A2R10G10B10_USCALED_PACK32)
VKSWITCHCASE(VK_FORMAT_A2R10G10B10_SSCALED_PACK32)
VKSWITCHCASE(VK_FORMAT_A2R10G10B10_UINT_PACK32)
VKSWITCHCASE(VK_FORMAT_A2R10G10B10_SINT_PACK32)
VKSWITCHCASE(VK_FORMAT_A2B10G10R10_UNORM_PACK32)
VKSWITCHCASE(VK_FORMAT_A2B10G10R10_SNORM_PACK32)
VKSWITCHCASE(VK_FORMAT_A2B10G10R10_USCALED_PACK32)
VKSWITCHCASE(VK_FORMAT_A2B10G10R10_SSCALED_PACK32)
VKSWITCHCASE(VK_FORMAT_A2B10G10R10_UINT_PACK32)
VKSWITCHCASE(VK_FORMAT_A2B10G10R10_SINT_PACK32)
VKSWITCHCASE(VK_FORMAT_R16_UNORM)
VKSWITCHCASE(VK_FORMAT_R16_SNORM)
VKSWITCHCASE(VK_FORMAT_R16_USCALED)
VKSWITCHCASE(VK_FORMAT_R16_SSCALED)
VKSWITCHCASE(VK_FORMAT_R16_UINT)
VKSWITCHCASE(VK_FORMAT_R16_SINT)
VKSWITCHCASE(VK_FORMAT_R16_SFLOAT)
VKSWITCHCASE(VK_FORMAT_R16G16_UNORM)
VKSWITCHCASE(VK_FORMAT_R16G16_SNORM)
VKSWITCHCASE(VK_FORMAT_R16G16_USCALED)
VKSWITCHCASE(VK_FORMAT_R16G16_SSCALED)
VKSWITCHCASE(VK_FORMAT_R16G16_UINT)
VKSWITCHCASE(VK_FORMAT_R16G16_SINT)
VKSWITCHCASE(VK_FORMAT_R16G16_SFLOAT)
VKSWITCHCASE(VK_FORMAT_R16G16B16_UNORM)
VKSWITCHCASE(VK_FORMAT_R16G16B16_SNORM)
VKSWITCHCASE(VK_FORMAT_R16G16B16_USCALED)
VKSWITCHCASE(VK_FORMAT_R16G16B16_SSCALED)
VKSWITCHCASE(VK_FORMAT_R16G16B16_UINT)
VKSWITCHCASE(VK_FORMAT_R16G16B16_SINT)
VKSWITCHCASE(VK_FORMAT_R16G16B16_SFLOAT)
VKSWITCHCASE(VK_FORMAT_R16G16B16A16_UNORM)
VKSWITCHCASE(VK_FORMAT_R16G16B16A16_SNORM)
VKSWITCHCASE(VK_FORMAT_R16G16B16A16_USCALED)
VKSWITCHCASE(VK_FORMAT_R16G16B16A16_SSCALED)
VKSWITCHCASE(VK_FORMAT_R16G16B16A16_UINT)
VKSWITCHCASE(VK_FORMAT_R16G16B16A16_SINT)
VKSWITCHCASE(VK_FORMAT_R16G16B16A16_SFLOAT)
VKSWITCHCASE(VK_FORMAT_R32_UINT)
VKSWITCHCASE(VK_FORMAT_R32_SINT)
VKSWITCHCASE(VK_FORMAT_R32_SFLOAT)
VKSWITCHCASE(VK_FORMAT_R32G32_UINT)
VKSWITCHCASE(VK_FORMAT_R32G32_SINT)
VKSWITCHCASE(VK_FORMAT_R32G32_SFLOAT)
VKSWITCHCASE(VK_FORMAT_R32G32B32_UINT)
VKSWITCHCASE(VK_FORMAT_R32G32B32_SINT)
VKSWITCHCASE(VK_FORMAT_R32G32B32_SFLOAT)
VKSWITCHCASE(VK_FORMAT_R32G32B32A32_UINT)
VKSWITCHCASE(VK_FORMAT_R32G32B32A32_SINT)
VKSWITCHCASE(VK_FORMAT_R32G32B32A32_SFLOAT)
VKSWITCHCASE(VK_FORMAT_R64_UINT)
VKSWITCHCASE(VK_FORMAT_R64_SINT)
VKSWITCHCASE(VK_FORMAT_R64_SFLOAT)
VKSWITCHCASE(VK_FORMAT_R64G64_UINT)
VKSWITCHCASE(VK_FORMAT_R64G64_SINT)
VKSWITCHCASE(VK_FORMAT_R64G64_SFLOAT)
VKSWITCHCASE(VK_FORMAT_R64G64B64_UINT)
VKSWITCHCASE(VK_FORMAT_R64G64B64_SINT)
VKSWITCHCASE(VK_FORMAT_R64G64B64_SFLOAT)
VKSWITCHCASE(VK_FORMAT_R64G64B64A64_UINT)
VKSWITCHCASE(VK_FORMAT_R64G64B64A64_SINT)
VKSWITCHCASE(VK_FORMAT_R64G64B64A64_SFLOAT)
VKSWITCHCASE(VK_FORMAT_B10G11R11_UFLOAT_PACK32)
VKSWITCHCASE(VK_FORMAT_E5B9G9R9_UFLOAT_PACK32)
VKSWITCHCASE(VK_FORMAT_D16_UNORM)
VKSWITCHCASE(VK_FORMAT_X8_D24_UNORM_PACK32)
VKSWITCHCASE(VK_FORMAT_D32_SFLOAT)
VKSWITCHCASE(VK_FORMAT_S8_UINT)
VKSWITCHCASE(VK_FORMAT_D16_UNORM_S8_UINT)
VKSWITCHCASE(VK_FORMAT_D24_UNORM_S8_UINT)
VKSWITCHCASE(VK_FORMAT_D32_SFLOAT_S8_UINT)
VKSWITCHCASE(VK_FORMAT_BC1_RGB_UNORM_BLOCK)
VKSWITCHCASE(VK_FORMAT_BC1_RGB_SRGB_BLOCK)
VKSWITCHCASE(VK_FORMAT_BC1_RGBA_UNORM_BLOCK)
VKSWITCHCASE(VK_FORMAT_BC1_RGBA_SRGB_BLOCK)
VKSWITCHCASE(VK_FORMAT_BC2_UNORM_BLOCK)
VKSWITCHCASE(VK_FORMAT_BC2_SRGB_BLOCK)
VKSWITCHCASE(VK_FORMAT_BC3_UNORM_BLOCK)
VKSWITCHCASE(VK_FORMAT_BC3_SRGB_BLOCK)
VKSWITCHCASE(VK_FORMAT_BC4_UNORM_BLOCK)
VKSWITCHCASE(VK_FORMAT_BC4_SNORM_BLOCK)
VKSWITCHCASE(VK_FORMAT_BC5_UNORM_BLOCK)
VKSWITCHCASE(VK_FORMAT_BC5_SNORM_BLOCK)
VKSWITCHCASE(VK_FORMAT_BC6H_UFLOAT_BLOCK)
VKSWITCHCASE(VK_FORMAT_BC6H_SFLOAT_BLOCK)
VKSWITCHCASE(VK_FORMAT_BC7_UNORM_BLOCK)
VKSWITCHCASE(VK_FORMAT_BC7_SRGB_BLOCK)
VKSWITCHCASE(VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK)
VKSWITCHCASE(VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK)
VKSWITCHCASE(VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK)
VKSWITCHCASE(VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK)
VKSWITCHCASE(VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK)
VKSWITCHCASE(VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK)
VKSWITCHCASE(VK_FORMAT_EAC_R11_UNORM_BLOCK)
VKSWITCHCASE(VK_FORMAT_EAC_R11_SNORM_BLOCK)
VKSWITCHCASE(VK_FORMAT_EAC_R11G11_UNORM_BLOCK)
VKSWITCHCASE(VK_FORMAT_EAC_R11G11_SNORM_BLOCK)
VKSWITCHCASE(VK_FORMAT_ASTC_4x4_UNORM_BLOCK)
VKSWITCHCASE(VK_FORMAT_ASTC_4x4_SRGB_BLOCK)
VKSWITCHCASE(VK_FORMAT_ASTC_5x4_UNORM_BLOCK)
VKSWITCHCASE(VK_FORMAT_ASTC_5x4_SRGB_BLOCK)
VKSWITCHCASE(VK_FORMAT_ASTC_5x5_UNORM_BLOCK)
VKSWITCHCASE(VK_FORMAT_ASTC_5x5_SRGB_BLOCK)
VKSWITCHCASE(VK_FORMAT_ASTC_6x5_UNORM_BLOCK)
VKSWITCHCASE(VK_FORMAT_ASTC_6x5_SRGB_BLOCK)
VKSWITCHCASE(VK_FORMAT_ASTC_6x6_UNORM_BLOCK)
VKSWITCHCASE(VK_FORMAT_ASTC_6x6_SRGB_BLOCK)
VKSWITCHCASE(VK_FORMAT_ASTC_8x5_UNORM_BLOCK)
VKSWITCHCASE(VK_FORMAT_ASTC_8x5_SRGB_BLOCK)
VKSWITCHCASE(VK_FORMAT_ASTC_8x6_UNORM_BLOCK)
VKSWITCHCASE(VK_FORMAT_ASTC_8x6_SRGB_BLOCK)
VKSWITCHCASE(VK_FORMAT_ASTC_8x8_UNORM_BLOCK)
VKSWITCHCASE(VK_FORMAT_ASTC_8x8_SRGB_BLOCK)
VKSWITCHCASE(VK_FORMAT_ASTC_10x5_UNORM_BLOCK)
VKSWITCHCASE(VK_FORMAT_ASTC_10x5_SRGB_BLOCK)
VKSWITCHCASE(VK_FORMAT_ASTC_10x6_UNORM_BLOCK)
VKSWITCHCASE(VK_FORMAT_ASTC_10x6_SRGB_BLOCK)
VKSWITCHCASE(VK_FORMAT_ASTC_10x8_UNORM_BLOCK)
VKSWITCHCASE(VK_FORMAT_ASTC_10x8_SRGB_BLOCK)
VKSWITCHCASE(VK_FORMAT_ASTC_10x10_UNORM_BLOCK)
VKSWITCHCASE(VK_FORMAT_ASTC_10x10_SRGB_BLOCK)
VKSWITCHCASE(VK_FORMAT_ASTC_12x10_UNORM_BLOCK)
VKSWITCHCASE(VK_FORMAT_ASTC_12x10_SRGB_BLOCK)
VKSWITCHCASE(VK_FORMAT_ASTC_12x12_UNORM_BLOCK)
VKSWITCHCASE(VK_FORMAT_ASTC_12x12_SRGB_BLOCK)
#undef VKSWITCHCASE
default:
break;
}
return FString::Printf(TEXT("Unknown VkFormat %d"), (int32)Format);
}
static FString GetVkResultErrorString(VkResult Result)
{
switch (Result)
{
// + 3 to skip "VK_"
#define VKSWITCHCASE(x) case x: return &TEXT(#x)[3];
VKSWITCHCASE(VK_SUCCESS)
VKSWITCHCASE(VK_NOT_READY)
VKSWITCHCASE(VK_TIMEOUT)
VKSWITCHCASE(VK_EVENT_SET)
VKSWITCHCASE(VK_EVENT_RESET)
VKSWITCHCASE(VK_INCOMPLETE)
VKSWITCHCASE(VK_ERROR_OUT_OF_HOST_MEMORY)
VKSWITCHCASE(VK_ERROR_OUT_OF_DEVICE_MEMORY)
VKSWITCHCASE(VK_ERROR_INITIALIZATION_FAILED)
VKSWITCHCASE(VK_ERROR_DEVICE_LOST)
VKSWITCHCASE(VK_ERROR_MEMORY_MAP_FAILED)
VKSWITCHCASE(VK_ERROR_LAYER_NOT_PRESENT)
VKSWITCHCASE(VK_ERROR_EXTENSION_NOT_PRESENT)
VKSWITCHCASE(VK_ERROR_FEATURE_NOT_PRESENT)
VKSWITCHCASE(VK_ERROR_INCOMPATIBLE_DRIVER)
VKSWITCHCASE(VK_ERROR_TOO_MANY_OBJECTS)
VKSWITCHCASE(VK_ERROR_FORMAT_NOT_SUPPORTED)
VKSWITCHCASE(VK_ERROR_SURFACE_LOST_KHR)
VKSWITCHCASE(VK_ERROR_NATIVE_WINDOW_IN_USE_KHR)
VKSWITCHCASE(VK_SUBOPTIMAL_KHR)
VKSWITCHCASE(VK_ERROR_OUT_OF_DATE_KHR)
VKSWITCHCASE(VK_ERROR_INCOMPATIBLE_DISPLAY_KHR)
VKSWITCHCASE(VK_ERROR_VALIDATION_FAILED_EXT)
VKSWITCHCASE(VK_ERROR_INVALID_SHADER_NV)
VKSWITCHCASE(VK_ERROR_FRAGMENTED_POOL)
VKSWITCHCASE(VK_ERROR_OUT_OF_POOL_MEMORY_KHR)
VKSWITCHCASE(VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR)
VKSWITCHCASE(VK_ERROR_NOT_PERMITTED_EXT)
#undef VKSWITCHCASE
default:
break;
}
return FString::Printf(TEXT("Unknown VkResult %d"), (int32)Result);
}
static FString GetVkImageTilingString(VkImageTiling Tiling)
{
switch (Tiling)
{
// + 16 to skip "VK_IMAGE_TILING_"
#define VKSWITCHCASE(x) case x: return &TEXT(#x)[16];
VKSWITCHCASE(VK_IMAGE_TILING_OPTIMAL)
VKSWITCHCASE(VK_IMAGE_TILING_LINEAR)
#undef VKSWITCHCASE
default:
break;
}
return FString::Printf(TEXT("Unknown VkImageTiling %d"), (int32)Tiling);
}
static FString GetVkImageLayoutString(VkImageLayout Layout)
{
return FString(VK_TYPE_TO_STRING(VkImageLayout, Layout)).RightChop(16);
}
static FString GetVkImageViewTypeString(VkImageViewType Type)
{
return FString(VK_TYPE_TO_STRING(VkImageViewType, Type)).RightChop(19);
}
static FString GetVkImageTypeString(VkImageType Type)
{
return FString(VK_TYPE_TO_STRING(VkImageType, Type)).RightChop(14);
}
static FString GetVkDescriptorTypeString(VkDescriptorType Type)
{
switch (Type)
{
// + 19 to skip "VK_DESCRIPTOR_TYPE_"
#define VKSWITCHCASE(x) case x: return &TEXT(#x)[19];
VKSWITCHCASE(VK_DESCRIPTOR_TYPE_SAMPLER)
VKSWITCHCASE(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER)
VKSWITCHCASE(VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE)
VKSWITCHCASE(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE)
VKSWITCHCASE(VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER)
VKSWITCHCASE(VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER)
VKSWITCHCASE(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER)
VKSWITCHCASE(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER)
VKSWITCHCASE(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC)
VKSWITCHCASE(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC)
VKSWITCHCASE(VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT)
#undef VKSWITCHCASE
default:
break;
}
return FString::Printf(TEXT("Unknown VkDescriptorType %d"), (int32)Type);
}
static FString GetVkStencilOpString(VkStencilOp Op)
{
switch (Op)
{
// + 14 to skip "VK_STENCIL_OP_"
#define VKSWITCHCASE(x) case x: return &TEXT(#x)[14];
VKSWITCHCASE(VK_STENCIL_OP_KEEP)
VKSWITCHCASE(VK_STENCIL_OP_ZERO)
VKSWITCHCASE(VK_STENCIL_OP_REPLACE)
VKSWITCHCASE(VK_STENCIL_OP_INCREMENT_AND_CLAMP)
VKSWITCHCASE(VK_STENCIL_OP_DECREMENT_AND_CLAMP)
VKSWITCHCASE(VK_STENCIL_OP_INVERT)
VKSWITCHCASE(VK_STENCIL_OP_INCREMENT_AND_WRAP)
VKSWITCHCASE(VK_STENCIL_OP_DECREMENT_AND_WRAP)
#undef VKSWITCHCASE
default:
break;
}
return FString::Printf(TEXT("Unknown VkStencilOp %d"), (int32)Op);
}
static FString GetVkCompareOpString(VkCompareOp Op)
{
switch (Op)
{
// + 14 to skip "VK_COMPARE_OP_"
#define VKSWITCHCASE(x) case x: return &TEXT(#x)[14];
VKSWITCHCASE(VK_COMPARE_OP_NEVER)
VKSWITCHCASE(VK_COMPARE_OP_LESS)
VKSWITCHCASE(VK_COMPARE_OP_EQUAL)
VKSWITCHCASE(VK_COMPARE_OP_LESS_OR_EQUAL)
VKSWITCHCASE(VK_COMPARE_OP_GREATER)
VKSWITCHCASE(VK_COMPARE_OP_NOT_EQUAL)
VKSWITCHCASE(VK_COMPARE_OP_GREATER_OR_EQUAL)
VKSWITCHCASE(VK_COMPARE_OP_ALWAYS)
#undef VKSWITCHCASE
default:
break;
}
return FString::Printf(TEXT("Unknown VkStencilOp %d"), (int32)Op);
}
static FString GetVkComponentMappingString(const VkComponentMapping& Mapping)
{
auto GetSwizzle = [](VkComponentSwizzle Swizzle) -> const TCHAR*
{
switch (Swizzle)
{
case VK_COMPONENT_SWIZZLE_IDENTITY: return TEXT("ID");
case VK_COMPONENT_SWIZZLE_ZERO: return TEXT("0");
case VK_COMPONENT_SWIZZLE_ONE: return TEXT("1");
case VK_COMPONENT_SWIZZLE_R: return TEXT("R");
case VK_COMPONENT_SWIZZLE_G: return TEXT("G");
case VK_COMPONENT_SWIZZLE_B: return TEXT("B");
case VK_COMPONENT_SWIZZLE_A: return TEXT("A");
default:
check(0);
return TEXT("-");
}
};
return FString::Printf(TEXT("(r=%s, g=%s, b=%s, a=%s)"), GetSwizzle(Mapping.r), GetSwizzle(Mapping.g), GetSwizzle(Mapping.b), GetSwizzle(Mapping.a));
}
#define AppendBitFieldName(BitField, Name) \
if ((Flags & BitField) == BitField)\
{\
Flags &= ~BitField;\
if (String.Len() > 0)\
{\
String += TEXT("|");\
}\
String += Name;\
}
static FString GetAspectMaskString(VkImageAspectFlags Flags)
{
if (Flags == 0)
{
return TEXT("0");
}
FString String;
AppendBitFieldName(VK_IMAGE_ASPECT_COLOR_BIT, TEXT("COLOR"));
AppendBitFieldName(VK_IMAGE_ASPECT_DEPTH_BIT, TEXT("DEPTH"));
AppendBitFieldName(VK_IMAGE_ASPECT_STENCIL_BIT, TEXT("STENCIL"));
AppendBitFieldName(VK_IMAGE_ASPECT_METADATA_BIT, TEXT("METADATA"));
if (Flags != 0)
{
FString Unknown = FString::Printf(TEXT("%d"), Flags);
AppendBitFieldName(Flags, Unknown);
}
return String;
}
FString GetSampleCountString(VkSampleCountFlags Flags)
{
if (Flags == 0)
{
return TEXT("0");
}
FString String;
AppendBitFieldName(VK_SAMPLE_COUNT_1_BIT, TEXT("1"));
AppendBitFieldName(VK_SAMPLE_COUNT_2_BIT, TEXT("2"));
AppendBitFieldName(VK_SAMPLE_COUNT_4_BIT, TEXT("4"));
AppendBitFieldName(VK_SAMPLE_COUNT_8_BIT, TEXT("8"));
AppendBitFieldName(VK_SAMPLE_COUNT_16_BIT, TEXT("16"));
AppendBitFieldName(VK_SAMPLE_COUNT_32_BIT, TEXT("32"));
AppendBitFieldName(VK_SAMPLE_COUNT_64_BIT, TEXT("64"));
if (Flags != 0)
{
FString Unknown = FString::Printf(TEXT("%d"), Flags);
AppendBitFieldName(Flags, Unknown);
}
return String;
}
FString GetImageUsageString(VkImageUsageFlags Flags)
{
if (Flags == 0)
{
return TEXT("0");
}
FString String;
AppendBitFieldName(VK_IMAGE_USAGE_TRANSFER_SRC_BIT, TEXT("XFER_SRC"));
AppendBitFieldName(VK_IMAGE_USAGE_TRANSFER_DST_BIT, TEXT("XFER_DST"));
AppendBitFieldName(VK_IMAGE_USAGE_SAMPLED_BIT, TEXT("SAMPLED"));
AppendBitFieldName(VK_IMAGE_USAGE_STORAGE_BIT, TEXT("STORAGE"));
AppendBitFieldName(VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, TEXT("COLOR_ATT"));
AppendBitFieldName(VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, TEXT("DS_ATT"));
AppendBitFieldName(VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT, TEXT("TRANS_ATT"));
AppendBitFieldName(VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT, TEXT("IN_ATT"));
if (Flags != 0)
{
FString Unknown = FString::Printf(TEXT("%d"), Flags);
AppendBitFieldName(Flags, Unknown);
}
return String;
}
#undef AppendBitFieldName
static FString GetImageSubresourceLayers(const VkImageSubresourceLayers& Layer)
{
return FString::Printf(TEXT("Aspect=%s MipLvl=%d BaseArray=%d NumLayers=%d"), *GetAspectMaskString(Layer.aspectMask), Layer.mipLevel, Layer.baseArrayLayer, Layer.layerCount);
}
FString GetExtentString(const VkExtent3D& Extent)
{
return FString::Printf(TEXT("w:%d h:%d d:%d"), Extent.width, Extent.height, Extent.depth);
}
static FString GetExtentString(const VkExtent2D& Extent)
{
return FString::Printf(TEXT("w:%d h:%d"), Extent.width, Extent.height);
}
static FString GetOffsetString(const VkOffset3D& Offset)
{
return FString::Printf(TEXT("x:%d y:%d z:%d"), Offset.x, Offset.y, Offset.z);
}
static FString GetOffsetString(const VkOffset2D& Offset)
{
return FString::Printf(TEXT("x:%d y:%d"), Offset.x, Offset.y);
}
static FString GetRectString(const VkRect2D& Rect)
{
return FString::Printf(TEXT("%s %s"), *GetOffsetString(Rect.offset), *GetExtentString(Rect.extent));
}
FString GetBufferImageCopyString(const VkBufferImageCopy& Region)
{
return FString::Printf(TEXT("BufOff=%d BufRow=%d BufImgHeight=%d ImgSubR=[%s] ImgOff=[%s] ImgExt=[%s]"),
Region.bufferOffset, Region.bufferRowLength, Region.bufferImageHeight, *GetImageSubresourceLayers(Region.imageSubresource),
*GetOffsetString(Region.imageOffset), *GetExtentString(Region.imageExtent));
}
static FString GetImageSubResourceRangeString(const VkImageSubresourceRange& Range)
{
return FString::Printf(TEXT("AspectMask=%s, BaseMip=%d, NumLevels=%d, BaseArrayLayer=%d, NumLayers=%d"), *GetAspectMaskString(Range.aspectMask), Range.baseMipLevel, Range.levelCount, Range.baseArrayLayer, Range.layerCount);
}
static FString GetClearColorValueString(const VkClearColorValue& Value)
{
return FString::Printf(TEXT("0x%x(%f), 0x%x(%f), 0x%x(%f), 0x%x(%f)"),
Value.uint32[0], Value.float32[0],
Value.uint32[1], Value.float32[1],
Value.uint32[2], Value.float32[2],
Value.uint32[3], Value.float32[3]);
}
static FString GetClearDepthStencilValueString(const VkClearDepthStencilValue& Value)
{
return FString::Printf(TEXT("d:%f s:%d"), Value.depth, Value.stencil);
}
static FString GetClearValueString(const VkClearValue& Value)
{
return FString::Printf(TEXT("(%s/%s)"), *GetClearColorValueString(Value.color), *GetClearDepthStencilValueString(Value.depthStencil));
}
void PrintfBeginResult(const FString& String)
{
DebugLog += FString::Printf(TEXT("[GLOBAL METHOD] %8d: %s"), DebugLine++, *String);
FlushDebugWrapperLog();
}
void PrintfBegin(const FString& String)
{
DebugLog += FString::Printf(TEXT("[GLOBAL METHOD] %8d: %s\n"), DebugLine++, *String);
FlushDebugWrapperLog();
}
void DevicePrintfBeginResult(VkDevice Device, const FString& String)
{
DebugLog += FString::Printf(TEXT("[D:0x%p]%8d: %s"), Device, DebugLine++, *String);
FlushDebugWrapperLog();
}
void DevicePrintfBegin(VkDevice Device, const FString& String)
{
DebugLog += FString::Printf(TEXT("[D:0x%p]%8d: %s\n"), Device, DebugLine++, *String);
FlushDebugWrapperLog();
}
void CmdPrintfBegin(VkCommandBuffer CmdBuffer, const FString& String)
{
DebugLog += FString::Printf(TEXT("[C:0x%p]%8d: %s\n"), CmdBuffer, DebugLine++, *String);
FlushDebugWrapperLog();
}
void CmdPrintfBeginResult(VkCommandBuffer CmdBuffer, const FString& String)
{
DebugLog += FString::Printf(TEXT("[C:0x%p]%8d: %s"), CmdBuffer, DebugLine++, *String);
FlushDebugWrapperLog();
}
void PrintResult(VkResult Result)
{
DebugLog += FString::Printf(TEXT(" -> %s\n"), *GetVkResultErrorString(Result));
FlushDebugWrapperLog();
}
void PrintResultAndPointer(VkResult Result, void* Handle)
{
DebugLog += FString::Printf(TEXT(" -> %s => 0x%p\n"), *GetVkResultErrorString(Result), Handle);
FlushDebugWrapperLog();
}
void PrintResultAndNamedHandle(VkResult Result, const TCHAR* HandleName, void* Handle)
{
DebugLog += FString::Printf(TEXT(" -> %s => %s=0x%p\n"), *GetVkResultErrorString(Result), HandleName, Handle);
FlushDebugWrapperLog();
}
void PrintResultAndNamedHandles(VkResult Result, const TCHAR* HandleName, uint32 NumHandles, uint64* Handles)
{
DebugLog += FString::Printf(TEXT(" -> %s => %s\n"), *GetVkResultErrorString(Result), HandleName);
for (uint32 Index = 0; Index < NumHandles; ++Index)
{
DebugLog += FString::Printf(TEXT(" [%d]=0x%p"), Index, (void*)Handles[Index]);
}
DebugLog += TEXT("\n");
FlushDebugWrapperLog();
}
void PrintResultAndPointer(VkResult Result, uint64 Handle)
{
DebugLog += FString::Printf(TEXT(" -> %s => %llu\n"), *GetVkResultErrorString(Result), Handle);
FlushDebugWrapperLog();
}
void PrintResultAndNamedHandle(VkResult Result, const TCHAR* HandleName, uint64 Handle)
{
DebugLog += FString::Printf(TEXT(" -> %s => %s=%llu\n"), *GetVkResultErrorString(Result), HandleName, Handle);
FlushDebugWrapperLog();
}
}
#endif
#if VULKAN_ENABLE_WRAP_LAYER
void FWrapLayer::GetPhysicalDeviceMemoryProperties(VkResult Result, VkPhysicalDevice PhysicalDevice, VkPhysicalDeviceMemoryProperties* Properties)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBegin(FString::Printf(TEXT("vkGetPhysicalDeviceMemoryProperties(OutProp=0x%p)[...]"), Properties));
FlushDebugWrapperLog();
#endif
}
}
void FWrapLayer::QueueWaitIdle(VkResult Result, VkQueue Queue)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBeginResult(FString::Printf(TEXT("vkQueueWaitIdle(Queue=0x%p)"), Queue));
#endif
}
else
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintResult(Result);
#endif
}
}
void FWrapLayer::AllocateMemory(VkResult Result, VkDevice Device, const VkMemoryAllocateInfo* AllocateInfo, VkDeviceMemory* Memory)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
DevicePrintfBeginResult(Device, FString::Printf(TEXT("vkAllocateMemory(AllocateInfo=0x%p, OutMem=0x%p): Size=%d, MemTypeIndex=%d"), AllocateInfo, Memory, (uint32)AllocateInfo->allocationSize, AllocateInfo->memoryTypeIndex));
#endif
}
else
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintResultAndNamedHandle(Result, TEXT("DevMem"), *Memory);
FlushDebugWrapperLog();
#endif
}
}
#if VULKAN_ENABLE_DUMP_LAYER
static void DumpErrorInvalidPointer(const FString& PointerTypename)
{
DebugLog += FString::Printf(TEXT(" -> ERROR: invalid pointer to %s\n"), *PointerTypename);
}
#endif
#if VULKAN_ENABLE_DUMP_LAYER
static void DumpMemoryRequirements(VkMemoryRequirements* pMemRequirements)
{
if (pMemRequirements)
{
DebugLog += FString::Printf(TEXT(" -> Size=%llu Align=%llu MemTypeBits=0x%x\n"), pMemRequirements->size, pMemRequirements->alignment, pMemRequirements->memoryTypeBits);
}
else
{
DumpErrorInvalidPointer(TEXT("VkMemoryRequirements"));
}
FlushDebugWrapperLog();
}
#endif
void FWrapLayer::GetBufferMemoryRequirements(VkResult Result, VkDevice Device, VkBuffer Buffer, VkMemoryRequirements* MemoryRequirements)
{
#if VULKAN_ENABLE_DUMP_LAYER
if (Result == VK_RESULT_MAX_ENUM)
{
DevicePrintfBeginResult(Device, FString::Printf(TEXT("vkGetBufferMemoryRequirements(Buffer=0x%p, OutReq=0x%p)"), Buffer, MemoryRequirements));
}
else
{
DumpMemoryRequirements(MemoryRequirements);
}
#endif
}
void FWrapLayer::GetImageMemoryRequirements(VkResult Result, VkDevice Device, VkImage Image, VkMemoryRequirements* MemoryRequirements)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
DevicePrintfBeginResult(Device, FString::Printf(TEXT("vkGetImageMemoryRequirements(Image=0x%p, OutReq=0x%p)"), Image, MemoryRequirements));
#endif
}
else
{
#if VULKAN_ENABLE_DUMP_LAYER
DumpMemoryRequirements(MemoryRequirements);
#endif
}
}
void FWrapLayer::CreateBuffer(VkResult Result, VkDevice Device, const VkBufferCreateInfo* CreateInfo, VkBuffer* Buffer)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
DevicePrintfBegin(Device, FString::Printf(TEXT("vkCreateBuffer(Info=0x%p, OutBuffer=0x%p)[...]"), CreateInfo, Buffer));
DebugLog += FString::Printf(TEXT("%sVkBufferCreateInfo: Flags=%d, Size=%d, Usage=%d"), Tabs, CreateInfo->flags, (uint32)CreateInfo->size, (uint32)CreateInfo->usage);
FlushDebugWrapperLog();
/*
VkSharingMode sharingMode;
uint32_t queueFamilyIndexCount;
const uint32_t* pQueueFamilyIndices;
*/
#endif
}
else
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintResultAndNamedHandle(Result, TEXT("Buffer"), *Buffer);
#endif
#if VULKAN_ENABLE_BUFFER_TRACKING_LAYER
FScopeLock ScopeLock(&GTrackingCS);
if (Buffer && CreateInfo)
{
auto& TrackingBuffer = GVulkanTrackingBuffers.FindOrAdd(*Buffer);
TrackingBuffer.CreateInfo = *CreateInfo;
#if VULKAN_ENABLE_TRACKING_CALLSTACK
CaptureCallStack(TrackingBuffer.CreateCallstack, 3);
#endif
}
#endif
}
}
void FWrapLayer::CreateBufferView(VkResult Result, VkDevice Device, const VkBufferViewCreateInfo* CreateInfo, VkBufferView* BufferView)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
DevicePrintfBeginResult(Device, FString::Printf(TEXT("vkCreateBufferView(Info=0x%p, OutBufferView=0x%p)\n"), CreateInfo, BufferView));
DebugLog += FString::Printf(TEXT("%sVkBufferCreateInfo: Flags=%d, Buffer=0x%p, Format=%s, Offset=%d, Range=%d\n"), Tabs, CreateInfo->flags, CreateInfo->buffer,
*GetVkFormatString(CreateInfo->format), CreateInfo->offset, CreateInfo->range);
#endif
}
else
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintResultAndNamedHandle(Result, TEXT("BufferView"), *BufferView);
FlushDebugWrapperLog();
#endif
#if VULKAN_ENABLE_BUFFER_TRACKING_LAYER
FScopeLock ScopeLock(&GTrackingCS);
if (BufferView && CreateInfo)
{
auto& TrackingBuffer = GVulkanTrackingBufferViews.FindOrAdd(*BufferView);
TrackingBuffer.CreateInfo = *CreateInfo;
#if VULKAN_ENABLE_TRACKING_CALLSTACK
CaptureCallStack(TrackingBuffer.CreateCallstack, 3);
#endif
GVulkanTrackingBufferToBufferViews.FindOrAdd(CreateInfo->buffer).Add(*BufferView);
}
#endif
}
}
void FWrapLayer::CreateImage(VkResult Result, VkDevice Device, const VkImageCreateInfo* CreateInfo, VkImage* Image)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
DevicePrintfBegin(Device, FString::Printf(TEXT("vkCreateImage(CreateInfo=0x%p, OutImage=0x%p)"), CreateInfo, Image));
if (CreateInfo)
{
DebugLog += FString::Printf(TEXT("%sVkImageCreateInfo: Flags=%d, ImageType=%s, Format=%s, MipLevels=%d, ArrayLayers=%d, Samples=%s\n"), Tabs, CreateInfo->flags, *GetVkImageTypeString(CreateInfo->imageType),
*GetVkFormatString(CreateInfo->format), CreateInfo->mipLevels, CreateInfo->arrayLayers, *GetSampleCountString(CreateInfo->samples));
DebugLog += FString::Printf(TEXT("%s\tExtent=(%s) Tiling=%s, Usage=%s, Initial=%s\n"), Tabs, *GetExtentString(CreateInfo->extent),
*GetVkImageTilingString(CreateInfo->tiling), *GetImageUsageString(CreateInfo->usage), *GetVkImageLayoutString(CreateInfo->initialLayout));
}
FlushDebugWrapperLog();
#endif
}
else
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintResultAndNamedHandle(Result, TEXT("Image"), *Image);
FlushDebugWrapperLog();
#endif
#if VULKAN_ENABLE_IMAGE_TRACKING_LAYER
{
FScopeLock ScopeLock(&GTrackingCS);
if (Image && CreateInfo)
{
FTrackingImage& TrackingImage = GVulkanTrackingImageLayouts.FindOrAdd(*Image);
TrackingImage.Setup(*CreateInfo, false);
#if VULKAN_ENABLE_TRACKING_CALLSTACK
CaptureCallStack(TrackingImage.CreateCallstack, 3);
#endif
}
}
#endif
}
}
void FWrapLayer::DestroyImage(VkResult Result, VkDevice Device, VkImage Image)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
DevicePrintfBegin(Device, FString::Printf(TEXT("vkDestroyImage(Image=0x%p)"), Image));
#endif
}
else
{
#if VULKAN_ENABLE_IMAGE_TRACKING_LAYER
BreakOnTrackingImage(Image);
{
FScopeLock ScopeLock(&GTrackingCS);
int32 NumRemoved = GVulkanTrackingImageLayouts.Remove(Image);
ensure(NumRemoved > 0);
}
#endif
}
}
void FWrapLayer::CreateImageView(VkResult Result, VkDevice Device, const VkImageViewCreateInfo* CreateInfo, VkImageView* ImageView)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
DevicePrintfBegin(Device, FString::Printf(TEXT("vkCreateImageView(Info=0x%p, OutImageView=0x%p)"), CreateInfo, ImageView));
DebugLog += FString::Printf(TEXT("%sVkImageViewCreateInfo: Flags=%d, Image=0x%p, ViewType=%s, Format=%s, Components=%s\n"), Tabs, CreateInfo->flags, CreateInfo->image,
*GetVkImageViewTypeString(CreateInfo->viewType), *GetVkFormatString(CreateInfo->format), *GetVkComponentMappingString(CreateInfo->components));
DebugLog += FString::Printf(TEXT("%s\tSubresourceRange=(%s)"), Tabs, *GetImageSubResourceRangeString(CreateInfo->subresourceRange));
#endif
}
else
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintResultAndNamedHandle(Result, TEXT("ImageView"), *ImageView);
FlushDebugWrapperLog();
#endif
#if VULKAN_ENABLE_IMAGE_TRACKING_LAYER
{
FScopeLock ScopeLock(&GTrackingCS);
auto& Found = GVulkanTrackingImageViews.FindOrAdd(*ImageView);
Found.CreateInfo = *CreateInfo;
#if VULKAN_ENABLE_TRACKING_CALLSTACK
CaptureCallStack(Found.CreateCallstack, 3);
#endif
}
BreakOnTrackingImageView(*ImageView);
#endif
}
}
void FWrapLayer::CreateFence(VkResult Result, VkDevice Device, const VkFenceCreateInfo* CreateInfo, VkFence* Fence)
{
#if VULKAN_ENABLE_DUMP_LAYER
if (Result == VK_RESULT_MAX_ENUM)
{
DevicePrintfBeginResult(Device, FString::Printf(TEXT("vkCreateFence(CreateInfo=0x%p%s, OutFence=0x%p)"),
CreateInfo, (CreateInfo->flags == VK_FENCE_CREATE_SIGNALED_BIT) ? TEXT("(SIGNALED)") : TEXT(""), Fence));
}
else
{
PrintResultAndNamedHandle(Result, TEXT("Fence"), *Fence);
}
FlushDebugWrapperLog();
#endif
}
#if VULKAN_ENABLE_DUMP_LAYER
static void DumpFenceList(uint32 FenceCount, const VkFence* Fences)
{
for (uint32 Index = 0; Index < FenceCount; ++Index)
{
DebugLog += Tabs;
DebugLog += '\t';
DebugLog += FString::Printf(TEXT("Fence[%d]=0x%p"), Index, Fences[Index]);
if (Index < FenceCount - 1)
{
DebugLog += TEXT("\n");
}
}
FlushDebugWrapperLog();
}
#endif
void FWrapLayer::ResetFences(VkResult Result, VkDevice Device, uint32 FenceCount, const VkFence* Fences)
{
#if VULKAN_ENABLE_DUMP_LAYER
if (Result == VK_RESULT_MAX_ENUM)
{
DevicePrintfBegin(Device, FString::Printf(TEXT("vkResetFences(Count=%d, Fences=0x%p)"), FenceCount, Fences));
DumpFenceList(FenceCount, Fences);
}
else
{
PrintResult(Result);
}
#endif
}
void FWrapLayer::WaitForFences(VkResult Result, VkDevice Device, uint32 FenceCount, const VkFence* Fences, VkBool32 bWaitAll, uint64_t Timeout)
{
#if VULKAN_ENABLE_DUMP_LAYER
if (Result == VK_RESULT_MAX_ENUM)
{
DevicePrintfBegin(Device, FString::Printf(TEXT("vkWaitForFences(Count=0x%p, Fences=%d, WaitAll=%d, Timeout=0x%p)"), FenceCount, Fences, (uint32)bWaitAll, Timeout));
DumpFenceList(FenceCount, Fences);
}
else
{
PrintResult(Result);
}
#endif
}
void FWrapLayer::CreateSemaphore(VkResult Result, VkDevice Device, const VkSemaphoreCreateInfo* CreateInfo, VkSemaphore* Semaphore)
{
#if VULKAN_ENABLE_DUMP_LAYER
if (Result == VK_RESULT_MAX_ENUM)
{
DevicePrintfBeginResult(Device, FString::Printf(TEXT("vkCreateSemaphore(CreateInfo=0x%p, OutSemaphore=0x%p)"), CreateInfo, Semaphore));
}
else
{
PrintResultAndNamedHandle(Result, TEXT("Semaphore"), *Semaphore);
}
FlushDebugWrapperLog();
#endif
}
#if VULKAN_ENABLE_DUMP_LAYER
static void DumpMappedMemoryRanges(VkResult Result, uint32 MemoryRangeCount, const VkMappedMemoryRange* MemoryRanges)
{
if (Result == VK_RESULT_MAX_ENUM)
{
for (uint32 Index = 0; Index < MemoryRangeCount; ++Index)
{
const VkMappedMemoryRange& Range = MemoryRanges[Index];
/*
typedef struct VkMappedMemoryRange {
VkStructureType sType;
const void* pNext;
VkDeviceMemory memory;
VkDeviceSize offset;
VkDeviceSize size;
} VkMappedMemoryRange;
*/
DebugLog += FString::Printf(TEXT("%s%d Memory=0x%p Offset=%d Size=%d\n"), Tabs, Index,
(void*)Range.memory, (uint64)Range.offset, (uint64)Range.size);
}
FlushDebugWrapperLog();
}
}
#endif
void FWrapLayer::InvalidateMappedMemoryRanges(VkResult Result, VkDevice Device, uint32 MemoryRangeCount, const VkMappedMemoryRange* MemoryRanges)
{
#if VULKAN_ENABLE_DUMP_LAYER
if (Result == VK_RESULT_MAX_ENUM)
{
DevicePrintfBeginResult(Device, FString::Printf(TEXT("vkInvalidateMappedMemoryRanges(Count=%d, Ranges=0x%p)"), MemoryRangeCount, MemoryRanges));
DumpMappedMemoryRanges(Result, MemoryRangeCount, MemoryRanges);
}
else
{
PrintResult(Result);
}
#endif
}
void FWrapLayer::FlushMappedMemoryRanges(VkResult Result, VkDevice Device, uint32 MemoryRangeCount, const VkMappedMemoryRange* MemoryRanges)
{
#if VULKAN_ENABLE_DUMP_LAYER
if (Result == VK_RESULT_MAX_ENUM)
{
DevicePrintfBeginResult(Device, FString::Printf(TEXT("vkFlushMappedMemoryRanges(Count=%d, Ranges=0x%p)"), MemoryRangeCount, MemoryRanges));
DumpMappedMemoryRanges(Result, MemoryRangeCount, MemoryRanges);
}
else
{
PrintResult(Result);
}
#endif
}
void FWrapLayer::CmdResolveImage(VkResult Result, VkCommandBuffer CommandBuffer, VkImage SrcImage, VkImageLayout SrcImageLayout, VkImage DstImage, VkImageLayout DstImageLayout, uint32 RegionCount, const VkImageResolve* Regions)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
CmdPrintfBegin(CommandBuffer, FString::Printf(TEXT("vkCmdResolveImage(SrcImage=0x%p, SrcImageLayout=%s, DestImage=0x%p, DestImageLayout=%s, NumRegions=%d, Regions=0x%p)[...]"),
CommandBuffer, SrcImage, *GetVkImageLayoutString(SrcImageLayout), DstImage, *GetVkImageLayoutString(DstImageLayout), RegionCount, Regions));
for (uint32 Index = 0; Index < RegionCount; ++Index)
{
DebugLog += Tabs;
DebugLog += FString::Printf(TEXT("Region %d: "), Index);
/*
typedef struct VkImageResolve {
VkImageSubresourceLayers srcSubresource;
VkOffset3D srcOffset;
VkImageSubresourceLayers dstSubresource;
VkOffset3D dstOffset;
VkExtent3D extent;
*/
}
FlushDebugWrapperLog();
#endif
}
}
void FWrapLayer::FreeDescriptorSets(VkResult Result, VkDevice Device, VkDescriptorPool DescriptorPool, uint32 DescriptorSetCount, const VkDescriptorSet* DescriptorSets)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
DevicePrintfBegin(Device, FString::Printf(TEXT("vkFreeDescriptorSets(Pool=0x%p, NumSets=%d, Sets=0x%p)"), DescriptorPool, DescriptorSetCount, DescriptorSets));
for (uint32 Index = 0; Index < DescriptorSetCount; ++Index)
{
DebugLog += Tabs;
DebugLog += FString::Printf(TEXT("Set %d: 0x%p\n"), Index, DescriptorSets[Index]);
}
#endif
}
else
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintResult(Result);
#endif
}
}
void FWrapLayer::CreateInstance(VkResult Result, const VkInstanceCreateInfo* CreateInfo, VkInstance* Instance)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBegin(FString::Printf(TEXT("vkCreateInstance(Info=0x%p, OutInstance=0x%p)[...]"), CreateInfo, Instance));
/*
typedef struct VkInstanceCreateInfo {
VkInstanceCreateFlags flags;
const VkApplicationInfo* pApplicationInfo;
uint32_t enabledLayerCount;
const char* const* ppEnabledLayerNames;
uint32_t enabledExtensionCount;
const char* const* ppEnabledExtensionNames;
} VkInstanceCreateInfo;
*/
#endif
}
else
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintResultAndNamedHandle(Result, TEXT("Instance"), *Instance);
FlushDebugWrapperLog();
#endif
}
}
void FWrapLayer::EnumeratePhysicalDevices(VkResult Result, uint32_t* ApiVersion)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBegin(FString::Printf(TEXT("vkEnumeratePhysicalDevices()")));
#endif
}
}
void FWrapLayer::EnumerateInstanceVersion(VkResult Result, VkInstance Instance, uint32* PhysicalDeviceCount, VkPhysicalDevice* PhysicalDevices)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBegin(FString::Printf(TEXT("vkEnumeratePhysicalDevices(Instance=0x%p, Count=0x%p, Devices=0x%p)"), Instance, PhysicalDeviceCount, PhysicalDevices));
if (PhysicalDeviceCount)
{
DebugLog += Tabs;
DebugLog += FString::Printf(TEXT("OutCount=%d\n"), *PhysicalDeviceCount);
if (PhysicalDevices)
{
for (uint32 Index = 0; Index < *PhysicalDeviceCount; ++Index)
{
DebugLog += Tabs;
DebugLog += FString::Printf(TEXT("\tOutDevice[%d]=0x%p\n"), Index, PhysicalDevices[Index]);
}
}
FlushDebugWrapperLog();
}
#endif
}
}
#if VULKAN_ENABLE_DUMP_LAYER || VULKAN_ENABLE_IMAGE_TRACKING_LAYER
static void DumpImageMemoryBarriers(uint32 ImageMemoryBarrierCount, const VkImageMemoryBarrier* ImageMemoryBarriers)
{
for (uint32 Index = 0; Index < ImageMemoryBarrierCount; ++Index)
{
const VkImageMemoryBarrier& ImageBarrier = ImageMemoryBarriers[Index];
DebugLog += FString::Printf(TEXT("%s\tImageBarrier[%d]: srcAccess=%s, oldLayout=%s, srcQueueFamilyIndex=%d\n"), Tabs, Index, VK_FLAGS_TO_STRING(VkAccessFlags, ImageBarrier.srcAccessMask), VK_TYPE_TO_STRING(VkImageLayout, ImageBarrier.oldLayout), ImageBarrier.srcQueueFamilyIndex);
DebugLog += FString::Printf(TEXT("%s\t\tdstAccess=%s, newLayout=%s, dstQueueFamilyIndex=%d\n"), Tabs, VK_FLAGS_TO_STRING(VkAccessFlags, ImageBarrier.dstAccessMask), VK_TYPE_TO_STRING(VkImageLayout, ImageBarrier.newLayout), ImageBarrier.dstQueueFamilyIndex);
DebugLog += FString::Printf(TEXT("%s\t\tImage=0x%p, subresourceRange=(%s)\n"), Tabs, ImageBarrier.image, *GetImageSubResourceRangeString(ImageBarrier.subresourceRange));
}
}
static void DumpImageMemoryBarriers(uint32 ImageMemoryBarrierCount, const VkImageMemoryBarrier2* ImageMemoryBarriers)
{
for (uint32 Index = 0; Index < ImageMemoryBarrierCount; ++Index)
{
const VkImageMemoryBarrier2& ImageBarrier = ImageMemoryBarriers[Index];
DebugLog += FString::Printf(TEXT("%s\tImageBarrier[%d]: srcStage=%s, srcAccess=%s, oldLayout=%s, srcQueueFamilyIndex=%d\n"), Tabs, Index, VK_FLAGS_TO_STRING(VkPipelineStageFlags2, ImageBarrier.srcStageMask), VK_FLAGS_TO_STRING(VkAccessFlags2, ImageBarrier.srcAccessMask), VK_TYPE_TO_STRING(VkImageLayout, ImageBarrier.oldLayout), ImageBarrier.srcQueueFamilyIndex);
DebugLog += FString::Printf(TEXT("%s\t\tdstStage=%s, dstAccess=%s, newLayout=%s, dstQueueFamilyIndex=%d\n"), Tabs, VK_FLAGS_TO_STRING(VkPipelineStageFlags2, ImageBarrier.dstStageMask), VK_FLAGS_TO_STRING(VkAccessFlags2, ImageBarrier.dstAccessMask), VK_TYPE_TO_STRING(VkImageLayout, ImageBarrier.newLayout), ImageBarrier.dstQueueFamilyIndex);
DebugLog += FString::Printf(TEXT("%s\t\tImage=0x%p, subresourceRange=(%s)\n"), Tabs, ImageBarrier.image, *GetImageSubResourceRangeString(ImageBarrier.subresourceRange));
}
}
#endif
void FWrapLayer::CmdPipelineBarrier(VkResult Result, VkCommandBuffer CommandBuffer, VkPipelineStageFlags SrcStageMask, VkPipelineStageFlags DstStageMask, VkDependencyFlags DependencyFlags, uint32 MemoryBarrierCount, const VkMemoryBarrier* MemoryBarriers, uint32 BufferMemoryBarrierCount, const VkBufferMemoryBarrier* BufferMemoryBarriers, uint32 ImageMemoryBarrierCount, const VkImageMemoryBarrier* ImageMemoryBarriers)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
CmdPrintfBegin(CommandBuffer, FString::Printf(TEXT("vkCmdPipelineBarrier(srcStageMask=%s, destStageMask=%s, Flags=%d, NumMemB=%d, MemB=0x%p,"), VK_FLAGS_TO_STRING(VkPipelineStageFlags, SrcStageMask), VK_FLAGS_TO_STRING(VkPipelineStageFlags, DstStageMask), (uint32)DependencyFlags, MemoryBarrierCount, MemoryBarriers));
DebugLog += FString::Printf(TEXT("%s\tNumBufferB=%d, BufferB=0x%p, NumImageB=%d, ImageB=0x%p)[...]\n"), Tabs, BufferMemoryBarrierCount, BufferMemoryBarriers, ImageMemoryBarrierCount, ImageMemoryBarriers);
DumpImageMemoryBarriers(ImageMemoryBarrierCount, ImageMemoryBarriers);
FlushDebugWrapperLog();
#endif
#if VULKAN_ENABLE_IMAGE_TRACKING_LAYER
{
FScopeLock ScopeLock(&GTrackingCS);
for (uint32 Index = 0; Index < ImageMemoryBarrierCount; ++Index)
{
BreakOnTrackingImage(ImageMemoryBarriers[Index].image);
if(DumpTrackImage(ImageMemoryBarriers[Index].image))
{
CmdPrintfBegin(CommandBuffer, FString::Printf(TEXT("vkCmdPipelineBarrier(SrcStageMask=%s, DstStageMask=%s, Flags=%d, NumMemB=%d, MemB=0x%p,"), VK_FLAGS_TO_STRING(VkPipelineStageFlags, SrcStageMask), VK_FLAGS_TO_STRING(VkPipelineStageFlags, DstStageMask), (uint32)DependencyFlags, MemoryBarrierCount, MemoryBarriers));
DebugLog += FString::Printf(TEXT("%s\tNumBufferB=%d, BufferB=0x%p, NumImageB=%d, ImageB=0x%p)[...]\n"), Tabs, BufferMemoryBarrierCount, BufferMemoryBarriers, ImageMemoryBarrierCount, ImageMemoryBarriers);
DumpImageMemoryBarriers(ImageMemoryBarrierCount, ImageMemoryBarriers);
FlushDebugWrapperLog();
}
FTrackingImage* TrackingImage = GVulkanTrackingImageLayouts.Find(ImageMemoryBarriers[Index].image);
check(TrackingImage);
#if VULKAN_ENABLE_TRACKING_CALLSTACK
FTrackingImage::FHistoryEntry* HistoryEntry = new (TrackingImage->History) FTrackingImage::FHistoryEntry;
HistoryEntry->ArrayLayouts = TrackingImage->ArrayLayouts;
#endif
const VkImageSubresourceRange& Range = ImageMemoryBarriers[Index].subresourceRange;
uint32 NumLayers = (Range.layerCount == VK_REMAINING_ARRAY_LAYERS) ? (TrackingImage->Info.CreateInfo.arrayLayers - Range.baseArrayLayer) : Range.layerCount;
for (uint32 LIndex = Range.baseArrayLayer; LIndex < Range.baseArrayLayer + NumLayers; ++LIndex)
{
TArray<VkImageLayout>& MipLayouts = TrackingImage->ArrayLayouts[LIndex];
uint32 NumLevels = (Range.levelCount == VK_REMAINING_MIP_LEVELS ) ? (TrackingImage->Info.CreateInfo.mipLevels - Range.baseMipLevel) : Range.levelCount;
for (uint32 MIndex = Range.baseMipLevel; MIndex < Range.baseMipLevel + NumLevels; ++MIndex)
{
if (ImageMemoryBarriers[Index].oldLayout != VK_IMAGE_LAYOUT_UNDEFINED && MipLayouts[MIndex] != ImageMemoryBarriers[Index].oldLayout)
{
ensure(0);
}
MipLayouts[MIndex] = ImageMemoryBarriers[Index].newLayout;
}
}
#if VULKAN_ENABLE_TRACKING_CALLSTACK
CaptureCallStack(HistoryEntry->Callstack, 2);
#endif
}
}
#endif
}
}
void FWrapLayer::CmdWaitEvents(VkResult Result, VkCommandBuffer CommandBuffer, uint32 EventCount, const VkEvent* Events, VkPipelineStageFlags SrcStageMask, VkPipelineStageFlags DstStageMask, uint32 MemoryBarrierCount,
const VkMemoryBarrier* MemoryBarriers, uint32 BufferMemoryBarrierCount, const VkBufferMemoryBarrier* BufferMemoryBarriers, uint32 ImageMemoryBarrierCount, const VkImageMemoryBarrier* ImageMemoryBarriers)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
CmdPrintfBegin(CommandBuffer, FString::Printf(TEXT("vkCmdWaitEvents(NumEvents=%d, Events=0x%p, SrcStageMask=%s, DestStageMask=%s, NumMemB=%d, MemB=0x%p,"), EventCount, Events, VK_FLAGS_TO_STRING(VkPipelineStageFlags, SrcStageMask), VK_FLAGS_TO_STRING(VkPipelineStageFlags, DstStageMask), MemoryBarrierCount, MemoryBarriers));
DebugLog += FString::Printf(TEXT("%s\tNumBufferB=%d, BufferB=0x%p, NumImageB=%d, ImageB=0x%p)[...]\n"), Tabs, BufferMemoryBarrierCount, BufferMemoryBarriers, ImageMemoryBarrierCount, ImageMemoryBarriers);
for (uint32 Index = 0; Index < EventCount; ++Index)
{
DebugLog += FString::Printf(TEXT("%s\tEvents[%d]=0x%p)\n"), Tabs, Index, Events[Index]);
}
DumpImageMemoryBarriers(ImageMemoryBarrierCount, ImageMemoryBarriers);
FlushDebugWrapperLog();
#endif
}
}
void FWrapLayer::CmdBindDescriptorSets(VkResult Result, VkCommandBuffer CommandBuffer, VkPipelineBindPoint PipelineBindPoint, VkPipelineLayout Layout, uint32 FirstSet, uint32 DescriptorSetCount, const VkDescriptorSet* DescriptorSets, uint32 DynamicOffsetCount, const uint32* DynamicOffsets)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
CmdPrintfBegin(CommandBuffer, FString::Printf(TEXT("vkCmdBindDescriptorSets(BindPoint=%s, Layout=0x%p, FirstSet=%d, NumDS=%d, DS=0x%p, NumDynamicOffset=%d, DynamicOffsets=0x%p)"), *GetPipelineBindPointString(PipelineBindPoint), Layout, FirstSet, DescriptorSetCount, DescriptorSets, DynamicOffsetCount, DynamicOffsets));
for (uint32 Index = 0; Index < DescriptorSetCount; ++Index)
{
DebugLog += FString::Printf(TEXT("%s\tDS[%d]=0x%p\n"), Tabs, Index, DescriptorSets[Index]);
}
for (uint32 Index = 0; Index < DynamicOffsetCount; ++Index)
{
DebugLog += FString::Printf(TEXT("%s\tDynamicOffset[%d]=%d (0x%x)\n"), Tabs, Index, DynamicOffsets[Index], DynamicOffsets[Index]);
}
FlushDebugWrapperLog();
#endif
}
}
void FWrapLayer::CreateDescriptorSetLayout(VkResult Result, VkDevice Device, const VkDescriptorSetLayoutCreateInfo* CreateInfo, VkDescriptorSetLayout* SetLayout)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
DevicePrintfBegin(Device, FString::Printf(TEXT("vkCreateDescriptorSetLayout(Info=0x%p, OutLayout=0x%p)[...]"), CreateInfo, SetLayout));
DebugLog += FString::Printf(TEXT("%sNumBindings=%d, Bindings=0x%p\n"), Tabs, CreateInfo->bindingCount, CreateInfo->pBindings);
for (uint32 Index = 0; Index < CreateInfo->bindingCount; ++Index)
{
DebugLog += FString::Printf(TEXT("%s\tBinding[%d]= binding=%d DescType=%s NumDesc=%d StageFlags=%x\n"), Tabs, Index,
CreateInfo->pBindings[Index].binding, *GetVkDescriptorTypeString(CreateInfo->pBindings[Index].descriptorType), CreateInfo->pBindings[Index].descriptorCount, (uint32)CreateInfo->pBindings[Index].stageFlags);
}
#endif
}
else
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintResultAndNamedHandle(Result, TEXT("DescriptorSetLayout"), *SetLayout);
#endif
}
}
void FWrapLayer::AllocateDescriptorSets(VkResult Result, VkDevice Device, const VkDescriptorSetAllocateInfo* AllocateInfo, VkDescriptorSet* DescriptorSets)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
DevicePrintfBegin(Device, FString::Printf(TEXT("vkAllocateDescriptorSets(Info=0x%p, OutSets=0x%p)"), AllocateInfo, DescriptorSets));
DebugLog += FString::Printf(TEXT("%s\tVkDescriptorSetAllocateInfo: Pool=0x%p, NumSetLayouts=%d:"), Tabs, AllocateInfo->descriptorPool, AllocateInfo->descriptorSetCount);
for (uint32 Index = 0; Index < AllocateInfo->descriptorSetCount; ++Index)
{
DebugLog += FString::Printf(TEXT(" [%d]=0x%p"), Index, (void*)AllocateInfo->pSetLayouts[Index]);
FlushDebugWrapperLog();
}
#endif
}
else
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintResultAndNamedHandles(Result, TEXT("DescriptorSet"), AllocateInfo->descriptorSetCount, (uint64*)DescriptorSets);
#endif
}
}
void FWrapLayer::UpdateDescriptorSets(VkResult Result, VkDevice Device, uint32 DescriptorWriteCount, const VkWriteDescriptorSet* DescriptorWrites, uint32 DescriptorCopyCount, const VkCopyDescriptorSet* DescriptorCopies)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
DevicePrintfBegin(Device, FString::Printf(TEXT("vkUpdateDescriptorSets(NumWrites=%d, Writes=0x%p, NumCopies=%d, Copies=0x%p)"), DescriptorWriteCount, DescriptorWrites, DescriptorCopyCount, DescriptorCopies));
#endif
for (uint32 Index = 0; Index < DescriptorWriteCount; ++Index)
{
#if VULKAN_ENABLE_DUMP_LAYER
DebugLog += FString::Printf(TEXT("%sWrite[%d]: Set=0x%p Binding=%d DstArrayElem=%d NumDesc=%d DescType=%s "), Tabs, Index,
DescriptorWrites[Index].dstSet, DescriptorWrites[Index].dstBinding, DescriptorWrites[Index].dstArrayElement, DescriptorWrites[Index].descriptorCount, *GetVkDescriptorTypeString(DescriptorWrites[Index].descriptorType));
#endif
switch (DescriptorWrites[Index].descriptorType)
{
case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
#if VULKAN_ENABLE_DUMP_LAYER
DebugLog += FString::Printf(TEXT("pBufferInfo=0x%p\n"), DescriptorWrites[Index].pBufferInfo);
#endif
if (DescriptorWrites[Index].pBufferInfo)
{
for (uint32 SubIndex = 0; SubIndex < DescriptorWrites[Index].descriptorCount; ++SubIndex)
{
#if VULKAN_ENABLE_DUMP_LAYER
DebugLog += FString::Printf(TEXT("%s\tpBufferInfo[%d]: buffer=0x%p, offset=%d, range=%d\n"), Tabs, SubIndex,
DescriptorWrites[Index].pBufferInfo->buffer, (int32)DescriptorWrites[Index].pBufferInfo->offset, (int32)DescriptorWrites[Index].pBufferInfo->range);
#endif
}
}
else
{
ValidationFail();
}
break;
case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
#if VULKAN_ENABLE_DUMP_LAYER
DebugLog += FString::Printf(TEXT("pTexelBufferView=0x%p\n"), DescriptorWrites[Index].pTexelBufferView);
#endif
if (DescriptorWrites[Index].pTexelBufferView)
{
for (uint32 SubIndex = 0; SubIndex < DescriptorWrites[Index].descriptorCount; ++SubIndex)
{
#if VULKAN_ENABLE_DUMP_LAYER
#if VULKAN_ENABLE_BUFFER_TRACKING_LAYER
DebugLog += FString::Printf(TEXT("%s\tpTexelBufferView[%d]=0x%p(B:0x%p)\n"), Tabs, SubIndex, DescriptorWrites[Index].pTexelBufferView[SubIndex], FindTrackingBuffer(DescriptorWrites[Index].pTexelBufferView[SubIndex]));
#else
DebugLog += FString::Printf(TEXT("%s\tpTexelBufferView[%d]=0x%p\n"), Tabs, SubIndex, DescriptorWrites[Index].pTexelBufferView[SubIndex]);
#endif
#endif
}
}
else
{
ValidationFail();
}
break;
case VK_DESCRIPTOR_TYPE_SAMPLER:
case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
default:
#if VULKAN_ENABLE_DUMP_LAYER
DebugLog += FString::Printf(TEXT("pImageInfo=0x%p\n"), DescriptorWrites[Index].pImageInfo);
#endif
if (DescriptorWrites[Index].pImageInfo)
{
for (uint32 SubIndex = 0; SubIndex < DescriptorWrites[Index].descriptorCount; ++SubIndex)
{
#if VULKAN_ENABLE_IMAGE_TRACKING_LAYER
BreakOnTrackingImageView(DescriptorWrites[Index].pImageInfo->imageView);
#endif
#if VULKAN_ENABLE_DUMP_LAYER
auto* FoundImageInfo = GVulkanTrackingImageViews.Find(DescriptorWrites[Index].pImageInfo->imageView);
VkImage *Image = FoundImageInfo ? &FoundImageInfo->CreateInfo.image : nullptr;
DebugLog += FString::Printf(TEXT("%s\tpImageInfo[%d]: Sampler=0x%p, ImageView=0x%p(I:0x%p), imageLayout=%s\n"), Tabs, SubIndex,
DescriptorWrites[Index].pImageInfo->sampler, DescriptorWrites[Index].pImageInfo->imageView, Image ? *Image : nullptr, *GetVkImageLayoutString(DescriptorWrites[Index].pImageInfo->imageLayout));
#endif
}
}
else
{
ValidationFail();
}
break;
}
}
#if VULKAN_ENABLE_DUMP_LAYER
FlushDebugWrapperLog();
#endif
}
/*
typedef struct VkWriteDescriptorSet {
VkDescriptorSet dstSet;
uint32_t dstBinding;
uint32_t dstArrayElement;
uint32_t descriptorCount;
VkDescriptorType descriptorType;
const VkDescriptorImageInfo* pImageInfo;
const VkDescriptorBufferInfo* pBufferInfo;
const VkBufferView* pTexelBufferView;
} VkWriteDescriptorSet;
*/
}
void FWrapLayer::CreateFramebuffer(VkResult Result, VkDevice Device, const VkFramebufferCreateInfo* CreateInfo, VkFramebuffer* Framebuffer)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
DevicePrintfBegin(Device, FString::Printf(TEXT("vkCreateFramebuffer(Info=0x%p, OutFramebuffer=0x%p)"), CreateInfo, Framebuffer));
DebugLog += FString::Printf(TEXT("%sVkFramebufferCreateInfo: Flags=%d, RenderPass=0x%p, NumAttachments=%d\n"), Tabs, CreateInfo->flags, CreateInfo->renderPass, CreateInfo->attachmentCount);
for (uint32 Index = 0; Index < CreateInfo->attachmentCount; ++Index)
{
auto* FoundImageInfo = GVulkanTrackingImageViews.Find(CreateInfo->pAttachments[Index]);
VkImage *Image = FoundImageInfo ? &FoundImageInfo->CreateInfo.image : nullptr;
DebugLog += FString::Printf(TEXT("%s\tAttachment[%d]: ImageView=0x%p(I:0x%p)\n"), Tabs, Index, CreateInfo->pAttachments[Index], Image ? *Image : nullptr);
}
DebugLog += FString::Printf(TEXT("%s\twidth=%d, height=%d, layers=%d\n"), Tabs, CreateInfo->width, CreateInfo->height, CreateInfo->layers);
#endif
}
else
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintResultAndNamedHandle(Result, TEXT("Framebuffer"), *Framebuffer);
if (Result == VK_SUCCESS)
{
FFBInfo Info;
Info.Info = *CreateInfo;
if (CreateInfo->attachmentCount)
{
Info.Attachments.AddUninitialized(CreateInfo->attachmentCount);
FMemory::Memcpy(&Info.Attachments[0], CreateInfo->pAttachments, CreateInfo->attachmentCount * sizeof(VkImageView));
Info.Info.pAttachments = &Info.Attachments[0];
}
GFramebufferInfo.Add(*Framebuffer, Info);
}
#endif
}
}
void FWrapLayer::CreateRenderPass(VkResult Result, VkDevice Device, const VkRenderPassCreateInfo* CreateInfo, VkRenderPass* RenderPass)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
DevicePrintfBegin(Device, FString::Printf(TEXT("vkCreateRenderPass(Info=0x%p, OutRenderPass=0x%p)[...]"), CreateInfo, RenderPass));
DebugLog += FString::Printf(TEXT("%s\tVkRenderPassCreateInfo: NumAttachments=%d, Attachments=0x%p, NumSubPasses=%d, SubPasses=0x%p\n"), Tabs, CreateInfo->attachmentCount, CreateInfo->pAttachments, CreateInfo->subpassCount, CreateInfo->pSubpasses);
for (uint32 Index = 0; Index < CreateInfo->attachmentCount; ++Index)
{
auto GetLoadOpString = [](VkAttachmentLoadOp Op) -> FString
{
switch (Op)
{
case VK_ATTACHMENT_LOAD_OP_LOAD: return TEXT("LOAD");
case VK_ATTACHMENT_LOAD_OP_CLEAR: return TEXT("CLEAR");
case VK_ATTACHMENT_LOAD_OP_DONT_CARE: return TEXT("DONT_CARE");
default: return FString::Printf(TEXT("Invalid(%d)"), (uint32)Op);
}
};
auto GetStoreOpString = [](VkAttachmentStoreOp Op) -> FString
{
switch(Op)
{
case VK_ATTACHMENT_STORE_OP_STORE: return TEXT("STORE");
case VK_ATTACHMENT_STORE_OP_DONT_CARE: return TEXT("DONT_CARE");
default: return FString::Printf(TEXT("Invalid(%d)"), (uint32)Op);
}
};
const VkAttachmentDescription& Desc = CreateInfo->pAttachments[Index];
DebugLog += FString::Printf(TEXT("%s\t\tAttachment[%d]: Flags=%s, Format=%s, Samples=%s, Load=%s, Store=%s\n"), Tabs, Index,
(Desc.flags == VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT ? TEXT("MAY_ALIAS") : TEXT("0")),
*GetVkFormatString(Desc.format), *GetSampleCountString(Desc.samples), *GetLoadOpString(Desc.loadOp), *GetStoreOpString(Desc.storeOp));
DebugLog += FString::Printf(TEXT("%s\t\t\tLoadStencil=%s, StoreStencil=%s, Initial=%s, Final=%s\n"), Tabs,
*GetLoadOpString(Desc.stencilLoadOp), *GetStoreOpString(Desc.stencilStoreOp), *VulkanRHI::GetVkImageLayoutString(Desc.initialLayout), *VulkanRHI::GetVkImageLayoutString(Desc.finalLayout));
}
for (uint32 Index = 0; Index < CreateInfo->subpassCount; ++Index)
{
const VkSubpassDescription& Desc = CreateInfo->pSubpasses[Index];
DebugLog += FString::Printf(TEXT("%s\t\tSubpass[%d]: Flags=%d, Bind=%s, NumInputAttach=%d, InputAttach=0x%p, NumColorAttach=%d, ColorAttach=0x%p, DSAttch=0x%p\n"), Tabs, Index,
Desc.flags,
Desc.pipelineBindPoint == VK_PIPELINE_BIND_POINT_COMPUTE ? TEXT("Compute") : TEXT("Gfx"),
Desc.inputAttachmentCount, Desc.pInputAttachments, Desc.colorAttachmentCount, Desc.pColorAttachments, Desc.pDepthStencilAttachment);
for (uint32 SubIndex = 0; SubIndex < Desc.inputAttachmentCount; ++SubIndex)
{
DebugLog += FString::Printf(TEXT("%s\t\t\tInputAttach[%d]: Attach=%d, Layout=%s\n"), Tabs, Index,
Desc.pInputAttachments[SubIndex].attachment, *GetVkImageLayoutString(Desc.pInputAttachments[SubIndex].layout));
}
for (uint32 SubIndex = 0; SubIndex < Desc.colorAttachmentCount; ++SubIndex)
{
DebugLog += FString::Printf(TEXT("%s\t\t\tColorAttach[%d]: Attach=%d, Layout=%s\n"), Tabs, Index,
Desc.pColorAttachments[SubIndex].attachment, *GetVkImageLayoutString(Desc.pColorAttachments[SubIndex].layout));
}
if (Desc.pDepthStencilAttachment)
{
DebugLog += FString::Printf(TEXT("%s\t\t\tDSAttach: Attach=%d, Layout=%s\n"), Tabs, Desc.pDepthStencilAttachment->attachment, *GetVkImageLayoutString(Desc.pDepthStencilAttachment->layout));
}
/*
typedef struct VkSubpassDescription {
const VkAttachmentReference* pResolveAttachments;
uint32_t preserveAttachmentCount;
const uint32_t* pPreserveAttachments;
} VkSubpassDescription;*/
}
/*
typedef struct VkRenderPassCreateInfo {
uint32_t dependencyCount;
const VkSubpassDependency* pDependencies;
} VkRenderPassCreateInfo;
*/
#endif
}
else
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintResultAndNamedHandle(Result, TEXT("RenderPass"), *RenderPass);
if (Result == VK_SUCCESS)
{
FRenderPassInfo Info;
Info.Info = *CreateInfo;
Info.Info.pAttachments = nullptr;
Info.Info.pSubpasses = nullptr;
Info.Info.pDependencies = nullptr;
Info.Descriptions.AddUninitialized(CreateInfo->attachmentCount);
if (CreateInfo->attachmentCount)
{
FMemory::Memcpy(&Info.Descriptions[0], CreateInfo->pAttachments, CreateInfo->attachmentCount * sizeof(VkAttachmentDescription));
}
GRenderPassInfo.Add(*RenderPass, Info);
}
FlushDebugWrapperLog();
#endif
}
}
void FWrapLayer::CreateRenderPass2KHR(VkResult Result, VkDevice Device, const VkRenderPassCreateInfo2* CreateInfo, VkRenderPass* RenderPass)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
DevicePrintfBegin(Device, FString::Printf(TEXT("vkCreateRenderPass2KHR(Info=0x%p, OutRenderPass=0x%p)[...]"), CreateInfo, RenderPass));
DebugLog += FString::Printf(TEXT("%s\tVkRenderPassCreateInfo2: Flags=%d, NumAttachments=%d, Attachments=0x%p, NumSubPasses=%d, SubPasses=0x%p\n"), Tabs, CreateInfo->attachmentCount, CreateInfo->pAttachments, CreateInfo->subpassCount, CreateInfo->pSubpasses);
for (uint32 Index = 0; Index < CreateInfo->attachmentCount; ++Index)
{
auto GetLoadOpString = [](VkAttachmentLoadOp Op) -> FString
{
switch (Op)
{
case VK_ATTACHMENT_LOAD_OP_LOAD: return TEXT("LOAD");
case VK_ATTACHMENT_LOAD_OP_CLEAR: return TEXT("CLEAR");
case VK_ATTACHMENT_LOAD_OP_DONT_CARE: return TEXT("DONT_CARE");
default: return FString::Printf(TEXT("Invalid(%d)"), (uint32)Op);
}
};
auto GetStoreOpString = [](VkAttachmentStoreOp Op) -> FString
{
switch (Op)
{
case VK_ATTACHMENT_STORE_OP_STORE: return TEXT("STORE");
case VK_ATTACHMENT_STORE_OP_DONT_CARE: return TEXT("DONT_CARE");
default: return FString::Printf(TEXT("Invalid(%d)"), (uint32)Op);
}
};
const VkAttachmentDescription2& Desc = CreateInfo->pAttachments[Index];
DebugLog += FString::Printf(TEXT("%s\t\tAttachment[%d]: Flags=%s, Format=%s, Samples=%s, Load=%s, Store=%s\n"), Tabs, Index,
(Desc.flags == VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT ? TEXT("MAY_ALIAS") : TEXT("0")),
*GetVkFormatString(Desc.format), *GetSampleCountString(Desc.samples), *GetLoadOpString(Desc.loadOp), *GetStoreOpString(Desc.storeOp));
DebugLog += FString::Printf(TEXT("%s\t\t\tLoadStencil=%s, StoreStencil=%s, Initial=%s, Final=%s\n"), Tabs,
*GetLoadOpString(Desc.stencilLoadOp), *GetStoreOpString(Desc.stencilStoreOp), *VulkanRHI::GetVkImageLayoutString(Desc.initialLayout), *VulkanRHI::GetVkImageLayoutString(Desc.finalLayout));
}
for (uint32 Index = 0; Index < CreateInfo->subpassCount; ++Index)
{
const VkSubpassDescription2& Desc = CreateInfo->pSubpasses[Index];
DebugLog += FString::Printf(TEXT("%s\t\tSubpass[%d]: Flags=%d, Bind=%s, NumInputAttach=%d, InputAttach=0x%p, NumColorAttach=%d, ColorAttach=0x%p, DSAttch=0x%p\n"), Tabs, Index,
Desc.flags,
Desc.pipelineBindPoint == VK_PIPELINE_BIND_POINT_COMPUTE ? TEXT("Compute") : TEXT("Gfx"),
Desc.inputAttachmentCount, Desc.pInputAttachments, Desc.colorAttachmentCount, Desc.pColorAttachments, Desc.pDepthStencilAttachment);
for (uint32 SubIndex = 0; SubIndex < Desc.inputAttachmentCount; ++SubIndex)
{
DebugLog += FString::Printf(TEXT("%s\t\t\tInputAttach[%d]: Attach=%d, Layout=%s\n"), Tabs, Index,
Desc.pInputAttachments[SubIndex].attachment, *GetVkImageLayoutString(Desc.pInputAttachments[SubIndex].layout));
}
for (uint32 SubIndex = 0; SubIndex < Desc.colorAttachmentCount; ++SubIndex)
{
DebugLog += FString::Printf(TEXT("%s\t\t\tColorAttach[%d]: Attach=%d, Layout=%s\n"), Tabs, Index,
Desc.pColorAttachments[SubIndex].attachment, *GetVkImageLayoutString(Desc.pColorAttachments[SubIndex].layout));
}
if (Desc.pDepthStencilAttachment)
{
DebugLog += FString::Printf(TEXT("%s\t\t\tDSAttach: Attach=%d, Layout=%s\n"), Tabs, Desc.pDepthStencilAttachment->attachment, *GetVkImageLayoutString(Desc.pDepthStencilAttachment->layout));
}
DebugLog += FString::Printf(TEXT("%s\t\t\tviewMask=%d\n"), Tabs, Desc.viewMask);
}
#endif
}
else
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintResultAndNamedHandle(Result, TEXT("RenderPass"), *RenderPass);
if (Result == VK_SUCCESS)
{
FRenderPassInfo Info;
Info.Info.sType = CreateInfo->sType;
Info.Info.attachmentCount = CreateInfo->attachmentCount;
Info.Info.dependencyCount = CreateInfo->dependencyCount;
Info.Info.subpassCount = CreateInfo->subpassCount;
Info.Info.flags = CreateInfo->flags;
Info.Info.pAttachments = nullptr;
Info.Info.pSubpasses = nullptr;
Info.Info.pDependencies = nullptr;
Info.Descriptions.AddUninitialized(CreateInfo->attachmentCount);
for (uint32 Index = 0; Index < CreateInfo->attachmentCount; ++Index)
{
Info.Descriptions[Index].flags = CreateInfo->pAttachments[Index].flags;
Info.Descriptions[Index].format = CreateInfo->pAttachments[Index].format;
Info.Descriptions[Index].samples = CreateInfo->pAttachments[Index].samples;
Info.Descriptions[Index].loadOp = CreateInfo->pAttachments[Index].loadOp;
Info.Descriptions[Index].storeOp = CreateInfo->pAttachments[Index].storeOp;
Info.Descriptions[Index].stencilLoadOp = CreateInfo->pAttachments[Index].stencilLoadOp;
Info.Descriptions[Index].stencilStoreOp = CreateInfo->pAttachments[Index].stencilStoreOp;
Info.Descriptions[Index].initialLayout = CreateInfo->pAttachments[Index].initialLayout;
Info.Descriptions[Index].finalLayout = CreateInfo->pAttachments[Index].finalLayout;
}
GRenderPassInfo.Add(*RenderPass, Info);
}
FlushDebugWrapperLog();
#endif
}
}
void FWrapLayer::QueueSubmit(VkResult Result, VkQueue Queue, uint32 SubmitCount, const VkSubmitInfo* Submits, VkFence Fence)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBeginResult(FString::Printf(TEXT("vkQueueSubmit(Queue=0x%p, Count=%d, Submits=0x%p, Fence=0x%p)"), Queue, SubmitCount, Submits, Fence));
for (uint32 Index = 0; Index < SubmitCount; ++Index)
{
DebugLog += FString::Printf(TEXT("\n%sSubmit[%d]:"), Tabs, Index);
if (Submits[Index].waitSemaphoreCount > 0)
{
DebugLog += FString::Printf(TEXT("\n%s\tWaitSemaphores(Mask): "), Tabs, Index);
for (uint32 SubIndex = 0; SubIndex < Submits[Index].waitSemaphoreCount; ++SubIndex)
{
DebugLog += FString::Printf(TEXT("0x%p(%d) "), Submits[Index].pWaitSemaphores[SubIndex], (int32)Submits[Index].pWaitDstStageMask[SubIndex]);
}
}
if (Submits[Index].commandBufferCount > 0)
{
DebugLog += FString::Printf(TEXT("\n%s\tCommandBuffers: "), Tabs, Index);
for (uint32 SubIndex = 0; SubIndex < Submits[Index].commandBufferCount; ++SubIndex)
{
DebugLog += FString::Printf(TEXT("0x%p "), Submits[Index].pCommandBuffers[SubIndex]);
}
}
if (Submits[Index].signalSemaphoreCount > 0)
{
DebugLog += FString::Printf(TEXT("\n%s\tSignalSemaphore: "), Tabs, Index);
for (uint32 SubIndex = 0; SubIndex < Submits[Index].signalSemaphoreCount; ++SubIndex)
{
DebugLog += FString::Printf(TEXT("0x%p "), Submits[Index].pSignalSemaphores[SubIndex]);
}
}
}
#endif
}
else
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintResult(Result);
#endif
}
}
void FWrapLayer::CreateShaderModule(VkResult Result, VkDevice Device, const VkShaderModuleCreateInfo* CreateInfo, VkShaderModule* ShaderModule)
{
#if VULKAN_ENABLE_DUMP_LAYER
if (Result == VK_RESULT_MAX_ENUM)
{
DevicePrintfBeginResult(Device, FString::Printf(TEXT("vkCreateShaderModule(CreateInfo=0x%p, OutShaderModule=0x%p)[...]"), CreateInfo, ShaderModule));
/*
typedef struct VkShaderModuleCreateInfo {
VkStructureType sType;
const void* pNext;
VkShaderModuleCreateFlags flags;
size_t codeSize;
const uint32_t* pCode;
} VkShaderModuleCreateInfo;
*/
}
else
{
PrintResultAndNamedHandle(Result, TEXT("ShaderModule"), *ShaderModule);
}
FlushDebugWrapperLog();
#endif
}
void FWrapLayer::CreatePipelineCache(VkResult Result, VkDevice Device, const VkPipelineCacheCreateInfo* CreateInfo, VkPipelineCache* PipelineCache)
{
#if VULKAN_ENABLE_DUMP_LAYER
if (Result == VK_RESULT_MAX_ENUM)
{
DevicePrintfBeginResult(Device, FString::Printf(TEXT("vkCreatePipelineCache(CreateInfo=0x%p, OutPipelineCache=0x%p) InitialSize=%d Data=0x%p "), CreateInfo, PipelineCache, (uint32)CreateInfo->initialDataSize, CreateInfo->pInitialData));
}
else
{
PrintResultAndNamedHandle(Result, TEXT("PipelineCache"), *PipelineCache);
}
FlushDebugWrapperLog();
#endif
}
void FWrapLayer::CreateCommandPool(VkResult Result, VkDevice Device, const VkCommandPoolCreateInfo* CreateInfo, VkCommandPool* CommandPool)
{
#if VULKAN_ENABLE_DUMP_LAYER
if (Result == VK_RESULT_MAX_ENUM)
{
DevicePrintfBeginResult(Device, FString::Printf(TEXT("vkCreateCommandPool(CreateInfo=0x%p, OutCommandPool=0x%p)[...]"), CreateInfo, CommandPool));
}
else
{
PrintResultAndNamedHandle(Result, TEXT("CommandPool"), *CommandPool);
}
FlushDebugWrapperLog();
#endif
}
void FWrapLayer::CreateQueryPool(VkResult Result, VkDevice Device, const VkQueryPoolCreateInfo* CreateInfo, VkQueryPool* QueryPool)
{
#if VULKAN_ENABLE_DUMP_LAYER
if (Result == VK_RESULT_MAX_ENUM)
{
DevicePrintfBeginResult(Device, FString::Printf(TEXT("vkCreateQueryPool(CreateInfo=0x%p, OutQueryPool=0x%p)[...]"), CreateInfo, QueryPool));
}
else
{
PrintResultAndNamedHandle(Result, TEXT("QueryPool"), *QueryPool);
}
FlushDebugWrapperLog();
#endif
}
void FWrapLayer::CreatePipelineLayout(VkResult Result, VkDevice Device, const VkPipelineLayoutCreateInfo* CreateInfo, VkPipelineLayout* PipelineLayout)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
DevicePrintfBegin(Device, FString::Printf(TEXT("vkCreatePipelineLayout(CreateInfo=0x%p, OutPipelineLayout=0x%p) NumLayouts=%d"), CreateInfo, PipelineLayout, CreateInfo->setLayoutCount));
DebugLog += FString::Printf(TEXT("%sLayouts: "), Tabs);
for (uint32 Index = 0; Index < CreateInfo->setLayoutCount; ++Index)
{
DebugLog += FString::Printf(TEXT("%d=0x%p "), Index, CreateInfo->pSetLayouts[Index]);
}
DebugLog += '\n';
#endif
}
else
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintResultAndNamedHandle(Result, TEXT("PipelineLayout"), *PipelineLayout);
#endif
}
/*
typedef struct VkPipelineLayoutCreateInfo {
VkPipelineLayoutCreateFlags flags;
uint32_t pushConstantRangeCount;
const VkPushConstantRange* pPushConstantRanges;
} VkPipelineLayoutCreateInfo;
*/
}
void FWrapLayer::CreateDescriptorPool(VkResult Result, VkDevice Device, const VkDescriptorPoolCreateInfo* CreateInfo, VkDescriptorPool* DescriptorPool)
{
#if VULKAN_ENABLE_DUMP_LAYER
if (Result == VK_RESULT_MAX_ENUM)
{
DevicePrintfBeginResult(Device, FString::Printf(TEXT("vkCreateDescriptorPool(CreateInfo=0x%p, OutDescriptorPool=0x%p)[...]"), CreateInfo, DescriptorPool));
}
else
{
PrintResultAndNamedHandle(Result, TEXT("DescriptorPool"), *DescriptorPool);
}
FlushDebugWrapperLog();
#endif
}
void FWrapLayer::CreateSampler(VkResult Result, VkDevice Device, const VkSamplerCreateInfo* CreateInfo, VkSampler* Sampler)
{
#if VULKAN_ENABLE_DUMP_LAYER
if (Result == VK_RESULT_MAX_ENUM)
{
DevicePrintfBeginResult(Device, FString::Printf(TEXT("vkCreateSampler(CreateInfo=0x%p, OutSampler=0x%p)[...]"), CreateInfo, Sampler));
}
else
{
PrintResultAndNamedHandle(Result, TEXT("Sampler"), *Sampler);
}
FlushDebugWrapperLog();
#endif
}
void FWrapLayer::CreateDevice(VkResult Result, VkPhysicalDevice PhysicalDevice, const VkDeviceCreateInfo* CreateInfo, VkDevice* Device)
{
#if VULKAN_ENABLE_DUMP_LAYER
if (Result == VK_RESULT_MAX_ENUM)
{
PrintfBeginResult(FString::Printf(TEXT("vkCreateDevice(PhysicalDevice=0x%p, CreateInfo=0x%p, OutDevice=0x%p)[...]"), PhysicalDevice, CreateInfo, Device));
}
else
{
PrintResultAndNamedHandle(Result, TEXT("Device"), *Device);
}
FlushDebugWrapperLog();
#endif
}
void FWrapLayer::GetPhysicalDeviceFeatures(VkResult Result, VkPhysicalDevice PhysicalDevice, VkPhysicalDeviceFeatures* Features)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBeginResult(FString::Printf(TEXT("GetPhysicalDeviceFeatures(PhysicalDevice=0x%p, Features=0x%p)[...]"), PhysicalDevice, Features));
#endif
}
else
{
#if VULKAN_ENABLE_DUMP_LAYER
DebugLog += FString::Printf(TEXT("VkPhysicalDeviceFeatures [...]\n"));
#endif
}
}
void FWrapLayer::GetPhysicalDeviceFormatProperties(VkResult Result, VkPhysicalDevice PhysicalDevice, VkFormat Format, VkFormatProperties* FormatProperties)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBegin(FString::Printf(TEXT("vkGetPhysicalDeviceFormatProperties(PhysicalDevice=0x%p, Format=%d, FormatProperties=0x%p)[...]"), PhysicalDevice, (int32)Format, FormatProperties));
#endif
}
}
void FWrapLayer::GetPhysicalDeviceFormatProperties2(VkResult Result, VkPhysicalDevice PhysicalDevice, VkFormat Format, VkFormatProperties2* FormatProperties)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBegin(FString::Printf(TEXT("vkGetPhysicalDeviceFormatProperties2(PhysicalDevice=0x%p, Format=%d, FormatProperties2=0x%p)[...]"), PhysicalDevice, (int32)Format, FormatProperties));
#endif
}
}
#if VULKAN_ENABLE_DUMP_LAYER
static void DumpImageFormatProperties(const VkImageFormatProperties* pProps)
{
if (pProps)
{
DebugLog += FString::Printf(
TEXT(" -> MaxExtent={ %u, %u, %u } MaxMipLevels=%u MaxArrayLayers=%u SampleCounts=0x%X MaxResourceSize=%llu\n"),
pProps->maxExtent.width, pProps->maxExtent.height, pProps->maxMipLevels, pProps->maxArrayLayers, pProps->sampleCounts, pProps->maxResourceSize
);
}
else
{
DumpErrorInvalidPointer(TEXT("VkImageFormatProperties"));
}
FlushDebugWrapperLog();
}
#endif
void FWrapLayer::GetPhysicalDeviceImageFormatProperties(VkResult Result, VkPhysicalDevice PhysicalDevice, VkFormat Format, VkImageType Type, VkImageTiling Tiling, VkImageUsageFlags Usage, VkImageCreateFlags Flags, VkImageFormatProperties* pImageFormatProperties)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBeginResult(FString::Printf(
TEXT("vkGetPhysicalDeviceImageFormatProperties(PhysicalDevice=0x%p, Format=%s, Type=%d, Tiling=%s, Usage=%d, Flags=%d, pImageFormatProperties=0x%p)[...]"),
PhysicalDevice, *GetVkFormatString(Format), (int32)Type, *GetVkImageTilingString(Tiling), (int32)Usage, (int32)Flags, pImageFormatProperties
));
#endif
}
else
{
#if VULKAN_ENABLE_DUMP_LAYER
DumpImageFormatProperties(pImageFormatProperties);
#endif
}
}
void FWrapLayer::GetPhysicalDeviceImageFormatProperties2(VkResult Result, VkPhysicalDevice PhysicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo , VkImageFormatProperties2* pImageFormatProperties)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBeginResult(FString::Printf(
TEXT("vkGetPhysicalDeviceImageFormatProperties(PhysicalDevice=0x%p, pImageFormatInfo=0x%p, pImageFormatProperties=0x%p)[...]"),
PhysicalDevice, pImageFormatInfo, pImageFormatProperties
));
#endif
}
else
{
#if VULKAN_ENABLE_DUMP_LAYER
DumpImageFormatProperties(pImageFormatProperties->imageFormatProperties);
#endif
}
}
void FWrapLayer::GetPhysicalDeviceProperties(VkResult Result, VkPhysicalDevice PhysicalDevice, VkPhysicalDeviceProperties* FormatProperties)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBegin(FString::Printf(TEXT("vkGetPhysicalDeviceProperties(PhysicalDevice=0x%p, Properties=0x%p)[...]"), PhysicalDevice, FormatProperties));
#endif
}
}
void FWrapLayer::BeginCommandBuffer(VkResult Result, VkCommandBuffer CommandBuffer, const VkCommandBufferBeginInfo* BeginInfo)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBeginResult(FString::Printf(TEXT("vkBeginCommandBuffer(CmdBuffer=0x%p, Info=0x%p)[...]"), CommandBuffer, BeginInfo));
#endif
}
else
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintResult(Result);
#endif
}
}
void FWrapLayer::EndCommandBuffer(VkResult Result, VkCommandBuffer CommandBuffer)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
CmdPrintfBeginResult(CommandBuffer, FString::Printf(TEXT("vkEndCommandBuffer(Cmd=0x%p)")));
#endif
}
else
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintResult(Result);
#endif
}
}
void FWrapLayer::CmdResetQueryPool(VkResult Result, VkCommandBuffer CommandBuffer, VkQueryPool QueryPool, uint32 FirstQuery, uint32 QueryCount)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
CmdPrintfBegin(CommandBuffer, FString::Printf(TEXT("vkCmdResetQueryPool(QueryPool=0x%p, FirstQuery=%d, NumQueries=%d)"), QueryPool, FirstQuery, QueryCount));
#endif
}
}
void FWrapLayer::CmdWriteTimestamp(VkResult Result, VkCommandBuffer CommandBuffer, VkPipelineStageFlagBits PipelineStage, VkQueryPool QueryPool, uint32 Query)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
CmdPrintfBegin(CommandBuffer, FString::Printf(TEXT("vkCmdWriteTimestamp(PipelineStage=%d, QueryPool=0x%p, Query=%d)"), (int32)PipelineStage, QueryPool, Query));
#endif
}
}
void FWrapLayer::CmdBindPipeline(VkResult Result, VkCommandBuffer CommandBuffer, VkPipelineBindPoint PipelineBindPoint, VkPipeline Pipeline)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
CmdPrintfBegin(CommandBuffer, FString::Printf(TEXT("vkCmdBindPipeline(BindPoint=%d, Pipeline=0x%p)[...]"), (int32)PipelineBindPoint, Pipeline));
#endif
}
}
void FWrapLayer::CmdPushConstants(VkResult Result, VkCommandBuffer CommandBuffer, VkPipelineLayout Layout, VkShaderStageFlags StageFlags, uint32_t Offset, uint32_t Size, const void* pValues)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
CmdPrintfBegin(CommandBuffer, FString::Printf(TEXT("vkCmdPushConstants(Layout=0x%p, StageFlags=0x%08X, Offset=%u, Size=%u, pValues=0x%p)"), Layout, StageFlags, Offset, Size, pValues));
#endif
}
}
void FWrapLayer::CmdBeginRenderPass(VkResult Result, VkCommandBuffer CommandBuffer, const VkRenderPassBeginInfo* RenderPassBegin, VkSubpassContents Contents)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
auto GetSubpassContents = [](VkSubpassContents InContents) -> FString
{
switch (InContents)
{
case VK_SUBPASS_CONTENTS_INLINE: return TEXT("INLINE");
case VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS: return TEXT("SECONDARY_CMD_BUFS");
default: return FString::Printf(TEXT("%d"), (int32)InContents);
}
};
CmdPrintfBegin(CommandBuffer, FString::Printf(TEXT("----- vkCmdBeginRenderPass(BeginInfo=0x%p, Contents=%s)"), RenderPassBegin, *GetSubpassContents(Contents)));
DebugLog += FString::Printf(TEXT("%sBeginInfo: RenderPass=0x%p, Framebuffer=0x%p, renderArea=(x:%d, y:%d, %s), clearValues=%d\n"),
Tabs, RenderPassBegin->renderPass, RenderPassBegin->framebuffer,
RenderPassBegin->renderArea.offset.x, RenderPassBegin->renderArea.offset.y,
*GetExtentString(RenderPassBegin->renderArea.extent),
RenderPassBegin->clearValueCount);
for (uint32 Index = 0; Index < RenderPassBegin->clearValueCount; ++Index)
{
DebugLog += FString::Printf(TEXT("%s\tclearValue[%d]=(%s)\n"), Tabs, Index, *GetClearValueString(RenderPassBegin->pClearValues[Index]));
}
FRenderPassInfo* FoundRPInfo = GRenderPassInfo.Find(RenderPassBegin->renderPass);
ensure(FoundRPInfo);
if (FoundRPInfo)
{
FFBInfo* FoundFBInfo = GFramebufferInfo.Find(RenderPassBegin->framebuffer);
ensure(FoundFBInfo);
if (FoundFBInfo)
{
for (uint32 Index = 0; Index < FoundFBInfo->Info.attachmentCount; ++Index)
{
VkImageView View = FoundFBInfo->Attachments[Index];
auto* FoundImageInfo = GVulkanTrackingImageViews.Find(View);
// Can be null for swapchain images!
if (FoundImageInfo)
{
DebugLog += FString::Printf(TEXT("%s\t\tAttachment[%d]: ImageView=0x%p(I:0x%p)\n"), Tabs, Index, View, FoundImageInfo->CreateInfo.image);
}
}
}
}
FlushDebugWrapperLog();
#endif
}
}
void FWrapLayer::CmdBeginRenderPass2KHR(VkResult Result, VkCommandBuffer CommandBuffer, const VkRenderPassBeginInfo* RenderPassBegin, const VkSubpassBeginInfo* SubpassBeginInfo)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
auto GetSubpassContents = [](VkSubpassContents InContents) -> FString
{
switch (InContents)
{
case VK_SUBPASS_CONTENTS_INLINE: return TEXT("INLINE");
case VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS: return TEXT("SECONDARY_CMD_BUFS");
default: return FString::Printf(TEXT("%d"), (int32)InContents);
}
};
CmdPrintfBegin(CommandBuffer, FString::Printf(TEXT("----- vkCmdBeginRenderPass2KHR(BeginInfo=0x%p, Contents=%s)"), RenderPassBegin, *GetSubpassContents(SubpassBeginInfo->contents)));
DebugLog += FString::Printf(TEXT("%sBeginInfo: RenderPass=0x%p, Framebuffer=0x%p, renderArea=(x:%d, y:%d, %s), clearValues=%d\n"),
Tabs, RenderPassBegin->renderPass, RenderPassBegin->framebuffer,
RenderPassBegin->renderArea.offset.x, RenderPassBegin->renderArea.offset.y,
*GetExtentString(RenderPassBegin->renderArea.extent),
RenderPassBegin->clearValueCount);
for (uint32 Index = 0; Index < RenderPassBegin->clearValueCount; ++Index)
{
DebugLog += FString::Printf(TEXT("%s\tclearValue[%d]=(%s)\n"), Tabs, Index, *GetClearValueString(RenderPassBegin->pClearValues[Index]));
}
FRenderPassInfo* FoundRPInfo = GRenderPassInfo.Find(RenderPassBegin->renderPass);
ensure(FoundRPInfo);
if (FoundRPInfo)
{
FFBInfo* FoundFBInfo = GFramebufferInfo.Find(RenderPassBegin->framebuffer);
ensure(FoundFBInfo);
if (FoundFBInfo)
{
for (uint32 Index = 0; Index < FoundFBInfo->Info.attachmentCount; ++Index)
{
VkImageView View = FoundFBInfo->Attachments[Index];
auto* FoundImageInfo = GVulkanTrackingImageViews.Find(View);
// Can be null for swapchain images!
if (FoundImageInfo)
{
DebugLog += FString::Printf(TEXT("%s\t\tAttachment[%d]: ImageView=0x%p(I:0x%p)\n"), Tabs, Index, View, FoundImageInfo->CreateInfo.image);
}
}
}
}
FlushDebugWrapperLog();
#endif
}
}
void FWrapLayer::CmdEndRenderPass(VkResult Result, VkCommandBuffer CommandBuffer)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
CmdPrintfBegin(CommandBuffer, TEXT("----- vkCmdEndRenderPass()"));
#endif
}
}
void FWrapLayer::CmdNextSubpass(VkResult Result, VkCommandBuffer CommandBuffer, VkSubpassContents Contents)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
CmdPrintfBegin(CommandBuffer, FString::Printf(TEXT("----- vkNextSubpass(Contents=0x%d)"), (uint32)Contents));
#endif
}
}
void FWrapLayer::CmdExecuteCommands(VkResult Result, VkCommandBuffer CommandBuffer, uint32 CommandBufferCount, const VkCommandBuffer* pCommandBuffers)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
CmdPrintfBegin(CommandBuffer, FString::Printf(TEXT("vkCmdExecuteCommands(CommandBufferCount=%u, pCommandBuffers=0x%p)"), CommandBufferCount, pCommandBuffers));
#endif
}
}
void FWrapLayer::CmdBeginQuery(VkResult Result, VkCommandBuffer CommandBuffer, VkQueryPool QueryPool, uint32 Query, VkQueryControlFlags Flags)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
CmdPrintfBegin(CommandBuffer, FString::Printf(TEXT("vkCmdBeginQuery(QueryPool=0x%p, Query=%d Flags=%d)"), QueryPool, Query, Flags));
#endif
}
}
void FWrapLayer::CmdEndQuery(VkResult Result, VkCommandBuffer CommandBuffer, VkQueryPool QueryPool, uint32 Query)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
CmdPrintfBegin(CommandBuffer, FString::Printf(TEXT("vkCmdEndQuery(QueryPool=0x%p, Query=%d)"), QueryPool, Query));
#endif
}
}
void FWrapLayer::CmdBindVertexBuffers(VkResult Result, VkCommandBuffer CommandBuffer, uint32 FirstBinding, uint32 BindingCount, const VkBuffer* Buffers, const VkDeviceSize* Offsets)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
CmdPrintfBegin(CommandBuffer, FString::Printf(TEXT("vkCmdBindVertexBuffers(FirstBinding=%d, NumBindings=%d, Buffers=0x%p, Offsets=0x%p)[...]"), FirstBinding, BindingCount, Buffers, Offsets));
FlushDebugWrapperLog();
#endif
}
}
void FWrapLayer::CmdBindIndexBuffer(VkResult Result, VkCommandBuffer CommandBuffer, VkBuffer IndexBuffer, VkDeviceSize Offset, VkIndexType IndexType)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
CmdPrintfBegin(CommandBuffer, FString::Printf(TEXT("vkCmdBindIndexBuffer(Buffer=0x%p, Offset=%d, IndexType=%d)"), IndexBuffer, (int32)Offset, (int32)IndexType));
FlushDebugWrapperLog();
#endif
}
}
void FWrapLayer::CmdSetViewport(VkResult Result, VkCommandBuffer CommandBuffer, uint32 FirstViewport, uint32 ViewportCount, const VkViewport* Viewports)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
CmdPrintfBegin(CommandBuffer, FString::Printf(TEXT("vkCmdSetViewport(FirstViewport=%d, ViewportCount=%d, Viewports=0x%p)[...]"), FirstViewport, ViewportCount, Viewports));
#endif
}
}
void FWrapLayer::CmdSetScissor(VkResult Result, VkCommandBuffer CommandBuffer, uint32 FirstScissor, uint32 ScissorCount, const VkRect2D* Scissors)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
CmdPrintfBegin(CommandBuffer, FString::Printf(TEXT("vkCmdSetScissor(FirstScissor=%d, ScissorCount=%d, Scissors=0x%p)[...]"), FirstScissor, ScissorCount, Scissors));
#endif
}
}
void FWrapLayer::CmdSetLineWidth(VkResult Result, VkCommandBuffer CommandBuffer, float LineWidth)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
CmdPrintfBegin(CommandBuffer, FString::Printf(TEXT("vkCmdSetLineWidth(Width=%f)"), LineWidth));
#endif
}
}
void FWrapLayer::CmdDraw(VkResult Result, VkCommandBuffer CommandBuffer, uint32 VertexCount, uint32 InstanceCount, uint32 FirstVertex, uint32 FirstInstance)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
CmdPrintfBegin(CommandBuffer, FString::Printf(TEXT("vkCmdDraw(NumVertices=%d, NumInstances=%d, FirstVertex=%d, FirstInstance=%d)"), VertexCount, InstanceCount, FirstVertex, FirstInstance));
#endif
}
}
void FWrapLayer::CmdDrawIndexed(VkResult Result, VkCommandBuffer CommandBuffer, uint32 IndexCount, uint32 InstanceCount, uint32 FirstIndex, int32_t VertexOffset, uint32 FirstInstance)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
CmdPrintfBegin(CommandBuffer, FString::Printf(TEXT("vkCmdDrawIndexed(IndexCount=%d, NumInstances=%d, FirstIndex=%d, VertexOffset=%d, FirstInstance=%d)"), IndexCount, InstanceCount, FirstIndex, VertexOffset, FirstInstance));
#endif
}
}
void FWrapLayer::CmdDrawIndirect(VkResult Result, VkCommandBuffer CommandBuffer, VkBuffer Buffer, VkDeviceSize Offset, uint32 DrawCount, uint32 Stride)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
CmdPrintfBegin(CommandBuffer, FString::Printf(TEXT("vkCmdDrawIndirect(Buffer=0x%p, Offset=%d, DrawCount=%d, Stride=%d)"), (void*)Buffer, Offset, DrawCount, Stride));
#endif
}
}
void FWrapLayer::CmdDrawIndexedIndirect(VkResult Result, VkCommandBuffer CommandBuffer, VkBuffer Buffer, VkDeviceSize Offset, uint32 DrawCount, uint32 Stride)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
CmdPrintfBegin(CommandBuffer, FString::Printf(TEXT("vkCmdDrawIndexedIndirect(Buffer=0x%p, Offset=%d, DrawCount=%d, Stride=%d)"), (void*)Buffer, Offset, DrawCount, Stride));
#endif
}
}
void FWrapLayer::CmdDispatch(VkResult Result, VkCommandBuffer CommandBuffer, uint32 X, uint32 Y, uint32 Z)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
CmdPrintfBegin(CommandBuffer, FString::Printf(TEXT("vkCmdDispatch(X=%d, Y=%d Z=%d)"), X, Y, Z));
#endif
}
}
void FWrapLayer::CmdDispatchIndirect(VkResult Result, VkCommandBuffer CommandBuffer, VkBuffer Buffer, VkDeviceSize Offset)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
CmdPrintfBegin(CommandBuffer, FString::Printf(TEXT("vkCmdDispatchIndirect(Buffer=0x%p, Offset=%d)"), (void*)Buffer, Offset));
#endif
}
}
void FWrapLayer::CmdCopyImage(VkResult Result, VkCommandBuffer CommandBuffer, VkImage SrcImage, VkImageLayout SrcImageLayout, VkImage DstImage, VkImageLayout DstImageLayout, uint32 RegionCount, const VkImageCopy* Regions)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
CmdPrintfBegin(CommandBuffer, FString::Printf(TEXT("vkCmdCopyImage(SrcImage=0x%p, SrcImageLayout=%d, DstImage=0x%p, DstImageLayout=%d, RegionCount=%d, Regions=0x%p)[...]"), SrcImage, (int32)SrcImageLayout, DstImage, (int32)DstImageLayout, RegionCount, Regions));
#endif
#if VULKAN_ENABLE_IMAGE_TRACKING_LAYER
BreakOnTrackingImage(SrcImage);
BreakOnTrackingImage(DstImage);
FScopeLock ScopeLock(&GTrackingCS);
FTrackingImage* FoundSrc = GVulkanTrackingImageLayouts.Find(SrcImage);
FTrackingImage* FoundDest = GVulkanTrackingImageLayouts.Find(DstImage);
ensure(FoundSrc && FoundDest);
if (FoundSrc && FoundDest)
{
for (uint32 Index = 0; Index < RegionCount; ++Index)
{
ensure(Regions[Index].srcSubresource.layerCount == Regions[Index].dstSubresource.layerCount);
for (uint32 LIndex = 0; LIndex < Regions[Index].srcSubresource.layerCount; ++LIndex)
{
ensure(FoundSrc->ArrayLayouts[Regions[Index].srcSubresource.baseArrayLayer + LIndex][Regions[Index].srcSubresource.mipLevel] == SrcImageLayout);
ensure(FoundDest->ArrayLayouts[Regions[Index].dstSubresource.baseArrayLayer + LIndex][Regions[Index].dstSubresource.mipLevel] == DstImageLayout);
}
}
}
#endif
}
}
void FWrapLayer::CmdCopyBufferToImage(VkResult Result, VkCommandBuffer CommandBuffer, VkBuffer SrcBuffer, VkImage DstImage, VkImageLayout DstImageLayout, uint32 RegionCount, const VkBufferImageCopy* Regions)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
CmdPrintfBegin(CommandBuffer, FString::Printf(TEXT("vkCmdCopyBufferToImage(SrcBuffer=0x%p, DstImage=0x%p, DstImageLayout=%s, NumRegions=%d, Regions=0x%p)"),
SrcBuffer, DstImage, *GetVkImageLayoutString(DstImageLayout), RegionCount, Regions));
for (uint32 Index = 0; Index < RegionCount; ++Index)
{
DebugLog += FString::Printf(TEXT("%sRegion[%d]: %s\n"), Tabs, Index, *GetBufferImageCopyString(Regions[Index]));
}
FlushDebugWrapperLog();
#endif
#if VULKAN_ENABLE_IMAGE_TRACKING_LAYER
BreakOnTrackingImage(DstImage);
FScopeLock ScopeLock(&GTrackingCS);
FTrackingImage* FoundDest = GVulkanTrackingImageLayouts.Find(DstImage);
ensure(FoundDest);
if (FoundDest)
{
for (uint32 Index = 0; Index < RegionCount; ++Index)
{
for (uint32 LIndex = 0; LIndex < Regions[Index].imageSubresource.layerCount; ++LIndex)
{
ensure(FoundDest->ArrayLayouts[Regions[Index].imageSubresource.baseArrayLayer + LIndex][Regions[Index].imageSubresource.mipLevel] == DstImageLayout);
}
}
}
#endif
}
}
void FWrapLayer::CmdCopyImageToBuffer(VkResult Result, VkCommandBuffer CommandBuffer, VkImage SrcImage, VkImageLayout SrcImageLayout, VkBuffer DstBuffer, uint32 RegionCount, const VkBufferImageCopy* Regions)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
CmdPrintfBegin(CommandBuffer, FString::Printf(TEXT("vkCmdCopyImageToBuffer(SrcImage=0x%p, SrcImageLayout=%s, SrcBuffer=0x%p, NumRegions=%d, Regions=0x%p)"),
SrcImage, *GetVkImageLayoutString(SrcImageLayout), DstBuffer, RegionCount, Regions));
for (uint32 Index = 0; Index < RegionCount; ++Index)
{
DebugLog += FString::Printf(TEXT("%sRegion[%d]: %s\n"), Tabs, Index, *GetBufferImageCopyString(Regions[Index]));
}
FlushDebugWrapperLog();
#endif
}
}
void FWrapLayer::CmdCopyBuffer(VkResult Result, VkCommandBuffer CommandBuffer, VkBuffer SrcBuffer, VkBuffer DstBuffer, uint32 RegionCount, const VkBufferCopy* Regions)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
CmdPrintfBegin(CommandBuffer, FString::Printf(TEXT("vkCmdCopyBuffer(SrcBuffer=0x%p, DstBuffer=0x%p, NumRegions=%d, Regions=0x%p)"), SrcBuffer, DstBuffer, RegionCount, Regions));
for (uint32 Index = 0; Index < RegionCount; ++Index)
{
DebugLog += FString::Printf(TEXT("%sRegion[%d]: SrcOffset=%d DestOffset=%d Size=%d\n"), Tabs, Index,
(int32)Regions[Index].srcOffset, (int32)Regions[Index].dstOffset, (int32)Regions[Index].size);
}
FlushDebugWrapperLog();
#endif
}
}
void FWrapLayer::CmdBlitImage(VkResult Result, VkCommandBuffer CommandBuffer, VkImage SrcImage, VkImageLayout SrcImageLayout, VkImage DstImage, VkImageLayout DstImageLayout, uint32 RegionCount, const VkImageBlit* Regions, VkFilter Filter)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
CmdPrintfBegin(CommandBuffer, FString::Printf(TEXT("vkCmdBlitImage(SrcImage=0x%p, SrcImageLayout=%d, DstImage=0x%p, DstImageLayout=%d, RegionCount=%d, Regions=0x%p, Filter=%d)[...]"), SrcImage, (int32)SrcImageLayout, DstImage, (int32)DstImageLayout, RegionCount, Regions, (int32)Filter));
FlushDebugWrapperLog();
#endif
#if VULKAN_ENABLE_IMAGE_TRACKING_LAYER
BreakOnTrackingImage(SrcImage);
BreakOnTrackingImage(DstImage);
FScopeLock ScopeLock(&GTrackingCS);
FTrackingImage* FoundSrc = GVulkanTrackingImageLayouts.Find(SrcImage);
FTrackingImage* FoundDest = GVulkanTrackingImageLayouts.Find(DstImage);
ensure(FoundSrc && FoundDest);
if (FoundSrc && FoundDest)
{
for (uint32 Index = 0; Index < RegionCount; ++Index)
{
ensure(Regions[Index].srcSubresource.layerCount == Regions[Index].dstSubresource.layerCount);
for (uint32 LIndex = 0; LIndex < Regions[Index].srcSubresource.layerCount; ++LIndex)
{
ensure(FoundSrc->ArrayLayouts[Regions[Index].srcSubresource.baseArrayLayer + LIndex][Regions[Index].srcSubresource.mipLevel] == SrcImageLayout);
ensure(FoundDest->ArrayLayouts[Regions[Index].dstSubresource.baseArrayLayer + LIndex][Regions[Index].dstSubresource.mipLevel] == DstImageLayout);
}
}
}
#endif
}
}
#if VULKAN_ENABLE_DUMP_LAYER
static void DumpImageSubresourceLayout(VkSubresourceLayout* pLayout)
{
if (pLayout)
{
DebugLog += FString::Printf(TEXT("VkSubresourceLayout: [...]\n"));
}
else
{
DumpErrorInvalidPointer(TEXT("VkSubresourceLayout"));
}
FlushDebugWrapperLog();
}
#endif
void FWrapLayer::GetImageSubresourceLayout(VkResult Result, VkDevice Device, VkImage Image, const VkImageSubresource* Subresource, VkSubresourceLayout* Layout)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
DevicePrintfBeginResult(Device, FString::Printf(TEXT("vkGetImageSubresourceLayout(Image=0x%p, Subresource=0x%p, OutLayout=0x%p)"), Image, Subresource, Layout));
FlushDebugWrapperLog();
#endif
}
else
{
#if VULKAN_ENABLE_DUMP_LAYER
DumpImageSubresourceLayout(Layout);
#endif
}
}
void FWrapLayer::GetImageSubresourceLayout2(VkResult Result, VkDevice Device, VkImage Image, const VkImageSubresource2KHR* Subresource, VkSubresourceLayout2KHR* Layout)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
DevicePrintfBeginResult(Device, FString::Printf(TEXT("vkGetImageSubresourceLayout2(Image=0x%p, Subresource=0x%p, OutLayout=0x%p)"), (void*)Image, Subresource, Layout));
FlushDebugWrapperLog();
#endif
}
else
{
#if VULKAN_ENABLE_DUMP_LAYER
DumpImageSubresourceLayout(Layout->layout);
#endif
}
}
void FWrapLayer::GetSwapChainImagesKHR(VkResult Result, VkDevice Device, VkSwapchainKHR Swapchain, uint32_t* SwapchainImageCount, VkImage* SwapchainImages)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
DevicePrintfBeginResult(Device, FString::Printf(TEXT("vkGetSwapchainImagesKHR(Swapchain=0x%p, OutSwapchainImageCount=0x%p, OutSwapchainImages=0x%p)\n"), Swapchain, SwapchainImageCount, SwapchainImages));
FlushDebugWrapperLog();
#endif
}
else
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintResult(Result);
if (SwapchainImages)
{
for (uint32 Index = 0; Index < *SwapchainImageCount; ++Index)
{
DebugLog += FString::Printf(TEXT("%sImage[%d]=0x%p\n"), Tabs, Index, SwapchainImages[Index]);
}
}
else
{
DebugLog += FString::Printf(TEXT("%sNumImages=%d\n"), Tabs, *SwapchainImageCount);
}
#endif
#if VULKAN_ENABLE_IMAGE_TRACKING_LAYER
if (SwapchainImages)
{
FScopeLock ScopeLock(&GTrackingCS);
for (uint32 Index = 0; Index < *SwapchainImageCount; ++Index)
{
BreakOnTrackingImage(SwapchainImages[Index]);
FTrackingImage& TrackingImage = GVulkanTrackingImageLayouts.FindOrAdd(SwapchainImages[Index]);
TrackingImage.Setup(1, 1, VK_IMAGE_LAYOUT_UNDEFINED, true);
}
}
#endif
}
}
void FWrapLayer::CmdClearAttachments(VkResult Result, VkCommandBuffer CommandBuffer, uint32 AttachmentCount, const VkClearAttachment* Attachments, uint32 RectCount, const VkClearRect* Rects)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
CmdPrintfBegin(CommandBuffer, FString::Printf(TEXT("vkCmdClearAttachments(AttachmentCount=%d, Attachments=0x%p, RectCount=%d, Rects=0x%p)"), AttachmentCount, Attachments, RectCount, Rects));
for (uint32 Index = 0; Index < AttachmentCount; ++Index)
{
DebugLog += FString::Printf(TEXT("%sAttachment[%d]= aspect=%s ColorAtt=%d ClearValue=%s\n"), Tabs, Index,
*GetAspectMaskString(Attachments[Index].aspectMask), Attachments[Index].colorAttachment, *GetClearValueString(Attachments[Index].clearValue));
}
for (uint32 Index = 0; Index < RectCount; ++Index)
{
DebugLog += FString::Printf(TEXT("%sRects[%d]= Rect=(%s) BaseArrayLayer=%d NumLayers=%d\n"), Tabs, Index, *GetRectString(Rects[Index].rect), Rects[Index].baseArrayLayer, Rects[Index].layerCount);
}
FlushDebugWrapperLog();
#endif
}
}
void FWrapLayer::CmdClearColorImage(VkResult Result, VkCommandBuffer CommandBuffer, VkImage Image, VkImageLayout ImageLayout, const VkClearColorValue* Color, uint32 RangeCount, const VkImageSubresourceRange* Ranges)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
CmdPrintfBegin(CommandBuffer, FString::Printf(TEXT("vkCmdClearColorImage(Image=0x%p, ImageLayout=%s, Color=%s, RangeCount=%d, Ranges=0x%p)"), Image, *GetVkImageLayoutString(ImageLayout), *GetClearColorValueString(*Color), RangeCount, Ranges));
for (uint32 Index = 0; Index < RangeCount; ++Index)
{
DebugLog += FString::Printf(TEXT("%sRange[%d]= %s\n"), Tabs, Index, *GetImageSubResourceRangeString(Ranges[Index]));
}
FlushDebugWrapperLog();
#endif
}
}
void FWrapLayer::CmdClearDepthStencilImage(VkResult Result, VkCommandBuffer CommandBuffer, VkImage Image, VkImageLayout ImageLayout, const VkClearDepthStencilValue* DepthStencil, uint32 RangeCount, const VkImageSubresourceRange* Ranges)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
CmdPrintfBegin(CommandBuffer, FString::Printf(TEXT("vkCmdClearDepthStencilImage(Image=0x%p, ImageLayout=%s, DepthStencil=%s, RangeCount=%d, Ranges=0x%p)"), Image, *GetVkImageLayoutString(ImageLayout), *GetClearDepthStencilValueString(*DepthStencil), RangeCount, Ranges));
for (uint32 Index = 0; Index < RangeCount; ++Index)
{
DebugLog += FString::Printf(TEXT("%sRange[%d]= %s\n"), Tabs, Index, *GetImageSubResourceRangeString(Ranges[Index]));
}
FlushDebugWrapperLog();
#endif
}
}
void FWrapLayer::QueuePresent(VkResult Result, VkQueue Queue, const VkPresentInfoKHR* PresentInfo)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBeginResult(FString::Printf(TEXT("vkQueuePresentKHR(Queue=0x%p, Info=0x%p)[...]"), Queue, PresentInfo));
DebugLog += FString::Printf(TEXT("\n%sPresentInfo: Results=0x%p"), Tabs, PresentInfo->pResults);
if (PresentInfo->waitSemaphoreCount > 0)
{
DebugLog += FString::Printf(TEXT("\n%s\tWaitSemaphores: "), Tabs);
for (uint32 SubIndex = 0; SubIndex < PresentInfo->waitSemaphoreCount; ++SubIndex)
{
DebugLog += FString::Printf(TEXT("0x%p "), PresentInfo->pWaitSemaphores[SubIndex]);
}
}
if (PresentInfo->swapchainCount > 0)
{
DebugLog += FString::Printf(TEXT("\n%s\tSwapchains (ImageIndex): "), Tabs);
for (uint32 SubIndex = 0; SubIndex < PresentInfo->swapchainCount; ++SubIndex)
{
DebugLog += FString::Printf(TEXT("0x%p(%d)"), PresentInfo->pSwapchains[SubIndex], PresentInfo->pImageIndices[SubIndex]);
}
}
#endif
}
else
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintResult(Result);
#endif
}
}
void FWrapLayer::CreateGraphicsPipelines(VkResult Result, VkDevice Device, VkPipelineCache PipelineCache, uint32 CreateInfoCount, const VkGraphicsPipelineCreateInfo* CreateInfos, VkPipeline* Pipelines)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
DevicePrintfBegin(Device, FString::Printf(TEXT("vkCreateGraphicsPipelines(PipelineCache=0x%p, CreateInfoCount=%d, CreateInfos=0x%p, OutPipelines=0x%p)[...]"), PipelineCache, CreateInfoCount, CreateInfos, Pipelines));
for (uint32 Index = 0; Index < CreateInfoCount; ++Index)
{
const VkGraphicsPipelineCreateInfo& CreateInfo = CreateInfos[Index];
DebugLog += FString::Printf(TEXT("%s%d: Flags=%d Stages=%d Layout=0x%p RenderPass=0x%p Subpass=%d\n"), Tabs, Index,
CreateInfo.flags, CreateInfo.stageCount, (void*)CreateInfo.layout, (void*)CreateInfo.renderPass, CreateInfo.subpass);
DebugLog += FString::Printf(TEXT("%s\tDepth Test %d Write %d %s Bounds %d (min %f max %f) Stencil %d\n"), Tabs, CreateInfo.pDepthStencilState->depthTestEnable, CreateInfo.pDepthStencilState->depthWriteEnable, *GetVkCompareOpString(CreateInfo.pDepthStencilState->depthCompareOp), CreateInfo.pDepthStencilState->depthBoundsTestEnable, CreateInfo.pDepthStencilState->minDepthBounds, CreateInfo.pDepthStencilState->maxDepthBounds, CreateInfo.pDepthStencilState->stencilTestEnable);
auto PrintStencilOp = [](const VkStencilOpState& State)
{
return FString::Printf(TEXT("Fail %s Pass %s DepthFail %s Compare %s CompareMask 0x%x WriteMask 0x%x Ref 0x%0x"), *GetVkStencilOpString(State.failOp), *GetVkStencilOpString(State.passOp), *GetVkStencilOpString(State.depthFailOp), *GetVkCompareOpString(State.compareOp), State.compareMask, State.writeMask, State.reference);
};
DebugLog += FString::Printf(TEXT("%s\t\tFront: %s\n"), Tabs, *PrintStencilOp(CreateInfo.pDepthStencilState->front));
DebugLog += FString::Printf(TEXT("%s\t\tBack: %s\n"), Tabs, *PrintStencilOp(CreateInfo.pDepthStencilState->back));
/*
DebugLog += FString::Printf(TEXT(""));
typedef struct VkGraphicsPipelineCreateInfo {
const VkPipelineShaderStageCreateInfo* pStages;
const VkPipelineVertexInputStateCreateInfo* pVertexInputState;
const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState;
const VkPipelineTessellationStateCreateInfo* pTessellationState;
const VkPipelineViewportStateCreateInfo* pViewportState;
const VkPipelineRasterizationStateCreateInfo* pRasterizationState;
const VkPipelineMultisampleStateCreateInfo* pMultisampleState;
const VkPipelineColorBlendStateCreateInfo* pColorBlendState;
const VkPipelineDynamicStateCreateInfo* pDynamicState;
VkPipeline basePipelineHandle;
int32_t basePipelineIndex;
} VkGraphicsPipelineCreateInfo;
*/
}
#endif
}
else
{
#if VULKAN_ENABLE_DUMP_LAYER
//#todo-rco: Multiple pipelines!
PrintResultAndNamedHandle(Result, TEXT("Pipeline"), Pipelines[0]);
#endif
}
}
void FWrapLayer::GetDeviceQueue(VkResult Result, VkDevice Device, uint32 QueueFamilyIndex, uint32 QueueIndex, VkQueue* Queue)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
DevicePrintfBeginResult(Device, FString::Printf(TEXT("vkGetDeviceQueue(QueueFamilyIndex=%d, QueueIndex=%d, OutQueue=0x%p)\n"), QueueFamilyIndex, QueueIndex, Queue));
#endif
}
else
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintResultAndNamedHandle(VK_SUCCESS, TEXT("Queue"), *Queue);
#endif
}
}
void FWrapLayer::DeviceWaitIdle(VkResult Result, VkDevice Device)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
DevicePrintfBeginResult(Device, FString::Printf(TEXT("vkDeviceWaitIdle()")));
#endif
}
else
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintResult(Result);
#endif
}
}
void FWrapLayer::MapMemory(VkResult Result, VkDevice Device, VkDeviceMemory Memory, VkDeviceSize Offset, VkDeviceSize Size, VkMemoryMapFlags Flags, void** Data)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
DevicePrintfBeginResult(Device, FString::Printf(TEXT("vkMapMemory(DevMem=0x%p, Off=%d, Size=%d, Flags=0x%x, OutData=0x%p)\n"), Memory, (uint32)Offset, (uint32)Size, Flags, Data));
#endif
}
else
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintResultAndPointer(Result, *Data);
#endif
}
}
void FWrapLayer::UnmapMemory(VkResult Result, VkDevice Device, VkDeviceMemory Memory)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
DevicePrintfBegin(Device, FString::Printf(TEXT("vkUnmapMemory(DevMem=0x%p)\n"), Memory));
#endif
}
else
{
}
}
#if VULKAN_ENABLE_DUMP_LAYER
static void DumpCommittedMemoryInBytes(VkDeviceSize* pCommittedMemoryInBytes)
{
if (pCommittedMemoryInBytes)
{
DebugLog += FString::Printf(TEXT(" -> Size=%llu\n"), *pCommittedMemoryInBytes);
}
else
{
DumpErrorInvalidPointer(TEXT("VkDeviceSize"));
}
FlushDebugWrapperLog();
}
#endif
void FWrapLayer::GetDeviceMemoryCommitment(VkResult Result, VkDevice Device, VkDeviceMemory Memory, VkDeviceSize* pCommittedMemoryInBytes)
{
#if VULKAN_ENABLE_DUMP_LAYER
if (Result == VK_RESULT_MAX_ENUM)
{
DevicePrintfBeginResult(Device, FString::Printf(TEXT("vkGetDeviceMemoryCommitment(Memory=0x%p, pCommittedMemoryInBytes=0x%p)"), Memory, pCommittedMemoryInBytes));
}
else
{
DumpCommittedMemoryInBytes(pCommittedMemoryInBytes);
}
#endif
}
void FWrapLayer::BindBufferMemory(VkResult Result, VkDevice Device, VkBuffer Buffer, VkDeviceMemory Memory, VkDeviceSize MemoryOffset)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
DevicePrintfBeginResult(Device, FString::Printf(TEXT("vkBindBufferMemory(Buffer=0x%p, Memory=0x%p, MemoryOffset=%llu)\n"), Buffer, Memory, MemoryOffset));
#endif
}
else
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintResult(Result);
#endif
}
}
void FWrapLayer::BindImageMemory(VkResult Result, VkDevice Device, VkImage Image, VkDeviceMemory Memory, VkDeviceSize MemoryOffset)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
DevicePrintfBeginResult(Device, FString::Printf(TEXT("vkBindImageMemory(Image=0x%p, DevMem=0x%p, MemOff=%d)\n"), Image, Memory, (uint32)MemoryOffset));
#endif
}
else
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintResult(Result);
#endif
}
}
void FWrapLayer::GetFenceStatus(VkResult Result, VkDevice Device, VkFence Fence)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
DevicePrintfBeginResult(Device, FString::Printf(TEXT("vkGetFenceStatus(Fence=0x%p)"), Fence));
#endif
}
else
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintResult(Result);
#endif
}
}
void FWrapLayer::GetQueryPoolResults(VkResult Result, VkDevice Device, VkQueryPool QueryPool, uint32 FirstQuery, uint32 QueryCount, size_t DataSize, void* Data, VkDeviceSize Stride, VkQueryResultFlags Flags)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
DevicePrintfBeginResult(Device, FString::Printf(TEXT("vkGetQueryPoolResults(QueryPool=0x%p, FirstQuery=%d, QueryCount=%d, DataSize=%d, Data=0x%p, Stride=%d, Flags=%d)[...]"), QueryPool, FirstQuery, QueryCount, (int32)DataSize, Data, Stride, Flags));
#endif
}
else
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintResult(Result);
#endif
}
}
void FWrapLayer::CreateComputePipelines(VkResult Result, VkDevice Device, VkPipelineCache PipelineCache, uint32 CreateInfoCount, const VkComputePipelineCreateInfo* CreateInfos, VkPipeline* Pipelines)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
DevicePrintfBeginResult(Device, FString::Printf(TEXT("vkCreateComputePipelines(PipelineCache=0x%p, CreateInfoCount=%d, CreateInfos=0x%p, OutPipelines=0x%p)[...]\n"), PipelineCache, CreateInfoCount, CreateInfos, Pipelines));
#endif
}
else
{
#if VULKAN_ENABLE_DUMP_LAYER
//#todo-rco: Multiple pipelines!
PrintResultAndNamedHandle(Result, TEXT("Pipeline"), Pipelines[0]);
#endif
}
}
void FWrapLayer::ResetCommandPool(VkResult Result, VkDevice Device, VkCommandPool CommandPool, VkCommandPoolResetFlags Flags)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
DevicePrintfBeginResult(Device, FString::Printf(TEXT("vkResetCommandPool(CommandPool=0x%p, Flags=0x%08X)"), CommandPool, Flags));
#endif
}
else
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintResult(Result);
#endif
}
}
void FWrapLayer::TrimCommandPool(VkResult Result, VkDevice Device, VkCommandPool CommandPool, VkCommandPoolTrimFlags Flags)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
DevicePrintfBeginResult(Device, FString::Printf(TEXT("vkTrimCommandPool(CommandPool=0x%p, Flags=0x%08X)"), CommandPool, Flags));
#endif
}
else
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintResult(Result);
#endif
}
}
void FWrapLayer::AllocateCommandBuffers(VkResult Result, VkDevice Device, const VkCommandBufferAllocateInfo* AllocateInfo, VkCommandBuffer* CommandBuffers)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
DevicePrintfBeginResult(Device, FString::Printf(TEXT("vkAllocateCommandBuffers(AllocateInfo=0x%p, OutCommandBuffers=0x%p)[...]\n"), AllocateInfo, CommandBuffers));
#endif
}
else
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintResultAndNamedHandle(Result, TEXT("CommandBuffers"), *CommandBuffers);
#endif
}
}
void FWrapLayer::CreateSwapchainKHR(VkResult Result, VkDevice Device, const VkSwapchainCreateInfoKHR* CreateInfo, VkSwapchainKHR* Swapchain)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
DevicePrintfBeginResult(Device, FString::Printf(TEXT("vkCreateSwapchainKHR(SwapChainInfo=0x%p, OutSwapChain=0x%p)[...]"), CreateInfo, Swapchain));
#endif
}
else
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintResultAndNamedHandle(Result, TEXT("SwapChain"), *Swapchain);
#endif
}
}
void FWrapLayer::AcquireNextImageKHR(VkResult Result, VkDevice Device, VkSwapchainKHR Swapchain, uint64_t Timeout, VkSemaphore Semaphore, VkFence Fence, uint32_t* ImageIndex)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
DevicePrintfBeginResult(Device, FString::Printf(TEXT("vkAcquireNextImageKHR(Swapchain=0x%p, Timeout=0x%p, Semaphore=0x%p, Fence=0x%p, OutImageIndex=0x%p)[...]\n"), Swapchain, (void*)Timeout, Semaphore, Fence, ImageIndex));
#endif
}
else
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintResultAndNamedHandle(Result, TEXT("ImageIndex"), *ImageIndex);
#endif
}
}
void FWrapLayer::FreeMemory(VkResult Result, VkDevice Device, VkDeviceMemory Memory)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
DevicePrintfBegin(Device, FString::Printf(TEXT("vkFreeMemory(DevMem=0x%p)"), Memory));
#endif
}
}
void FWrapLayer::DestroyFence(VkResult Result, VkDevice Device, VkFence Fence)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
DevicePrintfBegin(Device, FString::Printf(TEXT("vkDestroyFence(Fence=0x%p)"), Fence));
#endif
}
}
void FWrapLayer::DestroySemaphore(VkResult Result, VkDevice Device, VkSemaphore Semaphore)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
DevicePrintfBegin(Device, FString::Printf(TEXT("vkDestroySemaphore(Semaphore=0x%p)"), Semaphore));
#endif
}
}
void FWrapLayer::CreateEvent(VkResult Result, VkDevice Device, const VkEventCreateInfo* CreateInfo, VkEvent* Event)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
DevicePrintfBegin(Device, FString::Printf(TEXT("vkCreateEvent(CreateInfo=0x%p, OutEvent=0x%p)"), CreateInfo, Event));
#endif
}
else
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintResultAndNamedHandle(Result, TEXT("Event"), *Event);
#endif
}
}
void FWrapLayer::DestroyEvent(VkResult Result, VkDevice Device, VkEvent Event)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
DevicePrintfBegin(Device, FString::Printf(TEXT("vkDestroyEvent(Event=0x%p)"), Event));
#endif
}
else
{
}
}
void FWrapLayer::DestroyBuffer(VkResult Result, VkDevice Device, VkBuffer Buffer)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
DevicePrintfBegin(Device, FString::Printf(TEXT("vkDestroyBuffer(Buffer=0x%p)"), Buffer));
#endif
}
else
{
#if VULKAN_ENABLE_BUFFER_TRACKING_LAYER
{
FScopeLock ScopeLock(&GTrackingCS);
int32 NumRemoved = GVulkanTrackingBuffers.Remove(Buffer);
ensure(NumRemoved > 0);
auto* Found = GVulkanTrackingBufferToBufferViews.Find(Buffer);
if (Found)
{
ensure(Found->Num() > 0);
}
}
#endif
}
}
void FWrapLayer::DestroyBufferView(VkResult Result, VkDevice Device, VkBufferView BufferView)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
DevicePrintfBegin(Device, FString::Printf(TEXT("vkDestroyBufferView(BufferView=0x%p)"), BufferView));
#endif
}
else
{
#if VULKAN_ENABLE_BUFFER_TRACKING_LAYER
{
FScopeLock ScopeLock(&GTrackingCS);
int32 NumRemoved = GVulkanTrackingBufferViews.Remove(BufferView);
ensure(NumRemoved > 0);
}
#endif
}
}
void FWrapLayer::DestroyQueryPool(VkResult Result, VkDevice Device, VkQueryPool QueryPool)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
DevicePrintfBegin(Device, FString::Printf(TEXT("vkDestroyQueryPool(QueryPool=0x%p)"), QueryPool));
#endif
}
}
void FWrapLayer::DestroyImageView(VkResult Result, VkDevice Device, VkImageView ImageView)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
DevicePrintfBegin(Device, FString::Printf(TEXT("vkDestroyImageView(ImageView=0x%p)"), ImageView));
#endif
}
else
{
#if VULKAN_ENABLE_IMAGE_TRACKING_LAYER
{
FScopeLock ScopeLock(&GTrackingCS);
BreakOnTrackingImageView(ImageView);
int32 NumRemoved = GVulkanTrackingImageViews.Remove(ImageView);
ensure(NumRemoved > 0);
}
#endif
}
}
void FWrapLayer::DestroyShaderModule(VkResult Result, VkDevice Device, VkShaderModule ShaderModule)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
DevicePrintfBegin(Device, FString::Printf(TEXT("vkDestroyShaderModule(ShaderModule=0x%p)"), ShaderModule));
#endif
}
}
void FWrapLayer::DestroyPipelineCache(VkResult Result, VkDevice Device, VkPipelineCache PipelineCache)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
DevicePrintfBegin(Device, FString::Printf(TEXT("vkDestroyPipelineCache(PipelineCache=0x%p)"), PipelineCache));
#endif
}
}
void FWrapLayer::GetPipelineCacheData(VkResult Result, VkDevice Device, VkPipelineCache PipelineCache, size_t* DataSize, void* Data)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
DevicePrintfBegin(Device, FString::Printf(TEXT("vkGetPipelineCacheData(PipelineCache=0x%p, DataSize=%d, [Data])"), PipelineCache, DataSize));
#endif
}
else
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintResult(Result);
#endif
}
}
void FWrapLayer::MergePipelineCaches(VkResult Result, VkDevice Device, VkPipelineCache DestCache, uint32 SourceCacheCount, const VkPipelineCache* SrcCaches)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
DevicePrintfBegin(Device, FString::Printf(TEXT("vkMergePipelineCaches(DestCache=0x%p, SourceCacheCount=%d, [SrcCaches])"), DestCache, SourceCacheCount));
#endif
}
else
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintResult(Result);
#endif
}
}
void FWrapLayer::DestroySampler(VkResult Result, VkDevice Device, VkSampler Sampler)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
DevicePrintfBegin(Device, FString::Printf(TEXT("vkDestroySampler(Sampler=0x%p)"), Sampler));
#endif
}
}
void FWrapLayer::DestroySwapchainKHR(VkResult Result, VkDevice Device, VkSwapchainKHR SwapchainKHR)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
DevicePrintfBegin(Device, FString::Printf(TEXT("vkDestroySwapchainKHR(SwapchainKHR=0x%p)"), SwapchainKHR));
#endif
}
}
void FWrapLayer::FreeCommandBuffers(VkResult Result, VkDevice Device, VkCommandPool CommandPool, uint32 CommandBufferCount, const VkCommandBuffer* CommandBuffers)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
DevicePrintfBegin(Device, FString::Printf(TEXT("vkFreeCommandBuffers(CommandPool=0x%p, CommandBufferCount=%d, CommandBuffers=0x%p)[...]"), CommandPool, CommandBufferCount, CommandBuffers));
#endif
}
}
void FWrapLayer::DestroyInstance(VkResult Result, VkInstance Instance)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBegin(FString::Printf(TEXT("vkDestroyInstance(Instance=0x%p)"), Instance));
#endif
}
}
void FWrapLayer::ResetDescriptorPool(VkResult Result, VkDevice Device, VkDescriptorPool DescriptorPool, VkDescriptorPoolResetFlags Flags)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
DevicePrintfBegin(Device, FString::Printf(TEXT("vkResetDescriptorPool(DescriptorPool=0x%p, Flags=0x%x)"), DescriptorPool, (uint32)Flags));
#endif
}
else
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintResult(Result);
#endif
}
}
void FWrapLayer::DestroyDescriptorPool(VkResult Result, VkDevice Device, VkDescriptorPool DescriptorPool)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
DevicePrintfBegin(Device, FString::Printf(TEXT("vkDestroyDescriptorPool(DescriptorPool=0x%p)"), DescriptorPool));
#endif
}
}
void FWrapLayer::DestroyDescriptorSetLayout(VkResult Result, VkDevice Device, VkDescriptorSetLayout DescriptorSetLayout)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
DevicePrintfBegin(Device, FString::Printf(TEXT("vkDestroyDescriptorSetLayout(DescriptorSetLayout=0x%p)"), DescriptorSetLayout));
#endif
}
}
void FWrapLayer::DestroySurfaceKHR(VkResult Result, VkInstance Instance, VkSurfaceKHR SurfaceKHR)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBeginResult(FString::Printf(TEXT("vkDestroySurfaceKHR(PhysicalDevice=%llu, Surface=%llu)"), (uint64)Instance, (uint64)SurfaceKHR));
#endif
}
}
void FWrapLayer::DestroyFramebuffer(VkResult Result, VkDevice Device, VkFramebuffer Framebuffer)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
DevicePrintfBegin(Device, FString::Printf(TEXT("vkDestroyFramebuffer(Framebuffer=0x%p)"), Framebuffer));
#endif
}
}
void FWrapLayer::DestroyRenderPass(VkResult Result, VkDevice Device, VkRenderPass RenderPass)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
DevicePrintfBegin(Device, FString::Printf(TEXT("vkDestroyRenderPass(RenderPass=0x%p)"), RenderPass));
#endif
}
}
#if VULKAN_ENABLE_DUMP_LAYER
static void DumpExtent2D(const VkExtent2D* pExtent)
{
if (pExtent)
{
DebugLog += FString::Printf(TEXT(" -> Width=%u Height=%u\n"), pExtent->width, pExtent->height);
}
else
{
DumpErrorInvalidPointer(TEXT("VkExtent2D"));
}
FlushDebugWrapperLog();
}
#endif
void FWrapLayer::GetRenderAreaGranularity(VkResult Result, VkDevice Device, VkRenderPass RenderPass, VkExtent2D* pGranularity)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
DevicePrintfBeginResult(Device, FString::Printf(TEXT("vkGetRenderAreaGranularity(RenderPass=0x%p, pGranularity=0x%p)"), RenderPass, pGranularity));
#endif
}
else
{
#if VULKAN_ENABLE_DUMP_LAYER
DumpExtent2D(pGranularity);
#endif
}
}
void FWrapLayer::DestroyCommandPool(VkResult Result, VkDevice Device, VkCommandPool CommandPool)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
DevicePrintfBegin(Device, FString::Printf(TEXT("vkDestroyCommandPool(CommandPool=0x%p)"), CommandPool));
#endif
}
}
void FWrapLayer::DestroyPipelineLayout(VkResult Result, VkDevice Device, VkPipelineLayout PipelineLayout)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
DevicePrintfBegin(Device, FString::Printf(TEXT("vkDestroyPipelineLayout(PipelineLayout=0x%p)"), PipelineLayout));
#endif
}
}
void FWrapLayer::DestroyPipeline(VkResult Result, VkDevice Device, VkPipeline Pipeline)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
DevicePrintfBegin(Device, FString::Printf(TEXT("vkDestroyPipeline(Pipeline=0x%p)"), Pipeline));
#endif
}
}
void FWrapLayer::DestroyDevice(VkResult Result, VkDevice Device)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
DevicePrintfBegin(Device, FString::Printf(TEXT("vkDestroyDevice(Device=0x%p)"), Device));
#endif
}
}
void FWrapLayer::ResetCommandBuffer(VkResult Result, VkCommandBuffer CommandBuffer, VkCommandBufferResetFlags Flags)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBeginResult(FString::Printf(TEXT("vkResetCommandBuffer(Cmd=0x%p, Flags=%d)"), CommandBuffer, Flags));
#endif
}
else
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintResult(Result);
#endif
}
}
void FWrapLayer::GetPhysicalDeviceQueueFamilyProperties(VkResult Result, VkPhysicalDevice PhysicalDevice, uint32* QueueFamilyPropertyCount, VkQueueFamilyProperties* QueueFamilyProperties)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBeginResult(FString::Printf(TEXT("vkGetPhysicalDeviceQueueFamilyProperties(PhysicalDevice=0x%p, QueueFamilyPropertyCount=0x%p, QueueFamilyProperties=0x%p)[...]"), PhysicalDevice, QueueFamilyPropertyCount, QueueFamilyProperties));
#endif
}
}
void FWrapLayer::GetPhysicalDeviceQueueFamilyProperties2(VkResult Result, VkPhysicalDevice PhysicalDevice, uint32* QueueFamilyPropertyCount, VkQueueFamilyProperties2* QueueFamilyProperties)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBeginResult(FString::Printf(TEXT("vkGetPhysicalDeviceQueueFamilyProperties2(PhysicalDevice=0x%p, QueueFamilyPropertyCount=0x%p, QueueFamilyProperties2=0x%p)[...]"), PhysicalDevice, QueueFamilyPropertyCount, QueueFamilyProperties));
#endif
}
}
void FWrapLayer::GetImageMemoryRequirements2(VkResult Result, VkDevice Device, const VkImageMemoryRequirementsInfo2* Info, VkMemoryRequirements2* MemoryRequirements)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
DevicePrintfBegin(Device, FString::Printf(TEXT("vkGetImageMemoryRequirements2(Info=0x%p, MemReqs=0x%p)[...]"), Info, MemoryRequirements));
#endif
}
}
void FWrapLayer::GetBufferMemoryRequirements2(VkResult Result, VkDevice Device, const VkBufferMemoryRequirementsInfo2* Info, VkMemoryRequirements2* MemoryRequirements)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
DevicePrintfBegin(Device, FString::Printf(TEXT("vkGetBufferemoryRequirements2(Info=0x%p, MemReqs=0x%p)[...]"), Info, MemoryRequirements));
#endif
}
}
void FWrapLayer::GetImageSparseMemoryRequirements(VkResult Result, VkDevice Device, VkImage Image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
DevicePrintfBegin(Device, FString::Printf(TEXT("vkGetImageSparseMemoryRequirements(Device=0x%p, Image=0x%p, pSparseMemoryRequirementCount=0x%p, pSparseMemoryRequirements=0x%p)[...]"), Device, Image, pSparseMemoryRequirementCount, pSparseMemoryRequirements));
#endif
}
}
void FWrapLayer::GetPhysicalDeviceSparseImageFormatProperties(VkResult Result, VkPhysicalDevice PhysicalDevice, VkFormat Format, VkImageType Type, VkSampleCountFlagBits Samples, VkImageUsageFlags Usage, VkImageTiling Tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBegin(FString::Printf(
TEXT("vkGetPhysicalDeviceSparseImageFormatProperties(PhysicalDevice=0x%p, Format=%s, Type=%d, Samples=0x%08X, Usage=%d, Tiling=%d, pPropertyCount=%u, pProperties=0x%p)[...]"),
PhysicalDevice, *GetVkFormatString(Format), (int32)Type, (int32)Samples, (int32)Usage, *GetVkImageTilingString(Tiling), (pPropertyCount != nullptr ? *pPropertyCount : 0u), pProperties
));
#endif
}
}
void FWrapLayer::QueueBindSparse(VkResult Result, VkQueue Queue, uint32_t BindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence Fence)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBeginResult(FString::Printf(TEXT("vkQueueBindSparse(Queue=0x%p, BindInfoCount=%u, pBindInfo=0x%p, Fence=0x%p)"), Queue, BindInfoCount, pBindInfo, Fence));
#endif
}
else
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintResult(Result);
#endif
}
}
void FWrapLayer::GetPhysicalDeviceMemoryProperties2(VkResult Result, VkPhysicalDevice PhysicalDevice, VkPhysicalDeviceMemoryProperties2* MemoryProperties)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBegin(FString::Printf(TEXT("vkGetPhysicalDeviceMemoryProperties2(PhysicalDevice=0x%p, Properties=0x%p)[...]"), PhysicalDevice, MemoryProperties));
#endif
}
}
void FWrapLayer::GetPhysicalDeviceProperties2(VkResult Result, VkPhysicalDevice PhysicalDevice, VkPhysicalDeviceProperties2* Properties)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBegin(FString::Printf(TEXT("vkGetPhysicalDeviceProperties2(PhysicalDevice=0x%p, Properties=0x%p)[...]"), PhysicalDevice, Properties));
#endif
}
}
void FWrapLayer::GetPhysicalDeviceFeatures2(VkResult Result, VkPhysicalDevice PhysicalDevice, VkPhysicalDeviceFeatures2* Features)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBegin(FString::Printf(TEXT("vkGetPhysicalDeviceFeatures2(PhysicalDevice=0x%p, Features=0x%p)[...]"), PhysicalDevice, Features));
#endif
}
}
void FWrapLayer::GetPhysicalDeviceFragmentShadingRatesKHR(VkResult Result, VkPhysicalDevice PhysicalDevice, uint32* FragmentShadingRateCount, VkPhysicalDeviceFragmentShadingRateKHR* FragmentShadingRates)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBegin(FString::Printf(TEXT("GetPhysicalDeviceFragmentShadingRatesKHR(PhysicalDevice=0x%p, FragmentShadingRateCount=0x%p, FragmentShadingRates=0x%p)[...]"), PhysicalDevice, FragmentShadingRateCount, FragmentShadingRates));
#endif
}
}
void FWrapLayer::CmdSetDepthBias(VkResult Result, VkCommandBuffer CommandBuffer, float DepthBiasConstantFactor, float DepthBiasClamp, float DepthBiasSlopeFactor)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
CmdPrintfBegin(CommandBuffer, FString::Printf(TEXT("vkCmdSetDepthBias(ConstFactor=%f, Clamp=%f, SlopeFactor=%f)"), DepthBiasConstantFactor, DepthBiasClamp, DepthBiasSlopeFactor));
#endif
}
}
void FWrapLayer::CmdSetBlendConstants(VkResult Result, VkCommandBuffer CommandBuffer, const float BlendConstants[4])
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
CmdPrintfBegin(CommandBuffer, FString::Printf(TEXT("vkCmdSetBlendConstants(BlendConstants=[%f, %f, %f, %f])"), BlendConstants[0], BlendConstants[1], BlendConstants[2], BlendConstants[3]));
#endif
}
}
void FWrapLayer::CmdSetDepthBounds(VkResult Result, VkCommandBuffer CommandBuffer, float MinDepthBounds, float MaxDepthBounds)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
CmdPrintfBegin(CommandBuffer, FString::Printf(TEXT("vkCmdSetDepthBounds(Min=%f Max=%f])"), MinDepthBounds, MaxDepthBounds));
#endif
}
}
void FWrapLayer::CmdSetStencilCompareMask(VkResult Result, VkCommandBuffer CommandBuffer, VkStencilFaceFlags FaceMask, uint32 CompareMask)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
CmdPrintfBegin(CommandBuffer, FString::Printf(TEXT("vkCmdSetStencilCompareMask(FaceMask=%d, CompareMask=%d)"), (int32)FaceMask, (int32)CompareMask));
#endif
}
}
void FWrapLayer::CmdSetStencilWriteMask(VkResult Result, VkCommandBuffer CommandBuffer, VkStencilFaceFlags FaceMask, uint32 WriteMask)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
CmdPrintfBegin(CommandBuffer, FString::Printf(TEXT("vkCmdSetStencilWriteMask(FaceMask=%d, CompareMask=%d)"), (int32)FaceMask, (int32)WriteMask));
#endif
}
}
void FWrapLayer::CmdSetStencilReference(VkResult Result, VkCommandBuffer CommandBuffer, VkStencilFaceFlags FaceMask, uint32 Reference)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
CmdPrintfBegin(CommandBuffer, FString::Printf(TEXT("vkCmdSetStencilReference(FaceMask=%d, Ref=%d)"), (int32)FaceMask, (int32)Reference));
#endif
}
}
void FWrapLayer::CmdUpdateBuffer(VkResult Result, VkCommandBuffer CommandBuffer, VkBuffer DstBuffer, VkDeviceSize DstOffset, VkDeviceSize DataSize, const void* pData)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
CmdPrintfBegin(CommandBuffer, FString::Printf(TEXT("vkCmdUpdateBuffer(DstBuffer=0x%p, DstOffset=%d, Size=%d, Data=0x%p)"), DstBuffer, (uint32)DstOffset, (uint32)DataSize, pData));
#endif
}
}
void FWrapLayer::CmdFillBuffer(VkResult Result, VkCommandBuffer CommandBuffer, VkBuffer DstBuffer, VkDeviceSize DstOffset, VkDeviceSize Size, uint32 Data)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
CmdPrintfBegin(CommandBuffer, FString::Printf(TEXT("vkCmdFillBuffer(DstBuffer=0x%p, DstOffset=%d, Size=%d, Data=0x%x)"), DstBuffer, (uint32)DstOffset, (uint32)Size, Data));
#endif
}
}
void FWrapLayer::CmdSetEvent(VkResult Result, VkCommandBuffer CommandBuffer, VkEvent Event, VkPipelineStageFlags StageMask)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
CmdPrintfBegin(CommandBuffer, FString::Printf(TEXT("vkCmdSetEvent(Event=0x%p, StageMask=0x%x)"), Event, StageMask));
#endif
}
}
void FWrapLayer::CmdResetEvent(VkResult Result, VkCommandBuffer CommandBuffer, VkEvent Event, VkPipelineStageFlags StageMask)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
CmdPrintfBegin(CommandBuffer, FString::Printf(TEXT("vkCmdResetEvent(Event=0x%p, StageMask=0x%x)"), Event, StageMask));
#endif
}
}
void FWrapLayer::SetEvent(VkResult Result, VkDevice Device, VkEvent Event)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
DevicePrintfBegin(Device, FString::Printf(TEXT("vkCmdSetEvent(Event=0x%p)"), Event));
#endif
}
}
void FWrapLayer::ResetEvent(VkResult Result, VkDevice Device, VkEvent Event)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
DevicePrintfBegin(Device, FString::Printf(TEXT("vkCmdResetEvent(Event=0x%p)"), Event));
#endif
}
}
void FWrapLayer::GetEventStatus(VkResult Result, VkDevice Device, VkEvent Event)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
DevicePrintfBegin(Device, FString::Printf(TEXT("GetEventStatus(Event=0x%p)"), Event));
#endif
}
else
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintResult(Result);
#endif
}
}
void FWrapLayer::CmdCopyQueryPoolResults(VkResult Result, VkCommandBuffer CommandBuffer, VkQueryPool QueryPool, uint32 FirstQuery, uint32 QueryCount, VkBuffer DstBuffer, VkDeviceSize DstOffset, VkDeviceSize Stride, VkQueryResultFlags Flags)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
CmdPrintfBegin(CommandBuffer, FString::Printf(TEXT("vkCmdCopyQueryPoolResults(QueryPool=0x%p, FirstQuery=%d, QueryCount=%d, DstBuffer=0x%p, DstOffset=%d, Stride=%d, Flags=0x%x)"),
(void*)QueryPool, FirstQuery, QueryCount, (void*)DstBuffer, (uint32)DstOffset, (uint32)Stride, (uint32)Flags));
#endif
}
}
void FWrapLayer::GetInstanceProcAddr(VkResult Result, VkInstance Instance, const char* Name, PFN_vkVoidFunction VoidFunction)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBeginResult(FString::Printf(TEXT("vkGetInstanceProcAddr(Instance=0x%p, Name=%s)[...]"), Instance, ANSI_TO_TCHAR(Name)));
#endif
}
else
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintResultAndPointer(VK_SUCCESS, (void*)VoidFunction);
#endif
}
}
void FWrapLayer::GetDeviceProcAddr(VkResult Result, VkDevice Device, const char* Name, PFN_vkVoidFunction VoidFunction)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBeginResult(FString::Printf(TEXT("vkGetDeviceProcAddr(Device=0x%p, Name=%s)[...]"), Device, ANSI_TO_TCHAR(Name)));
#endif
}
else
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintResultAndPointer(VK_SUCCESS, (void*)VoidFunction);
#endif
}
}
void FWrapLayer::EnumerateInstanceExtensionProperties(VkResult Result, const char* LayerName, uint32* PropertyCount, VkExtensionProperties* Properties)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBeginResult(FString::Printf(TEXT("vkEnumerateInstanceExtensionProperties(LayerName=%s, PropertyCount=0x%p, Properties=0x%p)[...]"), ANSI_TO_TCHAR(LayerName), PropertyCount, Properties));
#endif
}
else
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintResultAndPointer(Result, (void*)(uint64)PropertyCount);
PrintResultAndPointer(Result, (void*)Properties);
#endif
}
}
void FWrapLayer::EnumerateDeviceExtensionProperties(VkResult Result, VkPhysicalDevice PhysicalDevice, const char* LayerName, uint32* PropertyCount, VkExtensionProperties* Properties)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBeginResult(FString::Printf(TEXT("vkEnumerateDeviceExtensionProperties(Device=0x%p, LayerName=%s, PropertyCount=0x%p, Properties=0x%p)[...]"), PhysicalDevice, ANSI_TO_TCHAR(LayerName), PropertyCount, Properties));
#endif
}
else
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintResultAndPointer(Result, (void*)(uint64)PropertyCount);
PrintResultAndPointer(Result, (void*)Properties);
#endif
}
}
void FWrapLayer::EnumerateInstanceLayerProperties(VkResult Result, uint32* PropertyCount, VkLayerProperties* Properties)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBeginResult(FString::Printf(TEXT("vkEnumerateInstanceLayerProperties(PropertyCount=0x%p, Properties=0x%p)[...]"), PropertyCount, Properties));
#endif
}
else
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintResultAndPointer(Result, (void*)(uint64)PropertyCount);
PrintResultAndPointer(Result, (void*)Properties);
#endif
}
}
void FWrapLayer::EnumerateDeviceLayerProperties(VkResult Result, VkPhysicalDevice PhysicalDevice, uint32* PropertyCount, VkLayerProperties* Properties)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBeginResult(FString::Printf(TEXT("vkEnumerateDeviceLayerProperties(Device=0x%p, PropertyCount=0x%p, Properties=0x%p)[...]"), PhysicalDevice, PropertyCount, Properties));
#endif
}
else
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintResultAndPointer(Result, (void*)(uint64)PropertyCount);
PrintResultAndPointer(Result, (void*)Properties);
#endif
}
}
void FWrapLayer::GetPhysicalDeviceSurfaceCapabilitiesKHR(VkResult Result, VkPhysicalDevice PhysicalDevice, VkSurfaceKHR Surface, VkSurfaceCapabilitiesKHR* SurfaceCapabilities)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBeginResult(FString::Printf(TEXT("vkGetPhysicalDeviceSurfaceCapabilitiesKHR(PhysicalDevice=0x%p, Surface=0x%p)[...]"), PhysicalDevice, Surface));
#endif
}
else
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintResult(Result);
#endif
}
}
void FWrapLayer::GetPhysicalDeviceSurfaceFormatsKHR(VkResult Result, VkPhysicalDevice PhysicalDevice, VkSurfaceKHR Surface, uint32_t* SurfaceFormatCountPtr, VkSurfaceFormatKHR* SurfaceFormats)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBeginResult(FString::Printf(TEXT("vkGetPhysicalDeviceSurfaceFormatsKHR(PhysicalDevice=0x%p, Surface=0x%p)[...]"), PhysicalDevice, Surface));
#endif
}
else
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintResult(Result);
#endif
}
}
void FWrapLayer::GetPhysicalDeviceSurfaceSupportKHR(VkResult Result, VkPhysicalDevice PhysicalDevice, uint32_t QueueFamilyIndex, VkSurfaceKHR Surface, VkBool32* SupportedPtr)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBeginResult(FString::Printf(TEXT("vkGetPhysicalDeviceSurfaceSupportKHR(PhysicalDevice=0x%p, QueueFamilyIndex=%d, Surface=0x%p)[...]"), PhysicalDevice, QueueFamilyIndex, (void*)Surface));
#endif
}
else
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintResult(Result);
#endif
}
}
void FWrapLayer::GetPhysicalDeviceSurfacePresentModesKHR(VkResult Result, VkPhysicalDevice PhysicalDevice, VkSurfaceKHR Surface, uint32_t* PresentModeCountPtr, VkPresentModeKHR* PresentModesPtr)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBeginResult(FString::Printf(TEXT("vkGetPhysicalDeviceSurfacePresentModesKHR(PhysicalDevice=0x%p, Surface=0x%p, PresentModeCountPtr=%d, PresentModesPtr=0x%p)"), PhysicalDevice, Surface, PresentModeCountPtr ? *PresentModeCountPtr:0, PresentModesPtr));
#endif
}
else
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintResult(Result);
#endif
}
}
#if VULKAN_USE_CREATE_ANDROID_SURFACE
void FWrapLayer::CreateAndroidSurfaceKHR(VkResult Result, VkInstance Instance, const VkAndroidSurfaceCreateInfoKHR* CreateInfo, VkSurfaceKHR* Surface)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBeginResult(FString::Printf(TEXT("vkCreateAndroidSurfaceKHR(Instance=0x%p, CreateInfo=0x%p, Surface=0x%p)[...]"), Instance, CreateInfo, Surface));
#endif
}
else
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintResult(Result);
#endif
}
}
#endif
#if VULKAN_USE_CREATE_WIN32_SURFACE
void FWrapLayer::CreateWin32SurfaceKHR(VkResult Result, VkInstance Instance, const VkWin32SurfaceCreateInfoKHR* CreateInfo, VkSurfaceKHR* Surface)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBeginResult(FString::Printf(TEXT("vkCreateWin32SurfaceKHR(Instance=0x%p, CreateInfo=0x%p, Surface=0x%p)[...]"), Instance, CreateInfo, Surface));
#endif
}
else
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintResult(Result);
#endif
}
}
#endif
void FWrapLayer::CreateAccelerationStructureKHR(VkResult Result, VkDevice Device, const VkAccelerationStructureCreateInfoKHR* CreateInfo, const VkAllocationCallbacks* Allocator, VkAccelerationStructureKHR* AccelerationStructure)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBeginResult(FString::Printf(TEXT("vkCreateAccelerationStructureKHR(Device=0x%p, CreateInfo=0x%p, AccelerationStructure=0x%p)[...]"), Device, CreateInfo, AccelerationStructure));
#endif
}
else
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintResult(Result);
#endif
}
}
void FWrapLayer::DestroyAccelerationStructureKHR(VkResult Result, VkDevice Device, VkAccelerationStructureKHR AccelerationStructure, const VkAllocationCallbacks* Allocator)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBeginResult(FString::Printf(TEXT("vkDestroyAccelerationStructureKHR(Device=0x%p, AccelerationStructure=0x%p)[...]"), Device, AccelerationStructure));
#endif
}
else
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintResult(Result);
#endif
}
}
void FWrapLayer::CmdBuildAccelerationStructuresKHR(VkResult Result, VkCommandBuffer CommandBuffer, uint32 InfoCount, const VkAccelerationStructureBuildGeometryInfoKHR* Infos, const VkAccelerationStructureBuildRangeInfoKHR* const* BuildRangeInfos)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBeginResult(FString::Printf(TEXT("vkCmdBuildAccelerationStructuresKHR")));
#endif
}
else
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintResult(Result);
#endif
}
}
void FWrapLayer::GetAccelerationStructureBuildSizesKHR(VkResult Result, VkDevice Device, VkAccelerationStructureBuildTypeKHR BuildType, const VkAccelerationStructureBuildGeometryInfoKHR* BuildInfo, const uint32* MaxPrimitiveCounts, VkAccelerationStructureBuildSizesInfoKHR* SizeInfo)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBeginResult(FString::Printf(TEXT("vkGetAccelerationStructureBuildSizesKHR")));
#endif
}
else
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintResult(Result);
#endif
}
}
void FWrapLayer::GetAccelerationStructureDeviceAddressKHR(VkResult Result, VkDevice Device, const VkAccelerationStructureDeviceAddressInfoKHR* Info)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBeginResult(FString::Printf(TEXT("vkGetAccelerationStructureDeviceAddressKHR")));
#endif
}
else
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintResult(Result);
#endif
}
}
void FWrapLayer::CmdTraceRaysKHR(VkResult Result, VkCommandBuffer CommandBuffer, const VkStridedDeviceAddressRegionKHR* RaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* MissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* HitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* CallableShaderBindingTable, uint32 width, uint32 height, uint32 depth)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBeginResult(FString::Printf(TEXT("vkCmdTraceRaysKHR")));
#endif
}
else
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintResult(Result);
#endif
}
}
void FWrapLayer::CmdTraceRaysIndirectKHR(VkResult Result, VkCommandBuffer CommandBuffer, const VkStridedDeviceAddressRegionKHR* RaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* MissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* HitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* CallableShaderBindingTable, VkDeviceAddress IndirectDeviceAddress)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBeginResult(FString::Printf(TEXT("vkCmdTraceRaysIndirectKHR")));
#endif
}
else
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintResult(Result);
#endif
}
}
void FWrapLayer::CmdTraceRaysIndirect2KHR(VkResult Result, VkDeviceAddress IndirectDeviceAddress)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBeginResult(FString::Printf(TEXT("vkCmdTraceRaysIndirect2KHR")));
#endif
}
else
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintResult(Result);
#endif
}
}
void FWrapLayer::CreateRayTracingPipelinesKHR(VkResult Result, VkDevice Device, VkDeferredOperationKHR DeferredOperation, VkPipelineCache PipelineCache, uint32_t CreateInfoCount, const VkRayTracingPipelineCreateInfoKHR* CreateInfos, const VkAllocationCallbacks* Allocator, VkPipeline* Pipelines)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBeginResult(FString::Printf(TEXT("vkCreateRayTracingPipelinesKHR")));
#endif
}
else
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintResult(Result);
#endif
}
}
void FWrapLayer::GetRayTracingShaderGroupHandlesKHR(VkResult Result, VkDevice Device, VkPipeline Pipeline, uint32_t FirstGroup, uint32_t GroupCount, size_t DataSize, void* Data)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBeginResult(FString::Printf(TEXT("vkGetRayTracingShaderGroupHandlesKHR")));
#endif
}
else
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintResult(Result);
#endif
}
}
void FWrapLayer::CmdWriteAccelerationStructuresPropertiesKHR(VkResult Result, VkCommandBuffer CommandBuffer, uint32_t AccelerationStructureCount, const VkAccelerationStructureKHR* AccelerationStructures, VkQueryType QueryType, VkQueryPool QueryPool, uint32_t FirstQuery)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBeginResult(FString::Printf(TEXT("vkCmdWriteAccelerationStructuresPropertiesKHR")));
#endif
}
else
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintResult(Result);
#endif
}
}
void FWrapLayer::CmdCopyAccelerationStructureKHR(VkResult Result, VkCommandBuffer CommandBuffer, const VkCopyAccelerationStructureInfoKHR* Info)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBeginResult(FString::Printf(TEXT("vkCmdCopyAccelerationStructureKHR")));
#endif
}
else
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintResult(Result);
#endif
}
}
void FWrapLayer::GetBufferDeviceAddressKHR(VkResult Result, VkDevice Device, const VkBufferDeviceAddressInfo* Info)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBeginResult(FString::Printf(TEXT("vkGetBufferDeviceAddressKHR(Device=0x%p, Buffer=0x%p)"), Device, Info->buffer));
#endif
}
else
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintResult(Result);
#endif
}
}
void FWrapLayer::GetDeviceImageMemoryRequirementsKHR(VkResult Result, VkDevice Device, const VkDeviceImageMemoryRequirements* Info, VkMemoryRequirements2* MemoryRequirements)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBeginResult(FString::Printf(TEXT("vkGetDeviceImageMemoryRequirementsKHR")));
#endif
}
}
void FWrapLayer::GetDeviceBufferMemoryRequirementsKHR(VkResult Result, VkDevice Device, const VkDeviceBufferMemoryRequirements* Info, VkMemoryRequirements2* MemoryRequirements)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBeginResult(FString::Printf(TEXT("vkGetDeviceBufferMemoryRequirementsKHR")));
#endif
}
}
void FWrapLayer::ResetQueryPoolEXT(VkResult Result, VkDevice Device, VkQueryPool QueryPool, uint32_t FirstQuery, uint32_t QueryCount)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBeginResult(FString::Printf(TEXT("ResetQueryPoolEXT(Device=0x%p, QueryPool=0x%p, FirstQuery=%u, QueryCount=%u)"), Device, QueryPool, FirstQuery, QueryCount));
#endif
}
}
void FWrapLayer::GetPhysicalDeviceCalibrateableTimeDomainsEXT(VkResult Result, VkPhysicalDevice PhysicalDevice, uint32_t* TimeDomainCount, VkTimeDomainEXT* TimeDomains)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBeginResult(FString::Printf(TEXT("PhysicalDeviceCalibrateableTimeDomainsEXT(PhysicalDevice=0x%p, TimeDomains=0x%p)"), PhysicalDevice, TimeDomains));
#endif
}
}
void FWrapLayer::GetCalibratedTimestampsEXT(VkResult Result, VkDevice Device, uint32_t TimestampCount, const VkCalibratedTimestampInfoEXT* TimestampInfos, uint64_t* Timestamps, uint64_t* MaxDeviation)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBeginResult(FString::Printf(TEXT("GetCalibratedTimestampsEXT(Device=0x%p, TimestampCount=%u)"), Device, TimestampCount));
#endif
}
}
void FWrapLayer::BindBufferMemory2(VkResult Result, VkDevice Device, uint32_t BindInfoCount, const VkBindBufferMemoryInfo* BindInfos)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBeginResult(FString::Printf(TEXT("BindBufferMemory2(Device=0x%p, BindInfoCount=%u)"), Device, BindInfoCount));
#endif
}
}
void FWrapLayer::BindImageMemory2(VkResult Result, VkDevice Device, uint32_t BindInfoCount, const VkBindImageMemoryInfo* BindInfos)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBeginResult(FString::Printf(TEXT("BindImageMemory2(Device=0x%p, BindInfoCount=%u)"), Device, BindInfoCount));
#endif
}
}
void FWrapLayer::GetDescriptorSetLayoutSizeEXT(VkResult Result, VkDevice Device, VkDescriptorSetLayout Layout, VkDeviceSize* OutLayoutSizeInBytes)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBeginResult(FString::Printf(TEXT("GetDescriptorSetLayoutSizeEXT(Device=0x%p, Layout=0x%p)"), Device, Layout));
#endif
}
}
void FWrapLayer::GetDescriptorSetLayoutBindingOffsetEXT(VkResult Result, VkDevice Device, VkDescriptorSetLayout Layout, uint32_t Binding, VkDeviceSize* Offset)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBeginResult(FString::Printf(TEXT("GetDescriptorSetLayoutBindingOffsetEXT(Device=0x%p, Layout=0x%p)"), Device, Layout));
#endif
}
}
void FWrapLayer::CmdBindDescriptorBuffersEXT(VkResult Result, VkCommandBuffer CommandBuffer, uint32_t BufferCount, const VkDescriptorBufferBindingInfoEXT* BindingInfos)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBeginResult(FString::Printf(TEXT("CmdBindDescriptorBuffersEXT(CommandBuffer=0x%p, BufferCount=%u)"), CommandBuffer, BufferCount));
for (uint32_t Index = 0; Index < BufferCount; ++Index)
{
DebugLog += FString::Printf(TEXT("%s%d - Address=0x%p Usage=0x%X\n"), Tabs, Index, BindingInfos[Index].address, BindingInfos[Index].usage);
}
#endif
}
}
void FWrapLayer::CmdSetDescriptorBufferOffsetsEXT(VkResult Result, VkCommandBuffer CommandBuffer, VkPipelineBindPoint PipelineBindPoint, VkPipelineLayout Layout, uint32_t FirstSet, uint32_t SetCount, const uint32_t* BufferIndices, const VkDeviceSize* Offsets)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBeginResult(FString::Printf(TEXT("CmdSetDescriptorBufferOffsetsEXT(CommandBuffer=0x%p, BindPoint=%s, PipelineLayout=0x%p, FirstSet=%u, SetCount=%u)"),
CommandBuffer, VK_TYPE_TO_STRING(VkPipelineBindPoint, PipelineBindPoint), Layout, FirstSet, SetCount));
for (uint32_t Index = 0; Index < SetCount; ++Index)
{
DebugLog += FString::Printf(TEXT("%sSet %u - BufferIndex=%u Offset=%llu\n"), Tabs, FirstSet + Index, BufferIndices[Index], Offsets[Index]);
}
#endif
}
}
void FWrapLayer::GetDescriptorEXT(VkResult Result, VkDevice Device, const VkDescriptorGetInfoEXT* DescriptorInfo, size_t DataSize, void* Descriptor)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBeginResult(FString::Printf(TEXT("GetDescriptorEXT(Device=0x%p, DataSize=%llu DescriptorType=%s)"), Device, DataSize, VK_TYPE_TO_STRING(VkDescriptorType, DescriptorInfo->type)));
#endif
}
}
void FWrapLayer::CreateDeferredOperationKHR(VkResult Result, VkDevice Device, const VkAllocationCallbacks* Allocator, VkDeferredOperationKHR* DeferredOperation)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBeginResult(FString::Printf(TEXT("CreateDeferredOperationKHR(Device=0x%p, DeferredOperation=0x%p)"), Device, DeferredOperation));
#endif
}
}
void FWrapLayer::DestroyDeferredOperationKHR(VkResult Result, VkDevice Device, VkDeferredOperationKHR DeferredOperation, const VkAllocationCallbacks* Allocator)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBeginResult(FString::Printf(TEXT("DestroyDeferredOperationKHR(Device=0x%p, DeferredOperation=0x%p)"), Device, DeferredOperation));
#endif
}
}
void FWrapLayer::DeferredOperationJoinKHR(VkResult Result, VkDevice Device, VkDeferredOperationKHR DeferredOperation)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBeginResult(FString::Printf(TEXT("DeferredOperationJoinKHR(Device=0x%p, DeferredOperation=0x%p)"), Device, DeferredOperation));
#endif
}
}
void FWrapLayer::GetDeferredOperationMaxConcurrencyKHR(VkResult Result, VkDevice Device, VkDeferredOperationKHR DeferredOperation)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBeginResult(FString::Printf(TEXT("GetDeferredOperationMaxConcurrencyKHR(Device=0x%p, DeferredOperation=0x%p)"), Device, DeferredOperation));
#endif
}
}
void FWrapLayer::GetDeferredOperationResultKHR(VkResult Result, VkDevice Device, VkDeferredOperationKHR DeferredOperation)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBeginResult(FString::Printf(TEXT("GetDeferredOperationResultKHR(Device=0x%p, DeferredOperation=0x%p)"), Device, DeferredOperation));
#endif
}
}
void FWrapLayer::GetDeviceFaultInfoEXT(VkResult Result, VkDevice Device, VkDeviceFaultCountsEXT* FaultCounts, VkDeviceFaultInfoEXT* FaultInfo)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBeginResult(FString::Printf(TEXT("GetDeviceFaultInfoEXT(Device=0x%p)"), Device));
#endif
}
}
void FWrapLayer::CmdPipelineBarrier2KHR(VkResult Result, VkCommandBuffer CommandBuffer, const VkDependencyInfo* DependencyInfo)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
CmdPrintfBegin(CommandBuffer, FString::Printf(TEXT("vkCmdPipelineBarrier2(CommandBuffer=0x%p, Flags=%d, NumMemB=%d, MemB=0x%p,"), CommandBuffer, (uint32)DependencyInfo->dependencyFlags, DependencyInfo->memoryBarrierCount, DependencyInfo->pMemoryBarriers));
DebugLog += FString::Printf(TEXT("%s\tNumBufferB=%d, BufferB=0x%p, NumImageB=%d, ImageB=0x%p)[...]\n"), Tabs, DependencyInfo->bufferMemoryBarrierCount, DependencyInfo->pBufferMemoryBarriers, DependencyInfo->imageMemoryBarrierCount, DependencyInfo->pImageMemoryBarriers);
DumpImageMemoryBarriers(DependencyInfo->imageMemoryBarrierCount, DependencyInfo->pImageMemoryBarriers);
FlushDebugWrapperLog();
#endif
#if VULKAN_ENABLE_IMAGE_TRACKING_LAYER
{
FScopeLock ScopeLock(&GTrackingCS);
for (uint32 Index = 0; Index < DependencyInfo->imageMemoryBarrierCount; ++Index)
{
const VkImageMemoryBarrier2& ImageBarrier = DependencyInfo->pImageMemoryBarriers[Index];
BreakOnTrackingImage(ImageBarrier.image);
if (DumpTrackImage(ImageBarrier.image))
{
CmdPrintfBegin(CommandBuffer, FString::Printf(TEXT("vkCmdPipelineBarrier2(Flags=%d, NumMemB=%d, MemB=0x%p,"), (uint32)DependencyInfo->dependencyFlags, DependencyInfo->memoryBarrierCount, DependencyInfo->pMemoryBarriers));
DebugLog += FString::Printf(TEXT("%s\tNumBufferB=%d, BufferB=0x%p, NumImageB=%d, ImageB=0x%p)[...]\n"), Tabs, DependencyInfo->bufferMemoryBarrierCount, DependencyInfo->pBufferMemoryBarriers, DependencyInfo->imageMemoryBarrierCount, DependencyInfo->pImageMemoryBarriers);
DumpImageMemoryBarriers(DependencyInfo->imageMemoryBarrierCount, DependencyInfo->pImageMemoryBarriers);
FlushDebugWrapperLog();
}
FTrackingImage* TrackingImage = GVulkanTrackingImageLayouts.Find(ImageBarrier.image);
check(TrackingImage);
#if VULKAN_ENABLE_TRACKING_CALLSTACK
FTrackingImage::FHistoryEntry* HistoryEntry = new (TrackingImage->History) FTrackingImage::FHistoryEntry;
HistoryEntry->ArrayLayouts = TrackingImage->ArrayLayouts;
#endif
const VkImageSubresourceRange& Range = ImageBarrier.subresourceRange;
uint32 NumLayers = (Range.layerCount == VK_REMAINING_ARRAY_LAYERS) ? (TrackingImage->Info.CreateInfo.arrayLayers - Range.baseArrayLayer) : Range.layerCount;
for (uint32 LIndex = Range.baseArrayLayer; LIndex < Range.baseArrayLayer + NumLayers; ++LIndex)
{
TArray<VkImageLayout>& MipLayouts = TrackingImage->ArrayLayouts[LIndex];
uint32 NumLevels = (Range.levelCount == VK_REMAINING_MIP_LEVELS) ? (TrackingImage->Info.CreateInfo.mipLevels - Range.baseMipLevel) : Range.levelCount;
for (uint32 MIndex = Range.baseMipLevel; MIndex < Range.baseMipLevel + NumLevels; ++MIndex)
{
if (ImageBarrier.oldLayout != VK_IMAGE_LAYOUT_UNDEFINED && MipLayouts[MIndex] != ImageBarrier.oldLayout)
{
ensure(0);
}
MipLayouts[MIndex] = ImageBarrier.newLayout;
}
}
#if VULKAN_ENABLE_TRACKING_CALLSTACK
CaptureCallStack(HistoryEntry->Callstack, 2);
#endif
}
}
#endif
}
}
void FWrapLayer::CmdResetEvent2KHR(VkResult Result, VkCommandBuffer CommandBuffer, VkEvent Event, VkPipelineStageFlags2 StageMask)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBeginResult(FString::Printf(TEXT("CmdResetEvent2KHR(CommandBuffer=0x%p, Event=0x%p, StageMask=0xllx)"), CommandBuffer, Event, StageMask));
#endif
}
}
void FWrapLayer::CmdSetEvent2KHR(VkResult Result, VkCommandBuffer CommandBuffer, VkEvent Event, const VkDependencyInfo* DependencyInfo)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBeginResult(FString::Printf(TEXT("CmdSetEvent2KHR(CommandBuffer=0x%p, Event=0x%p)"), CommandBuffer, Event));
#endif
}
}
void FWrapLayer::CmdWaitEvents2KHR(VkResult Result, VkCommandBuffer CommandBuffer, uint32_t EventCount, const VkEvent* Events, const VkDependencyInfo* DependencyInfos)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBeginResult(FString::Printf(TEXT("CmdWaitEvents2KHR(CommandBuffer=0x%p, EventCount=%u, Events=0x%p)"), CommandBuffer, EventCount, Events));
#endif
}
}
void FWrapLayer::QueueSubmit2KHR(VkResult Result, VkQueue Queue, uint32_t SubmitCount, const VkSubmitInfo2* Submits, VkFence Fence)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBeginResult(FString::Printf(TEXT("QueueSubmit2KHR(Queue=0x%p, SubmitCount=%u, Submits=0x%p, Fence=0x%p)"), Queue, SubmitCount, Submits, Fence));
#endif
}
}
void FWrapLayer::CreateSamplerYcbcrConversion(VkResult Result, VkDevice Device, const VkSamplerYcbcrConversionCreateInfo* CreateInfo, const VkAllocationCallbacks* Allocator, VkSamplerYcbcrConversion* YcbcrConversion)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBeginResult(FString::Printf(TEXT("CreateSamplerYcbcrConversion(Device=0x%p, CreateInfo=0x%p, Allocator=0x%p, YcbcrConversion=0x%p))"), Device, CreateInfo, Allocator, YcbcrConversion));
#endif
}
}
void FWrapLayer::DestroySamplerYcbcrConversion(VkResult Result, VkDevice Device, VkSamplerYcbcrConversion YcbcrConversion, const VkAllocationCallbacks* Allocator)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBeginResult(FString::Printf(TEXT("DestroySamplerYcbcrConversion(Device=0x%p, YcbcrConversion=0x%p, Allocator=0x%p))"), Device, YcbcrConversion, Allocator));
#endif
}
}
#if PLATFORM_ANDROID
void FWrapLayer::GetAndroidHardwareBufferPropertiesANDROID(VkResult Result, VkDevice Device, const struct AHardwareBuffer* Buffer, VkAndroidHardwareBufferPropertiesANDROID* Properties)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBeginResult(FString::Printf(TEXT("GetAndroidHardwareBufferPropertiesANDROID(Device=0x%p, Buffer=0x%p, Properties=0x%p))"), Device, Buffer, Properties));
#endif
}
}
#endif
void FWrapLayer::GetSemaphoreCounterValueKHR(VkResult Result, VkDevice Device, VkSemaphore Semaphore, uint64_t* Value)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBeginResult(FString::Printf(TEXT("GetSemaphoreCounterValueKHR(Device=0x%p, Semaphore=0x%p, Value=0x%p))"), Device, Semaphore, Value));
#endif
}
}
void FWrapLayer::WaitSemaphoresKHR(VkResult Result, VkDevice Device, const VkSemaphoreWaitInfo* WaitInfo, uint64_t Timeout)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBeginResult(FString::Printf(TEXT("WaitSemaphoresKHR(Device=0x%p, WaitInfo=0x%p, Timeout=0xllx))"), Device, WaitInfo, Timeout));
#endif
}
}
void FWrapLayer::SignalSemaphoreKHR(VkResult Result, VkDevice Device, const VkSemaphoreSignalInfo* SignalInfo)
{
if (Result == VK_RESULT_MAX_ENUM)
{
#if VULKAN_ENABLE_DUMP_LAYER
PrintfBeginResult(FString::Printf(TEXT("SignalSemaphoreKHR(Device=0x%p, SignalInfo=0x%p))"), Device, SignalInfo));
#endif
}
}
#if VULKAN_ENABLE_IMAGE_TRACKING_LAYER
namespace VulkanRHI
{
void BindDebugLabelName(VkImage Image, const TCHAR* Name)
{
if(Image == VK_NULL_HANDLE)
{
return;
}
FScopeLock ScopeLock(&GTrackingCS);
FTrackingImage* Found = GVulkanTrackingImageLayouts.Find(Image);
if (Found)
{
Found->Info.DebugName = Name ? Name : TEXT("null");
}
else
{
ensure(0);
}
}
}
#endif
#endif // VULKAN_ENABLE_WRAP_LAYER
#if VULKAN_ENABLE_DUMP_LAYER
namespace VulkanRHI
{
static struct FGlobalDumpLog
{
~FGlobalDumpLog()
{
FlushDebugWrapperLog();
}
} GGlobalDumpLogInstance;
static TArray<FString> GMarkers;
void DumpLayerPushMarker(const TCHAR* InName)
{
FString String = TEXT("***** vkCmdDbgMarkerBeginEXT: ");
for (auto& Name : GMarkers)
{
String += Name;
String += TEXT("/");
}
GMarkers.Push(InName);
String += InName;
String += TEXT("\n");
DebugLog += String;
FlushDebugWrapperLog();
}
void DumpLayerPopMarker()
{
FString String = TEXT("***** vkCmdDbgMarkerEndEXT: ");
GMarkers.Pop();
for (auto& Name : GMarkers)
{
String += Name;
String += TEXT("/");
}
String += TEXT("\n");
DebugLog += String;
FlushDebugWrapperLog();
}
}
#endif // VULKAN_ENABLE_DUMP_LAYER
#undef VULKAN_REPORT_LOG
#endif // VULKAN_HAS_DEBUGGING_ENABLED
Reference in New Issue View Git Blame Copy Permalink