text: //
  // 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
  