Publishing testing environment. Tests are available under [T] key.

src/Common.cpp

@@ -2,4 +2,157 @@
 
 #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);
+}
+
 #endif // #ifdef _WIN32

src/Common.h

@@ -1,29 +1,105 @@
 #ifndef COMMON_H_
 #define COMMON_H_
 
+#include "VmaUsage.h"
+
 #ifdef _WIN32
 
 #define MATHFU_COMPILE_WITHOUT_SIMD_SUPPORT
 #include <mathfu/glsl_mappings.h>
 #include <mathfu/constants.h>
 
+#include <iostream>
 #include <fstream>
 #include <vector>
-#include <string>
 #include <memory>
 #include <algorithm>
 #include <numeric>
 #include <array>
 #include <type_traits>
 #include <utility>
+#include <chrono>
+#include <string>
 
-#include <cmath>
 #include <cassert>
 #include <cstdlib>
 #include <cstdio>
+#include <cstdarg>
+
+typedef std::chrono::high_resolution_clock::time_point time_point;
+typedef std::chrono::high_resolution_clock::duration duration;
 
 #define ERR_GUARD_VULKAN(Expr) do { VkResult res__ = (Expr); if (res__ < 0) assert(0); } while(0)
 
+extern VkPhysicalDevice g_hPhysicalDevice;
+extern VkDevice g_hDevice;
+extern VmaAllocator g_hAllocator;
+extern bool g_MemoryAliasingWarningEnabled;
+
+inline float ToFloatSeconds(duration d)
+{
+    return std::chrono::duration_cast<std::chrono::duration<float>>(d).count();
+}
+
+template <typename T>
+inline T ceil_div(T x, T y)
+{
+	return (x+y-1) / y;
+}
+
+template <typename T>
+static inline T align_up(T val, T align)
+{
+	return (val + align - 1) / align * align;
+}
+
+class RandomNumberGenerator
+{
+public:
+    RandomNumberGenerator() : m_Value{GetTickCount()} {}
+    RandomNumberGenerator(uint32_t seed) : m_Value{seed} { }
+    void Seed(uint32_t seed) { m_Value = seed; }
+    uint32_t Generate() { return GenerateFast() ^ (GenerateFast() >> 7); }
+
+private:
+    uint32_t m_Value;
+    uint32_t GenerateFast() { return m_Value = (m_Value * 196314165 + 907633515); }
+};
+
+void ReadFile(std::vector<char>& out, const char* fileName);
+
+enum class CONSOLE_COLOR
+{
+    INFO,
+    NORMAL,
+    WARNING,
+    ERROR_,
+    COUNT
+};
+
+void SetConsoleColor(CONSOLE_COLOR color);
+
+void PrintMessage(CONSOLE_COLOR color, const char* msg);
+void PrintMessage(CONSOLE_COLOR color, const wchar_t* msg);
+
+inline void Print(const char* msg) { PrintMessage(CONSOLE_COLOR::NORMAL, msg); }
+inline void Print(const wchar_t* msg) { PrintMessage(CONSOLE_COLOR::NORMAL, msg); }
+inline void PrintWarning(const char* msg) { PrintMessage(CONSOLE_COLOR::WARNING, msg); }
+inline void PrintWarning(const wchar_t* msg) { PrintMessage(CONSOLE_COLOR::WARNING, msg); }
+inline void PrintError(const char* msg) { PrintMessage(CONSOLE_COLOR::ERROR_, msg); }
+inline void PrintError(const wchar_t* msg) { PrintMessage(CONSOLE_COLOR::ERROR_, msg); }
+
+void PrintMessageV(CONSOLE_COLOR color, const char* format, va_list argList);
+void PrintMessageV(CONSOLE_COLOR color, const wchar_t* format, va_list argList);
+void PrintMessageF(CONSOLE_COLOR color, const char* format, ...);
+void PrintMessageF(CONSOLE_COLOR color, const wchar_t* format, ...);
+void PrintWarningF(const char* format, ...);
+void PrintWarningF(const wchar_t* format, ...);
+void PrintErrorF(const char* format, ...);
+void PrintErrorF(const wchar_t* format, ...);
+
+void SaveFile(const wchar_t* filePath, const void* data, size_t dataSize);
+
 #endif // #ifdef _WIN32
 
 #endif

