| // |
| // Copyright (c) 2017-2022 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 |