// | |
// Copyright (c) 2017-2021 Advanced Micro Devices, Inc. All rights reserved. | |
// | |
// Permission is hereby granted, free of charge, to any person obtaining a copy | |
// of this software and associated documentation files (the "Software"), to deal | |
// in the Software without restriction, including without limitation the rights | |
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |
// copies of the Software, and to permit persons to whom the Software is | |
// furnished to do so, subject to the following conditions: | |
// | |
// The above copyright notice and this permission notice shall be included in | |
// all copies or substantial portions of the Software. | |
// | |
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | |
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | |
// THE SOFTWARE. | |
// | |
#include "Common.h" | |
#ifdef _WIN32 | |
void ReadFile(std::vector<char>& out, const char* fileName) | |
{ | |
std::ifstream file(fileName, std::ios::ate | std::ios::binary); | |
assert(file.is_open()); | |
size_t fileSize = (size_t)file.tellg(); | |
if(fileSize > 0) | |
{ | |
out.resize(fileSize); | |
file.seekg(0); | |
file.read(out.data(), fileSize); | |
} | |
else | |
out.clear(); | |
} | |
void SetConsoleColor(CONSOLE_COLOR color) | |
{ | |
WORD attr = 0; | |
switch(color) | |
{ | |
case CONSOLE_COLOR::INFO: | |
attr = FOREGROUND_INTENSITY; | |
break; | |
case CONSOLE_COLOR::NORMAL: | |
attr = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE; | |
break; | |
case CONSOLE_COLOR::WARNING: | |
attr = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_INTENSITY; | |
break; | |
case CONSOLE_COLOR::ERROR_: | |
attr = FOREGROUND_RED | FOREGROUND_INTENSITY; | |
break; | |
default: | |
assert(0); | |
} | |
HANDLE out = GetStdHandle(STD_OUTPUT_HANDLE); | |
SetConsoleTextAttribute(out, attr); | |
} | |
void PrintMessage(CONSOLE_COLOR color, const char* msg) | |
{ | |
if(color != CONSOLE_COLOR::NORMAL) | |
SetConsoleColor(color); | |
printf("%s\n", msg); | |
if (color != CONSOLE_COLOR::NORMAL) | |
SetConsoleColor(CONSOLE_COLOR::NORMAL); | |
} | |
void PrintMessage(CONSOLE_COLOR color, const wchar_t* msg) | |
{ | |
if(color != CONSOLE_COLOR::NORMAL) | |
SetConsoleColor(color); | |
wprintf(L"%s\n", msg); | |
if (color != CONSOLE_COLOR::NORMAL) | |
SetConsoleColor(CONSOLE_COLOR::NORMAL); | |
} | |
static const size_t CONSOLE_SMALL_BUF_SIZE = 256; | |
void PrintMessageV(CONSOLE_COLOR color, const char* format, va_list argList) | |
{ | |
size_t dstLen = (size_t)::_vscprintf(format, argList); | |
if(dstLen) | |
{ | |
bool useSmallBuf = dstLen < CONSOLE_SMALL_BUF_SIZE; | |
char smallBuf[CONSOLE_SMALL_BUF_SIZE]; | |
std::vector<char> bigBuf(useSmallBuf ? 0 : dstLen + 1); | |
char* bufPtr = useSmallBuf ? smallBuf : bigBuf.data(); | |
::vsprintf_s(bufPtr, dstLen + 1, format, argList); | |
PrintMessage(color, bufPtr); | |
} | |
} | |
void PrintMessageV(CONSOLE_COLOR color, const wchar_t* format, va_list argList) | |
{ | |
size_t dstLen = (size_t)::_vcwprintf(format, argList); | |
if(dstLen) | |
{ | |
bool useSmallBuf = dstLen < CONSOLE_SMALL_BUF_SIZE; | |
wchar_t smallBuf[CONSOLE_SMALL_BUF_SIZE]; | |
std::vector<wchar_t> bigBuf(useSmallBuf ? 0 : dstLen + 1); | |
wchar_t* bufPtr = useSmallBuf ? smallBuf : bigBuf.data(); | |
::vswprintf_s(bufPtr, dstLen + 1, format, argList); | |
PrintMessage(color, bufPtr); | |
} | |
} | |
void PrintMessageF(CONSOLE_COLOR color, const char* format, ...) | |
{ | |
va_list argList; | |
va_start(argList, format); | |
PrintMessageV(color, format, argList); | |
va_end(argList); | |
} | |
void PrintMessageF(CONSOLE_COLOR color, const wchar_t* format, ...) | |
{ | |
va_list argList; | |
va_start(argList, format); | |
PrintMessageV(color, format, argList); | |
va_end(argList); | |
} | |
void PrintWarningF(const char* format, ...) | |
{ | |
va_list argList; | |
va_start(argList, format); | |
PrintMessageV(CONSOLE_COLOR::WARNING, format, argList); | |
va_end(argList); | |
} | |
void PrintWarningF(const wchar_t* format, ...) | |
{ | |
va_list argList; | |
va_start(argList, format); | |
PrintMessageV(CONSOLE_COLOR::WARNING, format, argList); | |
va_end(argList); | |
} | |
void PrintErrorF(const char* format, ...) | |
{ | |
va_list argList; | |
va_start(argList, format); | |
PrintMessageV(CONSOLE_COLOR::WARNING, format, argList); | |
va_end(argList); | |
} | |
void PrintErrorF(const wchar_t* format, ...) | |
{ | |
va_list argList; | |
va_start(argList, format); | |
PrintMessageV(CONSOLE_COLOR::WARNING, format, argList); | |
va_end(argList); | |
} | |
void SaveFile(const wchar_t* filePath, const void* data, size_t dataSize) | |
{ | |
FILE* f = nullptr; | |
_wfopen_s(&f, filePath, L"wb"); | |
if(f) | |
{ | |
fwrite(data, 1, dataSize, f); | |
fclose(f); | |
} | |
else | |
assert(0); | |
} | |
std::wstring SizeToStr(size_t size) | |
{ | |
if(size == 0) | |
return L"0"; | |
wchar_t result[32]; | |
double size2 = (double)size; | |
if (size2 >= 1024.0*1024.0*1024.0*1024.0) | |
{ | |
swprintf_s(result, L"%.2f TB", size2 / (1024.0*1024.0*1024.0*1024.0)); | |
} | |
else if (size2 >= 1024.0*1024.0*1024.0) | |
{ | |
swprintf_s(result, L"%.2f GB", size2 / (1024.0*1024.0*1024.0)); | |
} | |
else if (size2 >= 1024.0*1024.0) | |
{ | |
swprintf_s(result, L"%.2f MB", size2 / (1024.0*1024.0)); | |
} | |
else if (size2 >= 1024.0) | |
{ | |
swprintf_s(result, L"%.2f KB", size2 / 1024.0); | |
} | |
else | |
swprintf_s(result, L"%llu B", size); | |
return result; | |
} | |
bool ConvertCharsToUnicode(std::wstring *outStr, const std::string &s, unsigned codePage) | |
{ | |
if (s.empty()) | |
{ | |
outStr->clear(); | |
return true; | |
} | |
// Phase 1 - Get buffer size. | |
const int size = MultiByteToWideChar(codePage, 0, s.data(), (int)s.length(), NULL, 0); | |
if (size == 0) | |
{ | |
outStr->clear(); | |
return false; | |
} | |
// Phase 2 - Do conversion. | |
std::unique_ptr<wchar_t[]> buf(new wchar_t[(size_t)size]); | |
int result = MultiByteToWideChar(codePage, 0, s.data(), (int)s.length(), buf.get(), size); | |
if (result == 0) | |
{ | |
outStr->clear(); | |
return false; | |
} | |
outStr->assign(buf.get(), (size_t)size); | |
return true; | |
} | |
bool ConvertCharsToUnicode(std::wstring *outStr, const char *s, size_t sCharCount, unsigned codePage) | |
{ | |
if (sCharCount == 0) | |
{ | |
outStr->clear(); | |
return true; | |
} | |
assert(sCharCount <= (size_t)INT_MAX); | |
// Phase 1 - Get buffer size. | |
int size = MultiByteToWideChar(codePage, 0, s, (int)sCharCount, NULL, 0); | |
if (size == 0) | |
{ | |
outStr->clear(); | |
return false; | |
} | |
// Phase 2 - Do conversion. | |
std::unique_ptr<wchar_t[]> buf(new wchar_t[(size_t)size]); | |
int result = MultiByteToWideChar(codePage, 0, s, (int)sCharCount, buf.get(), size); | |
if (result == 0) | |
{ | |
outStr->clear(); | |
return false; | |
} | |
outStr->assign(buf.get(), (size_t)size); | |
return true; | |
} | |
const wchar_t* PhysicalDeviceTypeToStr(VkPhysicalDeviceType type) | |
{ | |
// Skipping common prefix VK_PHYSICAL_DEVICE_TYPE_ | |
static const wchar_t* const VALUES[] = { | |
L"OTHER", | |
L"INTEGRATED_GPU", | |
L"DISCRETE_GPU", | |
L"VIRTUAL_GPU", | |
L"CPU", | |
}; | |
return (uint32_t)type < _countof(VALUES) ? VALUES[(uint32_t)type] : L""; | |
} | |
const wchar_t* VendorIDToStr(uint32_t vendorID) | |
{ | |
switch(vendorID) | |
{ | |
// Skipping common prefix VK_VENDOR_ID_ for these: | |
case 0x10001: return L"VIV"; | |
case 0x10002: return L"VSI"; | |
case 0x10003: return L"KAZAN"; | |
case 0x10004: return L"CODEPLAY"; | |
case 0x10005: return L"MESA"; | |
case 0x10006: return L"POCL"; | |
// Others... | |
case VENDOR_ID_AMD: return L"AMD"; | |
case VENDOR_ID_NVIDIA: return L"NVIDIA"; | |
case VENDOR_ID_INTEL: return L"Intel"; | |
case 0x1010: return L"ImgTec"; | |
case 0x13B5: return L"ARM"; | |
case 0x5143: return L"Qualcomm"; | |
} | |
return L""; | |
} | |
#if VMA_VULKAN_VERSION >= 1002000 | |
const wchar_t* DriverIDToStr(VkDriverId driverID) | |
{ | |
// Skipping common prefix VK_DRIVER_ID_ | |
static const wchar_t* const VALUES[] = { | |
L"", | |
L"AMD_PROPRIETARY", | |
L"AMD_OPEN_SOURCE", | |
L"MESA_RADV", | |
L"NVIDIA_PROPRIETARY", | |
L"INTEL_PROPRIETARY_WINDOWS", | |
L"INTEL_OPEN_SOURCE_MESA", | |
L"IMAGINATION_PROPRIETARY", | |
L"QUALCOMM_PROPRIETARY", | |
L"ARM_PROPRIETARY", | |
L"GOOGLE_SWIFTSHADER", | |
L"GGP_PROPRIETARY", | |
L"BROADCOM_PROPRIETARY", | |
L"MESA_LLVMPIPE", | |
L"MOLTENVK", | |
}; | |
return (uint32_t)driverID < _countof(VALUES) ? VALUES[(uint32_t)driverID] : L""; | |
} | |
#endif // #if VMA_VULKAN_VERSION >= 1002000 | |
#endif // #ifdef _WIN32 |