src/Tests.h

@@ -3,6 +3,7 @@
 
 #ifdef _WIN32
 
+void Test();
 
 #endif // #ifdef _WIN32
 

src/VulkanSample.cpp

@@ -38,12 +38,16 @@ static const uint32_t COMMAND_BUFFER_COUNT = 2;
 
 static bool g_EnableValidationLayer = true;
 
+VkPhysicalDevice g_hPhysicalDevice;
+VkDevice g_hDevice;
+VmaAllocator g_hAllocator;
+bool g_MemoryAliasingWarningEnabled = true;
+
 static HINSTANCE g_hAppInstance;
 static HWND g_hWnd;
 static LONG g_SizeX = 1280, g_SizeY = 720;
 static VkInstance g_hVulkanInstance;
 static VkSurfaceKHR g_hSurface;
-static VkPhysicalDevice g_hPhysicalDevice;
 static VkQueue g_hPresentQueue;
 static VkSurfaceFormatKHR g_SurfaceFormat;
 static VkExtent2D g_Extent;
@@ -77,8 +81,6 @@ static PFN_vkDebugReportMessageEXT g_pvkDebugReportMessageEXT;
 static PFN_vkDestroyDebugReportCallbackEXT g_pvkDestroyDebugReportCallbackEXT;
 static VkDebugReportCallbackEXT g_hCallback;
 
-static VkDevice g_hDevice;
-static VmaAllocator g_hAllocator;
 static VkQueue g_hGraphicsQueue;
 static VkCommandBuffer g_hTemporaryCommandBuffer;
 
@@ -144,10 +146,43 @@ VKAPI_ATTR VkBool32 VKAPI_CALL MyDebugReportCallback(
     const char* pMessage,
     void* pUserData)
 {
+    // "Non-linear image 0xebc91 is aliased with linear buffer 0xeb8e4 which may indicate a bug."
+    if(!g_MemoryAliasingWarningEnabled && flags == VK_DEBUG_REPORT_WARNING_BIT_EXT &&
+        (strstr(pMessage, " is aliased with non-linear ") || strstr(pMessage, " is aliased with linear ")))
+    {
+        return VK_FALSE;
+    }
+
+    // Ignoring because when VK_KHR_dedicated_allocation extension is enabled,
+    // vkGetBufferMemoryRequirements2KHR function is used instead, while Validation
+    // Layer seems to be unaware of it.
+    if (strstr(pMessage, "but vkGetBufferMemoryRequirements() has not been called on that buffer") != nullptr)
+    {
+        return VK_FALSE;
+    }
+    if (strstr(pMessage, "but vkGetImageMemoryRequirements() has not been called on that image") != nullptr)
+    {
+        return VK_FALSE;
+    }
+    
+    switch(flags)
+    {
+    case VK_DEBUG_REPORT_WARNING_BIT_EXT:
+        SetConsoleColor(CONSOLE_COLOR::WARNING);
+        break;
+    case VK_DEBUG_REPORT_ERROR_BIT_EXT:
+        SetConsoleColor(CONSOLE_COLOR::ERROR_);
+        break;
+    default:
+        SetConsoleColor(CONSOLE_COLOR::INFO);
+    }
+
     printf("%s \xBA %s\n", pLayerPrefix, pMessage);
 
-    if((flags == VK_DEBUG_REPORT_WARNING_BIT_EXT) ||
+    SetConsoleColor(CONSOLE_COLOR::NORMAL);
-        (flags == VK_DEBUG_REPORT_ERROR_BIT_EXT))
+
+    if(flags == VK_DEBUG_REPORT_WARNING_BIT_EXT ||
+        flags == VK_DEBUG_REPORT_ERROR_BIT_EXT)
     {
         OutputDebugStringA(pMessage);
         OutputDebugStringA("\n");
@@ -1602,8 +1637,15 @@ static LRESULT WINAPI WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
         return 0;
 
     case WM_KEYDOWN:
-        if(wParam == VK_ESCAPE)
+        switch(wParam)
+        {
+        case VK_ESCAPE:
             PostMessage(hWnd, WM_CLOSE, 0, 0);
+            break;
+        case 'T':
+            Test();
+            break;
+        }
         return 0;
 
     default: