Add files using upload-large-folder tool

third_party/ktx-src/tests/loadtests/appfwSDL/AppBaseSDL.cpp

@@ -0,0 +1,138 @@
+/* -*- tab-width: 4; -*- */
+/* vi: set sw=2 ts=4 expandtab: */
+
+/* $Id: f63e0a9e6eed51ed84a8eea1eff0708c8a6af22b $ */
+
+/*
+ * Copyright 2015-2020 Mark Callow.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @internal
+ * @file
+ * @~English
+ *
+ * @brief Base class for SDL applications.
+ */
+
+#include "AppBaseSDL.h"
+#include <iomanip>
+#include <sstream>
+#include <iostream>
+
+bool
+AppBaseSDL::initialize(Args& /*args*/)
+{
+    const char* basePath = SDL_GetBasePath();
+    // SDL_GetBasePath returns directory of the app, except for
+    // iOS & macOS app bundles where it returns the Resources
+    // directory.
+    if (basePath == NULL)
+        basePath = SDL_strdup("./");
+    sBasePath = basePath;
+#if SDL_PLATFORM_LINUX
+    // TODO figure out best way to handle these resources
+    sBasePath += "../resources/";
+#endif
+#if SDL_PLATFORM_WINDOWS
+    // Ditto
+    sBasePath += "resources/";
+#endif
+    return true;
+}
+
+
+void
+AppBaseSDL::initializeFPSTimer()
+{
+    lastFrameTime = 0;
+    fpsCounter.numFrames = 0;
+    fpsCounter.lastFPS = 0;
+    startTicks = fpsCounter.startTicks = SDL_GetPerformanceCounter();
+}
+
+
+void
+AppBaseSDL::finalize() {
+    
+}
+
+
+bool
+AppBaseSDL::doEvent(SDL_Event* event)
+{
+    switch (event->type) {
+      case SDL_EVENT_QUIT:
+        finalize();
+        exit(0);
+    }
+    return true;
+}
+
+
+void
+AppBaseSDL::onFPSUpdate()
+{
+    
+}
+
+
+//  Protected, non-virtual
+void
+AppBaseSDL::drawFrame()
+{
+    ticks_t ticks = SDL_GetPerformanceCounter();
+    Uint64 tps = SDL_GetPerformanceFrequency();
+    uint32_t msTicksSinceStart = (uint32_t)((ticks - startTicks) * 1000 / tps);
+
+    drawFrame(msTicksSinceStart);
+
+    ticks_t endTicks = SDL_GetPerformanceCounter();
+    lastFrameTime = (1000.0f * (endTicks - ticks)) / tps;
+    fpsCounter.numFrames++;
+    if (endTicks - fpsCounter.startTicks > tps) {
+        fpsCounter.lastFPS = (float)(fpsCounter.numFrames * tps)
+                             / (endTicks - fpsCounter.startTicks);
+        onFPSUpdate(); // Notify listeners that fps value has been updated.
+        fpsCounter.startTicks = endTicks;
+        fpsCounter.numFrames = 0;
+    }
+}
+
+//----------------------------------------------------------------------
+//  Window title and text overlay functions
+//----------------------------------------------------------------------
+
+
+void
+AppBaseSDL::setAppTitle(const char* const szExtra)
+{
+    appTitle = name();
+    if (szExtra != NULL && szExtra[0] != '\0') {
+        appTitle += ": ";
+        appTitle += szExtra;
+    }
+    setWindowTitle();
+}
+
+
+void
+AppBaseSDL::setWindowTitle()
+{
+    std::stringstream ss;
+    std::string wt;
+
+    ss << std::fixed << std::setprecision(2)
+       << lastFrameTime << "ms (" << fpsCounter.lastFPS << " fps)" << " ";
+    wt = ss.str();
+    wt += appTitle;
+    SDL_SetWindowTitle(pswMainWindow, wt.c_str());
+}
+
+
+const char* appName()
+{
+    return theApp->name();
+}
+

third_party/ktx-src/tests/loadtests/appfwSDL/AppBaseSDL.h

@@ -0,0 +1,85 @@
+/* -*- tab-width: 4; -*- */
+/* vi: set sw=2 ts=4 expandtab: */
+
+#ifndef APP_BASE_SDL_H_1456211087
+#define APP_BASE_SDL_H_1456211087
+
+/* $Id: f63e0a9e6eed51ed84a8eea1eff0708c8a6af22b $ */
+
+/*
+ * Copyright 2015-2020 Mark Callow.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @internal
+ * @file
+ * @~English
+ *
+ * @brief Declarations for App framework using SDL.
+ */
+
+#include <SDL3/SDL.h>
+#include <string>
+#include <vector>
+
+class AppBaseSDL {
+  public:
+    typedef Uint64 ticks_t;
+    typedef std::vector<std::string> Args;
+    AppBaseSDL(const char* const name) : szName(name), appTitle(name) { }
+    virtual bool initialize(Args& args);
+    virtual void finalize();
+    // Ticks in milliseconds since start.
+    virtual void drawFrame(uint32_t) { }
+    // When used with SDL_SetEventWatch, return value is ignored. When used
+    // with SDL_SetEventFilter, 1 causes event to be added to SDL's internal
+    // event queue, 0 causes it to be dropped.
+    virtual bool doEvent(SDL_Event* event);
+    virtual void onFPSUpdate();
+    virtual SDL_Window* getMainWindow() { return pswMainWindow; }
+    
+    void drawFrame();
+    void initializeFPSTimer();
+    const char* name() { return szName; }
+    const std::string getAssetPath() { return sBasePath; }
+
+    // Sets title to be used on window title bar. Content of szExtra ia
+    // appended to the app name.
+    virtual void setAppTitle(const char* const szExtra);
+
+    static bool onEvent(void* userdata, SDL_Event* event) {
+        return ((AppBaseSDL *)userdata)->doEvent(event);
+    }
+    
+    static void onDrawFrame(void* userdata) {
+        ((AppBaseSDL *)userdata)->drawFrame();
+    }
+
+  protected:
+    // Sets text on window title bar. Fps value is preprended to appTitle.
+    virtual void setWindowTitle();
+
+    ticks_t startTicks;
+    float lastFrameTime;  // ms
+    struct fpsCounter {
+        ticks_t startTicks;
+        int numFrames;
+        float lastFPS;
+    } fpsCounter;
+    
+    SDL_Window* pswMainWindow;
+    
+    const char* const szName;
+    std::string appTitle;
+    std::string sBasePath;
+
+};
+
+extern class AppBaseSDL* theApp;
+
+#endif /* APP_BASE_SDL_H_1456211087 */
+
+
+
+

third_party/ktx-src/tests/loadtests/appfwSDL/GLAppSDL.cpp

@@ -0,0 +1,330 @@
+/* -*- tab-width: 4; -*- */
+/* vi: set sw=2 ts=4 expandtab: */
+
+/* $Id: ac63511da134f2c25a9e1da86a36bc27b6198ae3 $ */
+
+/*
+ * Copyright 2015-2020 Mark Callow.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @internal
+ * @file
+ * @~English
+ *
+ * @brief GLAppSDL app class.
+ */
+
+#if defined(_WIN32)
+  #if _MSC_VER < 1900
+    #define snprintf _snprintf
+  #endif
+  #define _CRT_SECURE_NO_WARNINGS
+  #define WIN32_LEAN_AND_MEAN
+  #include "windows.h"
+  #include "GL/glew.h"
+  #include "SDL3/SDL_loadso.h"
+#else
+  #define GL_GLEXT_PROTOTYPES 1
+  #include "GL/glcorearb.h"   // for glEnable and FRAMEBUFFER_RGB
+#endif
+
+#include <stdio.h>
+#include <iomanip>
+#include <sstream>
+
+#include "GLAppSDL.h"
+
+#if SDL_PLATFORM_WINDOWS
+void setWindowsIcon(SDL_Window *sdlWindow);
+#endif
+
+bool
+GLAppSDL::initialize(Args& args)
+{
+    if (!AppBaseSDL::initialize(args))
+        return false;
+
+    SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, profile);
+    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, majorVersion);
+    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, minorVersion);
+    // On SDL3 this defaults to 8. On SDL2 it was 0.
+    SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 0);
+#if !defined(EMSCRIPTEN)
+    if (majorVersion >= 3)
+      SDL_GL_SetAttribute(SDL_GL_FRAMEBUFFER_SRGB_CAPABLE, 1);
+#endif
+#if defined(DEBUG) && !defined(EMSCRIPTEN)
+    SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, SDL_GL_CONTEXT_DEBUG_FLAG);
+#endif
+
+    if (profile == SDL_GL_CONTEXT_PROFILE_ES) {
+#if 0
+        int numVideoDrivers = SDL_GetNumVideoDrivers();
+        int i;
+        const char** drivers;
+
+        drivers = (const char**)SDL_malloc(sizeof(const char*) * numVideoDrivers);
+        for (i = 0; i < numVideoDrivers; i++) {
+            drivers[i] = SDL_GetVideoDriver(i);
+        }
+#endif
+
+        // Only the indicated platforms pay attention to these hints
+        // but they could be set on any platform.
+#if SDL_PLATFORM_WINDOWS || SDL_PLATFORM_LINUX
+        SDL_SetHint(SDL_HINT_OPENGL_ES_DRIVER, "1");
+#endif
+
+#if SDL_PLATFORM_WINDOWS
+        // If using ANGLE copied from Chrome should set to "d3dcompiler_46.dll"
+        // Should set value via compiler -D definition from gyp file.
+        SDL_SetHint(SDL_HINT_VIDEO_WIN_D3DCOMPILER, "none");
+#endif
+    }
+
+    SDL_SetHint(SDL_HINT_MAC_CTRL_CLICK_EMULATE_RIGHT_CLICK, "1");
+    // CAUTION: Setting this to 0 (the default) on macOS causes loss of all touch events
+    // from a trackpad not just those corresponding to mouse clicks.
+    SDL_SetHint(SDL_HINT_MOUSE_TOUCH_EVENTS, "1");
+
+#if 0
+    const char* mt = SDL_GetHint(SDL_HINT_MOUSE_TOUCH_EVENTS);
+    SDL_Log("MOUSE_TOUCH_EVENTS = %s", mt);
+    const char* tm = SDL_GetHint(SDL_HINT_TOUCH_MOUSE_EVENTS);
+    SDL_Log("TOUCH_MOUSE_EVENTS = %s", tm);
+    const char* tto = SDL_GetHint(SDL_HINT_TRACKPAD_IS_TOUCH_ONLY);
+    SDL_Log("TRACKPAD_IS_TOUCH_ONLY = %s", tto);
+#endif
+
+    pswMainWindow = SDL_CreateWindow(
+                        szName,
+                        w_width, w_height,
+                        SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE
+                    );
+
+    if (pswMainWindow == NULL) {
+        (void)SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, szName, SDL_GetError(), NULL);
+        return false;
+    }
+#if SDL_PLATFORM_WINDOWS
+    // Set the application's own icon in place of the Windows default set by SDL.
+    // Needs to be done here to avoid change being visible.
+    setWindowsIcon(pswMainWindow);
+#endif
+
+    sgcGLContext = SDL_GL_CreateContext(pswMainWindow);
+    // Work around bug in SDL. It returns a 2.x context when 3.x is requested.
+    // It does though internally record an error.
+    const char* error = SDL_GetError();
+    if (sgcGLContext == NULL
+        || (error[0] != '\0'
+            && majorVersion >= 3
+            && (profile == SDL_GL_CONTEXT_PROFILE_CORE
+                || profile == SDL_GL_CONTEXT_PROFILE_COMPATIBILITY))
+        ) {
+        (void)SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, szName, SDL_GetError(), NULL);
+        return false;
+    }
+
+#if SDL_PLATFORM_WINDOWS
+    if (profile != SDL_GL_CONTEXT_PROFILE_ES)
+    {
+        // No choice but to use GLEW for GL on Windows; there is no .lib with static
+        // bindings. For ES we use one of the hardware vendor SDKs all of which have
+        // static bindings.
+        // TODO: Figure out how to support {GLX,WGL}_EXT_create_context_es2_profile
+        //       were there are no static bindings. Need a GLEW equivalent for ES and
+        //       different compile options. Perhaps can borrow function loading stuff
+        //       from SDL's testgles2.c.
+
+        // So one build of this library can be linked in to applications using GLEW and
+        // applications not using GLEW, do not call any GLEW functions directly.
+        // Call via queried function pointers.
+        SDL_SharedObject* glewdll;
+#if defined(_DEBUG)
+        glewdll = SDL_LoadObject("glew32d.dll");
+        // KTX-Software repo only contains non-debug library for x64 hence this.
+        if (glewdll == NULL) {
+            glewdll = SDL_LoadObject("glew32.dll");
+        }
+#else
+        glewdll = SDL_LoadObject("glew32.dll");
+#endif
+        if (glewdll == NULL) {
+            std::string sName(szName);
+
+            (void)SDL_ShowSimpleMessageBox(
+                SDL_MESSAGEBOX_ERROR,
+                szName,
+                SDL_GetError(),
+                NULL);
+            return false;
+        }
+
+        typedef GLenum(GLEWAPIENTRY PFNGLEWINIT)(void);
+        typedef const GLubyte * GLEWAPIENTRY PFNGLEWGETERRORSTRING(GLenum error);
+        PFNGLEWINIT* pGlewInit;
+        PFNGLEWGETERRORSTRING* pGlewGetErrorString = nullptr;
+        bool loadError = true;
+#define STR(s) #s
+#if defined(_M_IX86)
+        /* Win32 GLEW uses __stdcall. */
+  #define DNAMESTR(x,n) STR(_##x##@##n)
+#else
+        /* x64 uses __cdecl. */
+  #define DNAMESTR(x,n) STR(x)
+#endif
+        pGlewInit = (PFNGLEWINIT*)SDL_LoadFunction(glewdll, DNAMESTR(glewInit,0));
+        if (pGlewInit != NULL) {
+            pGlewGetErrorString = (PFNGLEWGETERRORSTRING*)SDL_LoadFunction(
+                    glewdll, DNAMESTR(glewGetErrorString,4));
+            if (pGlewGetErrorString != NULL) {
+                loadError = false;
+            }
+        }
+
+        if (loadError) {
+            std::string sName(szName);
+
+            (void)SDL_ShowSimpleMessageBox(
+                SDL_MESSAGEBOX_ERROR,
+                szName,
+                SDL_GetError(),
+                NULL);
+            return false;
+        }
+        int iResult = pGlewInit();
+        if (iResult != GLEW_OK) {
+            std::string sName(szName);
+
+            (void)SDL_ShowSimpleMessageBox(
+                          SDL_MESSAGEBOX_ERROR,
+                          szName,
+                          (const char*)pGlewGetErrorString(iResult),
+                          NULL);
+            return false;
+        }
+    }
+#endif
+
+    int srgb;
+    SDL_GL_GetAttribute(SDL_GL_FRAMEBUFFER_SRGB_CAPABLE, &srgb);
+    if (srgb && profile != SDL_GL_CONTEXT_PROFILE_ES)
+        glEnable(GL_FRAMEBUFFER_SRGB);
+
+    // In case the window is created with a different size than specified.
+    int actualWidth, actualHeight;
+    SDL_GetWindowSizeInPixels(pswMainWindow, &actualWidth, &actualHeight);
+    resizeWindow(actualWidth, actualHeight);
+
+    initializeFPSTimer();
+    return true;
+}
+
+
+void
+GLAppSDL::finalize()
+{
+    SDL_GL_DestroyContext(sgcGLContext);
+}
+
+
+bool
+GLAppSDL::doEvent(SDL_Event* event)
+{
+    switch (event->type) {
+      case SDL_EVENT_WINDOW_PIXEL_SIZE_CHANGED:
+        resizeWindow(event->window.data1, event->window.data2);
+        return 0;
+        break;
+    }
+    return AppBaseSDL::doEvent(event);
+}
+
+
+void
+GLAppSDL::drawFrame(uint32_t /*msTicks*/)
+{
+    SDL_GL_SwapWindow(pswMainWindow);
+}
+
+
+void
+GLAppSDL::windowResized()
+{
+    // Derived class can override as necessary.
+}
+
+
+void
+GLAppSDL::resizeWindow(int width, int height)
+{
+    w_width = width;
+    w_height = height;
+    windowResized();
+}
+
+
+void
+GLAppSDL::onFPSUpdate()
+{
+    // Using onFPSUpdate avoids rewriting the title every frame.
+    setWindowTitle();
+}
+
+#if 0
+void
+GLAppSDL::setAppTitle(const char* const szExtra)
+{
+    appTitle = name();
+    if (szExtra != NULL && szExtra[0] != '\0') {
+        appTitle += ": ";
+        appTitle += szExtra;
+    }
+    setWindowTitle();
+}
+
+
+void
+GLAppSDL::setWindowTitle(const char* const szExtra)
+{
+    std::stringstream ss;
+
+    ss << std::fixed << std::setprecision(2)
+       << lastFrameTime << "ms (" << fpsCounter.lastFPS << " fps)"
+       << " - " << szName;
+
+    if (szExtra != NULL && szExtra[0] != '\0') {
+        ss << ": " << szExtra;
+    }
+    SDL_SetWindowTitle(pswMainWindow, ss.str().c_str());
+}
+
+void
+GLAppSDL::setWindowTitle()
+{
+    SDL_SetWindowTitle(pswMainWindow, appTitle.c_str());
+}
+#endif
+
+#if SDL_PLATFORM_WINDOWS
+// Windows specific code to use icon in module
+void
+setWindowsIcon(SDL_Window *sdlWindow) {
+    HINSTANCE handle = ::GetModuleHandle(nullptr);
+    // Identify icon by name rather than IDI_ macro to avoid having to
+    // include application's resource.h.
+    HICON icon = ::LoadIcon(handle, "MAIN_ICON");// MAKEINTRESOURCE(IDI_ICON1));
+    if (icon != nullptr){
+        HWND hwnd = (HWND)SDL_GetPointerProperty(SDL_GetWindowProperties(sdlWindow), SDL_PROP_WINDOW_WIN32_HWND_POINTER, NULL);
+        if (hwnd) {
+            ::SetClassLongPtr(hwnd, GCLP_HICON, reinterpret_cast<LONG_PTR>(icon));
+        }
+    }
+}
+#endif
+
+//    }
+

third_party/ktx-src/tests/loadtests/appfwSDL/GLAppSDL.h

@@ -0,0 +1,59 @@
+/* -*- tab-width: 4; -*- */
+/* vi: set sw=2 ts=4 expandtab: */
+
+#ifndef GL_APP_SDL_H_1456211188
+#define GL_APP_SDL_H_1456211188
+
+/* $Id: ac63511da134f2c25a9e1da86a36bc27b6198ae3 $ */
+
+/*
+ * Copyright 2015-2020 Mark Callow.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @internal
+ * @file
+ * @~English
+ *
+ * @brief Declaration of GLAppSDL base class for GL apps.
+ */
+
+#include "AppBaseSDL.h"
+
+
+class GLAppSDL : public AppBaseSDL {
+  public:
+      GLAppSDL(const char* const name,
+               int width, int height,
+               const SDL_GLProfile profile,
+               const int majorVersion,
+               const int minorVersion)
+            : AppBaseSDL(name),
+              profile(profile),
+              majorVersion(majorVersion), minorVersion(minorVersion)
+    {
+        appTitle = name;
+        w_width = width;
+        w_height = height;
+    };
+    virtual bool doEvent(SDL_Event* event);
+    virtual void drawFrame(uint32_t msTicks);
+    virtual void finalize();
+    virtual bool initialize(Args& args);
+    virtual void onFPSUpdate();
+    virtual void resizeWindow(int width, int height);
+    virtual void windowResized();
+
+  protected:
+    SDL_GLContext sgcGLContext;
+
+    int w_width;
+    int w_height;
+
+    const SDL_GLProfile profile;
+    const int majorVersion;
+    const int minorVersion;
+};
+
+#endif /* GL_APP_SDL_H_1456211188 */

third_party/ktx-src/tests/loadtests/appfwSDL/VulkanAppSDL/VulkanAppSDL.cpp

@@ -0,0 +1,1748 @@
+/* -*- tab-width: 4; -*- */
+/* vi: set sw=2 ts=4 expandtab: */
+
+/*
+ * Copyright 2017-2020 Mark Callow.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @internal
+ * @class VulkanAppSDL
+ * @~English
+ *
+ * @brief Framework for Vulkan apps using SDL windows.
+ *
+ * @author Mark Callow, github.com/MarkCallow.
+ */
+
+
+#if defined(_WIN32)
+  #if _MSC_VER < 1900
+    #define snprintf _snprintf
+  #endif
+  #define _CRT_SECURE_NO_WARNINGS
+#endif
+
+#include <assert.h>
+#include <stdio.h>
+#include <string.h>
+#include <iomanip>
+#include <string>
+#include <sstream>
+
+#include "VulkanAppSDL.h"
+
+// Include this when vulkantools is removed.
+//#include "vulkancheckres.h"
+
+#define ARRAY_LEN(a) (sizeof(a) / sizeof(a[0]))
+
+#define ERROR_RETURN(msg) \
+      (void)SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, szName, msg, NULL); \
+      return false;
+
+#define WARNING(msg) \
+      (void)SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_WARNING, szName, msg, NULL);
+
+#define GET_INSTANCE_PROC_ADDR(inst, entrypoint)                              \
+  {                                                                           \
+    pfn##entrypoint =                                                         \
+        (PFN_vk##entrypoint)vkGetInstanceProcAddr(inst, "vk" #entrypoint);    \
+    if (pfn##entrypoint == NULL) {                                            \
+        ERROR_RETURN("vkGetInstanceProcAddr: unable to find vk" #entrypoint); \
+    }                                                                         \
+  }
+
+#define GET_DEVICE_PROC_ADDR(device, entrypoint)                            \
+  {                                                                         \
+    pfn##entrypoint =                                                       \
+        (PFN_vk##entrypoint)vkGetDeviceProcAddr(device, "vk" #entrypoint);  \
+    if (pfn##entrypoint == NULL) {                                          \
+        ERROR_RETURN("vkGetDeviceProcAddr: unable to find vk" #entrypoint); \
+    }                                                                       \
+  }
+
+#if SDL_PLATFORM_WINDOWS
+void setWindowsIcon(SDL_Window *sdlWindow);
+#endif
+
+VulkanAppSDL::~VulkanAppSDL()
+{
+
+}
+
+
+bool
+VulkanAppSDL::initialize(Args& args)
+{
+    for (uint32_t i = 1; i < args.size(); i++) {
+        if (args[i].compare("--validate") == 0) {
+            validate = true;
+            args.erase(args.begin() + i);
+            break;
+        }
+    }
+    if (!AppBaseSDL::initialize(args))
+        return false;
+
+    SDL_SetHint(SDL_HINT_MAC_CTRL_CLICK_EMULATE_RIGHT_CLICK, "1");
+    // CAUTION: Setting this to 0 (the default) on macOS causes loss of all touch events
+    // from a trackpad not just those corresponding to mouse clicks.
+    SDL_SetHint(SDL_HINT_MOUSE_TOUCH_EVENTS, "1");
+    // Create window.
+    // Vulkan samples do not pass any information from Vulkan initialization
+    // to window creation so creating the window first should be ok...
+    pswMainWindow = SDL_CreateWindow(
+                        szName,
+                        w_width, w_height,
+                        SDL_WINDOW_VULKAN | SDL_WINDOW_RESIZABLE | SDL_WINDOW_HIGH_PIXEL_DENSITY
+                    );
+
+    if (pswMainWindow == NULL) {
+        (void)SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, szName,
+                                       SDL_GetError(), NULL);
+        return false;
+    }
+
+#if SDL_PLATFORM_WINDOWS
+    // Set the application's own icon in place of the Windows default set by SDL.
+    // Needs to be done here to avoid change being visible.
+    setWindowsIcon(pswMainWindow);
+#endif
+
+    if (!initializeVulkan()) {
+        return false;
+    }
+
+    initializeFPSTimer();
+    return true;
+}
+
+
+void
+VulkanAppSDL::finalize()
+{
+    if (vkctx.descriptorPool)
+    {
+        vkctx.device.destroyDescriptorPool(vkctx.descriptorPool, nullptr);
+    }
+    vkDestroyPipelineCache((VkDevice)vkctx.device, vkctx.pipelineCache, nullptr);
+
+    vkctx.swapchain.cleanup();
+    for (auto& shaderModule : shaderModules)
+    {
+        vkctx.device.destroyShaderModule(shaderModule);
+    }
+    if (enableTextOverlay)
+    {
+        delete textOverlay;
+    }
+
+    vkctx.device.destroyCommandPool(vkctx.commandPool);
+    //vkctx.device.destroy();
+    if (vsSurface != VK_NULL_HANDLE) {
+        // Destroy
+    }
+    //vkctx.instance.destroy();
+}
+
+
+bool
+VulkanAppSDL::doEvent(SDL_Event* event)
+{
+    switch (event->type) {
+      case SDL_EVENT_WINDOW_PIXEL_SIZE_CHANGED:
+        resizeWindow(event->window.data1, event->window.data2);
+        return 0;
+        break;
+    }
+    return AppBaseSDL::doEvent(event);
+}
+
+
+void
+VulkanAppSDL::drawFrame(uint32_t /*msTicks*/)
+{
+    if (!prepared)
+        return;
+
+    prepareFrame();
+
+    vkctx.drawCmdSubmitInfo.commandBufferCount = 1;
+    vkctx.drawCmdSubmitInfo.pCommandBuffers =
+                    &vkctx.drawCmdBuffers[currentBuffer];
+
+    // Submit to queue
+    VK_CHECK_RESULT(vkQueueSubmit(vkctx.queue, 1,
+                                  &vkctx.drawCmdSubmitInfo, VK_NULL_HANDLE));
+
+    submitFrame();
+}
+
+
+void
+VulkanAppSDL::windowResized()
+{
+    // Derived class can override as necessary.
+}
+
+void
+VulkanAppSDL::resizeWindow(int width, int height)
+{
+    // XXX Necessary? Get out-of-date errors from vkAcquireNextImage regardless
+    // of whether this guard is used. This guard doesn't seem to make them any
+    // less likely.
+#define GUARD 0
+#if GUARD
+    if (!prepared)
+    {
+        return;
+    }
+    prepared = false;
+#endif
+
+    // Recreate swap chain.
+
+    w_width = width;
+    w_height = height;
+
+    // This destroys any existing swapchain and makes a new one.
+    createSwapchain();
+
+    vkDestroyImageView(vkctx.device, vkctx.depthBuffer.view, nullptr);
+    vkDestroyImage(vkctx.device, vkctx.depthBuffer.image, nullptr);
+    vkFreeMemory(vkctx.device, vkctx.depthBuffer.mem, nullptr);
+
+    // Recreate the frame buffers
+    for (uint32_t i = 0; i < vkctx.framebuffers.size(); i++)
+    {
+        vkDestroyFramebuffer(vkctx.device, vkctx.framebuffers[i], nullptr);
+    }
+
+    // XXX Is this necessary? Is Willems doing this?
+    vkDestroyRenderPass(vkctx.device, vkctx.renderPass, NULL);
+
+    vkctx.destroyPresentCommandBuffers();
+    (void)(prepareDepthBuffer() // XXX Call it DepthStencil?
+        && vkctx.createPresentCommandBuffers()
+        && preparePresentCommandBuffers()
+        && prepareRenderPass()
+        && prepareFramebuffers());
+
+    flushInitialCommands();
+    if (enableTextOverlay)
+    {
+        textOverlay->reallocateCommandBuffers();
+        updateTextOverlay();
+    }
+    // Notify derived class.
+    windowResized();
+#if GUARD
+    prepared = true;
+#endif
+}
+
+
+void
+VulkanAppSDL::onFPSUpdate()
+{
+    if (!enableTextOverlay) {
+        setWindowTitle();
+    }
+    updateTextOverlay();
+    // Using onFPSUpdate avoids rewriting the title every frame.
+}
+
+
+//----------------------------------------------------------------------
+//  Frame draw utilities
+//----------------------------------------------------------------------
+
+
+void
+VulkanAppSDL::prepareFrame()
+{
+    // Acquire the next image from the swap chain
+    VkResult err;
+    err = vkctx.swapchain.acquireNextImage(semaphores.presentComplete,
+                                           &currentBuffer);
+
+    if (err == VK_ERROR_OUT_OF_DATE_KHR) {
+        // Swap chain is out of date (e.g. the window was resized).
+        // Re-create it.
+        //resize();
+        //draw(demo);
+        return;
+    } else if (err == VK_SUBOPTIMAL_KHR) {
+        // demo->swapchain is not as optimal as it could be, but the platform's
+        // presentation engine will still present the image correctly.
+    } else {
+        assert(!err);
+    }
+
+    // Submit post present image barrier to transform the image back to a
+    // color attachment that our render pass can write to
+    VkSubmitInfo submitInfo = {};
+    submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
+    submitInfo.pNext = NULL;
+    submitInfo.commandBufferCount = 1;
+    submitInfo.pCommandBuffers = &vkctx.postPresentCmdBuffers[currentBuffer];
+    VK_CHECK_RESULT(vkQueueSubmit(vkctx.queue, 1,
+                                  &submitInfo, VK_NULL_HANDLE));
+}
+
+
+void
+VulkanAppSDL::submitFrame()
+{
+    bool submitTextOverlay = enableTextOverlay && textOverlay->visible;
+
+    if (submitTextOverlay)
+    {
+        // Wait for color attachment output to finish before rendering the
+        // text overlay
+        VkPipelineStageFlags stageFlags
+                               = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
+        vkctx.drawCmdSubmitInfo.pWaitDstStageMask = &stageFlags;
+
+        // Set semaphores
+        // Wait for render complete semaphore
+        vkctx.drawCmdSubmitInfo.waitSemaphoreCount = 1;
+        vkctx.drawCmdSubmitInfo.pWaitSemaphores = &semaphores.renderComplete;
+        // Signal ready with text overlay complete semaphore
+        vkctx.drawCmdSubmitInfo.signalSemaphoreCount = 1;
+        vkctx.drawCmdSubmitInfo.pSignalSemaphores
+                                            = &semaphores.textOverlayComplete;
+
+        // Submit current text overlay command buffer
+        vkctx.drawCmdSubmitInfo.commandBufferCount = 1;
+        vkctx.drawCmdSubmitInfo.pCommandBuffers
+                                     = &textOverlay->cmdBuffers[currentBuffer];
+        VK_CHECK_RESULT(vkQueueSubmit(vkctx.queue, 1, &vkctx.drawCmdSubmitInfo,
+                                      VK_NULL_HANDLE));
+
+        // Reset stage mask
+        vkctx.drawCmdSubmitInfo.pWaitDstStageMask = &vkctx.submitPipelineStages;
+        // Reset wait and signal semaphores for rendering next frame
+        // Wait for swap chain presentation to finish
+        vkctx.drawCmdSubmitInfo.waitSemaphoreCount = 1;
+        vkctx.drawCmdSubmitInfo.pWaitSemaphores = &semaphores.presentComplete;
+        // Signal ready with offscreen semaphore
+        vkctx.drawCmdSubmitInfo.signalSemaphoreCount = 1;
+        vkctx.drawCmdSubmitInfo.pSignalSemaphores = &semaphores.renderComplete;
+    }
+    // Submit pre-present image barrier to transform the image from color
+    // attachment to present(khr) for presenting to the swap chain.
+    VkSubmitInfo submitInfo = {};
+    submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
+    submitInfo.pNext = NULL;
+    submitInfo.commandBufferCount = 1;
+    submitInfo.pCommandBuffers = &vkctx.prePresentCmdBuffers[currentBuffer];
+    VK_CHECK_RESULT(vkQueueSubmit(vkctx.queue, 1, &submitInfo, VK_NULL_HANDLE));
+
+    VkResult err =
+            vkctx.swapchain.queuePresent(vkctx.queue, currentBuffer,
+               submitTextOverlay ?
+                   semaphores.textOverlayComplete : semaphores.renderComplete);
+
+    if (err == VK_ERROR_OUT_OF_DATE_KHR) {
+        // swapchain is out of date (e.g. the window was resized) and
+        // must be recreated:
+        //resize();
+    } else if (err == VK_SUBOPTIMAL_KHR) {
+        if (!subOptimalPresentWarned) {
+            SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_WARNING, szName,
+                                     "Suboptimal present of framebuffer.",
+                                     NULL);
+        }
+    } else
+        assert(!err);
+
+    // This is necessary because the text overlay's command buffer changes
+    // every frame and, although the other command buffers are the same
+    // every frame, they aren't marked for simultaneous use.
+    VK_CHECK_RESULT(vkQueueWaitIdle(vkctx.queue));
+}
+
+
+//----------------------------------------------------------------------
+//  Vulkan Initialization
+//----------------------------------------------------------------------
+
+
+bool
+VulkanAppSDL::initializeVulkan()
+{
+    if (createInstance()
+            && findGpu()
+            && setupDebugReporting()
+            && vkctx.swapchain.connectInstance(vkctx.instance, vkctx.gpu)
+            && createSurface()
+            && createDevice()
+            && vkctx.swapchain.connectDevice(vkctx.device)
+            && createSemaphores()
+            && createSwapchain()
+            && prepareDepthBuffer()
+            && vkctx.createPresentCommandBuffers()
+            && preparePresentCommandBuffers()
+            && prepareRenderPass()
+            && createPipelineCache()
+            && prepareFramebuffers()) {
+        // Functions above most likely generate pipeline commands
+        // that need to be flushed before beginning the render loop.
+        flushInitialCommands();
+        prepareTextOverlay();
+
+        return true;
+    } else {
+        return false;
+    }
+}
+
+
+bool
+VulkanAppSDL::createInstance()
+{
+    MAYBE_UNUSED VkResult err;
+    uint32_t instanceLayerCount = 0;
+    std::vector<const char *>* instanceValidationLayers = nullptr;
+
+    std::vector<const char *> instanceValidationLayers_alt1 = {
+        "VK_LAYER_KHRONOS_validation"
+    };
+
+    std::vector<const char *> instanceValidationLayers_alt2 = {
+        "VK_LAYER_LUNARG_standard_validation"
+    };
+
+    // Look for validation layers.
+    bool validationFound = 0;
+    if (validate) {
+        err = vkEnumerateInstanceLayerProperties(&instanceLayerCount, NULL);
+        assert(err == VK_SUCCESS);
+
+        if (instanceLayerCount > 0) {
+            VkLayerProperties* instanceLayers
+                = new VkLayerProperties[instanceLayerCount];
+            err = vkEnumerateInstanceLayerProperties(&instanceLayerCount,
+                                                     instanceLayers);
+            assert(err == VK_SUCCESS);
+
+            validationFound = checkLayers(
+                                (uint32_t)instanceValidationLayers_alt1.size(),
+                                instanceValidationLayers_alt1.data(),
+                                instanceLayerCount,
+                                instanceLayers);
+            if (validationFound) {
+                instanceValidationLayers = &instanceValidationLayers_alt1;
+            } else {
+                // Use alternative set of validation layers.
+                validationFound = checkLayers(
+                                (uint32_t)instanceValidationLayers_alt2.size(),
+                                instanceValidationLayers_alt2.data(),
+                                instanceLayerCount,
+                                instanceLayers);
+                instanceValidationLayers = &instanceValidationLayers_alt2;
+            }
+            if (validationFound) {
+                for (uint32_t i = 0; i < instanceValidationLayers->size(); i++)
+                {
+                    deviceValidationLayers.push_back(
+                                instanceValidationLayers->data()[i]);
+                }
+            }
+            delete [] instanceLayers;
+        }
+
+        if (!validationFound) {
+            WARNING("vkEnumerateInstanceLayerProperties failed to find "
+                    "requested validation layers.\n");
+        }
+    }
+
+
+    /* Build list of needed extensions */
+    uint32_t rec;
+    const char* const* requiredExtensionNames = SDL_Vulkan_GetInstanceExtensions(&rec);
+    if (requiredExtensionNames == nullptr) {
+        std::string title;
+        std::stringstream msg;
+        title = szName;
+        title += ": SDL_Vulkan_GetInstanceExtensions Failure";
+        msg << "Could not retrieve instance extensions: "
+            << SDL_GetError();
+
+        (void)SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, title.c_str(),
+                                       msg.str().c_str(), NULL);
+        return false;
+    }
+
+    // Find out if device_properties2 is available. If so, enable it
+    // as it is required for ASTC HDR and also if we later find we
+    // are running on a Portability Subset device.
+    std::vector<vk::ExtensionProperties> availableExtensions =
+        vk::enumerateInstanceExtensionProperties(nullptr);
+    for (auto& extension : availableExtensions) {
+        if (!strncmp(extension.extensionName,
+                     VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME,
+                     VK_MAX_EXTENSION_NAME_SIZE)) {
+            extensionNames.push_back(
+                VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME
+            );
+        }
+#if VK_KHR_portability_subset
+        if (!strncmp(extension.extensionName,
+                     VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME,
+                     VK_MAX_EXTENSION_NAME_SIZE)) {
+            extensionNames.push_back(
+                VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME
+            );
+        }
+#endif
+    }
+
+    if (validate)
+        extensionNames.push_back(VK_EXT_DEBUG_REPORT_EXTENSION_NAME);
+
+    for (uint32_t i = 0; i < rec; i++) {
+        extensionNames.push_back(requiredExtensionNames[i]);
+    }
+
+    const vk::ApplicationInfo app(szName, 0, szName, 0, vkVersion);
+
+    vk::InstanceCreateInfo instanceInfo(
+                            {},
+                            &app,
+                            (uint32_t)deviceValidationLayers.size(),
+                            (const char *const *)deviceValidationLayers.data(),
+                            (uint32_t)extensionNames.size(),
+                            (const char *const *)extensionNames.data());
+#if VK_KHR_portability_subset
+    instanceInfo.setFlags(vk::InstanceCreateFlagBits::eEnumeratePortabilityKHR);
+#endif
+
+    /*
+     * This is info for a temp callback to use during CreateInstance.
+     * After the instance is created, we use the instance-based
+     * function to register the final callback.
+     */
+    VkDebugReportCallbackCreateInfoEXT dbgCreateInfo = { };
+    if (validate) {
+        dbgCreateInfo.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT;
+        dbgCreateInfo.pNext = NULL;
+        dbgCreateInfo.pfnCallback = debugFunc;
+        dbgCreateInfo.pUserData = this;
+        dbgCreateInfo.flags =
+            VK_DEBUG_REPORT_ERROR_BIT_EXT | VK_DEBUG_REPORT_WARNING_BIT_EXT
+            | VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT;
+            //| VK_DEBUG_REPORT_INFORMATION_BIT_EXT
+            //| VK_DEBUG_REPORT_DEBUG_BIT_EXT;
+        instanceInfo.pNext = &dbgCreateInfo;
+    }
+
+    //err = vkCreateInstance(&instanceInfo, NULL, &vkctx.instance);
+    vk::Result cerr;
+    cerr = vk::createInstance(&instanceInfo, nullptr, &vkctx.instance);
+
+    if (cerr != vk::Result::eSuccess) {
+        std::string title;
+        std::stringstream msg;
+        title = szName;
+        title += ": vkCreateInstance Failure";
+        if (cerr == vk::Result::eErrorIncompatibleDriver) {
+            msg << "Cannot find a compatible Vulkan installable client "
+                   "driver (ICD).";
+        } else if (cerr == vk::Result::eErrorExtensionNotPresent) {
+            // Figure out which extension(s) are missing.
+            uint32_t instanceExtensionCount = 0;
+
+            err = vkEnumerateInstanceExtensionProperties(
+                                                        NULL,
+                                                        &instanceExtensionCount,
+                                                        NULL);
+            VkExtensionProperties* instanceExtensions
+                = new VkExtensionProperties[instanceExtensionCount];
+
+            assert(err == VK_SUCCESS);
+            if (instanceExtensionCount > 0) {
+                err = vkEnumerateInstanceExtensionProperties(
+                                                        NULL,
+                                                        &instanceExtensionCount,
+                                                        instanceExtensions);
+                assert(err == VK_SUCCESS);
+            }
+            msg << "Cannot find the following extensions:\n";
+            for (uint32_t j = 0; j < extensionNames.size(); j++) {
+                uint32_t k;
+                for (k = 0; k < instanceExtensionCount; k++) {
+                    if (!strcmp(extensionNames[j],
+                                instanceExtensions[k].extensionName))
+                        break;
+                }
+                if (k == instanceExtensionCount) {
+                    // Not found
+                    msg << "    " << extensionNames[j] << "\n";
+                }
+            }
+            msg << "\nMake sure your layers path is set appropriately.";
+            delete [] instanceExtensions;
+       } else {
+            msg << "vkCreateInstance: unexpected failure, code = "
+                << cerr << ".\n\nDo you have a compatible Vulkan "
+                  "installable client driver (ICD) installed?";
+       }
+       (void)SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, title.c_str(),
+                                      msg.str().c_str(), NULL);
+       return false;
+    }
+
+    return true;
+} // createInstance
+
+
+bool
+VulkanAppSDL::findGpu()
+{
+    MAYBE_UNUSED vk::Result err;
+    uint32_t gpuCount;
+
+    // Make initial call to query gpu_count, then second call for gpu info.
+    err = vkctx.instance.enumeratePhysicalDevices(&gpuCount,
+                                                  (vk::PhysicalDevice*)nullptr);
+    assert(err == vk::Result::eSuccess);
+
+    if (gpuCount > 0) {
+        std::vector<vk::PhysicalDevice> gpus;
+        gpus.resize(gpuCount);
+        err = vkctx.instance.enumeratePhysicalDevices(&gpuCount, gpus.data());
+        assert(err == vk::Result::eSuccess);
+        // For now just grab the first physical device */
+        vkctx.gpu = gpus[0];
+        // Store properties and features so apps can query them.
+        vkctx.gpu.getProperties(&vkctx.gpuProperties);
+#if 0
+        vk::PhysicalDeviceFeatures2 gpuFeatures2;
+        vkctx.gpu.getFeatures2(&gpuFeatures2);
+        vkctx.gpuFeatures = gpuFeatures2.features;
+#else
+        vkctx.gpu.getFeatures(&vkctx.gpuFeatures);
+#endif
+        // Get Memory information and properties
+        vkctx.gpu.getMemoryProperties(&vkctx.memoryProperties);
+        
+    } else {
+        std::string msg;
+        ERROR_RETURN(
+            "vkEnumeratePhysicalDevices reported zero accessible devices.\n\n"
+            "Do you have a compatible Vulkan installable client driver (ICD) "
+            "installed?");
+    }
+
+    return true;
+} // findGpu
+
+
+bool
+VulkanAppSDL::setupDebugReporting()
+{
+    if (validate) {
+        GET_INSTANCE_PROC_ADDR(vkctx.instance, CreateDebugReportCallbackEXT);
+        GET_INSTANCE_PROC_ADDR(vkctx.instance, DestroyDebugReportCallbackEXT);
+        GET_INSTANCE_PROC_ADDR(vkctx.instance, DebugReportMessageEXT);
+        VkDebugReportCallbackCreateInfoEXT dbgCreateInfo;
+        dbgCreateInfo.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT;
+        dbgCreateInfo.pNext = NULL;
+        dbgCreateInfo.pfnCallback = debugFunc;
+        dbgCreateInfo.pUserData = this;
+        dbgCreateInfo.flags =
+            VK_DEBUG_REPORT_ERROR_BIT_EXT | VK_DEBUG_REPORT_WARNING_BIT_EXT;
+        VkResult err = pfnCreateDebugReportCallbackEXT(vkctx.instance,
+                                                       &dbgCreateInfo, NULL,
+                                                       &msgCallback);
+        switch (err) {
+          case VK_SUCCESS:
+            return true;
+            break;
+          case VK_ERROR_OUT_OF_HOST_MEMORY:
+            ERROR_RETURN("CreateDebugReportCallback: out of host memory.");
+            break;
+          default:
+          {
+            std::stringstream msg;
+            msg << "CreateDebugReportCallback: unexpected failure, result code "
+                << err << ".";
+            ERROR_RETURN(msg.str().c_str());
+            break;
+          }
+        }
+    }
+    return true;
+} // setupDebugReporting
+
+
+bool
+VulkanAppSDL::createSurface()
+{
+    vkctx.swapchain.initSurface(pswMainWindow);
+    return true;
+} // createSurface
+
+
+bool
+VulkanAppSDL::createDevice()
+{
+    typedef enum { optional, required } ext_need;
+    struct extension {
+        std::string name;
+        ext_need need;
+    };
+    std::vector<extension> wantedExtensions;
+    std::vector<const char*> extensionsToEnable;
+
+    wantedExtensions.push_back({VK_KHR_SWAPCHAIN_EXTENSION_NAME, required});
+    wantedExtensions.push_back({VK_KHR_MAINTENANCE1_EXTENSION_NAME, required});
+#if VK_KHR_portability_subset
+    // Portability must be enabled, if present.
+    wantedExtensions.push_back({VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME, optional});
+#endif
+    // And if present and enabled it requires this to be enabled.
+    wantedExtensions.push_back({VK_IMG_FORMAT_PVRTC_EXTENSION_NAME, optional});
+#if VK_EXT_texture_compression_astc_hdr
+    wantedExtensions.push_back(
+        {VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_EXTENSION_NAME, optional}
+    );
+#endif
+#if 0
+    wantedExtensions.push_back(
+        {TEXTURE_COMPRESSION_ASTC_3D_EXTENSION_NAME, optional}
+    );
+#endif
+
+    vk::Result err;
+
+    // Figure out if we have the required extensions and remove missing
+    // optional extensions from the list. If anyone wonders why we don't
+    // just request enablement and ignore the eErrorExtensionNotPresent
+    // for optional extensions, 2 answers: the debug layer and (some?) Vulkan
+    // implementations crash when you create a command buffer on the affected
+    // device.
+    uint32_t deviceExtensionCount = 0;
+
+    err = vkctx.gpu.enumerateDeviceExtensionProperties(
+                                            NULL,
+                                            &deviceExtensionCount,
+                                            (vk::ExtensionProperties*)nullptr);
+    assert(err == vk::Result::eSuccess);
+
+    std::vector<vk::ExtensionProperties> deviceExtensions;
+    deviceExtensions.resize(deviceExtensionCount);
+
+    if (deviceExtensionCount > 0) {
+        err = vkctx.gpu.enumerateDeviceExtensionProperties(
+                                                NULL,
+                                                &deviceExtensionCount,
+                                                deviceExtensions.data());
+        assert(err == vk::Result::eSuccess);
+    }
+
+    std::vector<std::string> missingExtensions;
+    for (uint32_t i = 0; i < wantedExtensions.size(); i++) {
+        uint32_t j;
+        for (j = 0; j < deviceExtensions.size(); j++) {
+            if (!wantedExtensions[i].name.compare(static_cast<const char*>(deviceExtensions[j].extensionName))) {
+                extensionsToEnable.push_back(wantedExtensions[i].name.c_str());
+                if (!wantedExtensions[i].name.compare(VK_IMG_FORMAT_PVRTC_EXTENSION_NAME)) {
+                    vkctx.enabledDeviceExtensions.pvrtc = true;
+
+                }
+#if VK_EXT_texture_compression_astc_hdr
+                if (!wantedExtensions[i].name.compare(VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_EXTENSION_NAME)) {
+                    vkctx.enabledDeviceExtensions.astc_hdr = true;
+                }
+#endif
+#if VK_KHR_portability_subset
+                if (!wantedExtensions[i].name.compare(VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME)) {
+                    vkctx.gpuIsPortabilitySubsetDevice = true;
+                }
+#endif
+                break;
+            }
+        }
+        if (j == deviceExtensionCount) {
+            // Not found
+            if (wantedExtensions[i].need == required) {
+                missingExtensions.push_back(wantedExtensions[i].name);
+            }
+        }
+    }
+
+    if (missingExtensions.size() > 0) {
+        std::string title;
+        std::stringstream msg;
+        std::vector<std::string>::const_iterator it;
+
+        title = szName;
+        title += ": Vulkan Extensions not Found";
+        msg << "The following required device extensions were not found:\n";
+        for (it = missingExtensions.begin(); it < missingExtensions.end(); it++)
+            msg << "    " << *it << "\n";
+
+        msg << "\n\nDo you have a compatible Vulkan "
+               "installable client driver (ICD) installed?";
+       (void)SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, title.c_str(),
+                                      msg.str().c_str(), NULL);
+       return false;
+    }
+
+    float queue_priorities[1] = {0.0};
+    const vk::DeviceQueueCreateInfo queueInfo(
+        {},
+        vkctx.swapchain.queueIndex,
+        1,
+        queue_priorities
+    );
+
+    vk::PhysicalDeviceFeatures deviceFeaturesToEnable;
+    // Enable specific required and available features here.
+    if (vkctx.gpuFeatures.samplerAnisotropy)
+        deviceFeaturesToEnable.samplerAnisotropy = true;
+    if (vkctx.gpuFeatures.textureCompressionASTC_LDR)
+        deviceFeaturesToEnable.textureCompressionASTC_LDR = true;
+    if (vkctx.gpuFeatures.textureCompressionBC)
+        deviceFeaturesToEnable.textureCompressionBC = true;
+    if (vkctx.gpuFeatures.textureCompressionETC2)
+        deviceFeaturesToEnable.textureCompressionETC2 = true;
+
+#if VK_KHR_portability_subset
+    if (vkctx.gpuIsPortabilitySubsetDevice) {
+        vk::PhysicalDeviceFeatures2 deviceFeatures;
+        deviceFeatures.pNext = &vkctx.gpuPortabilityFeatures;
+        vkctx.gpu.getFeatures2(&deviceFeatures);
+    }
+#endif
+
+#if 0
+    // This needs PhysicaldeviceFeaturesToEnable2 and proper understanding of how to
+    // navigate a structure chain. Maybe something also was necessary when the
+    // gpuFeatures were queried.
+    vk::BaseOutStructure* dfs = reinterpret_cast<vk::BaseOutStructure*>(&vkctx.gpuFeatures);
+    while (dfs->pNext != NULL) {
+        if (dfs->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT) {
+            vk::PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* ahf = dfs;
+            if (afs->textureCompressionASTC_HDR) {
+                // Add one of these structs to the requested deviceFeaturesToEnable we
+                // are passing in and enable this feature.
+            }
+        }
+        if (dfs->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_3D_FEATURES_EXT) {
+            vk::PhysicalDeviceTextureCompressionASTC3DFeaturesEXT* ahf = dfs;
+            if (afs->textureCompressionASTC_HDR) {
+                // Add one of these structs to the requested deviceFeaturesToEnable we
+                // are passing in and enable this feature.
+            }
+        }
+#endif
+
+    vk::DeviceCreateInfo deviceInfo(
+            {},
+            1,
+            &queueInfo,
+            (uint32_t)deviceValidationLayers.size(),
+            (const char *const *)((validate)
+                                  ? deviceValidationLayers.data()
+                                  : NULL),
+            (uint32_t)extensionsToEnable.size(),
+            (const char *const *)extensionsToEnable.data(),
+            &deviceFeaturesToEnable);
+
+#if VK_KHR_portability_subset
+    if (vkctx.gpuIsPortabilitySubsetDevice) {
+        // Enable all available portability features.
+        deviceInfo.pNext = &vkctx.gpuPortabilityFeatures;
+    }
+#endif
+
+    err = vkctx.gpu.createDevice(&deviceInfo, NULL, &vkctx.device);
+    if (err != vk::Result::eSuccess) {
+        assert(err != vk::Result::eErrorExtensionNotPresent);
+
+        std::string title;
+        std::stringstream msg;
+        title = szName;
+        title += ": vkCreateDevice Failure";
+            msg << "vkCreateDevice: unexpected failure: ";
+            msg << to_string(err) << ".";
+        (void)SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, title.c_str(),
+                                       msg.str().c_str(), NULL);
+        return false;
+    }
+
+    const vk::CommandPoolCreateInfo cmdPoolInfo(
+        vk::CommandPoolCreateFlagBits::eResetCommandBuffer,
+        vkctx.swapchain.queueIndex
+    );
+    err = vkctx.device.createCommandPool(&cmdPoolInfo,
+                              nullptr, &vkctx.commandPool);
+    assert(err == vk::Result::eSuccess);
+
+    vkctx.device.getQueue(vkctx.swapchain.queueIndex, 0, &vkctx.queue);
+
+    return true;
+} // createDevice
+
+
+// Create synchronization objects
+bool
+VulkanAppSDL::createSemaphores()
+{
+    VkSemaphoreCreateInfo semaphoreCreateInfo = {};
+    semaphoreCreateInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
+    semaphoreCreateInfo.pNext = NULL;
+    semaphoreCreateInfo.flags = 0;
+
+    // Semaphore used to synchronize image presentation.
+    // Ensures that the image is displayed before we start submitting new
+    // commands to the queue.
+    VK_CHECK_RESULT(vkCreateSemaphore(vkctx.device,
+                                      &semaphoreCreateInfo,
+                                      nullptr,
+                                      &semaphores.presentComplete));
+    // Semaphore used to synchronize render command submission.
+    // Ensures that the image is not presented until all render commands have
+    // been submitted and executed.
+    VK_CHECK_RESULT(vkCreateSemaphore(vkctx.device,
+                                      &semaphoreCreateInfo,
+                                      nullptr,
+                                      &semaphores.renderComplete));
+    // Semaphore used to synchronize text overlay command submission.
+    // Ensures that the image is not presented until all commands for the
+    // text overlay have been submitted and executed. Will be inserted after
+    // the render complete semaphore if the text overlay is enabled.
+    VK_CHECK_RESULT(vkCreateSemaphore(vkctx.device,
+                                      &semaphoreCreateInfo,
+                                      nullptr,
+                                      &semaphores.textOverlayComplete));
+
+    // Set up submit info structure
+    // Semaphores will stay the same during application lifetime
+    // Command buffer submission info is set by each example
+    vkctx.drawCmdSubmitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
+    vkctx.drawCmdSubmitInfo.pNext = NULL;
+    vkctx.drawCmdSubmitInfo.pWaitDstStageMask = &vkctx.submitPipelineStages;
+    vkctx.drawCmdSubmitInfo.waitSemaphoreCount = 1;
+    vkctx.drawCmdSubmitInfo.pWaitSemaphores = &semaphores.presentComplete;
+    vkctx.drawCmdSubmitInfo.signalSemaphoreCount = 1;
+    vkctx.drawCmdSubmitInfo.pSignalSemaphores = &semaphores.renderComplete;
+    return true;
+}
+
+
+bool
+VulkanAppSDL::createSwapchain()
+{
+    vkctx.swapchain.create(&w_width, &w_height, enableVSync);
+    return true;
+} // createSwapchain
+
+
+bool
+VulkanAppSDL::prepareDepthBuffer()
+{
+    vk::Format depthFormat;
+    vk::ImageAspectFlags aspectMask;
+  
+    if (!getSupportedDepthFormat(vkctx.gpu, eNoStencil, e24bits,
+                                 vk::ImageTiling::eOptimal,
+                                 depthFormat, aspectMask))
+        return false;
+    vkctx.depthBuffer.format = static_cast<VkFormat>(depthFormat);
+
+    VkImageCreateInfo image = {};
+    image.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
+    image.pNext = NULL;
+    image.imageType = VK_IMAGE_TYPE_2D;
+    image.format = static_cast<VkFormat>(depthFormat);
+    image.extent.width = w_width;
+    image.extent.height = w_height;
+    image.extent.depth = 1;
+    image.mipLevels = 1;
+    image.arrayLayers = 1;
+    image.samples = VK_SAMPLE_COUNT_1_BIT;
+    image.tiling = VK_IMAGE_TILING_OPTIMAL;
+    image.usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT
+                            | VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
+    image.flags = 0;
+
+    VkImageViewCreateInfo view = { };
+    view.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
+    view.pNext = NULL;
+    view.image = VK_NULL_HANDLE;
+    view.format = static_cast<VkFormat>(depthFormat);
+    // Set just DEPTH_BIT as we're not using stencil. This is okay even if a
+    // packed depth-stencil format was selected by getSupportedDepthFormat.
+    view.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
+    view.subresourceRange.baseMipLevel = 0;
+    view.subresourceRange.levelCount = 1;
+    view.subresourceRange.baseArrayLayer = 0;
+    view.subresourceRange.layerCount = 1;
+    view.flags = 0;
+    view.viewType = VK_IMAGE_VIEW_TYPE_2D;
+
+    VkMemoryRequirements mem_reqs;
+    U_ASSERT_ONLY VkResult err;
+    U_ASSERT_ONLY bool pass;
+
+    /* create image */
+    err = vkCreateImage(vkctx.device, &image, NULL, &vkctx.depthBuffer.image);
+    assert(!err);
+
+    vkGetImageMemoryRequirements(vkctx.device, vkctx.depthBuffer.image,
+                                 &mem_reqs);
+
+    vkctx.depthBuffer.memAlloc.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
+    vkctx.depthBuffer.memAlloc.pNext = NULL;
+    vkctx.depthBuffer.memAlloc.allocationSize = mem_reqs.size;
+    vkctx.depthBuffer.memAlloc.memoryTypeIndex = 0;
+
+    pass = vkctx.getMemoryType(mem_reqs.memoryTypeBits,
+                               vk::MemoryPropertyFlagBits::eDeviceLocal,
+                               &vkctx.depthBuffer.memAlloc.memoryTypeIndex);
+    assert(pass);
+
+    /* allocate memory */
+    err = vkAllocateMemory(vkctx.device, &vkctx.depthBuffer.memAlloc, NULL,
+                           &vkctx.depthBuffer.mem);
+    assert(!err);
+
+    /* bind memory */
+    err =
+        vkBindImageMemory(vkctx.device, vkctx.depthBuffer.image,
+                          vkctx.depthBuffer.mem, 0);
+    assert(!err);
+
+    setImageLayout(vkctx.depthBuffer.image,
+                   static_cast<VkImageAspectFlags>(aspectMask),
+                   VK_IMAGE_LAYOUT_UNDEFINED,
+                   VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
+                   (VkAccessFlags)0);
+
+    /* create image view */
+    view.image = vkctx.depthBuffer.image;
+    err = vkCreateImageView(vkctx.device, &view, NULL, &vkctx.depthBuffer.view);
+    assert(!err);
+
+    return true;
+} // prepareDepthBuffer
+
+
+bool
+VulkanAppSDL::preparePresentCommandBuffers()
+{
+    VkCommandBufferBeginInfo cmdBufferBeginInfo = {};
+    cmdBufferBeginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
+    cmdBufferBeginInfo.pNext = NULL;
+
+    for (uint32_t i = 0; i < vkctx.swapchain.imageCount; i++)
+    {
+        // Command buffer for post present barrier
+
+        // Insert a post present image barrier to transform the image back to a
+        // color attachment that our render pass can write to. We always use
+        // undefined image layout as the source as it doesn't actually matter
+        // what is done with the previous image contents
+
+        VK_CHECK_RESULT(vkBeginCommandBuffer(vkctx.postPresentCmdBuffers[i],
+                                             &cmdBufferBeginInfo));
+
+        VkImageMemoryBarrier postPresentBarrier = { };
+        postPresentBarrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
+        postPresentBarrier.pNext = NULL;
+        postPresentBarrier.srcAccessMask = 0;
+        postPresentBarrier.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
+        postPresentBarrier.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED;
+        postPresentBarrier.newLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
+        postPresentBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+        postPresentBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+        postPresentBarrier.subresourceRange =
+                                     { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 };
+        postPresentBarrier.image = vkctx.swapchain.buffers[i].image;
+
+        vkCmdPipelineBarrier(
+            vkctx.postPresentCmdBuffers[i],
+            VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
+            VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
+            0,
+            0, nullptr,
+            0, nullptr,
+            1, &postPresentBarrier);
+
+        VK_CHECK_RESULT(vkEndCommandBuffer(vkctx.postPresentCmdBuffers[i]));
+
+        // Command buffer for pre present barrier
+
+        // Submit a pre present image barrier to the queue.
+        // Transforms the (framebuffer) image layout from color attachment to
+        // present(khr) for presenting to the swap chain.
+
+        VK_CHECK_RESULT(vkBeginCommandBuffer(vkctx.prePresentCmdBuffers[i],
+                                             &cmdBufferBeginInfo));
+
+        VkImageMemoryBarrier prePresentBarrier = { };
+        prePresentBarrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
+        prePresentBarrier.pNext = NULL;
+        prePresentBarrier.srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
+        prePresentBarrier.dstAccessMask = VK_ACCESS_MEMORY_READ_BIT;
+        prePresentBarrier.oldLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
+        prePresentBarrier.newLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
+        prePresentBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+        prePresentBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+        prePresentBarrier.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 };
+        prePresentBarrier.image = vkctx.swapchain.buffers[i].image;
+
+        vkCmdPipelineBarrier(
+            vkctx.prePresentCmdBuffers[i],
+            VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
+            VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
+            0,
+            0, nullptr, // No memory barriers,
+            0, nullptr, // No buffer barriers,
+            1, &prePresentBarrier);
+
+        VK_CHECK_RESULT(vkEndCommandBuffer(vkctx.prePresentCmdBuffers[i]));
+    }
+    return true;
+}
+
+
+bool
+VulkanAppSDL::prepareDescriptorLayout()
+{
+    return true;
+}
+
+
+bool
+VulkanAppSDL::prepareRenderPass()
+{
+    VkAttachmentDescription attachments[2] = { };
+      attachments[0].format = vkctx.swapchain.colorFormat;
+      attachments[0].samples = VK_SAMPLE_COUNT_1_BIT;
+      attachments[0].loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
+      attachments[0].storeOp = VK_ATTACHMENT_STORE_OP_STORE;
+      attachments[0].stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
+      attachments[0].stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
+      attachments[0].initialLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
+      attachments[0].finalLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
+
+      attachments[1].format = vkctx.depthBuffer.format;
+      attachments[1].samples = VK_SAMPLE_COUNT_1_BIT;
+      attachments[1].loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
+      attachments[1].storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
+      attachments[1].stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
+      attachments[1].stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
+      attachments[1].initialLayout =
+                     VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
+      attachments[1].finalLayout =
+                     VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
+
+    const VkAttachmentReference color_reference = {
+        0,
+        VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
+    };
+    const VkAttachmentReference depth_reference = {
+        1,
+        VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
+    };
+    const VkSubpassDescription subpass = {
+        0,
+        VK_PIPELINE_BIND_POINT_GRAPHICS,
+        0,
+        NULL,
+        1,
+        &color_reference,
+        NULL,
+        &depth_reference,
+        0,
+        NULL,
+    };
+    const VkRenderPassCreateInfo rp_info = {
+        VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,
+        NULL,
+        0,
+        2,
+        attachments,
+        1,
+        &subpass,
+        0,
+        NULL,
+    };
+    U_ASSERT_ONLY VkResult err;
+
+    err = vkCreateRenderPass(vkctx.device, &rp_info, NULL, &vkctx.renderPass);
+    assert(!err);
+    return true;
+}
+
+
+bool
+VulkanAppSDL::createPipelineCache()
+{
+    VkPipelineCacheCreateInfo pipelineCacheCreateInfo = {};
+    pipelineCacheCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO;
+    VK_CHECK_RESULT(vkCreatePipelineCache(vkctx.device,
+                                          &pipelineCacheCreateInfo,
+                                          nullptr, &vkctx.pipelineCache));
+    return true;
+}
+
+
+bool
+VulkanAppSDL::preparePipeline()
+{
+    return true;
+}
+
+
+bool
+VulkanAppSDL::prepareDescriptorSet()
+{
+    return true;
+}
+
+
+bool
+VulkanAppSDL::prepareFramebuffers()
+{
+    VkImageView attachments[2];
+    attachments[1] = vkctx.depthBuffer.view;
+
+    const VkFramebufferCreateInfo fb_info = {
+        VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,
+        NULL,
+        0,
+        vkctx.renderPass,
+        2,
+        attachments,
+        w_width,
+        w_height,
+        1,
+    };
+    U_ASSERT_ONLY VkResult err;
+    uint32_t i;
+
+    vkctx.framebuffers.resize(vkctx.swapchain.imageCount);
+    for (i = 0; i < vkctx.framebuffers.size(); i++) {
+        attachments[0] = vkctx.swapchain.buffers[i].view;
+        err = vkCreateFramebuffer(vkctx.device, &fb_info, NULL,
+                                  &vkctx.framebuffers[i]);
+        assert(!err);
+    }
+    return true;
+}
+
+
+void
+VulkanAppSDL::flushInitialCommands()
+{
+    U_ASSERT_ONLY VkResult err;
+
+    if (setupCmdBuffer == VK_NULL_HANDLE)
+        return;
+
+    err = vkEndCommandBuffer(setupCmdBuffer);
+    assert(!err);
+
+    const VkCommandBuffer cmd_bufs[] = { setupCmdBuffer };
+    VkFence nullFence = VK_NULL_HANDLE;
+    VkSubmitInfo sInfo;
+    sInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
+    sInfo.pNext = NULL;
+    sInfo.waitSemaphoreCount = 0;
+    sInfo.pWaitSemaphores = NULL;
+    sInfo.pWaitDstStageMask = NULL;
+    sInfo.commandBufferCount = 1;
+    sInfo.pCommandBuffers = cmd_bufs;
+    sInfo.signalSemaphoreCount = 0;
+    sInfo.pSignalSemaphores = NULL;
+
+    err = vkQueueSubmit(vkctx.queue, 1, &sInfo, nullFence);
+    assert(!err);
+
+    err = vkQueueWaitIdle(vkctx.queue);
+    assert(!err);
+
+    vkFreeCommandBuffers(vkctx.device, vkctx.commandPool, 1, cmd_bufs);
+    setupCmdBuffer = VK_NULL_HANDLE;
+
+}
+
+
+//----------------------------------------------------------------------
+//  Window title and text overlay functions
+//----------------------------------------------------------------------
+
+
+void
+VulkanAppSDL::setWindowTitle()
+{
+    if (!enableTextOverlay) {
+        std::stringstream ss;
+        std::string wt;
+
+        ss << std::fixed << std::setprecision(2)
+           << lastFrameTime << "ms (" << fpsCounter.lastFPS << " fps)" << " ";
+        wt = ss.str();
+        wt += appTitle;
+        SDL_SetWindowTitle(pswMainWindow, wt.c_str());
+    } else {
+        SDL_SetWindowTitle(pswMainWindow, appTitle.c_str());
+    }
+}
+
+
+void
+VulkanAppSDL::prepareTextOverlay()
+{
+    if (enableTextOverlay) {
+        // Load the text rendering shaders
+        std::vector<VkPipelineShaderStageCreateInfo> shaderStages;
+        VkPipelineShaderStageCreateInfo shaderStage;
+        std::string filepath = getAssetPath() + "textoverlay.vert.spv";
+        shaderStage = static_cast<VkPipelineShaderStageCreateInfo>(vkctx.loadShader(filepath, vk::ShaderStageFlagBits::eVertex));
+        shaderStages.push_back(shaderStage);
+        shaderModules.push_back(shaderStage.module);
+        filepath = getAssetPath() + "textoverlay.frag.spv";
+        shaderStage = static_cast<VkPipelineShaderStageCreateInfo>(vkctx.loadShader(filepath, vk::ShaderStageFlagBits::eFragment));
+        shaderStages.push_back(shaderStage);
+        shaderModules.push_back(shaderStage.module);
+
+        textOverlay = new VulkanTextOverlay(
+            vkctx.gpu,
+            vkctx.device,
+            vkctx.queue,
+            vkctx.framebuffers,
+            vkctx.swapchain.colorFormat,
+            vkctx.depthBuffer.format,
+            &w_width,
+            &w_height,
+            shaderStages
+            );
+        updateTextOverlay();
+    }
+}
+
+
+void VulkanAppSDL::updateTextOverlay()
+{
+    if (!enableTextOverlay)
+        return;
+
+    textOverlay->beginTextUpdate();
+
+    textOverlay->addText(appTitle, 5.0f, 5.0f, VulkanTextOverlay::alignLeft);
+
+    std::stringstream ss;
+    ss << std::fixed << std::setprecision(2)
+       << lastFrameTime << "ms (" << fpsCounter.lastFPS << " fps)";
+    textOverlay->addText(ss.str(), 5.0f, 25.0f, VulkanTextOverlay::alignLeft);
+
+    // Cast is a workaround for a change in Vulkan SDK 1.2.141 to the
+    // declaration of deviceName in PhysicalDeviceProperties from a char
+    // array to use an Array1D template.
+    textOverlay->addText((char*)vkctx.gpuProperties.deviceName, 5.0f, 45.0f,
+                         VulkanTextOverlay::alignLeft);
+
+    // Leave a blank line between us and the derived class's text.
+    getOverlayText(85.0f);
+
+    textOverlay->endTextUpdate();
+}
+
+
+void VulkanAppSDL::getOverlayText(float /*yOffset*/)
+{
+    // Can be overriden in derived class
+}
+
+
+//----------------------------------------------------------------------
+//  Utility functions
+//----------------------------------------------------------------------
+
+// @brief Find suitable depth format to use.
+//
+// All depth formats are optional. This finds a supported format with at
+// least the required number of bits and without stencil, if possible and
+// not required.
+bool
+VulkanAppSDL::getSupportedDepthFormat(vk::PhysicalDevice gpu,
+                                      stencilRequirement requiredStencil,
+                                      depthRequirement requiredDepth,
+                                      vk::ImageTiling tiling,
+                                      vk::Format& depthFormat,
+                                      vk::ImageAspectFlags& aspectMask)
+{
+    struct depthFormatDescriptor {
+        stencilRequirement stencil;
+        depthRequirement depth;
+        vk::Format vkformat;
+    };
+    std::vector<depthFormatDescriptor> depthFormats = {
+      { eNoStencil, e16bits, vk::Format::eD16Unorm },
+      { eStencil, e16bits, vk::Format::eD16UnormS8Uint },
+      { eStencil, e24bits, vk::Format::eD24UnormS8Uint },
+      { eNoStencil, e32bits, vk::Format::eD32Sfloat },
+      { eStencil, e32bits, vk::Format::eD32SfloatS8Uint }
+    };
+
+    for (auto& format : depthFormats)
+    {
+        if (format.depth >= requiredDepth
+            && format.stencil >= requiredStencil) {
+            vk::FormatProperties formatProps;
+            gpu.getFormatProperties(format.vkformat, &formatProps);
+            // Format must support depth stencil attachment for tiling
+            vk::FormatFeatureFlags features;
+            if (tiling == vk::ImageTiling::eOptimal)
+                features = formatProps.optimalTilingFeatures;
+            else
+                features = formatProps.linearTilingFeatures;
+            if (features & vk::FormatFeatureFlagBits::eDepthStencilAttachment) {
+                depthFormat = format.vkformat;
+                if (format.stencil == eStencil)
+                    aspectMask = vk::ImageAspectFlagBits::eDepth | vk::ImageAspectFlagBits::eStencil;
+                else
+                    aspectMask = vk::ImageAspectFlagBits::eDepth;
+                return true;
+            }
+        }
+    }
+    (void)SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, szName,
+            "The VkPhysicalDevice does not support a suitable depth buffer.",
+                                   NULL);
+    return false;
+}
+
+void
+VulkanAppSDL::setImageLayout(VkImage image, VkImageAspectFlags aspectMask,
+        VkImageLayout old_image_layout,
+        VkImageLayout new_image_layout,
+        VkImageAspectFlags srcAccessMask)
+{
+    U_ASSERT_ONLY VkResult err;
+
+    if (setupCmdBuffer == VK_NULL_HANDLE) {
+        const VkCommandBufferAllocateInfo cbaInfo = {
+            VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
+            NULL,
+            vkctx.commandPool,
+            VK_COMMAND_BUFFER_LEVEL_PRIMARY,
+            1,
+        };
+
+        err = vkAllocateCommandBuffers(vkctx.device, &cbaInfo,
+                                       &setupCmdBuffer);
+        assert(!err);
+
+        VkCommandBufferInheritanceInfo cmdBufHInfo = { };
+        cmdBufHInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO;
+        cmdBufHInfo.pNext = NULL;
+        cmdBufHInfo.renderPass = VK_NULL_HANDLE;
+        cmdBufHInfo.subpass = 0;
+        cmdBufHInfo.framebuffer = VK_NULL_HANDLE;
+        cmdBufHInfo.occlusionQueryEnable = VK_FALSE;
+        cmdBufHInfo.queryFlags = 0;
+        cmdBufHInfo.pipelineStatistics = 0;
+
+        VkCommandBufferBeginInfo cmdBufInfo = { };
+        cmdBufInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
+        cmdBufInfo.pNext = NULL;
+        cmdBufInfo.flags = 0;
+        cmdBufInfo.pInheritanceInfo = &cmdBufHInfo;
+
+        err = vkBeginCommandBuffer(setupCmdBuffer, &cmdBufInfo);
+        assert(!err);
+    }
+
+    VkImageMemoryBarrier imageMemoryBarrier = { };
+    imageMemoryBarrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
+    imageMemoryBarrier.pNext = NULL;
+    imageMemoryBarrier.srcAccessMask = srcAccessMask;
+    imageMemoryBarrier.dstAccessMask = 0;
+    imageMemoryBarrier.oldLayout = old_image_layout;
+    imageMemoryBarrier.newLayout = new_image_layout;
+    imageMemoryBarrier.image = image;
+    imageMemoryBarrier.subresourceRange.aspectMask = aspectMask;
+    imageMemoryBarrier.subresourceRange.baseMipLevel = 0;
+    imageMemoryBarrier.subresourceRange.levelCount = 1;
+    imageMemoryBarrier.subresourceRange.baseArrayLayer = 0;
+    imageMemoryBarrier.subresourceRange.layerCount = 1;
+
+    if (new_image_layout == VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL) {
+        /* Make sure anything that was copying from this image has completed */
+        imageMemoryBarrier.dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
+    }
+
+    if (new_image_layout == VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL) {
+        imageMemoryBarrier.dstAccessMask =
+            VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
+    }
+
+    if (new_image_layout == VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL) {
+        imageMemoryBarrier.dstAccessMask =
+            VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
+    }
+
+    if (new_image_layout == VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL) {
+        /* Make sure any Copy or CPU writes to image are flushed */
+        imageMemoryBarrier.dstAccessMask =
+            VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_INPUT_ATTACHMENT_READ_BIT;
+    }
+
+    VkPipelineStageFlags src_stages = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
+    VkPipelineStageFlags dest_stages = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
+
+    vkCmdPipelineBarrier(setupCmdBuffer, src_stages, dest_stages, 0, 0,
+                         NULL, 0, NULL, 1, &imageMemoryBarrier);
+} // setImageLayout
+
+
+/*
+ * @internal
+ * @~English
+ * @brief Check if all layer names specified in @p names can be
+ *        found in the given layer properties.
+ *
+ * @return true if all layer names can be found, false otherwise.
+ */
+bool
+VulkanAppSDL::checkLayers(uint32_t nameCount, const char **names,
+                      uint32_t layerCount,
+                      VkLayerProperties *layers)
+{
+    for (uint32_t i = 0; i < nameCount; i++) {
+        bool found = 0;
+        for (uint32_t j = 0; j < layerCount; j++) {
+            if (!strcmp(names[i], layers[j].layerName)) {
+                found = 1;
+                break;
+            }
+        }
+        if (!found) {
+            fprintf(stderr, "Cannot find layer: %s\n", names[i]);
+            return 0;
+        }
+    }
+    return 1;
+}
+
+
+VKAPI_ATTR VkBool32 VKAPI_CALL
+VulkanAppSDL::debugFunc(VkDebugReportFlagsEXT msgFlags,
+                    VkDebugReportObjectTypeEXT objType,
+                    uint64_t srcObject, size_t location, int32_t msgCode,
+                    const char *pLayerPrefix, const char *pMsg,
+                    void *pUserData)
+{
+    VulkanAppSDL* app = (VulkanAppSDL*)pUserData;
+    return app->debugFunc(msgFlags, objType, srcObject, location, msgCode,
+                          pLayerPrefix, pMsg);
+}
+
+
+VKAPI_ATTR VkBool32 VKAPI_CALL
+VulkanAppSDL::debugFunc(VkDebugReportFlagsEXT msgFlags,
+                    VkDebugReportObjectTypeEXT /*objType*/,
+                    uint64_t /*srcObject*/, size_t /*location*/, int32_t msgCode,
+                    const char *pLayerPrefix, const char *pMsg)
+{
+
+    std::string title = szName;
+    std::string text(pMsg);
+    std::string prefix("");
+    std::stringstream message;
+    uint32_t mbFlags = SDL_MESSAGEBOX_INFORMATION;
+
+    // Errors may cause undefined behaviour or a crash.
+    if (msgFlags & VK_DEBUG_REPORT_ERROR_BIT_EXT) {
+        mbFlags = SDL_MESSAGEBOX_ERROR;
+        prefix += "ERROR:";
+    }
+    // Warnings indicate use of Vulkan that may expose an app bug
+    if (msgFlags & VK_DEBUG_REPORT_WARNING_BIT_EXT) {
+        // We know that we're submitting queues without fences, ignore this
+        // warning
+        // XXX Check this
+        if (strstr(pMsg,
+                   "vkQueueSubmit parameter, VkFence fence, is null pointer")) {
+            return false;
+        }
+        mbFlags = SDL_MESSAGEBOX_WARNING;
+        prefix += "WARNING:";
+    }
+    // Performance warnings indicate sub-optimal usage of the API
+    if (msgFlags & VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT)
+    {
+        mbFlags = SDL_MESSAGEBOX_WARNING;
+        prefix += "PERFORMANCE:";
+    };
+    // Information that may be handy during debugging.
+    if (msgFlags & VK_DEBUG_REPORT_INFORMATION_BIT_EXT)
+    {
+        mbFlags = SDL_MESSAGEBOX_INFORMATION;
+        prefix += "INFO:";
+    }
+    // Diagnostic info from the Vulkan loader and layers.
+#if 0
+    // Usually not helpful in terms of API usage, but may help to debug layer
+    // and loader problems
+    if (msgFlags & VK_DEBUG_REPORT_DEBUG_BIT_EXT)
+    {
+        mbFlags = SDL_MESSAGEBOX_INFORMATION;
+        prefix += "DEBUG:";
+    }
+#endif
+    message << prefix << " [" << pLayerPrefix << "] Code "
+            << std::showbase << std::internal << std::setfill('0') << std::hex
+            << std::setw(8) << msgCode << ": " << std::endl << text;
+
+    title += " Debug Report";
+    if (showDebugReport(mbFlags, title, message.str(), prepared)) {
+        SDL_Event sdlevent;
+        sdlevent.type = SDL_EVENT_QUIT;
+        sdlevent.quit.timestamp = SDL_GetTicks();
+
+        (void)SDL_PushEvent(&sdlevent);
+    }
+
+    /*
+     * false indicates that layer should not bail-out of an
+     * API call that had validation failures. This may mean that the
+     * app dies inside the driver due to invalid parameter(s).
+     * That's what would happen without validation layers, so we'll
+     * keep that behavior here.
+     */
+    return false;
+}
+
+
+std::string&
+VulkanAppSDL::wrapText(std::string& source, size_t width,
+                       const std::string& whitespace)
+{
+    if (source.length() <= width)
+        return source;
+
+    // Find the longest "word" and possibly set @a width to that. The
+    // message box width is set from the longest line and many of
+    // the debug messages contain a long URL reference which could
+    // easily be wider than @a width.
+    size_t ws = source.find_first_not_of(whitespace);
+    size_t we = 0;
+    size_t maxWordLength = 0;
+    for (; ws < source.length(); ws = we + 1) {
+        size_t wl;
+        we = source.find_first_of(whitespace, ws);
+        if (we == std::string::npos) we = source.length();
+        wl = we - ws;
+        if (wl > maxWordLength) maxWordLength = wl;
+    }
+    if (maxWordLength > width)
+        width = maxWordLength;
+
+    // If the string is one long word, nothing further to do.
+    if (source.length() == width)
+        return source;
+
+    size_t  endPos = width, startPos = 0;
+    while (startPos < source.length())
+    {
+        size_t  breakPos, sizeToElim;
+
+        endPos = source.find_last_of(whitespace, endPos);
+        if (endPos == std::string::npos)
+            break;
+        if (endPos > startPos) {
+            breakPos = source.find_last_not_of(whitespace, endPos) + 1;
+            if (breakPos == std::string::npos)
+                break;
+            endPos = source.find_first_not_of(whitespace, ++endPos);
+            sizeToElim = endPos - breakPos;
+            source.replace( breakPos, sizeToElim , "\n");
+            startPos = endPos;
+        } else { // have to tolerate a long line
+            startPos += width;
+        }
+        endPos += width;
+    }
+    return source;
+}
+
+
+uint32_t
+VulkanAppSDL::showDebugReport(uint32_t mbFlags, const std::string title,
+                              std::string message, bool enableAbort)
+{
+    const SDL_MessageBoxButtonData buttons[] = {
+        /* .flags, .buttonid, .text */
+        { SDL_MESSAGEBOX_BUTTON_RETURNKEY_DEFAULT, 0, "Continue" },
+        { SDL_MESSAGEBOX_BUTTON_ESCAPEKEY_DEFAULT, 1, "Abort" },
+    };
+#if 0
+    const SDL_MessageBoxColorScheme colorScheme = {
+        { /* .colors (.r, .g, .b) */
+            /* [SDL_MESSAGEBOX_COLOR_BACKGROUND] */
+            { 255,   0,   0 },
+            /* [SDL_MESSAGEBOX_COLOR_TEXT] */
+            {   0, 255,   0 },
+            /* [SDL_MESSAGEBOX_COLOR_BUTTON_BORDER] */
+            { 255, 255,   0 },
+            /* [SDL_MESSAGEBOX_COLOR_BUTTON_BACKGROUND] */
+            {   0,   0, 255 },
+            /* [SDL_MESSAGEBOX_COLOR_BUTTON_SELECTED] */
+            { 255,   0, 255 }
+        }
+    };
+#endif
+    wrapText(message, 70, " \t\r");
+    const SDL_MessageBoxData messageboxdata = {
+        mbFlags,                                            // .flags
+        NULL,                                               // .window
+        title.c_str(),                                      // .title
+        message.c_str(),                                    // .message
+        (int)(enableAbort ? SDL_arraysize(buttons) : 1),    // .numbuttons
+        buttons,                                            // .buttons
+        NULL //&colorScheme                                     // .colorScheme
+    };
+    int buttonid;
+    if (!SDL_ShowMessageBox(&messageboxdata, &buttonid)) {
+        SDL_Log("error displaying message box");
+    }
+    if (buttonid == -1) {
+        SDL_Log("no selection");
+        return 0;
+    } else {
+        return buttonid;
+    }
+}
+
+#if SDL_PLATFORM_WINDOWS
+    // Windows specific code to use icon in module
+    #define WIN32_LEAN_AND_MEAN
+    #include <Windows.h>
+void setWindowsIcon(SDL_Window *sdlWindow) {
+    HINSTANCE handle = ::GetModuleHandle(nullptr);
+    // Identify icon by name rather than IDI_ macro to avoid having to
+    // include application's resource.h.
+    HICON icon = ::LoadIcon(handle, "MAIN_ICON");  // MAKEINTRESOURCE(IDI_ICON1));
+    if (icon != nullptr) {
+        HWND hwnd = (HWND)SDL_GetPointerProperty(SDL_GetWindowProperties(sdlWindow),
+                                                 SDL_PROP_WINDOW_WIN32_HWND_POINTER, NULL);
+        if (hwnd) {
+            ::SetClassLongPtr(hwnd, GCLP_HICON, reinterpret_cast<LONG_PTR>(icon));
+        }
+    }
+}
+#endif
+

third_party/ktx-src/tests/loadtests/appfwSDL/VulkanAppSDL/VulkanAppSDL.h

@@ -0,0 +1,172 @@
+/* -*- tab-width: 4; -*- */
+/* vi: set sw=2 ts=4 expandtab: */
+
+#ifndef VULKAN_APP_SDL_H_1456211188
+#define VULKAN_APP_SDL_H_1456211188
+
+/*
+ * Copyright 2017-2020 Mark Callow.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <array>
+#include <cstring>
+#include <new>
+#include <vector>
+#define VK_ENABLE_BETA_EXTENSIONS 1
+#include <vulkan/vulkan.hpp>
+#include <SDL3/SDL_vulkan.h> // Must be after vulkan.hpp.
+
+#include "AppBaseSDL.h"
+#include "VulkanContext.h"
+#include "VulkanSwapchain.h"
+#include "vulkantextoverlay.hpp"
+#include "unused.h"
+
+class VulkanAppSDL : public AppBaseSDL {
+  public:
+    VulkanAppSDL(const char* const name,
+             int width, int height,
+             const uint32_t version,
+             bool enableTextOverlay)
+            : AppBaseSDL(name), w_width(width), w_height(height),
+              subOptimalPresentWarned(false), validate(false),
+              vkVersion(version),
+              enableTextOverlay(enableTextOverlay),
+              textOverlay(nullptr)
+    {
+        // The overridden new below will zero the storage. Thus
+        // we avoid a long list of initializers.
+        appTitle = name;
+    };
+    virtual ~VulkanAppSDL();
+    virtual bool doEvent(SDL_Event* event);
+    virtual void drawFrame(uint32_t msTicks);
+    virtual void finalize();
+    virtual bool initialize(Args& args);
+    virtual void onFPSUpdate();
+    virtual void resizeWindow(int width, int height);
+    virtual void windowResized();
+
+    static void* operator new(size_t size) {
+        void* storage = ::operator new(size);
+        memset(storage, 0, size);
+        return storage;
+    }
+
+    static void operator delete(void* storage, size_t) {
+        ::operator delete(storage);
+    }
+
+    void updateTextOverlay();
+
+    // Called when the text overlay is updating
+    // Can be overridden in derived class to add custom text to the overlay
+    virtual void getOverlayText(float yOffset);
+
+  protected:
+    bool createDevice();
+    bool createInstance();
+    bool createPipelineCache();
+    bool createSemaphores();
+    bool createSurface();
+    bool createSwapchain();
+    bool findGpu();
+    void flushInitialCommands();
+    bool initializeVulkan();
+    bool prepareColorBuffers();
+    bool prepareCommandBuffers();
+    bool prepareDepthBuffer();
+    bool prepareDescriptorLayout();
+    void prepareFrame();
+    bool preparePresentCommandBuffers();
+    bool prepareRenderPass();
+    bool preparePipeline();
+    bool prepareDescriptorSet();
+    bool prepareFramebuffers();
+    void prepareTextOverlay();
+    void submitFrame();
+
+    bool setupDebugReporting();
+
+    enum stencilRequirement { eNoStencil = 0, eStencil = 1 };
+    enum depthRequirement { e16bits = 0, e24bits = 1, e32bits = 2 };
+    bool getSupportedDepthFormat(vk::PhysicalDevice gpu,
+                                 stencilRequirement requiredStencil,
+                                 depthRequirement requiredDepth,
+                                 vk::ImageTiling tiling,
+                                 vk::Format& pFormat,
+                                 vk::ImageAspectFlags& pAspectMask);
+
+    // Sets text on window title bar.
+    void setWindowTitle();
+
+    void setImageLayout(VkImage image, VkImageAspectFlags aspectMask,
+                        VkImageLayout old_image_layout,
+                        VkImageLayout new_image_layout,
+                        VkAccessFlags srcAccessMask);
+
+    VKAPI_ATTR VkBool32 VKAPI_CALL
+    debugFunc(VkFlags msgFlags, VkDebugReportObjectTypeEXT objType,
+              uint64_t srcObject, size_t location, int32_t msgCode,
+              const char *pLayerPrefix, const char *pMsg);
+    std::string& wrapText(std::string& source, size_t width = 70,
+                          const std::string& whitespace = " \t\r");
+    uint32_t showDebugReport(uint32_t mbFlags, const std::string title,
+                             std::string message, bool enableAbort);
+
+    static bool checkLayers(uint32_t nameCount, const char **names,
+                            uint32_t layerCount, VkLayerProperties *layers);
+    static VKAPI_ATTR VkBool32 VKAPI_CALL
+    debugFunc(VkFlags msgFlags, VkDebugReportObjectTypeEXT objType,
+              uint64_t srcObject, size_t location, int32_t msgCode,
+              const char *pLayerPrefix, const char *pMsg, void *pUserData);
+
+    bool prepared = false;
+    // Set true if want presents v-sync'ed.
+    bool enableVSync = false;
+
+    uint32_t w_width;
+    uint32_t w_height;
+
+    bool subOptimalPresentWarned;
+    bool validate;
+
+    std::vector<const char*> extensionNames;
+    std::vector<const char*> deviceValidationLayers;
+
+    VkCommandBuffer setupCmdBuffer;
+    VkSurfaceKHR vsSurface;
+
+    VulkanContext vkctx;
+
+    // Index of active framebuffer.
+    uint32_t currentBuffer;
+
+    // Synchronization semaphores
+    struct {
+        // Swap chain image presentation
+        VkSemaphore presentComplete;
+        // Command buffer submission and execution
+        VkSemaphore renderComplete;
+        // Text overlay submission and execution
+        VkSemaphore textOverlayComplete;
+    } semaphores;
+
+    const uint32_t vkVersion;
+
+    // Saved for clean-up
+    std::vector<vk::ShaderModule> shaderModules;
+
+    bool enableTextOverlay = false;
+    VulkanTextOverlay *textOverlay;
+    // List of shader modules created (stored for cleanup)
+
+    VkDebugReportCallbackEXT msgCallback;
+
+    PFN_vkCreateDebugReportCallbackEXT pfnCreateDebugReportCallbackEXT;
+    PFN_vkDestroyDebugReportCallbackEXT pfnDestroyDebugReportCallbackEXT;
+    PFN_vkDebugReportMessageEXT pfnDebugReportMessageEXT;
+};
+
+#endif /* VULKAN_APP_SDL_H_1456211188 */

third_party/ktx-src/tests/loadtests/appfwSDL/VulkanAppSDL/VulkanContext.cpp

@@ -0,0 +1,363 @@
+/* -*- tab-width: 4; -*- */
+/* vi: set sw=2 ts=4 expandtab: */
+
+/*
+ * Copyright 2017-2020 Mark Callow.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+
+/**
+ * @internal
+ * @class VulkanContext
+ * @~English
+ *
+ * @brief Class for holding and passing Vulkan context info to applications.
+ *
+ * @author Mark Callow, github.com/MarkCallow.
+ */
+
+#include <exception>
+#include <iomanip>
+#include <sstream>
+#include <SDL3/SDL_iostream.h>
+#include "VulkanContext.h"
+// Until exceptions are used everywhere...
+#include "vulkancheckres.h"
+#include "ltexceptions.h"
+#include "unused.h"
+
+vk::CommandBuffer
+VulkanContext::createCommandBuffer(vk::CommandBufferLevel level, bool begin)
+{
+    vk::CommandBuffer cmdBuffer;
+
+    vk::CommandBufferAllocateInfo cmdBufAllocateInfo(
+            commandPool,
+            level,
+            1);
+
+    vk::Result res
+      = device.allocateCommandBuffers(&cmdBufAllocateInfo, &cmdBuffer);
+
+    if (res != vk::Result::eSuccess) {
+        throw bad_vulkan_alloc((int)res, "device.allocateCommandBuffers");
+    }
+
+    // If requested, also start the new command buffer
+    if (begin)
+    {
+        vk::CommandBufferBeginInfo cmdBufInfo;
+        res = cmdBuffer.begin(&cmdBufInfo);
+        if (res != vk::Result::eSuccess) {
+            throw bad_vulkan_alloc((int)res, "cmdBuffer.begin");
+        }
+    }
+
+    return cmdBuffer;
+}
+
+
+void
+VulkanContext::flushCommandBuffer(vk::CommandBuffer& cmdBuffer,
+                                  bool free)
+{
+    if (!cmdBuffer) {
+        return;
+    }
+
+    cmdBuffer.end();
+
+    vk::SubmitInfo submitInfo;
+    submitInfo.commandBufferCount = 1;
+    submitInfo.pCommandBuffers = &cmdBuffer;
+
+    vk::Result res = queue.submit(1, &submitInfo, nullptr);
+    if (res != vk::Result::eSuccess) {
+        if (res == vk::Result::eErrorDeviceLost) {
+            throw std::runtime_error("Vulkan device lost.");
+        } else {
+            throw bad_vulkan_alloc((int)res, "queue.submit");
+        }
+    }
+
+    queue.waitIdle();
+
+    if (free) {
+        device.freeCommandBuffers(commandPool, 1, &cmdBuffer);
+    }
+}
+
+bool
+VulkanContext::createDrawCommandBuffers()
+{
+    VkCommandBufferAllocateInfo aInfo;
+    aInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
+    aInfo.pNext = NULL;
+    aInfo.commandPool = commandPool;
+    aInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
+    aInfo.commandBufferCount = 1;
+
+    drawCmdBuffers.resize(swapchain.imageCount);
+    for (uint32_t i = 0; i < swapchain.imageCount; i++) {
+        VK_CHECK_RESULT(vkAllocateCommandBuffers(device, &aInfo,
+                        &drawCmdBuffers[i]));
+    }
+    return true;
+}
+
+bool
+VulkanContext::createPresentCommandBuffers()
+{
+    VkCommandBufferAllocateInfo aInfo;
+    aInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
+    aInfo.pNext = NULL;
+    aInfo.commandPool = commandPool;
+    aInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
+    aInfo.commandBufferCount = 1;
+
+    prePresentCmdBuffers.resize(swapchain.imageCount);
+    postPresentCmdBuffers.resize(swapchain.imageCount);
+    for (uint32_t i = 0; i < swapchain.imageCount; i++) {
+        VK_CHECK_RESULT(vkAllocateCommandBuffers(device, &aInfo,
+                        &prePresentCmdBuffers[i]));
+        VK_CHECK_RESULT(vkAllocateCommandBuffers(device, &aInfo,
+                        &postPresentCmdBuffers[i]));
+    }
+    return true;
+}
+
+void
+VulkanContext::destroyDrawCommandBuffers()
+{
+    if (drawCmdBuffers.size() > 0) {
+        vkFreeCommandBuffers(device, commandPool,
+                        static_cast<uint32_t>(drawCmdBuffers.size()),
+                        drawCmdBuffers.data());
+    }
+    for (uint32_t i = 0; i < drawCmdBuffers.size(); ++i) {
+        drawCmdBuffers[i] = nullptr;
+    }
+
+}
+
+void
+VulkanContext::destroyPresentCommandBuffers()
+{
+    vkFreeCommandBuffers(device, commandPool,
+                    static_cast<uint32_t>(drawCmdBuffers.size()),
+                    prePresentCmdBuffers.data());
+    vkFreeCommandBuffers(device, commandPool,
+                    static_cast<uint32_t>(drawCmdBuffers.size()),
+                    postPresentCmdBuffers.data());
+}
+
+bool
+VulkanContext::checkDrawCommandBuffers()
+{
+    for (auto& cmdBuffer : drawCmdBuffers)
+    {
+        if (cmdBuffer == VK_NULL_HANDLE)
+        {
+            return false;
+        }
+    }
+    return true;
+}
+
+bool
+VulkanContext::createBuffer(vk::BufferUsageFlags usageFlags,
+                            vk::MemoryPropertyFlags memoryPropertyFlags,
+                            vk::DeviceSize size,
+                            void * data,
+                            vk::Buffer* buffer,
+                            vk::DeviceMemory* memory)
+{
+    vk::MemoryRequirements memReqs;
+    vk::MemoryAllocateInfo memAlloc(0, 0);
+    vk::BufferCreateInfo bufferCreateInfo({}, size, usageFlags);
+
+    vk::Result res = device.createBuffer(&bufferCreateInfo, nullptr, buffer);
+    if (res != vk::Result::eSuccess) {
+        return false;
+    }
+
+    device.getBufferMemoryRequirements(*buffer, &memReqs);
+    memAlloc.allocationSize = memReqs.size;
+    memAlloc.memoryTypeIndex = getMemoryType(memReqs.memoryTypeBits,
+                                             memoryPropertyFlags);
+    res = device.allocateMemory(&memAlloc, nullptr, memory);
+    if (res == vk::Result::eSuccess) {
+        if (data != nullptr)
+        {
+            void *mapped;
+            mapped = device.mapMemory(*memory, 0, size, {});
+            memcpy(mapped, data, (size_t)size);
+            device.unmapMemory(*memory);
+        }
+        device.bindBufferMemory(*buffer, *memory, 0);
+
+        return true;
+    } else
+        return false;
+}
+
+bool
+VulkanContext::createBuffer(vk::BufferUsageFlags usage,
+                            vk::DeviceSize size,
+                            void* data,
+                            vk::Buffer* buffer,
+                            vk::DeviceMemory* memory)
+{
+    return createBuffer(usage, vk::MemoryPropertyFlagBits::eHostVisible,
+                        size, data, buffer, memory);
+}
+
+bool
+VulkanContext::createBuffer(vk::BufferUsageFlags usage,
+                            vk::DeviceSize size,
+                            void* data,
+                            vk::Buffer* buffer,
+                            vk::DeviceMemory* memory,
+                            vk::DescriptorBufferInfo* descriptor)
+{
+    bool res = createBuffer(usage, size, data, buffer, memory);
+    if (res)
+    {
+        descriptor->offset = 0;
+        descriptor->buffer = *buffer;
+        descriptor->range = size;
+        return true;
+    }
+    else
+    {
+        return false;
+    }
+}
+
+bool
+VulkanContext::createBuffer(vk::BufferUsageFlags usage,
+                            vk::MemoryPropertyFlags memoryPropertyFlags,
+                            vk::DeviceSize size,
+                            void* data,
+                            vk::Buffer* buffer,
+                            vk::DeviceMemory* memory,
+                            vk::DescriptorBufferInfo* descriptor)
+{
+    bool res = createBuffer(usage, memoryPropertyFlags, size, data, buffer, memory);
+    if (res)
+    {
+        descriptor->offset = 0;
+        descriptor->buffer = *buffer;
+        descriptor->range = size;
+        return true;
+    }
+    else
+    {
+        return false;
+    }
+}
+
+bool
+VulkanContext::getMemoryType(uint32_t typeBits,
+                             vk::MemoryPropertyFlags requirementsMask,
+                             uint32_t *typeIndex) const
+{
+    // Search memtypes to find first index with desired properties
+    for (uint32_t i = 0; i < VK_MAX_MEMORY_TYPES; i++) {
+        if ((typeBits & 1) == 1) {
+            // Type is available, does it match user properties?
+            if ((memoryProperties.memoryTypes[i].propertyFlags &
+                 requirementsMask) == requirementsMask) {
+                *typeIndex = i;
+                return true;
+            }
+        }
+        typeBits >>= 1;
+    }
+    // No memory types matched, return failure
+    return false;
+}
+
+uint32_t
+VulkanContext::getMemoryType(uint32_t typeBits,
+                             vk::MemoryPropertyFlags requirementsMask) const
+{
+    // Search memtypes to find first index with desired properties
+    for (uint32_t i = 0; i < VK_MAX_MEMORY_TYPES; i++) {
+        if ((typeBits & 1) == 1) {
+            // Type is available, does it match user properties?
+            if ((memoryProperties.memoryTypes[i].propertyFlags &
+                 requirementsMask) == requirementsMask) {
+                return i;
+            }
+        }
+        typeBits >>= 1;
+    }
+    // No memory types matched, return failure
+    // TODO throw error
+    return 0;
+}
+
+vk::PipelineShaderStageCreateInfo
+VulkanContext::loadShader(std::string filename,
+                          vk::ShaderStageFlagBits stage,
+                          const char* const modname)
+{
+    vk::PipelineShaderStageCreateInfo shaderStage({}, stage);
+    shaderStage.module = loadShader(filename);
+    shaderStage.pName = modname;
+    return shaderStage;
+}
+
+vk::ShaderModule
+VulkanContext::loadShader(std::string filename)
+{
+    size_t codeSize;
+    uint32_t* shaderCode;
+
+    shaderCode = readSpv(filename.c_str(), &codeSize);
+
+    vk::ShaderModule shaderModule;
+    vk::ShaderModuleCreateInfo moduleCreateInfo({}, codeSize, shaderCode);
+
+    vk::Result res
+          = device.createShaderModule(&moduleCreateInfo, NULL, &shaderModule);
+    if (res != vk::Result::eSuccess) {
+        throw bad_vulkan_alloc((int)res, "device.createShaderModule");
+    }
+
+    delete[] shaderCode;
+
+    assert(shaderModule);
+    return shaderModule;
+}
+
+uint32_t*
+VulkanContext::readSpv(const char *filename, size_t *pSize) {
+    size_t size;
+    U_ASSERT_ONLY size_t retval;
+    uint32_t* shader_code;
+
+  SDL_IOStream* io = SDL_IOFromFile(filename, "rb");
+    if (!io) {
+        std::stringstream message;
+
+        // String returned by SDL_GetError() includes file name.
+        message << "Open of shader failed: " << SDL_GetError();
+        throw std::runtime_error(message.str());
+    }
+
+    size = (size_t)SDL_GetIOSize(io);
+
+    // Round-up to next 4-byte size.
+    shader_code = new uint32_t[(size + 3)/4];
+    retval = SDL_ReadIO(io, shader_code, size);
+    assert(retval == size);
+
+    *pSize = size;
+
+    SDL_CloseIO(io);
+    return shader_code;
+}
+

third_party/ktx-src/tests/loadtests/appfwSDL/VulkanAppSDL/VulkanContext.h

@@ -0,0 +1,134 @@
+/* -*- tab-width: 4; -*- */
+/* vi: set sw=2 ts=4 expandtab: */
+
+#ifndef VULKAN_TEXTURE_H_229895365400979164311947449304284143508
+#define VULKAN_TEXTURE_H_229895365400979164311947449304284143508
+
+/*
+ * Copyright 2017-2020 Mark Callow.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <vector>
+#define VK_ENABLE_BETA_EXTENSIONS 1
+#include <vulkan/vulkan.hpp>
+#include "VulkanSwapchain.h"
+
+struct VulkanDepthBuffer {
+    VkFormat format;
+    VkImage image;
+    VkMemoryAllocateInfo memAlloc;
+    VkDeviceMemory mem;
+    VkImageView view;
+};
+
+struct VulkanContext {
+    vk::Instance instance;
+    vk::PhysicalDevice gpu;
+    vk::PhysicalDeviceFeatures gpuFeatures;
+#if VK_KHR_portability_subset
+    vk::PhysicalDevicePortabilitySubsetFeaturesKHR gpuPortabilityFeatures;
+#endif
+    vk::PhysicalDeviceProperties gpuProperties;
+    vk::PhysicalDeviceMemoryProperties memoryProperties;
+    vk::Device device;
+    vk::CommandPool commandPool;
+    vk::Queue queue;
+
+    bool gpuIsPortabilitySubsetDevice = false;
+
+    struct {
+       bool pvrtc = false;
+       bool astc_hdr = false;
+       bool astc_3d = false;
+    } enabledDeviceExtensions;
+    std::vector<VkCommandBuffer> drawCmdBuffers;
+    std::vector<VkCommandBuffer> postPresentCmdBuffers;
+    std::vector<VkCommandBuffer> prePresentCmdBuffers;
+    VkRenderPass renderPass;
+    // Pipeline stage flags for the submit info structure
+    const VkPipelineStageFlags submitPipelineStages =
+                                      VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;
+    // Contains command buffers and semaphores to be presented to the queue
+    VkSubmitInfo drawCmdSubmitInfo;
+
+    vk::DescriptorPool descriptorPool;
+    VkPipelineCache pipelineCache;
+
+    VulkanSwapchain swapchain;
+    // List of frame buffers (same as number of swap chain images)
+    std::vector<VkFramebuffer>framebuffers;
+    VulkanDepthBuffer depthBuffer;
+
+    // Create a new command buffer, opening it for command entry,
+    // if requested.
+    vk::CommandBuffer createCommandBuffer(vk::CommandBufferLevel level,
+                                        bool begin);
+    // End a command buffer, submit it to the queue and free, if requested.
+    // Note : Waits for the queue to become idle
+    void flushCommandBuffer(vk::CommandBuffer& commandBuffer, bool free);
+
+    // Create a command buffer for each image in the swap chain.
+    bool createDrawCommandBuffers();
+    bool createPresentCommandBuffers();
+    bool checkDrawCommandBuffers();
+    void destroyDrawCommandBuffers();
+    void destroyPresentCommandBuffers();
+
+
+    bool getMemoryType(uint32_t typeBits,
+                       vk::MemoryPropertyFlags requirementsMask,
+                       uint32_t *typeIndex) const;
+    uint32_t getMemoryType(uint32_t typeBits,
+                           vk::MemoryPropertyFlags requirementsMask) const;
+
+    // Create a buffer, fill it with data (if != NULL) and bind buffer memory
+    bool createBuffer(
+        vk::BufferUsageFlags usageFlags,
+        vk::MemoryPropertyFlags memoryPropertyFlags,
+        vk::DeviceSize size,
+        void *data,
+        vk::Buffer *buffer,
+        vk::DeviceMemory *memory);
+    // This version always uses HOST_VISIBLE memory
+    bool createBuffer(
+        vk::BufferUsageFlags usage,
+        vk::DeviceSize size,
+        void *data,
+        vk::Buffer *buffer,
+        vk::DeviceMemory *memory);
+    // Overload that assigns buffer info to descriptor
+    bool createBuffer(
+        vk::BufferUsageFlags usage,
+        vk::DeviceSize size,
+        void* data,
+        vk::Buffer* buffer,
+        vk::DeviceMemory* memory,
+        vk::DescriptorBufferInfo* descriptor);
+    // Overload to pass memory property flags
+    bool createBuffer(
+        vk::BufferUsageFlags usage,
+        vk::MemoryPropertyFlags memoryPropertyFlags,
+        vk::DeviceSize size,
+        void* data,
+        vk::Buffer* buffer,
+        vk::DeviceMemory* memory,
+        vk::DescriptorBufferInfo* descriptor);
+
+    vk::PipelineShaderStageCreateInfo loadShader(std::string filename,
+                                            vk::ShaderStageFlagBits stage,
+                                            const char* const modname = "main");
+    vk::ShaderModule loadShader(std::string filename);
+    uint32_t* readSpv(const char *filename, size_t *pSize);
+
+    bool gpuSupportsSwizzle() {
+#if VK_KHR_portability_subset
+        return !gpuIsPortabilitySubsetDevice
+               || gpuPortabilityFeatures.imageViewFormatSwizzle;
+#else
+        return true;
+#endif
+    }
+};
+
+#endif /* VULKAN_TEXTURE_H_229895365400979164311947449304284143508 */

third_party/ktx-src/tests/loadtests/appfwSDL/VulkanAppSDL/VulkanSwapchain.cpp

@@ -0,0 +1,434 @@
+/* -*- tab-width: 4; -*- */
+/* vi: set sw=2 ts=4 expandtab: */
+
+/*
+ * Copyright 2017-2020 Mark Callow.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @internal
+ * @class VulkanSwapchain
+ * @~English
+ *
+ * @brief Manage the swapchain for a Vulkan app.
+ *
+ * A swap chain is a collection of image buffers used for rendering
+ * The images can then be presented to the windowing system for display.
+ *
+ * @author Mark Callow, github.com/MarkCallow.
+ */
+
+#include <stdlib.h>
+#include <string>
+#include <fstream>
+#include <assert.h>
+#include <stdio.h>
+#include <vector>
+#ifdef _WIN32
+#include <windows.h>
+#include <fcntl.h>
+#include <io.h>
+#else
+#endif
+
+#include "VulkanSwapchain.h"
+
+#include <SDL3/SDL.h>
+#include <SDL3/SDL_vulkan.h>
+#include "AppBaseSDL.h"
+#include "unused.h"
+
+#define ERROR_RETURN(msg)                                                     \
+      (void)SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, theApp->name(),    \
+                                     msg, NULL);                              \
+      return false;
+
+#define GET_INSTANCE_PROC_ADDR(inst, entrypoint)                              \
+  {                                                                           \
+    pfn##entrypoint =                                                         \
+        (PFN_vk##entrypoint)vkGetInstanceProcAddr(inst, "vk"#entrypoint);     \
+    if (pfn##entrypoint == NULL) {                                            \
+        ERROR_RETURN("vkGetInstanceProcAddr: unable to find vk"#entrypoint);  \
+    }                                                                         \
+  }
+
+#define GET_DEVICE_PROC_ADDR(device, entrypoint)                            \
+  {                                                                         \
+    pfn##entrypoint =                                                       \
+        (PFN_vk##entrypoint)vkGetDeviceProcAddr(device, "vk"#entrypoint);   \
+    if (pfn##entrypoint == NULL) {                                          \
+        ERROR_RETURN("vkGetDeviceProcAddr: unable to find vk"#entrypoint);  \
+    }                                                                       \
+  }
+
+// Creates an os specific surface
+// Tries to find a graphics and a present queue
+bool
+VulkanSwapchain::initSurface(SDL_Window* window)
+{
+    U_ASSERT_ONLY VkResult err;
+
+    if (!SDL_Vulkan_CreateSurface(window, instance, nullptr, &surface)) {
+        std::string msg = "SDL_CreateVulkanSurface failed: ";
+        msg += SDL_GetError();
+        ERROR_RETURN(msg.c_str());
+    }
+
+    // Get available queue family properties
+    uint32_t queueCount;
+    vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, &queueCount, NULL);
+    assert(queueCount >= 1);
+
+    std::vector<VkQueueFamilyProperties> queueProps(queueCount);
+    vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, &queueCount,
+                                             queueProps.data());
+
+    // Iterate over the queues looking for ones which support presenting.
+    std::vector<VkBool32> supportsPresent(queueCount);
+    for (uint32_t i = 0; i < queueCount; i++) {
+        vkGetPhysicalDeviceSurfaceSupportKHR(physicalDevice, i, surface,
+                                             &supportsPresent[i]);
+    }
+
+    // Search for a graphics- and present-capable queue.
+    uint32_t graphicsQueueIndex = UINT32_MAX;
+    uint32_t presentQueueIndex = UINT32_MAX;
+    for (uint32_t i = 0; i < queueCount; i++) {
+        if ((queueProps[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) != 0)
+        {
+            if (graphicsQueueIndex == UINT32_MAX)
+            {
+                graphicsQueueIndex = i;
+            }
+
+            if (supportsPresent[i] == VK_TRUE)
+            {
+                graphicsQueueIndex = i;
+                presentQueueIndex = i;
+                break;
+            }
+        }
+    }
+    if (presentQueueIndex == UINT32_MAX) {
+        // If there's no queue that supports both present and graphics
+        // try to find a separate present queue
+        for (uint32_t i = 0; i < queueCount; ++i)
+        {
+            if (supportsPresent[i] == VK_TRUE)
+            {
+                presentQueueIndex = i;
+                break;
+            }
+        }
+    }
+
+    // Exit if either a graphics or a presenting queue hasn't been found
+    if (graphicsQueueIndex == UINT32_MAX
+        || presentQueueIndex == UINT32_MAX)
+    {
+        ERROR_RETURN("Could not find a graphics or presenting queue!");
+    }
+
+    // TODO: Add support for separate graphics and presenting queue
+    if (graphicsQueueIndex != presentQueueIndex)
+    {
+        ERROR_RETURN("Separate graphics and present queues not yet supported!");
+    }
+
+    queueIndex = graphicsQueueIndex;
+
+    // Get list of supported surface formats
+    uint32_t formatCount;
+    err = vkGetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface,
+                                               &formatCount, NULL);
+    assert(err == VK_SUCCESS);
+    assert(formatCount > 0);
+
+    std::vector<VkSurfaceFormatKHR> surfaceFormats(formatCount);
+    err = vkGetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface,
+                                               &formatCount,
+                                               surfaceFormats.data());
+    assert(err == VK_SUCCESS);
+
+    // If the surface format list only includes one entry with
+    // VK_FORMAT_UNDEFINED, there is no preferred format.
+    // Assume VK_FORMAT_B8G8R8A8_RGB.
+    // TODO: Consider passing in desired format from app.
+    if ((formatCount == 1) && (surfaceFormats[0].format == VK_FORMAT_UNDEFINED))
+    {
+        colorFormat = VK_FORMAT_B8G8R8A8_SRGB;
+    }
+    else
+    {
+        assert(formatCount >= 1);
+        uint32_t i;
+        for (i = 0; i < formatCount; i++) {
+            if (surfaceFormats[i].format == VK_FORMAT_B8G8R8A8_SRGB) {
+                break;
+            }
+        }
+        if (i == formatCount) {
+            // Pick the first available, if no SRGB.
+            // FIXME probably should raise an error...
+            i = 0;
+        }
+        colorFormat = surfaceFormats[i].format;
+    }
+    colorSpace = surfaceFormats[0].colorSpace;
+    return true;
+}
+
+
+// Connect to the instance and device and get all required function pointers
+bool
+VulkanSwapchain::connectDevice(VkDevice targetDevice)
+{
+    this->device = targetDevice;
+#if USE_FUNCPTRS_FOR_KHR_EXTS
+    GET_DEVICE_PROC_ADDR(device, CreateSwapchainKHR);
+    GET_DEVICE_PROC_ADDR(device, DestroySwapchainKHR);
+    GET_DEVICE_PROC_ADDR(device, GetSwapchainImagesKHR);
+    GET_DEVICE_PROC_ADDR(device, AcquireNextImageKHR);
+    GET_DEVICE_PROC_ADDR(device, QueuePresentKHR);
+#endif
+    return true;
+}
+
+
+// Connect to the instance and device and get all required function pointers
+bool
+VulkanSwapchain::connectInstance(VkInstance targetInstance,
+                                 VkPhysicalDevice targetPhysicalDevice)
+{
+    this->instance = targetInstance;
+    this->physicalDevice = targetPhysicalDevice;
+#if USE_FUNCPTRS_FOR_KHR_EXTS
+    GET_INSTANCE_PROC_ADDR(instance, GetPhysicalDeviceSurfaceSupportKHR);
+    GET_INSTANCE_PROC_ADDR(instance, GetPhysicalDeviceSurfaceCapabilitiesKHR);
+    GET_INSTANCE_PROC_ADDR(instance, GetPhysicalDeviceSurfaceFormatsKHR);
+    GET_INSTANCE_PROC_ADDR(instance, GetPhysicalDeviceSurfacePresentModesKHR);
+#endif
+    return true;
+}
+
+
+// Create the swap chain and get images with given width and height
+void
+VulkanSwapchain::create(uint32_t *width, uint32_t *height,
+                        bool vsync)
+{
+    U_ASSERT_ONLY VkResult err;
+    VkSwapchainKHR oldSwapchain = swapchain;
+
+    // Get physical device surface properties and formats
+    VkSurfaceCapabilitiesKHR surfCaps;
+    err = vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface,
+                                                    &surfCaps);
+    assert(err == VK_SUCCESS);
+
+    // Get available present modes
+    uint32_t presentModeCount;
+    err = vkGetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface,
+                                                    &presentModeCount, NULL);
+    assert(err == VK_SUCCESS);
+    assert(presentModeCount > 0);
+
+    std::vector<VkPresentModeKHR> presentModes(presentModeCount);
+
+    err = vkGetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface,
+                                                    &presentModeCount,
+                                                    presentModes.data());
+    assert(err == VK_SUCCESS);
+
+    VkExtent2D swapchainExtent = {};
+    // width and height are either both 0xFFFFFFFF, or both not 0xFFFFFFFF.
+    if (surfCaps.currentExtent.width == UINT32_MAX)
+    {
+        // If the surface size is undefined, the size is set to
+        // the size of the images requested.
+        swapchainExtent.width = *width;
+        swapchainExtent.height = *height;
+    }
+    else
+    {
+        swapchainExtent = surfCaps.currentExtent;
+        *width = surfCaps.currentExtent.width;
+        *height = surfCaps.currentExtent.height;
+    }
+
+
+    // Select a present mode for the swapchain
+
+    // The VK_PRESENT_MODE_FIFO_KHR mode must always be present as per spec
+    // This mode waits for the vertical blank ("v-sync")
+    VkPresentModeKHR swapchainPresentMode = VK_PRESENT_MODE_FIFO_KHR;
+
+    // If v-sync is not requested, try to find a mailbox mode if present
+    // It's the lowest latency non-tearing present mode available
+    if (!vsync)
+    {
+        for (size_t i = 0; i < presentModeCount; i++)
+        {
+            if (presentModes[i] == VK_PRESENT_MODE_MAILBOX_KHR)
+            {
+                swapchainPresentMode = VK_PRESENT_MODE_MAILBOX_KHR;
+                break;
+            }
+            if ((swapchainPresentMode != VK_PRESENT_MODE_MAILBOX_KHR)
+                 && (presentModes[i] == VK_PRESENT_MODE_IMMEDIATE_KHR))
+            {
+                swapchainPresentMode = VK_PRESENT_MODE_IMMEDIATE_KHR;
+            }
+        }
+    }
+
+    // Determine the number of images
+    uint32_t desiredNumberOfSwapchainImages = surfCaps.minImageCount + 1;
+    if ((surfCaps.maxImageCount > 0)
+         && (desiredNumberOfSwapchainImages > surfCaps.maxImageCount))
+    {
+        desiredNumberOfSwapchainImages = surfCaps.maxImageCount;
+    }
+
+    VkSurfaceTransformFlagsKHR preTransform;
+    if (surfCaps.supportedTransforms & VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR) {
+        preTransform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
+    } else {
+        preTransform = surfCaps.currentTransform;
+    }
+
+    VkSwapchainCreateInfoKHR swapchainCI = {};
+    swapchainCI.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
+    swapchainCI.pNext = NULL;
+    swapchainCI.surface = surface;
+    swapchainCI.minImageCount = desiredNumberOfSwapchainImages;
+    swapchainCI.imageFormat = colorFormat;
+    swapchainCI.imageColorSpace = colorSpace;
+    swapchainCI.imageExtent = { swapchainExtent.width, swapchainExtent.height };
+    swapchainCI.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
+    swapchainCI.preTransform = (VkSurfaceTransformFlagBitsKHR)preTransform;
+    swapchainCI.imageArrayLayers = 1;
+    swapchainCI.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
+    swapchainCI.queueFamilyIndexCount = 0;
+    swapchainCI.pQueueFamilyIndices = NULL;
+    swapchainCI.presentMode = swapchainPresentMode;
+    swapchainCI.oldSwapchain = oldSwapchain;
+    swapchainCI.clipped = true;
+    swapchainCI.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
+
+    err = vkCreateSwapchainKHR(device, &swapchainCI, nullptr, &swapchain);
+    assert(err == VK_SUCCESS);
+
+    // If an existing swap chain is re-created, destroy the old swap chain
+    // This also cleans up all the presentable images
+    if (oldSwapchain != VK_NULL_HANDLE)
+    {
+        for (uint32_t i = 0; i < imageCount; i++)
+        {
+            vkDestroyImageView(device, buffers[i].view, nullptr);
+        }
+        vkDestroySwapchainKHR(device, oldSwapchain, nullptr);
+    }
+
+    err = vkGetSwapchainImagesKHR(device, swapchain, &imageCount, NULL);
+    assert(err == VK_SUCCESS);
+
+    // Get the swap chain images
+    images.resize(imageCount);
+    err = vkGetSwapchainImagesKHR(device, swapchain,
+                                  &imageCount, images.data());
+    assert(err == VK_SUCCESS);
+
+    // Get the swap chain buffers containing the image and imageview
+    buffers.resize(imageCount);
+    for (uint32_t i = 0; i < imageCount; i++)
+    {
+        VkImageViewCreateInfo colorAttachmentView = {};
+        colorAttachmentView.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
+        colorAttachmentView.pNext = NULL;
+        colorAttachmentView.format = colorFormat;
+        colorAttachmentView.components = {
+            VK_COMPONENT_SWIZZLE_IDENTITY,
+            VK_COMPONENT_SWIZZLE_IDENTITY,
+            VK_COMPONENT_SWIZZLE_IDENTITY,
+            VK_COMPONENT_SWIZZLE_IDENTITY
+        };
+        colorAttachmentView.subresourceRange.aspectMask
+                                                  = VK_IMAGE_ASPECT_COLOR_BIT;
+        colorAttachmentView.subresourceRange.baseMipLevel = 0;
+        colorAttachmentView.subresourceRange.levelCount = 1;
+        colorAttachmentView.subresourceRange.baseArrayLayer = 0;
+        colorAttachmentView.subresourceRange.layerCount = 1;
+        colorAttachmentView.viewType = VK_IMAGE_VIEW_TYPE_2D;
+        colorAttachmentView.flags = 0;
+
+        buffers[i].image = images[i];
+
+        colorAttachmentView.image = buffers[i].image;
+
+        err = vkCreateImageView(device, &colorAttachmentView, nullptr,
+                                &buffers[i].view);
+        assert(err == VK_SUCCESS);
+    }
+}
+
+
+// Acquires the next image in the swap chain
+VkResult
+VulkanSwapchain::acquireNextImage(VkSemaphore presentCompleteSemaphore,
+                                  uint32_t *currentBuffer)
+{
+    return vkAcquireNextImageKHR(device, swapchain, UINT64_MAX,
+                                 presentCompleteSemaphore,
+                                 (VkFence)nullptr,
+                                 currentBuffer);
+}
+
+
+// Present the current image to the queue
+VkResult
+VulkanSwapchain::queuePresent(VkQueue queue, uint32_t currentBuffer)
+{
+    VkPresentInfoKHR presentInfo = {};
+    presentInfo.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
+    presentInfo.pNext = NULL;
+    presentInfo.swapchainCount = 1;
+    presentInfo.pSwapchains = &swapchain;
+    presentInfo.pImageIndices = &currentBuffer;
+    return vkQueuePresentKHR(queue, &presentInfo);
+}
+
+
+// Present the current image to the queue when semaphore signaled.
+VkResult
+VulkanSwapchain::queuePresent(VkQueue queue, uint32_t currentBuffer,
+                              VkSemaphore waitSemaphore)
+{
+    VkPresentInfoKHR presentInfo = {};
+    presentInfo.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
+    presentInfo.pNext = NULL;
+    presentInfo.swapchainCount = 1;
+    presentInfo.pSwapchains = &swapchain;
+    presentInfo.pImageIndices = &currentBuffer;
+    if (waitSemaphore != VK_NULL_HANDLE)
+    {
+        presentInfo.pWaitSemaphores = &waitSemaphore;
+        presentInfo.waitSemaphoreCount = 1;
+    }
+    return vkQueuePresentKHR(queue, &presentInfo);
+}
+
+
+// Free all Vulkan resources used by the swap chain
+void
+VulkanSwapchain::cleanup()
+{
+    for (uint32_t i = 0; i < imageCount; i++)
+    {
+        vkDestroyImageView(device, buffers[i].view, nullptr);
+    }
+    vkDestroySwapchainKHR(device, swapchain, nullptr);
+    vkDestroySurfaceKHR(instance, surface, nullptr);
+}
+

third_party/ktx-src/tests/loadtests/appfwSDL/VulkanAppSDL/VulkanSwapchain.h

@@ -0,0 +1,105 @@
+/* -*- tab-width: 4; -*- */
+/* vi: set sw=2 ts=4 expandtab: */
+
+/*
+ * Copyright 2017-2020 Mark Callow.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#pragma once
+
+#include <vector>
+
+#include <vulkan/vulkan.h>
+
+#if !defined(USE_FUNCPTRS_FOR_KHR_EXTS)
+#define USE_FUNCPTRS_FOR_KHR_EXTS 0
+#endif
+
+typedef struct _SwapchainBuffers {
+    VkImage image;
+    VkImageView view;
+} SwapchainBuffer;
+
+class VulkanSwapchain
+{
+  public:
+    VkFormat colorFormat;
+    VkColorSpaceKHR colorSpace;
+
+    VkSwapchainKHR swapchain = VK_NULL_HANDLE;
+
+    uint32_t imageCount;
+    std::vector<VkImage> images;
+    std::vector<SwapchainBuffer> buffers;
+
+    // Index of the detected graphics- and present-capable device queue.
+    uint32_t queueIndex = UINT32_MAX;
+
+    // Creates an OS specific surface.
+    // Looks for a graphics and a present queue
+    bool initSurface(struct SDL_Window* window);
+
+    // Connect to device and get required device function pointers.
+    bool connectDevice(VkDevice device);
+
+    // Connect to instance and get required instance function pointers.
+    bool connectInstance(VkInstance instance,
+                         VkPhysicalDevice physicalDevice);
+
+    // Create the swap chain and get images with given width and height
+    void create(uint32_t *width, uint32_t *height,
+                bool vsync = false);
+
+    // Acquires the next image in the swap chain
+    VkResult acquireNextImage(VkSemaphore presentCompleteSemaphore,
+                              uint32_t *currentBuffer);
+
+    // Present the current image to the queue
+    VkResult queuePresent(VkQueue queue, uint32_t currentBuffer);
+
+    // Present the current image to the queue
+    VkResult queuePresent(VkQueue queue, uint32_t currentBuffer,
+                          VkSemaphore waitSemaphore);
+
+
+    // Free all Vulkan resources used by the swap chain
+    void cleanup();
+
+  private:
+    VkInstance instance;
+    VkDevice device;
+    VkPhysicalDevice physicalDevice;
+    VkSurfaceKHR surface;
+#if USE_FUNCPTRS_FOR_KHR_EXTS
+    PFN_vkGetPhysicalDeviceSurfaceSupportKHR
+        pfnGetPhysicalDeviceSurfaceSupportKHR;
+    PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR
+        pfnGetPhysicalDeviceSurfaceCapabilitiesKHR;
+    PFN_vkGetPhysicalDeviceSurfaceFormatsKHR
+        pfnGetPhysicalDeviceSurfaceFormatsKHR;
+    PFN_vkGetPhysicalDeviceSurfacePresentModesKHR
+        pfnGetPhysicalDeviceSurfacePresentModesKHR;
+
+    PFN_vkCreateSwapchainKHR pfnCreateSwapchainKHR;
+    PFN_vkDestroySwapchainKHR pfnDestroySwapchainKHR;
+    PFN_vkGetSwapchainImagesKHR pfnGetSwapchainImagesKHR;
+    PFN_vkAcquireNextImageKHR pfnAcquireNextImageKHR;
+    PFN_vkQueuePresentKHR pfnQueuePresentKHR;
+
+#define vkGetPhysicalDeviceSurfaceSupportKHR \
+            pfnGetPhysicalDeviceSurfaceSupportKHR
+#define vkGetPhysicalDeviceSurfaceCapabilitiesKHR \
+            pfnGetPhysicalDeviceSurfaceCapabilitiesKHR
+#define vkGetPhysicalDeviceSurfaceFormatsKHR \
+            pfnGetPhysicalDeviceSurfaceFormatsKHR
+#define vkGetPhysicalDeviceSurfacePresentModesKHR \
+            pfnGetPhysicalDeviceSurfacePresentModesKHR
+
+#define vkCreateSwapchainKHR pfnCreateSwapchainKHR
+#define vkDestroySwapchainKHR pfnDestroySwapchainKHR
+#define vkGetSwapchainImagesKHR pfnGetSwapchainImagesKHR
+#define vkAcquireNextImageKHR pfnAcquireNextImageKHR
+#define vkQueuePresentKHR pfnQueuePresentKHR
+#endif
+};

third_party/ktx-src/tests/loadtests/appfwSDL/VulkanAppSDL/mac/vulkan/README.md

@@ -0,0 +1,8 @@
+<!-- Copyright 2024 Mark Callow -->
+<!-- SPDX-License-Identifier: Apache-2.0 -->
+
+# Vulkan ICD and Explicit Layer Manifest Files
+
+These were copied from `macOS/share/vulkan` in the Vulkan SDK and have been
+modified for inclusion in a macOS application bundle to cause the Vulkan loader
+to find the libraries within the bundle.

third_party/ktx-src/tests/loadtests/appfwSDL/VulkanAppSDL/mac/vulkan/explicit_layer.d/VkLayer_khronos_validation.json

@@ -0,0 +1,1709 @@
+{
+    "file_format_version": "1.2.0",
+    "layer": {
+        "name": "VK_LAYER_KHRONOS_validation",
+        "type": "GLOBAL",
+        "library_path": "../../../Frameworks/libVkLayer_khronos_validation.dylib",
+        "api_version": "1.3.283",
+        "implementation_version": "1",
+        "description": "Khronos Validation Layer",
+        "introduction": "The main, comprehensive Khronos validation layer.\n\nVulkan is an Explicit API, enabling direct control over how GPUs actually work. By design, minimal error checking is done inside a Vulkan driver. Applications have full control and responsibility for correct operation. Any errors in how Vulkan is used can result in a crash. \n\nThe Khronos Valiation Layer can be enabled to assist development by enabling developers to verify their applications correctly use the Vulkan API.",
+        "platforms": [
+            "WINDOWS",
+            "LINUX",
+            "ANDROID",
+            "MACOS"
+        ],
+        "url": "https://vulkan.lunarg.com/doc/sdk/latest/windows/khronos_validation_layer.html",
+        "instance_extensions": [
+            {
+                "name": "VK_EXT_debug_report",
+                "spec_version": "9"
+            },
+            {
+                "name": "VK_EXT_debug_utils",
+                "spec_version": "1"
+            },
+            {
+                "name": "VK_EXT_layer_settings",
+                "spec_version": "2"
+            },
+            {
+                "name": "VK_EXT_validation_features",
+                "spec_version": "2"
+            }
+        ],
+        "device_extensions": [
+            {
+                "name": "VK_EXT_debug_marker",
+                "spec_version": "4",
+                "entrypoints": [
+                    "vkDebugMarkerSetObjectTagEXT",
+                    "vkDebugMarkerSetObjectNameEXT",
+                    "vkCmdDebugMarkerBeginEXT",
+                    "vkCmdDebugMarkerEndEXT",
+                    "vkCmdDebugMarkerInsertEXT"
+                ]
+            },
+            {
+                "name": "VK_EXT_validation_cache",
+                "spec_version": "1",
+                "entrypoints": [
+                    "vkCreateValidationCacheEXT",
+                    "vkDestroyValidationCacheEXT",
+                    "vkGetValidationCacheDataEXT",
+                    "vkMergeValidationCachesEXT"
+                ]
+            },
+            {
+                "name": "VK_EXT_tooling_info",
+                "spec_version": "1",
+                "entrypoints": [
+                    "vkGetPhysicalDeviceToolPropertiesEXT"
+                ]
+            }
+        ],
+        "features": {
+            "presets": [
+                {
+                    "label": "Standard",
+                    "description": "Good default validation setup that balance validation coverage and performance.",
+                    "platforms": [
+                        "WINDOWS",
+                        "LINUX",
+                        "MACOS",
+                        "ANDROID"
+                    ],
+                    "status": "STABLE",
+                    "settings": [
+                        {
+                            "key": "validate_core",
+                            "value": true
+                        },
+                        {
+                            "key": "check_image_layout",
+                            "value": true
+                        },
+                        {
+                            "key": "check_command_buffer",
+                            "value": true
+                        },
+                        {
+                            "key": "check_object_in_use",
+                            "value": true
+                        },
+                        {
+                            "key": "check_query",
+                            "value": true
+                        },
+                        {
+                            "key": "check_shaders",
+                            "value": true
+                        },
+                        {
+                            "key": "check_shaders_caching",
+                            "value": true
+                        },
+                        {
+                            "key": "unique_handles",
+                            "value": true
+                        },
+                        {
+                            "key": "object_lifetime",
+                            "value": true
+                        },
+                        {
+                            "key": "stateless_param",
+                            "value": true
+                        },
+                        {
+                            "key": "thread_safety",
+                            "value": false
+                        },
+                        {
+                            "key": "validate_sync",
+                            "value": false
+                        },
+                        {
+                            "key": "validate_gpu_based",
+                            "value": "GPU_BASED_NONE"
+                        },
+                        {
+                            "key": "validate_best_practices",
+                            "value": false
+                        },
+                        {
+                            "key": "report_flags",
+                            "value": [
+                                "error"
+                            ]
+                        }
+                    ]
+                },
+                {
+                    "label": "Reduced-Overhead",
+                    "description": "Disables some checks in the interest of better performance.",
+                    "platforms": [
+                        "WINDOWS",
+                        "LINUX",
+                        "MACOS"
+                    ],
+                    "status": "STABLE",
+                    "settings": [
+                        {
+                            "key": "validate_core",
+                            "value": true
+                        },
+                        {
+                            "key": "check_image_layout",
+                            "value": false
+                        },
+                        {
+                            "key": "check_command_buffer",
+                            "value": false
+                        },
+                        {
+                            "key": "check_object_in_use",
+                            "value": false
+                        },
+                        {
+                            "key": "check_query",
+                            "value": false
+                        },
+                        {
+                            "key": "check_shaders",
+                            "value": true
+                        },
+                        {
+                            "key": "check_shaders_caching",
+                            "value": true
+                        },
+                        {
+                            "key": "unique_handles",
+                            "value": false
+                        },
+                        {
+                            "key": "object_lifetime",
+                            "value": true
+                        },
+                        {
+                            "key": "stateless_param",
+                            "value": true
+                        },
+                        {
+                            "key": "thread_safety",
+                            "value": false
+                        },
+                        {
+                            "key": "validate_sync",
+                            "value": false
+                        },
+                        {
+                            "key": "validate_gpu_based",
+                            "value": "GPU_BASED_NONE"
+                        },
+                        {
+                            "key": "validate_best_practices",
+                            "value": false
+                        },
+                        {
+                            "key": "report_flags",
+                            "value": [
+                                "error"
+                            ]
+                        }
+                    ]
+                },
+                {
+                    "label": "Best Practices",
+                    "description": "Provides warnings on valid API usage that is potential API misuse.",
+                    "platforms": [
+                        "WINDOWS",
+                        "LINUX",
+                        "MACOS",
+                        "ANDROID"
+                    ],
+                    "status": "STABLE",
+                    "settings": [
+                        {
+                            "key": "validate_core",
+                            "value": false
+                        },
+                        {
+                            "key": "check_image_layout",
+                            "value": false
+                        },
+                        {
+                            "key": "check_command_buffer",
+                            "value": false
+                        },
+                        {
+                            "key": "check_object_in_use",
+                            "value": false
+                        },
+                        {
+                            "key": "check_query",
+                            "value": false
+                        },
+                        {
+                            "key": "check_shaders",
+                            "value": false
+                        },
+                        {
+                            "key": "check_shaders_caching",
+                            "value": false
+                        },
+                        {
+                            "key": "unique_handles",
+                            "value": false
+                        },
+                        {
+                            "key": "object_lifetime",
+                            "value": false
+                        },
+                        {
+                            "key": "stateless_param",
+                            "value": false
+                        },
+                        {
+                            "key": "thread_safety",
+                            "value": false
+                        },
+                        {
+                            "key": "validate_sync",
+                            "value": false
+                        },
+                        {
+                            "key": "validate_gpu_based",
+                            "value": "GPU_BASED_NONE"
+                        },
+                        {
+                            "key": "validate_best_practices",
+                            "value": true
+                        },
+                        {
+                            "key": "report_flags",
+                            "value": [
+                                "error",
+                                "warn",
+                                "perf"
+                            ]
+                        }
+                    ]
+                },
+                {
+                    "label": "Synchronization",
+                    "description": "Identify resource access conflicts due to missing or incorrect synchronization operations between actions reading or writing the same regions of memory.",
+                    "platforms": [
+                        "WINDOWS",
+                        "LINUX",
+                        "MACOS",
+                        "ANDROID"
+                    ],
+                    "status": "STABLE",
+                    "settings": [
+                        {
+                            "key": "validate_core",
+                            "value": false
+                        },
+                        {
+                            "key": "check_image_layout",
+                            "value": false
+                        },
+                        {
+                            "key": "check_command_buffer",
+                            "value": false
+                        },
+                        {
+                            "key": "check_object_in_use",
+                            "value": false
+                        },
+                        {
+                            "key": "check_query",
+                            "value": false
+                        },
+                        {
+                            "key": "check_shaders",
+                            "value": false
+                        },
+                        {
+                            "key": "check_shaders_caching",
+                            "value": false
+                        },
+                        {
+                            "key": "unique_handles",
+                            "value": true
+                        },
+                        {
+                            "key": "object_lifetime",
+                            "value": false
+                        },
+                        {
+                            "key": "stateless_param",
+                            "value": false
+                        },
+                        {
+                            "key": "thread_safety",
+                            "value": true
+                        },
+                        {
+                            "key": "validate_sync",
+                            "value": true
+                        },
+                        {
+                            "key": "sync_queue_submit",
+                            "value": true
+                        },
+                        {
+                            "key": "validate_gpu_based",
+                            "value": "GPU_BASED_NONE"
+                        },
+                        {
+                            "key": "validate_best_practices",
+                            "value": false
+                        },
+                        {
+                            "key": "report_flags",
+                            "value": [
+                                "error"
+                            ]
+                        }
+                    ]
+                },
+                {
+                    "label": "GPU-Assisted",
+                    "description": "Check for API usage errors at shader execution time.",
+                    "platforms": [
+                        "WINDOWS",
+                        "LINUX"
+                    ],
+                    "status": "STABLE",
+                    "settings": [
+                        {
+                            "key": "validate_core",
+                            "value": false
+                        },
+                        {
+                            "key": "check_image_layout",
+                            "value": false
+                        },
+                        {
+                            "key": "check_command_buffer",
+                            "value": false
+                        },
+                        {
+                            "key": "check_object_in_use",
+                            "value": false
+                        },
+                        {
+                            "key": "check_query",
+                            "value": false
+                        },
+                        {
+                            "key": "check_shaders",
+                            "value": false
+                        },
+                        {
+                            "key": "check_shaders_caching",
+                            "value": false
+                        },
+                        {
+                            "key": "unique_handles",
+                            "value": false
+                        },
+                        {
+                            "key": "object_lifetime",
+                            "value": false
+                        },
+                        {
+                            "key": "stateless_param",
+                            "value": false
+                        },
+                        {
+                            "key": "thread_safety",
+                            "value": false
+                        },
+                        {
+                            "key": "validate_sync",
+                            "value": false
+                        },
+                        {
+                            "key": "validate_gpu_based",
+                            "value": "GPU_BASED_GPU_ASSISTED"
+                        },
+                        {
+                            "key": "gpuav_reserve_binding_slot",
+                            "value": true
+                        },
+                        {
+                            "key": "validate_best_practices",
+                            "value": false
+                        },
+                        {
+                            "key": "report_flags",
+                            "value": [
+                                "error"
+                            ]
+                        }
+                    ]
+                },
+                {
+                    "label": "Debug Printf",
+                    "description": "Debug shader code by \"printing\" any values of interest to the debug callback or stdout.",
+                    "platforms": [
+                        "WINDOWS",
+                        "LINUX"
+                    ],
+                    "status": "STABLE",
+                    "settings": [
+                        {
+                            "key": "validate_core",
+                            "value": false
+                        },
+                        {
+                            "key": "check_image_layout",
+                            "value": false
+                        },
+                        {
+                            "key": "check_command_buffer",
+                            "value": false
+                        },
+                        {
+                            "key": "check_object_in_use",
+                            "value": false
+                        },
+                        {
+                            "key": "check_query",
+                            "value": false
+                        },
+                        {
+                            "key": "check_shaders",
+                            "value": false
+                        },
+                        {
+                            "key": "check_shaders_caching",
+                            "value": false
+                        },
+                        {
+                            "key": "unique_handles",
+                            "value": false
+                        },
+                        {
+                            "key": "object_lifetime",
+                            "value": false
+                        },
+                        {
+                            "key": "stateless_param",
+                            "value": false
+                        },
+                        {
+                            "key": "thread_safety",
+                            "value": false
+                        },
+                        {
+                            "key": "validate_sync",
+                            "value": false
+                        },
+                        {
+                            "key": "validate_gpu_based",
+                            "value": "GPU_BASED_DEBUG_PRINTF"
+                        },
+                        {
+                            "key": "validate_best_practices",
+                            "value": false
+                        },
+                        {
+                            "key": "report_flags",
+                            "value": [
+                                "error"
+                            ]
+                        }
+                    ]
+                }
+            ],
+            "settings": [
+                {
+                    "key": "validation_control",
+                    "label": "Validation Areas",
+                    "description": "Control of the Validation layer validation",
+                    "type": "GROUP",
+                    "expanded": true,
+                    "settings": [
+                        {
+                            "key": "fine_grained_locking",
+                            "env": "VK_LAYER_FINE_GRAINED_LOCKING",
+                            "label": "Fine Grained Locking",
+                            "description": "Enable fine grained locking for Core Validation, which should improve performance in multithreaded applications. This setting allows the optimization to be disabled for debugging.",
+                            "type": "BOOL",
+                            "default": true,
+                            "platforms": [
+                                "WINDOWS",
+                                "LINUX",
+                                "MACOS",
+                                "ANDROID"
+                            ]
+                        },
+                        {
+                            "key": "validate_core",
+                            "label": "Core",
+                            "description": "The main, heavy-duty validation checks. This may be valuable early in the development cycle to reduce validation output while correcting parameter/object usage errors.",
+                            "type": "BOOL",
+                            "default": true,
+                            "settings": [
+                                {
+                                    "key": "check_image_layout",
+                                    "label": "Image Layout",
+                                    "description": "Check that the layout of each image subresource is correct whenever it is used by a command buffer. These checks are very CPU intensive for some applications.",
+                                    "type": "BOOL",
+                                    "default": true,
+                                    "dependence": {
+                                        "mode": "ALL",
+                                        "settings": [
+                                            {
+                                                "key": "validate_core",
+                                                "value": true
+                                            }
+                                        ]
+                                    }
+                                },
+                                {
+                                    "key": "check_command_buffer",
+                                    "label": "Command Buffer State",
+                                    "description": "Check that all Vulkan objects used by a command buffer have not been destroyed. These checks can be CPU intensive for some applications.",
+                                    "type": "BOOL",
+                                    "default": true,
+                                    "dependence": {
+                                        "mode": "ALL",
+                                        "settings": [
+                                            {
+                                                "key": "validate_core",
+                                                "value": true
+                                            }
+                                        ]
+                                    }
+                                },
+                                {
+                                    "key": "check_object_in_use",
+                                    "label": "Object in Use",
+                                    "description": "Check that Vulkan objects are not in use by a command buffer when they are destroyed.",
+                                    "type": "BOOL",
+                                    "default": true,
+                                    "dependence": {
+                                        "mode": "ALL",
+                                        "settings": [
+                                            {
+                                                "key": "validate_core",
+                                                "value": true
+                                            }
+                                        ]
+                                    }
+                                },
+                                {
+                                    "key": "check_query",
+                                    "label": "Query",
+                                    "description": "Checks for commands that use VkQueryPool objects.",
+                                    "type": "BOOL",
+                                    "default": true,
+                                    "dependence": {
+                                        "mode": "ALL",
+                                        "settings": [
+                                            {
+                                                "key": "validate_core",
+                                                "value": true
+                                            }
+                                        ]
+                                    }
+                                },
+                                {
+                                    "key": "check_shaders",
+                                    "label": "Shader",
+                                    "description": "Shader checks. These checks can be CPU intensive during application start up, especially if Shader Validation Caching is also disabled.",
+                                    "type": "BOOL",
+                                    "default": true,
+                                    "expanded": true,
+                                    "dependence": {
+                                        "mode": "ALL",
+                                        "settings": [
+                                            {
+                                                "key": "validate_core",
+                                                "value": true
+                                            }
+                                        ]
+                                    },
+                                    "settings": [
+                                        {
+                                            "key": "check_shaders_caching",
+                                            "label": "Caching",
+                                            "description": "Enable caching of shader validation results.",
+                                            "type": "BOOL",
+                                            "default": true,
+                                            "dependence": {
+                                                "mode": "ALL",
+                                                "settings": [
+                                                    {
+                                                        "key": "validate_core",
+                                                        "value": true
+                                                    },
+                                                    {
+                                                        "key": "check_shaders",
+                                                        "value": true
+                                                    }
+                                                ]
+                                            }
+                                        }
+                                    ]
+                                }
+                            ]
+                        },
+                        {
+                            "key": "unique_handles",
+                            "label": "Handle Wrapping",
+                            "description": "Handle wrapping checks. Disable this feature if you are exerience crashes when creating new extensions or developing new Vulkan objects/structures.",
+                            "type": "BOOL",
+                            "default": true,
+                            "status": "STABLE",
+                            "platforms": [
+                                "WINDOWS",
+                                "LINUX",
+                                "MACOS",
+                                "ANDROID"
+                            ]
+                        },
+                        {
+                            "key": "object_lifetime",
+                            "label": "Object Lifetime",
+                            "description": "Object tracking checks. This may not always be necessary late in a development cycle.",
+                            "type": "BOOL",
+                            "default": true,
+                            "status": "STABLE",
+                            "platforms": [
+                                "WINDOWS",
+                                "LINUX",
+                                "MACOS",
+                                "ANDROID"
+                            ]
+                        },
+                        {
+                            "key": "stateless_param",
+                            "label": "Stateless Parameter",
+                            "description": "Stateless parameter checks. This may not always be necessary late in a development cycle.",
+                            "type": "BOOL",
+                            "default": true,
+                            "status": "STABLE",
+                            "platforms": [
+                                "WINDOWS",
+                                "LINUX",
+                                "MACOS",
+                                "ANDROID"
+                            ]
+                        },
+                        {
+                            "key": "thread_safety",
+                            "label": "Thread Safety",
+                            "description": "Thread checks. In order to not degrade performance, it might be best to run your program with thread-checking disabled most of the time, enabling it occasionally for a quick sanity check or when debugging difficult application behaviors.",
+                            "type": "BOOL",
+                            "default": true,
+                            "status": "STABLE",
+                            "platforms": [
+                                "WINDOWS",
+                                "LINUX",
+                                "MACOS",
+                                "ANDROID"
+                            ]
+                        },
+                        {
+                            "key": "validate_sync",
+                            "label": "Synchronization",
+                            "description": "Enable synchronization validation during command buffers recording. This feature reports resource access conflicts due to missing or incorrect synchronization operations between actions (Draw, Copy, Dispatch, Blit) reading or writing the same regions of memory.",
+                            "url": "${LUNARG_SDK}/synchronization_usage.html",
+                            "type": "BOOL",
+                            "default": false,
+                            "expanded": true,
+                            "status": "STABLE",
+                            "platforms": [
+                                "WINDOWS",
+                                "LINUX",
+                                "MACOS",
+                                "ANDROID"
+                            ],
+                            "settings": [
+                                {
+                                    "key": "sync_queue_submit",
+                                    "label": "QueueSubmit Synchronization Validation",
+                                    "description": "Enable synchronization validation between submitted command buffers when Synchronization Validation is enabled. This option will increase the synchronization performance cost.",
+                                    "type": "BOOL",
+                                    "default": true,
+                                    "status": "STABLE",
+                                    "dependence": {
+                                        "mode": "ALL",
+                                        "settings": [
+                                            {
+                                                "key": "validate_sync",
+                                                "value": true
+                                            }
+                                        ]
+                                    }
+                                }
+                            ]
+                        },
+                        {
+                            "key": "validate_gpu_based",
+                            "label": "GPU Base",
+                            "description": "Setting an option here will enable specialized areas of validation",
+                            "type": "ENUM",
+                            "default": "GPU_BASED_NONE",
+                            "expanded": true,
+                            "status": "STABLE",
+                            "platforms": [
+                                "WINDOWS",
+                                "LINUX"
+                            ],
+                            "flags": [
+                                {
+                                    "key": "GPU_BASED_NONE",
+                                    "label": "None",
+                                    "description": "No GPU-based validation."
+                                },
+                                {
+                                    "key": "GPU_BASED_DEBUG_PRINTF",
+                                    "label": "Debug Printf",
+                                    "description": "Enables processing of debug printf instructions in shaders and sending debug strings to the debug callback.",
+                                    "url": "${LUNARG_SDK}/debug_printf.html",
+                                    "status": "STABLE",
+                                    "platforms": [
+                                        "WINDOWS",
+                                        "LINUX"
+                                    ],
+                                    "settings": [
+                                        {
+                                            "key": "printf_to_stdout",
+                                            "label": "Redirect Printf messages to stdout",
+                                            "description": "Enable redirection of Debug Printf messages from the debug callback to stdout",
+                                            "type": "BOOL",
+                                            "default": true,
+                                            "platforms": [
+                                                "WINDOWS",
+                                                "LINUX"
+                                            ],
+                                            "dependence": {
+                                                "mode": "ALL",
+                                                "settings": [
+                                                    {
+                                                        "key": "validate_gpu_based",
+                                                        "value": "GPU_BASED_DEBUG_PRINTF"
+                                                    }
+                                                ]
+                                            }
+                                        },
+                                        {
+                                            "key": "printf_verbose",
+                                            "label": "Printf verbose",
+                                            "description": "Set the verbosity of debug printf messages",
+                                            "type": "BOOL",
+                                            "default": false,
+                                            "platforms": [
+                                                "WINDOWS",
+                                                "LINUX"
+                                            ],
+                                            "dependence": {
+                                                "mode": "ALL",
+                                                "settings": [
+                                                    {
+                                                        "key": "validate_gpu_based",
+                                                        "value": "GPU_BASED_DEBUG_PRINTF"
+                                                    }
+                                                ]
+                                            }
+                                        },
+                                        {
+                                            "key": "printf_buffer_size",
+                                            "label": "Printf buffer size",
+                                            "description": "Set the size in bytes of the buffer used by debug printf",
+                                            "type": "INT",
+                                            "default": 1024,
+                                            "range": {
+                                                "min": 128,
+                                                "max": 1048576
+                                            },
+                                            "unit": "bytes",
+                                            "platforms": [
+                                                "WINDOWS",
+                                                "LINUX"
+                                            ],
+                                            "dependence": {
+                                                "mode": "ALL",
+                                                "settings": [
+                                                    {
+                                                        "key": "validate_gpu_based",
+                                                        "value": "GPU_BASED_DEBUG_PRINTF"
+                                                    }
+                                                ]
+                                            }
+                                        }
+                                    ]
+                                },
+                                {
+                                    "key": "GPU_BASED_GPU_ASSISTED",
+                                    "label": "GPU-Assisted",
+                                    "description": "Check for API usage errors at shader execution time.",
+                                    "url": "${LUNARG_SDK}/gpu_validation.html",
+                                    "platforms": [
+                                        "WINDOWS",
+                                        "LINUX"
+                                    ],
+                                    "settings": [
+                                        {
+                                            "key": "gpuav_shader_instrumentation",
+                                            "label": "Shader instrumentation",
+                                            "description": "Instrument shaders to validate descriptors, descriptor indexing, buffer device addresses and ray queries. Warning: will considerably slow down shader executions.",
+                                            "type": "BOOL",
+                                            "default": true,
+                                            "platforms": [
+                                                "WINDOWS",
+                                                "LINUX"
+                                            ],
+                                            "dependence": {
+                                                "mode": "ALL",
+                                                "settings": [
+                                                    {
+                                                        "key": "validate_gpu_based",
+                                                        "value": "GPU_BASED_GPU_ASSISTED"
+                                                    }
+                                                ]
+                                            },
+                                            "settings": [
+                                                {
+                                                    "key": "gpuav_descriptor_checks",
+                                                    "label": "Descriptors indexing",
+                                                    "description": "Enable descriptors and buffer out of bounds validation when using descriptor indexing",
+                                                    "type": "BOOL",
+                                                    "default": true,
+                                                    "platforms": [
+                                                        "WINDOWS",
+                                                        "LINUX"
+                                                    ],
+                                                    "dependence": {
+                                                        "mode": "ALL",
+                                                        "settings": [
+                                                            {
+                                                                "key": "gpuav_shader_instrumentation",
+                                                                "value": true
+                                                            }
+                                                        ]
+                                                    },
+                                                    "settings": [
+                                                        {
+                                                            "key": "gpuav_warn_on_robust_oob",
+                                                            "label": "Generate warning on out of bounds accesses even if buffer robustness is enabled",
+                                                            "description": "Warn on out of bounds accesses even if robustness is enabled",
+                                                            "type": "BOOL",
+                                                            "default": true,
+                                                            "platforms": [
+                                                                "WINDOWS",
+                                                                "LINUX"
+                                                            ],
+                                                            "dependence": {
+                                                                "mode": "ALL",
+                                                                "settings": [
+                                                                    {
+                                                                        "key": "gpuav_shader_instrumentation",
+                                                                        "value": true
+                                                                    }
+                                                                ]
+                                                            }
+                                                        }
+                                                    ]
+                                                },
+                                                {
+                                                    "key": "gpuav_buffer_address_oob",
+                                                    "label": "Out of bounds buffer device addresses",
+                                                    "type": "BOOL",
+                                                    "default": true,
+                                                    "description": "Check for ",
+                                                    "platforms": [
+                                                        "WINDOWS",
+                                                        "LINUX"
+                                                    ],
+                                                    "dependence": {
+                                                        "mode": "ALL",
+                                                        "settings": [
+                                                            {
+                                                                "key": "gpuav_shader_instrumentation",
+                                                                "value": true
+                                                            }
+                                                        ]
+                                                    },
+                                                    "settings": [
+                                                        {
+                                                            "key": "gpuav_max_buffer_device_addresses",
+                                                            "label": "Maximum number of buffer device addresses in use at one time",
+                                                            "description": "",
+                                                            "type": "INT",
+                                                            "default": 10000,
+                                                            "range": {
+                                                                "min": 100,
+                                                                "max": 10000000
+                                                            },
+                                                            "platforms": [
+                                                                "WINDOWS",
+                                                                "LINUX"
+                                                            ],
+                                                            "dependence": {
+                                                                "mode": "ALL",
+                                                                "settings": [
+                                                                    {
+                                                                        "key": "gpuav_shader_instrumentation",
+                                                                        "value": true
+                                                                    }
+                                                                ]
+                                                            }
+                                                        }
+                                                    ]
+                                                },
+                                                {
+                                                    "key": "gpuav_validate_ray_query",
+                                                    "label": "RayQuery SPIR-V Instructions",
+                                                    "description": "Enable shader instrumentation on OpRayQueryInitializeKHR",
+                                                    "type": "BOOL",
+                                                    "default": true,
+                                                    "platforms": [
+                                                        "WINDOWS",
+                                                        "LINUX"
+                                                    ],
+                                                    "dependence": {
+                                                        "mode": "ALL",
+                                                        "settings": [
+                                                            {
+                                                                "key": "gpuav_shader_instrumentation",
+                                                                "value": true
+                                                            }
+                                                        ]
+                                                    }
+                                                },
+                                                {
+                                                    "key": "gpuav_cache_instrumented_shaders",
+                                                    "label": "Cache instrumented shaders rather than instrumenting them on every run",
+                                                    "description": "Enable instrumented shader caching",
+                                                    "type": "BOOL",
+                                                    "default": true,
+                                                    "platforms": [
+                                                        "WINDOWS",
+                                                        "LINUX"
+                                                    ],
+                                                    "dependence": {
+                                                        "mode": "ALL",
+                                                        "settings": [
+                                                            {
+                                                                "key": "gpuav_shader_instrumentation",
+                                                                "value": true
+                                                            }
+                                                        ]
+                                                    }
+                                                },
+                                                {
+                                                    "key": "gpuav_select_instrumented_shaders",
+                                                    "label": "Enable instrumenting shaders selectively",
+                                                    "description": "Select which shaders to instrument passing a VkValidationFeaturesEXT struct with GPU-AV enabled in the VkShaderModuleCreateInfo pNext",
+                                                    "type": "BOOL",
+                                                    "default": false,
+                                                    "platforms": [
+                                                        "WINDOWS",
+                                                        "LINUX"
+                                                    ],
+                                                    "dependence": {
+                                                        "mode": "ALL",
+                                                        "settings": [
+                                                            {
+                                                                "key": "gpuav_shader_instrumentation",
+                                                                "value": true
+                                                            }
+                                                        ]
+                                                    }
+                                                }
+                                            ]
+                                        },
+                                        {
+                                            "key": "gpuav_buffers_validation",
+                                            "label": "Buffer content validation",
+                                            "description": "Validate buffers containing parameters used in indirect Vulkan commands, or used in copy commands",
+                                            "type": "BOOL",
+                                            "default": true,
+                                            "platforms": [
+                                                "WINDOWS",
+                                                "LINUX"
+                                            ],
+                                            "dependence": {
+                                                "mode": "ALL",
+                                                "settings": [
+                                                    {
+                                                        "key": "validate_gpu_based",
+                                                        "value": "GPU_BASED_GPU_ASSISTED"
+                                                    }
+                                                ]
+                                            },
+                                            "settings": [
+                                                {
+                                                    "key": "gpuav_indirect_draws_buffers",
+                                                    "label": "Indirect draws parameters",
+                                                    "type": "BOOL",
+                                                    "default": true,
+                                                    "description": "Validate buffers containing draw parameters used in indirect draw commands",
+                                                    "platforms": [
+                                                        "WINDOWS",
+                                                        "LINUX"
+                                                    ],
+                                                    "dependence": {
+                                                        "mode": "ALL",
+                                                        "settings": [
+                                                            {
+                                                                "key": "gpuav_buffers_validation",
+                                                                "value": true
+                                                            }
+                                                        ]
+                                                    }
+                                                },
+                                                {
+                                                    "key": "indirect_dispatches",
+                                                    "label": "Indirect dispatches parameters",
+                                                    "type": "BOOL",
+                                                    "default": true,
+                                                    "description": "Validate buffers containing dispatch parameters used in indirect dispatch commands",
+                                                    "platforms": [
+                                                        "WINDOWS",
+                                                        "LINUX"
+                                                    ],
+                                                    "dependence": {
+                                                        "mode": "ALL",
+                                                        "settings": [
+                                                            {
+                                                                "key": "gpuav_buffers_validation",
+                                                                "value": true
+                                                            }
+                                                        ]
+                                                    }
+                                                },
+                                                {
+                                                    "key": "indirect_trace_rays",
+                                                    "label": "Indirect trace rays parameters",
+                                                    "type": "BOOL",
+                                                    "default": true,
+                                                    "description": "Validate buffers containing ray tracing parameters used in indirect ray tracing commands",
+                                                    "platforms": [
+                                                        "WINDOWS",
+                                                        "LINUX"
+                                                    ],
+                                                    "dependence": {
+                                                        "mode": "ALL",
+                                                        "settings": [
+                                                            {
+                                                                "key": "gpuav_buffers_validation",
+                                                                "value": true
+                                                            }
+                                                        ]
+                                                    }
+                                                },
+                                                {
+                                                    "key": "gpuav_buffer_copies",
+                                                    "label": "Buffer copies",
+                                                    "type": "BOOL",
+                                                    "default": true,
+                                                    "description": "Validate copies involving a VkBuffer. Right now only validates copy buffer to image.",
+                                                    "platforms": [
+                                                        "WINDOWS",
+                                                        "LINUX"
+                                                    ],
+                                                    "dependence": {
+                                                        "mode": "ALL",
+                                                        "settings": [
+                                                            {
+                                                                "key": "gpuav_buffers_validation",
+                                                                "value": true
+                                                            }
+                                                        ]
+                                                    }
+                                                }
+                                            ]
+                                        },
+                                        {
+                                            "key": "gpuav_advanced_settings",
+                                            "label": "Advanced Settings",
+                                            "description": "GPU-AV advanced settings",
+                                            "type": "GROUP",
+                                            "view": "ADVANCED",
+                                            "platforms": [
+                                                "WINDOWS",
+                                                "LINUX"
+                                            ],
+                                            "dependence": {
+                                                "mode": "ALL",
+                                                "settings": [
+                                                    {
+                                                        "key": "validate_gpu_based",
+                                                        "value": "GPU_BASED_GPU_ASSISTED"
+                                                    }
+                                                ]
+                                            },
+                                            "settings": [
+                                                {
+                                                    "key": "gpuav_reserve_binding_slot",
+                                                    "label": "Reserve Descriptor Set Binding Slot",
+                                                    "type": "BOOL",
+                                                    "default": true,
+                                                    "description": "Specifies that the validation layers reserve a descriptor set binding slot for their own use. The layer reports a value for VkPhysicalDeviceLimits::maxBoundDescriptorSets that is one less than the value reported by the device. If the device supports the binding of only one descriptor set, the validation layer does not perform GPU-assisted validation.",
+                                                    "platforms": [
+                                                        "WINDOWS",
+                                                        "LINUX"
+                                                    ],
+                                                    "dependence": {
+                                                        "mode": "ALL",
+                                                        "settings": [
+                                                            {
+                                                                "key": "validate_gpu_based",
+                                                                "value": "GPU_BASED_GPU_ASSISTED"
+                                                            }
+                                                        ]
+                                                    }
+                                                },
+                                                {
+                                                    "key": "gpuav_vma_linear_output",
+                                                    "label": "Linear Memory Allocation Mode",
+                                                    "description": "Use VMA linear memory allocations for GPU-AV output buffers instead of finding best place for new allocations among free regions to optimize memory usage. Enabling this setting reduces performance cost but disabling this method minimizes memory usage.",
+                                                    "type": "BOOL",
+                                                    "default": true,
+                                                    "platforms": [
+                                                        "WINDOWS",
+                                                        "LINUX"
+                                                    ],
+                                                    "dependence": {
+                                                        "mode": "ALL",
+                                                        "settings": [
+                                                            {
+                                                                "key": "validate_gpu_based",
+                                                                "value": "GPU_BASED_GPU_ASSISTED"
+                                                            }
+                                                        ]
+                                                    }
+                                                }
+                                            ]
+                                        },
+                                        {
+                                            "key": "gpuav_debug_settings",
+                                            "label": "Developer Debug Settings",
+                                            "description": "GPU-AV debug settings",
+                                            "type": "GROUP",
+                                            "view": "ADVANCED",
+                                            "platforms": [
+                                                "WINDOWS",
+                                                "LINUX"
+                                            ],
+                                            "dependence": {
+                                                "mode": "ALL",
+                                                "settings": [
+                                                    {
+                                                        "key": "validate_gpu_based",
+                                                        "value": "GPU_BASED_GPU_ASSISTED"
+                                                    }
+                                                ]
+                                            },
+                                            "settings": [
+                                                {
+                                                    "key": "gpuav_debug_validate_instrumented_shaders",
+                                                    "label": "Validate instrumented shaders",
+                                                    "description": "Run spirv-val after doing shader instrumentation",
+                                                    "type": "BOOL",
+                                                    "default": false,
+                                                    "platforms": [
+                                                        "WINDOWS",
+                                                        "LINUX"
+                                                    ],
+                                                    "dependence": {
+                                                        "mode": "ALL",
+                                                        "settings": [
+                                                            {
+                                                                "key": "validate_gpu_based",
+                                                                "value": "GPU_BASED_GPU_ASSISTED"
+                                                            }
+                                                        ]
+                                                    }
+                                                },
+                                                {
+                                                    "key": "gpuav_debug_dump_instrumented_shaders",
+                                                    "label": "Dump instrumented shaders",
+                                                    "description": "Will dump the instrumented shaders (before and after) to working directory",
+                                                    "type": "BOOL",
+                                                    "default": false,
+                                                    "platforms": [
+                                                        "WINDOWS",
+                                                        "LINUX"
+                                                    ],
+                                                    "dependence": {
+                                                        "mode": "ALL",
+                                                        "settings": [
+                                                            {
+                                                                "key": "validate_gpu_based",
+                                                                "value": "GPU_BASED_GPU_ASSISTED"
+                                                            }
+                                                        ]
+                                                    }
+                                                }
+                                            ]
+                                        }
+                                    ]
+                                }
+                            ]
+                        },
+                        {
+                            "key": "validate_best_practices",
+                            "label": "Best Practices",
+                            "description": "Outputs warnings related to common misuse of the API, but which are not explicitly prohibited by the specification.",
+                            "url": "${LUNARG_SDK}/best_practices.html",
+                            "type": "BOOL",
+                            "default": false,
+                            "expanded": true,
+                            "status": "STABLE",
+                            "platforms": [
+                                "WINDOWS",
+                                "LINUX",
+                                "MACOS",
+                                "ANDROID"
+                            ],
+                            "settings": [
+                                {
+                                    "key": "validate_best_practices_arm",
+                                    "label": "ARM-specific best practices",
+                                    "description": "Outputs warnings for spec-conforming but non-ideal code on ARM GPUs.",
+                                    "type": "BOOL",
+                                    "default": false,
+                                    "platforms": [
+                                        "WINDOWS",
+                                        "LINUX",
+                                        "MACOS",
+                                        "ANDROID"
+                                    ],
+                                    "dependence": {
+                                        "mode": "ALL",
+                                        "settings": [
+                                            {
+                                                "key": "validate_best_practices",
+                                                "value": true
+                                            }
+                                        ]
+                                    }
+                                },
+                                {
+                                    "key": "validate_best_practices_amd",
+                                    "label": "AMD-specific best practices",
+                                    "description": "Outputs warnings for spec-conforming but non-ideal code on AMD GPUs.",
+                                    "type": "BOOL",
+                                    "default": false,
+                                    "platforms": [
+                                        "WINDOWS",
+                                        "LINUX",
+                                        "MACOS"
+                                    ],
+                                    "dependence": {
+                                        "mode": "ALL",
+                                        "settings": [
+                                            {
+                                                "key": "validate_best_practices",
+                                                "value": true
+                                            }
+                                        ]
+                                    }
+                                },
+                                {
+                                    "key": "validate_best_practices_img",
+                                    "label": "IMG-specific best practices",
+                                    "description": "Outputs warnings for spec-conforming but non-ideal code on Imagination GPUs.",
+                                    "type": "BOOL",
+                                    "default": false,
+                                    "platforms": [
+                                        "WINDOWS",
+                                        "LINUX",
+                                        "MACOS"
+                                    ],
+                                    "dependence": {
+                                        "mode": "ALL",
+                                        "settings": [
+                                            {
+                                                "key": "validate_best_practices",
+                                                "value": true
+                                            }
+                                        ]
+                                    }
+                                },
+                                {
+                                    "key": "validate_best_practices_nvidia",
+                                    "label": "NVIDIA-specific best practices",
+                                    "description": "Outputs warnings for spec-conforming but non-ideal code on NVIDIA GPUs.",
+                                    "type": "BOOL",
+                                    "default": false,
+                                    "platforms": [
+                                        "WINDOWS",
+                                        "LINUX",
+                                        "ANDROID"
+                                    ],
+                                    "dependence": {
+                                        "mode": "ALL",
+                                        "settings": [
+                                            {
+                                                "key": "validate_best_practices",
+                                                "value": true
+                                            }
+                                        ]
+                                    }
+                                }
+                            ]
+                        }
+                    ]
+                },
+                {
+                    "key": "debug_action",
+                    "label": "Debug Action",
+                    "description": "Specifies what action is to be taken when a layer reports information",
+                    "type": "FLAGS",
+                    "flags": [
+                        {
+                            "key": "VK_DBG_LAYER_ACTION_LOG_MSG",
+                            "label": "Log Message",
+                            "description": "Log a txt message to stdout or to a log filename.",
+                            "settings": [
+                                {
+                                    "key": "log_filename",
+                                    "label": "Log Filename",
+                                    "description": "Specifies the output filename",
+                                    "type": "SAVE_FILE",
+                                    "default": "stdout",
+                                    "dependence": {
+                                        "mode": "ALL",
+                                        "settings": [
+                                            {
+                                                "key": "debug_action",
+                                                "value": [
+                                                    "VK_DBG_LAYER_ACTION_LOG_MSG"
+                                                ]
+                                            }
+                                        ]
+                                    }
+                                }
+                            ]
+                        },
+                        {
+                            "key": "VK_DBG_LAYER_ACTION_CALLBACK",
+                            "label": "Callback",
+                            "description": "Call user defined callback function(s) that have been registered via the VK_EXT_debug_report extension. Since application must register callback, this is a NOOP for the settings file.",
+                            "view": "HIDDEN"
+                        },
+                        {
+                            "key": "VK_DBG_LAYER_ACTION_DEBUG_OUTPUT",
+                            "label": "Debug Output",
+                            "description": "Log a txt message using the Windows OutputDebugString function.",
+                            "platforms": [
+                                "WINDOWS"
+                            ]
+                        },
+                        {
+                            "key": "VK_DBG_LAYER_ACTION_BREAK",
+                            "label": "Break",
+                            "description": "Trigger a breakpoint if a debugger is in use."
+                        }
+                    ],
+                    "default": [
+                        "VK_DBG_LAYER_ACTION_LOG_MSG"
+                    ]
+                },
+                {
+                    "key": "report_flags",
+                    "label": "Message Severity",
+                    "description": "Comma-delineated list of options specifying the types of messages to be reported",
+                    "type": "FLAGS",
+                    "flags": [
+                        {
+                            "key": "info",
+                            "label": "Info",
+                            "description": "Report informational messages."
+                        },
+                        {
+                            "key": "warn",
+                            "label": "Warning",
+                            "description": "Report warnings from using the API in a manner which may lead to undefined behavior or to warn the user of common trouble spots. A warning does NOT necessarily signify illegal application behavior."
+                        },
+                        {
+                            "key": "perf",
+                            "label": "Performance",
+                            "description": "Report usage of the API that may cause suboptimal performance."
+                        },
+                        {
+                            "key": "error",
+                            "label": "Error",
+                            "description": "Report errors in API usage."
+                        },
+                        {
+                            "key": "debug",
+                            "label": "Debug",
+                            "description": "For layer development. Report messages for debugging layer behavior.",
+                            "view": "HIDDEN"
+                        }
+                    ],
+                    "default": [
+                        "error"
+                    ]
+                },
+                {
+                    "key": "enable_message_limit",
+                    "label": "Limit Duplicated Messages",
+                    "description": "Enable limiting of duplicate messages.",
+                    "type": "BOOL",
+                    "default": true,
+                    "settings": [
+                        {
+                            "key": "duplicate_message_limit",
+                            "env": "VK_LAYER_DUPLICATE_MESSAGE_LIMIT",
+                            "label": "Max Duplicated Messages",
+                            "description": "Maximum number of times any single validation message should be reported.",
+                            "type": "INT",
+                            "default": 10,
+                            "range": {
+                                "min": 1
+                            },
+                            "dependence": {
+                                "mode": "ALL",
+                                "settings": [
+                                    {
+                                        "key": "enable_message_limit",
+                                        "value": true
+                                    }
+                                ]
+                            }
+                        }
+                    ]
+                },
+                {
+                    "key": "message_id_filter",
+                    "label": "Mute Message VUIDs",
+                    "description": "List of VUIDs and VUID identifers which are to be IGNORED by the validation layer",
+                    "type": "LIST",
+                    "env": "VK_LAYER_MESSAGE_ID_FILTER",
+                    "default": []
+                },
+                {
+                    "key": "message_format",
+                    "label": "Message Format",
+                    "description": "Specifies how error messages are reported",
+                    "type": "GROUP",
+                    "expanded": true,
+                    "settings": [
+                        {
+                            "key": "message_format_display_application_name",
+                            "label": "Display Application Name",
+                            "description": "Useful when running multiple instances to know which instance the message is from.",
+                            "type": "BOOL",
+                            "default": false,
+                            "platforms": [
+                                "WINDOWS",
+                                "LINUX",
+                                "MACOS",
+                                "ANDROID"
+                            ]
+                        }
+                    ]
+                },
+                {
+                    "key": "disables",
+                    "label": "Disables",
+                    "description": "Specify areas of validation to be disabled",
+                    "type": "FLAGS",
+                    "env": "VK_LAYER_DISABLES",
+                    "flags": [
+                        {
+                            "key": "VK_VALIDATION_FEATURE_DISABLE_THREAD_SAFETY_EXT",
+                            "label": "Thread Safety",
+                            "description": "Thread checks. In order to not degrade performance, it might be best to run your program with thread-checking disabled most of the time, enabling it occasionally for a quick sanity check or when debugging difficult application behaviors."
+                        },
+                        {
+                            "key": "VK_VALIDATION_FEATURE_DISABLE_API_PARAMETERS_EXT",
+                            "label": "Stateless Parameter",
+                            "description": "Stateless parameter checks. This may not always be necessary late in a development cycle."
+                        },
+                        {
+                            "key": "VK_VALIDATION_FEATURE_DISABLE_OBJECT_LIFETIMES_EXT",
+                            "label": "Object Lifetime",
+                            "description": "Object tracking checks. This may not always be necessary late in a development cycle."
+                        },
+                        {
+                            "key": "VK_VALIDATION_FEATURE_DISABLE_CORE_CHECKS_EXT",
+                            "label": "Core",
+                            "description": "The main, heavy-duty validation checks. This may be valuable early in the development cycle to reduce validation output while correcting parameter/object usage errors."
+                        },
+                        {
+                            "key": "VK_VALIDATION_FEATURE_DISABLE_UNIQUE_HANDLES_EXT",
+                            "label": "Handle Wrapping",
+                            "description": "Handle wrapping checks. Disable this feature if you are exerience crashes when creating new extensions or developing new Vulkan objects/structures."
+                        },
+                        {
+                            "key": "VK_VALIDATION_FEATURE_DISABLE_SHADERS_EXT",
+                            "label": "Shader Validation",
+                            "description": "Shader checks. These checks can be CPU intensive during application start up, especially if Shader Validation Caching is also disabled.",
+                            "view": "ADVANCED"
+                        },
+                        {
+                            "key": "VALIDATION_CHECK_DISABLE_COMMAND_BUFFER_STATE",
+                            "label": "Command Buffer State",
+                            "description": "Check that all Vulkan objects used by a command buffer have not been destroyed. These checks can be CPU intensive for some applications.",
+                            "view": "ADVANCED"
+                        },
+                        {
+                            "key": "VALIDATION_CHECK_DISABLE_IMAGE_LAYOUT_VALIDATION",
+                            "label": "Image Layout",
+                            "description": "Check that the layout of each image subresource is correct whenever it is used by a command buffer. These checks are very CPU intensive for some applications.",
+                            "view": "ADVANCED"
+                        },
+                        {
+                            "key": "VALIDATION_CHECK_DISABLE_QUERY_VALIDATION",
+                            "label": "Query",
+                            "description": "Checks for commands that use VkQueryPool objects.",
+                            "view": "ADVANCED"
+                        },
+                        {
+                            "key": "VALIDATION_CHECK_DISABLE_OBJECT_IN_USE",
+                            "label": "Object in Use",
+                            "description": "Check that Vulkan objects are not in use by a command buffer when they are destroyed.",
+                            "view": "ADVANCED"
+                        },
+                        {
+                            "key": "VALIDATION_CHECK_DISABLE_SYNCHRONIZATION_VALIDATION_QUEUE_SUBMIT",
+                            "label": "QueueSubmit Synchronization Validation",
+                            "description": "Check synchronization validation between submitted command buffers when Synchronization Validation is enabled.",
+                            "view": "ADVANCED"
+                        },
+                        {
+                            "key": "VK_VALIDATION_FEATURE_DISABLE_SHADER_VALIDATION_CACHE_EXT",
+                            "label": "Shader Validation Caching",
+                            "description": "Disable caching of shader validation results.",
+                            "view": "ADVANCED"
+                        }
+                    ],
+                    "default": [
+                        "VK_VALIDATION_FEATURE_DISABLE_THREAD_SAFETY_EXT"
+                    ]
+                },
+                {
+                    "key": "enables",
+                    "label": "Enables",
+                    "description": "Setting an option here will enable specialized areas of validation",
+                    "type": "FLAGS",
+                    "env": "VK_LAYER_ENABLES",
+                    "flags": [
+                        {
+                            "key": "VK_VALIDATION_FEATURE_ENABLE_SYNCHRONIZATION_VALIDATION_EXT",
+                            "label": "Synchronization",
+                            "description": "This feature reports resource access conflicts due to missing or incorrect synchronization operations between actions (Draw, Copy, Dispatch, Blit) reading or writing the same regions of memory.",
+                            "url": "${LUNARG_SDK}/synchronization_usage.html",
+                            "status": "STABLE",
+                            "platforms": [
+                                "WINDOWS",
+                                "LINUX",
+                                "MACOS",
+                                "ANDROID"
+                            ]
+                        },
+                        {
+                            "key": "VK_VALIDATION_FEATURE_ENABLE_DEBUG_PRINTF_EXT",
+                            "label": "Debug Printf",
+                            "description": "Enables processing of debug printf instructions in shaders and sending debug strings to the debug callback.",
+                            "url": "${LUNARG_SDK}/debug_printf.html",
+                            "status": "STABLE",
+                            "platforms": [
+                                "WINDOWS",
+                                "LINUX"
+                            ]
+                        },
+                        {
+                            "key": "VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT",
+                            "label": "GPU-Assisted",
+                            "description": "Check for API usage errors at shader execution time.",
+                            "url": "${LUNARG_SDK}/gpu_validation.html",
+                            "platforms": [
+                                "WINDOWS",
+                                "LINUX"
+                            ]
+                        },
+                        {
+                            "key": "VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT",
+                            "label": "Reserve Descriptor Set Binding Slot",
+                            "description": "Specifies that the validation layers reserve a descriptor set binding slot for their own use. The layer reports a value for VkPhysicalDeviceLimits::maxBoundDescriptorSets that is one less than the value reported by the device. If the device supports the binding of only one descriptor set, the validation layer does not perform GPU-assisted validation.",
+                            "platforms": [
+                                "WINDOWS",
+                                "LINUX"
+                            ]
+                        },
+                        {
+                            "key": "VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES_EXT",
+                            "label": "Best Practices",
+                            "description": "Activating this feature enables the output of warnings related to common misuse of the API, but which are not explicitly prohibited by the specification.",
+                            "url": "${LUNARG_SDK}/best_practices.html",
+                            "platforms": [
+                                "WINDOWS",
+                                "LINUX",
+                                "MACOS",
+                                "ANDROID"
+                            ]
+                        },
+                        {
+                            "key": "VALIDATION_CHECK_ENABLE_VENDOR_SPECIFIC_ARM",
+                            "label": "ARM-specific best practices",
+                            "description": "Activating this feature enables the output of warnings related to ARM-specific misuse of the API, but which are not explicitly prohibited by the specification.",
+                            "platforms": [
+                                "WINDOWS",
+                                "LINUX",
+                                "MACOS",
+                                "ANDROID"
+                            ]
+                        },
+                        {
+                            "key": "VALIDATION_CHECK_ENABLE_VENDOR_SPECIFIC_AMD",
+                            "label": "AMD-specific best practices",
+                            "description": "Adds check for spec-conforming but non-ideal code on AMD GPUs.",
+                            "platforms": [
+                                "WINDOWS",
+                                "LINUX",
+                                "MACOS"
+                            ]
+                        },
+                        {
+                            "key": "VALIDATION_CHECK_ENABLE_VENDOR_SPECIFIC_IMG",
+                            "label": "IMG-specific best practices",
+                            "description": "Adds check for spec-conforming but non-ideal code on Imagination GPUs.",
+                            "platforms": [
+                                "WINDOWS",
+                                "LINUX",
+                                "MACOS"
+                            ]
+                        },
+                        {
+                            "key": "VALIDATION_CHECK_ENABLE_VENDOR_SPECIFIC_NVIDIA",
+                            "label": "NVIDIA-specific best practices",
+                            "description": "Activating this feature enables the output of warnings related to NVIDIA-specific misuse of the API, but which are not explicitly prohibited by the specification.",
+                            "platforms": [
+                                "WINDOWS",
+                                "LINUX",
+                                "ANDROID"
+                            ]
+                        },
+                        {
+                            "key": "VALIDATION_CHECK_ENABLE_VENDOR_SPECIFIC_ALL",
+                            "label": "Hardware specific best practices",
+                            "description": "Activating this feature enables all vendor specific best practices.",
+                            "platforms": [
+                                "WINDOWS",
+                                "LINUX",
+                                "ANDROID"
+                            ]
+                        }
+                    ],
+                    "default": []
+                }
+            ]
+        }
+    }
+}

third_party/ktx-src/tests/loadtests/appfwSDL/VulkanAppSDL/mac/vulkan/icd.d/MoltenVK_icd.json

@@ -0,0 +1,8 @@
+{
+    "file_format_version": "1.0.0",
+    "ICD": {
+        "library_path": "../../../Frameworks/libMoltenVK.dylib",
+        "api_version": "1.2.0",
+        "is_portability_driver": true
+    }
+}

third_party/ktx-src/tests/loadtests/appfwSDL/VulkanAppSDL/shaders/textoverlay.frag

@@ -0,0 +1,16 @@
+// Copyright 2017-2020 Mark Callow
+// SPDX-License-Identifier: Apache-2.0
+
+#version 450 core
+
+layout (location = 0) in vec2 inUV;
+
+layout (binding = 0) uniform sampler2D samplerFont;
+
+layout (location = 0) out vec4 outFragColor;
+
+void main(void)
+{
+	float color = texture(samplerFont, inUV).r;
+	outFragColor = vec4(vec3(color), 1.0);
+}

third_party/ktx-src/tests/loadtests/appfwSDL/VulkanAppSDL/shaders/textoverlay.vert

@@ -0,0 +1,20 @@
+// Copyright 2017-2020 Mark Callow
+// SPDX-License-Identifier: Apache-2.0
+
+#version 450 core
+
+layout (location = 0) in vec2 inPos;
+layout (location = 1) in vec2 inUV;
+
+layout (location = 0) out vec2 outUV;
+
+out gl_PerVertex
+{
+    vec4 gl_Position;
+};
+
+void main(void)
+{
+	gl_Position = vec4(inPos, 0.0, 1.0);
+	outUV = inUV;
+}

third_party/ktx-src/tests/loadtests/appfwSDL/VulkanAppSDL/vulkancheckres.h

@@ -0,0 +1,48 @@
+/* -*- tab-width: 4; -*- */
+/* vi: set sw=2 ts=4 expandtab: */
+
+#ifndef VULKAN_CHECK_RES_H_1456211188
+#define VULKAN_CHECK_RES_H_1456211188
+
+/*
+ * Copyright 2017-2020 Mark Callow.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <iomanip>
+#include <sstream>
+
+#include <SDL3/SDL_messagebox.h>
+
+/**
+ * @internal
+ * @file
+ * @~English
+ *
+ * @brief Check result of a Vulkan command.
+ *
+ * Use for commands that will always succeed unless usage is invalid.
+ */
+#if defined(DEBUG)
+#define VK_CHECK_RESULT(f)                                                    \
+{                                                                             \
+    VkResult res = (f);                                                       \
+    if (res != VK_SUCCESS)                                                    \
+    {                                                                         \
+        std::stringstream msg;                                                \
+        msg << "Fatal : VkResult is \"" << res << "\" in " << __FILE__        \
+            << " at line " << __LINE__ << std::endl;                          \
+        SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR,                        \
+                                 "VkSample_02_cube_textured",                 \
+                                 msg.str().c_str(),                           \
+                                 NULL);                                       \
+        assert(res == VK_SUCCESS);                                            \
+    }                                                                         \
+}
+#else
+#define VK_CHECK_RESULT(f) (void)f
+#endif
+
+#endif

third_party/ktx-src/tests/loadtests/appfwSDL/VulkanAppSDL/vulkandebug.cpp

@@ -0,0 +1,288 @@
+/*
+* Vulkan examples debug wrapper
+* 
+* Appendix for VK_EXT_Debug_Report can be found at https://github.com/KhronosGroup/Vulkan-Docs/blob/1.0-VK_EXT_debug_report/doc/specs/vulkan/appendices/debug_report.txt
+*
+* Copyright 2016 Sascha Willems - www.saschawillems.de
+* SPDX-License-Identifier: MIT
+*/
+
+#include "vulkandebug.h"
+#include <iostream>
+#include "unused.h"
+
+namespace vkDebug
+{
+    int validationLayerCount = 1;
+    const char *validationLayerNames[] = 
+    {
+        // This is a meta layer that enables all of the standard
+        // validation layers in the correct order :
+        // threading, parameter_validation, device_limits, object_tracker, image, core_validation, swapchain, and unique_objects
+        "VK_LAYER_LUNARG_standard_validation"
+    };
+
+    PFN_vkCreateDebugReportCallbackEXT CreateDebugReportCallback = VK_NULL_HANDLE;
+    PFN_vkDestroyDebugReportCallbackEXT DestroyDebugReportCallback = VK_NULL_HANDLE;
+    PFN_vkDebugReportMessageEXT dbgBreakCallback = VK_NULL_HANDLE;
+
+    VkDebugReportCallbackEXT msgCallback;
+
+    VkBool32 messageCallback(
+        VkDebugReportFlagsEXT flags,
+        VkDebugReportObjectTypeEXT /*objType*/,
+        uint64_t /*srcObject*/,
+        size_t /*location*/,
+        int32_t msgCode,
+        const char* pLayerPrefix,
+        const char* pMsg,
+        void* /*pUserData*/)
+    {
+        // Message text passed in by validation layer
+        std::string text(pMsg);
+
+        // Select prefix depending on flags passed to the callback
+        // Note that multiple flags may be set for a single validation message
+        std::string prefix("");
+
+        // Error that may result in undefined behaviour
+        if (flags & VK_DEBUG_REPORT_ERROR_BIT_EXT)
+        {
+            prefix += "ERROR:";
+        };
+        // Warnings may hint at unexpected / non-spec API usage
+        if (flags & VK_DEBUG_REPORT_WARNING_BIT_EXT)
+        {
+            prefix += "WARNING:";
+        };
+        // May indicate sub-optimal usage of the API
+        if (flags & VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT)
+        {
+            prefix += "PERFORMANCE:";
+        };
+        // Informal messages that may become handy during debugging
+        if (flags & VK_DEBUG_REPORT_INFORMATION_BIT_EXT)
+        {
+            prefix += "INFO:";
+        }
+        // Diagnostic info from the Vulkan loader and layers
+        // Usually not helpful in terms of API usage, but may help to debug layer and loader problems 
+        if (flags & VK_DEBUG_REPORT_DEBUG_BIT_EXT)
+        {
+            prefix += "DEBUG:";
+        }
+
+        // Display message to default output (console if activated)
+        std::cout << prefix << " [" << pLayerPrefix << "] Code " << msgCode << " : " << pMsg << "\n";
+
+        fflush(stdout);
+
+        // The return value of this callback controls wether the Vulkan call that caused
+        // the validation message will be aborted or not
+        // We return VK_FALSE as we DON'T want Vulkan calls that cause a validation message 
+        // (and return a VkResult) to abort
+        // If you instead want to have calls abort, pass in VK_TRUE and the function will 
+        // return VK_ERROR_VALIDATION_FAILED_EXT 
+        return VK_FALSE;
+    }
+
+    void setupDebugging(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportCallbackEXT callBack)
+    {
+        CreateDebugReportCallback = (PFN_vkCreateDebugReportCallbackEXT)vkGetInstanceProcAddr(instance, "vkCreateDebugReportCallbackEXT");
+        DestroyDebugReportCallback = (PFN_vkDestroyDebugReportCallbackEXT)vkGetInstanceProcAddr(instance, "vkDestroyDebugReportCallbackEXT");
+        dbgBreakCallback = (PFN_vkDebugReportMessageEXT)vkGetInstanceProcAddr(instance, "vkDebugReportMessageEXT");
+
+        VkDebugReportCallbackCreateInfoEXT dbgCreateInfo = {};
+        dbgCreateInfo.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT;
+        dbgCreateInfo.pfnCallback = (PFN_vkDebugReportCallbackEXT)messageCallback;
+        dbgCreateInfo.flags = flags;
+
+        U_ASSERT_ONLY VkResult err = CreateDebugReportCallback(
+            instance,
+            &dbgCreateInfo,
+            nullptr,
+            (callBack != VK_NULL_HANDLE) ? &callBack : &msgCallback);
+        assert(!err);
+        (void)err; // Supress VC++ unused variable warning for Release config.
+    }
+    
+    void freeDebugCallback(VkInstance instance)
+    {
+        if (msgCallback != VK_NULL_HANDLE)
+        {
+            DestroyDebugReportCallback(instance, msgCallback, nullptr);
+        }
+    }
+
+    namespace DebugMarker
+    {
+        bool active = false;
+
+        PFN_vkDebugMarkerSetObjectTagEXT pfnDebugMarkerSetObjectTag = VK_NULL_HANDLE;
+        PFN_vkDebugMarkerSetObjectNameEXT pfnDebugMarkerSetObjectName = VK_NULL_HANDLE;
+        PFN_vkCmdDebugMarkerBeginEXT pfnCmdDebugMarkerBegin = VK_NULL_HANDLE;
+        PFN_vkCmdDebugMarkerEndEXT pfnCmdDebugMarkerEnd = VK_NULL_HANDLE;
+        PFN_vkCmdDebugMarkerInsertEXT pfnCmdDebugMarkerInsert = VK_NULL_HANDLE;
+
+        void setup(VkDevice device)
+        {
+            pfnDebugMarkerSetObjectTag = (PFN_vkDebugMarkerSetObjectTagEXT)vkGetDeviceProcAddr(device, "vkDebugMarkerSetObjectTagEXT");
+            pfnDebugMarkerSetObjectName = (PFN_vkDebugMarkerSetObjectNameEXT)vkGetDeviceProcAddr(device, "vkDebugMarkerSetObjectNameEXT");
+            pfnCmdDebugMarkerBegin = (PFN_vkCmdDebugMarkerBeginEXT)vkGetDeviceProcAddr(device, "vkCmdDebugMarkerBeginEXT");
+            pfnCmdDebugMarkerEnd = (PFN_vkCmdDebugMarkerEndEXT)vkGetDeviceProcAddr(device, "vkCmdDebugMarkerEndEXT");
+            pfnCmdDebugMarkerInsert = (PFN_vkCmdDebugMarkerInsertEXT)vkGetDeviceProcAddr(device, "vkCmdDebugMarkerInsertEXT");
+
+            // Set flag if at least one function pointer is present
+            active = (pfnDebugMarkerSetObjectName != VK_NULL_HANDLE);
+        }
+
+        void setObjectName(VkDevice device, uint64_t object, VkDebugReportObjectTypeEXT objectType, const char *name)
+        {
+            // Check for valid function pointer (may not be present if not running in a debugging application)
+            if (pfnDebugMarkerSetObjectName)
+            {
+                VkDebugMarkerObjectNameInfoEXT nameInfo = {};
+                nameInfo.sType = VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT;
+                nameInfo.objectType = objectType;
+                nameInfo.object = object;
+                nameInfo.pObjectName = name;
+                pfnDebugMarkerSetObjectName(device, &nameInfo);
+            }
+        }
+
+        void setObjectTag(VkDevice device, uint64_t object, VkDebugReportObjectTypeEXT objectType, uint64_t name, size_t tagSize, const void* tag)
+        {
+            // Check for valid function pointer (may not be present if not running in a debugging application)
+            if (pfnDebugMarkerSetObjectTag)
+            {
+                VkDebugMarkerObjectTagInfoEXT tagInfo = {};
+                tagInfo.sType = VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT;
+                tagInfo.objectType = objectType;
+                tagInfo.object = object;
+                tagInfo.tagName = name;
+                tagInfo.tagSize = tagSize;
+                tagInfo.pTag = tag;
+                pfnDebugMarkerSetObjectTag(device, &tagInfo);
+            }
+        }
+
+        void beginRegion(VkCommandBuffer cmdbuffer, const char* pMarkerName, glm::vec4 color)
+        {
+            // Check for valid function pointer (may not be present if not running in a debugging application)
+            if (pfnCmdDebugMarkerBegin)
+            {
+                VkDebugMarkerMarkerInfoEXT markerInfo = {};
+                markerInfo.sType = VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT;
+                memcpy(markerInfo.color, &color[0], sizeof(float) * 4);
+                markerInfo.pMarkerName = pMarkerName;
+                pfnCmdDebugMarkerBegin(cmdbuffer, &markerInfo);
+            }
+        }
+
+        void insert(VkCommandBuffer cmdbuffer, std::string markerName, glm::vec4 color)
+        {
+            // Check for valid function pointer (may not be present if not running in a debugging application)
+            if (pfnCmdDebugMarkerInsert)
+            {
+                VkDebugMarkerMarkerInfoEXT markerInfo = {};
+                markerInfo.sType = VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT;
+                memcpy(markerInfo.color, &color[0], sizeof(float) * 4);
+                markerInfo.pMarkerName = markerName.c_str();
+                pfnCmdDebugMarkerInsert(cmdbuffer, &markerInfo);
+            }
+        }
+
+        void endRegion(VkCommandBuffer cmdBuffer)
+        {
+            // Check for valid function (may not be present if not runnin in a debugging application)
+            if (pfnCmdDebugMarkerEnd)
+            {
+                pfnCmdDebugMarkerEnd(cmdBuffer);
+            }
+        }
+
+        void setCommandBufferName(VkDevice device, VkCommandBuffer cmdBuffer, const char * name)
+        {
+            setObjectName(device, (uint64_t)cmdBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, name);
+        }
+
+        void setQueueName(VkDevice device, VkQueue queue, const char * name)
+        {
+            setObjectName(device, (uint64_t)queue, VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT, name);
+        }
+
+        void setImageName(VkDevice device, VkImage image, const char * name)
+        {
+            setObjectName(device, (uint64_t)image, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, name);
+        }
+
+        void setSamplerName(VkDevice device, VkSampler sampler, const char * name)
+        {
+            setObjectName(device, (uint64_t)sampler, VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT, name);
+        }
+
+        void setBufferName(VkDevice device, VkBuffer buffer, const char * name)
+        {
+            setObjectName(device, (uint64_t)buffer, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, name);
+        }
+
+        void setDeviceMemoryName(VkDevice device, VkDeviceMemory memory, const char * name)
+        {
+            setObjectName(device, (uint64_t)memory, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, name);
+        }
+
+        void setShaderModuleName(VkDevice device, VkShaderModule shaderModule, const char * name)
+        {
+            setObjectName(device, (uint64_t)shaderModule, VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT, name);
+        }
+
+        void setPipelineName(VkDevice device, VkPipeline pipeline, const char * name)
+        {
+            setObjectName(device, (uint64_t)pipeline, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, name);
+        }
+
+        void setPipelineLayoutName(VkDevice device, VkPipelineLayout pipelineLayout, const char * name)
+        {
+            setObjectName(device, (uint64_t)pipelineLayout, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT, name);
+        }
+
+        void setRenderPassName(VkDevice device, VkRenderPass renderPass, const char * name)
+        {
+            setObjectName(device, (uint64_t)renderPass, VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT, name);
+        }
+
+        void setFramebufferName(VkDevice device, VkFramebuffer framebuffer, const char * name)
+        {
+            setObjectName(device, (uint64_t)framebuffer, VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT, name);
+        }
+
+        void setDescriptorSetLayoutName(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const char * name)
+        {
+            setObjectName(device, (uint64_t)descriptorSetLayout, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT, name);
+        }
+
+        void setDescriptorSetName(VkDevice device, VkDescriptorSet descriptorSet, const char * name)
+        {
+            setObjectName(device, (uint64_t)descriptorSet, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT, name);
+        }
+
+        void setSemaphoreName(VkDevice device, VkSemaphore semaphore, const char * name)
+        {
+            setObjectName(device, (uint64_t)semaphore, VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT, name);
+        }
+
+        void setFenceName(VkDevice device, VkFence fence, const char * name)
+        {
+            setObjectName(device, (uint64_t)fence, VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT, name);
+        }
+
+        void setEventName(VkDevice device, VkEvent _event, const char * name)
+        {
+            setObjectName(device, (uint64_t)_event, VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT, name);
+        }
+    }
+
+}
+
+// vi: set sw=2 ts=4 expandtab:
+

third_party/ktx-src/tests/loadtests/appfwSDL/VulkanAppSDL/vulkandebug.h

@@ -0,0 +1,106 @@
+/*
+ * Copyright 2017-2020 Mark Callow
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#pragma once
+#include "vulkan/vulkan.h"
+
+#include <math.h>
+#include <stdlib.h>
+#include <string>
+#include <cstring>
+#include <fstream>
+#include <assert.h>
+#include <stdio.h>
+#include <vector>
+#ifdef _WIN32
+  #include <windows.h>
+  #include <fcntl.h>
+  #include <io.h>
+#endif
+
+#define GLM_FORCE_RADIANS
+#define GLM_FORCE_DEPTH_ZERO_TO_ONE
+#include "disable_glm_warnings.h"
+#include <glm/glm.hpp>
+#include "reenable_warnings.h"
+
+namespace vkDebug
+{
+    // Default validation layers
+    extern int validationLayerCount;
+    extern const char *validationLayerNames[];
+
+    // Default debug callback
+    VkBool32 messageCallback(
+        VkDebugReportFlagsEXT flags,
+        VkDebugReportObjectTypeEXT objType,
+        uint64_t srcObject,
+        size_t location,
+        int32_t msgCode,
+        const char* pLayerPrefix,
+        const char* pMsg,
+        void* pUserData);
+
+    // Load debug function pointers and set debug callback
+    // if callBack is NULL, default message callback will be used
+    void setupDebugging(
+        VkInstance instance, 
+        VkDebugReportFlagsEXT flags, 
+        VkDebugReportCallbackEXT callBack);
+    // Clear debug callback
+    void freeDebugCallback(VkInstance instance);
+
+    // Setup and functions for the VK_EXT_debug_marker_extension
+    // Extension spec can be found at https://github.com/KhronosGroup/Vulkan-Docs/blob/1.0-VK_EXT_debug_marker/doc/specs/vulkan/appendices/VK_EXT_debug_marker.txt
+    // Note that the extension will only be present if run from an offline debugging application
+    // The actual check for extension presence and enabling it on the device is done in the example base class
+    // See VulkanExampleBase::createInstance and VulkanExampleBase::createDevice (base/vulkanexamplebase.cpp)
+    namespace DebugMarker
+    {
+        // Set to true if function pointer for the debug marker are available
+        extern bool active;
+
+        // Get function pointers for the debug report extensions from the device
+        void setup(VkDevice device);
+
+        // Sets the debug name of an object
+        // All Objects in Vulkan are represented by their 64-bit handles which are passed into this function
+        // along with the object type
+        void setObjectName(VkDevice device, uint64_t object, VkDebugReportObjectTypeEXT objectType, const char *name);
+
+        // Set the tag for an object
+        void setObjectTag(VkDevice device, uint64_t object, VkDebugReportObjectTypeEXT objectType, uint64_t name, size_t tagSize, const void* tag);
+
+        // Start a new debug marker region
+        void beginRegion(VkCommandBuffer cmdbuffer, const char* pMarkerName, glm::vec4 color);
+
+        // Insert a new debug marker into the command buffer
+        void insert(VkCommandBuffer cmdbuffer, std::string markerName, glm::vec4 color);
+
+        // End the current debug marker region
+        void endRegion(VkCommandBuffer cmdBuffer);
+
+        // Object specific naming functions
+        void setCommandBufferName(VkDevice device, VkCommandBuffer cmdBuffer, const char * name);
+        void setQueueName(VkDevice device, VkQueue queue, const char * name);
+        void setImageName(VkDevice device, VkImage image, const char * name);
+        void setSamplerName(VkDevice device, VkSampler sampler, const char * name);
+        void setBufferName(VkDevice device, VkBuffer buffer, const char * name);
+        void setDeviceMemoryName(VkDevice device, VkDeviceMemory memory, const char * name);
+        void setShaderModuleName(VkDevice device, VkShaderModule shaderModule, const char * name);
+        void setPipelineName(VkDevice device, VkPipeline pipeline, const char * name);
+        void setPipelineLayoutName(VkDevice device, VkPipelineLayout pipelineLayout, const char * name);
+        void setRenderPassName(VkDevice device, VkRenderPass renderPass, const char * name);
+        void setFramebufferName(VkDevice device, VkFramebuffer framebuffer, const char * name);
+        void setDescriptorSetLayoutName(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const char * name);
+        void setDescriptorSetName(VkDevice device, VkDescriptorSet descriptorSet, const char * name);
+        void setSemaphoreName(VkDevice device, VkSemaphore semaphore, const char * name);
+        void setFenceName(VkDevice device, VkFence fence, const char * name);
+        void setEventName(VkDevice device, VkEvent _event, const char * name);
+    }
+
+}
+
+// vi: set sw=2 ts=4 expandtab:

third_party/ktx-src/tests/loadtests/appfwSDL/VulkanAppSDL/vulkantextoverlay.hpp

@@ -0,0 +1,839 @@
+/*
+* Copyright 2016 Sascha Willems - www.saschawillems.de
+* SPDX-License-Identifier: MIT
+*
+* Text overlay class for displaying debug information
+*
+*/
+
+#pragma once
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <vector>
+#include <sstream>
+#include <iomanip>
+
+#include <vulkan/vulkan.h>
+#include "vulkantools.h"
+#include "vulkandebug.h"
+
+#include "stb/stb_font_consolas_24_latin1.inl"
+
+// Defines for the STB font used
+// STB font files can be found at http://nothings.org/stb/font/
+#define STB_FONT_NAME stb_font_consolas_24_latin1
+#define STB_FONT_WIDTH STB_FONT_consolas_24_latin1_BITMAP_WIDTH
+#define STB_FONT_HEIGHT STB_FONT_consolas_24_latin1_BITMAP_HEIGHT 
+#define STB_FIRST_CHAR STB_FONT_consolas_24_latin1_FIRST_CHAR
+#define STB_NUM_CHARS STB_FONT_consolas_24_latin1_NUM_CHARS
+#define STB_MISSING_GLPYH 0x80 // Actually a control character.
+
+// Max. number of chars the text overlay buffer can hold
+#define MAX_CHAR_COUNT 1024
+
+
+/**
+ * @internal
+ * @brief Given the lead byte of a UTF-8 sequence returns the expected length of the codepoint
+ * @param[in] leadByte The lead byte of a UTF-8 sequence
+ * @return The expected length of the codepoint */
+[[nodiscard]] constexpr inline int sequenceLength(uint8_t leadByte) noexcept {
+    if ((leadByte & 0b1000'0000u) == 0b0000'0000u)
+        return 1;
+    if ((leadByte & 0b1110'0000u) == 0b1100'0000u)
+        return 2;
+    if ((leadByte & 0b1111'0000u) == 0b1110'0000u)
+        return 3;
+    if ((leadByte & 0b1111'1000u) == 0b1111'0000u)
+        return 4;
+
+    return 0;
+}
+
+/**
+ * @internal
+ * @brief Checks if the codepoint was coded as a longer than required sequence
+ * @param[in] codepoint The unicode codepoint
+ * @param[in] length The UTF-8 sequence length
+ * @return True if the sequence length was inappropriate for the given codepoint */
+[[nodiscard]] constexpr inline bool isOverlongSequence(uint32_t codepoint, int length) noexcept {
+    if (codepoint < 0x80)
+        return length != 1;
+    else if (codepoint < 0x800)
+        return length != 2;
+    else if (codepoint < 0x10000)
+        return length != 3;
+    else
+        return false;
+}
+
+/**
+ * @internal
+ * @brief Checks if the codepoint is valid
+ * @param[in] codepoint The unicode codepoint
+ * @return True if the codepoint is a valid unicode codepoint */
+[[nodiscard]] constexpr inline bool isCodepointValid(uint32_t codepoint) noexcept {
+    return codepoint <= 0x0010FFFFu
+            && !(0xD800u <= codepoint && codepoint <= 0xDBFFu);
+}
+
+/**
+ * @internal
+ * @brief Safely checks and advances a UTF-8 sequence iterator to the start of the next unicode codepoint
+ * @param[in] it iterator to be advanced
+ * @param[in] end iterator pointing to the end of the range
+ * @return True if the advance operation was successful and the advanced codepoint was a valid UTF-8 sequence */
+template <typename Iterator>
+[[nodiscard]] constexpr bool advanceUTF8(Iterator& it, Iterator end,
+                                         uint32_t& codepoint) noexcept {
+    if (it == end)
+        return false;
+
+    const auto length = sequenceLength(*it);
+    if (length == 0)
+        return false;
+
+    if (std::distance(it, end) < length)
+        return false;
+
+    for (int i = 1; i < length; ++i) {
+        const auto trailByte = *(it + i);
+        if ((static_cast<uint8_t>(trailByte) & 0b1100'0000u) != 0b1000'0000u)
+            return false;
+    }
+
+    codepoint = 0;
+    switch (length) {
+    case 1:
+        codepoint |= *it++;
+        break;
+    case 2:
+        codepoint |= (*it++ & 0b0001'1111u) << 6u;
+        codepoint |= (*it++ & 0b0011'1111u);
+        break;
+    case 3:
+        codepoint |= (*it++ & 0b0000'1111u) << 12u;
+        codepoint |= (*it++ & 0b0011'1111u) << 6u;
+        codepoint |= (*it++ & 0b0011'1111u);
+        break;
+    case 4:
+        codepoint |= (*it++ & 0b0000'0111u) << 18u;
+        codepoint |= (*it++ & 0b0011'1111u) << 12u;
+        codepoint |= (*it++ & 0b0011'1111u) << 6u;
+        codepoint |= (*it++ & 0b0011'1111u);
+        break;
+    }
+
+    if (!isCodepointValid(codepoint))
+        return false;
+
+    if (isOverlongSequence(codepoint, length))
+        return false;
+
+    return true;
+}
+
+// Mostly self-contained text overlay class
+// todo : comment
+class VulkanTextOverlay
+{
+private:
+    VkPhysicalDevice physicalDevice;
+    VkDevice device;
+    VkPhysicalDeviceMemoryProperties deviceMemoryProperties;
+    VkQueue queue;
+    VkFormat colorFormat;
+    VkFormat depthFormat;
+
+    uint32_t *frameBufferWidth;
+    uint32_t *frameBufferHeight;
+
+    VkSampler sampler;
+    VkImage image;
+    VkImageView view;
+    VkBuffer buffer;
+    VkDeviceMemory memory;
+    VkDeviceMemory imageMemory;
+    VkDescriptorPool descriptorPool;
+    VkDescriptorSetLayout descriptorSetLayout;
+    VkDescriptorSet descriptorSet;
+    VkPipelineLayout pipelineLayout;
+    VkPipelineCache pipelineCache;
+    VkPipeline pipeline;
+    VkRenderPass renderPass;
+    VkCommandPool commandPool;
+    std::vector<VkFramebuffer*> frameBuffers;
+    std::vector<VkPipelineShaderStageCreateInfo> shaderStages;
+
+    // Pointer to mapped vertex buffer
+    glm::vec4 *mapped = nullptr;
+    // Used during text updates
+    glm::vec4 *mappedLocal = nullptr;
+
+    stb_fontchar stbFontData[STB_NUM_CHARS];
+    uint32_t numLetters;
+
+    // Try to find appropriate memory type for a memory allocation
+    uint32_t getMemoryType(uint32_t typeBits, VkFlags properties)
+    {
+        for (uint32_t i = 0; i < 32; i++)
+        {
+            if ((typeBits & 1) == 1)
+            {
+                if ((deviceMemoryProperties.memoryTypes[i].propertyFlags & properties) == properties)
+                {
+                    return i;
+                }
+            }
+            typeBits >>= 1;
+        }
+
+        // todo : throw error
+        return 0;
+    }
+
+public:
+
+    enum TextAlign { alignLeft, alignCenter, alignRight };
+
+    bool visible = true;
+    bool invalidated = false;
+
+    std::vector<VkCommandBuffer> cmdBuffers;
+
+    VulkanTextOverlay(
+        VkPhysicalDevice physicalDevice,
+        VkDevice device,
+        VkQueue queue,
+        std::vector<VkFramebuffer> &framebuffers,
+        VkFormat colorformat,
+        VkFormat depthformat,
+        uint32_t *framebufferwidth,
+        uint32_t *framebufferheight,
+        std::vector<VkPipelineShaderStageCreateInfo> shaderstages)
+    {
+        this->physicalDevice = physicalDevice;
+        this->device = device;
+        this->queue = queue;
+        this->colorFormat = colorformat;
+        this->depthFormat = depthformat;
+
+        this->frameBuffers.resize(framebuffers.size());
+        for (uint32_t i = 0; i < framebuffers.size(); i++)
+        {
+            this->frameBuffers[i] = &framebuffers[i];
+        }
+
+        this->shaderStages = shaderstages;
+
+        this->frameBufferWidth = framebufferwidth;
+        this->frameBufferHeight = framebufferheight;
+
+        vkGetPhysicalDeviceMemoryProperties(physicalDevice, &deviceMemoryProperties);
+        cmdBuffers.resize(framebuffers.size());
+        prepareResources();
+        prepareRenderPass();
+        preparePipeline();
+    }
+
+    ~VulkanTextOverlay()
+    {
+        // Free up all Vulkan resources requested by the text overlay
+        vkDestroySampler(device, sampler, nullptr);
+        vkDestroyImage(device, image, nullptr);
+        vkDestroyImageView(device, view, nullptr);
+        vkDestroyBuffer(device, buffer, nullptr);
+        vkFreeMemory(device, memory, nullptr);
+        vkFreeMemory(device, imageMemory, nullptr);
+        vkDestroyDescriptorSetLayout(device, descriptorSetLayout, nullptr);
+        vkDestroyDescriptorPool(device, descriptorPool, nullptr);
+        vkDestroyPipelineLayout(device, pipelineLayout, nullptr);
+        vkDestroyPipelineCache(device, pipelineCache, nullptr);
+        vkDestroyPipeline(device, pipeline, nullptr);
+        vkDestroyRenderPass(device, renderPass, nullptr);
+        vkFreeCommandBuffers(device, commandPool, static_cast<uint32_t>(cmdBuffers.size()), cmdBuffers.data());
+        vkDestroyCommandPool(device, commandPool, nullptr);
+    }
+
+    // Prepare all vulkan resources required to render the font
+    // The text overlay uses separate resources for descriptors (pool, sets, layouts), pipelines and command buffers
+    void prepareResources()
+    {
+        static unsigned char font24pixels[STB_FONT_HEIGHT][STB_FONT_WIDTH];
+        STB_FONT_NAME(stbFontData, font24pixels, STB_FONT_HEIGHT);
+
+        // Command buffer
+
+        // Pool
+        VkCommandPoolCreateInfo cmdPoolInfo = {};
+        cmdPoolInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
+        cmdPoolInfo.queueFamilyIndex = 0; // todo : pass from example base / swap chain
+        cmdPoolInfo.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
+        VK_CHECK_RESULT(vkCreateCommandPool(device, &cmdPoolInfo, nullptr, &commandPool));
+
+        VkCommandBufferAllocateInfo cmdBufAllocateInfo =
+            vkTools::initializers::commandBufferAllocateInfo(
+                commandPool,
+                VK_COMMAND_BUFFER_LEVEL_PRIMARY,
+                (uint32_t)cmdBuffers.size());
+
+        VK_CHECK_RESULT(vkAllocateCommandBuffers(device, &cmdBufAllocateInfo, cmdBuffers.data()));
+
+        // Vertex buffer, 4 per character.
+        VkDeviceSize bufferSize = MAX_CHAR_COUNT * sizeof(glm::vec4) * 4;
+
+        VkBufferCreateInfo bufferInfo = vkTools::initializers::bufferCreateInfo(VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, bufferSize);
+        VK_CHECK_RESULT(vkCreateBuffer(device, &bufferInfo, nullptr, &buffer));
+
+        VkMemoryRequirements memReqs;
+        VkMemoryAllocateInfo allocInfo = vkTools::initializers::memoryAllocateInfo();
+
+        vkGetBufferMemoryRequirements(device, buffer, &memReqs);
+        allocInfo.allocationSize = memReqs.size;
+        allocInfo.memoryTypeIndex = getMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
+        VK_CHECK_RESULT(vkAllocateMemory(device, &allocInfo, nullptr, &memory));
+        VK_CHECK_RESULT(vkBindBufferMemory(device, buffer, memory, 0));
+
+        // Map persistent
+        VK_CHECK_RESULT(vkMapMemory(device, memory, 0, VK_WHOLE_SIZE, 0, (void **)&mapped));
+
+
+        // Font texture
+        VkImageCreateInfo imageInfo = vkTools::initializers::imageCreateInfo();
+        imageInfo.imageType = VK_IMAGE_TYPE_2D;
+        imageInfo.format = VK_FORMAT_R8_UNORM;
+        imageInfo.extent.width = STB_FONT_WIDTH;
+        imageInfo.extent.height = STB_FONT_HEIGHT;
+        imageInfo.extent.depth = 1;
+        imageInfo.mipLevels = 1;
+        imageInfo.arrayLayers = 1;
+        imageInfo.samples = VK_SAMPLE_COUNT_1_BIT;
+        imageInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
+        imageInfo.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT;
+        imageInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
+        imageInfo.initialLayout = VK_IMAGE_LAYOUT_PREINITIALIZED;
+        VK_CHECK_RESULT(vkCreateImage(device, &imageInfo, nullptr, &image));
+
+        vkGetImageMemoryRequirements(device, image, &memReqs);
+        allocInfo.allocationSize = memReqs.size;
+        allocInfo.memoryTypeIndex = getMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
+        VK_CHECK_RESULT(vkAllocateMemory(device, &allocInfo, nullptr, &imageMemory));
+        VK_CHECK_RESULT(vkBindImageMemory(device, image, imageMemory, 0));
+
+        // Staging
+
+        struct {
+            VkDeviceMemory memory;
+            VkBuffer buffer;
+        } stagingBuffer;
+
+        VkBufferCreateInfo bufferCreateInfo = vkTools::initializers::bufferCreateInfo();
+        bufferCreateInfo.size = allocInfo.allocationSize;
+        bufferCreateInfo.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
+        bufferCreateInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
+
+        VK_CHECK_RESULT(vkCreateBuffer(device, &bufferCreateInfo, nullptr, &stagingBuffer.buffer));
+
+        // Get memory requirements for the staging buffer (alignment, memory type bits)
+        vkGetBufferMemoryRequirements(device, stagingBuffer.buffer, &memReqs);
+
+        allocInfo.allocationSize = memReqs.size;
+        // Get memory type index for a host visible buffer
+        allocInfo.memoryTypeIndex = getMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT);
+
+        VK_CHECK_RESULT(vkAllocateMemory(device, &allocInfo, nullptr, &stagingBuffer.memory));
+        VK_CHECK_RESULT(vkBindBufferMemory(device, stagingBuffer.buffer, stagingBuffer.memory, 0));
+
+        uint8_t *data;
+        VK_CHECK_RESULT(vkMapMemory(device, stagingBuffer.memory, 0, allocInfo.allocationSize, 0, (void **)&data));
+        memcpy(data, &font24pixels[0][0], STB_FONT_WIDTH * STB_FONT_HEIGHT);
+        vkUnmapMemory(device, stagingBuffer.memory);
+
+        // Copy to image
+
+        VkCommandBuffer copyCmd;
+        cmdBufAllocateInfo.commandBufferCount = 1;
+        VK_CHECK_RESULT(vkAllocateCommandBuffers(device, &cmdBufAllocateInfo, &copyCmd));
+
+        VkCommandBufferBeginInfo cmdBufInfo = vkTools::initializers::commandBufferBeginInfo();
+        VK_CHECK_RESULT(vkBeginCommandBuffer(copyCmd, &cmdBufInfo));
+
+        // Prepare for transfer
+        vkTools::setImageLayout(
+            copyCmd,
+            image,
+            VK_IMAGE_ASPECT_COLOR_BIT,
+            VK_IMAGE_LAYOUT_PREINITIALIZED,
+            VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
+
+        VkBufferImageCopy bufferCopyRegion = {};
+        bufferCopyRegion.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+        bufferCopyRegion.imageSubresource.mipLevel = 0;
+        bufferCopyRegion.imageSubresource.layerCount = 1;
+        bufferCopyRegion.imageExtent.width = STB_FONT_WIDTH;
+        bufferCopyRegion.imageExtent.height = STB_FONT_HEIGHT;
+        bufferCopyRegion.imageExtent.depth = 1;
+
+        vkCmdCopyBufferToImage(
+            copyCmd,
+            stagingBuffer.buffer,
+            image,
+            VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
+            1,
+            &bufferCopyRegion
+            );
+
+        // Prepare for shader read
+        vkTools::setImageLayout(
+            copyCmd,
+            image,
+            VK_IMAGE_ASPECT_COLOR_BIT,
+            VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
+            VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
+
+        VK_CHECK_RESULT(vkEndCommandBuffer(copyCmd));
+
+        VkSubmitInfo submitInfo = vkTools::initializers::submitInfo();
+        submitInfo.commandBufferCount = 1;
+        submitInfo.pCommandBuffers = &copyCmd;
+
+        VK_CHECK_RESULT(vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE));
+        VK_CHECK_RESULT(vkQueueWaitIdle(queue));
+
+        vkFreeCommandBuffers(device, commandPool, 1, &copyCmd);
+        vkFreeMemory(device, stagingBuffer.memory, nullptr);
+        vkDestroyBuffer(device, stagingBuffer.buffer, nullptr);
+
+
+        VkImageViewCreateInfo imageViewInfo = vkTools::initializers::imageViewCreateInfo();
+        imageViewInfo.image = image;
+        imageViewInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
+        imageViewInfo.format = imageInfo.format;
+        imageViewInfo.components = {
+            VK_COMPONENT_SWIZZLE_IDENTITY,
+            VK_COMPONENT_SWIZZLE_IDENTITY,
+            VK_COMPONENT_SWIZZLE_IDENTITY,
+            VK_COMPONENT_SWIZZLE_IDENTITY
+        };
+        imageViewInfo.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 };
+
+        VK_CHECK_RESULT(vkCreateImageView(device, &imageViewInfo, nullptr, &view));
+
+        // Sampler
+        VkSamplerCreateInfo samplerInfo = vkTools::initializers::samplerCreateInfo();
+        samplerInfo.magFilter = VK_FILTER_LINEAR;
+        samplerInfo.minFilter = VK_FILTER_LINEAR;
+        samplerInfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR;
+        samplerInfo.addressModeU = VK_SAMPLER_ADDRESS_MODE_REPEAT;
+        samplerInfo.addressModeV = VK_SAMPLER_ADDRESS_MODE_REPEAT;
+        samplerInfo.addressModeW = VK_SAMPLER_ADDRESS_MODE_REPEAT;
+        samplerInfo.mipLodBias = 0.0f;
+        samplerInfo.compareOp = VK_COMPARE_OP_NEVER;
+        samplerInfo.minLod = 0.0f;
+        samplerInfo.maxLod = 1.0f;
+        samplerInfo.borderColor = VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE;
+        samplerInfo.anisotropyEnable = VK_FALSE;
+        samplerInfo.maxAnisotropy = 1.0;
+        VK_CHECK_RESULT(vkCreateSampler(device, &samplerInfo, nullptr, &sampler));
+
+        // Descriptor
+        // Font uses a separate descriptor pool
+        std::array<VkDescriptorPoolSize, 1> poolSizes;
+        poolSizes[0] = vkTools::initializers::descriptorPoolSize(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1);
+
+        VkDescriptorPoolCreateInfo descriptorPoolInfo =
+            vkTools::initializers::descriptorPoolCreateInfo(
+                static_cast<uint32_t>(poolSizes.size()),
+                poolSizes.data(),
+                1);
+
+        VK_CHECK_RESULT(vkCreateDescriptorPool(device, &descriptorPoolInfo, nullptr, &descriptorPool));
+
+        // Descriptor set layout
+        std::array<VkDescriptorSetLayoutBinding, 1> setLayoutBindings;
+        setLayoutBindings[0] = vkTools::initializers::descriptorSetLayoutBinding(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_SHADER_STAGE_FRAGMENT_BIT, 0);
+
+        VkDescriptorSetLayoutCreateInfo descriptorSetLayoutInfo =
+            vkTools::initializers::descriptorSetLayoutCreateInfo(
+                setLayoutBindings.data(),
+                static_cast<uint32_t>(setLayoutBindings.size()));
+
+        VK_CHECK_RESULT(vkCreateDescriptorSetLayout(device, &descriptorSetLayoutInfo, nullptr, &descriptorSetLayout));
+
+        // Pipeline layout
+        VkPipelineLayoutCreateInfo pipelineLayoutInfo =
+            vkTools::initializers::pipelineLayoutCreateInfo(
+                &descriptorSetLayout,
+                1);
+
+        VK_CHECK_RESULT(vkCreatePipelineLayout(device, &pipelineLayoutInfo, nullptr, &pipelineLayout));
+
+        // Descriptor set
+        VkDescriptorSetAllocateInfo descriptorSetAllocInfo =
+            vkTools::initializers::descriptorSetAllocateInfo(
+                descriptorPool,
+                &descriptorSetLayout,
+                1);
+
+        VK_CHECK_RESULT(vkAllocateDescriptorSets(device, &descriptorSetAllocInfo, &descriptorSet));
+
+        VkDescriptorImageInfo texDescriptor =
+            vkTools::initializers::descriptorImageInfo(
+                sampler,
+                view,
+                VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
+
+        std::array<VkWriteDescriptorSet, 1> writeDescriptorSets;
+        writeDescriptorSets[0] = vkTools::initializers::writeDescriptorSet(descriptorSet, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 0, &texDescriptor);
+        vkUpdateDescriptorSets(device, static_cast<uint32_t>(writeDescriptorSets.size()), writeDescriptorSets.data(), 0, NULL);
+
+        // Pipeline cache
+        VkPipelineCacheCreateInfo pipelineCacheCreateInfo = {};
+        pipelineCacheCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO;
+        VK_CHECK_RESULT(vkCreatePipelineCache(device, &pipelineCacheCreateInfo, nullptr, &pipelineCache));
+    }
+
+    // Prepare a separate pipeline for the font rendering decoupled from the main application
+    void preparePipeline()
+    {
+        VkPipelineInputAssemblyStateCreateInfo inputAssemblyState =
+            vkTools::initializers::pipelineInputAssemblyStateCreateInfo(
+                VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP,
+                0,
+                // primmitiveRestartEnable not needed but disabling it results in a MoltenVK
+                // feature not present warning.
+                VK_TRUE);
+
+        VkPipelineRasterizationStateCreateInfo rasterizationState =
+            vkTools::initializers::pipelineRasterizationStateCreateInfo(
+                VK_POLYGON_MODE_FILL,
+                VK_CULL_MODE_BACK_BIT,
+                VK_FRONT_FACE_CLOCKWISE,
+                0);
+        // Because we haven't enabled the depthClamp device feature.
+        rasterizationState.depthClampEnable = VK_FALSE;
+
+        // Enable blending
+        VkPipelineColorBlendAttachmentState blendAttachmentState =
+            vkTools::initializers::pipelineColorBlendAttachmentState(0xf, VK_TRUE);
+
+        blendAttachmentState.srcColorBlendFactor = VK_BLEND_FACTOR_ONE;
+        blendAttachmentState.dstColorBlendFactor = VK_BLEND_FACTOR_ONE;
+        blendAttachmentState.colorBlendOp = VK_BLEND_OP_ADD;
+        blendAttachmentState.srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE;
+        blendAttachmentState.dstAlphaBlendFactor = VK_BLEND_FACTOR_ONE;
+        blendAttachmentState.alphaBlendOp = VK_BLEND_OP_ADD;
+        blendAttachmentState.colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
+
+        VkPipelineColorBlendStateCreateInfo colorBlendState =
+            vkTools::initializers::pipelineColorBlendStateCreateInfo(
+                1,
+                &blendAttachmentState);
+
+        VkPipelineDepthStencilStateCreateInfo depthStencilState =
+            vkTools::initializers::pipelineDepthStencilStateCreateInfo(
+                VK_FALSE,
+                VK_FALSE,
+                VK_COMPARE_OP_LESS_OR_EQUAL);
+
+        VkPipelineViewportStateCreateInfo viewportState =
+            vkTools::initializers::pipelineViewportStateCreateInfo(1, 1, 0);
+
+        VkPipelineMultisampleStateCreateInfo multisampleState =
+            vkTools::initializers::pipelineMultisampleStateCreateInfo(
+                VK_SAMPLE_COUNT_1_BIT,
+                0);
+
+        std::vector<VkDynamicState> dynamicStateEnables = {
+            VK_DYNAMIC_STATE_VIEWPORT,
+            VK_DYNAMIC_STATE_SCISSOR
+        };
+
+        VkPipelineDynamicStateCreateInfo dynamicState =
+            vkTools::initializers::pipelineDynamicStateCreateInfo(
+                dynamicStateEnables.data(),
+                static_cast<uint32_t>(dynamicStateEnables.size()),
+                0);
+
+        std::array<VkVertexInputBindingDescription, 2> vertexBindings = {};
+        vertexBindings[0] = vkTools::initializers::vertexInputBindingDescription(0, sizeof(glm::vec4), VK_VERTEX_INPUT_RATE_VERTEX);
+        vertexBindings[1] = vkTools::initializers::vertexInputBindingDescription(1, sizeof(glm::vec4), VK_VERTEX_INPUT_RATE_VERTEX);
+
+        std::array<VkVertexInputAttributeDescription, 2> vertexAttribs = {};
+        // Position
+        vertexAttribs[0] = vkTools::initializers::vertexInputAttributeDescription(0, 0, VK_FORMAT_R32G32_SFLOAT, 0);
+        // UV
+        vertexAttribs[1] = vkTools::initializers::vertexInputAttributeDescription(1, 1, VK_FORMAT_R32G32_SFLOAT, sizeof(glm::vec2));
+
+        VkPipelineVertexInputStateCreateInfo inputState = vkTools::initializers::pipelineVertexInputStateCreateInfo();
+        inputState.vertexBindingDescriptionCount = static_cast<uint32_t>(vertexBindings.size());
+        inputState.pVertexBindingDescriptions = vertexBindings.data();
+        inputState.vertexAttributeDescriptionCount = static_cast<uint32_t>(vertexAttribs.size());
+        inputState.pVertexAttributeDescriptions = vertexAttribs.data();
+
+        VkGraphicsPipelineCreateInfo pipelineCreateInfo =
+            vkTools::initializers::pipelineCreateInfo(
+                pipelineLayout,
+                renderPass,
+                0);
+
+        pipelineCreateInfo.pVertexInputState = &inputState;
+        pipelineCreateInfo.pInputAssemblyState = &inputAssemblyState;
+        pipelineCreateInfo.pRasterizationState = &rasterizationState;
+        pipelineCreateInfo.pColorBlendState = &colorBlendState;
+        pipelineCreateInfo.pMultisampleState = &multisampleState;
+        pipelineCreateInfo.pViewportState = &viewportState;
+        pipelineCreateInfo.pDepthStencilState = &depthStencilState;
+        pipelineCreateInfo.pDynamicState = &dynamicState;
+        pipelineCreateInfo.stageCount = static_cast<uint32_t>(shaderStages.size());
+        pipelineCreateInfo.pStages = shaderStages.data();
+
+        VK_CHECK_RESULT(vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCreateInfo, nullptr, &pipeline));
+    }
+
+    // Prepare a separate render pass for rendering the text as an overlay
+    void prepareRenderPass()
+    {
+        VkAttachmentDescription attachments[2] = {};
+
+        // Color attachment
+        attachments[0].format = colorFormat;
+        attachments[0].samples = VK_SAMPLE_COUNT_1_BIT;
+        // Don't clear the framebuffer (like the renderpass from the example does)
+        attachments[0].loadOp = VK_ATTACHMENT_LOAD_OP_LOAD;
+        attachments[0].storeOp = VK_ATTACHMENT_STORE_OP_STORE;
+        attachments[0].stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
+        attachments[0].stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
+        attachments[0].initialLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
+        attachments[0].finalLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
+
+        // Depth attachment
+        attachments[1].format = depthFormat;
+        attachments[1].samples = VK_SAMPLE_COUNT_1_BIT;
+        attachments[1].loadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
+        attachments[1].storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
+        attachments[1].stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
+        attachments[1].stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
+        attachments[1].initialLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
+        attachments[1].finalLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
+
+        VkAttachmentReference colorReference = {};
+        colorReference.attachment = 0;
+        colorReference.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
+
+        VkAttachmentReference depthReference = {};
+        depthReference.attachment = 1;
+        depthReference.layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
+
+        VkSubpassDescription subpass = {};
+        subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
+        subpass.flags = 0;
+        subpass.inputAttachmentCount = 0;
+        subpass.pInputAttachments = NULL;
+        subpass.colorAttachmentCount = 1;
+        subpass.pColorAttachments = &colorReference;
+        subpass.pResolveAttachments = NULL;
+        subpass.pDepthStencilAttachment = &depthReference;
+        subpass.preserveAttachmentCount = 0;
+        subpass.pPreserveAttachments = NULL;
+
+        VkRenderPassCreateInfo renderPassInfo = {};
+        renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
+        renderPassInfo.pNext = NULL;
+        renderPassInfo.attachmentCount = 2;
+        renderPassInfo.pAttachments = attachments;
+        renderPassInfo.subpassCount = 1;
+        renderPassInfo.pSubpasses = &subpass;
+        renderPassInfo.dependencyCount = 0;
+        renderPassInfo.pDependencies = NULL;
+
+        VK_CHECK_RESULT(vkCreateRenderPass(device, &renderPassInfo, nullptr, &renderPass));
+    }
+
+    // Map buffer 
+    void beginTextUpdate()
+    {
+        mappedLocal = mapped;
+        numLetters = 0;
+    }
+
+    // Add text to the current buffer
+    // todo : drop shadow? color attribute?
+    void addText(std::string text, float x, float y, TextAlign align)
+    {
+        if (numLetters == MAX_CHAR_COUNT)
+            return;
+
+        assert(mapped != nullptr);
+
+        const float charW = 1.5f / *frameBufferWidth;
+        const float charH = 1.5f / *frameBufferHeight;
+
+        float fbW = (float)*frameBufferWidth;
+        float fbH = (float)*frameBufferHeight;
+        x = (x / fbW * 2.0f) - 1.0f;
+        y = (y / fbH * 2.0f) - 1.0f;
+
+        // Calculate text width
+        float textWidth = 0;
+        uint32_t codepoint;
+        auto it = text.begin();
+        while (it != text.end())
+        {
+            if (!advanceUTF8(it, text.end(), codepoint))
+                break;
+            // TODO: Get a UTF8 font. Consider changing to Dear ImGUI
+            // https://github.com/ocornut/imgui.
+            // Placeholder to avoid crashing.
+            if (codepoint > STB_NUM_CHARS + STB_FIRST_CHAR)
+                codepoint = STB_MISSING_GLPYH;
+            stb_fontchar *charData = &stbFontData[(uint32_t)codepoint - STB_FIRST_CHAR];
+            textWidth += charData->advance * charW;
+        }
+        switch (align)
+        {
+        case alignRight:
+            x -= textWidth;
+            break;
+        case alignCenter:
+            x -= textWidth / 2.0f;
+            break;
+        case alignLeft:
+            break;
+        }
+
+        // Generate a uv mapped quad per char in the new text
+        it = text.begin();
+        while (it != text.end())
+        {
+            if (!advanceUTF8(it, text.end(), codepoint))
+                break;
+            if (codepoint > STB_NUM_CHARS + STB_FIRST_CHAR)
+                codepoint = STB_MISSING_GLPYH;
+
+            stb_fontchar *charData = &stbFontData[(uint32_t)codepoint - STB_FIRST_CHAR];
+
+            mappedLocal->x = (x + (float)charData->x0 * charW);
+            mappedLocal->y = (y + (float)charData->y0 * charH);
+            mappedLocal->z = charData->s0;
+            mappedLocal->w = charData->t0;
+            mappedLocal++;
+
+            mappedLocal->x = (x + (float)charData->x1 * charW);
+            mappedLocal->y = (y + (float)charData->y0 * charH);
+            mappedLocal->z = charData->s1;
+            mappedLocal->w = charData->t0;
+            mappedLocal++;
+
+            mappedLocal->x = (x + (float)charData->x0 * charW);
+            mappedLocal->y = (y + (float)charData->y1 * charH);
+            mappedLocal->z = charData->s0;
+            mappedLocal->w = charData->t1;
+            mappedLocal++;
+
+            mappedLocal->x = (x + (float)charData->x1 * charW);
+            mappedLocal->y = (y + (float)charData->y1 * charH);
+            mappedLocal->z = charData->s1;
+            mappedLocal->w = charData->t1;
+            mappedLocal++;
+
+            x += charData->advance * charW;
+
+            numLetters++;
+
+            if (numLetters == MAX_CHAR_COUNT)
+                break; // Truncate the text.
+        }
+    }
+    // Unmap buffer and update command buffers
+    void endTextUpdate()
+    {
+        updateCommandBuffers();
+    }
+
+    // Needs to be called by the application
+    void updateCommandBuffers()
+    {
+        VkCommandBufferBeginInfo cmdBufInfo = vkTools::initializers::commandBufferBeginInfo();
+
+        VkRenderPassBeginInfo renderPassBeginInfo = vkTools::initializers::renderPassBeginInfo();
+        renderPassBeginInfo.renderPass = renderPass;
+        renderPassBeginInfo.renderArea.extent.width = *frameBufferWidth;
+        renderPassBeginInfo.renderArea.extent.height = *frameBufferHeight;
+        renderPassBeginInfo.clearValueCount = 0;
+        renderPassBeginInfo.pClearValues = nullptr;
+
+        for (uint32_t i = 0; i < cmdBuffers.size(); ++i)
+        {
+            renderPassBeginInfo.framebuffer = *frameBuffers[i];
+
+            VK_CHECK_RESULT(vkBeginCommandBuffer(cmdBuffers[i], &cmdBufInfo));
+
+            if (vkDebug::DebugMarker::active)
+            {
+                vkDebug::DebugMarker::beginRegion(cmdBuffers[i], "Text overlay", glm::vec4(1.0f, 0.94f, 0.3f, 1.0f));
+            }
+
+            vkCmdBeginRenderPass(cmdBuffers[i], &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);
+
+            VkViewport viewport = vkTools::initializers::viewport((float)*frameBufferWidth, (float)*frameBufferHeight, 0.0f, 1.0f);
+            vkCmdSetViewport(cmdBuffers[i], 0, 1, &viewport);
+
+            VkRect2D scissor = vkTools::initializers::rect2D(*frameBufferWidth, *frameBufferHeight, 0, 0);
+            vkCmdSetScissor(cmdBuffers[i], 0, 1, &scissor);
+            
+            vkCmdBindPipeline(cmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
+            vkCmdBindDescriptorSets(cmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout, 0, 1, &descriptorSet, 0, NULL);
+
+            VkDeviceSize offsets = 0;
+            vkCmdBindVertexBuffers(cmdBuffers[i], 0, 1, &buffer, &offsets);
+            vkCmdBindVertexBuffers(cmdBuffers[i], 1, 1, &buffer, &offsets);
+            for (uint32_t j = 0; j < numLetters; j++)
+            {
+                vkCmdDraw(cmdBuffers[i], 4, 1, j * 4, 0);
+            }
+
+            vkCmdEndRenderPass(cmdBuffers[i]);
+
+            if (vkDebug::DebugMarker::active)
+            {
+                vkDebug::DebugMarker::endRegion(cmdBuffers[i]);
+            }
+
+            VK_CHECK_RESULT(vkEndCommandBuffer(cmdBuffers[i]));
+        }
+    }
+
+    // Submit the text command buffers to a queue
+    void submit(VkQueue targetQueue, uint32_t bufferindex, VkSubmitInfo submitInfo)
+    {
+        if (!visible)
+        {
+            return;
+        }
+
+        submitInfo.pCommandBuffers = &cmdBuffers[bufferindex];
+        submitInfo.commandBufferCount = 1;
+
+        VK_CHECK_RESULT(vkQueueSubmit(targetQueue, 1, &submitInfo, VK_NULL_HANDLE));
+    }
+
+    void reallocateCommandBuffers()
+    {
+        vkFreeCommandBuffers(device, commandPool, static_cast<uint32_t>(cmdBuffers.size()), cmdBuffers.data());
+
+        VkCommandBufferAllocateInfo cmdBufAllocateInfo =
+            vkTools::initializers::commandBufferAllocateInfo(
+                commandPool,
+                VK_COMMAND_BUFFER_LEVEL_PRIMARY,
+                static_cast<uint32_t>(cmdBuffers.size()));
+
+        VK_CHECK_RESULT(vkAllocateCommandBuffers(device, &cmdBufAllocateInfo, cmdBuffers.data()));
+    }
+
+};
+
+// vi: set sw=2 ts=4 expandtab: 

third_party/ktx-src/tests/loadtests/appfwSDL/VulkanAppSDL/vulkantools.cpp

@@ -0,0 +1,918 @@
+/*
+* Copyright 2016 Sascha Willems - www.saschawillems.de
+* SPDX-License-Identifier: MIT
+*
+* Assorted commonly used Vulkan helper functions
+*
+* asserts on unhandled cases in setImageLayout added by Mark Callow, 2017.3.3.
+*/
+
+#if defined(_WIN32)
+  #define _CRT_SECURE_NO_WARNINGS // For fopen
+#endif
+
+#include "vulkantools.h"
+#include "unused.h"
+
+namespace vkTools
+{
+
+    VkBool32 checkGlobalExtensionPresent(const char* extensionName)
+    {
+        uint32_t extensionCount = 0;
+        std::vector<VkExtensionProperties> extensions;
+        vkEnumerateInstanceExtensionProperties(NULL, &extensionCount, NULL);
+        extensions.resize(extensionCount);
+        vkEnumerateInstanceExtensionProperties(NULL, &extensionCount, extensions.data());
+        for (auto& ext : extensions)
+        {
+            if (!strcmp(extensionName, ext.extensionName))
+            {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    VkBool32 checkDeviceExtensionPresent(VkPhysicalDevice physicalDevice, const char* extensionName)
+    {
+        uint32_t extensionCount = 0;
+        std::vector<VkExtensionProperties> extensions;
+        vkEnumerateDeviceExtensionProperties(physicalDevice, NULL, &extensionCount, NULL);
+        extensions.resize(extensionCount);
+        vkEnumerateDeviceExtensionProperties(physicalDevice, NULL, &extensionCount, extensions.data());
+        for (auto& ext : extensions)
+        {
+            if (!strcmp(extensionName, ext.extensionName))
+            {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    std::string errorString(VkResult errorCode)
+    {
+        switch (errorCode)
+        {
+#define STR(r) case VK_ ##r: return #r
+            STR(NOT_READY);
+            STR(TIMEOUT);
+            STR(EVENT_SET);
+            STR(EVENT_RESET);
+            STR(INCOMPLETE);
+            STR(ERROR_OUT_OF_HOST_MEMORY);
+            STR(ERROR_OUT_OF_DEVICE_MEMORY);
+            STR(ERROR_INITIALIZATION_FAILED);
+            STR(ERROR_DEVICE_LOST);
+            STR(ERROR_MEMORY_MAP_FAILED);
+            STR(ERROR_LAYER_NOT_PRESENT);
+            STR(ERROR_EXTENSION_NOT_PRESENT);
+            STR(ERROR_FEATURE_NOT_PRESENT);
+            STR(ERROR_INCOMPATIBLE_DRIVER);
+            STR(ERROR_TOO_MANY_OBJECTS);
+            STR(ERROR_FORMAT_NOT_SUPPORTED);
+            STR(ERROR_SURFACE_LOST_KHR);
+            STR(ERROR_NATIVE_WINDOW_IN_USE_KHR);
+            STR(SUBOPTIMAL_KHR);
+            STR(ERROR_OUT_OF_DATE_KHR);
+            STR(ERROR_INCOMPATIBLE_DISPLAY_KHR);
+            STR(ERROR_VALIDATION_FAILED_EXT);
+            STR(ERROR_INVALID_SHADER_NV);
+#undef STR
+        default:
+            return "UNKNOWN_ERROR";
+        }
+    }
+
+    VkBool32 getSupportedDepthFormat(VkPhysicalDevice physicalDevice, VkFormat *depthFormat)
+    {
+        // Since all depth formats may be optional, we need to find a suitable depth format to use
+        // Start with the highest precision packed format
+        std::vector<VkFormat> depthFormats = { 
+            VK_FORMAT_D32_SFLOAT_S8_UINT, 
+            VK_FORMAT_D32_SFLOAT,
+            VK_FORMAT_D24_UNORM_S8_UINT, 
+            VK_FORMAT_D16_UNORM_S8_UINT, 
+            VK_FORMAT_D16_UNORM 
+        };
+
+        for (auto& format : depthFormats)
+        {
+            VkFormatProperties formatProps;
+            vkGetPhysicalDeviceFormatProperties(physicalDevice, format, &formatProps);
+            // Format must support depth stencil attachment for optimal tiling
+            if (formatProps.optimalTilingFeatures & VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT)
+            {
+                *depthFormat = format;
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    // Create an image memory barrier for changing the layout of
+    // an image and put it into an active command buffer
+    // See chapter 11.4 "Image Layout" for details
+
+    void setImageLayout(
+        VkCommandBuffer cmdbuffer, 
+        VkImage image, 
+        VkImageAspectFlags /*aspectMask*/, 
+        VkImageLayout oldImageLayout, 
+        VkImageLayout newImageLayout,
+        VkImageSubresourceRange subresourceRange)
+    {
+        // Create an image barrier object
+        VkImageMemoryBarrier imageMemoryBarrier = vkTools::initializers::imageMemoryBarrier();
+        imageMemoryBarrier.oldLayout = oldImageLayout;
+        imageMemoryBarrier.newLayout = newImageLayout;
+        imageMemoryBarrier.image = image;
+        imageMemoryBarrier.subresourceRange = subresourceRange;
+
+        // Source layouts (old)
+        // Source access mask controls actions that have to be finished on the old layout
+        // before it will be transitioned to the new layout
+        switch (oldImageLayout)
+        {
+        case VK_IMAGE_LAYOUT_UNDEFINED:
+                // Image layout is undefined (or does not matter)
+                // Only valid as initial layout
+                // No flags required, listed only for completeness
+                imageMemoryBarrier.srcAccessMask = 0;
+                break;
+
+        case VK_IMAGE_LAYOUT_PREINITIALIZED:
+                // Image is preinitialized
+                // Only valid as initial layout for linear images, preserves memory contents
+                // Make sure host writes have been finished
+                imageMemoryBarrier.srcAccessMask = VK_ACCESS_HOST_WRITE_BIT;
+                break;
+
+        case VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
+                // Image is a color attachment
+                // Make sure any writes to the color buffer have been finished
+                imageMemoryBarrier.srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
+                break;
+
+        case VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:
+                // Image is a depth/stencil attachment
+                // Make sure any writes to the depth/stencil buffer have been finished
+                imageMemoryBarrier.srcAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
+                break;
+
+        case VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL:
+                // Image is a transfer source 
+                // Make sure any reads from the image have been finished
+                imageMemoryBarrier.srcAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
+                break;
+
+        case VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL:
+                // Image is a transfer destination
+                // Make sure any writes to the image have been finished
+                imageMemoryBarrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
+                break;
+
+        case VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
+                // Image is read by a shader
+                // Make sure any shader reads from the image have been finished
+                imageMemoryBarrier.srcAccessMask = VK_ACCESS_SHADER_READ_BIT;
+                break;
+
+        default:
+            assert(0); // Attempt to use unhandled case.
+        }
+
+        // Target layouts (new)
+        // Destination access mask controls the dependency for the new image layout
+        switch (newImageLayout)
+        {
+        case VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL:
+            // Image will be used as a transfer destination
+            // Make sure any writes to the image have been finished
+            imageMemoryBarrier.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
+            break;
+
+        case VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL:
+            // Image will be used as a transfer source
+            // Make sure any reads from and writes to the image have been finished
+            imageMemoryBarrier.srcAccessMask = imageMemoryBarrier.srcAccessMask | VK_ACCESS_TRANSFER_READ_BIT;
+            imageMemoryBarrier.dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
+            break;
+
+        case VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
+            // Image will be used as a color attachment
+            // Make sure any writes to the color buffer have been finished
+            imageMemoryBarrier.srcAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
+            imageMemoryBarrier.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
+            break;
+
+        case VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:
+            // Image layout will be used as a depth/stencil attachment
+            // Make sure any writes to depth/stencil buffer have been finished
+            imageMemoryBarrier.dstAccessMask = imageMemoryBarrier.dstAccessMask | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
+            break;
+
+        case VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
+            // Image will be read in a shader (sampler, input attachment)
+            // Make sure any writes to the image have been finished
+            if (imageMemoryBarrier.srcAccessMask == 0)
+            {
+                imageMemoryBarrier.srcAccessMask = VK_ACCESS_HOST_WRITE_BIT | VK_ACCESS_TRANSFER_WRITE_BIT;
+            }
+            imageMemoryBarrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
+            break;
+
+        default:
+            assert(0); // Attempt to use unhandled case.
+        }
+
+        // Put barrier on top
+        VkPipelineStageFlags srcStageFlags = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
+        VkPipelineStageFlags destStageFlags = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
+
+        // Put barrier inside setup command buffer
+        vkCmdPipelineBarrier(
+            cmdbuffer, 
+            srcStageFlags, 
+            destStageFlags, 
+            0, 
+            0, nullptr,
+            0, nullptr,
+            1, &imageMemoryBarrier);
+    }
+
+    // Fixed sub resource on first mip level and layer
+    void setImageLayout(
+        VkCommandBuffer cmdbuffer,
+        VkImage image,
+        VkImageAspectFlags aspectMask,
+        VkImageLayout oldImageLayout,
+        VkImageLayout newImageLayout)
+    {
+        VkImageSubresourceRange subresourceRange = {};
+        subresourceRange.aspectMask = aspectMask;
+        subresourceRange.baseMipLevel = 0;
+        subresourceRange.levelCount = 1;
+        subresourceRange.layerCount = 1;
+        setImageLayout(cmdbuffer, image, aspectMask, oldImageLayout, newImageLayout, subresourceRange);
+    }
+
+    void exitFatal(std::string message, std::string caption)
+    {
+        (void)SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, caption.c_str(),
+                                       message.c_str(), NULL);
+        std::cerr << message << "\n";
+        exit(1);
+    }
+
+    std::string readTextFile(const char *fileName)
+    {
+        std::string fileContent;
+        std::ifstream fileStream(fileName, std::ios::in);
+        if (!fileStream.is_open()) {
+            printf("File %s not found\n", fileName);
+            return "";
+        }
+        std::string line = "";
+        while (!fileStream.eof()) {
+            getline(fileStream, line);
+            fileContent.append(line + "\n");
+        }
+        fileStream.close();
+        return fileContent;
+    }
+
+#if defined(__ANDROID__)
+    // Android shaders are stored as assets in the apk
+    // So they need to be loaded via the asset manager
+    VkShaderModule loadShader(AAssetManager* assetManager, const char *fileName, VkDevice device, VkShaderStageFlagBits stage)
+    {
+        // Load shader from compressed asset
+        AAsset* asset = AAssetManager_open(assetManager, fileName, AASSET_MODE_STREAMING);
+        assert(asset);
+        size_t size = AAsset_getLength(asset);
+        assert(size > 0);
+
+        char *shaderCode = new char[size];
+        AAsset_read(asset, shaderCode, size);
+        AAsset_close(asset);
+
+        VkShaderModule shaderModule;
+        VkShaderModuleCreateInfo moduleCreateInfo;
+        moduleCreateInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
+        moduleCreateInfo.pNext = NULL;
+        moduleCreateInfo.codeSize = size;
+        moduleCreateInfo.pCode = (uint32_t*)shaderCode;
+        moduleCreateInfo.flags = 0;
+
+        VK_CHECK_RESULT(vkCreateShaderModule(device, &moduleCreateInfo, NULL, &shaderModule));
+
+        delete[] shaderCode;
+
+        return shaderModule;
+    }
+#else
+    VkShaderModule loadShader(const char *fileName, VkDevice device, VkShaderStageFlagBits /*stage*/) 
+    {
+        size_t size;
+
+        FILE *fp = fopen(fileName, "rb");
+        assert(fp);
+
+        fseek(fp, 0L, SEEK_END);
+        size = ftell(fp);
+
+        fseek(fp, 0L, SEEK_SET);
+
+        //shaderCode = malloc(size);
+        char *shaderCode = new char[size];
+        U_ASSERT_ONLY size_t retval = fread(shaderCode, size, 1, fp);
+        assert(retval == 1);
+        (void)retval; // Supress VC++ unused variable warning for Release config.
+        assert(size > 0);
+
+        fclose(fp);
+
+        VkShaderModule shaderModule;
+        VkShaderModuleCreateInfo moduleCreateInfo;
+        moduleCreateInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
+        moduleCreateInfo.pNext = NULL;
+        moduleCreateInfo.codeSize = size;
+        moduleCreateInfo.pCode = (uint32_t*)shaderCode;
+        moduleCreateInfo.flags = 0;
+
+        VK_CHECK_RESULT(vkCreateShaderModule(device, &moduleCreateInfo, NULL, &shaderModule));
+
+        delete[] shaderCode;
+
+        return shaderModule;
+    }
+#endif
+
+    VkShaderModule loadShaderGLSL(const char *fileName, VkDevice device, VkShaderStageFlagBits stage)
+    {
+        std::string shaderSrc = readTextFile(fileName);
+        const char *shaderCode = shaderSrc.c_str();
+        size_t size = strlen(shaderCode);
+        assert(size > 0);
+
+        VkShaderModule shaderModule;
+        VkShaderModuleCreateInfo moduleCreateInfo;
+        moduleCreateInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
+        moduleCreateInfo.pNext = NULL;
+        moduleCreateInfo.codeSize = 3 * sizeof(uint32_t) + size + 1;
+        moduleCreateInfo.pCode = (uint32_t*)malloc(moduleCreateInfo.codeSize);
+        moduleCreateInfo.flags = 0;
+
+        // Magic SPV number
+        ((uint32_t *)moduleCreateInfo.pCode)[0] = 0x07230203; 
+        ((uint32_t *)moduleCreateInfo.pCode)[1] = 0;
+        ((uint32_t *)moduleCreateInfo.pCode)[2] = stage;
+        memcpy(((uint32_t *)moduleCreateInfo.pCode + 3), shaderCode, size + 1);
+
+        VK_CHECK_RESULT(vkCreateShaderModule(device, &moduleCreateInfo, NULL, &shaderModule));
+
+        return shaderModule;
+    }
+
+    VkImageMemoryBarrier prePresentBarrier(VkImage presentImage)
+    {
+        VkImageMemoryBarrier imageMemoryBarrier = vkTools::initializers::imageMemoryBarrier();
+        imageMemoryBarrier.srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
+        imageMemoryBarrier.dstAccessMask = 0;
+        imageMemoryBarrier.oldLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
+        imageMemoryBarrier.newLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
+        imageMemoryBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+        imageMemoryBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+        imageMemoryBarrier.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 };
+        imageMemoryBarrier.image = presentImage;
+        return imageMemoryBarrier;
+    }
+
+    VkImageMemoryBarrier postPresentBarrier(VkImage presentImage)
+    {
+        VkImageMemoryBarrier imageMemoryBarrier = vkTools::initializers::imageMemoryBarrier();
+        imageMemoryBarrier.srcAccessMask = 0;
+        imageMemoryBarrier.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
+        imageMemoryBarrier.oldLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
+        imageMemoryBarrier.newLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
+        imageMemoryBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+        imageMemoryBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+        imageMemoryBarrier.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 };
+        imageMemoryBarrier.image = presentImage;
+        return imageMemoryBarrier;
+    }
+
+    void destroyUniformData(VkDevice device, vkTools::UniformData *uniformData)
+    {
+        if (uniformData->mapped != nullptr)
+        {
+            vkUnmapMemory(device, uniformData->memory);
+        }
+        vkDestroyBuffer(device, uniformData->buffer, nullptr);
+        vkFreeMemory(device, uniformData->memory, nullptr);
+    }
+}
+
+VkMemoryAllocateInfo vkTools::initializers::memoryAllocateInfo()
+{
+    VkMemoryAllocateInfo memAllocInfo = {};
+    memAllocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
+    memAllocInfo.pNext = NULL;
+    memAllocInfo.allocationSize = 0;
+    memAllocInfo.memoryTypeIndex = 0;
+    return memAllocInfo;
+}
+
+VkCommandBufferAllocateInfo vkTools::initializers::commandBufferAllocateInfo(VkCommandPool commandPool, VkCommandBufferLevel level, uint32_t bufferCount)
+{
+    VkCommandBufferAllocateInfo commandBufferAllocateInfo = {};
+    commandBufferAllocateInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
+    commandBufferAllocateInfo.commandPool = commandPool;
+    commandBufferAllocateInfo.level = level;
+    commandBufferAllocateInfo.commandBufferCount = bufferCount;
+    return commandBufferAllocateInfo;
+}
+
+VkCommandPoolCreateInfo vkTools::initializers::commandPoolCreateInfo()
+{
+    VkCommandPoolCreateInfo cmdPoolCreateInfo = {};
+    cmdPoolCreateInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
+    return cmdPoolCreateInfo;
+}
+
+VkCommandBufferBeginInfo vkTools::initializers::commandBufferBeginInfo()
+{
+    VkCommandBufferBeginInfo cmdBufferBeginInfo = {};
+    cmdBufferBeginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
+    cmdBufferBeginInfo.pNext = NULL;
+    return cmdBufferBeginInfo;
+}
+
+VkCommandBufferInheritanceInfo vkTools::initializers::commandBufferInheritanceInfo()
+{
+    VkCommandBufferInheritanceInfo cmdBufferInheritanceInfo = {};
+    cmdBufferInheritanceInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO;
+    return cmdBufferInheritanceInfo;
+}
+
+VkRenderPassBeginInfo vkTools::initializers::renderPassBeginInfo()
+{
+    VkRenderPassBeginInfo renderPassBeginInfo = {};
+    renderPassBeginInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
+    renderPassBeginInfo.pNext = NULL;
+    return renderPassBeginInfo;
+}
+
+VkRenderPassCreateInfo vkTools::initializers::renderPassCreateInfo()
+{
+    VkRenderPassCreateInfo renderPassCreateInfo = {};
+    renderPassCreateInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
+    renderPassCreateInfo.pNext = NULL;
+    return renderPassCreateInfo;
+}
+
+VkImageMemoryBarrier vkTools::initializers::imageMemoryBarrier()
+{
+    VkImageMemoryBarrier imageMemoryBarrier = {};
+    imageMemoryBarrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
+    imageMemoryBarrier.pNext = NULL;
+    // Some default values
+    imageMemoryBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+    imageMemoryBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+    return imageMemoryBarrier;
+}
+
+VkBufferMemoryBarrier vkTools::initializers::bufferMemoryBarrier()
+{
+    VkBufferMemoryBarrier bufferMemoryBarrier = {};
+    bufferMemoryBarrier.sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER;
+    bufferMemoryBarrier.pNext = NULL;
+    return bufferMemoryBarrier;
+}
+
+VkMemoryBarrier vkTools::initializers::memoryBarrier()
+{
+    VkMemoryBarrier memoryBarrier = {};
+    memoryBarrier.sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER;
+    memoryBarrier.pNext = NULL;
+    return memoryBarrier;
+}
+
+VkImageCreateInfo vkTools::initializers::imageCreateInfo()
+{
+    VkImageCreateInfo imageCreateInfo = {};
+    imageCreateInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
+    imageCreateInfo.pNext = NULL;
+    return imageCreateInfo;
+}
+
+VkSamplerCreateInfo vkTools::initializers::samplerCreateInfo()
+{
+    VkSamplerCreateInfo samplerCreateInfo = {};
+    samplerCreateInfo.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
+    samplerCreateInfo.pNext = NULL;
+    return samplerCreateInfo;
+}
+
+VkImageViewCreateInfo vkTools::initializers::imageViewCreateInfo()
+{
+    VkImageViewCreateInfo imageViewCreateInfo = {};
+    imageViewCreateInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
+    imageViewCreateInfo.pNext = NULL;
+    return imageViewCreateInfo;
+}
+
+VkFramebufferCreateInfo vkTools::initializers::framebufferCreateInfo()
+{
+    VkFramebufferCreateInfo framebufferCreateInfo = {};
+    framebufferCreateInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
+    framebufferCreateInfo.pNext = NULL;
+    return framebufferCreateInfo;
+}
+
+VkSemaphoreCreateInfo vkTools::initializers::semaphoreCreateInfo()
+{
+    VkSemaphoreCreateInfo semaphoreCreateInfo = {};
+    semaphoreCreateInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
+    semaphoreCreateInfo.pNext = NULL;
+    semaphoreCreateInfo.flags = 0;
+    return semaphoreCreateInfo;
+}
+
+VkFenceCreateInfo vkTools::initializers::fenceCreateInfo(VkFenceCreateFlags flags)
+{
+    VkFenceCreateInfo fenceCreateInfo = {};
+    fenceCreateInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
+    fenceCreateInfo.flags = flags;
+    return fenceCreateInfo;
+}
+
+VkEventCreateInfo vkTools::initializers::eventCreateInfo()
+{
+    VkEventCreateInfo eventCreateInfo = {};
+    eventCreateInfo.sType = VK_STRUCTURE_TYPE_EVENT_CREATE_INFO;
+    return eventCreateInfo;
+}
+
+VkSubmitInfo vkTools::initializers::submitInfo()
+{
+    VkSubmitInfo submitInfo = {};
+    submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
+    submitInfo.pNext = NULL;
+    return submitInfo;
+}
+
+VkViewport vkTools::initializers::viewport(
+    float width, 
+    float height, 
+    float minDepth, 
+    float maxDepth)
+{
+    VkViewport viewport = {};
+    viewport.width = width;
+    viewport.height = height;
+    viewport.minDepth = minDepth;
+    viewport.maxDepth = maxDepth;
+    return viewport;
+}
+
+VkRect2D vkTools::initializers::rect2D(
+    int32_t width, 
+    int32_t height, 
+    int32_t offsetX, 
+    int32_t offsetY)
+{
+    VkRect2D rect2D = {};
+    rect2D.extent.width = width;
+    rect2D.extent.height = height;
+    rect2D.offset.x = offsetX;
+    rect2D.offset.y = offsetY;
+    return rect2D;
+}
+
+VkBufferCreateInfo vkTools::initializers::bufferCreateInfo()
+{
+    VkBufferCreateInfo bufCreateInfo = {};
+    bufCreateInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
+    return bufCreateInfo;
+}
+
+VkBufferCreateInfo vkTools::initializers::bufferCreateInfo(
+    VkBufferUsageFlags usage, 
+    VkDeviceSize size)
+{
+    VkBufferCreateInfo bufCreateInfo = {};
+    bufCreateInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
+    bufCreateInfo.pNext = NULL;
+    bufCreateInfo.usage = usage;
+    bufCreateInfo.size = size;
+    bufCreateInfo.flags = 0;
+    return bufCreateInfo;
+}
+
+VkDescriptorPoolCreateInfo vkTools::initializers::descriptorPoolCreateInfo(
+    uint32_t poolSizeCount, 
+    VkDescriptorPoolSize* pPoolSizes, 
+    uint32_t maxSets)
+{
+    VkDescriptorPoolCreateInfo descriptorPoolInfo = {};
+    descriptorPoolInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
+    descriptorPoolInfo.pNext = NULL;
+    descriptorPoolInfo.poolSizeCount = poolSizeCount;
+    descriptorPoolInfo.pPoolSizes = pPoolSizes;
+    descriptorPoolInfo.maxSets = maxSets;
+    return descriptorPoolInfo;
+}
+
+VkDescriptorPoolSize vkTools::initializers::descriptorPoolSize(
+    VkDescriptorType type, 
+    uint32_t descriptorCount)
+{
+    VkDescriptorPoolSize descriptorPoolSize = {};
+    descriptorPoolSize.type = type;
+    descriptorPoolSize.descriptorCount = descriptorCount;
+    return descriptorPoolSize;
+}
+
+VkDescriptorSetLayoutBinding vkTools::initializers::descriptorSetLayoutBinding(
+    VkDescriptorType type, 
+    VkShaderStageFlags stageFlags, 
+    uint32_t binding)
+{
+    VkDescriptorSetLayoutBinding setLayoutBinding = {};
+    setLayoutBinding.descriptorType = type;
+    setLayoutBinding.stageFlags = stageFlags;
+    setLayoutBinding.binding = binding;
+    // Default value in all examples
+    setLayoutBinding.descriptorCount = 1; 
+    return setLayoutBinding;
+}
+
+VkDescriptorSetLayoutCreateInfo vkTools::initializers::descriptorSetLayoutCreateInfo(
+    const VkDescriptorSetLayoutBinding* pBindings,
+    uint32_t bindingCount)
+{
+    VkDescriptorSetLayoutCreateInfo descriptorSetLayoutCreateInfo = {};
+    descriptorSetLayoutCreateInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
+    descriptorSetLayoutCreateInfo.pNext = NULL;
+    descriptorSetLayoutCreateInfo.pBindings = pBindings;
+    descriptorSetLayoutCreateInfo.bindingCount = bindingCount;
+    return descriptorSetLayoutCreateInfo;
+}
+
+VkPipelineLayoutCreateInfo vkTools::initializers::pipelineLayoutCreateInfo(
+    const VkDescriptorSetLayout* pSetLayouts,
+    uint32_t setLayoutCount)
+{
+    VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo = {};
+    pipelineLayoutCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
+    pipelineLayoutCreateInfo.pNext = NULL;
+    pipelineLayoutCreateInfo.setLayoutCount = setLayoutCount;
+    pipelineLayoutCreateInfo.pSetLayouts = pSetLayouts;
+    return pipelineLayoutCreateInfo;
+}
+
+VkDescriptorSetAllocateInfo vkTools::initializers::descriptorSetAllocateInfo(
+    VkDescriptorPool descriptorPool,
+    const VkDescriptorSetLayout* pSetLayouts,
+    uint32_t descriptorSetCount)
+{
+    VkDescriptorSetAllocateInfo descriptorSetAllocateInfo = {};
+    descriptorSetAllocateInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
+    descriptorSetAllocateInfo.pNext = NULL;
+    descriptorSetAllocateInfo.descriptorPool = descriptorPool;
+    descriptorSetAllocateInfo.pSetLayouts = pSetLayouts;
+    descriptorSetAllocateInfo.descriptorSetCount = descriptorSetCount;
+    return descriptorSetAllocateInfo;
+}
+
+VkDescriptorImageInfo vkTools::initializers::descriptorImageInfo(VkSampler sampler, VkImageView imageView, VkImageLayout imageLayout)
+{
+    VkDescriptorImageInfo descriptorImageInfo = {};
+    descriptorImageInfo.sampler = sampler;
+    descriptorImageInfo.imageView = imageView;
+    descriptorImageInfo.imageLayout = imageLayout;
+    return descriptorImageInfo;
+}
+
+VkWriteDescriptorSet vkTools::initializers::writeDescriptorSet(
+    VkDescriptorSet dstSet, 
+    VkDescriptorType type, 
+    uint32_t binding, 
+    VkDescriptorBufferInfo* bufferInfo)
+{
+    VkWriteDescriptorSet writeDescriptorSet = {};
+    writeDescriptorSet.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
+    writeDescriptorSet.pNext = NULL;
+    writeDescriptorSet.dstSet = dstSet;
+    writeDescriptorSet.descriptorType = type;
+    writeDescriptorSet.dstBinding = binding;
+    writeDescriptorSet.pBufferInfo = bufferInfo;
+    // Default value in all examples
+    writeDescriptorSet.descriptorCount = 1;
+    return writeDescriptorSet;
+}
+
+VkWriteDescriptorSet vkTools::initializers::writeDescriptorSet(
+    VkDescriptorSet dstSet, 
+    VkDescriptorType type, 
+    uint32_t binding, 
+    VkDescriptorImageInfo * imageInfo)
+{
+    VkWriteDescriptorSet writeDescriptorSet = {};
+    writeDescriptorSet.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
+    writeDescriptorSet.pNext = NULL;
+    writeDescriptorSet.dstSet = dstSet;
+    writeDescriptorSet.descriptorType = type;
+    writeDescriptorSet.dstBinding = binding;
+    writeDescriptorSet.pImageInfo = imageInfo;
+    // Default value in all examples
+    writeDescriptorSet.descriptorCount = 1;
+    return writeDescriptorSet;
+}
+
+VkVertexInputBindingDescription vkTools::initializers::vertexInputBindingDescription(
+    uint32_t binding, 
+    uint32_t stride, 
+    VkVertexInputRate inputRate)
+{
+    VkVertexInputBindingDescription vInputBindDescription = {};
+    vInputBindDescription.binding = binding;
+    vInputBindDescription.stride = stride;
+    vInputBindDescription.inputRate = inputRate;
+    return vInputBindDescription;
+}
+
+VkVertexInputAttributeDescription vkTools::initializers::vertexInputAttributeDescription(
+    uint32_t binding, 
+    uint32_t location, 
+    VkFormat format, 
+    uint32_t offset)
+{
+    VkVertexInputAttributeDescription vInputAttribDescription = {};
+    vInputAttribDescription.location = location;
+    vInputAttribDescription.binding = binding;
+    vInputAttribDescription.format = format;
+    vInputAttribDescription.offset = offset;
+    return vInputAttribDescription;
+}
+
+VkPipelineVertexInputStateCreateInfo vkTools::initializers::pipelineVertexInputStateCreateInfo()
+{
+    VkPipelineVertexInputStateCreateInfo pipelineVertexInputStateCreateInfo = {};
+    pipelineVertexInputStateCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
+    pipelineVertexInputStateCreateInfo.pNext = NULL;
+    return pipelineVertexInputStateCreateInfo;
+}
+
+VkPipelineInputAssemblyStateCreateInfo vkTools::initializers::pipelineInputAssemblyStateCreateInfo(
+    VkPrimitiveTopology topology, 
+    VkPipelineInputAssemblyStateCreateFlags flags, 
+    VkBool32 primitiveRestartEnable)
+{
+    VkPipelineInputAssemblyStateCreateInfo pipelineInputAssemblyStateCreateInfo = {};
+    pipelineInputAssemblyStateCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
+    pipelineInputAssemblyStateCreateInfo.topology = topology;
+    pipelineInputAssemblyStateCreateInfo.flags = flags;
+    pipelineInputAssemblyStateCreateInfo.primitiveRestartEnable = primitiveRestartEnable;
+    return pipelineInputAssemblyStateCreateInfo;
+}
+
+VkPipelineRasterizationStateCreateInfo vkTools::initializers::pipelineRasterizationStateCreateInfo(
+    VkPolygonMode polygonMode, 
+    VkCullModeFlags cullMode, 
+    VkFrontFace frontFace, 
+    VkPipelineRasterizationStateCreateFlags flags)
+{
+    VkPipelineRasterizationStateCreateInfo pipelineRasterizationStateCreateInfo = {};
+    pipelineRasterizationStateCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
+    pipelineRasterizationStateCreateInfo.polygonMode = polygonMode;
+    pipelineRasterizationStateCreateInfo.cullMode = cullMode;
+    pipelineRasterizationStateCreateInfo.frontFace = frontFace;
+    pipelineRasterizationStateCreateInfo.flags = flags;
+    pipelineRasterizationStateCreateInfo.depthClampEnable = VK_TRUE;
+    pipelineRasterizationStateCreateInfo.lineWidth = 1.0f;
+    return pipelineRasterizationStateCreateInfo;
+}
+
+VkPipelineColorBlendAttachmentState vkTools::initializers::pipelineColorBlendAttachmentState(
+    VkColorComponentFlags colorWriteMask, 
+    VkBool32 blendEnable)
+{
+    VkPipelineColorBlendAttachmentState pipelineColorBlendAttachmentState = {};
+    pipelineColorBlendAttachmentState.colorWriteMask = colorWriteMask;
+    pipelineColorBlendAttachmentState.blendEnable = blendEnable;
+    return pipelineColorBlendAttachmentState;
+}
+
+VkPipelineColorBlendStateCreateInfo vkTools::initializers::pipelineColorBlendStateCreateInfo(
+    uint32_t attachmentCount, 
+    const VkPipelineColorBlendAttachmentState * pAttachments)
+{
+    VkPipelineColorBlendStateCreateInfo pipelineColorBlendStateCreateInfo = {};
+    pipelineColorBlendStateCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
+    pipelineColorBlendStateCreateInfo.pNext = NULL;
+    pipelineColorBlendStateCreateInfo.attachmentCount = attachmentCount;
+    pipelineColorBlendStateCreateInfo.pAttachments = pAttachments;
+    return pipelineColorBlendStateCreateInfo;
+}
+
+VkPipelineDepthStencilStateCreateInfo vkTools::initializers::pipelineDepthStencilStateCreateInfo(
+    VkBool32 depthTestEnable, 
+    VkBool32 depthWriteEnable, 
+    VkCompareOp depthCompareOp)
+{
+    VkPipelineDepthStencilStateCreateInfo pipelineDepthStencilStateCreateInfo = {};
+    pipelineDepthStencilStateCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO;
+    pipelineDepthStencilStateCreateInfo.depthTestEnable = depthTestEnable;
+    pipelineDepthStencilStateCreateInfo.depthWriteEnable = depthWriteEnable;
+    pipelineDepthStencilStateCreateInfo.depthCompareOp = depthCompareOp;
+    pipelineDepthStencilStateCreateInfo.front = pipelineDepthStencilStateCreateInfo.back;
+    pipelineDepthStencilStateCreateInfo.back.compareOp = VK_COMPARE_OP_ALWAYS;
+    return pipelineDepthStencilStateCreateInfo;
+}
+
+VkPipelineViewportStateCreateInfo vkTools::initializers::pipelineViewportStateCreateInfo(
+    uint32_t viewportCount, 
+    uint32_t scissorCount, 
+    VkPipelineViewportStateCreateFlags flags)
+{
+    VkPipelineViewportStateCreateInfo pipelineViewportStateCreateInfo = {};
+    pipelineViewportStateCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
+    pipelineViewportStateCreateInfo.viewportCount = viewportCount;
+    pipelineViewportStateCreateInfo.scissorCount = scissorCount;
+    pipelineViewportStateCreateInfo.flags = flags;
+    return pipelineViewportStateCreateInfo;
+}
+
+VkPipelineMultisampleStateCreateInfo vkTools::initializers::pipelineMultisampleStateCreateInfo(
+    VkSampleCountFlagBits rasterizationSamples, 
+    VkPipelineMultisampleStateCreateFlags flags)
+{
+    VkPipelineMultisampleStateCreateInfo pipelineMultisampleStateCreateInfo = {};
+    pipelineMultisampleStateCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
+    pipelineMultisampleStateCreateInfo.rasterizationSamples = rasterizationSamples;
+    pipelineMultisampleStateCreateInfo.flags = flags;
+    return pipelineMultisampleStateCreateInfo;
+}
+
+VkPipelineDynamicStateCreateInfo vkTools::initializers::pipelineDynamicStateCreateInfo(
+    const VkDynamicState * pDynamicStates, 
+    uint32_t dynamicStateCount, 
+    VkPipelineDynamicStateCreateFlags flags)
+{
+    VkPipelineDynamicStateCreateInfo pipelineDynamicStateCreateInfo = {};
+    pipelineDynamicStateCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
+    pipelineDynamicStateCreateInfo.pDynamicStates = pDynamicStates;
+    pipelineDynamicStateCreateInfo.dynamicStateCount = dynamicStateCount;
+    pipelineDynamicStateCreateInfo.flags = flags;
+    return pipelineDynamicStateCreateInfo;
+}
+
+VkPipelineTessellationStateCreateInfo vkTools::initializers::pipelineTessellationStateCreateInfo(uint32_t patchControlPoints)
+{
+    VkPipelineTessellationStateCreateInfo pipelineTessellationStateCreateInfo = {};
+    pipelineTessellationStateCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO;
+    pipelineTessellationStateCreateInfo.patchControlPoints = patchControlPoints;
+    return pipelineTessellationStateCreateInfo;
+}
+
+VkGraphicsPipelineCreateInfo vkTools::initializers::pipelineCreateInfo(
+    VkPipelineLayout layout, 
+    VkRenderPass renderPass, 
+    VkPipelineCreateFlags flags)
+{
+    VkGraphicsPipelineCreateInfo pipelineCreateInfo = {};
+    pipelineCreateInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
+    pipelineCreateInfo.pNext = NULL;
+    pipelineCreateInfo.layout = layout;
+    pipelineCreateInfo.renderPass = renderPass;
+    pipelineCreateInfo.flags = flags;
+    return pipelineCreateInfo;
+}
+
+VkComputePipelineCreateInfo vkTools::initializers::computePipelineCreateInfo(VkPipelineLayout layout, VkPipelineCreateFlags flags)
+{
+    VkComputePipelineCreateInfo computePipelineCreateInfo = {};
+    computePipelineCreateInfo.sType = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO;
+    computePipelineCreateInfo.layout = layout;
+    computePipelineCreateInfo.flags = flags;
+    return computePipelineCreateInfo;
+}
+
+VkPushConstantRange vkTools::initializers::pushConstantRange(
+    VkShaderStageFlags stageFlags,
+    uint32_t size,
+    uint32_t offset)
+{
+    VkPushConstantRange pushConstantRange = {};
+    pushConstantRange.stageFlags = stageFlags;
+    pushConstantRange.offset = offset;
+    pushConstantRange.size = size;
+    return pushConstantRange;
+}
+
+// vi: set sw=2 ts=4 expandtab:

third_party/ktx-src/tests/loadtests/appfwSDL/VulkanAppSDL/vulkantools.h

@@ -0,0 +1,312 @@
+/*
+* Copyright 2016 Sascha Willems - www.saschawillems.de
+* SPDX-License-Identifier: MIT
+*
+* Assorted commonly used Vulkan helper functions
+*/
+
+#pragma once
+
+#include "vulkan/vulkan.h"
+
+#include <math.h>
+#include <stdlib.h>
+#include <string>
+#include <cstring>
+#include <fstream>
+#include <assert.h>
+#include <stdio.h>
+#include <vector>
+#include <iostream>
+#include <stdexcept>
+#if defined(_WIN32)
+#include <windows.h>
+#include <fcntl.h>
+#include <io.h>
+#elif defined(__ANDROID__)
+#include "vulkanandroid.h"
+#include <android/asset_manager.h>
+#endif
+
+#include <SDL3/SDL_messagebox.h>
+
+// Custom define for better code readability
+#define VK_FLAGS_NONE 0
+// Default fence timeout in nanoseconds
+#define DEFAULT_FENCE_TIMEOUT 100000000000
+
+#if 0
+// Macro to check and display Vulkan return results
+#define VK_CHECK_RESULT(f)                                                                              \
+{                                                                                                       \
+    VkResult res = (f);                                                                                 \
+    if (res != VK_SUCCESS)                                                                              \
+    {                                                                                                   \
+        std::cout << "Fatal : VkResult is \"" << vkTools::errorString(res) << "\" in " << __FILE__ << " at line " << __LINE__ << std::endl; \
+        assert(res == VK_SUCCESS);                                                                      \
+    }                                                                                                   \
+}
+#endif
+#if defined(DEBUG)
+#include <sstream>
+extern const char* appName();
+#define VK_CHECK_RESULT(f)                                                    \
+{                                                                             \
+    VkResult res = (f);                                                       \
+    if (res != VK_SUCCESS)                                                    \
+    {                                                                         \
+        std::stringstream msg;                                                \
+        msg << "Fatal error. VkResult is \""                                  \
+            << vkTools::errorString(res) << "\" in " << __FILE__              \
+            << " at line " << __LINE__ << std::endl;                          \
+        SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR,                        \
+                                 appName(),                                      \
+                                 msg.str().c_str(),                           \
+                                 NULL);                                       \
+        assert(res == VK_SUCCESS);                                            \
+    }                                                                         \
+}
+#else
+#define VK_CHECK_RESULT(f) (void)f
+#endif
+
+
+namespace vkTools
+{
+    // Check if extension is globally available
+    VkBool32 checkGlobalExtensionPresent(const char* extensionName);
+    // Check if extension is present on the given device
+    VkBool32 checkDeviceExtensionPresent(VkPhysicalDevice physicalDevice, const char* extensionName);
+    // Return string representation of a vulkan error string
+    std::string errorString(VkResult errorCode);
+
+    // Selected a suitable supported depth format starting with 32 bit down to 16 bit
+    // Returns false if none of the depth formats in the list is supported by the device
+    VkBool32 getSupportedDepthFormat(VkPhysicalDevice physicalDevice, VkFormat *depthFormat);
+
+    // Put an image memory barrier for setting an image layout on the sub resource into the given command buffer
+    void setImageLayout(
+        VkCommandBuffer cmdbuffer,
+        VkImage image,
+        VkImageAspectFlags aspectMask,
+        VkImageLayout oldImageLayout,
+        VkImageLayout newImageLayout,
+        VkImageSubresourceRange subresourceRange);
+    // Uses a fixed sub resource layout with first mip level and layer
+    void setImageLayout(
+        VkCommandBuffer cmdbuffer, 
+        VkImage image, 
+        VkImageAspectFlags aspectMask, 
+        VkImageLayout oldImageLayout, 
+        VkImageLayout newImageLayout);
+
+    // Display error message and exit on fatal error
+    void exitFatal(std::string message, std::string caption);
+    // Load a text file (e.g. GLGL shader) into a std::string
+    std::string readTextFile(const char *fileName);
+    // Load a binary file into a buffer (e.g. SPIR-V)
+    char *readBinaryFile(const char *filename, size_t *psize);
+
+    // Load a SPIR-V shader
+#if defined(__ANDROID__)
+    VkShaderModule loadShader(AAssetManager* assetManager, const char *fileName, VkDevice device, VkShaderStageFlagBits stage);
+#else
+    VkShaderModule loadShader(const char *fileName, VkDevice device, VkShaderStageFlagBits stage);
+#endif
+
+    // Load a GLSL shader
+    // Note : Only for testing purposes, support for directly feeding GLSL shaders into Vulkan
+    // may be dropped at some point 
+    VkShaderModule loadShaderGLSL(const char *fileName, VkDevice device, VkShaderStageFlagBits stage);
+
+    // Returns a pre-present image memory barrier
+    // Transforms the image's layout from color attachment to present khr
+    VkImageMemoryBarrier prePresentBarrier(VkImage presentImage);
+
+    // Returns a post-present image memory barrier
+    // Transforms the image's layout back from present khr to color attachment
+    VkImageMemoryBarrier postPresentBarrier(VkImage presentImage);
+
+    // Contains all vulkan objects
+    // required for a uniform data object
+    struct UniformData 
+    {
+        VkBuffer buffer;
+        VkDeviceMemory memory;
+        VkDescriptorBufferInfo descriptor;
+        uint32_t allocSize;
+        void* mapped = nullptr;
+    };
+
+    // Destroy (and free) Vulkan resources used by a uniform data structure
+    void destroyUniformData(VkDevice device, vkTools::UniformData *uniformData);
+
+    // Contains often used vulkan object initializers
+    // Save lot of VK_STRUCTURE_TYPE assignments
+    // Some initializers are parameterized for convenience
+    namespace initializers
+    {
+        VkMemoryAllocateInfo memoryAllocateInfo();
+
+        VkCommandBufferAllocateInfo commandBufferAllocateInfo(
+            VkCommandPool commandPool,
+            VkCommandBufferLevel level,
+            uint32_t bufferCount);
+
+        VkCommandPoolCreateInfo commandPoolCreateInfo();
+        VkCommandBufferBeginInfo commandBufferBeginInfo();
+        VkCommandBufferInheritanceInfo commandBufferInheritanceInfo();
+
+        VkRenderPassBeginInfo renderPassBeginInfo();
+        VkRenderPassCreateInfo renderPassCreateInfo();
+
+        VkImageMemoryBarrier imageMemoryBarrier();
+        VkBufferMemoryBarrier bufferMemoryBarrier();
+        VkMemoryBarrier memoryBarrier();
+
+        VkImageCreateInfo imageCreateInfo();
+        VkSamplerCreateInfo samplerCreateInfo();
+        VkImageViewCreateInfo imageViewCreateInfo();
+
+        VkFramebufferCreateInfo framebufferCreateInfo();
+
+        VkSemaphoreCreateInfo semaphoreCreateInfo();
+        VkFenceCreateInfo fenceCreateInfo(VkFenceCreateFlags flags);
+        VkEventCreateInfo eventCreateInfo();
+
+        VkSubmitInfo submitInfo();
+
+        VkViewport viewport(
+            float width, 
+            float height, 
+            float minDepth, 
+            float maxDepth);
+
+        VkRect2D rect2D(
+            int32_t width,
+            int32_t height,
+            int32_t offsetX,
+            int32_t offsetY);
+
+        VkBufferCreateInfo bufferCreateInfo();
+
+        VkBufferCreateInfo bufferCreateInfo(
+            VkBufferUsageFlags usage, 
+            VkDeviceSize size);
+
+        VkDescriptorPoolCreateInfo descriptorPoolCreateInfo(
+            uint32_t poolSizeCount,
+            VkDescriptorPoolSize* pPoolSizes,
+            uint32_t maxSets);
+
+        VkDescriptorPoolSize descriptorPoolSize(
+            VkDescriptorType type,
+            uint32_t descriptorCount);
+
+        VkDescriptorSetLayoutBinding descriptorSetLayoutBinding(
+            VkDescriptorType type, 
+            VkShaderStageFlags stageFlags, 
+            uint32_t binding);
+
+        VkDescriptorSetLayoutCreateInfo descriptorSetLayoutCreateInfo(
+            const VkDescriptorSetLayoutBinding* pBindings,
+            uint32_t bindingCount);
+
+        VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo(
+            const VkDescriptorSetLayout* pSetLayouts,
+            uint32_t setLayoutCount );
+
+        VkDescriptorSetAllocateInfo descriptorSetAllocateInfo(
+            VkDescriptorPool descriptorPool,
+            const VkDescriptorSetLayout* pSetLayouts,
+            uint32_t descriptorSetCount);
+
+        VkDescriptorImageInfo descriptorImageInfo(
+            VkSampler sampler,
+            VkImageView imageView,
+            VkImageLayout imageLayout);
+
+        VkWriteDescriptorSet writeDescriptorSet(
+            VkDescriptorSet dstSet, 
+            VkDescriptorType type, 
+            uint32_t binding, 
+            VkDescriptorBufferInfo* bufferInfo);
+
+        VkWriteDescriptorSet writeDescriptorSet(
+            VkDescriptorSet dstSet, 
+            VkDescriptorType type, 
+            uint32_t binding, 
+            VkDescriptorImageInfo* imageInfo);
+
+        VkVertexInputBindingDescription vertexInputBindingDescription(
+            uint32_t binding, 
+            uint32_t stride, 
+            VkVertexInputRate inputRate);
+
+        VkVertexInputAttributeDescription vertexInputAttributeDescription(
+            uint32_t binding,
+            uint32_t location,
+            VkFormat format,
+            uint32_t offset);
+
+        VkPipelineVertexInputStateCreateInfo pipelineVertexInputStateCreateInfo();
+
+        VkPipelineInputAssemblyStateCreateInfo pipelineInputAssemblyStateCreateInfo(
+            VkPrimitiveTopology topology,
+            VkPipelineInputAssemblyStateCreateFlags flags,
+            VkBool32 primitiveRestartEnable);
+
+        VkPipelineRasterizationStateCreateInfo pipelineRasterizationStateCreateInfo(
+            VkPolygonMode polygonMode,
+            VkCullModeFlags cullMode,
+            VkFrontFace frontFace,
+            VkPipelineRasterizationStateCreateFlags flags);
+
+        VkPipelineColorBlendAttachmentState pipelineColorBlendAttachmentState(
+            VkColorComponentFlags colorWriteMask,
+            VkBool32 blendEnable);
+
+        VkPipelineColorBlendStateCreateInfo pipelineColorBlendStateCreateInfo(
+            uint32_t attachmentCount,
+            const VkPipelineColorBlendAttachmentState* pAttachments);
+
+        VkPipelineDepthStencilStateCreateInfo pipelineDepthStencilStateCreateInfo(
+            VkBool32 depthTestEnable,
+            VkBool32 depthWriteEnable,
+            VkCompareOp depthCompareOp);
+
+        VkPipelineViewportStateCreateInfo pipelineViewportStateCreateInfo(
+            uint32_t viewportCount,
+            uint32_t scissorCount,
+            VkPipelineViewportStateCreateFlags flags);
+
+        VkPipelineMultisampleStateCreateInfo pipelineMultisampleStateCreateInfo(
+            VkSampleCountFlagBits rasterizationSamples,
+            VkPipelineMultisampleStateCreateFlags flags);
+
+        VkPipelineDynamicStateCreateInfo pipelineDynamicStateCreateInfo(
+            const VkDynamicState *pDynamicStates,
+            uint32_t dynamicStateCount,
+            VkPipelineDynamicStateCreateFlags flags);
+
+        VkPipelineTessellationStateCreateInfo pipelineTessellationStateCreateInfo(
+            uint32_t patchControlPoints);
+
+        VkGraphicsPipelineCreateInfo pipelineCreateInfo(
+            VkPipelineLayout layout,
+            VkRenderPass renderPass,
+            VkPipelineCreateFlags flags);
+
+        VkComputePipelineCreateInfo computePipelineCreateInfo(
+            VkPipelineLayout layout,
+            VkPipelineCreateFlags flags);
+
+        VkPushConstantRange pushConstantRange(
+            VkShaderStageFlags stageFlags,
+            uint32_t size,
+            uint32_t offset);
+    }
+
+}
+
+// vi: set sw=2 ts=4 expandtab:

third_party/ktx-src/tests/loadtests/appfwSDL/main.cpp

@@ -0,0 +1,96 @@
+/* -*- tab-width: 4; -*- */
+/* vi: set sw=2 ts=4 expandtab: */
+
+/* $Id: f63e0a9e6eed51ed84a8eea1eff0708c8a6af22b $ */
+
+/*
+ * Copyright 2015-2020 Mark Callow.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @internal
+ * @file
+ * @~English
+ *
+ * @brief main() function for SDL app framework.
+ */
+
+#include <string>
+#include <vector>
+#include <stdio.h>
+#include "AppBaseSDL.h"
+#include <SDL3/SDL_main.h>
+#include "platform_utils.h"
+#if defined(EMSCRIPTEN)
+#include <emscripten.h>
+#endif
+
+#define SDL_GESTURE_IMPLEMENTATION 1
+#include "SDL_gesture.h"
+
+#if defined(SDL_PLATFORM_IOS)
+  #define NEED_MAIN_LOOP 0
+  //int SDL_iPhoneSetAnimationCallback(
+  //                             SDL_Window * window, int interval,
+  //                             void (*callback)(void*), void *callbackParam
+  //                                  );
+  #define setAnimationCallback(win, cb, userdata) \
+    SDL_SetiOSAnimationCallback(win, 1, cb, userdata)
+#elif defined(EMSCRIPTEN)
+  #define NEED_MAIN_LOOP 0
+  //void emscripten_set_main_loop_arg(em_arg_callback_func func, void *arg,
+  //                                  int fps, int simulate_infinite_loop);
+  #define setAnimationCallback(win, cb, userdata) \
+    emscripten_set_main_loop_arg(cb, userdata, 0, 0)
+#else
+  #define NEED_MAIN_LOOP 1
+  #define setAnimationCallback(win, cb, userdata)
+#endif
+
+static void
+quit() {
+    Gesture_Quit();
+    SDL_Quit();
+}
+
+int
+main(int argc, char* argv[])
+{
+  if (!SDL_Init(SDL_INIT_VIDEO | SDL_INIT_EVENTS)) {
+      fprintf(stderr, "%s: SDL video initialization failed: %s\n",
+              theApp->name(), SDL_GetError());
+      return 1;
+  }
+  Gesture_Init();
+  atexit(quit);
+
+  InitUTF8CLI(argc, argv);
+  AppBaseSDL::Args args(argv, argv+argc);
+
+  if (!theApp->initialize(args))
+    return 1;
+
+  // Catches events before they are added to the event queue.
+  // May need this for some events that need rapid response...
+  // SDL_SetEventFilter(theApp->onEvent, theApp);
+  // Triggered when event added to queue.
+  SDL_AddEventWatch(theApp->onEvent, theApp);
+  if (!NEED_MAIN_LOOP) {
+    // TODO: Fix this main to work for multiple windows. One way is to have the
+    // application call setAnimationCallback and keep a list of the windows in
+    // this file, calling drawFrame for each window.
+    setAnimationCallback(theApp->getMainWindow(), theApp->onDrawFrame, theApp);
+    // iOS version of SDL will not exit when main completes.
+    // The Emscripten version of the app must be compiled with
+    // -s NO_EXIT_RUNTIME=1 to prevent Emscripten exiting when main completes.
+    return 0;
+  } else {
+    for (;;) {
+      SDL_PumpEvents();
+      theApp->drawFrame();
+      // XXX Let app return a sleeptime from drawFrame()? If so
+      // sleep(sleeptime);
+    }
+  }
+}

third_party/ktx-src/tests/loadtests/common/LoadTestSample.cpp

@@ -0,0 +1,330 @@
+/* -*- tab-width: 4; -*- */
+/* vi: set sw=2 ts=4 expandtab: */
+
+/*
+ * Copyright 2017-2020 Mark Callow.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @internal
+ * @class LoadTestSample
+ * @~English
+ *
+ * @brief Definition of a base class for texture loading test samples.
+ *
+ * @author Mark Callow, github.com/MarkCallow.
+ */
+
+#if defined(_WIN32)
+  #define _USE_MATH_DEFINES
+#endif
+#include "LoadTestSample.h"
+#define GLM_ENABLE_EXPERIMENTAL
+#include <glm/gtx/vector_angle.hpp>
+#include <SDL3/SDL_log.h>
+
+#if !defined(LOADTESTSAMPLE_LOG_GESTURE_DETECTION)
+  // Log detected and completed gestures.
+  #define LOADTESTSAMPLE_LOG_GESTURE_DETECTION 0
+#endif
+#if !defined(LOADTESTSAMPLE_LOG_GESTURE_EVENTS)
+  // Log events contributing to gesture detection and gestures.
+  #define LOADTESTSAMPLE_LOG_GESTURE_EVENTS 0
+#endif
+#if !defined(LOADTESTSAMPLE_LOG_MOUSE_UP_DOWN_EVENTS)
+  #define LOADTESTSAMPLE_LOG_MOUSE_UP_DOWN_EVENTS 0
+#endif
+#if !defined(LOADTESTSAMPLE_LOG_MOUSE_MOTION_EVENTS)
+  #define LOADTESTSAMPLE_LOG_MOUSE_MOTION_EVENTS 0
+#endif
+
+#if LOADTESTSAMPLE_LOG_GESTURE_EVENTS
+  #include <sstream>
+
+  const std::string printFingerIds(SDL_Finger* fingers[], uint32_t numFingers) {
+      std::stringstream msg;
+      assert(numFingers > 0);
+      msg << std::hex << std::showbase;
+      msg << "finger id" << (numFingers > 1 ? "s" : "") << ": ";
+      for (uint32_t f = 0; f < numFingers; f++) {
+          if (f > 0) {
+              if (f == numFingers - 1)
+                  msg << " & ";
+              else
+                  msg << ", ";
+          }
+          msg << fingers[f]->id;
+      }
+      return msg.str();
+  }
+
+  const std::string printVector(const std::string& name, glm::vec2 v) {
+      std::stringstream msg;
+      msg << name << " (" << v.x << ", " << v.y << ")";
+      return msg.str();
+  }
+#endif
+
+[[maybe_unused]] static const char*
+buttonName(Uint8 button) {
+    switch(button) {
+        case SDL_BUTTON_LEFT: return "left";
+        case SDL_BUTTON_MIDDLE: return "middle";
+        case SDL_BUTTON_RIGHT: return "right";
+        default: return "other";
+    }
+}
+
+int
+LoadTestSample::doEvent(SDL_Event* event)
+{
+    switch (event->type) {
+      case SDL_EVENT_MOUSE_MOTION:
+      {
+        SDL_MouseMotionEvent& motion = event->motion;
+#if LOADTESTSAMPLE_LOG_MOUSE_MOTION_EVENTS
+        SDL_Log("LTS: MOUSE_MOTION - x: %f, y: %f", motion.x, motion.y);
+#endif
+        // On macOS with trackpad, SDL_TOUCH_MOUSEID is never set.
+        // Prefer mouse events on macOS because press is required. When
+        // finger motion events are used the object starts to rotate when
+        // you drag the cursor over the window. Not nice.
+        if (mouseButtons.left)
+        {
+            rotation.x -= yflip * (mousePos.y - (float)motion.y) * 1.25f;
+            rotation.y -= (mousePos.x - (float)motion.x) * 1.25f;
+            viewChanged();
+        }
+        if (mouseButtons.right)
+        {
+            zoom += (mousePos.y - (float)motion.y) * .005f;
+            viewChanged();
+        }
+        if (mouseButtons.middle)
+        {
+            cameraPos.x -= (mousePos.x - (float)motion.x) * 0.01f;
+            cameraPos.y += yflip * (mousePos.y - (float)motion.y) * 0.01f;
+            viewChanged();
+        }
+        mousePos = glm::vec2((float)motion.x, (float)motion.y);
+        return 0;
+      }
+      case SDL_EVENT_MOUSE_BUTTON_DOWN:
+        mousePos = glm::vec2((float)event->button.x, (float)event->button.y);
+        if (LOADTESTSAMPLE_LOG_MOUSE_UP_DOWN_EVENTS) {
+            SDL_Log("LTS: MOUSE_DOWN - button: %s, x: %f, y: %f", buttonName(event->button.button),
+                     event->button.x, event->button.y);
+        }
+        switch (event->button.button) {
+          case SDL_BUTTON_LEFT:
+            mouseButtons.left = true;
+            break;
+          case SDL_BUTTON_MIDDLE:
+            mouseButtons.middle = true;
+            break;
+          case SDL_BUTTON_RIGHT:
+            mouseButtons.right = true;
+            break;
+          default:
+            return 1;
+        }
+        return 0;
+      case SDL_EVENT_MOUSE_BUTTON_UP:
+       if (LOADTESTSAMPLE_LOG_MOUSE_UP_DOWN_EVENTS) {
+            SDL_Log("LTS: MOUSE_UP - button: %s, x: %f, y: %f", buttonName(event->button.button),
+                     event->button.x, event->button.y);
+        }
+        switch (event->button.button) {
+          case SDL_BUTTON_LEFT:
+            mouseButtons.left = false;
+            break;
+          case SDL_BUTTON_MIDDLE:
+            mouseButtons.middle = false;
+            break;
+          case SDL_BUTTON_RIGHT:
+            mouseButtons.right = false;
+            break;
+          default:
+            return 1;
+        }
+        return 0;
+      case SDL_EVENT_FINGER_DOWN: {
+        // Prevent multifingers from triggering the left button action and
+        // interfering with multigestures.
+        //
+        // On iOS you get a left button down event no matter how many fingers
+        // you touch to the screen. We want 1 finger mouse to work so
+        // behaviour is same as pressing the trackpad on macOS, etc. As iOS
+        // button_down events come before finger_down we can clear the left
+        // button down state, if we have multiple fingers. Hope this ordering
+        // is the same on other touch screen platforms that send a left-button
+        // event regardless of the number of fingers.
+        //
+        // On macOS button_down events come after finger_down so this code has
+        // no effect.
+        //
+        // Another way to handle this is to identify the platform and work
+        // differently for each platform.
+        int numFingers;
+        SDL_Finger** fingers = SDL_GetTouchFingers(event->tfinger.touchID, &numFingers);
+        int retVal = 0;
+#if LOADTESTSAMPLE_LOG_GESTURE_EVENTS
+        SDL_Log("LTS: Finger: %#" SDL_PRIx64 " down - fingers: %i, %s, x: %f, y: %f",
+                event->tfinger.fingerID, numFingers,
+                printFingerIds(fingers, numFingers).c_str(),
+                event->tfinger.x, event->tfinger.y);
+#endif
+        if (numFingers > 1) {
+            mouseButtons.left = false;
+            if (LOADTESTSAMPLE_LOG_GESTURE_EVENTS) {
+                SDL_Log("LTS: FINGER_DOWN with multiple fingers received."
+                        " Resetting mouseButtons.left.");
+            }
+            if (numFingers == 2) {
+                firstFingerId = fingers[0]->id;
+                // Calc. difference vector between fingers.
+                glm::vec2 vDifference;
+                vDifference.x = fingers[1]->x - fingers[0]->x;
+                vDifference.y = fingers[1]->y - fingers[0]->y;
+                distanceStart = glm::length(vDifference);
+                distanceLast = distanceStart;
+                // Need normalized vectors for glm::orientedAngle
+                nvDifferenceStart = glm::normalize(vDifference);
+                nvDifferenceLast = nvDifferenceStart;
+                processingGesture = true;
+#if LOADTESTSAMPLE_LOG_GESTURE_EVENTS
+                // Angle of vector to X axis.
+                xAngleStart = atan2f(vDifference.y, vDifference.x);
+                SDL_Log("LTS: FINGER_DOWN, start values: %s, Distance = %f, XAngle = %f°",
+                        printVector("Difference", vDifference).c_str(),
+                        distanceStart, xAngleStart * 180.0 / M_PI
+                        );
+#endif
+                retVal = 1;
+            }
+        }
+
+        // It is possible to somehow get out of the window without seeing
+        // FINGER_UP so as a safeguard stop any previous gesture.
+        zooming = rotating = false;
+        SDL_free(fingers);
+        return retVal;
+      }
+      case SDL_EVENT_FINGER_UP: {
+        int numFingers;
+        SDL_Finger** fingers = SDL_GetTouchFingers(event->tfinger.touchID, &numFingers);
+#if LOADTESTSAMPLE_LOG_GESTURE_EVENTS
+        SDL_Log("LTS: Finger: %#" SDL_PRIx64 " up - fingers: %i, %s, x: %f, y: %f",
+                event->tfinger.fingerID, numFingers,
+                printFingerIds(fingers, numFingers).c_str(),
+                event->tfinger.x, event->tfinger.y);
+#endif
+        if (processingGesture && numFingers == 2) {
+            // There may still be one finger down. Even so the action is completed.
+            if (LOADTESTSAMPLE_LOG_GESTURE_DETECTION) {
+                SDL_Log("-------------- LTS: %s complete. -----------------",
+                        zooming ? "zooming" : rotating ? "rotating" : "gesture");
+            }
+            zooming = rotating = processingGesture = false;
+        }
+        SDL_free(fingers);
+        break;
+      }
+      case SDL_EVENT_FINGER_MOTION: {
+        int numFingers;
+        SDL_Finger** fingers = SDL_GetTouchFingers(event->tfinger.touchID, &numFingers);
+        if (numFingers != 2)
+            return 1;
+        if (!processingGesture) {
+            // Protect against FINGER_MOTION without FINGER_DOWN. This can
+            // happen when the sample is switched by a swipe and the new sample
+            // receives the tail end of the swipe motion.
+            return 1;
+        }
+        // With two fingers down, events come in pairs. No point in processing
+        // both.
+        if (event->tfinger.fingerID == firstFingerId) {
+            return 0;
+        }
+
+        glm::vec2 vDifference; // Difference vector between the fingers.
+        vDifference.x = fingers[1]->x - fingers[0]->x;
+        vDifference.y = fingers[1]->y - fingers[0]->y;
+        float distance = glm::length(vDifference);
+        // Normalized vectors required by glm::orientedAngle
+        glm::vec2 nvDifference = glm::normalize(vDifference);
+        // Angle between start and current difference vectors
+        float sAngle = glm::orientedAngle(nvDifferenceStart, nvDifference);
+        // Angle between current and previous difference vectors
+        float dAngle = glm::orientedAngle(nvDifferenceLast, nvDifference);
+        // Difference in distance since last motion event.
+        float dDist = distance - distanceLast;
+        // Difference in distance since start.
+        float dDistStart = distance - distanceStart;
+#if LOADTESTSAMPLE_LOG_GESTURE_EVENTS
+        if (!(rotating || zooming)) {
+                // Angle from X axis to vDifference vector
+                float xAngle = atan2f(vDifference.y, vDifference.x);
+                SDL_Log("LTS FINGER_MOTION: Not zooming or rotating. "
+                        " timestamp = %" SDL_PRIu64 ", %s, %s",
+                        event->tfinger.timestamp,
+                        printFingerIds(fingers, numFingers).c_str(),
+                        printVector("Difference", vDifference).c_str());
+                SDL_Log("... distanceLast = %f, distance = %f, dDist = %f, dDistStart = %f, xAngle = %f°, sAngle = %f°, dAngle = %f°",
+                        distanceLast, distance, dDist, dDistStart,
+                        xAngle * 180.0 / M_PI, sAngle * 180.0 / M_PI, dAngle * 180.0 / M_PI);
+        }
+#endif
+        nvDifferenceLast = nvDifference;
+        distanceLast = distance;
+
+        // This is all heuristics derived from use.
+        if (zooming) {
+            zoom += dDist * 10.0f;
+            if (LOADTESTSAMPLE_LOG_GESTURE_EVENTS) {
+                SDL_Log("LTS MG: Zooming. zoom = %f", zoom);
+            }
+        } else if (!rotating) {
+            if (fabs(dDistStart) >= 0.1 && fabs(dAngle) < 0.5 * M_PI / 180.0) {
+                zooming = true;
+                zoom += dDist * 10.0f;
+                if (LOADTESTSAMPLE_LOG_GESTURE_DETECTION) {
+                    SDL_Log("---------------- LTS MG: pinch/zoom detected ---------------\n"
+                            " dAngle = %f°, dDistStart = %f, dDist = %f, zoom = %f",
+                            dAngle * 180.0 / M_PI, dDistStart, dDist, zoom);
+                }
+            }
+        }
+        if (rotating) {
+            rotation.z +=
+                static_cast<float>(dAngle * 180.0 / M_PI);
+            if (LOADTESTSAMPLE_LOG_GESTURE_EVENTS) {
+                SDL_Log("LTS MG: Rotating around Z. rotation.z = %f°", rotation.z);
+            }
+       } else if (!zooming) {
+          if (fabs(sAngle) > 15 * M_PI / 180.0 && fabs(dDistStart) < 0.1) {
+                rotating = true;
+                rotation.z += static_cast<float>(dAngle * 180.0 / M_PI);
+                if (LOADTESTSAMPLE_LOG_GESTURE_DETECTION) {
+                    SDL_Log("---------------- LTS MG: rotation detected ---------------\n"
+                            " sAngle = %f°, dAngle = %f°, dDistStart = %f, rotation.z = %f°",
+                            sAngle * 180 / M_PI, dAngle * 180.0 / M_PI, dDistStart, rotation.z);
+                }
+            }
+        }
+        viewChanged();
+        SDL_free(fingers);
+        return 0;
+      }
+      case SDL_EVENT_KEY_UP:
+        if (event->key.key == 'q')
+            quit = true;
+        keyPressed(event->key.key);
+        return 0;
+      default:
+        break;
+    }
+    return 1;
+}
+

third_party/ktx-src/tests/loadtests/common/LoadTestSample.h

@@ -0,0 +1,91 @@
+/* -*- tab-width: 4; -*- */
+/* vi: set sw=2 ts=4 expandtab: */
+
+/*
+ * Copyright 2017-2020 Mark Callow, <khronos at callow dot im>.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#ifndef _LOAD_TEST_SAMPLE_H
+#define _LOAD_TEST_SAMPLE_H
+
+#include <string>
+#include <SDL3/SDL.h>
+#define GLM_FORCE_RADIANS
+#include "disable_glm_warnings.h"
+#include <glm/glm.hpp>
+#include "reenable_warnings.h"
+
+#define ARRAY_LEN(a) (sizeof(a) / sizeof(a[0]))
+
+class LoadTestSample {
+  public:
+    typedef uint64_t ticks_t;
+    LoadTestSample(uint32_t width, uint32_t height,
+                   const std::string sBasePath,
+                   int32_t yflip = 1)
+           : w_width(width), w_height(height), yflip(yflip),
+             sBasePath(sBasePath)
+    {
+    }
+
+    virtual ~LoadTestSample() { };
+    virtual int doEvent(SDL_Event* event);
+    virtual void resize(uint32_t width, uint32_t height) = 0;
+    virtual void run(uint32_t msTicks) = 0;
+
+    //virtual void getOverlayText(TextOverlay *textOverlay) { };
+
+    typedef LoadTestSample* (*PFN_create)(uint32_t width, uint32_t height,
+                                          const char* const szArgs,
+                                          const std::string sBasePath);
+
+  protected:
+    virtual void keyPressed(uint32_t /*keyCode*/) { }
+    virtual void viewChanged() { }
+    
+    const std::string getAssetPath() { return sBasePath; }
+
+    glm::vec3 rotation;
+    glm::vec3 cameraPos;
+    glm::vec2 mousePos;
+    glm::vec2 nvDifferenceStart; // Normalized difference between fingers at start of gesture.
+    float distanceStart = 0.0; // Distance between fingers at start of gesture.
+    float xAngleStart = 0.0;   // Angle between x-axis and nvDifferenceStart. Unused unless event logging is enabled.
+    glm::vec2 nvDifferenceLast; // Normalized difference between fingers at last motion event.
+    float distanceLast = 0.0;   // Distance between fingers at last motion event.
+    Uint64 firstFingerId = 0;
+    bool processingGesture = false;
+
+    struct {
+        bool left = false;
+        bool right = false;
+        bool middle = false;
+    } mouseButtons;
+    bool quit = false;
+    bool rotating = false;
+    bool zooming = false;
+    bool paused = false;
+
+    float zoom = 0;
+
+    uint32_t w_width;
+    uint32_t w_height;
+
+    // Defines a frame rate independent timer value clamped from -1.0...1.0
+    // For use in animations, rotations, etc.
+    float timer = 0.0f;
+    // Multiplier for speeding up (or slowing down) the global timer
+    float timerSpeed = 0.25f;
+
+    // Use to adjust mouse rotation speed
+    float rotationSpeed = 1.0f;
+    // Use to adjust mouse zoom speed
+    float zoomSpeed = 1.0f;
+    // multiplier to decide if Y increases down or up
+    int32_t yflip;
+
+    const std::string sBasePath;
+};
+
+#endif /* _LOAD_TEST_SAMPLE_H */

third_party/ktx-src/tests/loadtests/common/SwipeDetector.cpp

@@ -0,0 +1,146 @@
+/* -*- tab-width: 4; -*- */
+/* vi: set sw=2 ts=4 expandtab: */
+
+/*
+ * Copyright 2017-2020 Mark Callow.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @internal
+ * @class SwipeDetector
+ * @~English
+ *
+ * @brief Definition of a class for detecting swipes.
+ *
+ * @author Mark Callow, github.com/MarkCallow.
+ */
+
+#include <assert.h>
+#include "SwipeDetector.h"
+#include <SDL3/SDL_log.h>
+
+#if !defined(SWIPEDETECTOR_LOG_GESTURE_EVENTS)
+  #define SWIPEDETECTOR_LOG_GESTURE_EVENTS 0
+#endif
+#if !defined(SWIPEDETECTOR_LOG_GESTURE_DETECTION)
+  #define SWIPEDETECTOR_LOG_GESTURE_DETECTION 0
+#endif
+
+bool
+SwipeDetector::doEvent(SDL_Event* event)
+{
+    bool result = false;
+
+    switch (event->type) {
+      case SDL_EVENT_FINGER_UP: {
+        int numFingers;
+        SDL_Finger** fingers = SDL_GetTouchFingers(event->tfinger.touchID, &numFingers);
+        if (SWIPEDETECTOR_LOG_GESTURE_EVENTS) {
+            SDL_Log("SD: Finger: %" SDL_PRIx64 " UP - fingers: %i, x: %f, y: %f",
+                    event->tfinger.fingerID, numFingers, event->tfinger.x, event->tfinger.y);
+        }
+        // SDL_GetTouchFingers appears to return the number of fingers
+        // down *before* the event was generated, so 1 means the last finger
+        // just lifted.
+        if (numFingers == 1 && gestureStart.time != 0) {
+            gestureStart.time = 0;
+            gestureSwipe = false;
+            if (SWIPEDETECTOR_LOG_GESTURE_DETECTION) {
+                SDL_Log("***************** SD: FINGER_UP, %smultigesture done *****************",
+                        gestureSwipe ? "Swipe complete & " : "");
+            }
+        } else {
+            result = true;
+        }
+        SDL_free(fingers);
+        break;
+      }
+      case GESTURE_MULTIGESTURE: {
+        Gesture_MultiGestureEvent& mgesture = *(Gesture_MultiGestureEvent *)event;
+        if (SWIPEDETECTOR_LOG_GESTURE_EVENTS) {
+            SDL_Log("SD: MG Event: x = %f, y = %f, dAng = %f (%f), dR = %f, numFingers = %i, time = %" SDL_PRIu64,
+               mgesture.x,
+               mgesture.y,
+               mgesture.dTheta * 180.0 / M_PI,
+               mgesture.dTheta,
+               mgesture.dDist,
+               mgesture.numFingers,
+               mgesture.timestamp);
+        }
+        if (SWIPEDETECTOR_LOG_GESTURE_DETECTION) {
+            SDL_Log("SD: mgestureSwipe = %i, time = %" SDL_PRIu64,
+                     gestureSwipe,
+                     (mgesture.timestamp - gestureStart.time) / 1000000);
+        }
+        if (gestureStart.time == 0) {
+            if (SWIPEDETECTOR_LOG_GESTURE_DETECTION) {
+                SDL_Log("************ SD: Multigesture detection start **************");
+            }
+            gestureStart.time = mgesture.timestamp;
+            gestureStart.point.x = mgesture.x;
+            gestureStart.point.y = mgesture.y;
+            lastVector.reset();
+            gestureSwipe = false;
+        } else {
+            if (!gestureSwipe) {
+                vector sv; // Vector from start point to current position
+                float velocity;
+                float theta; // Angle between current vector and previous vector.
+                float duration;
+                sv.w = mgesture.x - gestureStart.point.x;
+                sv.h = mgesture.y - gestureStart.point.y;
+                float distance = sv.length();
+                if (lastVector.has_value()) {
+                    // SDL2 timestamps were in milliseconds, SDL3 are nanoseconds. Given the
+                    // normalized distances reported, using nanoseconds leads to 0 velocitySq.
+                    duration = static_cast<float>(
+                        (mgesture.timestamp - gestureStart.time) / 1000000.0);
+
+                    velocity = distance / duration;
+                    assert(!std::isinf(velocity));
+                    theta = static_cast<float>(lastVector->getAngle(sv));
+                    if (SWIPEDETECTOR_LOG_GESTURE_DETECTION) {
+                        SDL_Log("SD: Detection: distance = %f, velocity = %f, theta = %f, sv angle = %f, sv angle normalized = %f, lastv angle = %f",
+                                distance, velocity, theta,
+                                sv.getAngle(),
+                                sv.getAngleNormalized(),
+                                lastVector->getAngle());
+                    }
+                    lastVector = sv;
+                    // Multiple events with the same timestamp is a possibility
+                    // hence the isinf() check.
+                    if (std::abs(theta) < 3.0 && std::abs(mgesture.dDist) > 0.01 && !std::isinf(velocity) && velocity > 0.0007) {
+                        if (SWIPEDETECTOR_LOG_GESTURE_DETECTION)
+                            SDL_Log("----------------- SD: Swipe %s detected -----------------",
+                                    toString(sv.getDirection()).c_str());
+                        gestureSwipe = true;
+                        if (SDL_EventEnabled(SDL_EVENT_USER)) {
+                            SDL_Event user_event;
+                            // SDL will copy this entire struct! Initialize to keep memory
+                            // checkers happy.
+                            SDL_zero(user_event);
+                            user_event.type = SDL_EVENT_USER;
+                            user_event.user.code = swipeGesture;
+                            user_event.user.data1 = SwipeDetector::directionToPointer(sv.getDirection());
+                            user_event.user.data2 = NULL;
+                            SDL_PushEvent(&user_event);
+                        }
+                    } else {
+                        if (SWIPEDETECTOR_LOG_GESTURE_DETECTION) SDL_Log("SD: No swipe detected.");
+                        result = true;
+                    }
+                } else {
+                     lastVector = sv;
+                     result = true;
+                }
+            }
+        }
+        break;
+      }
+      default:
+          result = true;
+    }
+
+    return result;
+}

third_party/ktx-src/tests/loadtests/common/SwipeDetector.h

@@ -0,0 +1,200 @@
+/* -*- tab-width: 4; -*- */
+/* vi: set sw=2 ts=4 expandtab: */
+
+/*
+ * Copyright 2017-2020 Mark Callow, <khronos at callow dot im>.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#ifndef _SWIPE_DETECTOR_H
+#define _SWIPE_DETECTOR_H
+#if defined(_WIN32)
+  #define _USE_MATH_DEFINES
+#endif
+#include <optional>
+#include <string>
+#include <math.h>
+#include <SDL3/SDL.h>
+#include "SDL_gesture.h"
+
+class SwipeDetector {
+  public:
+    enum class Direction { up, down, left, right };
+
+    SwipeDetector() : gestureSwipe(false) {}
+    bool doEvent(SDL_Event* event);
+
+#if defined(_MSC_VER) && !defined(__clang__)
+   // Not clangcl
+   #pragma warning(push)
+   #pragma warning(disable : 4311)
+   #pragma warning(disable : 4302)
+   #pragma warning(disable : 4312)
+#endif
+#if defined(__clang__)
+    #pragma clang diagnostic push
+    #pragma clang diagnostic ignored "-Wvoid-pointer-to-int-cast"
+#endif
+    // These conversions allow storing a Direction in a pointer.
+    // Ugly. Horrible. But preferable to allocating and freeing memory
+    // when passing the information in user events.
+    static inline Direction pointerToDirection(void* p) {
+        return static_cast<SwipeDetector::Direction>(reinterpret_cast<long>(p));
+    }
+
+    // Only preserves the low 32-bits of the pointer; perfect for this use.
+    static inline void* directionToPointer(SwipeDetector::Direction d) {
+        return reinterpret_cast<void*>(static_cast<long>(d));
+    }
+#if defined(_MSC_VER) && !defined(__clang__)
+        #pragma warning(pop)
+#endif
+#if defined(__clang__)
+    #pragma clang diagnostic pop
+#endif
+
+    static const Uint32 swipeGesture = 0x01;
+
+    class vector {
+      public:
+        float w;
+        float h;
+
+        vector() : w(0.0), h(0.0) { }
+        vector(float _w, float _h) : w(_w), h(_h) { }
+        /**
+         * @~English
+         * @internal
+         * @brief Find the angle between the vector and the X-axis
+         *
+         * Positive angles increase counter-clockwise from the X-axis
+         * which has +x to the right.
+         *
+         * @return the angle between the vector and the x axis in degrees.
+         */
+        double getAngle() {
+            double rad = atan2(h, w);
+            return rad * 180/M_PI;
+        }
+
+        /**
+         * @~English
+         * @internal
+         * @brief Find the angle between this vector and another.
+         *
+         * Positive angles increase counter-clockwise.
+         *
+         * @return the angle between the 2 vectors in degrees.
+         */
+        double getAngle(const vector& v2) {
+            // Reputed to be more accurate but in our use so far both approaches give same answer.
+            //double rad = atan2f(v2.h, v2.w) - SDL_atan2(h, w);
+            double rad = atan2f(w * v2.h - h * v2.w, w * v2.w + h * v2.h);
+            return rad * 180/M_PI;
+        }
+
+        /**
+         * @~English
+         * @internal
+         * @brief Find the angle between the vector and the X-axis
+         *
+         * Positive angles increase counter-clockwise from the X-axis
+         * which has +x to the right. Value is normalized to the range 0 to 360.
+         *
+         * @return the angle between the vector and the x axis in degrees.
+         */
+        double getAngleNormalized() {
+            double rad = atan2(h, w) + M_PI;
+            return fmod(rad*180/M_PI + 180, 360);
+        }
+
+        /**
+         * @~English
+         * @internal
+         * @brief Return the length of the vector.
+         *
+         * @return the length of the vector.
+         */
+        float length() { return sqrt(w * w + h * h); }
+
+        /**
+         * @~English
+         * @internal
+         * @brief Return the direction of the vector.
+         *
+         * @return the direction
+         */
+        Direction getDirection() {
+            double angle = getAngleNormalized();
+            return getDirection(angle);
+        }
+
+        /**
+         * @~English
+         * @internal
+         * @brief Return a direction given an angle.
+         *
+         * Directions are defined as follows:
+         *
+         * Up: [45, 135]
+         * Right: [0,45] and [315, 360]
+         * Down: [225, 315]
+         * Left: [135, 225]
+         *
+         * @param angle an angle from 0 to 360°
+         * @return the direction of an angle
+         */
+        static Direction getDirection(double angle){
+            if (inRange(angle, 45, 135)) {
+                return Direction::down;
+            } else if (inRange(angle, 0, 45) || inRange(angle, 315, 360)) {
+                return Direction::right;
+            } else if (inRange(angle, 225, 315)) {
+                return Direction::up;
+            } else {
+               return Direction::left;
+           }
+        }
+
+      protected:
+        /**
+         * @~English
+         * @internal
+         * @brief Check if angle falls within an interval.
+         *
+         * @param angle an angle
+         * @param init the initial bound
+         * @param end the final bound
+         *
+         * @return true if the given angle is in the interval [init, end), false
+         *         otherwise.
+         */
+        static bool inRange(double angle, float init, float end){
+            return (angle >= init) && (angle < end);
+        }
+    };
+
+  protected:
+    struct gestureStart {
+        Uint64 time;
+        SDL_FPoint point;
+        gestureStart() { time = 0; point.x = point.y = 0.0; }
+    } gestureStart;
+    std::optional<vector> lastVector;
+    bool gestureSwipe;
+};
+
+[[nodiscard]] inline std::string toString(SwipeDetector::Direction dir) {
+    switch (dir) {
+      case SwipeDetector::Direction::up: return "up";
+      case SwipeDetector::Direction::down: return "down";
+      case SwipeDetector::Direction::left: return "left";
+      case SwipeDetector::Direction::right: return "right";
+      // This is to hide a warning from MSVC. According to the solution given
+      // in https://developercommunity.visualstudio.com/t/Visual-Studio-warning-on-Strongly-typed-/96302
+      // it is possible to construct an enum class with any value. Thus warning.
+      default: return "unknown";
+    }
+}
+
+#endif /* _SWIPE_DETECTOR_H */

third_party/ktx-src/tests/loadtests/common/TranscodeTargetStrToFmt.cpp

@@ -0,0 +1,61 @@
+/* -*- tab-width: 4; -*- */
+/* vi: set sw=2 ts=4 expandtab: */
+
+/*
+ * Copyright 2017-2020 Mark Callow, <khronos at callow dot im>.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <assert.h>
+#include <ktx.h>
+#include "TranscodeTargetStrToFmt.h"
+
+ktx_transcode_fmt_e
+TranscodeTargetStrToFmt(std::string format)
+{
+    if (!format.compare("ETC1_RGB"))
+        return KTX_TTF_ETC1_RGB;
+    else if (!format.compare("ETC2_RGBA"))
+        return KTX_TTF_ETC2_RGBA;
+    else if (!format.compare("BC1_RGB"))
+        return KTX_TTF_BC1_RGB;
+    else if (!format.compare("BC3_RGBA"))
+        return KTX_TTF_BC3_RGBA;
+    else if (!format.compare("BC4_R"))
+        return KTX_TTF_BC4_R;
+    else if (!format.compare("BC5_RG"))
+        return KTX_TTF_BC5_RG;
+    else if (!format.compare("BC7_M6_RGB"))
+        return KTX_TTF_BC7_M6_RGB;
+    else if (!format.compare("BC7_M5_RGBA"))
+        return KTX_TTF_BC7_M5_RGBA;
+    else if (!format.compare("PVRTC1_4_RGB"))
+        return KTX_TTF_PVRTC1_4_RGB;
+    else if (!format.compare("PVRTC1_4_RGBA"))
+        return KTX_TTF_PVRTC1_4_RGBA;
+    else if (!format.compare("ASTC_4x4_RGBA"))
+        return KTX_TTF_ASTC_4x4_RGBA;
+    else if (!format.compare("PVRTC2_4_RGB"))
+        return KTX_TTF_PVRTC2_4_RGB;
+    else if (!format.compare("PVRTC2_4_RGBA"))
+        return KTX_TTF_PVRTC2_4_RGBA;
+    else if (!format.compare("ETC2_EAC_R11"))
+        return KTX_TTF_ETC2_EAC_R11;
+    else if (!format.compare("ETC2_EAC_RG11"))
+        return KTX_TTF_ETC2_EAC_RG11;
+    else if (!format.compare("RGBA32"))
+        return KTX_TTF_RGBA32;
+    else if (!format.compare("RGB565"))
+        return KTX_TTF_RGB565;
+    else if (!format.compare("BGR565"))
+        return KTX_TTF_BGR565;
+    else if (!format.compare("RGBA4444"))
+        return KTX_TTF_RGBA4444;
+    else if (!format.compare("ETC"))
+        return KTX_TTF_ETC;
+    else if (!format.compare("BC1_OR_3"))
+        return KTX_TTF_BC1_OR_3;
+    assert(false); // Error in args in sample table.
+    return static_cast<ktx_transcode_fmt_e>(-1); // To keep compilers happy.
+}
+

third_party/ktx-src/tests/loadtests/common/TranscodeTargetStrToFmt.h

@@ -0,0 +1,16 @@
+/* -*- tab-width: 4; -*- */
+/* vi: set sw=2 ts=4 expandtab: */
+
+/*
+ * Copyright 2017-2020 Mark Callow, <khronos at callow dot im>.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#ifndef _TRANSCODE_TARGET_STR_TO_FMT_
+#define _TRANSCODE_TARGET_STR_TO_FMT_
+
+#include <string>
+
+ktx_transcode_fmt_e TranscodeTargetStrToFmt(std::string format);
+
+#endif /* _TRANSCODE_TARGET_STR_TO_FMT_ */

third_party/ktx-src/tests/loadtests/common/disable_glm_warnings.h

@@ -0,0 +1,21 @@
+/* -*- tab-width: 4; -*- */
+/* vi: set sw=2 ts=4 expandtab: */
+
+/*
+ * Copyright 2021 Mark Callow.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#if !defined DISABLE_GLM_WARNINGS_H
+
+// Temporarily disable the warnings caused by the GLM code.
+#if defined(_MSC_VER)
+  #pragma warning(push)
+  #pragma warning(disable: 4201)
+#elif defined(__clang__)
+  #pragma clang diagnostic push
+  #pragma clang diagnostic ignored "-Wgnu-anonymous-struct"
+  #pragma clang diagnostic ignored "-Wnested-anon-types"
+#endif
+
+#endif /* DISABLE_GLM_WARNINGS_H */

third_party/ktx-src/tests/loadtests/common/ltexceptions.h

@@ -0,0 +1,66 @@
+/* -*- tab-width: 4; -*- */
+/* vi: set sw=2 ts=4 expandtab: */
+
+/*
+ * Copyright 2018-2020 Mark Callow, <khronos at callow dot im>.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @internal
+ * @file
+ * @~English
+ *
+ * @brief Custom exceptions for the load tests.
+ */
+
+#include <stdexcept>
+#include <string>
+
+#define OUT_OF_HOST_MEMORY -1
+#define OUT_OF_DEVICE_MEMORY -2
+#define FRAGMENTED_POOL -12
+#define OUT_OF_POOL_MEMORY -1000069000
+
+class bad_vulkan_alloc : public std::bad_alloc {
+  public:
+    bad_vulkan_alloc(int which, const char* _message) : std::bad_alloc() {
+        if (which == FRAGMENTED_POOL) {
+            message << "Pool fragmented when allocating for " << _message << ".";
+        } else {
+          std::string memtype;
+            switch (which) {
+              case OUT_OF_HOST_MEMORY: memtype = "host"; break;
+              case OUT_OF_DEVICE_MEMORY: memtype = "device"; break;
+              case OUT_OF_POOL_MEMORY: memtype = "pool"; break;
+              default: break;
+            }
+            message << "Out of " << memtype << " memory for " << _message << ".";
+        }
+        _what = message.str();
+    }
+    bad_vulkan_alloc(const bad_vulkan_alloc& in)
+      : std::bad_alloc()
+      , message{in.message.str()}
+      , _what{in._what}
+    {}
+    virtual const char* what() const throw() {
+        return _what.c_str();
+    }
+  protected:
+    std::stringstream message;
+    std::string _what;
+};
+
+class unsupported_ttype : public std::runtime_error {
+  public:
+    unsupported_ttype()
+         : std::runtime_error("Implementation does not support needed operations on image format") { }
+    unsupported_ttype(std::string& message) : std::runtime_error(message) { }
+};
+
+class unsupported_ctype : public std::runtime_error {
+  public:
+    unsupported_ctype()
+         : std::runtime_error("Unsupported compression format") { }
+};

third_party/ktx-src/tests/loadtests/common/models/cube.obj

@@ -0,0 +1,63 @@
+# Copyright 2020 The Khronos Group Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+# Max2Obj Version 4.0 Mar 10th, 2001
+#
+# object default to come ...
+#
+v  -5.000000 -5.000000 -5.000000
+v  5.000000 -5.000000 -5.000000
+v  -5.000000 5.000000 -5.000000
+v  5.000000 5.000000 -5.000000
+v  -5.000000 -5.000000 5.000000
+v  5.000000 -5.000000 5.000000
+v  -5.000000 5.000000 5.000000
+v  5.000000 5.000000 5.000000
+# 8 vertices
+
+vt  0.000000 0.000000 0.000000
+vt  1.000000 0.000000 0.000000
+vt  0.000000 1.000000 0.000000
+vt  1.000000 1.000000 0.000000
+vt  0.000000 0.000000 0.000000
+vt  1.000000 0.000000 0.000000
+vt  0.000000 1.000000 0.000000
+vt  1.000000 1.000000 0.000000
+vt  0.000000 0.000000 0.000000
+vt  1.000000 0.000000 0.000000
+vt  0.000000 1.000000 0.000000
+vt  1.000000 1.000000 0.000000
+# 12 texture vertices
+
+vn  0.000000 0.000000 -2.000000
+vn  0.000000 0.000000 -1.000000
+vn  0.000000 0.000000 -1.000000
+vn  0.000000 0.000000 -2.000000
+vn  0.000000 -0.000000 2.000000
+vn  0.000000 -0.000000 1.000000
+vn  0.000000 -0.000000 1.000000
+vn  0.000000 -0.000000 2.000000
+# 8 vertex normals
+
+g default
+s 2
+f 1/10/1 3/12/3 4/11/4
+f 4/11/4 2/9/2 1/10/1
+s 4
+f 5/9/5 6/10/6 8/12/8
+f 8/12/8 7/11/7 5/9/5
+s 8
+f 1/5/1 2/6/2 6/8/6
+f 6/8/6 5/7/5 1/5/1
+s 16
+f 2/1/2 4/2/4 8/4/8
+f 8/4/8 6/3/6 2/1/2
+s 32
+f 4/5/4 3/6/3 7/8/7
+f 7/8/7 8/7/8 4/5/4
+s 64
+f 3/1/3 1/2/1 5/4/5
+f 5/4/5 7/3/7 3/1/3
+# 12 faces
+
+g

third_party/ktx-src/tests/loadtests/common/models/sphere.obj

@@ -0,0 +1,2503 @@
+# Copyright 2020 The Khronos Group Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+# Max2Obj Version 4.0 Mar 10th, 2001
+#
+# object default to come ...
+#
+v  0.000000 19.737080 -0.000000
+v  -0.000000 19.357838 -3.850513
+v  -0.751198 19.357838 -3.776527
+v  -1.473528 19.357838 -3.557410
+v  -2.139230 19.357838 -3.201585
+v  -2.722724 19.357838 -2.722724
+v  -3.201585 19.357838 -2.139230
+v  -3.557411 19.357838 -1.473527
+v  -3.776527 19.357838 -0.751197
+v  -3.850513 19.357838 0.000001
+v  -3.776526 19.357838 0.751199
+v  -3.557410 19.357838 1.473529
+v  -3.201584 19.357838 2.139232
+v  -2.722722 19.357838 2.722726
+v  -2.139228 19.357838 3.201586
+v  -1.473525 19.357838 3.557412
+v  -0.751195 19.357838 3.776527
+v  0.000004 19.357838 3.850513
+v  0.751202 19.357838 3.776526
+v  1.473532 19.357838 3.557409
+v  2.139235 19.357838 3.201582
+v  2.722728 19.357838 2.722721
+v  3.201588 19.357838 2.139226
+v  3.557413 19.357838 1.473523
+v  3.776528 19.357838 0.751192
+v  3.850513 19.357838 -0.000006
+v  3.776525 19.357838 -0.751204
+v  3.557408 19.357838 -1.473534
+v  3.201581 19.357838 -2.139236
+v  2.722719 19.357838 -2.722729
+v  2.139224 19.357838 -3.201589
+v  1.473520 19.357838 -3.557414
+v  0.751190 19.357838 -3.776528
+v  -0.000000 18.234684 -7.553053
+v  -1.473528 18.234684 -7.407924
+v  -2.890428 18.234684 -6.978112
+v  -4.196251 18.234684 -6.280135
+v  -5.340816 18.234684 -5.340816
+v  -6.280135 18.234684 -4.196251
+v  -6.978112 18.234684 -2.890427
+v  -7.407924 18.234684 -1.473526
+v  -7.553053 18.234684 0.000002
+v  -7.407923 18.234684 1.473531
+v  -6.978110 18.234684 2.890432
+v  -6.280132 18.234684 4.196255
+v  -5.340812 18.234684 5.340819
+v  -4.196247 18.234684 6.280138
+v  -2.890423 18.234684 6.978114
+v  -1.473521 18.234684 7.407925
+v  0.000007 18.234684 7.553053
+v  1.473535 18.234684 7.407922
+v  2.890436 18.234684 6.978108
+v  4.196259 18.234684 6.280129
+v  5.340822 18.234684 5.340808
+v  6.280140 18.234684 4.196243
+v  6.978116 18.234684 2.890418
+v  7.407926 18.234684 1.473516
+v  7.553053 18.234684 -0.000012
+v  7.407921 18.234684 -1.473540
+v  6.978106 18.234684 -2.890441
+v  6.280127 18.234684 -4.196263
+v  5.340805 18.234684 -5.340826
+v  4.196239 18.234684 -6.280143
+v  2.890414 18.234684 -6.978117
+v  1.473512 18.234684 -7.407927
+v  -0.000000 16.410782 -10.965334
+v  -2.139230 16.410782 -10.754638
+v  -4.196251 16.410782 -10.130648
+v  -6.092012 16.410782 -9.117342
+v  -7.753662 16.410782 -7.753662
+v  -9.117343 16.410782 -6.092012
+v  -10.130649 16.410782 -4.196250
+v  -10.754639 16.410782 -2.139228
+v  -10.965334 16.410782 0.000004
+v  -10.754638 16.410782 2.139235
+v  -10.130646 16.410782 4.196257
+v  -9.117338 16.410782 6.092018
+v  -7.753657 16.410782 7.753667
+v  -6.092007 16.410782 9.117347
+v  -4.196243 16.410782 10.130651
+v  -2.139221 16.410782 10.754640
+v  0.000011 16.410782 10.965334
+v  2.139242 16.410782 10.754636
+v  4.196263 16.410782 10.130643
+v  6.092024 16.410782 9.117334
+v  7.753672 16.410782 7.753652
+v  9.117351 16.410782 6.092000
+v  10.130653 16.410782 4.196237
+v  10.754642 16.410782 2.139214
+v  10.965334 16.410782 -0.000018
+v  10.754635 16.410782 -2.139249
+v  10.130640 16.410782 -4.196270
+v  9.117331 16.410782 -6.092030
+v  7.753647 16.410782 -7.753677
+v  6.091995 16.410782 -9.117354
+v  4.196230 16.410782 -10.130656
+v  2.139207 16.410782 -10.754642
+v  -0.000001 13.956223 -13.956223
+v  -2.722724 13.956223 -13.688058
+v  -5.340815 13.956223 -12.893869
+v  -7.753661 13.956223 -11.604176
+v  -9.868540 13.956223 -9.868540
+v  -11.604177 13.956223 -7.753661
+v  -12.893869 13.956223 -5.340813
+v  -13.688059 13.956223 -2.722721
+v  -13.956223 13.956223 0.000005
+v  -13.688057 13.956223 2.722730
+v  -12.893867 13.956223 5.340822
+v  -11.604171 13.956223 7.753669
+v  -9.868534 13.956223 9.868546
+v  -7.753654 13.956223 11.604181
+v  -5.340805 13.956223 12.893873
+v  -2.722712 13.956223 13.688061
+v  0.000013 13.956223 13.956223
+v  2.722738 13.956223 13.688055
+v  5.340830 13.956223 12.893863
+v  7.753676 13.956223 11.604166
+v  9.868553 13.956223 9.868527
+v  11.604186 13.956223 7.753646
+v  12.893877 13.956223 5.340797
+v  13.688063 13.956223 2.722703
+v  13.956223 13.956223 -0.000022
+v  13.688054 13.956223 -2.722747
+v  12.893860 13.956223 -5.340838
+v  11.604161 13.956223 -7.753684
+v  9.868521 13.956223 -9.868559
+v  7.753639 13.956223 -11.604191
+v  5.340788 13.956223 -12.893880
+v  2.722694 13.956223 -13.688065
+v  -0.000001 10.965333 -16.410782
+v  -3.201585 10.965333 -16.095453
+v  -6.280134 10.965333 -15.161586
+v  -9.117341 10.965333 -13.645067
+v  -11.604176 10.965333 -11.604176
+v  -13.645067 10.965333 -9.117341
+v  -15.161587 10.965333 -6.280132
+v  -16.095455 10.965333 -3.201581
+v  -16.410782 10.965333 0.000005
+v  -16.095453 10.965333 3.201591
+v  -15.161583 10.965333 6.280142
+v  -13.645061 10.965333 9.117350
+v  -11.604168 10.965333 11.604183
+v  -9.117332 10.965333 13.645074
+v  -6.280122 10.965333 15.161591
+v  -3.201571 10.965333 16.095457
+v  0.000016 10.965333 16.410782
+v  3.201602 10.965333 16.095451
+v  6.280151 10.965333 15.161579
+v  9.117358 10.965333 13.645056
+v  11.604191 10.965333 11.604160
+v  13.645080 10.965333 9.117324
+v  15.161595 10.965333 6.280113
+v  16.095459 10.965333 3.201560
+v  16.410782 10.965333 -0.000026
+v  16.095448 10.965333 -3.201612
+v  15.161575 10.965333 -6.280161
+v  13.645050 10.965333 -9.117368
+v  11.604154 10.965333 -11.604198
+v  9.117315 10.965333 -13.645085
+v  6.280103 10.965333 -15.161599
+v  3.201550 10.965333 -16.095461
+v  -0.000001 7.553053 -18.234684
+v  -3.557410 7.553053 -17.884310
+v  -6.978111 7.553053 -16.846651
+v  -10.130647 7.553053 -15.161587
+v  -12.893868 7.553053 -12.893868
+v  -15.161587 7.553053 -10.130647
+v  -16.846653 7.553053 -6.978108
+v  -17.884310 7.553053 -3.557406
+v  -18.234684 7.553053 0.000006
+v  -17.884308 7.553053 3.557418
+v  -16.846647 7.553053 6.978120
+v  -15.161580 7.553053 10.130656
+v  -12.893860 7.553053 12.893877
+v  -10.130636 7.553053 15.161592
+v  -6.978098 7.553053 16.846657
+v  -3.557395 7.553053 17.884314
+v  0.000018 7.553053 18.234684
+v  3.557429 7.553053 17.884306
+v  6.978130 7.553053 16.846643
+v  10.130666 7.553053 15.161573
+v  12.893886 7.553053 12.893852
+v  15.161599 7.553053 10.130627
+v  16.846661 7.553053 6.978087
+v  17.884315 7.553053 3.557383
+v  18.234684 7.553053 -0.000029
+v  17.884304 7.553053 -3.557441
+v  16.846640 7.553053 -6.978141
+v  15.161567 7.553053 -10.130675
+v  12.893844 7.553053 -12.893893
+v  10.130617 7.553053 -15.161606
+v  6.978076 7.553053 -16.846666
+v  3.557372 7.553053 -17.884317
+v  -0.000001 3.850514 -19.357838
+v  -3.776527 3.850514 -18.985882
+v  -7.407923 3.850514 -17.884310
+v  -10.754637 3.850514 -16.095453
+v  -13.688058 3.850514 -13.688058
+v  -16.095453 3.850514 -10.754637
+v  -17.884310 3.850514 -7.407920
+v  -18.985882 3.850514 -3.776522
+v  -19.357838 3.850514 0.000006
+v  -18.985880 3.850514 3.776534
+v  -17.884306 3.850514 7.407932
+v  -16.095448 3.850514 10.754647
+v  -13.688049 3.850514 13.688066
+v  -10.754626 3.850514 16.095461
+v  -7.407909 3.850514 17.884315
+v  -3.776510 3.850514 18.985886
+v  0.000019 3.850514 19.357838
+v  3.776546 3.850514 18.985878
+v  7.407944 3.850514 17.884300
+v  10.754658 3.850514 16.095440
+v  13.688075 3.850514 13.688040
+v  16.095469 3.850514 10.754616
+v  17.884319 3.850514 7.407897
+v  18.985888 3.850514 3.776498
+v  19.357838 3.850514 -0.000031
+v  18.985876 3.850514 -3.776559
+v  17.884296 3.850514 -7.407955
+v  16.095434 3.850514 -10.754667
+v  13.688031 3.850514 -13.688085
+v  10.754605 3.850514 -16.095474
+v  7.407886 3.850514 -17.884325
+v  3.776485 3.850514 -18.985889
+v  -0.000001 0.000001 -19.737080
+v  -3.850513 0.000001 -19.357838
+v  -7.553053 0.000001 -18.234684
+v  -10.965333 0.000001 -16.410782
+v  -13.956223 0.000001 -13.956223
+v  -16.410784 0.000001 -10.965333
+v  -18.234686 0.000001 -7.553051
+v  -19.357838 0.000001 -3.850508
+v  -19.737080 0.000001 0.000006
+v  -19.357836 0.000001 3.850521
+v  -18.234680 0.000001 7.553062
+v  -16.410776 0.000001 10.965343
+v  -13.956214 0.000001 13.956232
+v  -10.965322 0.000001 16.410789
+v  -7.553039 0.000001 18.234690
+v  -3.850496 0.000001 19.357841
+v  0.000019 0.000001 19.737080
+v  3.850533 0.000001 19.357834
+v  7.553074 0.000001 18.234674
+v  10.965354 0.000001 16.410769
+v  13.956241 0.000001 13.956205
+v  16.410797 0.000001 10.965311
+v  18.234695 0.000001 7.553027
+v  19.357843 0.000001 3.850484
+v  19.737080 0.000001 -0.000032
+v  19.357830 0.000001 -3.850546
+v  18.234671 0.000001 -7.553085
+v  16.410761 0.000001 -10.965364
+v  13.956196 0.000001 -13.956249
+v  10.965301 0.000001 -16.410805
+v  7.553015 0.000001 -18.234699
+v  3.850471 0.000001 -19.357845
+v  -0.000001 -3.850511 -19.357838
+v  -3.776527 -3.850511 -18.985882
+v  -7.407923 -3.850511 -17.884310
+v  -10.754637 -3.850511 -16.095455
+v  -13.688058 -3.850511 -13.688058
+v  -16.095455 -3.850511 -10.754637
+v  -17.884312 -3.850511 -7.407921
+v  -18.985884 -3.850511 -3.776522
+v  -19.357838 -3.850511 0.000006
+v  -18.985880 -3.850511 3.776535
+v  -17.884306 -3.850511 7.407932
+v  -16.095448 -3.850511 10.754647
+v  -13.688049 -3.850511 13.688067
+v  -10.754626 -3.850511 16.095461
+v  -7.407909 -3.850511 17.884315
+v  -3.776510 -3.850511 18.985886
+v  0.000019 -3.850511 19.357838
+v  3.776547 -3.850511 18.985878
+v  7.407944 -3.850511 17.884302
+v  10.754658 -3.850511 16.095440
+v  13.688076 -3.850511 13.688041
+v  16.095469 -3.850511 10.754617
+v  17.884321 -3.850511 7.407898
+v  18.985888 -3.850511 3.776498
+v  19.357838 -3.850511 -0.000031
+v  18.985876 -3.850511 -3.776559
+v  17.884296 -3.850511 -7.407955
+v  16.095434 -3.850511 -10.754668
+v  13.688032 -3.850511 -13.688085
+v  10.754606 -3.850511 -16.095476
+v  7.407887 -3.850511 -17.884325
+v  3.776486 -3.850511 -18.985889
+v  -0.000001 -7.553051 -18.234686
+v  -3.557411 -7.553051 -17.884310
+v  -6.978111 -7.553051 -16.846653
+v  -10.130647 -7.553051 -15.161588
+v  -12.893869 -7.553051 -12.893869
+v  -15.161588 -7.553051 -10.130647
+v  -16.846653 -7.553051 -6.978109
+v  -17.884312 -7.553051 -3.557406
+v  -18.234686 -7.553051 0.000006
+v  -17.884310 -7.553051 3.557418
+v  -16.846649 -7.553051 6.978120
+v  -15.161581 -7.553051 10.130657
+v  -12.893861 -7.553051 12.893878
+v  -10.130637 -7.553051 15.161593
+v  -6.978098 -7.553051 16.846659
+v  -3.557395 -7.553051 17.884314
+v  0.000018 -7.553051 18.234686
+v  3.557429 -7.553051 17.884308
+v  6.978131 -7.553051 16.846645
+v  10.130667 -7.553051 15.161574
+v  12.893886 -7.553051 12.893853
+v  15.161600 -7.553051 10.130628
+v  16.846663 -7.553051 6.978087
+v  17.884315 -7.553051 3.557383
+v  18.234686 -7.553051 -0.000029
+v  17.884304 -7.553051 -3.557441
+v  16.846640 -7.553051 -6.978142
+v  15.161568 -7.553051 -10.130676
+v  12.893845 -7.553051 -12.893894
+v  10.130618 -7.553051 -15.161607
+v  6.978077 -7.553051 -16.846666
+v  3.557372 -7.553051 -17.884319
+v  -0.000001 -10.965333 -16.410782
+v  -3.201585 -10.965333 -16.095453
+v  -6.280134 -10.965333 -15.161587
+v  -9.117341 -10.965333 -13.645068
+v  -11.604176 -10.965333 -11.604176
+v  -13.645068 -10.965333 -9.117341
+v  -15.161588 -10.965333 -6.280132
+v  -16.095455 -10.965333 -3.201581
+v  -16.410782 -10.965333 0.000005
+v  -16.095453 -10.965333 3.201591
+v  -15.161583 -10.965333 6.280142
+v  -13.645062 -10.965333 9.117351
+v  -11.604168 -10.965333 11.604183
+v  -9.117332 -10.965333 13.645074
+v  -6.280122 -10.965333 15.161592
+v  -3.201571 -10.965333 16.095457
+v  0.000016 -10.965333 16.410782
+v  3.201602 -10.965333 16.095451
+v  6.280152 -10.965333 15.161579
+v  9.117359 -10.965333 13.645056
+v  11.604191 -10.965333 11.604161
+v  13.645080 -10.965333 9.117324
+v  15.161595 -10.965333 6.280113
+v  16.095459 -10.965333 3.201560
+v  16.410782 -10.965333 -0.000026
+v  16.095449 -10.965333 -3.201612
+v  15.161575 -10.965333 -6.280161
+v  13.645050 -10.965333 -9.117368
+v  11.604154 -10.965333 -11.604198
+v  9.117315 -10.965333 -13.645085
+v  6.280103 -10.965333 -15.161599
+v  3.201550 -10.965333 -16.095461
+v  -0.000001 -13.956223 -13.956223
+v  -2.722724 -13.956223 -13.688058
+v  -5.340815 -13.956223 -12.893868
+v  -7.753661 -13.956223 -11.604176
+v  -9.868540 -13.956223 -9.868540
+v  -11.604176 -13.956223 -7.753661
+v  -12.893869 -13.956223 -5.340813
+v  -13.688059 -13.956223 -2.722721
+v  -13.956223 -13.956223 0.000005
+v  -13.688057 -13.956223 2.722729
+v  -12.893866 -13.956223 5.340821
+v  -11.604171 -13.956223 7.753668
+v  -9.868533 -13.956223 9.868546
+v  -7.753654 -13.956223 11.604180
+v  -5.340805 -13.956223 12.893873
+v  -2.722712 -13.956223 13.688060
+v  0.000013 -13.956223 13.956223
+v  2.722738 -13.956223 13.688055
+v  5.340830 -13.956223 12.893863
+v  7.753676 -13.956223 11.604166
+v  9.868552 -13.956223 9.868527
+v  11.604186 -13.956223 7.753646
+v  12.893876 -13.956223 5.340796
+v  13.688062 -13.956223 2.722703
+v  13.956223 -13.956223 -0.000022
+v  13.688053 -13.956223 -2.722747
+v  12.893859 -13.956223 -5.340838
+v  11.604161 -13.956223 -7.753684
+v  9.868521 -13.956223 -9.868559
+v  7.753639 -13.956223 -11.604191
+v  5.340788 -13.956223 -12.893880
+v  2.722694 -13.956223 -13.688064
+v  -0.000000 -16.410784 -10.965333
+v  -2.139230 -16.410784 -10.754637
+v  -4.196251 -16.410784 -10.130647
+v  -6.092011 -16.410784 -9.117341
+v  -7.753661 -16.410784 -7.753661
+v  -9.117341 -16.410784 -6.092011
+v  -10.130647 -16.410784 -4.196249
+v  -10.754638 -16.410784 -2.139228
+v  -10.965333 -16.410784 0.000004
+v  -10.754636 -16.410784 2.139235
+v  -10.130644 -16.410784 4.196256
+v  -9.117337 -16.410784 6.092018
+v  -7.753656 -16.410784 7.753666
+v  -6.092006 -16.410784 9.117345
+v  -4.196243 -16.410784 10.130650
+v  -2.139221 -16.410784 10.754639
+v  0.000011 -16.410784 10.965333
+v  2.139241 -16.410784 10.754635
+v  4.196262 -16.410784 10.130642
+v  6.092023 -16.410784 9.117333
+v  7.753671 -16.410784 7.753651
+v  9.117349 -16.410784 6.092000
+v  10.130652 -16.410784 4.196237
+v  10.754640 -16.410784 2.139214
+v  10.965333 -16.410784 -0.000018
+v  10.754633 -16.410784 -2.139248
+v  10.130639 -16.410784 -4.196269
+v  9.117330 -16.410784 -6.092029
+v  7.753646 -16.410784 -7.753676
+v  6.091994 -16.410784 -9.117353
+v  4.196230 -16.410784 -10.130655
+v  2.139207 -16.410784 -10.754642
+v  -0.000000 -18.234686 -7.553051
+v  -1.473527 -18.234686 -7.407920
+v  -2.890427 -18.234686 -6.978109
+v  -4.196249 -18.234686 -6.280132
+v  -5.340813 -18.234686 -5.340813
+v  -6.280132 -18.234686 -4.196249
+v  -6.978109 -18.234686 -2.890426
+v  -7.407921 -18.234686 -1.473525
+v  -7.553051 -18.234686 0.000002
+v  -7.407920 -18.234686 1.473530
+v  -6.978107 -18.234686 2.890431
+v  -6.280129 -18.234686 4.196253
+v  -5.340810 -18.234686 5.340816
+v  -4.196245 -18.234686 6.280135
+v  -2.890422 -18.234686 6.978111
+v  -1.473521 -18.234686 7.407922
+v  0.000007 -18.234686 7.553051
+v  1.473535 -18.234686 7.407919
+v  2.890435 -18.234686 6.978106
+v  4.196258 -18.234686 6.280127
+v  5.340820 -18.234686 5.340806
+v  6.280138 -18.234686 4.196241
+v  6.978113 -18.234686 2.890417
+v  7.407923 -18.234686 1.473516
+v  7.553051 -18.234686 -0.000012
+v  7.407918 -18.234686 -1.473539
+v  6.978104 -18.234686 -2.890440
+v  6.280124 -18.234686 -4.196261
+v  5.340803 -18.234686 -5.340823
+v  4.196238 -18.234686 -6.280140
+v  2.890413 -18.234686 -6.978115
+v  1.473511 -18.234686 -7.407924
+v  -0.000000 -19.357838 -3.850508
+v  -0.751197 -19.357838 -3.776522
+v  -1.473526 -19.357838 -3.557406
+v  -2.139228 -19.357838 -3.201581
+v  -2.722721 -19.357838 -2.722721
+v  -3.201581 -19.357838 -2.139228
+v  -3.557406 -19.357838 -1.473525
+v  -3.776522 -19.357838 -0.751196
+v  -3.850508 -19.357838 0.000001
+v  -3.776522 -19.357838 0.751198
+v  -3.557405 -19.357838 1.473528
+v  -3.201580 -19.357838 2.139230
+v  -2.722719 -19.357838 2.722722
+v  -2.139225 -19.357838 3.201582
+v  -1.473523 -19.357838 3.557407
+v  -0.751194 -19.357838 3.776523
+v  0.000004 -19.357838 3.850508
+v  0.751201 -19.357838 3.776521
+v  1.473530 -19.357838 3.557404
+v  2.139232 -19.357838 3.201578
+v  2.722724 -19.357838 2.722717
+v  3.201584 -19.357838 2.139224
+v  3.557408 -19.357838 1.473521
+v  3.776523 -19.357838 0.751191
+v  3.850508 -19.357838 -0.000006
+v  3.776521 -19.357838 -0.751203
+v  3.557403 -19.357838 -1.473532
+v  3.201577 -19.357838 -2.139234
+v  2.722715 -19.357838 -2.722726
+v  2.139221 -19.357838 -3.201585
+v  1.473518 -19.357838 -3.557409
+v  0.751189 -19.357838 -3.776524
+v  0.000000 -19.737080 -0.000000
+# 482 vertices
+
+vt  0.000000 1.000000 0.000000
+vt  0.031250 1.000000 0.000000
+vt  0.062500 1.000000 0.000000
+vt  0.093750 1.000000 0.000000
+vt  0.125000 1.000000 0.000000
+vt  0.156250 1.000000 0.000000
+vt  0.187500 1.000000 0.000000
+vt  0.218750 1.000000 0.000000
+vt  0.250000 1.000000 0.000000
+vt  0.281250 1.000000 0.000000
+vt  0.312500 1.000000 0.000000
+vt  0.343750 1.000000 0.000000
+vt  0.375000 1.000000 0.000000
+vt  0.406250 1.000000 0.000000
+vt  0.437500 1.000000 0.000000
+vt  0.468750 1.000000 0.000000
+vt  0.500000 1.000000 0.000000
+vt  0.531250 1.000000 0.000000
+vt  0.562500 1.000000 0.000000
+vt  0.593750 1.000000 0.000000
+vt  0.625000 1.000000 0.000000
+vt  0.656250 1.000000 0.000000
+vt  0.687500 1.000000 0.000000
+vt  0.718750 1.000000 0.000000
+vt  0.750000 1.000000 0.000000
+vt  0.781250 1.000000 0.000000
+vt  0.812500 1.000000 0.000000
+vt  0.843750 1.000000 0.000000
+vt  0.875000 1.000000 0.000000
+vt  0.906250 1.000000 0.000000
+vt  0.937500 1.000000 0.000000
+vt  0.968750 1.000000 0.000000
+vt  1.000000 1.000000 0.000000
+vt  0.000000 0.937500 0.000000
+vt  0.031250 0.937500 0.000000
+vt  0.062500 0.937500 0.000000
+vt  0.093750 0.937500 0.000000
+vt  0.125000 0.937500 0.000000
+vt  0.156250 0.937500 0.000000
+vt  0.187500 0.937500 0.000000
+vt  0.218750 0.937500 0.000000
+vt  0.250000 0.937500 0.000000
+vt  0.281250 0.937500 0.000000
+vt  0.312500 0.937500 0.000000
+vt  0.343750 0.937500 0.000000
+vt  0.375000 0.937500 0.000000
+vt  0.406250 0.937500 0.000000
+vt  0.437500 0.937500 0.000000
+vt  0.468750 0.937500 0.000000
+vt  0.500000 0.937500 0.000000
+vt  0.531250 0.937500 0.000000
+vt  0.562500 0.937500 0.000000
+vt  0.593750 0.937500 0.000000
+vt  0.625000 0.937500 0.000000
+vt  0.656250 0.937500 0.000000
+vt  0.687500 0.937500 0.000000
+vt  0.718750 0.937500 0.000000
+vt  0.750000 0.937500 0.000000
+vt  0.781250 0.937500 0.000000
+vt  0.812500 0.937500 0.000000
+vt  0.843750 0.937500 0.000000
+vt  0.875000 0.937500 0.000000
+vt  0.906250 0.937500 0.000000
+vt  0.937500 0.937500 0.000000
+vt  0.968750 0.937500 0.000000
+vt  1.000000 0.937500 0.000000
+vt  0.000000 0.875000 0.000000
+vt  0.031250 0.875000 0.000000
+vt  0.062500 0.875000 0.000000
+vt  0.093750 0.875000 0.000000
+vt  0.125000 0.875000 0.000000
+vt  0.156250 0.875000 0.000000
+vt  0.187500 0.875000 0.000000
+vt  0.218750 0.875000 0.000000
+vt  0.250000 0.875000 0.000000
+vt  0.281250 0.875000 0.000000
+vt  0.312500 0.875000 0.000000
+vt  0.343750 0.875000 0.000000
+vt  0.375000 0.875000 0.000000
+vt  0.406250 0.875000 0.000000
+vt  0.437500 0.875000 0.000000
+vt  0.468750 0.875000 0.000000
+vt  0.500000 0.875000 0.000000
+vt  0.531250 0.875000 0.000000
+vt  0.562500 0.875000 0.000000
+vt  0.593750 0.875000 0.000000
+vt  0.625000 0.875000 0.000000
+vt  0.656250 0.875000 0.000000
+vt  0.687500 0.875000 0.000000
+vt  0.718750 0.875000 0.000000
+vt  0.750000 0.875000 0.000000
+vt  0.781250 0.875000 0.000000
+vt  0.812500 0.875000 0.000000
+vt  0.843750 0.875000 0.000000
+vt  0.875000 0.875000 0.000000
+vt  0.906250 0.875000 0.000000
+vt  0.937500 0.875000 0.000000
+vt  0.968750 0.875000 0.000000
+vt  1.000000 0.875000 0.000000
+vt  0.000000 0.812500 0.000000
+vt  0.031250 0.812500 0.000000
+vt  0.062500 0.812500 0.000000
+vt  0.093750 0.812500 0.000000
+vt  0.125000 0.812500 0.000000
+vt  0.156250 0.812500 0.000000
+vt  0.187500 0.812500 0.000000
+vt  0.218750 0.812500 0.000000
+vt  0.250000 0.812500 0.000000
+vt  0.281250 0.812500 0.000000
+vt  0.312500 0.812500 0.000000
+vt  0.343750 0.812500 0.000000
+vt  0.375000 0.812500 0.000000
+vt  0.406250 0.812500 0.000000
+vt  0.437500 0.812500 0.000000
+vt  0.468750 0.812500 0.000000
+vt  0.500000 0.812500 0.000000
+vt  0.531250 0.812500 0.000000
+vt  0.562500 0.812500 0.000000
+vt  0.593750 0.812500 0.000000
+vt  0.625000 0.812500 0.000000
+vt  0.656250 0.812500 0.000000
+vt  0.687500 0.812500 0.000000
+vt  0.718750 0.812500 0.000000
+vt  0.750000 0.812500 0.000000
+vt  0.781250 0.812500 0.000000
+vt  0.812500 0.812500 0.000000
+vt  0.843750 0.812500 0.000000
+vt  0.875000 0.812500 0.000000
+vt  0.906250 0.812500 0.000000
+vt  0.937500 0.812500 0.000000
+vt  0.968750 0.812500 0.000000
+vt  1.000000 0.812500 0.000000
+vt  0.000000 0.750000 0.000000
+vt  0.031250 0.750000 0.000000
+vt  0.062500 0.750000 0.000000
+vt  0.093750 0.750000 0.000000
+vt  0.125000 0.750000 0.000000
+vt  0.156250 0.750000 0.000000
+vt  0.187500 0.750000 0.000000
+vt  0.218750 0.750000 0.000000
+vt  0.250000 0.750000 0.000000
+vt  0.281250 0.750000 0.000000
+vt  0.312500 0.750000 0.000000
+vt  0.343750 0.750000 0.000000
+vt  0.375000 0.750000 0.000000
+vt  0.406250 0.750000 0.000000
+vt  0.437500 0.750000 0.000000
+vt  0.468750 0.750000 0.000000
+vt  0.500000 0.750000 0.000000
+vt  0.531250 0.750000 0.000000
+vt  0.562500 0.750000 0.000000
+vt  0.593750 0.750000 0.000000
+vt  0.625000 0.750000 0.000000
+vt  0.656250 0.750000 0.000000
+vt  0.687500 0.750000 0.000000
+vt  0.718750 0.750000 0.000000
+vt  0.750000 0.750000 0.000000
+vt  0.781250 0.750000 0.000000
+vt  0.812500 0.750000 0.000000
+vt  0.843750 0.750000 0.000000
+vt  0.875000 0.750000 0.000000
+vt  0.906250 0.750000 0.000000
+vt  0.937500 0.750000 0.000000
+vt  0.968750 0.750000 0.000000
+vt  1.000000 0.750000 0.000000
+vt  0.000000 0.687500 0.000000
+vt  0.031250 0.687500 0.000000
+vt  0.062500 0.687500 0.000000
+vt  0.093750 0.687500 0.000000
+vt  0.125000 0.687500 0.000000
+vt  0.156250 0.687500 0.000000
+vt  0.187500 0.687500 0.000000
+vt  0.218750 0.687500 0.000000
+vt  0.250000 0.687500 0.000000
+vt  0.281250 0.687500 0.000000
+vt  0.312500 0.687500 0.000000
+vt  0.343750 0.687500 0.000000
+vt  0.375000 0.687500 0.000000
+vt  0.406250 0.687500 0.000000
+vt  0.437500 0.687500 0.000000
+vt  0.468750 0.687500 0.000000
+vt  0.500000 0.687500 0.000000
+vt  0.531250 0.687500 0.000000
+vt  0.562500 0.687500 0.000000
+vt  0.593750 0.687500 0.000000
+vt  0.625000 0.687500 0.000000
+vt  0.656250 0.687500 0.000000
+vt  0.687500 0.687500 0.000000
+vt  0.718750 0.687500 0.000000
+vt  0.750000 0.687500 0.000000
+vt  0.781250 0.687500 0.000000
+vt  0.812500 0.687500 0.000000
+vt  0.843750 0.687500 0.000000
+vt  0.875000 0.687500 0.000000
+vt  0.906250 0.687500 0.000000
+vt  0.937500 0.687500 0.000000
+vt  0.968750 0.687500 0.000000
+vt  1.000000 0.687500 0.000000
+vt  0.000000 0.625000 0.000000
+vt  0.031250 0.625000 0.000000
+vt  0.062500 0.625000 0.000000
+vt  0.093750 0.625000 0.000000
+vt  0.125000 0.625000 0.000000
+vt  0.156250 0.625000 0.000000
+vt  0.187500 0.625000 0.000000
+vt  0.218750 0.625000 0.000000
+vt  0.250000 0.625000 0.000000
+vt  0.281250 0.625000 0.000000
+vt  0.312500 0.625000 0.000000
+vt  0.343750 0.625000 0.000000
+vt  0.375000 0.625000 0.000000
+vt  0.406250 0.625000 0.000000
+vt  0.437500 0.625000 0.000000
+vt  0.468750 0.625000 0.000000
+vt  0.500000 0.625000 0.000000
+vt  0.531250 0.625000 0.000000
+vt  0.562500 0.625000 0.000000
+vt  0.593750 0.625000 0.000000
+vt  0.625000 0.625000 0.000000
+vt  0.656250 0.625000 0.000000
+vt  0.687500 0.625000 0.000000
+vt  0.718750 0.625000 0.000000
+vt  0.750000 0.625000 0.000000
+vt  0.781250 0.625000 0.000000
+vt  0.812500 0.625000 0.000000
+vt  0.843750 0.625000 0.000000
+vt  0.875000 0.625000 0.000000
+vt  0.906250 0.625000 0.000000
+vt  0.937500 0.625000 0.000000
+vt  0.968750 0.625000 0.000000
+vt  1.000000 0.625000 0.000000
+vt  0.000000 0.562500 0.000000
+vt  0.031250 0.562500 0.000000
+vt  0.062500 0.562500 0.000000
+vt  0.093750 0.562500 0.000000
+vt  0.125000 0.562500 0.000000
+vt  0.156250 0.562500 0.000000
+vt  0.187500 0.562500 0.000000
+vt  0.218750 0.562500 0.000000
+vt  0.250000 0.562500 0.000000
+vt  0.281250 0.562500 0.000000
+vt  0.312500 0.562500 0.000000
+vt  0.343750 0.562500 0.000000
+vt  0.375000 0.562500 0.000000
+vt  0.406250 0.562500 0.000000
+vt  0.437500 0.562500 0.000000
+vt  0.468750 0.562500 0.000000
+vt  0.500000 0.562500 0.000000
+vt  0.531250 0.562500 0.000000
+vt  0.562500 0.562500 0.000000
+vt  0.593750 0.562500 0.000000
+vt  0.625000 0.562500 0.000000
+vt  0.656250 0.562500 0.000000
+vt  0.687500 0.562500 0.000000
+vt  0.718750 0.562500 0.000000
+vt  0.750000 0.562500 0.000000
+vt  0.781250 0.562500 0.000000
+vt  0.812500 0.562500 0.000000
+vt  0.843750 0.562500 0.000000
+vt  0.875000 0.562500 0.000000
+vt  0.906250 0.562500 0.000000
+vt  0.937500 0.562500 0.000000
+vt  0.968750 0.562500 0.000000
+vt  1.000000 0.562500 0.000000
+vt  0.000000 0.500000 0.000000
+vt  0.031250 0.500000 0.000000
+vt  0.062500 0.500000 0.000000
+vt  0.093750 0.500000 0.000000
+vt  0.125000 0.500000 0.000000
+vt  0.156250 0.500000 0.000000
+vt  0.187500 0.500000 0.000000
+vt  0.218750 0.500000 0.000000
+vt  0.250000 0.500000 0.000000
+vt  0.281250 0.500000 0.000000
+vt  0.312500 0.500000 0.000000
+vt  0.343750 0.500000 0.000000
+vt  0.375000 0.500000 0.000000
+vt  0.406250 0.500000 0.000000
+vt  0.437500 0.500000 0.000000
+vt  0.468750 0.500000 0.000000
+vt  0.500000 0.500000 0.000000
+vt  0.531250 0.500000 0.000000
+vt  0.562500 0.500000 0.000000
+vt  0.593750 0.500000 0.000000
+vt  0.625000 0.500000 0.000000
+vt  0.656250 0.500000 0.000000
+vt  0.687500 0.500000 0.000000
+vt  0.718750 0.500000 0.000000
+vt  0.750000 0.500000 0.000000
+vt  0.781250 0.500000 0.000000
+vt  0.812500 0.500000 0.000000
+vt  0.843750 0.500000 0.000000
+vt  0.875000 0.500000 0.000000
+vt  0.906250 0.500000 0.000000
+vt  0.937500 0.500000 0.000000
+vt  0.968750 0.500000 0.000000
+vt  1.000000 0.500000 0.000000
+vt  0.000000 0.437500 0.000000
+vt  0.031250 0.437500 0.000000
+vt  0.062500 0.437500 0.000000
+vt  0.093750 0.437500 0.000000
+vt  0.125000 0.437500 0.000000
+vt  0.156250 0.437500 0.000000
+vt  0.187500 0.437500 0.000000
+vt  0.218750 0.437500 0.000000
+vt  0.250000 0.437500 0.000000
+vt  0.281250 0.437500 0.000000
+vt  0.312500 0.437500 0.000000
+vt  0.343750 0.437500 0.000000
+vt  0.375000 0.437500 0.000000
+vt  0.406250 0.437500 0.000000
+vt  0.437500 0.437500 0.000000
+vt  0.468750 0.437500 0.000000
+vt  0.500000 0.437500 0.000000
+vt  0.531250 0.437500 0.000000
+vt  0.562500 0.437500 0.000000
+vt  0.593750 0.437500 0.000000
+vt  0.625000 0.437500 0.000000
+vt  0.656250 0.437500 0.000000
+vt  0.687500 0.437500 0.000000
+vt  0.718750 0.437500 0.000000
+vt  0.750000 0.437500 0.000000
+vt  0.781250 0.437500 0.000000
+vt  0.812500 0.437500 0.000000
+vt  0.843750 0.437500 0.000000
+vt  0.875000 0.437500 0.000000
+vt  0.906250 0.437500 0.000000
+vt  0.937500 0.437500 0.000000
+vt  0.968750 0.437500 0.000000
+vt  1.000000 0.437500 0.000000
+vt  0.000000 0.375000 0.000000
+vt  0.031250 0.375000 0.000000
+vt  0.062500 0.375000 0.000000
+vt  0.093750 0.375000 0.000000
+vt  0.125000 0.375000 0.000000
+vt  0.156250 0.375000 0.000000
+vt  0.187500 0.375000 0.000000
+vt  0.218750 0.375000 0.000000
+vt  0.250000 0.375000 0.000000
+vt  0.281250 0.375000 0.000000
+vt  0.312500 0.375000 0.000000
+vt  0.343750 0.375000 0.000000
+vt  0.375000 0.375000 0.000000
+vt  0.406250 0.375000 0.000000
+vt  0.437500 0.375000 0.000000
+vt  0.468750 0.375000 0.000000
+vt  0.500000 0.375000 0.000000
+vt  0.531250 0.375000 0.000000
+vt  0.562500 0.375000 0.000000
+vt  0.593750 0.375000 0.000000
+vt  0.625000 0.375000 0.000000
+vt  0.656250 0.375000 0.000000
+vt  0.687500 0.375000 0.000000
+vt  0.718750 0.375000 0.000000
+vt  0.750000 0.375000 0.000000
+vt  0.781250 0.375000 0.000000
+vt  0.812500 0.375000 0.000000
+vt  0.843750 0.375000 0.000000
+vt  0.875000 0.375000 0.000000
+vt  0.906250 0.375000 0.000000
+vt  0.937500 0.375000 0.000000
+vt  0.968750 0.375000 0.000000
+vt  1.000000 0.375000 0.000000
+vt  0.000000 0.312500 0.000000
+vt  0.031250 0.312500 0.000000
+vt  0.062500 0.312500 0.000000
+vt  0.093750 0.312500 0.000000
+vt  0.125000 0.312500 0.000000
+vt  0.156250 0.312500 0.000000
+vt  0.187500 0.312500 0.000000
+vt  0.218750 0.312500 0.000000
+vt  0.250000 0.312500 0.000000
+vt  0.281250 0.312500 0.000000
+vt  0.312500 0.312500 0.000000
+vt  0.343750 0.312500 0.000000
+vt  0.375000 0.312500 0.000000
+vt  0.406250 0.312500 0.000000
+vt  0.437500 0.312500 0.000000
+vt  0.468750 0.312500 0.000000
+vt  0.500000 0.312500 0.000000
+vt  0.531250 0.312500 0.000000
+vt  0.562500 0.312500 0.000000
+vt  0.593750 0.312500 0.000000
+vt  0.625000 0.312500 0.000000
+vt  0.656250 0.312500 0.000000
+vt  0.687500 0.312500 0.000000
+vt  0.718750 0.312500 0.000000
+vt  0.750000 0.312500 0.000000
+vt  0.781250 0.312500 0.000000
+vt  0.812500 0.312500 0.000000
+vt  0.843750 0.312500 0.000000
+vt  0.875000 0.312500 0.000000
+vt  0.906250 0.312500 0.000000
+vt  0.937500 0.312500 0.000000
+vt  0.968750 0.312500 0.000000
+vt  1.000000 0.312500 0.000000
+vt  0.000000 0.250000 0.000000
+vt  0.031250 0.250000 0.000000
+vt  0.062500 0.250000 0.000000
+vt  0.093750 0.250000 0.000000
+vt  0.125000 0.250000 0.000000
+vt  0.156250 0.250000 0.000000
+vt  0.187500 0.250000 0.000000
+vt  0.218750 0.250000 0.000000
+vt  0.250000 0.250000 0.000000
+vt  0.281250 0.250000 0.000000
+vt  0.312500 0.250000 0.000000
+vt  0.343750 0.250000 0.000000
+vt  0.375000 0.250000 0.000000
+vt  0.406250 0.250000 0.000000
+vt  0.437500 0.250000 0.000000
+vt  0.468750 0.250000 0.000000
+vt  0.500000 0.250000 0.000000
+vt  0.531250 0.250000 0.000000
+vt  0.562500 0.250000 0.000000
+vt  0.593750 0.250000 0.000000
+vt  0.625000 0.250000 0.000000
+vt  0.656250 0.250000 0.000000
+vt  0.687500 0.250000 0.000000
+vt  0.718750 0.250000 0.000000
+vt  0.750000 0.250000 0.000000
+vt  0.781250 0.250000 0.000000
+vt  0.812500 0.250000 0.000000
+vt  0.843750 0.250000 0.000000
+vt  0.875000 0.250000 0.000000
+vt  0.906250 0.250000 0.000000
+vt  0.937500 0.250000 0.000000
+vt  0.968750 0.250000 0.000000
+vt  1.000000 0.250000 0.000000
+vt  0.000000 0.187500 0.000000
+vt  0.031250 0.187500 0.000000
+vt  0.062500 0.187500 0.000000
+vt  0.093750 0.187500 0.000000
+vt  0.125000 0.187500 0.000000
+vt  0.156250 0.187500 0.000000
+vt  0.187500 0.187500 0.000000
+vt  0.218750 0.187500 0.000000
+vt  0.250000 0.187500 0.000000
+vt  0.281250 0.187500 0.000000
+vt  0.312500 0.187500 0.000000
+vt  0.343750 0.187500 0.000000
+vt  0.375000 0.187500 0.000000
+vt  0.406250 0.187500 0.000000
+vt  0.437500 0.187500 0.000000
+vt  0.468750 0.187500 0.000000
+vt  0.500000 0.187500 0.000000
+vt  0.531250 0.187500 0.000000
+vt  0.562500 0.187500 0.000000
+vt  0.593750 0.187500 0.000000
+vt  0.625000 0.187500 0.000000
+vt  0.656250 0.187500 0.000000
+vt  0.687500 0.187500 0.000000
+vt  0.718750 0.187500 0.000000
+vt  0.750000 0.187500 0.000000
+vt  0.781250 0.187500 0.000000
+vt  0.812500 0.187500 0.000000
+vt  0.843750 0.187500 0.000000
+vt  0.875000 0.187500 0.000000
+vt  0.906250 0.187500 0.000000
+vt  0.937500 0.187500 0.000000
+vt  0.968750 0.187500 0.000000
+vt  1.000000 0.187500 0.000000
+vt  0.000000 0.125000 0.000000
+vt  0.031250 0.125000 0.000000
+vt  0.062500 0.125000 0.000000
+vt  0.093750 0.125000 0.000000
+vt  0.125000 0.125000 0.000000
+vt  0.156250 0.125000 0.000000
+vt  0.187500 0.125000 0.000000
+vt  0.218750 0.125000 0.000000
+vt  0.250000 0.125000 0.000000
+vt  0.281250 0.125000 0.000000
+vt  0.312500 0.125000 0.000000
+vt  0.343750 0.125000 0.000000
+vt  0.375000 0.125000 0.000000
+vt  0.406250 0.125000 0.000000
+vt  0.437500 0.125000 0.000000
+vt  0.468750 0.125000 0.000000
+vt  0.500000 0.125000 0.000000
+vt  0.531250 0.125000 0.000000
+vt  0.562500 0.125000 0.000000
+vt  0.593750 0.125000 0.000000
+vt  0.625000 0.125000 0.000000
+vt  0.656250 0.125000 0.000000
+vt  0.687500 0.125000 0.000000
+vt  0.718750 0.125000 0.000000
+vt  0.750000 0.125000 0.000000
+vt  0.781250 0.125000 0.000000
+vt  0.812500 0.125000 0.000000
+vt  0.843750 0.125000 0.000000
+vt  0.875000 0.125000 0.000000
+vt  0.906250 0.125000 0.000000
+vt  0.937500 0.125000 0.000000
+vt  0.968750 0.125000 0.000000
+vt  1.000000 0.125000 0.000000
+vt  0.000000 0.062500 0.000000
+vt  0.031250 0.062500 0.000000
+vt  0.062500 0.062500 0.000000
+vt  0.093750 0.062500 0.000000
+vt  0.125000 0.062500 0.000000
+vt  0.156250 0.062500 0.000000
+vt  0.187500 0.062500 0.000000
+vt  0.218750 0.062500 0.000000
+vt  0.250000 0.062500 0.000000
+vt  0.281250 0.062500 0.000000
+vt  0.312500 0.062500 0.000000
+vt  0.343750 0.062500 0.000000
+vt  0.375000 0.062500 0.000000
+vt  0.406250 0.062500 0.000000
+vt  0.437500 0.062500 0.000000
+vt  0.468750 0.062500 0.000000
+vt  0.500000 0.062500 0.000000
+vt  0.531250 0.062500 0.000000
+vt  0.562500 0.062500 0.000000
+vt  0.593750 0.062500 0.000000
+vt  0.625000 0.062500 0.000000
+vt  0.656250 0.062500 0.000000
+vt  0.687500 0.062500 0.000000
+vt  0.718750 0.062500 0.000000
+vt  0.750000 0.062500 0.000000
+vt  0.781250 0.062500 0.000000
+vt  0.812500 0.062500 0.000000
+vt  0.843750 0.062500 0.000000
+vt  0.875000 0.062500 0.000000
+vt  0.906250 0.062500 0.000000
+vt  0.937500 0.062500 0.000000
+vt  0.968750 0.062500 0.000000
+vt  1.000000 0.062500 0.000000
+vt  0.000000 -0.000000 0.000000
+vt  0.031250 -0.000000 0.000000
+vt  0.062500 -0.000000 0.000000
+vt  0.093750 -0.000000 0.000000
+vt  0.125000 -0.000000 0.000000
+vt  0.156250 -0.000000 0.000000
+vt  0.187500 -0.000000 0.000000
+vt  0.218750 -0.000000 0.000000
+vt  0.250000 -0.000000 0.000000
+vt  0.281250 -0.000000 0.000000
+vt  0.312500 -0.000000 0.000000
+vt  0.343750 -0.000000 0.000000
+vt  0.375000 -0.000000 0.000000
+vt  0.406250 -0.000000 0.000000
+vt  0.437500 -0.000000 0.000000
+vt  0.468750 -0.000000 0.000000
+vt  0.500000 -0.000000 0.000000
+vt  0.531250 -0.000000 0.000000
+vt  0.562500 -0.000000 0.000000
+vt  0.593750 -0.000000 0.000000
+vt  0.625000 -0.000000 0.000000
+vt  0.656250 -0.000000 0.000000
+vt  0.687500 -0.000000 0.000000
+vt  0.718750 -0.000000 0.000000
+vt  0.750000 -0.000000 0.000000
+vt  0.781250 -0.000000 0.000000
+vt  0.812500 -0.000000 0.000000
+vt  0.843750 -0.000000 0.000000
+vt  0.875000 -0.000000 0.000000
+vt  0.906250 -0.000000 0.000000
+vt  0.937500 -0.000000 0.000000
+vt  0.968750 -0.000000 0.000000
+vt  1.000000 -0.000000 0.000000
+# 561 texture vertices
+
+vn  0.000000 1.000000 -0.000000
+vn  -0.005744 0.976740 -0.214348
+vn  -0.047451 0.976740 -0.209109
+vn  -0.087334 0.976740 -0.195834
+vn  -0.123861 0.976740 -0.175033
+vn  -0.155629 0.976740 -0.147506
+vn  -0.181415 0.976740 -0.114310
+vn  -0.200230 0.976740 -0.076721
+vn  -0.211350 0.976740 -0.036184
+vn  -0.214348 0.976740 0.005744
+vn  -0.209109 0.976740 0.047451
+vn  -0.195834 0.976740 0.087334
+vn  -0.175033 0.976740 0.123861
+vn  -0.147506 0.976740 0.155629
+vn  -0.114310 0.976740 0.181415
+vn  -0.076721 0.976740 0.200230
+vn  -0.036184 0.976740 0.211350
+vn  0.005744 0.976740 0.214348
+vn  0.047451 0.976740 0.209109
+vn  0.087334 0.976740 0.195834
+vn  0.123862 0.976740 0.175033
+vn  0.155629 0.976740 0.147505
+vn  0.181415 0.976740 0.114309
+vn  0.200230 0.976740 0.076721
+vn  0.211350 0.976740 0.036184
+vn  0.214348 0.976740 -0.005744
+vn  0.209109 0.976740 -0.047451
+vn  0.195834 0.976740 -0.087334
+vn  0.175033 0.976740 -0.123862
+vn  0.147505 0.976740 -0.155629
+vn  0.114309 0.976740 -0.181415
+vn  0.076721 0.976740 -0.200230
+vn  0.036184 0.976740 -0.211350
+vn  -0.002983 0.923888 -0.382651
+vn  -0.077577 0.923888 -0.374717
+vn  -0.149190 0.923888 -0.352382
+vn  -0.215070 0.923888 -0.316506
+vn  -0.272685 0.923888 -0.268466
+vn  -0.319820 0.923888 -0.210109
+vn  -0.354665 0.923888 -0.143678
+vn  -0.375881 0.923888 -0.071726
+vn  -0.382651 0.923888 0.002983
+vn  -0.374717 0.923888 0.077578
+vn  -0.352382 0.923888 0.149191
+vn  -0.316506 0.923888 0.215070
+vn  -0.268466 0.923888 0.272685
+vn  -0.210109 0.923888 0.319821
+vn  -0.143678 0.923888 0.354666
+vn  -0.071725 0.923888 0.375881
+vn  0.002984 0.923888 0.382651
+vn  0.077578 0.923888 0.374717
+vn  0.149191 0.923888 0.352382
+vn  0.215071 0.923888 0.316505
+vn  0.272685 0.923888 0.268466
+vn  0.319821 0.923888 0.210109
+vn  0.354666 0.923888 0.143678
+vn  0.375881 0.923888 0.071725
+vn  0.382651 0.923888 -0.002984
+vn  0.374717 0.923888 -0.077578
+vn  0.352382 0.923888 -0.149191
+vn  0.316505 0.923888 -0.215071
+vn  0.268465 0.923888 -0.272685
+vn  0.210109 0.923888 -0.319821
+vn  0.143678 0.923888 -0.354666
+vn  0.071725 0.923888 -0.375881
+vn  -0.002681 0.831490 -0.555533
+vn  -0.111008 0.831490 -0.544335
+vn  -0.215070 0.831490 -0.512219
+vn  -0.310866 0.831490 -0.460419
+vn  -0.394716 0.831490 -0.390925
+vn  -0.463398 0.831490 -0.306408
+vn  -0.514271 0.831490 -0.210116
+vn  -0.545381 0.831490 -0.105750
+vn  -0.555533 0.831490 0.002681
+vn  -0.544335 0.831490 0.111008
+vn  -0.512219 0.831490 0.215070
+vn  -0.460419 0.831490 0.310867
+vn  -0.390925 0.831490 0.394717
+vn  -0.306408 0.831490 0.463398
+vn  -0.210116 0.831490 0.514271
+vn  -0.105749 0.831490 0.545381
+vn  0.002681 0.831490 0.555533
+vn  0.111009 0.831490 0.544335
+vn  0.215070 0.831490 0.512219
+vn  0.310867 0.831490 0.460419
+vn  0.394717 0.831490 0.390925
+vn  0.463398 0.831490 0.306408
+vn  0.514271 0.831490 0.210116
+vn  0.545381 0.831490 0.105749
+vn  0.555533 0.831490 -0.002681
+vn  0.544335 0.831490 -0.111009
+vn  0.512219 0.831490 -0.215071
+vn  0.460419 0.831490 -0.310867
+vn  0.390925 0.831490 -0.394717
+vn  0.306408 0.831490 -0.463398
+vn  0.210115 0.831490 -0.514271
+vn  0.105749 0.831490 -0.545381
+vn  -0.002276 0.707138 -0.707072
+vn  -0.140175 0.707138 -0.693042
+vn  -0.272687 0.707138 -0.652379
+vn  -0.394720 0.707138 -0.586645
+vn  -0.501585 0.707138 -0.498367
+vn  -0.589173 0.707138 -0.390936
+vn  -0.654120 0.707138 -0.268482
+vn  -0.693930 0.707138 -0.135711
+vn  -0.707072 0.707138 0.002276
+vn  -0.693042 0.707138 0.140175
+vn  -0.652379 0.707138 0.272687
+vn  -0.586645 0.707138 0.394721
+vn  -0.498366 0.707138 0.501585
+vn  -0.390936 0.707138 0.589174
+vn  -0.268482 0.707138 0.654121
+vn  -0.135711 0.707138 0.693930
+vn  0.002276 0.707138 0.707072
+vn  0.140176 0.707138 0.693042
+vn  0.272688 0.707138 0.652378
+vn  0.394721 0.707138 0.586644
+vn  0.501585 0.707138 0.498366
+vn  0.589174 0.707138 0.390935
+vn  0.654121 0.707138 0.268482
+vn  0.693930 0.707138 0.135710
+vn  0.707072 0.707138 -0.002277
+vn  0.693042 0.707138 -0.140176
+vn  0.652378 0.707138 -0.272688
+vn  0.586644 0.707138 -0.394721
+vn  0.498366 0.707138 -0.501585
+vn  0.390935 0.707138 -0.589174
+vn  0.268481 0.707138 -0.654121
+vn  0.135710 0.707138 -0.693930
+vn  -0.001785 0.555605 -0.831445
+vn  -0.163957 0.555605 -0.815120
+vn  -0.319829 0.555605 -0.767472
+vn  -0.463410 0.555605 -0.690329
+vn  -0.589182 0.555605 -0.586658
+vn  -0.692312 0.555605 -0.460442
+vn  -0.768838 0.555605 -0.316531
+vn  -0.815817 0.555605 -0.160456
+vn  -0.831445 0.555605 0.001785
+vn  -0.815120 0.555605 0.163957
+vn  -0.767471 0.555605 0.319829
+vn  -0.690329 0.555605 0.463410
+vn  -0.586658 0.555605 0.589182
+vn  -0.460441 0.555605 0.692313
+vn  -0.316531 0.555605 0.768838
+vn  -0.160456 0.555605 0.815817
+vn  0.001785 0.555605 0.831445
+vn  0.163958 0.555605 0.815120
+vn  0.319830 0.555605 0.767471
+vn  0.463410 0.555605 0.690329
+vn  0.589183 0.555605 0.586657
+vn  0.692313 0.555605 0.460441
+vn  0.768838 0.555605 0.316530
+vn  0.815817 0.555605 0.160455
+vn  0.831445 0.555605 -0.001786
+vn  0.815120 0.555605 -0.163958
+vn  0.767471 0.555605 -0.319830
+vn  0.690329 0.555605 -0.463411
+vn  0.586657 0.555605 -0.589183
+vn  0.460441 0.555605 -0.692313
+vn  0.316530 0.555605 -0.768838
+vn  0.160455 0.555605 -0.815817
+vn  -0.001228 0.382713 -0.923866
+vn  -0.181441 0.382713 -0.905875
+vn  -0.354682 0.382713 -0.853072
+vn  -0.514293 0.382713 -0.767485
+vn  -0.654140 0.382713 -0.652404
+vn  -0.768849 0.382713 -0.512252
+vn  -0.854011 0.382713 -0.352414
+vn  -0.906354 0.382713 -0.179033
+vn  -0.923866 0.382713 0.001228
+vn  -0.905875 0.382713 0.181441
+vn  -0.853071 0.382713 0.354683
+vn  -0.767485 0.382713 0.514294
+vn  -0.652404 0.382713 0.654140
+vn  -0.512252 0.382713 0.768849
+vn  -0.352414 0.382713 0.854011
+vn  -0.179033 0.382713 0.906354
+vn  0.001228 0.382713 0.923866
+vn  0.181442 0.382713 0.905875
+vn  0.354683 0.382713 0.853071
+vn  0.514294 0.382713 0.767484
+vn  0.654141 0.382713 0.652403
+vn  0.768849 0.382713 0.512251
+vn  0.854011 0.382713 0.352413
+vn  0.906354 0.382713 0.179032
+vn  0.923866 0.382713 -0.001229
+vn  0.905875 0.382713 -0.181443
+vn  0.853071 0.382713 -0.354684
+vn  0.767484 0.382713 -0.514295
+vn  0.652403 0.382713 -0.654141
+vn  0.512251 0.382713 -0.768850
+vn  0.352413 0.382713 -0.854012
+vn  0.179032 0.382713 -0.906354
+vn  -0.000626 0.195108 -0.980782
+vn  -0.191954 0.195108 -0.961814
+vn  -0.375906 0.195108 -0.905885
+vn  -0.545413 0.195108 -0.815143
+vn  -0.693959 0.195108 -0.693075
+vn  -0.815837 0.195108 -0.544373
+vn  -0.906363 0.195108 -0.374751
+vn  -0.962058 0.195108 -0.190728
+vn  -0.980782 0.195108 0.000625
+vn  -0.961814 0.195108 0.191954
+vn  -0.905885 0.195108 0.375907
+vn  -0.815143 0.195108 0.545413
+vn  -0.693075 0.195108 0.693960
+vn  -0.544373 0.195108 0.815838
+vn  -0.374751 0.195108 0.906364
+vn  -0.190727 0.195108 0.962058
+vn  0.000626 0.195108 0.980782
+vn  0.191955 0.195108 0.961814
+vn  0.375907 0.195108 0.905884
+vn  0.545414 0.195108 0.815142
+vn  0.693960 0.195108 0.693075
+vn  0.815838 0.195108 0.544372
+vn  0.906364 0.195108 0.374750
+vn  0.962058 0.195108 0.190727
+vn  0.980782 0.195108 -0.000627
+vn  0.961814 0.195108 -0.191956
+vn  0.905884 0.195108 -0.375908
+vn  0.815142 0.195108 -0.545414
+vn  0.693074 0.195108 -0.693961
+vn  0.544372 0.195108 -0.815839
+vn  0.374750 0.195108 -0.906364
+vn  0.190726 0.195108 -0.962058
+vn  -0.000000 -0.000000 -1.000000
+vn  -0.195090 -0.000000 -0.980785
+vn  -0.382683 0.000000 -0.923880
+vn  -0.555570 0.000000 -0.831470
+vn  -0.707107 0.000000 -0.707107
+vn  -0.831470 0.000000 -0.555570
+vn  -0.923880 0.000000 -0.382683
+vn  -0.980785 0.000000 -0.195090
+vn  -1.000000 0.000000 0.000000
+vn  -0.980785 -0.000000 0.195091
+vn  -0.923879 0.000000 0.382684
+vn  -0.831469 0.000000 0.555571
+vn  -0.707106 0.000000 0.707107
+vn  -0.555570 0.000000 0.831470
+vn  -0.382683 -0.000000 0.923880
+vn  -0.195089 0.000000 0.980785
+vn  0.000001 -0.000000 1.000000
+vn  0.195091 0.000000 0.980785
+vn  0.382685 0.000000 0.923879
+vn  0.555571 0.000000 0.831469
+vn  0.707108 0.000000 0.707106
+vn  0.831470 0.000000 0.555569
+vn  0.923880 0.000000 0.382682
+vn  0.980786 0.000000 0.195089
+vn  1.000000 0.000000 -0.000002
+vn  0.980785 -0.000000 -0.195092
+vn  0.923879 0.000000 -0.382685
+vn  0.831469 0.000000 -0.555572
+vn  0.707106 0.000000 -0.707108
+vn  0.555569 0.000000 -0.831471
+vn  0.382681 0.000000 -0.923880
+vn  0.195089 0.000000 -0.980786
+vn  0.000624 -0.195108 -0.980782
+vn  -0.190728 -0.195108 -0.962058
+vn  -0.374751 -0.195108 -0.906363
+vn  -0.544373 -0.195107 -0.815837
+vn  -0.693075 -0.195107 -0.693959
+vn  -0.815143 -0.195108 -0.545413
+vn  -0.905885 -0.195108 -0.375906
+vn  -0.961814 -0.195107 -0.191954
+vn  -0.980782 -0.195107 -0.000625
+vn  -0.962058 -0.195107 0.190728
+vn  -0.906363 -0.195107 0.374752
+vn  -0.815837 -0.195108 0.544374
+vn  -0.693959 -0.195108 0.693076
+vn  -0.545412 -0.195107 0.815143
+vn  -0.375906 -0.195107 0.905885
+vn  -0.191953 -0.195108 0.961814
+vn  -0.000624 -0.195107 0.980782
+vn  0.190729 -0.195107 0.962058
+vn  0.374753 -0.195107 0.906363
+vn  0.544374 -0.195107 0.815837
+vn  0.693076 -0.195108 0.693959
+vn  0.815144 -0.195108 0.545412
+vn  0.905885 -0.195108 0.375905
+vn  0.961815 -0.195108 0.191953
+vn  0.980782 -0.195108 0.000623
+vn  0.962058 -0.195107 -0.190730
+vn  0.906363 -0.195108 -0.374753
+vn  0.815836 -0.195107 -0.544375
+vn  0.693958 -0.195107 -0.693077
+vn  0.545411 -0.195108 -0.815144
+vn  0.375904 -0.195107 -0.905886
+vn  0.191953 -0.195107 -0.961815
+vn  0.001227 -0.382713 -0.923866
+vn  -0.179034 -0.382713 -0.906354
+vn  -0.352414 -0.382713 -0.854011
+vn  -0.512252 -0.382713 -0.768849
+vn  -0.652404 -0.382713 -0.654140
+vn  -0.767485 -0.382713 -0.514293
+vn  -0.853072 -0.382713 -0.354682
+vn  -0.905875 -0.382713 -0.181441
+vn  -0.923866 -0.382713 -0.001227
+vn  -0.906354 -0.382713 0.179034
+vn  -0.854011 -0.382713 0.352415
+vn  -0.768848 -0.382713 0.512253
+vn  -0.654140 -0.382713 0.652405
+vn  -0.514293 -0.382713 0.767485
+vn  -0.354682 -0.382713 0.853072
+vn  -0.181440 -0.382713 0.905875
+vn  -0.001227 -0.382713 0.923866
+vn  0.179035 -0.382713 0.906354
+vn  0.352415 -0.382713 0.854011
+vn  0.512253 -0.382713 0.768848
+vn  0.652405 -0.382713 0.654139
+vn  0.767486 -0.382713 0.514292
+vn  0.853072 -0.382713 0.354681
+vn  0.905875 -0.382713 0.181440
+vn  0.923866 -0.382713 0.001226
+vn  0.906354 -0.382713 -0.179035
+vn  0.854010 -0.382713 -0.352416
+vn  0.768848 -0.382713 -0.512254
+vn  0.654139 -0.382713 -0.652406
+vn  0.514292 -0.382713 -0.767486
+vn  0.354681 -0.382713 -0.853072
+vn  0.181440 -0.382713 -0.905875
+vn  0.001784 -0.555605 -0.831445
+vn  -0.160456 -0.555605 -0.815817
+vn  -0.316531 -0.555605 -0.768838
+vn  -0.460442 -0.555605 -0.692312
+vn  -0.586658 -0.555605 -0.589182
+vn  -0.690329 -0.555605 -0.463410
+vn  -0.767472 -0.555605 -0.319829
+vn  -0.815121 -0.555605 -0.163957
+vn  -0.831445 -0.555605 -0.001784
+vn  -0.815817 -0.555605 0.160457
+vn  -0.768837 -0.555605 0.316532
+vn  -0.692312 -0.555605 0.460442
+vn  -0.589182 -0.555605 0.586659
+vn  -0.463409 -0.555605 0.690330
+vn  -0.319828 -0.555605 0.767472
+vn  -0.163956 -0.555605 0.815121
+vn  -0.001784 -0.555605 0.831445
+vn  0.160457 -0.555605 0.815817
+vn  0.316532 -0.555605 0.768837
+vn  0.460443 -0.555605 0.692312
+vn  0.586659 -0.555605 0.589181
+vn  0.690330 -0.555605 0.463409
+vn  0.767472 -0.555605 0.319828
+vn  0.815121 -0.555605 0.163956
+vn  0.831445 -0.555605 0.001783
+vn  0.815816 -0.555605 -0.160458
+vn  0.768837 -0.555605 -0.316533
+vn  0.692312 -0.555605 -0.460443
+vn  0.589181 -0.555605 -0.586659
+vn  0.463408 -0.555605 -0.690330
+vn  0.319827 -0.555605 -0.767472
+vn  0.163956 -0.555605 -0.815121
+vn  0.002275 -0.707138 -0.707072
+vn  -0.135711 -0.707138 -0.693930
+vn  -0.268483 -0.707138 -0.654120
+vn  -0.390936 -0.707138 -0.589173
+vn  -0.498367 -0.707138 -0.501585
+vn  -0.586645 -0.707138 -0.394720
+vn  -0.652379 -0.707138 -0.272687
+vn  -0.693042 -0.707138 -0.140175
+vn  -0.707072 -0.707138 -0.002275
+vn  -0.693930 -0.707138 0.135711
+vn  -0.654120 -0.707138 0.268483
+vn  -0.589173 -0.707138 0.390936
+vn  -0.501584 -0.707138 0.498367
+vn  -0.394720 -0.707138 0.586645
+vn  -0.272687 -0.707138 0.652379
+vn  -0.140174 -0.707138 0.693042
+vn  -0.002275 -0.707138 0.707072
+vn  0.135712 -0.707138 0.693930
+vn  0.268483 -0.707138 0.654120
+vn  0.390937 -0.707138 0.589173
+vn  0.498367 -0.707138 0.501584
+vn  0.586645 -0.707138 0.394719
+vn  0.652379 -0.707138 0.272686
+vn  0.693042 -0.707138 0.140174
+vn  0.707072 -0.707138 0.002274
+vn  0.693930 -0.707138 -0.135712
+vn  0.654120 -0.707138 -0.268484
+vn  0.589173 -0.707138 -0.390937
+vn  0.501584 -0.707138 -0.498367
+vn  0.394719 -0.707138 -0.586646
+vn  0.272686 -0.707138 -0.652379
+vn  0.140174 -0.707138 -0.693042
+vn  0.002680 -0.831490 -0.555533
+vn  -0.105750 -0.831490 -0.545381
+vn  -0.210117 -0.831490 -0.514271
+vn  -0.306408 -0.831490 -0.463398
+vn  -0.390925 -0.831490 -0.394716
+vn  -0.460419 -0.831490 -0.310866
+vn  -0.512219 -0.831490 -0.215070
+vn  -0.544335 -0.831490 -0.111008
+vn  -0.555533 -0.831490 -0.002680
+vn  -0.545381 -0.831490 0.105750
+vn  -0.514271 -0.831490 0.210117
+vn  -0.463398 -0.831490 0.306409
+vn  -0.394716 -0.831490 0.390926
+vn  -0.310866 -0.831490 0.460419
+vn  -0.215069 -0.831491 0.512219
+vn  -0.111008 -0.831490 0.544335
+vn  -0.002680 -0.831490 0.555533
+vn  0.105750 -0.831490 0.545381
+vn  0.210117 -0.831490 0.514271
+vn  0.306409 -0.831490 0.463397
+vn  0.390926 -0.831490 0.394716
+vn  0.460420 -0.831490 0.310866
+vn  0.512220 -0.831490 0.215069
+vn  0.544335 -0.831490 0.111007
+vn  0.555533 -0.831490 0.002680
+vn  0.545381 -0.831490 -0.105751
+vn  0.514271 -0.831490 -0.210117
+vn  0.463397 -0.831491 -0.306409
+vn  0.394716 -0.831491 -0.390926
+vn  0.310865 -0.831490 -0.460420
+vn  0.215069 -0.831490 -0.512220
+vn  0.111007 -0.831490 -0.544335
+vn  0.002983 -0.923888 -0.382651
+vn  -0.071726 -0.923888 -0.375880
+vn  -0.143678 -0.923888 -0.354665
+vn  -0.210109 -0.923888 -0.319820
+vn  -0.268466 -0.923888 -0.272685
+vn  -0.316505 -0.923888 -0.215070
+vn  -0.352382 -0.923888 -0.149190
+vn  -0.374717 -0.923888 -0.077577
+vn  -0.382651 -0.923888 -0.002983
+vn  -0.375880 -0.923888 0.071726
+vn  -0.354665 -0.923888 0.143678
+vn  -0.319820 -0.923888 0.210109
+vn  -0.272684 -0.923888 0.268466
+vn  -0.215070 -0.923888 0.316506
+vn  -0.149190 -0.923888 0.352382
+vn  -0.077577 -0.923888 0.374717
+vn  -0.002983 -0.923888 0.382651
+vn  0.071726 -0.923888 0.375880
+vn  0.143679 -0.923888 0.354665
+vn  0.210109 -0.923888 0.319820
+vn  0.268466 -0.923888 0.272684
+vn  0.316506 -0.923888 0.215069
+vn  0.352382 -0.923888 0.149190
+vn  0.374717 -0.923888 0.077577
+vn  0.382651 -0.923888 0.002983
+vn  0.375880 -0.923888 -0.071726
+vn  0.354665 -0.923888 -0.143679
+vn  0.319820 -0.923888 -0.210110
+vn  0.272684 -0.923888 -0.268466
+vn  0.215069 -0.923888 -0.316506
+vn  0.149190 -0.923888 -0.352382
+vn  0.077577 -0.923888 -0.374717
+vn  0.005744 -0.976740 -0.214348
+vn  -0.036184 -0.976740 -0.211350
+vn  -0.076721 -0.976740 -0.200230
+vn  -0.114310 -0.976740 -0.181415
+vn  -0.147505 -0.976740 -0.155628
+vn  -0.175033 -0.976740 -0.123861
+vn  -0.195834 -0.976740 -0.087334
+vn  -0.209109 -0.976740 -0.047451
+vn  -0.214348 -0.976740 -0.005744
+vn  -0.211350 -0.976740 0.036184
+vn  -0.200230 -0.976740 0.076721
+vn  -0.181415 -0.976740 0.114310
+vn  -0.155628 -0.976740 0.147506
+vn  -0.123861 -0.976740 0.175033
+vn  -0.087334 -0.976740 0.195834
+vn  -0.047450 -0.976740 0.209109
+vn  -0.005744 -0.976740 0.214348
+vn  0.036184 -0.976740 0.211350
+vn  0.076721 -0.976740 0.200230
+vn  0.114310 -0.976740 0.181415
+vn  0.147506 -0.976740 0.155628
+vn  0.175033 -0.976740 0.123861
+vn  0.195834 -0.976740 0.087334
+vn  0.209109 -0.976740 0.047450
+vn  0.214348 -0.976740 0.005743
+vn  0.211350 -0.976740 -0.036184
+vn  0.200230 -0.976740 -0.076721
+vn  0.181415 -0.976740 -0.114310
+vn  0.155628 -0.976740 -0.147506
+vn  0.123861 -0.976740 -0.175033
+vn  0.087334 -0.976740 -0.195834
+vn  0.047450 -0.976740 -0.209109
+vn  0.000000 -1.000000 -0.000000
+# 482 vertex normals
+
+g default
+s 1
+f 1/1/1 2/34/2 3/35/3
+f 1/2/1 3/35/3 4/36/4
+f 1/3/1 4/36/4 5/37/5
+f 1/4/1 5/37/5 6/38/6
+f 1/5/1 6/38/6 7/39/7
+f 1/6/1 7/39/7 8/40/8
+f 1/7/1 8/40/8 9/41/9
+f 1/8/1 9/41/9 10/42/10
+f 1/9/1 10/42/10 11/43/11
+f 1/10/1 11/43/11 12/44/12
+f 1/11/1 12/44/12 13/45/13
+f 1/12/1 13/45/13 14/46/14
+f 1/13/1 14/46/14 15/47/15
+f 1/14/1 15/47/15 16/48/16
+f 1/15/1 16/48/16 17/49/17
+f 1/16/1 17/49/17 18/50/18
+f 1/17/1 18/50/18 19/51/19
+f 1/18/1 19/51/19 20/52/20
+f 1/19/1 20/52/20 21/53/21
+f 1/20/1 21/53/21 22/54/22
+f 1/21/1 22/54/22 23/55/23
+f 1/22/1 23/55/23 24/56/24
+f 1/23/1 24/56/24 25/57/25
+f 1/24/1 25/57/25 26/58/26
+f 1/25/1 26/58/26 27/59/27
+f 1/26/1 27/59/27 28/60/28
+f 1/27/1 28/60/28 29/61/29
+f 1/28/1 29/61/29 30/62/30
+f 1/29/1 30/62/30 31/63/31
+f 1/30/1 31/63/31 32/64/32
+f 1/31/1 32/64/32 33/65/33
+f 1/32/1 33/65/33 2/66/2
+f 2/34/2 34/67/34 35/68/35
+f 2/34/2 35/68/35 3/35/3
+f 3/35/3 35/68/35 36/69/36
+f 3/35/3 36/69/36 4/36/4
+f 4/36/4 36/69/36 37/70/37
+f 4/36/4 37/70/37 5/37/5
+f 5/37/5 37/70/37 38/71/38
+f 5/37/5 38/71/38 6/38/6
+f 6/38/6 38/71/38 39/72/39
+f 6/38/6 39/72/39 7/39/7
+f 7/39/7 39/72/39 40/73/40
+f 7/39/7 40/73/40 8/40/8
+f 8/40/8 40/73/40 41/74/41
+f 8/40/8 41/74/41 9/41/9
+f 9/41/9 41/74/41 42/75/42
+f 9/41/9 42/75/42 10/42/10
+f 10/42/10 42/75/42 43/76/43
+f 10/42/10 43/76/43 11/43/11
+f 11/43/11 43/76/43 44/77/44
+f 11/43/11 44/77/44 12/44/12
+f 12/44/12 44/77/44 45/78/45
+f 12/44/12 45/78/45 13/45/13
+f 13/45/13 45/78/45 46/79/46
+f 13/45/13 46/79/46 14/46/14
+f 14/46/14 46/79/46 47/80/47
+f 14/46/14 47/80/47 15/47/15
+f 15/47/15 47/80/47 48/81/48
+f 15/47/15 48/81/48 16/48/16
+f 16/48/16 48/81/48 49/82/49
+f 16/48/16 49/82/49 17/49/17
+f 17/49/17 49/82/49 50/83/50
+f 17/49/17 50/83/50 18/50/18
+f 18/50/18 50/83/50 51/84/51
+f 18/50/18 51/84/51 19/51/19
+f 19/51/19 51/84/51 52/85/52
+f 19/51/19 52/85/52 20/52/20
+f 20/52/20 52/85/52 53/86/53
+f 20/52/20 53/86/53 21/53/21
+f 21/53/21 53/86/53 54/87/54
+f 21/53/21 54/87/54 22/54/22
+f 22/54/22 54/87/54 55/88/55
+f 22/54/22 55/88/55 23/55/23
+f 23/55/23 55/88/55 56/89/56
+f 23/55/23 56/89/56 24/56/24
+f 24/56/24 56/89/56 57/90/57
+f 24/56/24 57/90/57 25/57/25
+f 25/57/25 57/90/57 58/91/58
+f 25/57/25 58/91/58 26/58/26
+f 26/58/26 58/91/58 59/92/59
+f 26/58/26 59/92/59 27/59/27
+f 27/59/27 59/92/59 60/93/60
+f 27/59/27 60/93/60 28/60/28
+f 28/60/28 60/93/60 61/94/61
+f 28/60/28 61/94/61 29/61/29
+f 29/61/29 61/94/61 62/95/62
+f 29/61/29 62/95/62 30/62/30
+f 30/62/30 62/95/62 63/96/63
+f 30/62/30 63/96/63 31/63/31
+f 31/63/31 63/96/63 64/97/64
+f 31/63/31 64/97/64 32/64/32
+f 32/64/32 64/97/64 65/98/65
+f 32/64/32 65/98/65 33/65/33
+f 33/65/33 65/98/65 34/99/34
+f 33/65/33 34/99/34 2/66/2
+f 34/67/34 66/100/66 67/101/67
+f 34/67/34 67/101/67 35/68/35
+f 35/68/35 67/101/67 68/102/68
+f 35/68/35 68/102/68 36/69/36
+f 36/69/36 68/102/68 69/103/69
+f 36/69/36 69/103/69 37/70/37
+f 37/70/37 69/103/69 70/104/70
+f 37/70/37 70/104/70 38/71/38
+f 38/71/38 70/104/70 71/105/71
+f 38/71/38 71/105/71 39/72/39
+f 39/72/39 71/105/71 72/106/72
+f 39/72/39 72/106/72 40/73/40
+f 40/73/40 72/106/72 73/107/73
+f 40/73/40 73/107/73 41/74/41
+f 41/74/41 73/107/73 74/108/74
+f 41/74/41 74/108/74 42/75/42
+f 42/75/42 74/108/74 75/109/75
+f 42/75/42 75/109/75 43/76/43
+f 43/76/43 75/109/75 76/110/76
+f 43/76/43 76/110/76 44/77/44
+f 44/77/44 76/110/76 77/111/77
+f 44/77/44 77/111/77 45/78/45
+f 45/78/45 77/111/77 78/112/78
+f 45/78/45 78/112/78 46/79/46
+f 46/79/46 78/112/78 79/113/79
+f 46/79/46 79/113/79 47/80/47
+f 47/80/47 79/113/79 80/114/80
+f 47/80/47 80/114/80 48/81/48
+f 48/81/48 80/114/80 81/115/81
+f 48/81/48 81/115/81 49/82/49
+f 49/82/49 81/115/81 82/116/82
+f 49/82/49 82/116/82 50/83/50
+f 50/83/50 82/116/82 83/117/83
+f 50/83/50 83/117/83 51/84/51
+f 51/84/51 83/117/83 84/118/84
+f 51/84/51 84/118/84 52/85/52
+f 52/85/52 84/118/84 85/119/85
+f 52/85/52 85/119/85 53/86/53
+f 53/86/53 85/119/85 86/120/86
+f 53/86/53 86/120/86 54/87/54
+f 54/87/54 86/120/86 87/121/87
+f 54/87/54 87/121/87 55/88/55
+f 55/88/55 87/121/87 88/122/88
+f 55/88/55 88/122/88 56/89/56
+f 56/89/56 88/122/88 89/123/89
+f 56/89/56 89/123/89 57/90/57
+f 57/90/57 89/123/89 90/124/90
+f 57/90/57 90/124/90 58/91/58
+f 58/91/58 90/124/90 91/125/91
+f 58/91/58 91/125/91 59/92/59
+f 59/92/59 91/125/91 92/126/92
+f 59/92/59 92/126/92 60/93/60
+f 60/93/60 92/126/92 93/127/93
+f 60/93/60 93/127/93 61/94/61
+f 61/94/61 93/127/93 94/128/94
+f 61/94/61 94/128/94 62/95/62
+f 62/95/62 94/128/94 95/129/95
+f 62/95/62 95/129/95 63/96/63
+f 63/96/63 95/129/95 96/130/96
+f 63/96/63 96/130/96 64/97/64
+f 64/97/64 96/130/96 97/131/97
+f 64/97/64 97/131/97 65/98/65
+f 65/98/65 97/131/97 66/132/66
+f 65/98/65 66/132/66 34/99/34
+f 66/100/66 98/133/98 99/134/99
+f 66/100/66 99/134/99 67/101/67
+f 67/101/67 99/134/99 100/135/100
+f 67/101/67 100/135/100 68/102/68
+f 68/102/68 100/135/100 101/136/101
+f 68/102/68 101/136/101 69/103/69
+f 69/103/69 101/136/101 102/137/102
+f 69/103/69 102/137/102 70/104/70
+f 70/104/70 102/137/102 103/138/103
+f 70/104/70 103/138/103 71/105/71
+f 71/105/71 103/138/103 104/139/104
+f 71/105/71 104/139/104 72/106/72
+f 72/106/72 104/139/104 105/140/105
+f 72/106/72 105/140/105 73/107/73
+f 73/107/73 105/140/105 106/141/106
+f 73/107/73 106/141/106 74/108/74
+f 74/108/74 106/141/106 107/142/107
+f 74/108/74 107/142/107 75/109/75
+f 75/109/75 107/142/107 108/143/108
+f 75/109/75 108/143/108 76/110/76
+f 76/110/76 108/143/108 109/144/109
+f 76/110/76 109/144/109 77/111/77
+f 77/111/77 109/144/109 110/145/110
+f 77/111/77 110/145/110 78/112/78
+f 78/112/78 110/145/110 111/146/111
+f 78/112/78 111/146/111 79/113/79
+f 79/113/79 111/146/111 112/147/112
+f 79/113/79 112/147/112 80/114/80
+f 80/114/80 112/147/112 113/148/113
+f 80/114/80 113/148/113 81/115/81
+f 81/115/81 113/148/113 114/149/114
+f 81/115/81 114/149/114 82/116/82
+f 82/116/82 114/149/114 115/150/115
+f 82/116/82 115/150/115 83/117/83
+f 83/117/83 115/150/115 116/151/116
+f 83/117/83 116/151/116 84/118/84
+f 84/118/84 116/151/116 117/152/117
+f 84/118/84 117/152/117 85/119/85
+f 85/119/85 117/152/117 118/153/118
+f 85/119/85 118/153/118 86/120/86
+f 86/120/86 118/153/118 119/154/119
+f 86/120/86 119/154/119 87/121/87
+f 87/121/87 119/154/119 120/155/120
+f 87/121/87 120/155/120 88/122/88
+f 88/122/88 120/155/120 121/156/121
+f 88/122/88 121/156/121 89/123/89
+f 89/123/89 121/156/121 122/157/122
+f 89/123/89 122/157/122 90/124/90
+f 90/124/90 122/157/122 123/158/123
+f 90/124/90 123/158/123 91/125/91
+f 91/125/91 123/158/123 124/159/124
+f 91/125/91 124/159/124 92/126/92
+f 92/126/92 124/159/124 125/160/125
+f 92/126/92 125/160/125 93/127/93
+f 93/127/93 125/160/125 126/161/126
+f 93/127/93 126/161/126 94/128/94
+f 94/128/94 126/161/126 127/162/127
+f 94/128/94 127/162/127 95/129/95
+f 95/129/95 127/162/127 128/163/128
+f 95/129/95 128/163/128 96/130/96
+f 96/130/96 128/163/128 129/164/129
+f 96/130/96 129/164/129 97/131/97
+f 97/131/97 129/164/129 98/165/98
+f 97/131/97 98/165/98 66/132/66
+f 98/133/98 130/166/130 131/167/131
+f 98/133/98 131/167/131 99/134/99
+f 99/134/99 131/167/131 132/168/132
+f 99/134/99 132/168/132 100/135/100
+f 100/135/100 132/168/132 133/169/133
+f 100/135/100 133/169/133 101/136/101
+f 101/136/101 133/169/133 134/170/134
+f 101/136/101 134/170/134 102/137/102
+f 102/137/102 134/170/134 135/171/135
+f 102/137/102 135/171/135 103/138/103
+f 103/138/103 135/171/135 136/172/136
+f 103/138/103 136/172/136 104/139/104
+f 104/139/104 136/172/136 137/173/137
+f 104/139/104 137/173/137 105/140/105
+f 105/140/105 137/173/137 138/174/138
+f 105/140/105 138/174/138 106/141/106
+f 106/141/106 138/174/138 139/175/139
+f 106/141/106 139/175/139 107/142/107
+f 107/142/107 139/175/139 140/176/140
+f 107/142/107 140/176/140 108/143/108
+f 108/143/108 140/176/140 141/177/141
+f 108/143/108 141/177/141 109/144/109
+f 109/144/109 141/177/141 142/178/142
+f 109/144/109 142/178/142 110/145/110
+f 110/145/110 142/178/142 143/179/143
+f 110/145/110 143/179/143 111/146/111
+f 111/146/111 143/179/143 144/180/144
+f 111/146/111 144/180/144 112/147/112
+f 112/147/112 144/180/144 145/181/145
+f 112/147/112 145/181/145 113/148/113
+f 113/148/113 145/181/145 146/182/146
+f 113/148/113 146/182/146 114/149/114
+f 114/149/114 146/182/146 147/183/147
+f 114/149/114 147/183/147 115/150/115
+f 115/150/115 147/183/147 148/184/148
+f 115/150/115 148/184/148 116/151/116
+f 116/151/116 148/184/148 149/185/149
+f 116/151/116 149/185/149 117/152/117
+f 117/152/117 149/185/149 150/186/150
+f 117/152/117 150/186/150 118/153/118
+f 118/153/118 150/186/150 151/187/151
+f 118/153/118 151/187/151 119/154/119
+f 119/154/119 151/187/151 152/188/152
+f 119/154/119 152/188/152 120/155/120
+f 120/155/120 152/188/152 153/189/153
+f 120/155/120 153/189/153 121/156/121
+f 121/156/121 153/189/153 154/190/154
+f 121/156/121 154/190/154 122/157/122
+f 122/157/122 154/190/154 155/191/155
+f 122/157/122 155/191/155 123/158/123
+f 123/158/123 155/191/155 156/192/156
+f 123/158/123 156/192/156 124/159/124
+f 124/159/124 156/192/156 157/193/157
+f 124/159/124 157/193/157 125/160/125
+f 125/160/125 157/193/157 158/194/158
+f 125/160/125 158/194/158 126/161/126
+f 126/161/126 158/194/158 159/195/159
+f 126/161/126 159/195/159 127/162/127
+f 127/162/127 159/195/159 160/196/160
+f 127/162/127 160/196/160 128/163/128
+f 128/163/128 160/196/160 161/197/161
+f 128/163/128 161/197/161 129/164/129
+f 129/164/129 161/197/161 130/198/130
+f 129/164/129 130/198/130 98/165/98
+f 130/166/130 162/199/162 163/200/163
+f 130/166/130 163/200/163 131/167/131
+f 131/167/131 163/200/163 164/201/164
+f 131/167/131 164/201/164 132/168/132
+f 132/168/132 164/201/164 165/202/165
+f 132/168/132 165/202/165 133/169/133
+f 133/169/133 165/202/165 166/203/166
+f 133/169/133 166/203/166 134/170/134
+f 134/170/134 166/203/166 167/204/167
+f 134/170/134 167/204/167 135/171/135
+f 135/171/135 167/204/167 168/205/168
+f 135/171/135 168/205/168 136/172/136
+f 136/172/136 168/205/168 169/206/169
+f 136/172/136 169/206/169 137/173/137
+f 137/173/137 169/206/169 170/207/170
+f 137/173/137 170/207/170 138/174/138
+f 138/174/138 170/207/170 171/208/171
+f 138/174/138 171/208/171 139/175/139
+f 139/175/139 171/208/171 172/209/172
+f 139/175/139 172/209/172 140/176/140
+f 140/176/140 172/209/172 173/210/173
+f 140/176/140 173/210/173 141/177/141
+f 141/177/141 173/210/173 174/211/174
+f 141/177/141 174/211/174 142/178/142
+f 142/178/142 174/211/174 175/212/175
+f 142/178/142 175/212/175 143/179/143
+f 143/179/143 175/212/175 176/213/176
+f 143/179/143 176/213/176 144/180/144
+f 144/180/144 176/213/176 177/214/177
+f 144/180/144 177/214/177 145/181/145
+f 145/181/145 177/214/177 178/215/178
+f 145/181/145 178/215/178 146/182/146
+f 146/182/146 178/215/178 179/216/179
+f 146/182/146 179/216/179 147/183/147
+f 147/183/147 179/216/179 180/217/180
+f 147/183/147 180/217/180 148/184/148
+f 148/184/148 180/217/180 181/218/181
+f 148/184/148 181/218/181 149/185/149
+f 149/185/149 181/218/181 182/219/182
+f 149/185/149 182/219/182 150/186/150
+f 150/186/150 182/219/182 183/220/183
+f 150/186/150 183/220/183 151/187/151
+f 151/187/151 183/220/183 184/221/184
+f 151/187/151 184/221/184 152/188/152
+f 152/188/152 184/221/184 185/222/185
+f 152/188/152 185/222/185 153/189/153
+f 153/189/153 185/222/185 186/223/186
+f 153/189/153 186/223/186 154/190/154
+f 154/190/154 186/223/186 187/224/187
+f 154/190/154 187/224/187 155/191/155
+f 155/191/155 187/224/187 188/225/188
+f 155/191/155 188/225/188 156/192/156
+f 156/192/156 188/225/188 189/226/189
+f 156/192/156 189/226/189 157/193/157
+f 157/193/157 189/226/189 190/227/190
+f 157/193/157 190/227/190 158/194/158
+f 158/194/158 190/227/190 191/228/191
+f 158/194/158 191/228/191 159/195/159
+f 159/195/159 191/228/191 192/229/192
+f 159/195/159 192/229/192 160/196/160
+f 160/196/160 192/229/192 193/230/193
+f 160/196/160 193/230/193 161/197/161
+f 161/197/161 193/230/193 162/231/162
+f 161/197/161 162/231/162 130/198/130
+f 162/199/162 194/232/194 195/233/195
+f 162/199/162 195/233/195 163/200/163
+f 163/200/163 195/233/195 196/234/196
+f 163/200/163 196/234/196 164/201/164
+f 164/201/164 196/234/196 197/235/197
+f 164/201/164 197/235/197 165/202/165
+f 165/202/165 197/235/197 198/236/198
+f 165/202/165 198/236/198 166/203/166
+f 166/203/166 198/236/198 199/237/199
+f 166/203/166 199/237/199 167/204/167
+f 167/204/167 199/237/199 200/238/200
+f 167/204/167 200/238/200 168/205/168
+f 168/205/168 200/238/200 201/239/201
+f 168/205/168 201/239/201 169/206/169
+f 169/206/169 201/239/201 202/240/202
+f 169/206/169 202/240/202 170/207/170
+f 170/207/170 202/240/202 203/241/203
+f 170/207/170 203/241/203 171/208/171
+f 171/208/171 203/241/203 204/242/204
+f 171/208/171 204/242/204 172/209/172
+f 172/209/172 204/242/204 205/243/205
+f 172/209/172 205/243/205 173/210/173
+f 173/210/173 205/243/205 206/244/206
+f 173/210/173 206/244/206 174/211/174
+f 174/211/174 206/244/206 207/245/207
+f 174/211/174 207/245/207 175/212/175
+f 175/212/175 207/245/207 208/246/208
+f 175/212/175 208/246/208 176/213/176
+f 176/213/176 208/246/208 209/247/209
+f 176/213/176 209/247/209 177/214/177
+f 177/214/177 209/247/209 210/248/210
+f 177/214/177 210/248/210 178/215/178
+f 178/215/178 210/248/210 211/249/211
+f 178/215/178 211/249/211 179/216/179
+f 179/216/179 211/249/211 212/250/212
+f 179/216/179 212/250/212 180/217/180
+f 180/217/180 212/250/212 213/251/213
+f 180/217/180 213/251/213 181/218/181
+f 181/218/181 213/251/213 214/252/214
+f 181/218/181 214/252/214 182/219/182
+f 182/219/182 214/252/214 215/253/215
+f 182/219/182 215/253/215 183/220/183
+f 183/220/183 215/253/215 216/254/216
+f 183/220/183 216/254/216 184/221/184
+f 184/221/184 216/254/216 217/255/217
+f 184/221/184 217/255/217 185/222/185
+f 185/222/185 217/255/217 218/256/218
+f 185/222/185 218/256/218 186/223/186
+f 186/223/186 218/256/218 219/257/219
+f 186/223/186 219/257/219 187/224/187
+f 187/224/187 219/257/219 220/258/220
+f 187/224/187 220/258/220 188/225/188
+f 188/225/188 220/258/220 221/259/221
+f 188/225/188 221/259/221 189/226/189
+f 189/226/189 221/259/221 222/260/222
+f 189/226/189 222/260/222 190/227/190
+f 190/227/190 222/260/222 223/261/223
+f 190/227/190 223/261/223 191/228/191
+f 191/228/191 223/261/223 224/262/224
+f 191/228/191 224/262/224 192/229/192
+f 192/229/192 224/262/224 225/263/225
+f 192/229/192 225/263/225 193/230/193
+f 193/230/193 225/263/225 194/264/194
+f 193/230/193 194/264/194 162/231/162
+f 194/232/194 226/265/226 227/266/227
+f 194/232/194 227/266/227 195/233/195
+f 195/233/195 227/266/227 228/267/228
+f 195/233/195 228/267/228 196/234/196
+f 196/234/196 228/267/228 229/268/229
+f 196/234/196 229/268/229 197/235/197
+f 197/235/197 229/268/229 230/269/230
+f 197/235/197 230/269/230 198/236/198
+f 198/236/198 230/269/230 231/270/231
+f 198/236/198 231/270/231 199/237/199
+f 199/237/199 231/270/231 232/271/232
+f 199/237/199 232/271/232 200/238/200
+f 200/238/200 232/271/232 233/272/233
+f 200/238/200 233/272/233 201/239/201
+f 201/239/201 233/272/233 234/273/234
+f 201/239/201 234/273/234 202/240/202
+f 202/240/202 234/273/234 235/274/235
+f 202/240/202 235/274/235 203/241/203
+f 203/241/203 235/274/235 236/275/236
+f 203/241/203 236/275/236 204/242/204
+f 204/242/204 236/275/236 237/276/237
+f 204/242/204 237/276/237 205/243/205
+f 205/243/205 237/276/237 238/277/238
+f 205/243/205 238/277/238 206/244/206
+f 206/244/206 238/277/238 239/278/239
+f 206/244/206 239/278/239 207/245/207
+f 207/245/207 239/278/239 240/279/240
+f 207/245/207 240/279/240 208/246/208
+f 208/246/208 240/279/240 241/280/241
+f 208/246/208 241/280/241 209/247/209
+f 209/247/209 241/280/241 242/281/242
+f 209/247/209 242/281/242 210/248/210
+f 210/248/210 242/281/242 243/282/243
+f 210/248/210 243/282/243 211/249/211
+f 211/249/211 243/282/243 244/283/244
+f 211/249/211 244/283/244 212/250/212
+f 212/250/212 244/283/244 245/284/245
+f 212/250/212 245/284/245 213/251/213
+f 213/251/213 245/284/245 246/285/246
+f 213/251/213 246/285/246 214/252/214
+f 214/252/214 246/285/246 247/286/247
+f 214/252/214 247/286/247 215/253/215
+f 215/253/215 247/286/247 248/287/248
+f 215/253/215 248/287/248 216/254/216
+f 216/254/216 248/287/248 249/288/249
+f 216/254/216 249/288/249 217/255/217
+f 217/255/217 249/288/249 250/289/250
+f 217/255/217 250/289/250 218/256/218
+f 218/256/218 250/289/250 251/290/251
+f 218/256/218 251/290/251 219/257/219
+f 219/257/219 251/290/251 252/291/252
+f 219/257/219 252/291/252 220/258/220
+f 220/258/220 252/291/252 253/292/253
+f 220/258/220 253/292/253 221/259/221
+f 221/259/221 253/292/253 254/293/254
+f 221/259/221 254/293/254 222/260/222
+f 222/260/222 254/293/254 255/294/255
+f 222/260/222 255/294/255 223/261/223
+f 223/261/223 255/294/255 256/295/256
+f 223/261/223 256/295/256 224/262/224
+f 224/262/224 256/295/256 257/296/257
+f 224/262/224 257/296/257 225/263/225
+f 225/263/225 257/296/257 226/297/226
+f 225/263/225 226/297/226 194/264/194
+f 226/265/226 258/298/258 259/299/259
+f 226/265/226 259/299/259 227/266/227
+f 227/266/227 259/299/259 260/300/260
+f 227/266/227 260/300/260 228/267/228
+f 228/267/228 260/300/260 261/301/261
+f 228/267/228 261/301/261 229/268/229
+f 229/268/229 261/301/261 262/302/262
+f 229/268/229 262/302/262 230/269/230
+f 230/269/230 262/302/262 263/303/263
+f 230/269/230 263/303/263 231/270/231
+f 231/270/231 263/303/263 264/304/264
+f 231/270/231 264/304/264 232/271/232
+f 232/271/232 264/304/264 265/305/265
+f 232/271/232 265/305/265 233/272/233
+f 233/272/233 265/305/265 266/306/266
+f 233/272/233 266/306/266 234/273/234
+f 234/273/234 266/306/266 267/307/267
+f 234/273/234 267/307/267 235/274/235
+f 235/274/235 267/307/267 268/308/268
+f 235/274/235 268/308/268 236/275/236
+f 236/275/236 268/308/268 269/309/269
+f 236/275/236 269/309/269 237/276/237
+f 237/276/237 269/309/269 270/310/270
+f 237/276/237 270/310/270 238/277/238
+f 238/277/238 270/310/270 271/311/271
+f 238/277/238 271/311/271 239/278/239
+f 239/278/239 271/311/271 272/312/272
+f 239/278/239 272/312/272 240/279/240
+f 240/279/240 272/312/272 273/313/273
+f 240/279/240 273/313/273 241/280/241
+f 241/280/241 273/313/273 274/314/274
+f 241/280/241 274/314/274 242/281/242
+f 242/281/242 274/314/274 275/315/275
+f 242/281/242 275/315/275 243/282/243
+f 243/282/243 275/315/275 276/316/276
+f 243/282/243 276/316/276 244/283/244
+f 244/283/244 276/316/276 277/317/277
+f 244/283/244 277/317/277 245/284/245
+f 245/284/245 277/317/277 278/318/278
+f 245/284/245 278/318/278 246/285/246
+f 246/285/246 278/318/278 279/319/279
+f 246/285/246 279/319/279 247/286/247
+f 247/286/247 279/319/279 280/320/280
+f 247/286/247 280/320/280 248/287/248
+f 248/287/248 280/320/280 281/321/281
+f 248/287/248 281/321/281 249/288/249
+f 249/288/249 281/321/281 282/322/282
+f 249/288/249 282/322/282 250/289/250
+f 250/289/250 282/322/282 283/323/283
+f 250/289/250 283/323/283 251/290/251
+f 251/290/251 283/323/283 284/324/284
+f 251/290/251 284/324/284 252/291/252
+f 252/291/252 284/324/284 285/325/285
+f 252/291/252 285/325/285 253/292/253
+f 253/292/253 285/325/285 286/326/286
+f 253/292/253 286/326/286 254/293/254
+f 254/293/254 286/326/286 287/327/287
+f 254/293/254 287/327/287 255/294/255
+f 255/294/255 287/327/287 288/328/288
+f 255/294/255 288/328/288 256/295/256
+f 256/295/256 288/328/288 289/329/289
+f 256/295/256 289/329/289 257/296/257
+f 257/296/257 289/329/289 258/330/258
+f 257/296/257 258/330/258 226/297/226
+f 258/298/258 290/331/290 291/332/291
+f 258/298/258 291/332/291 259/299/259
+f 259/299/259 291/332/291 292/333/292
+f 259/299/259 292/333/292 260/300/260
+f 260/300/260 292/333/292 293/334/293
+f 260/300/260 293/334/293 261/301/261
+f 261/301/261 293/334/293 294/335/294
+f 261/301/261 294/335/294 262/302/262
+f 262/302/262 294/335/294 295/336/295
+f 262/302/262 295/336/295 263/303/263
+f 263/303/263 295/336/295 296/337/296
+f 263/303/263 296/337/296 264/304/264
+f 264/304/264 296/337/296 297/338/297
+f 264/304/264 297/338/297 265/305/265
+f 265/305/265 297/338/297 298/339/298
+f 265/305/265 298/339/298 266/306/266
+f 266/306/266 298/339/298 299/340/299
+f 266/306/266 299/340/299 267/307/267
+f 267/307/267 299/340/299 300/341/300
+f 267/307/267 300/341/300 268/308/268
+f 268/308/268 300/341/300 301/342/301
+f 268/308/268 301/342/301 269/309/269
+f 269/309/269 301/342/301 302/343/302
+f 269/309/269 302/343/302 270/310/270
+f 270/310/270 302/343/302 303/344/303
+f 270/310/270 303/344/303 271/311/271
+f 271/311/271 303/344/303 304/345/304
+f 271/311/271 304/345/304 272/312/272
+f 272/312/272 304/345/304 305/346/305
+f 272/312/272 305/346/305 273/313/273
+f 273/313/273 305/346/305 306/347/306
+f 273/313/273 306/347/306 274/314/274
+f 274/314/274 306/347/306 307/348/307
+f 274/314/274 307/348/307 275/315/275
+f 275/315/275 307/348/307 308/349/308
+f 275/315/275 308/349/308 276/316/276
+f 276/316/276 308/349/308 309/350/309
+f 276/316/276 309/350/309 277/317/277
+f 277/317/277 309/350/309 310/351/310
+f 277/317/277 310/351/310 278/318/278
+f 278/318/278 310/351/310 311/352/311
+f 278/318/278 311/352/311 279/319/279
+f 279/319/279 311/352/311 312/353/312
+f 279/319/279 312/353/312 280/320/280
+f 280/320/280 312/353/312 313/354/313
+f 280/320/280 313/354/313 281/321/281
+f 281/321/281 313/354/313 314/355/314
+f 281/321/281 314/355/314 282/322/282
+f 282/322/282 314/355/314 315/356/315
+f 282/322/282 315/356/315 283/323/283
+f 283/323/283 315/356/315 316/357/316
+f 283/323/283 316/357/316 284/324/284
+f 284/324/284 316/357/316 317/358/317
+f 284/324/284 317/358/317 285/325/285
+f 285/325/285 317/358/317 318/359/318
+f 285/325/285 318/359/318 286/326/286
+f 286/326/286 318/359/318 319/360/319
+f 286/326/286 319/360/319 287/327/287
+f 287/327/287 319/360/319 320/361/320
+f 287/327/287 320/361/320 288/328/288
+f 288/328/288 320/361/320 321/362/321
+f 288/328/288 321/362/321 289/329/289
+f 289/329/289 321/362/321 290/363/290
+f 289/329/289 290/363/290 258/330/258
+f 290/331/290 322/364/322 323/365/323
+f 290/331/290 323/365/323 291/332/291
+f 291/332/291 323/365/323 324/366/324
+f 291/332/291 324/366/324 292/333/292
+f 292/333/292 324/366/324 325/367/325
+f 292/333/292 325/367/325 293/334/293
+f 293/334/293 325/367/325 326/368/326
+f 293/334/293 326/368/326 294/335/294
+f 294/335/294 326/368/326 327/369/327
+f 294/335/294 327/369/327 295/336/295
+f 295/336/295 327/369/327 328/370/328
+f 295/336/295 328/370/328 296/337/296
+f 296/337/296 328/370/328 329/371/329
+f 296/337/296 329/371/329 297/338/297
+f 297/338/297 329/371/329 330/372/330
+f 297/338/297 330/372/330 298/339/298
+f 298/339/298 330/372/330 331/373/331
+f 298/339/298 331/373/331 299/340/299
+f 299/340/299 331/373/331 332/374/332
+f 299/340/299 332/374/332 300/341/300
+f 300/341/300 332/374/332 333/375/333
+f 300/341/300 333/375/333 301/342/301
+f 301/342/301 333/375/333 334/376/334
+f 301/342/301 334/376/334 302/343/302
+f 302/343/302 334/376/334 335/377/335
+f 302/343/302 335/377/335 303/344/303
+f 303/344/303 335/377/335 336/378/336
+f 303/344/303 336/378/336 304/345/304
+f 304/345/304 336/378/336 337/379/337
+f 304/345/304 337/379/337 305/346/305
+f 305/346/305 337/379/337 338/380/338
+f 305/346/305 338/380/338 306/347/306
+f 306/347/306 338/380/338 339/381/339
+f 306/347/306 339/381/339 307/348/307
+f 307/348/307 339/381/339 340/382/340
+f 307/348/307 340/382/340 308/349/308
+f 308/349/308 340/382/340 341/383/341
+f 308/349/308 341/383/341 309/350/309
+f 309/350/309 341/383/341 342/384/342
+f 309/350/309 342/384/342 310/351/310
+f 310/351/310 342/384/342 343/385/343
+f 310/351/310 343/385/343 311/352/311
+f 311/352/311 343/385/343 344/386/344
+f 311/352/311 344/386/344 312/353/312
+f 312/353/312 344/386/344 345/387/345
+f 312/353/312 345/387/345 313/354/313
+f 313/354/313 345/387/345 346/388/346
+f 313/354/313 346/388/346 314/355/314
+f 314/355/314 346/388/346 347/389/347
+f 314/355/314 347/389/347 315/356/315
+f 315/356/315 347/389/347 348/390/348
+f 315/356/315 348/390/348 316/357/316
+f 316/357/316 348/390/348 349/391/349
+f 316/357/316 349/391/349 317/358/317
+f 317/358/317 349/391/349 350/392/350
+f 317/358/317 350/392/350 318/359/318
+f 318/359/318 350/392/350 351/393/351
+f 318/359/318 351/393/351 319/360/319
+f 319/360/319 351/393/351 352/394/352
+f 319/360/319 352/394/352 320/361/320
+f 320/361/320 352/394/352 353/395/353
+f 320/361/320 353/395/353 321/362/321
+f 321/362/321 353/395/353 322/396/322
+f 321/362/321 322/396/322 290/363/290
+f 322/364/322 354/397/354 355/398/355
+f 322/364/322 355/398/355 323/365/323
+f 323/365/323 355/398/355 356/399/356
+f 323/365/323 356/399/356 324/366/324
+f 324/366/324 356/399/356 357/400/357
+f 324/366/324 357/400/357 325/367/325
+f 325/367/325 357/400/357 358/401/358
+f 325/367/325 358/401/358 326/368/326
+f 326/368/326 358/401/358 359/402/359
+f 326/368/326 359/402/359 327/369/327
+f 327/369/327 359/402/359 360/403/360
+f 327/369/327 360/403/360 328/370/328
+f 328/370/328 360/403/360 361/404/361
+f 328/370/328 361/404/361 329/371/329
+f 329/371/329 361/404/361 362/405/362
+f 329/371/329 362/405/362 330/372/330
+f 330/372/330 362/405/362 363/406/363
+f 330/372/330 363/406/363 331/373/331
+f 331/373/331 363/406/363 364/407/364
+f 331/373/331 364/407/364 332/374/332
+f 332/374/332 364/407/364 365/408/365
+f 332/374/332 365/408/365 333/375/333
+f 333/375/333 365/408/365 366/409/366
+f 333/375/333 366/409/366 334/376/334
+f 334/376/334 366/409/366 367/410/367
+f 334/376/334 367/410/367 335/377/335
+f 335/377/335 367/410/367 368/411/368
+f 335/377/335 368/411/368 336/378/336
+f 336/378/336 368/411/368 369/412/369
+f 336/378/336 369/412/369 337/379/337
+f 337/379/337 369/412/369 370/413/370
+f 337/379/337 370/413/370 338/380/338
+f 338/380/338 370/413/370 371/414/371
+f 338/380/338 371/414/371 339/381/339
+f 339/381/339 371/414/371 372/415/372
+f 339/381/339 372/415/372 340/382/340
+f 340/382/340 372/415/372 373/416/373
+f 340/382/340 373/416/373 341/383/341
+f 341/383/341 373/416/373 374/417/374
+f 341/383/341 374/417/374 342/384/342
+f 342/384/342 374/417/374 375/418/375
+f 342/384/342 375/418/375 343/385/343
+f 343/385/343 375/418/375 376/419/376
+f 343/385/343 376/419/376 344/386/344
+f 344/386/344 376/419/376 377/420/377
+f 344/386/344 377/420/377 345/387/345
+f 345/387/345 377/420/377 378/421/378
+f 345/387/345 378/421/378 346/388/346
+f 346/388/346 378/421/378 379/422/379
+f 346/388/346 379/422/379 347/389/347
+f 347/389/347 379/422/379 380/423/380
+f 347/389/347 380/423/380 348/390/348
+f 348/390/348 380/423/380 381/424/381
+f 348/390/348 381/424/381 349/391/349
+f 349/391/349 381/424/381 382/425/382
+f 349/391/349 382/425/382 350/392/350
+f 350/392/350 382/425/382 383/426/383
+f 350/392/350 383/426/383 351/393/351
+f 351/393/351 383/426/383 384/427/384
+f 351/393/351 384/427/384 352/394/352
+f 352/394/352 384/427/384 385/428/385
+f 352/394/352 385/428/385 353/395/353
+f 353/395/353 385/428/385 354/429/354
+f 353/395/353 354/429/354 322/396/322
+f 354/397/354 386/430/386 387/431/387
+f 354/397/354 387/431/387 355/398/355
+f 355/398/355 387/431/387 388/432/388
+f 355/398/355 388/432/388 356/399/356
+f 356/399/356 388/432/388 389/433/389
+f 356/399/356 389/433/389 357/400/357
+f 357/400/357 389/433/389 390/434/390
+f 357/400/357 390/434/390 358/401/358
+f 358/401/358 390/434/390 391/435/391
+f 358/401/358 391/435/391 359/402/359
+f 359/402/359 391/435/391 392/436/392
+f 359/402/359 392/436/392 360/403/360
+f 360/403/360 392/436/392 393/437/393
+f 360/403/360 393/437/393 361/404/361
+f 361/404/361 393/437/393 394/438/394
+f 361/404/361 394/438/394 362/405/362
+f 362/405/362 394/438/394 395/439/395
+f 362/405/362 395/439/395 363/406/363
+f 363/406/363 395/439/395 396/440/396
+f 363/406/363 396/440/396 364/407/364
+f 364/407/364 396/440/396 397/441/397
+f 364/407/364 397/441/397 365/408/365
+f 365/408/365 397/441/397 398/442/398
+f 365/408/365 398/442/398 366/409/366
+f 366/409/366 398/442/398 399/443/399
+f 366/409/366 399/443/399 367/410/367
+f 367/410/367 399/443/399 400/444/400
+f 367/410/367 400/444/400 368/411/368
+f 368/411/368 400/444/400 401/445/401
+f 368/411/368 401/445/401 369/412/369
+f 369/412/369 401/445/401 402/446/402
+f 369/412/369 402/446/402 370/413/370
+f 370/413/370 402/446/402 403/447/403
+f 370/413/370 403/447/403 371/414/371
+f 371/414/371 403/447/403 404/448/404
+f 371/414/371 404/448/404 372/415/372
+f 372/415/372 404/448/404 405/449/405
+f 372/415/372 405/449/405 373/416/373
+f 373/416/373 405/449/405 406/450/406
+f 373/416/373 406/450/406 374/417/374
+f 374/417/374 406/450/406 407/451/407
+f 374/417/374 407/451/407 375/418/375
+f 375/418/375 407/451/407 408/452/408
+f 375/418/375 408/452/408 376/419/376
+f 376/419/376 408/452/408 409/453/409
+f 376/419/376 409/453/409 377/420/377
+f 377/420/377 409/453/409 410/454/410
+f 377/420/377 410/454/410 378/421/378
+f 378/421/378 410/454/410 411/455/411
+f 378/421/378 411/455/411 379/422/379
+f 379/422/379 411/455/411 412/456/412
+f 379/422/379 412/456/412 380/423/380
+f 380/423/380 412/456/412 413/457/413
+f 380/423/380 413/457/413 381/424/381
+f 381/424/381 413/457/413 414/458/414
+f 381/424/381 414/458/414 382/425/382
+f 382/425/382 414/458/414 415/459/415
+f 382/425/382 415/459/415 383/426/383
+f 383/426/383 415/459/415 416/460/416
+f 383/426/383 416/460/416 384/427/384
+f 384/427/384 416/460/416 417/461/417
+f 384/427/384 417/461/417 385/428/385
+f 385/428/385 417/461/417 386/462/386
+f 385/428/385 386/462/386 354/429/354
+f 386/430/386 418/463/418 419/464/419
+f 386/430/386 419/464/419 387/431/387
+f 387/431/387 419/464/419 420/465/420
+f 387/431/387 420/465/420 388/432/388
+f 388/432/388 420/465/420 421/466/421
+f 388/432/388 421/466/421 389/433/389
+f 389/433/389 421/466/421 422/467/422
+f 389/433/389 422/467/422 390/434/390
+f 390/434/390 422/467/422 423/468/423
+f 390/434/390 423/468/423 391/435/391
+f 391/435/391 423/468/423 424/469/424
+f 391/435/391 424/469/424 392/436/392
+f 392/436/392 424/469/424 425/470/425
+f 392/436/392 425/470/425 393/437/393
+f 393/437/393 425/470/425 426/471/426
+f 393/437/393 426/471/426 394/438/394
+f 394/438/394 426/471/426 427/472/427
+f 394/438/394 427/472/427 395/439/395
+f 395/439/395 427/472/427 428/473/428
+f 395/439/395 428/473/428 396/440/396
+f 396/440/396 428/473/428 429/474/429
+f 396/440/396 429/474/429 397/441/397
+f 397/441/397 429/474/429 430/475/430
+f 397/441/397 430/475/430 398/442/398
+f 398/442/398 430/475/430 431/476/431
+f 398/442/398 431/476/431 399/443/399
+f 399/443/399 431/476/431 432/477/432
+f 399/443/399 432/477/432 400/444/400
+f 400/444/400 432/477/432 433/478/433
+f 400/444/400 433/478/433 401/445/401
+f 401/445/401 433/478/433 434/479/434
+f 401/445/401 434/479/434 402/446/402
+f 402/446/402 434/479/434 435/480/435
+f 402/446/402 435/480/435 403/447/403
+f 403/447/403 435/480/435 436/481/436
+f 403/447/403 436/481/436 404/448/404
+f 404/448/404 436/481/436 437/482/437
+f 404/448/404 437/482/437 405/449/405
+f 405/449/405 437/482/437 438/483/438
+f 405/449/405 438/483/438 406/450/406
+f 406/450/406 438/483/438 439/484/439
+f 406/450/406 439/484/439 407/451/407
+f 407/451/407 439/484/439 440/485/440
+f 407/451/407 440/485/440 408/452/408
+f 408/452/408 440/485/440 441/486/441
+f 408/452/408 441/486/441 409/453/409
+f 409/453/409 441/486/441 442/487/442
+f 409/453/409 442/487/442 410/454/410
+f 410/454/410 442/487/442 443/488/443
+f 410/454/410 443/488/443 411/455/411
+f 411/455/411 443/488/443 444/489/444
+f 411/455/411 444/489/444 412/456/412
+f 412/456/412 444/489/444 445/490/445
+f 412/456/412 445/490/445 413/457/413
+f 413/457/413 445/490/445 446/491/446
+f 413/457/413 446/491/446 414/458/414
+f 414/458/414 446/491/446 447/492/447
+f 414/458/414 447/492/447 415/459/415
+f 415/459/415 447/492/447 448/493/448
+f 415/459/415 448/493/448 416/460/416
+f 416/460/416 448/493/448 449/494/449
+f 416/460/416 449/494/449 417/461/417
+f 417/461/417 449/494/449 418/495/418
+f 417/461/417 418/495/418 386/462/386
+f 418/463/418 450/496/450 451/497/451
+f 418/463/418 451/497/451 419/464/419
+f 419/464/419 451/497/451 452/498/452
+f 419/464/419 452/498/452 420/465/420
+f 420/465/420 452/498/452 453/499/453
+f 420/465/420 453/499/453 421/466/421
+f 421/466/421 453/499/453 454/500/454
+f 421/466/421 454/500/454 422/467/422
+f 422/467/422 454/500/454 455/501/455
+f 422/467/422 455/501/455 423/468/423
+f 423/468/423 455/501/455 456/502/456
+f 423/468/423 456/502/456 424/469/424
+f 424/469/424 456/502/456 457/503/457
+f 424/469/424 457/503/457 425/470/425
+f 425/470/425 457/503/457 458/504/458
+f 425/470/425 458/504/458 426/471/426
+f 426/471/426 458/504/458 459/505/459
+f 426/471/426 459/505/459 427/472/427
+f 427/472/427 459/505/459 460/506/460
+f 427/472/427 460/506/460 428/473/428
+f 428/473/428 460/506/460 461/507/461
+f 428/473/428 461/507/461 429/474/429
+f 429/474/429 461/507/461 462/508/462
+f 429/474/429 462/508/462 430/475/430
+f 430/475/430 462/508/462 463/509/463
+f 430/475/430 463/509/463 431/476/431
+f 431/476/431 463/509/463 464/510/464
+f 431/476/431 464/510/464 432/477/432
+f 432/477/432 464/510/464 465/511/465
+f 432/477/432 465/511/465 433/478/433
+f 433/478/433 465/511/465 466/512/466
+f 433/478/433 466/512/466 434/479/434
+f 434/479/434 466/512/466 467/513/467
+f 434/479/434 467/513/467 435/480/435
+f 435/480/435 467/513/467 468/514/468
+f 435/480/435 468/514/468 436/481/436
+f 436/481/436 468/514/468 469/515/469
+f 436/481/436 469/515/469 437/482/437
+f 437/482/437 469/515/469 470/516/470
+f 437/482/437 470/516/470 438/483/438
+f 438/483/438 470/516/470 471/517/471
+f 438/483/438 471/517/471 439/484/439
+f 439/484/439 471/517/471 472/518/472
+f 439/484/439 472/518/472 440/485/440
+f 440/485/440 472/518/472 473/519/473
+f 440/485/440 473/519/473 441/486/441
+f 441/486/441 473/519/473 474/520/474
+f 441/486/441 474/520/474 442/487/442
+f 442/487/442 474/520/474 475/521/475
+f 442/487/442 475/521/475 443/488/443
+f 443/488/443 475/521/475 476/522/476
+f 443/488/443 476/522/476 444/489/444
+f 444/489/444 476/522/476 477/523/477
+f 444/489/444 477/523/477 445/490/445
+f 445/490/445 477/523/477 478/524/478
+f 445/490/445 478/524/478 446/491/446
+f 446/491/446 478/524/478 479/525/479
+f 446/491/446 479/525/479 447/492/447
+f 447/492/447 479/525/479 480/526/480
+f 447/492/447 480/526/480 448/493/448
+f 448/493/448 480/526/480 481/527/481
+f 448/493/448 481/527/481 449/494/449
+f 449/494/449 481/527/481 450/528/450
+f 449/494/449 450/528/450 418/495/418
+f 482/529/482 451/497/451 450/496/450
+f 482/530/482 452/498/452 451/497/451
+f 482/531/482 453/499/453 452/498/452
+f 482/532/482 454/500/454 453/499/453
+f 482/533/482 455/501/455 454/500/454
+f 482/534/482 456/502/456 455/501/455
+f 482/535/482 457/503/457 456/502/456
+f 482/536/482 458/504/458 457/503/457
+f 482/537/482 459/505/459 458/504/458
+f 482/538/482 460/506/460 459/505/459
+f 482/539/482 461/507/461 460/506/460
+f 482/540/482 462/508/462 461/507/461
+f 482/541/482 463/509/463 462/508/462
+f 482/542/482 464/510/464 463/509/463
+f 482/543/482 465/511/465 464/510/464
+f 482/544/482 466/512/466 465/511/465
+f 482/545/482 467/513/467 466/512/466
+f 482/546/482 468/514/468 467/513/467
+f 482/547/482 469/515/469 468/514/468
+f 482/548/482 470/516/470 469/515/469
+f 482/549/482 471/517/471 470/516/470
+f 482/550/482 472/518/472 471/517/471
+f 482/551/482 473/519/473 472/518/472
+f 482/552/482 474/520/474 473/519/473
+f 482/553/482 475/521/475 474/520/474
+f 482/554/482 476/522/476 475/521/475
+f 482/555/482 477/523/477 476/522/476
+f 482/556/482 478/524/478 477/523/477
+f 482/557/482 479/525/479 478/524/478
+f 482/558/482 480/526/480 479/525/479
+f 482/559/482 481/527/481 480/526/480
+f 482/560/482 450/528/450 481/527/481
+# 960 faces
+
+g

third_party/ktx-src/tests/loadtests/common/reenable_warnings.h

@@ -0,0 +1,18 @@
+/* -*- tab-width: 4; -*- */
+/* vi: set sw=2 ts=4 expandtab: */
+
+/*
+ * Copyright 2021 Mark Callow.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#if !defined REENABLE_WARNINGS_H
+
+// Reenable warnings disabled by, e.g. disable_glm_warnings.h.
+#if defined(_MSC_VER)
+  #pragma warning(pop)
+#elif defined(__clang__)
+  #pragma clang diagnostic pop
+#endif
+
+#endif /* REENABLE_WARNINGS_H */

third_party/ktx-src/tests/loadtests/common/vecmath.hpp

@@ -0,0 +1,448 @@
+/* -*- tab-width: 4; -*- */
+/* vi: set sw=2 ts=4 expandtab: */
+
+/*
+ * Copyright 2016-2020 Mark Callow
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#ifndef VECMATH_9B7E1CFE346D11E6AFA2D7DC87495A69_H
+#define VECMATH_9B7E1CFE346D11E6AFA2D7DC87495A69_H
+
+/**
+ * @file
+ * @~English
+ *
+ * @brief Vector math package modelled after GLSL.
+ */
+
+#include <assert.h>
+#include <math.h>
+
+struct vec2 {
+    // Anonymous unions are portable.
+    union {
+        float x;
+        float r;
+    };
+    union {
+        float y;
+        float g;
+    };
+
+    vec2() { };
+};
+
+struct vec3 {
+    union {
+        float x;
+        float r;
+    };
+    union {
+        float y;
+        float g;
+    };
+    union {
+        float z;
+        float b;
+    };
+
+    vec3() { }
+
+    vec3(float x, float y, float z) : x(x), y(y), z(z) { }
+
+    vec3(const vec3& value)
+        : x(value.x), y(value.y), z(value.z) { }
+
+    vec3 operator-() const
+    {
+        return vec3(-x, -y, -z);
+    }
+
+    vec3 operator-(const vec3& value) const
+    {
+        return vec3(this->x - value.x, this->y - value.y, this->z - value.z);
+    }
+
+    vec3 operator/(float divisor) const
+    {
+        return vec3(x / divisor, y / divisor, z / divisor);
+    }
+
+    vec3& operator/=(float divisor)
+    {
+        x /= divisor;
+        y /= divisor;
+        z /= divisor;
+        return *this;
+    }
+
+    vec3& operator=(const vec3& value)
+    {
+        x = value.x;
+        y = value.y;
+        z = value.z;
+        return *this;
+    }
+
+    float operator[](int i) const
+    {
+        switch (i) {
+          case 0: return x;
+          case 1: return y;
+          case 2: return z;
+          default:
+            assert(false);
+            return z;
+        }
+    }
+
+    float& operator[](int i)
+    {
+        switch (i) {
+          case 0: return x;
+          case 1: return y;
+          case 2: return z;
+          default:
+            assert(false);
+            return z;
+        }
+    }
+
+    vec3 cross(const vec3& value) const
+    {
+        return vec3::cross(*this, value);
+    }
+
+    float dot(const vec3& vec) const
+    {
+        return vec3::dot(*this, vec);
+    }
+
+    float length() const
+    {
+        return sqrt(dot(*this));
+    }
+
+    vec3& normalize()
+    {
+        float length = this->length();
+        return (length > 0.0f ? *this /= length : *this);
+    }
+
+    static vec3 cross(const vec3& a, const vec3& b)
+    {
+        return vec3(a.y * b.z - a.z * b.y,
+                    a.z * b.x - a.x * b.z,
+                    a.x * b.y - a.y * b.x);
+    }
+
+    static float dot(const vec3& a, const vec3& b)
+    {
+        return a.x * b.x + a.y * b.y + a.z * b.z;
+    }
+
+    static vec3 normalize (const vec3& input)
+    {
+        float length = input.length();
+        return (length > 0.0f ? input / length : input);
+    }
+};
+
+
+struct vec4 {
+
+    union {
+        float x;
+        float r;
+    };
+    union {
+        float y;
+        float g;
+    };
+    union {
+        float z;
+        float b;
+    };
+    union {
+        float w;
+        float a;
+    };
+
+    vec4() { }
+
+    vec4(float x, float y, float z, float w) : x(x), y(y), z(z), w(w) { }
+
+    vec4(const vec3& value, float w)
+        : x(value.x), y(value.y), z(value.z), w(w) { }
+
+    vec4(const vec4& value)
+        : x(value.x), y(value.y), z(value.z), w(value.w) { }
+
+    vec4 operator/(float divisor) const
+    {
+        return vec4(x / divisor, y / divisor, z / divisor, w / divisor);
+    }
+
+    vec4& operator/=(float divisor)
+    {
+        x /= divisor;
+        y /= divisor;
+        z /= divisor;
+        w /= divisor;
+        return *this;
+    }
+
+    vec4 operator*(float multiplicand) const
+    {
+        return vec4(x * multiplicand, y * multiplicand, z * multiplicand,
+                    w * multiplicand);
+    }
+
+    vec4& operator=(const vec4& value)
+    {
+        x = value.x;
+        y = value.y;
+        z = value.z;
+        w = value.w;
+        return *this;
+    }
+
+    float operator[](int i) const
+    {
+        switch (i) {
+          case 0: return x;
+          case 1: return y;
+          case 2: return z;
+          case 3: return w;
+          default:
+            assert(false);
+            return z;
+        }
+    }
+
+    float& operator[](int i)
+    {
+        switch (i) {
+          case 0: return x;
+          case 1: return y;
+          case 2: return z;
+          case 3: return w;
+          default:
+            assert(false);
+            return z;
+        }
+    }
+
+    float dot(const vec4& vec) const
+    {
+        return vec4::dot(*this, vec);
+    }
+
+    float length() const
+    {
+        return sqrt(dot(*this));
+    }
+
+    static float dot(const vec4& a, const vec4& b)
+    {
+        return a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w;
+    }
+
+    static vec4 normalize (const vec4& input)
+    {
+        float length = input.length();
+        return (length > 0.0f ? input / length : input);
+    }
+};
+
+struct mat3 {
+    vec3 m[3];
+
+    mat3()
+    {
+        m[0] = vec3(1.0f, 0.0f, 0.0f);
+        m[1] = vec3(0.0f, 1.0f, 0.0f);
+        m[2] = vec3(0.0f, 0.0f, 1.0f);
+    }
+
+    mat3(const vec3& value1, const vec3& value2, const vec3& value3)
+    {
+        m[0] = value1;
+        m[1] = value2;
+        m[2] = value3;
+    }
+
+    mat3 transpose() const
+    {
+        return mat3(vec3(m[0].x, m[1].x, m[2].x),
+                    vec3(m[0].y, m[1].y, m[2].y),
+                    vec3(m[0].z, m[1].z, m[2].z));
+    }
+};
+
+struct mat4 {
+    vec4 m[4];
+
+    mat4()
+    {
+        m[0] = vec4(1.0f, 0.0f, 0.0f, 0.0f);
+        m[1] = vec4(0.0f, 1.0f, 0.0f, 0.0f);
+        m[2] = vec4(0.0f, 0.0f, 1.0f, 0.0f);
+        m[3] = vec4(0.0f, 0.0f, 0.0f, 1.0f);
+    }
+
+    mat4(const vec4& value1, const vec4& value2,
+         const vec4& value3, const vec4& value4)
+    {
+        m[0] = value1;
+        m[1] = value2;
+        m[2] = value3;
+        m[3] = value4;
+    }
+
+    mat4 operator*(float value) const
+    {
+        return mat4(m[0] * value, m[1] * value, m[2] * value, m[3] * value);
+    }
+
+    mat4 operator*(const mat4& value) const
+    {
+        mat4 right = value.transpose();
+        return mat4(
+           vec4(m[0].dot(right.m[0]), m[0].dot(right.m[1]),
+                m[0].dot(right.m[2]), m[0].dot(right.m[3])),
+           vec4(m[1].dot(right.m[0]), m[1].dot(right.m[1]),
+                m[1].dot(right.m[2]), m[1].dot(right.m[3])),
+           vec4(m[2].dot(right.m[0]), m[2].dot(right.m[1]),
+                m[2].dot(right.m[2]), m[2].dot(right.m[3])),
+           vec4(m[3].dot(right.m[0]), m[3].dot(right.m[1]),
+                m[3].dot(right.m[2]), m[3].dot(right.m[3]))
+       );
+    }
+
+    vec4 operator*(const vec4& value) const
+    {
+        return vec4(m[0].dot(value), m[1].dot(value),
+                    m[2].dot(value), m[3].dot(value));
+    }
+
+    vec4& operator[](int i)
+    {
+        return m[i];
+    }
+
+    mat4 transpose() const
+    {
+        return mat4(vec4(m[0][0], m[1][0], m[2][0], m[3][0]),
+                    vec4(m[0][1], m[1][1], m[2][1], m[3][1]),
+                    vec4(m[0][2], m[1][2], m[2][2], m[3][2]),
+                    vec4(m[0][3], m[1][3], m[2][3], m[3][3]));
+    }
+
+    static mat4 translate(const vec3& trans)
+    {
+        return mat4(vec4(1.0f, 0.0f, 0.0f, trans.x),
+                    vec4(0.0f, 1.0f, 0.0f, trans.y),
+                    vec4(0.0f, 0.0f, 1.0f, trans.z),
+                    vec4(0.0f, 0.0f, 0.0f, 1.0f));
+    }
+
+    static mat4 translate(float x, float y, float z)
+    {
+        return mat4(vec4(1.0f, 0.0f, 0.0f, x),
+                    vec4(0.0f, 1.0f, 0.0f, y),
+                    vec4(0.0f, 0.0f, 1.0f, z),
+                    vec4(0.0f, 0.0f, 0.0f, 1.0f));
+    }
+
+    static mat4 scale(const vec3& scale)
+    {
+        return mat4(vec4(scale.x, 0.0f, 0.0f, 0.0f),
+                    vec4(0.0f, scale.y, 0.0f, 0.0f),
+                    vec4(0.0f, 0.0f, scale.z, 0.0f),
+                    vec4(0.0f, 0.0f, 0.0f, 1.0f));
+    }
+
+    static mat4 scale(float x, float y, float z)
+    {
+        return mat4(vec4(x, 0.0f, 0.0f, 0.0f),
+                    vec4(0.0f, y, 0.0f, 0.0f),
+                    vec4(0.0f, 0.0f, z, 0.0f),
+                    vec4(0.0f, 0.0f, 0.0f, 1.0f));
+    }
+
+    static mat4 frustum(float left, float right, float bottom, float top,
+                        float zNear, float zFar)
+    {
+        return mat4(
+            vec4(2.0f * zNear / (right - left), 0.0f,
+                 (right + left) / (right - left), 0.0f),
+            vec4(0.0f, 2.0f * zNear / (top - bottom),
+                 (top + bottom) / (top - bottom), 0.0f),
+            vec4(0.0f, 0.0f, (zFar + zNear) / (zNear - zFar),
+                 2.0f * zFar * zNear / (zNear - zFar)),
+            vec4(0.0f, 0.0f, -1.0f, 0.0f)
+        );
+    }
+
+    static mat4 ortho(float left, float right, float bottom, float top,
+                      float zNear, float zFar)
+    {
+        return mat4(
+             vec4(2.0f / (right - left), 0.0f, 0.0f,
+                  (right + left) / (left - right)),
+             vec4(0.0f, 2.0f / (top - bottom), 0.0f,
+                  (top + bottom) / (bottom - top)),
+             vec4(0.0f, 0.0f, 2.0f / (zNear - zFar),
+                  (zFar + zNear) / (zNear - zFar)),
+             vec4(0.0f, 0.0f, 0.0f, 1.0f)
+        );
+    }
+
+    static mat4 lookAt(const vec3& eye, const vec3& center, const vec3& up)
+    {
+        vec3 const forward(vec3::normalize(center - eye));
+        vec3 const side(vec3::normalize(vec3::cross(forward, up)));
+        vec3 const u(vec3::cross(side, forward));
+
+        mat4 result;
+        result[0][0] = side.x;
+        result[1][0] = side.y;
+        result[2][0] = side.z;
+        result[0][1] = u.x;
+        result[1][1] = u.y;
+        result[2][1] = u.z;
+        result[0][2] =-forward.x;
+        result[1][2] =-forward.y;
+        result[2][2] =-forward.z;
+        result[3][0] =-vec3::dot(side, eye);
+        result[3][1] =-vec3::dot(u, eye);
+        result[3][2] = vec3::dot(forward, eye);
+
+        return result;
+    }
+
+    static mat4 lookAt(float eyeX, float eyeY, float eyeZ,
+                       float centerX, float centerY, float centerZ,
+                       float upX, float upY, float upZ)
+    {
+        return mat4::lookAt(vec3(eyeX, eyeY, eyeZ),
+                            vec3(centerX, centerY, centerZ),
+                            vec3(upX, upY, upZ));
+    }
+
+    static mat4 perspective(float fovY, float aspect, float zNear, float zFar)
+    {
+        float scaleY = 1.0f / tan(fovY * 3.1415962f / 360.0f);
+        return mat4(
+             vec4(scaleY / aspect, 0.0f, 0.0f, 0.0f),
+             vec4(0.0f, scaleY, 0.0f, 0.0f),
+             vec4(0.0f, 0.0f, (zFar + zNear) / (zNear - zFar),
+                  (2.0f * zFar * zNear) / (zNear - zFar)),
+             vec4(0.0f, 0.0f, -1.0f, 0.0f)
+        );
+    }
+};
+
+#endif /* VECMATH_9B7E1CFE-346D-11E6-AFA2-D7DC87495A69_H */

third_party/ktx-src/tests/loadtests/compile_shader.cmake

@@ -0,0 +1,80 @@
+# Copyright 2020 Andreas Atteneder
+# SPDX-License-Identifier: Apache-2.0
+
+function(compile_shader shader_target shader_name shader_src_path shader_path)
+
+    set(vert_name "${shader_name}.vert")
+    set(vert2spirv_in "${shader_src_path}/${vert_name}")
+    set(vert2spirv_out "${CMAKE_CURRENT_BINARY_DIR}/${shader_path}/${vert_name}.spv")
+
+    add_custom_command(OUTPUT
+    ${vert2spirv_out}
+    COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_CURRENT_BINARY_DIR}/${shader_path}
+    COMMAND glslc "-fshader-stage=vertex" -o "${vert2spirv_out}" "${vert2spirv_in}"
+    DEPENDS ${vert2spirv_in}
+    WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR}
+    COMMENT "Compiling ${vert_name}."
+    VERBATIM
+    )
+
+    set(frag_name "${shader_name}.frag")
+    set(frag2spirv_in "${shader_src_path}/${frag_name}")
+    set(frag2spirv_out "${CMAKE_CURRENT_BINARY_DIR}/${shader_path}/${frag_name}.spv")
+
+    add_custom_command(OUTPUT
+    ${frag2spirv_out}
+    COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_CURRENT_BINARY_DIR}/${shader_path}
+    COMMAND glslc "-fshader-stage=fragment" -o "${frag2spirv_out}" "${frag2spirv_in}"
+    DEPENDS ${frag2spirv_in}
+    WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR}
+    COMMENT "Compiling ${frag_name}."
+    VERBATIM
+    )
+
+    add_custom_target(
+        ${shader_target}
+        DEPENDS
+        ${vert2spirv_out}
+        ${frag2spirv_out}
+        SOURCES
+        ${vert2spirv_in}
+        ${frag2spirv_in}
+    )
+
+    set_target_properties(${shader_target} PROPERTIES EXCLUDE_FROM_ALL "FALSE")
+
+    set(SHADER_SOURCES ${SHADER_SOURCES} ${frag2spirv_out} ${vert2spirv_out} PARENT_SCOPE)
+
+endfunction(compile_shader)
+
+function(compile_shader_list shader_target shader_src_path shader_path)
+
+    foreach(shader ${ARGN})
+        set(spirv_in  "${shader_src_path}/${shader}")
+        set(spirv_out "${CMAKE_CURRENT_BINARY_DIR}/${shader_path}/${shader}.spv")
+
+        add_custom_command(OUTPUT
+        ${spirv_out}
+        COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_CURRENT_BINARY_DIR}/${shader_path}
+        COMMAND glslc -o "${spirv_out}" "${spirv_in}"
+        DEPENDS ${spirv_in}
+        WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR}
+        COMMENT "Compiling ${shader}."
+        VERBATIM
+        )
+
+        list(APPEND inputs ${spirv_in})
+        list(APPEND outputs ${spirv_out})
+     endforeach()
+
+    add_custom_target(
+        ${shader_target}
+        DEPENDS ${outputs}
+        SOURCES ${inputs}
+    )
+
+    set_target_properties(${shader_target} PROPERTIES EXCLUDE_FROM_ALL "FALSE")
+
+    set(SHADER_SOURCES ${SHADER_SOURCES} ${outputs} PARENT_SCOPE)
+
+endfunction()

third_party/ktx-src/tests/loadtests/geom/cube.h

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2016-2020 Mark Callow
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+static const float cube_face[] =
+{
+    -1.0f, +1.0f, +1.0f, /* Front */
+    +1.0f, -1.0f, +1.0f,
+    +1.0f, +1.0f, +1.0f,
+    -1.0f, -1.0f, +1.0f,
+    -1.0f, +1.0f, -1.0f, /* Back */
+    +1.0f, -1.0f, -1.0f,
+    +1.0f, +1.0f, -1.0f,
+    -1.0f, -1.0f, -1.0f,
+    +1.0f, -1.0f, +1.0f, /* Right */
+    +1.0f, +1.0f, -1.0f,
+    +1.0f, +1.0f, +1.0f,
+    +1.0f, -1.0f, -1.0f,
+    -1.0f, -1.0f, +1.0f, /* Left */
+    -1.0f, +1.0f, -1.0f,
+    -1.0f, +1.0f, +1.0f,
+    -1.0f, -1.0f, -1.0f,
+    -1.0f, -1.0f, +1.0f, /* Bottom */
+    +1.0f, -1.0f, -1.0f,
+    +1.0f, -1.0f, +1.0f,
+    -1.0f, -1.0f, -1.0f,
+    -1.0f, +1.0f, +1.0f, /* Top */
+    +1.0f, +1.0f, -1.0f,
+    +1.0f, +1.0f, +1.0f,
+    -1.0f, +1.0f, -1.0f,
+};
+#define CUBE_NUM_FACE_COMPONENTS 3
+#define CUBE_FACE_STRIDE (sizeof(float) * CUBE_NUM_FACE_COMPONENTS)
+
+static const float cube_color[] = /* almost random colors */
+{
+    0.7f, 0.1f, 0.2f, 0.0f,     0.8f, 0.9f, 0.3f, 0.0f,     0.4f, 1.0f, 0.5f, 0.0f,     0.0f, 0.6f, 0.1f, 0.0f,
+    0.8f, 0.2f, 0.3f, 0.0f,     0.9f, 1.0f, 0.4f, 0.0f,     0.5f, 0.0f, 0.6f, 0.0f,     0.1f, 0.7f, 0.2f, 0.0f,
+    0.9f, 0.3f, 0.4f, 0.0f,     1.0f, 0.0f, 0.5f, 0.0f,     0.6f, 0.1f, 0.7f, 0.0f,     0.2f, 0.8f, 0.3f, 0.0f,
+    1.0f, 0.4f, 0.5f, 0.0f,     0.0f, 0.1f, 0.6f, 0.0f,     0.7f, 0.2f, 0.8f, 0.0f,     0.3f, 0.9f, 0.4f, 0.0f,
+    0.0f, 0.5f, 0.6f, 0.0f,     0.1f, 0.2f, 0.7f, 0.0f,     0.8f, 0.3f, 0.9f, 0.0f,     0.4f, 1.0f, 0.5f, 0.0f,
+    0.1f, 0.6f, 0.7f, 0.0f,     0.2f, 0.3f, 0.8f, 0.0f,     0.9f, 0.4f, 1.0f, 0.0f,     0.5f, 0.0f, 0.6f, 0.0f,
+};
+static const float cube_texture[] =
+{
+    0.0f, 1.0f,     1.0f, 0.0f,     1.0f, 1.0f,     0.0f, 0.0f,
+    1.0f, 1.0f,     0.0f, 0.0f,     0.0f, 1.0f,     1.0f, 0.0f,
+    0.0f, 1.0f,     1.0f, 0.0f,     1.0f, 1.0f,     0.0f, 0.0f,
+    1.0f, 1.0f,     0.0f, 0.0f,     0.0f, 1.0f,     1.0f, 0.0f,
+    0.0f, 1.0f,     1.0f, 0.0f,     1.0f, 1.0f,     0.0f, 0.0f,
+    1.0f, 1.0f,     0.0f, 0.0f,     0.0f, 1.0f,     1.0f, 0.0f
+};
+static const float cube_normal[] =
+{
+    0.0f, 0.0f, +1.0f,  0.0f, 0.0f, +1.0f,  0.0f, 0.0f, +1.0f,  0.0f, 0.0f, +1.0f,
+    0.0f, 0.0f, -1.0f,  0.0f, 0.0f, -1.0f,  0.0f, 0.0f, -1.0f,  0.0f, 0.0f, -1.0f,
+    +1.0f, 0.0f, 0.0f,  +1.0f, 0.0f, 0.0f,  +1.0f, 0.0f, 0.0f,  +1.0f, 0.0f, 0.0f,
+    -1.0f, 0.0f, 0.0f,  -1.0f, 0.0f, 0.0f,  -1.0f, 0.0f, 0.0f,  -1.0f, 0.0f, 0.0f,
+    0.0f, -1.0f, 0.0f,  0.0f, -1.0f, 0.0f,  0.0f, -1.0f, 0.0f,  0.0f, -1.0f, 0.0f,
+    0.0f, +1.0f, 0.0f,  0.0f, +1.0f, 0.0f,  0.0f, +1.0f, 0.0f,  0.0f, +1.0f, 0.0f,
+};
+
+static const unsigned short cube_index_buffer[] = {
+     0, 3, 1, 2, 0, 1,  /* Front */
+     6, 5, 4, 5, 7, 4,  /* Back */
+     8,11, 9,10, 8, 9,  /* Right */
+    15,12,13,12,14,13,  /* Left */
+    16,19,17,18,16,17,  /* Bottom */
+    23,20,21,20,22,21   /* Top */
+};
+#define CUBE_NUM_INDICES (sizeof(cube_index_buffer) / sizeof(unsigned short))

third_party/ktx-src/tests/loadtests/geom/cube_data.h

@@ -0,0 +1,155 @@
+/*
+ * Vulkan Samples
+ *
+ * Copyright 2015-2016 Valve Corporation
+ * Copyright 2015-2016 LunarG, Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+//--------------------------------------------------------------------------------------
+// Mesh and VertexFormat Data
+//--------------------------------------------------------------------------------------
+struct Vertex {
+    float posX, posY, posZ, posW; // Position data
+    float r, g, b, a;             // Color
+};
+
+struct VertexUV {
+    float posX, posY, posZ, posW; // Position data
+    float u, v;                   // texture u,v
+};
+
+#define XYZ1(_x_, _y_, _z_) (_x_), (_y_), (_z_), 1.f
+#define UV(_u_, _v_) (_u_), (_v_)
+
+static const Vertex g_vbData[] = {
+    {XYZ1(-1, -1, -1), XYZ1(0.f, 0.f, 0.f)},
+    {XYZ1(1, -1, -1), XYZ1(1.f, 0.f, 0.f)},
+    {XYZ1(-1, 1, -1), XYZ1(0.f, 1.f, 0.f)},
+    {XYZ1(-1, 1, -1), XYZ1(0.f, 1.f, 0.f)},
+    {XYZ1(1, -1, -1), XYZ1(1.f, 0.f, 0.f)},
+    {XYZ1(1, 1, -1), XYZ1(1.f, 1.f, 0.f)},
+
+    {XYZ1(-1, -1, 1), XYZ1(0.f, 0.f, 1.f)},
+    {XYZ1(-1, 1, 1), XYZ1(0.f, 1.f, 1.f)},
+    {XYZ1(1, -1, 1), XYZ1(1.f, 0.f, 1.f)},
+    {XYZ1(1, -1, 1), XYZ1(1.f, 0.f, 1.f)},
+    {XYZ1(-1, 1, 1), XYZ1(0.f, 1.f, 1.f)},
+    {XYZ1(1, 1, 1), XYZ1(1.f, 1.f, 1.f)},
+
+    {XYZ1(1, 1, 1), XYZ1(1.f, 1.f, 1.f)},
+    {XYZ1(1, 1, -1), XYZ1(1.f, 1.f, 0.f)},
+    {XYZ1(1, -1, 1), XYZ1(1.f, 0.f, 1.f)},
+    {XYZ1(1, -1, 1), XYZ1(1.f, 0.f, 1.f)},
+    {XYZ1(1, 1, -1), XYZ1(1.f, 1.f, 0.f)},
+    {XYZ1(1, -1, -1), XYZ1(1.f, 0.f, 0.f)},
+
+    {XYZ1(-1, 1, 1), XYZ1(0.f, 1.f, 1.f)},
+    {XYZ1(-1, -1, 1), XYZ1(0.f, 0.f, 1.f)},
+    {XYZ1(-1, 1, -1), XYZ1(0.f, 1.f, 0.f)},
+    {XYZ1(-1, 1, -1), XYZ1(0.f, 1.f, 0.f)},
+    {XYZ1(-1, -1, 1), XYZ1(0.f, 0.f, 1.f)},
+    {XYZ1(-1, -1, -1), XYZ1(0.f, 0.f, 0.f)},
+
+    {XYZ1(1, 1, 1), XYZ1(1.f, 1.f, 1.f)},
+    {XYZ1(-1, 1, 1), XYZ1(0.f, 1.f, 1.f)},
+    {XYZ1(1, 1, -1), XYZ1(1.f, 1.f, 0.f)},
+    {XYZ1(1, 1, -1), XYZ1(1.f, 1.f, 0.f)},
+    {XYZ1(-1, 1, 1), XYZ1(0.f, 1.f, 1.f)},
+    {XYZ1(-1, 1, -1), XYZ1(0.f, 1.f, 0.f)},
+
+    {XYZ1(1, -1, 1), XYZ1(1.f, 0.f, 1.f)},
+    {XYZ1(1, -1, -1), XYZ1(1.f, 0.f, 0.f)},
+    {XYZ1(-1, -1, 1), XYZ1(0.f, 0.f, 1.f)},
+    {XYZ1(-1, -1, 1), XYZ1(0.f, 0.f, 1.f)},
+    {XYZ1(1, -1, -1), XYZ1(1.f, 0.f, 0.f)},
+    {XYZ1(-1, -1, -1), XYZ1(0.f, 0.f, 0.f)},
+};
+
+static const Vertex g_vb_solid_face_colors_Data[] = {
+    {XYZ1(-1, -1, -1), XYZ1(1.f, 0.f, 0.f)},
+    {XYZ1(1, -1, -1), XYZ1(1.f, 0.f, 0.f)},
+    {XYZ1(-1, 1, -1), XYZ1(1.f, 0.f, 0.f)},
+    {XYZ1(-1, 1, -1), XYZ1(1.f, 0.f, 0.f)},
+    {XYZ1(1, -1, -1), XYZ1(1.f, 0.f, 0.f)},
+    {XYZ1(1, 1, -1), XYZ1(1.f, 0.f, 0.f)},
+
+    {XYZ1(-1, -1, 1), XYZ1(0.f, 1.f, 0.f)},
+    {XYZ1(-1, 1, 1), XYZ1(0.f, 1.f, 0.f)},
+    {XYZ1(1, -1, 1), XYZ1(0.f, 1.f, 0.f)},
+    {XYZ1(1, -1, 1), XYZ1(0.f, 1.f, 0.f)},
+    {XYZ1(-1, 1, 1), XYZ1(0.f, 1.f, 0.f)},
+    {XYZ1(1, 1, 1), XYZ1(0.f, 1.f, 0.f)},
+
+    {XYZ1(1, 1, 1), XYZ1(0.f, 0.f, 1.f)},
+    {XYZ1(1, 1, -1), XYZ1(0.f, 0.f, 1.f)},
+    {XYZ1(1, -1, 1), XYZ1(0.f, 0.f, 1.f)},
+    {XYZ1(1, -1, 1), XYZ1(0.f, 0.f, 1.f)},
+    {XYZ1(1, 1, -1), XYZ1(0.f, 0.f, 1.f)},
+    {XYZ1(1, -1, -1), XYZ1(0.f, 0.f, 1.f)},
+
+    {XYZ1(-1, 1, 1), XYZ1(1.f, 1.f, 0.f)},
+    {XYZ1(-1, -1, 1), XYZ1(1.f, 1.f, 0.f)},
+    {XYZ1(-1, 1, -1), XYZ1(1.f, 1.f, 0.f)},
+    {XYZ1(-1, 1, -1), XYZ1(1.f, 1.f, 0.f)},
+    {XYZ1(-1, -1, 1), XYZ1(1.f, 1.f, 0.f)},
+    {XYZ1(-1, -1, -1), XYZ1(1.f, 1.f, 0.f)},
+
+    {XYZ1(1, 1, 1), XYZ1(1.f, 0.f, 1.f)},
+    {XYZ1(-1, 1, 1), XYZ1(1.f, 0.f, 1.f)},
+    {XYZ1(1, 1, -1), XYZ1(1.f, 0.f, 1.f)},
+    {XYZ1(1, 1, -1), XYZ1(1.f, 0.f, 1.f)},
+    {XYZ1(-1, 1, 1), XYZ1(1.f, 0.f, 1.f)},
+    {XYZ1(-1, 1, -1), XYZ1(1.f, 0.f, 1.f)},
+
+    {XYZ1(1, -1, 1), XYZ1(0.f, 1.f, 1.f)},
+    {XYZ1(1, -1, -1), XYZ1(0.f, 1.f, 1.f)},
+    {XYZ1(-1, -1, 1), XYZ1(0.f, 1.f, 1.f)},
+    {XYZ1(-1, -1, 1), XYZ1(0.f, 1.f, 1.f)},
+    {XYZ1(1, -1, -1), XYZ1(0.f, 1.f, 1.f)},
+    {XYZ1(-1, -1, -1), XYZ1(0.f, 1.f, 1.f)},
+};
+
+static const VertexUV g_vb_texture_Data[] = {
+    {XYZ1(-1, -1, -1), UV(0.f, 0.f)},
+    {XYZ1(-1, 1, 1), UV(1.f, 1.f)},
+    {XYZ1(-1, -1, 1), UV(1.f, 0.f)},
+    {XYZ1(-1, 1, 1), UV(1.f, 1.f)},
+    {XYZ1(-1, -1, -1), UV(0.f, 0.f)},
+    {XYZ1(-1, 1, -1), UV(0.f, 1.f)},
+
+    {XYZ1(-1, -1, -1), UV(1.f, 0.f)},
+    {XYZ1(1, -1, -1), UV(0.f, 0.f)},
+    {XYZ1(1, 1, -1), UV(0.f, 1.f)},
+    {XYZ1(-1, -1, -1), UV(1.f, 0.f)},
+    {XYZ1(1, 1, -1), UV(0.f, 1.f)},
+    {XYZ1(-1, 1, -1), UV(1.f, 1.f)},
+
+    {XYZ1(-1, -1, -1), UV(1.f, 1.f)},
+    {XYZ1(1, -1, 1), UV(0.f, 0.f)},
+    {XYZ1(1, -1, -1), UV(1.f, 0.f)},
+    {XYZ1(-1, -1, -1), UV(1.f, 1.f)},
+    {XYZ1(-1, -1, 1), UV(0.f, 1.f)},
+    {XYZ1(1, -1, 1), UV(0.f, 0.f)},
+
+    {XYZ1(-1, 1, -1), UV(1.f, 1.f)},
+    {XYZ1(1, 1, 1), UV(0.f, 0.f)},
+    {XYZ1(-1, 1, 1), UV(0.f, 1.f)},
+    {XYZ1(-1, 1, -1), UV(1.f, 1.f)},
+    {XYZ1(1, 1, -1), UV(1.f, 0.f)},
+    {XYZ1(1, 1, 1), UV(0.f, 0.f)},
+
+    {XYZ1(1, 1, -1), UV(1.f, 1.f)},
+    {XYZ1(1, -1, 1), UV(0.f, 0.f)},
+    {XYZ1(1, 1, 1), UV(0.f, 1.f)},
+    {XYZ1(1, -1, 1), UV(0.f, 0.f)},
+    {XYZ1(1, 1, -1), UV(1.f, 1.f)},
+    {XYZ1(1, -1, -1), UV(1.f, 0.f)},
+
+    {XYZ1(-1, 1, 1), UV(0.f, 1.f)},
+    {XYZ1(1, 1, 1), UV(1.f, 1.f)},
+    {XYZ1(-1, -1, 1), UV(0.f, 0.f)},
+    {XYZ1(-1, -1, 1), UV(0.f, 0.f)},
+    {XYZ1(1, 1, 1), UV(1.f, 1.f)},
+    {XYZ1(1, -1, 1), UV(1.f, 0.f)},
+};

third_party/ktx-src/tests/loadtests/geom/frame.h

@@ -0,0 +1,23 @@
+/*
+ * Copyright 2016-2020 Mark Callow
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/*
+ * Frame definition
+ */
+static const GLbyte frame_position[] =
+{
+    -1, -1, 0,
+     1, -1, 0,
+     1,  1, 0,
+    -1,  1, 0
+};
+
+static const GLbyte frame_color[] =
+{
+    1, 1, 0,
+    1, 1, 0,
+    1, 1, 0,
+    1, 1, 0
+};

third_party/ktx-src/tests/loadtests/geom/quad.h

@@ -0,0 +1,34 @@
+/* -*- tab-width: 4; -*- */
+/* vi: set et sw=2 ts=4 expandtab: */
+
+/*
+ * Copyright 2016-2020 Mark Callow
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/*
+ * Quad definition
+ */
+static const GLfloat quad_position[] =
+{
+    1.0f, -1.0f, 0,
+    1.0f,  1.0f, 0,
+    -1.0f, -1.0f, 0,
+    -1.0f,  1.0f, 0
+};
+
+static const GLfloat quad_color[] =
+{
+    0.7f, 0.1f, 0.2f,
+    0.8f, 0.9f, 0.3f,   
+    0.4f, 1.0f, 0.5f,
+    0.0f, 0.6f, 0.1f
+};
+
+static GLfloat quad_texture[] =
+{
+   1.0f, 0.0f,
+   1.0f, 1.0f,
+   0.0f, 0.0f,
+   0.0f, 1.0f
+};

third_party/ktx-src/tests/loadtests/glloadtests.cmake

@@ -0,0 +1,449 @@
+# Copyright 2020 Andreas Atteneder
+# SPDX-License-Identifier: Apache-2.0
+
+set(OPENGL_ES_EMULATOR "" CACHE PATH "Path to OpenGL ES emulation libraries")
+
+if(NOT APPLE_LOCKED_OS)
+    find_package(OpenGL REQUIRED)
+endif()
+if(WIN32)
+    find_package(GLEW REQUIRED)
+endif()
+
+function( create_gl_target target version sources common_resources test_images
+          KTX_GL_CONTEXT_PROFILE
+          KTX_GL_CONTEXT_MAJOR_VERSION KTX_GL_CONTEXT_MINOR_VERSION
+          EMULATE_GLES)
+
+    set( resources ${common_resources};${test_images} )
+
+    add_executable( ${target}
+        ${EXE_FLAG}
+        glloadtests.cmake
+        ${sources}
+        ${resources}
+    )
+
+    set_code_sign(${target})
+
+    # Nota Bene.
+    #
+    # 1. With the Visual Studio generator, at least, The SDL and GLEW
+    #    includes coming from GLAppSDL are being converted to system
+    #    includes. To see them in VS, view the whole command line in
+    #    the compile section of the project properties and look at the
+    #    Additional Options pane at the bottom.
+    # 2. GL_APP_SDL's INTERFACE_INCLUDE_DIRECTORIES includes the SYSTEM
+    #    include from appfwSDL.
+    #
+    # I do not understand the reasons for either of these.
+    target_include_directories(
+        ${target}
+    PRIVATE
+        $<TARGET_PROPERTY:GLAppSDL,INTERFACE_INCLUDE_DIRECTORIES>
+        $<TARGET_PROPERTY:ktx,INTERFACE_INCLUDE_DIRECTORIES>
+        $<TARGET_PROPERTY:objUtil,INTERFACE_INCLUDE_DIRECTORIES>
+    )
+
+    set_target_properties(${target} PROPERTIES
+        CXX_VISIBILITY_PRESET ${STATIC_APP_LIB_SYMBOL_VISIBILITY}
+    )
+
+
+    target_link_libraries(
+        ${target}
+        objUtil
+        GLAppSDL
+        appfwSDL
+        ktx
+    )
+
+    if(NOT EMSCRIPTEN AND NOT EMULATE_GLES)
+        target_link_libraries(
+            ${target}
+            ${OPENGL_LIBRARIES}
+        )
+    endif()
+
+    if(APPLE)
+        if(IOS)
+            # This is location where CMake puts the configured Info.plist.
+            # I have not found a CMake variable for this.
+            set( launch_screen ${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/${target}.dir/LaunchScreen.storyboard )
+            configure_file( glloadtests/resources/ios/LaunchScreen.storyboard.in
+                 ${launch_screen}
+            )
+            set( INFO_PLIST_IN "${PROJECT_SOURCE_DIR}/tests/loadtests/glloadtests/resources/ios/Info.plist.in" )
+            set( icon_launch_assets
+                ${PROJECT_SOURCE_DIR}/icons/ios/CommonIcons.xcassets
+                glloadtests/resources/ios/LaunchImages.xcassets
+                ${launch_screen}
+            )
+            target_sources( ${target}
+                PRIVATE
+                ${PROJECT_SOURCE_DIR}/icons/ios/CommonIcons.xcassets
+                glloadtests/resources/ios/LaunchImages.xcassets
+                glloadtests/resources/ios/LaunchScreen.storyboard.in
+            )
+            # Add to resources so they'll be copied to the bundle.
+            list( APPEND resources ${icon_launch_assets} )
+            target_link_libraries(
+                ${target}
+                ${AudioToolbox_LIBRARY}
+                ${AVFoundation_LIBRARY}
+                ${CoreAudio_LIBRARY}
+                ${CoreBluetooth_LIBRARY}
+                ${CoreGraphics_LIBRARY}
+                ${CoreMotion_LIBRARY}
+                ${CoreHaptics_LIBRARY}
+                ${Foundation_LIBRARY}
+                ${GameController_LIBRARY}
+                ${Metal_LIBRARY}
+                ${OpenGLES_LIBRARY}
+                ${QuartzCore_LIBRARY}
+                ${UIKit_LIBRARY}
+            )
+        else()
+            set( INFO_PLIST_IN "${PROJECT_SOURCE_DIR}/tests/loadtests/glloadtests/resources/mac/Info.plist.in" )
+        endif()
+    elseif(EMSCRIPTEN)
+        # Beware of de-duplication in list expansion for commands and options.
+        # SHELL: prevents it but if they are separate items in the list they
+        # be de-duplicated.
+        list( TRANSFORM test_images REPLACE
+            "(${PROJECT_SOURCE_DIR}/tests/testimages/([a-zA-Z0-9_].*$))"
+            "SHELL:--preload-file \\1@\\2"
+            OUTPUT_VARIABLE preloads
+        )
+        target_link_options(
+            ${target}
+        PRIVATE
+            "SHELL:--source-map-base ./"
+            ${preloads}
+            "SHELL:--exclude-file '${PROJECT_SOURCE_DIR}/tests/testimages/cubemap*'"
+            "SHELL:--use-port=sdl3"
+            "SHELL:-s ALLOW_MEMORY_GROWTH=1"
+            "SHELL:-s DISABLE_EXCEPTION_CATCHING=0"
+            "SHELL:-s USE_WEBGL2=1"
+        )
+    elseif(WIN32)
+        target_sources(
+            ${target}
+        PRIVATE
+            glloadtests/resources/win/glloadtests.rc
+            glloadtests/resources/win/resource.h
+        )
+        if(EMULATE_GLES)
+            if (KTX_GL_CONTEXT_MAJOR_VERSION EQUAL 1)
+                target_link_libraries(
+                    ${target}
+                    "${OPENGL_ES_EMULATOR}/libGLES_CM.lib"
+                    "${OPENGL_ES_EMULATOR}/libEGL.lib"
+                )
+             else()
+                target_link_libraries(
+                    ${target}
+                    "${OPENGL_ES_EMULATOR}/libGLESv2.lib"
+                    "${OPENGL_ES_EMULATOR}/libEGL.lib"
+                )
+             endif()
+        else()
+            target_link_libraries(
+                ${target}
+                ${GLEW_LIBRARIES}
+            )
+        endif()
+        ensure_runtime_dependencies_windows(${target})
+    elseif(LINUX)
+        # The output file is configured at CMake config time.
+        configure_file(glloadtests/resources/linux/glloadtests.desktop.in
+                  ${CMAKE_CURRENT_BINARY_DIR}/${target}.desktop
+        )
+        target_sources(
+              ${target}
+          PRIVATE
+              # Put the input file in sources as that is what must be edited.
+              glloadtests/resources/linux/glloadtests.desktop.in
+             #${CMAKE_CURRENT_BINARY_DIR}/${target}.desktop
+        )
+    endif()
+
+    target_link_libraries( ${target} ${LOAD_TEST_COMMON_LIBS} )
+
+    if(NOT EMULATE_GLES OR KTX_GL_CONTEXT_MAJOR_VERSION GREATER 1)
+        target_compile_definitions(
+            ${target}
+        PRIVATE
+            $<TARGET_PROPERTY:ktx,INTERFACE_COMPILE_DEFINITIONS>
+            GL_CONTEXT_PROFILE=${KTX_GL_CONTEXT_PROFILE}
+            GL_CONTEXT_MAJOR_VERSION=${KTX_GL_CONTEXT_MAJOR_VERSION}
+            GL_CONTEXT_MINOR_VERSION=${KTX_GL_CONTEXT_MINOR_VERSION}
+            $<$<PLATFORM_ID:Windows>:NOMINMAX>
+        )
+    else()
+        target_compile_definitions(
+            ${target}
+        PRIVATE
+            $<TARGET_PROPERTY:ktx,INTERFACE_COMPILE_DEFINITIONS>
+            $<$<PLATFORM_ID:Windows>:NOMINMAX>
+        )
+    endif()
+
+    set_target_properties( ${target} PROPERTIES RESOURCE "${resources}" )
+
+    if(APPLE)
+        set(product_name "${target}")
+        set( bundle_identifier org.khronos.ktx.${product_name} )
+        # This property must be set to avoid an Xcode warning.
+        set_target_properties(${target} PROPERTIES XCODE_ATTRIBUTE_PRODUCT_BUNDLE_IDENTIFIER "org.khronos.ktx.${product_name}")
+        # See important comment about MACOSX_BUNDLE_INFO_PLIST and these
+        # properties in ./vkloadtests.cmake.
+        set_target_properties( ${target} PROPERTIES
+            MACOSX_BUNDLE_BUNDLE_NAME ${product_name}
+            MACOSX_BUNDLE_EXECUTABLE_NAME ${product_name}
+            MACOSX_BUNDLE_COPYRIGHT "© 2024 Khronos Group, Inc."
+            MACOSX_BUNDLE_GUI_IDENTIFIER ${bundle_identifier}
+            MACOSX_BUNDLE_INFO_PLIST ${INFO_PLIST_IN}
+            MACOSX_BUNDLE_INFO_STRING "View KTX textures; display via OpenGL."
+            MACOSX_BUNDLE_ICON_FILE ${KTX_APP_ICON}
+            MACOSX_BUNDLE_BUNDLE_VERSION ${PROJECT_VERSION}
+            MACOSX_BUNDLE_SHORT_VERSION_STRING  ${PROJECT_VERSION}
+            # Because libassimp is built with bitcode disabled. It's not
+            # important unless submitting to the App Store and currently
+            # bitcode is optional.
+            XCODE_ATTRIBUTE_ENABLE_BITCODE "NO"
+            XCODE_ATTRIBUTE_ONLY_ACTIVE_ARCH "YES"
+            XCODE_ATTRIBUTE_ASSETCATALOG_COMPILER_APPICON_NAME ${KTX_APP_ICON_BASENAME}
+            XCODE_ATTRIBUTE_TARGETED_DEVICE_FAMILY "1,2" # iPhone and iPad
+        )
+        unset(product_name)
+        unset(bundle_identifier)
+
+        # The generated project code for building an Apple bundle automatically
+        # copies the executable and all files with the RESOURCE property to the
+        # bundle adjusting for the difference in bundle layout between iOS &
+        # macOS.
+
+        if(NOT IOS)
+            set_target_properties( ${target} PROPERTIES
+                INSTALL_RPATH "@executable_path/../Frameworks"
+            )
+
+            if(BUILD_SHARED_LIBS)
+              add_custom_command( TARGET ${target} POST_BUILD
+                  COMMAND ${CMAKE_COMMAND} -E copy $<TARGET_FILE:ktx> "$<TARGET_BUNDLE_CONTENT_DIR:${target}>/Frameworks/$<TARGET_FILE_NAME:ktx>"
+                  COMMAND ${CMAKE_COMMAND} -E create_symlink $<TARGET_FILE_NAME:ktx> "$<TARGET_BUNDLE_CONTENT_DIR:${target}>/Frameworks/$<TARGET_SONAME_FILE_NAME:ktx>"
+                  COMMENT "Copy KTX library to build destination"
+              )
+            endif()
+            # Re. SDL3 & assimp: no copy required.: vcpkg libs are static or else
+            # vcpkg arranges copy. Brew libs cannot be bundled.
+
+            # Specify destination for cmake --install.
+            install(TARGETS ${target}
+                BUNDLE
+                    DESTINATION /Applications
+                    COMPONENT GlLoadTestApps
+            )
+
+        endif()
+
+    else()
+        if(EMSCRIPTEN)
+            set_target_properties(${target} PROPERTIES SUFFIX ".html")
+        endif()
+
+        # This copies the resources next to the executable for ease
+        # of use during debugging and testing.
+        add_custom_command( TARGET ${target} POST_BUILD
+            COMMAND ${CMAKE_COMMAND} -E make_directory
+              $<TARGET_FILE_DIR:${target}>/../resources
+            COMMAND ${CMAKE_COMMAND} -E copy_if_different
+              ${resources}
+              $<TARGET_FILE_DIR:${target}>/../resources
+        )
+
+        # See important comment and TODO:s starting at line 365
+        # in ./vkloadtests.cmake regarding installation of these
+        # targets. Search for "keep the resources".
+
+        set_target_properties( ${target} PROPERTIES
+            INSTALL_RPATH "\$ORIGIN;${CMAKE_INSTALL_FULL_LIBDIR}"
+        )
+
+        ######### IMPORTANT ######
+        # When installing via `cmake --install` ALSO install the
+        # library component. There seems no way to make a dependency.
+        ##########################
+#        set( destroot "${LOAD_TEST_DESTROOT}/$<TARGET_FILE_NAME:${target}>")
+        # NOTE: WHEN RUNNING MANUAL INSTALLS INSTALL library COMPONENT TOO.
+#        install(TARGETS ${target}
+#            RUNTIME
+#                DESTINATION ${destroot}/bin
+#                COMPONENT GlLoadTestApps
+#            LIBRARY
+#                DESTINATION ${CMAKE_INSTALL_LIBDIR}
+#                COMPONENT GlLoadTestApps
+#            RESOURCE
+#                DESTINATION ${destroot}/resources
+#                COMPONENT GlLoadTestApps
+#        )
+#        install(TARGETS ktx
+#            RUNTIME
+#                DESTINATION ${destroot}/bin
+#                COMPONENT GlLoadTestApps
+#            LIBRARY
+#                DESTINATION ${destroot}/lib
+#                COMPONENT GlLoadTestApps
+#        )
+#        if(LINUX)
+#            # Add a link from the regular bin directory to put command
+#            # on PATH.
+#            install(CODE "
+#               EXECUTE_PROCESS(COMMAND ln -s ${destroot}/bin/$<TARGET_FILE_NAME:${target}> ${CMAKE_INSTALL_FULL_BINDIR}
+#               )"
+#               COMPONENT GlLoadTestApps
+#            )
+#            install(FILES
+#                ${CMAKE_CURRENT_BINARY_DIR}/${target}.desktop
+#                DESTINATION /usr/share/applications
+#                COMPONENT GlLoadTestApps
+#            )
+#        endif(LINUX)
+    endif()
+endfunction( create_gl_target target )
+
+
+set( ES1_TEST_IMAGES
+    no-npot.ktx
+    hi_mark.ktx
+    luminance-reference-metadata.ktx
+    orient-up-metadata.ktx
+    orient-down-metadata.ktx
+    etc1.ktx
+    etc2-rgb.ktx
+    etc2-rgba1.ktx
+    etc2-rgba8.ktx
+    rgba-reference.ktx
+    rgb-reference.ktx
+    rgb-amg-reference.ktx
+    rgb-mipmap-reference.ktx
+    hi_mark_sq.ktx
+)
+list( TRANSFORM ES1_TEST_IMAGES
+    PREPEND "${PROJECT_SOURCE_DIR}/tests/testimages/"
+)
+
+set( ES1_SOURCES
+    glloadtests/gles1/ES1LoadTests.cpp
+    glloadtests/gles1/DrawTexture.cpp
+    glloadtests/gles1/DrawTexture.h
+    glloadtests/gles1/TexturedCube.cpp
+    glloadtests/gles1/TexturedCube.h
+)
+
+set( GL3_TEST_IMAGES
+    etc1s_Iron_Bars_001_normal.ktx2
+    uastc_Iron_Bars_001_normal.ktx2
+    color_grid_uastc_zstd.ktx2
+    color_grid_zstd.ktx2
+    color_grid_uastc.ktx2
+    color_grid_basis.ktx2
+    kodim17_basis.ktx2
+    kodim17_basis.ktx2
+    FlightHelmet_baseColor_basis.ktx2
+    rgba-reference-u.ktx2
+    rgba-reference-u.ktx2
+    rgba-reference-u.ktx2
+    cubemap_goldengate_uastc_rdo4_zstd5_rd.ktx2
+    cubemap_yokohama_basis_rd.ktx2
+    orient-down-metadata-u.ktx2
+    orient-down-metadata-u.ktx2
+    texturearray_bc3_unorm.ktx2
+    texturearray_astc_8x8_unorm.ktx2
+    texturearray_etc2_unorm.ktx2
+    3dtex_7_reference_u.ktx2
+    rgb-mipmap-reference-u.ktx2
+    hi_mark.ktx
+    orient-up-metadata.ktx
+    orient-down-metadata.ktx
+    not4_rgb888_srgb.ktx
+    etc1.ktx
+    etc2-rgb.ktx
+    etc2-rgba1.ktx
+    etc2-rgba8.ktx
+    etc2-sRGB.ktx
+    etc2-sRGBa1.ktx
+    etc2-sRGBa8.ktx
+    rgba-reference.ktx
+    rgb-reference.ktx
+    conftestimage_R11_EAC.ktx
+    conftestimage_SIGNED_R11_EAC.ktx
+    conftestimage_RG11_EAC.ktx
+    conftestimage_SIGNED_RG11_EAC.ktx
+    texturearray_bc3_unorm.ktx
+    texturearray_astc_8x8_unorm.ktx
+    texturearray_etc2_unorm.ktx
+    rgb-amg-reference.ktx
+    rgb-mipmap-reference.ktx
+    hi_mark_sq.ktx
+)
+list( TRANSFORM GL3_TEST_IMAGES
+    PREPEND "${PROJECT_SOURCE_DIR}/tests/testimages/"
+)
+set( GL3_RESOURCE_FILES ${LOAD_TEST_COMMON_RESOURCE_FILES} ${GL3_TEST_IMAGES} )
+
+set( GL3_SOURCES
+    common/TranscodeTargetStrToFmt.cpp
+    common/TranscodeTargetStrToFmt.h
+    common/disable_glm_warnings.h
+    common/reenable_warnings.h
+    glloadtests/shader-based/DrawTexture.cpp
+    glloadtests/shader-based/DrawTexture.h
+    glloadtests/shader-based/EncodeTexture.cpp
+    glloadtests/shader-based/EncodeTexture.h
+    glloadtests/shader-based/GL3LoadTests.cpp
+    glloadtests/shader-based/GL3LoadTestSample.cpp
+    glloadtests/shader-based/GL3LoadTestSample.h
+    glloadtests/shader-based/InstancedSampleBase.cpp
+    glloadtests/shader-based/InstancedSampleBase.h
+    glloadtests/shader-based/mygl.h
+    glloadtests/shader-based/shaders.cpp
+    glloadtests/shader-based/Texture3d.cpp
+    glloadtests/shader-based/Texture3d.h
+    glloadtests/shader-based/TextureArray.cpp
+    glloadtests/shader-based/TextureArray.h
+    glloadtests/shader-based/TextureMipmap.cpp
+    glloadtests/shader-based/TextureMipmap.h
+    glloadtests/shader-based/TextureCubemap.cpp
+    glloadtests/shader-based/TextureCubemap.h
+    glloadtests/shader-based/TexturedCube.cpp
+    glloadtests/shader-based/TexturedCube.h
+    glloadtests/utils/GLMeshLoader.hpp
+    glloadtests/utils/GLTextureTranscoder.hpp
+)
+
+
+if(WIN32)
+    if(NOT OPENGL_ES_EMULATOR)
+        message("OPENGL_ES_EMULATOR not set. Will not build OpenGL ES load tests applications.")
+    else()
+        set(EMULATE_GLES ON)
+    endif()
+endif()
+
+if(IOS OR EMULATE_GLES)
+    # OpenGL ES 1.0
+    create_gl_target( es1loadtests "ES1" "${ES1_SOURCES}" "${KTX_APP_ICON_PATH}" "${ES1_TEST_IMAGES}" SDL_GL_CONTEXT_PROFILE_ES 1 0 ON)
+endif()
+
+if(IOS OR EMSCRIPTEN OR EMULATE_GLES)
+    # OpenGL ES 3.0
+    create_gl_target( es3loadtests "ES3" "${GL3_SOURCES}" "${LOAD_TEST_COMMON_RESOURCE_FILES}" "${GL3_TEST_IMAGES}" SDL_GL_CONTEXT_PROFILE_ES 3 0 ON YES)
+endif()
+
+if( (APPLE AND NOT IOS) OR LINUX OR WIN32 )
+    # OpenGL 3.3
+    create_gl_target( gl3loadtests "GL3" "${GL3_SOURCES}" "${LOAD_TEST_COMMON_RESOURCE_FILES}" "${GL3_TEST_IMAGES}" SDL_GL_CONTEXT_PROFILE_CORE 3 3 OFF YES)
+endif()
+

third_party/ktx-src/tests/loadtests/glloadtests/GLLoadTests.cpp

@@ -0,0 +1,313 @@
+/* -*- tab-width: 4; -*- */
+/* vi: set sw=2 ts=4 expandtab: */
+
+/*
+ * Copyright 2015-2020 Mark Callow.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @internal
+ * @file
+ * @~English
+ *
+ * @brief Implementation of app for running a set of OpenGL load tests.
+ */
+
+#include <exception>
+#include <sstream>
+#include <ktx.h>
+
+#include "GLLoadTests.h"
+#include "ltexceptions.h"
+
+GLLoadTests::GLLoadTests(const sampleInvocation samples[],
+                         const uint32_t numSamples,
+                         const char* const name,
+                         const SDL_GLProfile profile,
+                         const int majorVersion,
+                         const int minorVersion)
+                : GLAppSDL(name, 640, 480, profile, majorVersion, minorVersion),
+                  siSamples(samples), sampleIndex(numSamples)
+{
+    pCurSample = nullptr;
+}
+
+GLLoadTests::~GLLoadTests()
+{
+    delete pCurSample;
+}
+
+bool
+GLLoadTests::initialize(Args& args)
+{
+    bool explicitlyLoadOpenGL = false;
+    for (uint32_t i = 1; i < args.size(); i++) {
+        if (args[i].compare("--load-gl") == 0) {
+            explicitlyLoadOpenGL = true;
+            args.erase(args.begin() + i);
+            break;
+        }
+    }
+
+    if (!GLAppSDL::initialize(args))
+        return false;
+
+    // --load-gl allows testing of explicitly loading the OpenGL pointers.
+    // Default is for ktxTexture_GLUpload to implicitly load them.
+    if (explicitlyLoadOpenGL)
+        ktxLoadOpenGL(reinterpret_cast<PFNGLGETPROCADDRESS>(SDL_GL_GetProcAddress));
+
+    for (auto it = args.begin() + 1; it != args.end(); it++) {
+        infiles.push_back(*it);
+    }
+    if (infiles.size() > 0) {
+        sampleIndex.setNumSamples((uint32_t)infiles.size());
+    }
+    // Launch the first sample.
+    invokeSample(Direction::eForward);
+    return true;
+}
+
+
+void
+GLLoadTests::finalize()
+{
+    delete pCurSample;
+    GLAppSDL::finalize();
+}
+
+
+bool
+GLLoadTests::doEvent(SDL_Event* event)
+{
+    bool result = false;
+    switch (event->type) {
+      case SDL_EVENT_KEY_UP:
+        switch (event->key.key) {
+          case 'q':
+            quit = true;
+            break;
+          case 'n':
+            ++sampleIndex;
+            invokeSample(Direction::eForward);
+            break;
+          case 'p':
+            --sampleIndex;
+            invokeSample(Direction::eBack);
+            break;
+          default:
+            result = true;
+        }
+        break;
+      case SDL_EVENT_MOUSE_BUTTON_DOWN:
+        // Forward to sample in case this is the start of motion.
+        result = true;
+        switch (event->button.button) {
+          case SDL_BUTTON_LEFT:
+            buttonDown.x = event->button.x;
+            buttonDown.y = event->button.y;
+            buttonDown.timestamp = event->button.timestamp;
+            break;
+          default:
+            break;
+        }
+        break;
+      case SDL_EVENT_MOUSE_BUTTON_UP:
+        // Forward to sample so it doesn't get stuck in button down state.
+        result = true;
+        switch (event->button.button) {
+          case SDL_BUTTON_LEFT:
+            if (SDL_fabs(event->button.x - buttonDown.x) < 5
+                && SDL_fabs(event->button.y - buttonDown.y) < 5
+                && (event->button.timestamp - buttonDown.timestamp) < 100) {
+                // Advance to the next sample.
+                ++sampleIndex;
+                invokeSample(Direction::eForward);
+            }
+            break;
+          default:
+            break;
+        }
+        break;
+      // On macOS drop events come also when Launch Pad sends a file open event.
+      case SDL_EVENT_DROP_BEGIN:
+        // Opens of multiple selected files from Finder/LaunchPad come as
+        // a BEGIN, COMPLETE sequence per file. Only clear infiles after a
+        // suitable pause between COMPLETE and BEGIN.
+        if (event->drop.timestamp - dropCompleteTime > 500) {
+            infiles.clear();
+        }
+        break;
+      case SDL_EVENT_DROP_FILE:
+        infiles.push_back(event->drop.data);
+        break;
+      case SDL_EVENT_DROP_COMPLETE:
+        if (!infiles.empty()) {
+            // Guard against the drop being text.
+            dropCompleteTime = event->drop.timestamp;
+            sampleIndex.setNumSamples((uint32_t)infiles.size());
+            invokeSample(Direction::eForward);
+        }
+        break;
+      case SDL_EVENT_USER:
+        if (event->user.code == SwipeDetector::swipeGesture) {
+            // This is horrible.
+            uint64_t udirection = reinterpret_cast<uint64_t>(event->user.data1);
+            SwipeDetector::Direction direction =
+              static_cast<SwipeDetector::Direction>(udirection);
+            switch (direction) {
+              case SwipeDetector::Direction::left:
+                ++sampleIndex;
+                invokeSample(Direction::eForward);
+                break;
+              case SwipeDetector::Direction::right:
+                --sampleIndex;
+                invokeSample(Direction::eBack);
+                break;
+              default:
+                result = true;
+            }
+        } else {
+            result = true;
+        }
+        break;
+      default:
+        result = swipeDetector.doEvent(event);
+    }
+    
+    if (result) {
+        // Further processing required.
+        if (pCurSample != nullptr)
+            result = pCurSample->doEvent(event);  // Give sample a chance.
+        if (result)
+            return GLAppSDL::doEvent(event);  // Pass to base class.
+    }
+    return result;
+}
+
+
+void
+GLLoadTests::windowResized()
+{
+    if (pCurSample != nullptr)
+        pCurSample->resize(w_width, w_height);
+}
+
+
+void
+GLLoadTests::drawFrame(uint32_t msTicks)
+{
+    if (pCurSample != nullptr)
+        pCurSample->run(msTicks);
+
+    GLAppSDL::drawFrame(msTicks);
+}
+
+#if 0
+void
+GLLoadTests::getOverlayText(GLTextOverlay * textOverlay)
+{
+    if (enableTextOverlay && pCurSample != nullptr) {
+        pCurSample->getOverlayText(textOverlay);
+    }
+}
+#endif
+
+void
+GLLoadTests::invokeSample(Direction dir)
+{
+    const sampleInvocation* sampleInv = &siSamples[sampleIndex];
+
+    delete pCurSample;
+    // Certain events can be triggered during new sample initialization
+    // while pCurSample is not valid, e.g. FOCUS_LOST. Protect against
+    // problems from this by indicating there is no current sample.
+    pCurSample = nullptr;
+
+    uint32_t unsupportedTypeExceptions = 0;
+    std::string fileTitle;
+    for (;;) {
+        try {
+            if (infiles.size() > 0) {
+                fileTitle = "Viewing file ";
+                fileTitle += infiles[sampleIndex];
+                pCurSample = showFile(infiles[sampleIndex]);
+            } else {
+                sampleInv = &siSamples[sampleIndex];
+                pCurSample = sampleInv->createSample(w_width, w_height,
+                                                     sampleInv->args,
+                                                     sBasePath);
+            }
+            break;
+        } catch (unsupported_ctype& e) {
+            (void)e; // To quiet unused variable warnings from some compilers.
+            unsupportedTypeExceptions++;
+            if (unsupportedTypeExceptions == sampleIndex.getNumSamples()) {
+                SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR,
+                    infiles.size() > 0 ? fileTitle.c_str() : sampleInv->title,
+                    "None of the specified samples or files use texture types "
+                    "supported on this platform.",
+                    NULL);
+                exit(0);
+            } else {
+                dir == Direction::eForward ? ++sampleIndex : --sampleIndex;
+            }
+        } catch (std::exception& e) {
+            const SDL_MessageBoxButtonData buttons[] = {
+                /* .flags, .buttonid, .text */
+                { SDL_MESSAGEBOX_BUTTON_RETURNKEY_DEFAULT, 0, "Continue" },
+                { SDL_MESSAGEBOX_BUTTON_ESCAPEKEY_DEFAULT, 1, "Abort" },
+            };
+#if 0
+            const SDL_MessageBoxColorScheme colorScheme = {
+                { /* .colors (.r, .g, .b) */
+                    /* [SDL_MESSAGEBOX_COLOR_BACKGROUND] */
+                    { 255,   0,   0 },
+                    /* [SDL_MESSAGEBOX_COLOR_TEXT] */
+                    {   0, 255,   0 },
+                    /* [SDL_MESSAGEBOX_COLOR_BUTTON_BORDER] */
+                    { 255, 255,   0 },
+                    /* [SDL_MESSAGEBOX_COLOR_BUTTON_BACKGROUND] */
+                    {   0,   0, 255 },
+                    /* [SDL_MESSAGEBOX_COLOR_BUTTON_SELECTED] */
+                    { 255,   0, 255 }
+                }
+            };
+#endif
+            const SDL_MessageBoxData messageboxdata = {
+                SDL_MESSAGEBOX_ERROR,                               // .flags
+                NULL,                                               // .window
+                infiles.size() > 0 ?
+                 fileTitle.c_str() : sampleInv->title,              // .title
+                e.what(),                                           // .message
+                SDL_arraysize(buttons),                             // .numbuttons
+                buttons,                                            // .buttons
+                NULL //&colorScheme                                 // .colorScheme
+            };
+            int buttonid;
+            if (!SDL_ShowMessageBox(&messageboxdata, &buttonid)) {
+                SDL_Log("error displaying error message box");
+                exit(1);
+            }
+            if (buttonid == 0) {
+                // Continue
+                dir == Direction::eForward ? ++sampleIndex : --sampleIndex;
+            } else {
+                // We've been told to quit or no button was pressed.
+                exit(1);
+            }
+        }
+    }
+    setAppTitle(infiles.size() > 0 ? fileTitle.c_str()  : sampleInv->title);
+    pCurSample->resize(w_width, w_height);
+}
+
+void
+GLLoadTests::onFPSUpdate()
+{
+    // Using onFPSUpdate avoids rewriting the title every frame.
+    //setWindowTitle(pCurSample->title);
+    GLAppSDL::onFPSUpdate();
+}
+

third_party/ktx-src/tests/loadtests/glloadtests/GLLoadTests.h

@@ -0,0 +1,100 @@
+/* -*- tab-width: 4; -*- */
+/* vi: set sw=2 ts=4 expandtab: */
+
+#ifndef GL_LOAD_TESTS_H
+#define GL_LOAD_TESTS_H
+
+/*
+ * Copyright 2015-2020 Mark Callow.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @internal
+ * @file
+ * @~English
+ *
+ * @brief Definition of app for running a set of OpenGL load tests.
+ */
+
+#include <string>
+#include <vector>
+
+#include "GLAppSDL.h"
+#include "LoadTestSample.h"
+#include "SwipeDetector.h"
+
+class GLLoadTests : public GLAppSDL {
+  public:
+    /** A table of samples and arguments */
+    typedef struct sampleInvocation_ {
+        const LoadTestSample::PFN_create createSample;
+        const char* const args;
+        const char* const title;
+    } sampleInvocation;
+    
+    GLLoadTests(const sampleInvocation samples[],
+                const uint32_t numSamples,
+                const char* const name,
+                const SDL_GLProfile profile,
+                const int majorVersion,
+                const int minorVersion);
+    virtual ~GLLoadTests();
+    virtual bool doEvent(SDL_Event* event);
+    virtual void drawFrame(uint32_t msTicks);
+    virtual void finalize();
+    //virtual void getOverlayText(TextOverlay* textOverlay, float yOffset);
+    virtual bool initialize(Args& args);
+    virtual void onFPSUpdate();
+    virtual void windowResized();
+
+  protected:
+    enum class Direction {
+        eForward,
+        eBack
+    };
+    void invokeSample(Direction dir);
+    LoadTestSample* showFile(const std::string& filename);
+    LoadTestSample* pCurSample;
+
+    bool quit = false;
+
+    const sampleInvocation* const siSamples;
+    class sampleIndex {
+      public:
+        sampleIndex(const uint32_t numSamples) : numSamples(numSamples) {
+            index = 0;
+        }
+        sampleIndex& operator++() {
+            if (++index >= numSamples)
+                index = 0;
+            return *this;
+        }
+        sampleIndex& operator--() {
+            if (--index > numSamples /* underflow */)
+                index = numSamples-1;
+            return *this;
+        }
+        operator int32_t() {
+            return index;
+        }
+        uint32_t getNumSamples() { return numSamples; }
+        void setNumSamples(uint32_t ns) { numSamples = ns; }
+      protected:
+        uint32_t numSamples;
+        uint32_t index;
+    } sampleIndex;
+
+    std::vector<std::string> infiles;
+    
+    Sint64 dropCompleteTime = 0;
+    struct {
+        float x;
+        float y;
+        Sint64 timestamp;
+    } buttonDown;
+
+    SwipeDetector swipeDetector;
+};
+
+#endif /* GL_LOAD_TESTS_H */

third_party/ktx-src/tests/loadtests/glloadtests/gles1/DrawTexture.cpp

@@ -0,0 +1,250 @@
+/* -*- tab-width: 4; -*- */
+/* vi: set sw=2 ts=4 expandtab: */
+
+/*
+ * Copyright 2018-2020 Mark Callow.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @file    DrawTexture.cpp
+ * @brief   Draw textures at actual size using the DrawTexture functions
+ *          from OES_draw_texture.
+ *
+ * @author  Mark Callow
+ */
+
+
+#if defined(_WIN32)
+  #if _MSC_VER < 1900
+    #define snprintf _snprintf
+  #endif
+  #define _CRT_SECURE_NO_WARNINGS
+#endif
+
+#include <iomanip>
+#include <sstream>
+#include <ktx.h>
+#include "disable_glm_warnings.h"
+#include <glm/gtc/matrix_transform.hpp>
+#include <glm/gtc/type_ptr.hpp>
+#include "reenable_warnings.h"
+
+#include "DrawTexture.h"
+#include "frame.h"
+
+/* ------------------------------------------------------------------------ */
+
+#if 0
+static int isPowerOfTwo (int x)
+{
+   if (x < 0) x = -1;
+   return ((x != 0) && !(x & (x - 1)));
+}
+#endif
+
+/* ------------------------------------------------------------------------ */
+
+LoadTestSample*
+DrawTexture::create(uint32_t width, uint32_t height,
+                    const char* const szArgs,
+                    const std::string sBasePath)
+{
+    return new DrawTexture(width, height, szArgs, sBasePath);
+}
+
+DrawTexture::DrawTexture(uint32_t width, uint32_t height,
+                         const char* const szArgs,
+                         const std::string sBasePath)
+        : LoadTestSample(width, height, sBasePath)
+{
+    GLint           iCropRect[4] = {0, 0, 0, 0};
+    const GLchar*  szExtensions  = (const GLchar*)glGetString(GL_EXTENSIONS);
+    const char* filename;
+    std::string pathname;
+    GLenum target;
+    GLboolean npotTexture;
+    GLenum glerror;
+    ktxTexture* kTexture;
+    KTX_error_code ktxresult;
+    GLint sign_s = 1, sign_t = 1;
+
+    bInitialized = false;
+    gnTexture = 0;
+
+
+    if (strstr(szExtensions, "OES_draw_texture") != NULL) {
+       glDrawTexsOES = (PFNGLDRAWTEXSOESPROC)SDL_GL_GetProcAddress("glDrawTexsOES");
+       glDrawTexiOES = (PFNGLDRAWTEXIOESPROC)SDL_GL_GetProcAddress("glDrawTexiOES");
+       glDrawTexxOES = (PFNGLDRAWTEXXOESPROC)SDL_GL_GetProcAddress("glDrawTexxOES");
+       glDrawTexfOES = (PFNGLDRAWTEXFOESPROC)SDL_GL_GetProcAddress("glDrawTexfOES");
+       glDrawTexsvOES = (PFNGLDRAWTEXSVOESPROC)SDL_GL_GetProcAddress("glDrawTexsvOES");
+       glDrawTexivOES = (PFNGLDRAWTEXIVOESPROC)SDL_GL_GetProcAddress("glDrawTexivOES");
+       glDrawTexxvOES = (PFNGLDRAWTEXXVOESPROC)SDL_GL_GetProcAddress("glDrawTexxvOES");
+       glDrawTexfvOES = (PFNGLDRAWTEXFVOESPROC)SDL_GL_GetProcAddress("glDrawTexfvOES");
+    } else {
+        /* Can't do anything */
+        std::stringstream message;
+
+        message << "DrawTexture: this OpenGL ES implementation does not support"
+                << " OES_draw_texture. Can't Run Test";
+        throw std::runtime_error(message.str());
+    }
+  
+    if (strstr(szExtensions, "OES_texture_npot") != NULL)
+       bNpotSupported = GL_TRUE;
+    else
+       bNpotSupported = GL_FALSE;
+
+
+    if ((filename = strchr(szArgs, ' ')) != NULL) {
+        npotTexture = GL_FALSE;
+        if (!strncmp(szArgs, "--npot ", 7)) {
+            npotTexture = GL_TRUE;
+#if defined(DEBUG)
+        } else {
+            assert(0); /* Unknown argument in sampleInvocations */
+#endif
+        }
+    } else {
+        filename = szArgs;
+        npotTexture = GL_FALSE;
+    }
+
+    if (npotTexture  && !bNpotSupported) {
+        /* Load error texture. */
+        filename = "no-npot.ktx";
+    }
+    
+    pathname = getAssetPath() + filename;
+    
+    ktxresult = ktxTexture_CreateFromNamedFile(pathname.c_str(),
+                                               KTX_TEXTURE_CREATE_NO_FLAGS,
+                                               &kTexture);
+    if (KTX_SUCCESS != ktxresult) {
+        std::stringstream message;
+
+        message << "Creation of ktxTexture from \"" << pathname
+                << "\" failed: " << ktxErrorString(ktxresult);
+        throw std::runtime_error(message.str());
+    }
+    ktxresult = ktxTexture_GLUpload(kTexture, &gnTexture, &target, &glerror);
+
+    if (KTX_SUCCESS == ktxresult) {
+        if (target != GL_TEXTURE_2D) {
+            /* Can only draw 2D textures */
+            glDeleteTextures(1, &gnTexture);
+            return;
+        }
+
+        if (kTexture->orientation.x == KTX_ORIENT_X_LEFT)
+            sign_s = -1;
+        if (kTexture->orientation.y == KTX_ORIENT_Y_DOWN)
+            sign_t = -1;
+
+        iCropRect[2] = uTexWidth = kTexture->baseWidth;
+        iCropRect[3] = uTexHeight = kTexture->baseHeight;
+        iCropRect[2] *= sign_s;
+        iCropRect[3] *= sign_t;
+
+        glEnable(target);
+
+        if (kTexture->numLevels > 1)
+            // Enable bilinear mipmapping.
+            // TO DO: application can consider inserting a key,value pair in
+            // the KTX file that indicates what type of filtering to use.
+            glTexParameteri(target,
+                            GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST);
+        else
+            glTexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+        glTexParameteri(target, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+
+        glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
+        glTexParameteriv(target, GL_TEXTURE_CROP_RECT_OES, iCropRect);
+
+        /* Check for any errors */
+        assert(GL_NO_ERROR == glGetError());
+
+        ktxTexture_Destroy(kTexture);
+    } else {
+        std::stringstream message;
+
+        message << "Load of texture from \"" << pathname << "\" failed: ";
+        if (ktxresult == KTX_GL_ERROR) {
+            message << std::showbase << "GL error " << std::hex << glerror
+                    << "occurred.";
+        } else {
+            message << ktxErrorString(ktxresult);
+        }
+        throw std::runtime_error(message.str());
+    }
+
+    glClearColor(0.4f, 0.4f, 0.5f, 1.0f);
+    glColor4f(1.0f, 1.0f, 0.0f, 1.0f);
+    glEnableClientState(GL_VERTEX_ARRAY);
+    glVertexPointer(3, GL_BYTE, 0, (GLvoid *)frame_position);
+
+    bInitialized = GL_TRUE;
+}
+
+/* ------------------------------------------------------------------------ */
+
+DrawTexture::~DrawTexture()
+{
+    if (bInitialized) {
+        glDeleteTextures(1, &gnTexture);
+    }
+    assert(GL_NO_ERROR == glGetError());
+}
+
+/* ------------------------------------------------------------------------ */
+
+void
+DrawTexture::resize(uint32_t uNewWidth, uint32_t uNewHeight)
+{
+    glViewport(0, 0, uNewWidth, uNewHeight);
+    this->uWidth = uNewWidth;
+    this->uHeight = uNewHeight;
+
+    // Set up an orthographic projection where 1 = 1 pixel
+    framePMatrix = glm::ortho(0.f, (float)uWidth, 0.f, (float)uHeight);
+    // Move (0,0,0) to the center of the window.
+    framePMatrix *= glm::translate(glm::mat4(),
+                              glm::vec3((float)uWidth/2, (float)uHeight/2, 0));
+
+    glMatrixMode(GL_PROJECTION);
+    glLoadMatrixf(glm::value_ptr(framePMatrix));
+
+    glMatrixMode(GL_MODELVIEW);
+    // Scale the frame to fill the viewport. To guarantee its lines
+    // appear we need to inset them by half-a-pixel hence the -1.
+    // [Lines at the edges of the clip volume may or may not appear
+    // depending on the OpenGL ES implementation. This is because
+    // (a) the edges are on the points of the diamonds of the diamond
+    //     exit rule and slight precision errors can easily push the
+    //     lines outside the diamonds.
+    // (b) the specification allows lines to be up to 1 pixel either
+    //     side of the exact position.]
+    glLoadIdentity();
+    glScalef((float)(uWidth - 1) / 2, (float)(uHeight - 1) / 2, 1);
+}
+
+/* ------------------------------------------------------------------------ */
+
+void
+DrawTexture::run(uint32_t /*msTicks*/)
+{
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+    glDisable(GL_TEXTURE_2D);
+    glDrawArrays(GL_LINE_LOOP, 0, 4);
+
+    glEnable(GL_TEXTURE_2D);
+    glDrawTexiOES(uWidth/2 - uTexWidth/2,
+                         (uHeight)/2 - uTexHeight/2,
+                         0,
+                         uTexWidth, uTexHeight);
+
+    assert(GL_NO_ERROR == glGetError());
+}
+
+/* ------------------------------------------------------------------------ */

third_party/ktx-src/tests/loadtests/glloadtests/gles1/DrawTexture.h

@@ -0,0 +1,66 @@
+/* -*- tab-width: 4; -*- */
+/* vi: set sw=2 ts=4 expandtab: */
+
+/*
+ * Copyright 2018-2020 Mark Callow.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @file    DrawTexture.h
+ * @brief   Draw textures at actual size using the DrawTexture functions
+ *          from OES_draw_texture.
+ *
+ * @author  Mark Callow
+ */
+
+#ifndef DRAW_TEXTURE_H
+#define DRAW_TEXTURE_H
+
+#include <GLES/gl.h>
+#include <GLES/glext.h>
+
+#include "LoadTestSample.h"
+
+class DrawTexture : public LoadTestSample {
+  public:
+    DrawTexture(uint32_t width, uint32_t height,
+                const char* const szArgs,
+                const std::string sBasePath);
+    ~DrawTexture();
+
+    virtual void resize(uint32_t width, uint32_t height);
+    virtual void run(uint32_t msTicks);
+
+    //virtual void getOverlayText(GLTextOverlay *textOverlay);
+
+    static LoadTestSample*
+    create(uint32_t width, uint32_t height,
+           const char* const szArgs, const std::string sBasePath);
+
+  protected:
+     PFNGLDRAWTEXSOESPROC glDrawTexsOES;
+     PFNGLDRAWTEXIOESPROC glDrawTexiOES;
+     PFNGLDRAWTEXXOESPROC glDrawTexxOES;
+     PFNGLDRAWTEXFOESPROC glDrawTexfOES;
+     PFNGLDRAWTEXSVOESPROC glDrawTexsvOES;
+     PFNGLDRAWTEXIVOESPROC glDrawTexivOES;
+     PFNGLDRAWTEXXVOESPROC glDrawTexxvOES;
+     PFNGLDRAWTEXFVOESPROC glDrawTexfvOES;
+
+    uint32_t uWidth;
+    uint32_t uHeight;
+
+    uint32_t uTexWidth;
+    uint32_t uTexHeight;
+
+    glm::mat4 framePMatrix;
+
+    GLuint gnTexture;
+
+    bool bNpotSupported;
+
+    bool bInitialized;
+};
+
+#endif /* DRAW_TEXTURE_H */

third_party/ktx-src/tests/loadtests/glloadtests/gles1/ES1LoadTests.cpp

@@ -0,0 +1,109 @@
+/* -*- tab-width: 4; -*- */
+/* vi: set sw=2 ts=4 expandtab: */
+
+/*
+ * Copyright 2018-2020 Mark Callow.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @file    ES1LoadTests.cpp
+ * @brief  List of tests of the KTX loader for OpenGL ES 1.1.
+ *
+ * The loader is tested by loading and drawing KTX textures in various formats
+ * using the DrawTexture and TexturedCube samples.
+ */
+
+#include <sstream>
+#include <ktx.h>
+
+#include "GLLoadTests.h"
+#include "DrawTexture.h"
+#include "TexturedCube.h"
+
+LoadTestSample*
+GLLoadTests::showFile(const std::string& filename)
+{
+    KTX_error_code ktxresult;
+    ktxTexture* kTexture;
+    ktxresult = ktxTexture_CreateFromNamedFile(filename.c_str(),
+                                        KTX_TEXTURE_CREATE_NO_FLAGS,
+                                        &kTexture);
+    if (KTX_SUCCESS != ktxresult) {
+        std::stringstream message;
+
+        message << "Creation of ktxTexture from \"" << getAssetPath()
+                << filename << "\" failed: " << ktxErrorString(ktxresult);
+        throw std::runtime_error(message.str());
+    }
+
+    LoadTestSample::PFN_create createViewer;
+    LoadTestSample* pViewer;
+    createViewer = DrawTexture::create;
+    ktxTexture_Destroy(kTexture);
+    pViewer = createViewer(w_width, w_height, filename.c_str(), "");
+    return pViewer;
+}
+
+const GLLoadTests::sampleInvocation siSamples[] = {
+    { DrawTexture::create,
+      "--npot hi_mark.ktx",
+      "RGB8 NPOT HI Logo"
+    },
+    { DrawTexture::create,
+      "--npot luminance-reference-metadata.ktx",
+      "LUMINANCE8 NPOT"
+    },
+    { DrawTexture::create,
+      "orient-up-metadata.ktx",
+      "RGB8 + KTXOrientation up"
+    },
+    { DrawTexture::create,
+      "orient-down-metadata.ktx",
+      "RGB8 + KTXOrientation down"
+    },
+    { DrawTexture::create,
+      "etc1.ktx",
+      "ETC1 RGB8"
+    },
+    { DrawTexture::create,
+      "etc2-rgb.ktx",
+      "ETC2 RGB8"
+    },
+    { DrawTexture::create,
+      "etc2-rgba1.ktx",
+      "ETC2 RGB8A1"
+    },
+    { DrawTexture::create,
+      "etc2-rgba8.ktx",
+      "ETC2 RGB8A8"
+    },
+    { DrawTexture::create,
+      "rgba-reference.ktx",
+      "RGBA8"
+    },
+    { TexturedCube::create,
+      "rgb-reference.ktx",
+      "RGB8"
+    },
+    { TexturedCube::create,
+      "rgb-amg-reference.ktx",
+      "RGB8 + Auto Mipmap"
+    },
+    { TexturedCube::create,
+      "rgb-mipmap-reference.ktx",
+      "RGB8 Color/level mipmap"
+    },
+    { TexturedCube::create,
+      "--npot hi_mark_sq.ktx",
+      "RGB8 NPOT HI Logo"
+    },
+};
+
+const int iNumSamples = sizeof(siSamples) / sizeof(GLLoadTests::sampleInvocation);
+
+AppBaseSDL* theApp = new GLLoadTests(siSamples, iNumSamples,
+                                         "KTX Loader Tests for OpenGL ES 1",
+                                         SDL_GL_CONTEXT_PROFILE_ES, 1, 1);
+
+

third_party/ktx-src/tests/loadtests/glloadtests/gles1/TexturedCube.cpp

@@ -0,0 +1,202 @@
+/* -*- tab-width: 4; -*- */
+/* vi: set sw=2 ts=4 expandtab: */
+
+/*
+ * Copyright 2018-2020 Mark Callow.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @file    TexturedCube.cpp
+ * @brief    Draw a textured cube.
+ */
+
+#if defined(_WIN32)
+  #if _MSC_VER < 1900
+    #define snprintf _snprintf
+  #endif
+  #define _CRT_SECURE_NO_WARNINGS
+#endif
+
+#include <iomanip>
+#include <sstream>
+#include <ktx.h>
+#include "disable_glm_warnings.h"
+#include <glm/gtc/matrix_transform.hpp>
+#include <glm/gtc/type_ptr.hpp>
+#include "reenable_warnings.h"
+
+#include "TexturedCube.h"
+#include "cube.h"
+
+
+#if defined(_WIN32)
+#define snprintf _snprintf
+#endif
+
+/* ------------------------------------------------------------------------- */
+
+LoadTestSample*
+TexturedCube::create(uint32_t width, uint32_t height,
+                    const char* const szArgs,
+                    const std::string sBasePath)
+{
+    return new TexturedCube(width, height, szArgs, sBasePath);
+}
+
+TexturedCube::TexturedCube(uint32_t width, uint32_t height,
+                         const char* const szArgs,
+                         const std::string sBasePath)
+        : LoadTestSample(width, height, sBasePath)
+{
+    const GLchar*  szExtensions = (const GLchar*)glGetString(GL_EXTENSIONS);
+    const char* filename;
+    std::string pathname;
+    GLuint gnTexture = 0;
+    GLenum target;
+    GLenum glerror;
+    GLboolean npotSupported, npotTexture;
+    ktxTexture* kTexture;
+    KTX_error_code ktxresult;
+
+    if (strstr(szExtensions, "OES_texture_npot") != NULL)
+        npotSupported = GL_TRUE;
+    else
+        npotSupported = GL_FALSE;
+    
+    if ((filename = strchr(szArgs, ' ')) != NULL) {
+        npotTexture = GL_FALSE;
+        if (!strncmp(szArgs, "--npot ", 7)) {
+            npotTexture = GL_TRUE;
+#if defined(DEBUG)
+        } else {
+            assert(0); /* Unknown argument in sampleInvocations */
+#endif
+        }
+    } else {
+        filename = szArgs;
+        npotTexture = GL_FALSE;
+    }
+    
+    if (npotTexture  && !npotSupported) {
+        /* Load error texture. */
+        filename = "no-npot.ktx";
+    }
+    pathname = getAssetPath() + filename;
+
+    ktxresult = ktxTexture_CreateFromNamedFile(pathname.c_str(),
+                                               KTX_TEXTURE_CREATE_NO_FLAGS,
+                                               &kTexture);
+    if (KTX_SUCCESS != ktxresult) {
+        std::stringstream message;
+
+        message << "Creation of ktxTexture from \"" << pathname
+                << "\" failed: " << ktxErrorString(ktxresult);
+        throw std::runtime_error(message.str());
+    }
+    ktxresult = ktxTexture_GLUpload(kTexture, &gnTexture, &target, &glerror);
+
+    if (KTX_SUCCESS == ktxresult) {
+        if (target != GL_TEXTURE_2D) {
+            /* Can only draw 2D textures */
+            glDeleteTextures(1, &gnTexture);
+            return;
+        }
+        glEnable(target);
+
+        if (kTexture->numLevels > 1)
+            // Enable bilinear mipmapping.
+            // TO DO: application can consider inserting a key,value pair in
+            // the KTX file that indicates what type of filtering to use.
+            glTexParameteri(target,
+                            GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST);
+        else
+            glTexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+        glTexParameteri(target, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+        glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
+
+        ktxTexture_Destroy(kTexture);
+    } else {
+        std::stringstream message;
+
+        message << "Load of texture from \"" << pathname << "\" failed: ";
+        if (ktxresult == KTX_GL_ERROR) {
+            message << std::showbase << "GL error " << std::hex << glerror
+                    << "occurred.";
+        } else {
+            message << ktxErrorString(ktxresult);
+        }
+        throw std::runtime_error(message.str());
+    }
+
+    /* By default dithering is enabled. Dithering does not provide visual
+     * improvement in this sample so disable it to improve performance. 
+     */
+    glDisable(GL_DITHER);
+
+    glEnable(GL_CULL_FACE);
+    glClearColor(0.2f,0.3f,0.4f,1.0f);
+
+    glEnableClientState(GL_VERTEX_ARRAY);
+    glEnableClientState(GL_COLOR_ARRAY);
+    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+
+    glVertexPointer(3, GL_FLOAT, 0, cube_face);
+    glColorPointer(4, GL_FLOAT, 0, cube_color);
+    glTexCoordPointer(2, GL_FLOAT, 0, cube_texture);
+}
+
+TexturedCube::~TexturedCube()
+{
+    glDisable(GL_TEXTURE_2D);
+    glEnable(GL_DITHER);
+    glDisable(GL_CULL_FACE);
+    glDisableClientState(GL_VERTEX_ARRAY);
+    glDisableClientState(GL_COLOR_ARRAY);
+    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+    assert(GL_NO_ERROR == glGetError());
+}
+
+void
+TexturedCube::resize(uint32_t uWidth, uint32_t uHeight)
+{
+    glm::mat4 matProj;
+    glViewport(0, 0, uWidth, uHeight);
+
+    glMatrixMode( GL_PROJECTION );
+    matProj = glm::perspective(glm::radians(45.f),
+                               uWidth / (float)uHeight,
+                               1.f, 100.f);
+    glLoadIdentity();
+    glLoadMatrixf(glm::value_ptr(matProj));
+
+    glMatrixMode( GL_MODELVIEW );
+    assert(GL_NO_ERROR == glGetError());
+}
+
+void
+TexturedCube::run(uint32_t msTicks)
+{
+    /* Setup the view matrix : just turn around the cube. */
+    const float fDistance = 5.0f;
+    glm::vec3 eye((float)cos( msTicks*0.001f ) * fDistance,
+                  (float)sin( msTicks*0.0007f ) * fDistance,
+                  (float)sin( msTicks*0.001f ) * fDistance);
+    glm::vec3 look(0.,0.,0.);
+    glm::vec3 up(0.,1.,0.);
+    glm::mat4 matView = glm::lookAt( eye, look, up );
+
+    glLoadIdentity();
+    glLoadMatrixf(glm::value_ptr(matView));
+
+    /* Draw */
+    glClear( GL_COLOR_BUFFER_BIT );
+
+    glDrawElements(GL_TRIANGLES, CUBE_NUM_INDICES,
+                   GL_UNSIGNED_SHORT, cube_index_buffer);
+
+    assert(GL_NO_ERROR == glGetError());
+}
+
+/* ------------------------------------------------------------------------- */
+

third_party/ktx-src/tests/loadtests/glloadtests/gles1/TexturedCube.h

@@ -0,0 +1,38 @@
+/* -*- tab-width: 4; -*- */
+/* vi: set sw=2 ts=4 expandtab: */
+
+/*
+ * Copyright 2018-2020 Mark Callow.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @file    TexturedCube.cpp
+ * @brief   Draw a textured cube.
+ */
+
+#ifndef TEXTURED_CUBE_H
+#define TEXTURED_CUBE_H
+
+#include <GLES/gl.h>
+#include <GLES/glext.h>
+
+#include "LoadTestSample.h"
+class TexturedCube : public LoadTestSample {
+  public:
+    TexturedCube(uint32_t width, uint32_t height,
+                 const char* const szArgs,
+                 const std::string sBasePath);
+    ~TexturedCube();
+
+    virtual void resize(uint32_t width, uint32_t height);
+    virtual void run(uint32_t msTicks);
+
+    //virtual void getOverlayText(GLTextOverlay *textOverlay);
+
+    static LoadTestSample*
+    create(uint32_t width, uint32_t height,
+           const char* const szArgs, const std::string sBasePath);
+};
+
+#endif /* TEXTURED_CUBE_H */

third_party/ktx-src/tests/loadtests/glloadtests/resources/ios/Info.plist.in

@@ -0,0 +1,50 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+    Copyright 2015-2024 Mark Callow
+    SPDX-License-Identifier: Apache-2.0
+
+    WARNING: Do not attempt to edit the Info.plist you see in the Xcode
+    project. It is unavoidably configured from this by CMake. Edit here.
+-->
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>CFBundleName</key>
+    <string>${MACOSX_BUNDLE_BUNDLE_NAME}</string>
+    <key>CFBundleDisplayName</key>
+    <string>${MACOSX_BUNDLE_BUNDLE_NAME}</string>
+    <key>CFBundleGetInfoString</key>
+    <string>${MACOSX_BUNDLE_INFO_STRING}</string>
+    <key>NSHumanReadableCopyright</key>
+    <string>${MACOSX_BUNDLE_COPYRIGHT}</string>
+    <key>CFBundleDevelopmentRegion</key>
+    <string>en</string>
+    <key>CFBundleExecutable</key>
+    <string>${MACOSX_BUNDLE_EXECUTABLE_NAME}</string>
+    <key>CFBundleIdentifier</key>
+    <string>${MACOSX_BUNDLE_GUI_IDENTIFIER}</string>
+    <key>CFBundleInfoDictionaryVersion</key>
+    <string>6.0</string>
+    <key>CFBundlePackageType</key>
+    <string>APPL</string>
+    <key>CFBundleVersion</key>
+    <string>${MACOSX_BUNDLE_BUNDLE_VERSION}</string>
+    <key>CFBundleShortVersionString</key>
+    <string>${MACOSX_BUNDLE_SHORT_VERSION_STRING}</string>
+    <key>CFBundleSignature</key>
+    <string>????</string>
+    <key>NSMainNibFile</key>
+    <string></string>
+    <key>UILaunchStoryboardName</key>
+    <string>LaunchScreen</string>
+    <key>UISupportedInterfaceOrientations</key>
+    <array>
+        <string>UIInterfaceOrientationPortrait</string>
+        <string>UIInterfaceOrientationPortraitUpsideDown</string>
+        <string>UIInterfaceOrientationLandscapeLeft</string>
+        <string>UIInterfaceOrientationLandscapeRight</string>
+    </array>
+    <key>UIApplicationSupportsIndirectInputEvents</key>
+    <string>YES</string>
+</dict>
+</plist>