VkApp.cpp

Go to the documentation of this file.

/*
* Vulkan Example base class
*
* Copyright (C) by Sascha Willems - www.saschawillems.de
*
* This code is licensed under the MIT license (MIT) (http://opensource.org/licenses/MIT)
*/
 
#include "VkApp.h"
#include "VkSystem.h"
#include "VkVisualModule.h"
#include "SceneGraph.h"
#include "SceneGraphFactory.h"
 
void VkApp::renderFrame()
{
    VkApp::prepareFrame();
    submitInfo.commandBufferCount = 1;
    submitInfo.pCommandBuffers = &drawCmdBuffers[currentBuffer];
    VK_CHECK_RESULT(vkQueueSubmit(ctx->graphicsQueueHandle(), 1, &submitInfo, VK_NULL_HANDLE));
    VkApp::submitFrame();
}
void VkApp::renderFrame() {…}
 
std::string VkApp::getWindowTitle()
{
    std::string device(dyno::VkSystem::instance()->getDeviceProperties().deviceName);
    std::string windowTitle;
    windowTitle = title + " - " + device;
    if (!settings.overlay) {
        windowTitle += " - " + std::to_string(frameCounter) + " fps";
    }
    return windowTitle;
}
std::string VkApp::getWindowTitle() {…}
 
void VkApp::createCommandBuffers()
{
    // Create one command buffer for each swap chain image and reuse for rendering
    drawCmdBuffers.resize(swapChain.imageCount);
 
    VkCommandBufferAllocateInfo cmdBufAllocateInfo =
        vks::initializers::commandBufferAllocateInfo(
            cmdPool,
            VK_COMMAND_BUFFER_LEVEL_PRIMARY,
            static_cast<uint32_t>(drawCmdBuffers.size()));
 
    VK_CHECK_RESULT(vkAllocateCommandBuffers(ctx->deviceHandle(), &cmdBufAllocateInfo, drawCmdBuffers.data()));
}
void VkApp::createCommandBuffers() {…}
 
void VkApp::destroyCommandBuffers()
{
    vkFreeCommandBuffers(ctx->deviceHandle(), cmdPool, static_cast<uint32_t>(drawCmdBuffers.size()), drawCmdBuffers.data());
}
void VkApp::destroyCommandBuffers() {…}
 
std::string VkApp::getShadersPath() const
{
    return getAssetPath() + "shaders/" + shaderDir + "/";
}
std::string VkApp::getShadersPath() const {…}
 
void VkApp::prepare()
{
    if (ctx->enableDebugMarkers) {
        //vks::debugmarker::setup(ctx->deviceHandle());
    }
    initSwapchain();
    createCommandPool();
    setupSwapChain();
    createCommandBuffers();
    createSynchronizationPrimitives();
    setupDepthStencil();
    setupRenderPass();
//  createPipelineCache();
    setupFrameBuffer();
    settings.overlay = settings.overlay;
    if (settings.overlay) {
        UIOverlay.shaders = {
            loadShader(getShadersPath() + "base/uioverlay.vert.spv", VK_SHADER_STAGE_VERTEX_BIT),
            loadShader(getShadersPath() + "base/uioverlay.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT),
        };
        UIOverlay.prepareResources();
        UIOverlay.preparePipeline(ctx->pipelineCacheHandle(), renderPass);
    }
 
    // Make sure the code works properly both with different queues families for graphics and compute and the same queue family
#ifdef DEBUG_FORCE_SHARED_GRAPHICS_COMPUTE_QUEUE
    ctx->queueFamilyIndices.compute = ctx->queueFamilyIndices.graphics;
#endif
 
    // Initialize the all nodes and modules in a scenegraph.
    dyno::SceneGraphFactory::instance()->active()->reset();
    
    this->prepare(renderPass);
    this->viewChanged();
 
    this->buildCommandBuffers();
 
    prepared = true;
}
void VkApp::prepare() {…}
 
VkPipelineShaderStageCreateInfo VkApp::loadShader(std::string fileName, VkShaderStageFlagBits stage)
{
    VkPipelineShaderStageCreateInfo shaderStage = {};
    shaderStage.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
    shaderStage.stage = stage;
    shaderStage.module = vks::tools::loadShaderModule(fileName, ctx->deviceHandle());
    shaderStage.pName = "main";
    assert(shaderStage.module != VK_NULL_HANDLE);
    shaderModules.push_back(shaderStage.module);
    return shaderStage;
}
VkPipelineShaderStageCreateInfo VkApp::loadShader(std::string fileName, VkShaderStageFlagBits stage) {…}
 
void VkApp::nextFrame()
{
    auto tStart = std::chrono::high_resolution_clock::now();
    if (viewUpdated)
    {
        viewUpdated = false;
        viewChanged();
    }
 
    render();
    frameCounter++;
    auto tEnd = std::chrono::high_resolution_clock::now();
    auto tDiff = std::chrono::duration<double, std::milli>(tEnd - tStart).count();
    frameTimer = (float)tDiff / 1000.0f;
    camera.update(frameTimer);
    if (camera.moving())
    {
        viewUpdated = true;
    }
    // Convert to clamped timer value
    if (!paused)
    {
        timer += timerSpeed * frameTimer;
        if (timer > 1.0)
        {
            timer -= 1.0f;
        }
    }
    float fpsTimer = (float)(std::chrono::duration<double, std::milli>(tEnd - lastTimestamp).count());
    if (fpsTimer > 1000.0f)
    {
        lastFPS = static_cast<uint32_t>((float)frameCounter * (1000.0f / fpsTimer));
#if defined(_WIN32)
        if (!settings.overlay)  {
            std::string windowTitle = getWindowTitle();
            SetWindowText(window, windowTitle.c_str());
        }
#endif
        frameCounter = 0;
        lastTimestamp = tEnd;
    }
    // TODO: Cap UI overlay update rates
    updateOverlay();
}
void VkApp::nextFrame() {…}
 
void VkApp::renderLoop()
{
    destWidth = width;
    destHeight = height;
    lastTimestamp = std::chrono::high_resolution_clock::now();
#if defined(_WIN32)
    MSG msg;
    bool quitMessageReceived = false;
    while (!quitMessageReceived) {
        while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
            if (msg.message == WM_QUIT) {
                quitMessageReceived = true;
                break;
            }
        }
        if (prepared && !IsIconic(window)) {
            nextFrame();
        }
    }
#elif defined(VK_USE_PLATFORM_ANDROID_KHR)
    while (1)
    {
        int ident;
        int events;
        struct android_poll_source* source;
        bool destroy = false;
 
        focused = true;
 
        while ((ident = ALooper_pollAll(focused ? 0 : -1, NULL, &events, (void**)&source)) >= 0)
        {
            if (source != NULL)
            {
                source->process(androidApp, source);
            }
            if (androidApp->destroyRequested != 0)
            {
                LOGD("Android app destroy requested");
                destroy = true;
                break;
            }
        }
 
        // App destruction requested
        // Exit loop, example will be destroyed in application main
        if (destroy)
        {
            ANativeActivity_finish(androidApp->activity);
            break;
        }
 
        // Render frame
        if (prepared)
        {
            auto tStart = std::chrono::high_resolution_clock::now();
            render();
            frameCounter++;
            auto tEnd = std::chrono::high_resolution_clock::now();
            auto tDiff = std::chrono::duration<double, std::milli>(tEnd - tStart).count();
            frameTimer = tDiff / 1000.0f;
            camera.update(frameTimer);
            // Convert to clamped timer value
            if (!paused)
            {
                timer += timerSpeed * frameTimer;
                if (timer > 1.0)
                {
                    timer -= 1.0f;
                }
            }
            float fpsTimer = std::chrono::duration<double, std::milli>(tEnd - lastTimestamp).count();
            if (fpsTimer > 1000.0f)
            {
                lastFPS = (float)frameCounter * (1000.0f / fpsTimer);
                frameCounter = 0;
                lastTimestamp = tEnd;
            }
 
            // TODO: Cap UI overlay update rates/only issue when update requested
            updateOverlay();
 
            bool updateView = false;
 
            // Check touch state (for movement)
            if (touchDown) {
                touchTimer += frameTimer;
            }
            if (touchTimer >= 1.0) {
                camera.keys.up = true;
                viewChanged();
            }
 
            // Check gamepad state
            const float deadZone = 0.0015f;
            // todo : check if gamepad is present
            // todo : time based and relative axis positions
            if (camera.type != Camera::CameraType::firstperson)
            {
                // Rotate
                if (std::abs(gamePadState.axisLeft.x) > deadZone)
                {
                    camera.rotate(glm::vec3(0.0f, gamePadState.axisLeft.x * 0.5f, 0.0f));
                    updateView = true;
                }
                if (std::abs(gamePadState.axisLeft.y) > deadZone)
                {
                    camera.rotate(glm::vec3(gamePadState.axisLeft.y * 0.5f, 0.0f, 0.0f));
                    updateView = true;
                }
                // Zoom
                if (std::abs(gamePadState.axisRight.y) > deadZone)
                {
                    camera.translate(glm::vec3(0.0f, 0.0f, gamePadState.axisRight.y * 0.01f));
                    updateView = true;
                }
                if (updateView)
                {
                    viewChanged();
                }
            }
            else
            {
                updateView = camera.updatePad(gamePadState.axisLeft, gamePadState.axisRight, frameTimer);
                if (updateView)
                {
                    viewChanged();
                }
            }
        }
    }
#endif
    // Flush device to make sure all resources can be freed
    if (ctx->deviceHandle() != VK_NULL_HANDLE) {
        vkDeviceWaitIdle(ctx->deviceHandle());
    }
}
void VkApp::renderLoop() {…}
 
void VkApp::updateOverlay()
{
    if (!settings.overlay)
        return;
 
    ImGuiIO& io = ImGui::GetIO();
 
    io.DisplaySize = ImVec2((float)width, (float)height);
    io.DeltaTime = frameTimer;
 
    io.MousePos = ImVec2(mousePos.x, mousePos.y);
    io.MouseDown[0] = mouseButtons.left;
    io.MouseDown[1] = mouseButtons.right;
 
    ImGui::NewFrame();
 
    ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 0);
    ImGui::SetNextWindowPos(ImVec2(10, 10));
    ImGui::SetNextWindowSize(ImVec2(0, 0));
    ImGui::Begin("Vulkan Example", nullptr, ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove);
    ImGui::TextUnformatted(title.c_str());
    ImGui::TextUnformatted(dyno::VkSystem::instance()->getDeviceProperties().deviceName);
    ImGui::Text("%.2f ms/frame (%.1d fps)", (1000.0f / lastFPS), lastFPS);
 
#if defined(VK_USE_PLATFORM_ANDROID_KHR)
    ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(0.0f, 5.0f * UIOverlay.scale));
#endif
    ImGui::PushItemWidth(110.0f * UIOverlay.scale);
    OnUpdateUIOverlay(&UIOverlay);
    ImGui::PopItemWidth();
#if defined(VK_USE_PLATFORM_ANDROID_KHR)
    ImGui::PopStyleVar();
#endif
 
    ImGui::End();
    ImGui::PopStyleVar();
    ImGui::Render();
 
    if (UIOverlay.update() || UIOverlay.updated) {
        buildCommandBuffers();
        UIOverlay.updated = false;
    }
 
#if defined(VK_USE_PLATFORM_ANDROID_KHR)
    if (mouseButtons.left) {
        mouseButtons.left = false;
    }
#endif
}
void VkApp::updateOverlay() {…}
 
void VkApp::drawUI(const VkCommandBuffer commandBuffer)
{
    if (settings.overlay) {
        const VkViewport viewport = vks::initializers::viewport((float)width, (float)height, 0.0f, 1.0f);
        const VkRect2D scissor = vks::initializers::rect2D(width, height, 0, 0);
        vkCmdSetViewport(commandBuffer, 0, 1, &viewport);
        vkCmdSetScissor(commandBuffer, 0, 1, &scissor);
 
        UIOverlay.draw(commandBuffer);
    }
}
void VkApp::drawUI(const VkCommandBuffer commandBuffer) {…}
 
void VkApp::prepareFrame()
{
    // Acquire the next image from the swap chain
    VkResult result = swapChain.acquireNextImage(semaphores.presentComplete, &currentBuffer);
    // Recreate the swapchain if it's no longer compatible with the surface (OUT_OF_DATE) or no longer optimal for presentation (SUBOPTIMAL)
    if ((result == VK_ERROR_OUT_OF_DATE_KHR) || (result == VK_SUBOPTIMAL_KHR)) {
        windowResize();
    }
    else {
        VK_CHECK_RESULT(result);
    }
}
void VkApp::prepareFrame() {…}
 
void VkApp::submitFrame()
{
    VkResult result = swapChain.queuePresent(ctx->graphicsQueueHandle(), currentBuffer, semaphores.renderComplete);
    if (!((result == VK_SUCCESS) || (result == VK_SUBOPTIMAL_KHR))) {
        if (result == VK_ERROR_OUT_OF_DATE_KHR) {
            // Swap chain is no longer compatible with the surface and needs to be recreated
            windowResize();
            return;
        } else {
            VK_CHECK_RESULT(result);
        }
    }
    VK_CHECK_RESULT(vkQueueWaitIdle(ctx->graphicsQueueHandle()));
}
void VkApp::submitFrame() {…}
 
VkApp::VkApp(bool enableValidation)
{
#if !defined(VK_USE_PLATFORM_ANDROID_KHR)
    // Check for a valid asset path
    struct stat info;
    if (stat(getAssetPath().c_str(), &info) != 0)
    {
#if defined(_WIN32)
        std::string msg = "Could not locate asset path in \"" + getAssetPath() + "\" !";
        MessageBox(NULL, msg.c_str(), "Fatal error", MB_OK | MB_ICONERROR);
#else
        std::cerr << "Error: Could not find asset path in " << getAssetPath() << "\n";
#endif
        exit(-1);
    }
#endif
 
    settings.validation = enableValidation;
 
#if defined(_WIN32)
    // Enable console if validation is active
// Debug message callback will output to it
    if (this->settings.validation)
    {
        setupConsole("Vulkan validation output");
    }
    setupDPIAwareness();
 
    paused = true;
#endif
 
    title = "Compute shader Height FieldFluid simulation";
    camera.type = Camera::CameraType::lookat;
    camera.setPerspective(60.0f, (float)width / (float)height, 0.1f, 512.0f);
    camera.setRotation(glm::vec3(-30.0f, -45.0f, 0.0f));
    camera.setTranslation(glm::vec3(0.0f, 0.0f, -5.0f));
    settings.overlay = true;
 
    ctx = dyno::VkSystem::instance()->currentContext();
}
VkApp::VkApp(bool enableValidation) {…}
 
VkApp::~VkApp()
{
    // Clean up Vulkan resources
    swapChain.cleanup();
    if (descriptorPool != VK_NULL_HANDLE)
    {
        vkDestroyDescriptorPool(ctx->deviceHandle(), descriptorPool, nullptr);
    }
    destroyCommandBuffers();
    vkDestroyRenderPass(ctx->deviceHandle(), renderPass, nullptr);
    for (uint32_t i = 0; i < frameBuffers.size(); i++)
    {
        vkDestroyFramebuffer(ctx->deviceHandle(), frameBuffers[i], nullptr);
    }
 
    for (auto& shaderModule : shaderModules)
    {
        vkDestroyShaderModule(ctx->deviceHandle(), shaderModule, nullptr);
    }
    vkDestroyImageView(ctx->deviceHandle(), depthStencil.view, nullptr);
    vkDestroyImage(ctx->deviceHandle(), depthStencil.image, nullptr);
    vkFreeMemory(ctx->deviceHandle(), depthStencil.mem, nullptr);
 
    vkDestroyPipelineCache(ctx->deviceHandle(), ctx->pipelineCacheHandle(), nullptr);
 
    vkDestroyCommandPool(ctx->deviceHandle(), cmdPool, nullptr);
 
    vkDestroySemaphore(ctx->deviceHandle(), semaphores.presentComplete, nullptr);
    vkDestroySemaphore(ctx->deviceHandle(), semaphores.renderComplete, nullptr);
    for (auto& fence : waitFences) {
        vkDestroyFence(ctx->deviceHandle(), fence, nullptr);
    }
 
    if (settings.overlay) {
        UIOverlay.freeResources();
    }
 
#if defined(VK_USE_PLATFORM_ANDROID_KHR)
    // todo : android cleanup (if required)
#endif
}
VkApp::~VkApp() {…}
 
bool VkApp::initVulkan()
{
#if defined(VK_USE_PLATFORM_ANDROID_KHR)
    vks::android::loadVulkanFunctions(dyno::VkSystem::instance()->instanceHandle());
#endif
 
    // Find a suitable depth format
    VkBool32 validDepthFormat = vks::tools::getSupportedDepthFormat(ctx->physicalDevice, &depthFormat);
    assert(validDepthFormat);
 
    swapChain.connect(dyno::VkSystem::instance()->instanceHandle(), ctx->physicalDevice, ctx->deviceHandle());
 
    // Create synchronization objects
    VkSemaphoreCreateInfo semaphoreCreateInfo = vks::initializers::semaphoreCreateInfo();
    // Create a 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(ctx->deviceHandle(), &semaphoreCreateInfo, nullptr, &semaphores.presentComplete));
    // Create a semaphore used to synchronize command submission
    // Ensures that the image is not presented until all commands have been submitted and executed
    VK_CHECK_RESULT(vkCreateSemaphore(ctx->deviceHandle(), &semaphoreCreateInfo, nullptr, &semaphores.renderComplete));
 
    // Set up submit info structure
    // Semaphores will stay the same during application lifetime
    // Command buffer submission info is set by each example
    submitInfo = vks::initializers::submitInfo();
    submitInfo.pWaitDstStageMask = &submitPipelineStages;
    submitInfo.waitSemaphoreCount = 1;
    submitInfo.pWaitSemaphores = &semaphores.presentComplete;
    submitInfo.signalSemaphoreCount = 1;
    submitInfo.pSignalSemaphores = &semaphores.renderComplete;
 
    return true;
}
bool VkApp::initVulkan() {…}
 
#if defined(_WIN32)
// Win32 : Sets up a console window and redirects standard output to it
void VkApp::setupConsole(std::string title)
{
    AllocConsole();
    AttachConsole(GetCurrentProcessId());
    FILE *stream;
    freopen_s(&stream, "CONOUT$", "w+", stdout);
    freopen_s(&stream, "CONOUT$", "w+", stderr);
    SetConsoleTitle(TEXT(title.c_str()));
}
 
void VkApp::setupDPIAwareness()
{
    typedef HRESULT *(__stdcall *SetProcessDpiAwarenessFunc)(PROCESS_DPI_AWARENESS);
 
    HMODULE shCore = LoadLibraryA("Shcore.dll");
    if (shCore)
    {
        SetProcessDpiAwarenessFunc setProcessDpiAwareness =
            (SetProcessDpiAwarenessFunc)GetProcAddress(shCore, "SetProcessDpiAwareness");
 
        if (setProcessDpiAwareness != nullptr)
        {
            setProcessDpiAwareness(PROCESS_PER_MONITOR_DPI_AWARE);
        }
 
        FreeLibrary(shCore);
    }
}
 
HWND VkApp::setupWindow(HINSTANCE hinstance, WNDPROC wndproc)
{
    this->windowInstance = hinstance;
 
    WNDCLASSEX wndClass;
 
    wndClass.cbSize = sizeof(WNDCLASSEX);
    wndClass.style = CS_HREDRAW | CS_VREDRAW;
    wndClass.lpfnWndProc = wndproc;
    wndClass.cbClsExtra = 0;
    wndClass.cbWndExtra = 0;
    wndClass.hInstance = hinstance;
    wndClass.hIcon = LoadIcon(NULL, IDI_APPLICATION);
    wndClass.hCursor = LoadCursor(NULL, IDC_ARROW);
    wndClass.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
    wndClass.lpszMenuName = NULL;
    wndClass.lpszClassName = name.c_str();
    wndClass.hIconSm = LoadIcon(NULL, IDI_WINLOGO);
 
    if (!RegisterClassEx(&wndClass))
    {
        std::cout << "Could not register window class!\n";
        fflush(stdout);
        exit(1);
    }
 
    int screenWidth = GetSystemMetrics(SM_CXSCREEN);
    int screenHeight = GetSystemMetrics(SM_CYSCREEN);
 
    if (settings.fullscreen)
    {
        if ((width != (uint32_t)screenWidth) && (height != (uint32_t)screenHeight))
        {
            DEVMODE dmScreenSettings;
            memset(&dmScreenSettings, 0, sizeof(dmScreenSettings));
            dmScreenSettings.dmSize       = sizeof(dmScreenSettings);
            dmScreenSettings.dmPelsWidth  = width;
            dmScreenSettings.dmPelsHeight = height;
            dmScreenSettings.dmBitsPerPel = 32;
            dmScreenSettings.dmFields     = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;
            if (ChangeDisplaySettings(&dmScreenSettings, CDS_FULLSCREEN) != DISP_CHANGE_SUCCESSFUL)
            {
                if (MessageBox(NULL, "Fullscreen Mode not supported!\n Switch to window mode?", "Error", MB_YESNO | MB_ICONEXCLAMATION) == IDYES)
                {
                    settings.fullscreen = false;
                }
                else
                {
                    return nullptr;
                }
            }
            screenWidth = width;
            screenHeight = height;
        }
 
    }
 
    DWORD dwExStyle;
    DWORD dwStyle;
 
    if (settings.fullscreen)
    {
        dwExStyle = WS_EX_APPWINDOW;
        dwStyle = WS_POPUP | WS_CLIPSIBLINGS | WS_CLIPCHILDREN;
    }
    else
    {
        dwExStyle = WS_EX_APPWINDOW | WS_EX_WINDOWEDGE;
        dwStyle = WS_OVERLAPPEDWINDOW | WS_CLIPSIBLINGS | WS_CLIPCHILDREN;
    }
 
    RECT windowRect;
    windowRect.left = 0L;
    windowRect.top = 0L;
    windowRect.right = settings.fullscreen ? (long)screenWidth : (long)width;
    windowRect.bottom = settings.fullscreen ? (long)screenHeight : (long)height;
 
    AdjustWindowRectEx(&windowRect, dwStyle, FALSE, dwExStyle);
 
    std::string windowTitle = getWindowTitle();
    window = CreateWindowEx(0,
        name.c_str(),
        windowTitle.c_str(),
        dwStyle | WS_CLIPSIBLINGS | WS_CLIPCHILDREN,
        0,
        0,
        windowRect.right - windowRect.left,
        windowRect.bottom - windowRect.top,
        NULL,
        NULL,
        hinstance,
        NULL);
 
    if (!settings.fullscreen)
    {
        // Center on screen
        uint32_t x = (GetSystemMetrics(SM_CXSCREEN) - windowRect.right) / 2;
        uint32_t y = (GetSystemMetrics(SM_CYSCREEN) - windowRect.bottom) / 2;
        SetWindowPos(window, 0, x, y, 0, 0, SWP_NOZORDER | SWP_NOSIZE);
    }
 
    if (!window)
    {
        printf("Could not create window!\n");
        fflush(stdout);
        return nullptr;
    }
 
    ShowWindow(window, SW_SHOW);
    SetForegroundWindow(window);
    SetFocus(window);
 
    return window;
}
 
void VkApp::handleMessages(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    switch (uMsg)
    {
    case WM_CLOSE:
        prepared = false;
        DestroyWindow(hWnd);
        PostQuitMessage(0);
        break;
    case WM_PAINT:
        ValidateRect(window, NULL);
        break;
    case WM_KEYDOWN:
        switch (wParam)
        {
        case KEY_P:
            paused = !paused;
            break;
        case KEY_N:
            dyno::SceneGraphFactory::instance()->active()->takeOneFrame();
            break;
        case KEY_F1:
            if (settings.overlay) {
                UIOverlay.visible = !UIOverlay.visible;
            }
            break;
        case KEY_ESCAPE:
            PostQuitMessage(0);
            break;
        }
 
        if (camera.type == Camera::firstperson)
        {
            switch (wParam)
            {
            case KEY_W:
                camera.keys.up = true;
                break;
            case KEY_S:
                camera.keys.down = true;
                break;
            case KEY_A:
                camera.keys.left = true;
                break;
            case KEY_D:
                camera.keys.right = true;
                break;
            }
        }
 
        keyPressed((uint32_t)wParam);
        break;
    case WM_KEYUP:
        if (camera.type == Camera::firstperson)
        {
            switch (wParam)
            {
            case KEY_W:
                camera.keys.up = false;
                break;
            case KEY_S:
                camera.keys.down = false;
                break;
            case KEY_A:
                camera.keys.left = false;
                break;
            case KEY_D:
                camera.keys.right = false;
                break;
            }
        }
        break;
    case WM_LBUTTONDOWN:
        mousePos = glm::vec2((float)LOWORD(lParam), (float)HIWORD(lParam));
        mouseButtons.left = true;
        break;
    case WM_RBUTTONDOWN:
        mousePos = glm::vec2((float)LOWORD(lParam), (float)HIWORD(lParam));
        mouseButtons.right = true;
        break;
    case WM_MBUTTONDOWN:
        mousePos = glm::vec2((float)LOWORD(lParam), (float)HIWORD(lParam));
        mouseButtons.middle = true;
        break;
    case WM_LBUTTONUP:
        mouseButtons.left = false;
        break;
    case WM_RBUTTONUP:
        mouseButtons.right = false;
        break;
    case WM_MBUTTONUP:
        mouseButtons.middle = false;
        break;
    case WM_MOUSEWHEEL:
    {
        short wheelDelta = GET_WHEEL_DELTA_WPARAM(wParam);
        camera.translate(glm::vec3(0.0f, 0.0f, (float)wheelDelta * 0.005f));
        viewUpdated = true;
        break;
    }
    case WM_MOUSEMOVE:
    {
        handleMouseMove(LOWORD(lParam), HIWORD(lParam));
        break;
    }
    case WM_SIZE:
        if ((prepared) && (wParam != SIZE_MINIMIZED))
        {
            if ((resizing) || ((wParam == SIZE_MAXIMIZED) || (wParam == SIZE_RESTORED)))
            {
                destWidth = LOWORD(lParam);
                destHeight = HIWORD(lParam);
                windowResize();
            }
        }
        break;
    case WM_GETMINMAXINFO:
    {
        LPMINMAXINFO minMaxInfo = (LPMINMAXINFO)lParam;
        minMaxInfo->ptMinTrackSize.x = 64;
        minMaxInfo->ptMinTrackSize.y = 64;
        break;
    }
    case WM_ENTERSIZEMOVE:
        resizing = true;
        break;
    case WM_EXITSIZEMOVE:
        resizing = false;
        break;
    }
}
#elif defined(VK_USE_PLATFORM_ANDROID_KHR)
int32_t VkApp::handleAppInput(struct android_app* app, AInputEvent* event)
{
    VkApp* vulkanExample = reinterpret_cast<VkApp*>(app->userData);
    if (AInputEvent_getType(event) == AINPUT_EVENT_TYPE_MOTION)
    {
        int32_t eventSource = AInputEvent_getSource(event);
        switch (eventSource) {
            case AINPUT_SOURCE_JOYSTICK: {
                // Left thumbstick
                vulkanExample->gamePadState.axisLeft.x = AMotionEvent_getAxisValue(event, AMOTION_EVENT_AXIS_X, 0);
                vulkanExample->gamePadState.axisLeft.y = AMotionEvent_getAxisValue(event, AMOTION_EVENT_AXIS_Y, 0);
                // Right thumbstick
                vulkanExample->gamePadState.axisRight.x = AMotionEvent_getAxisValue(event, AMOTION_EVENT_AXIS_Z, 0);
                vulkanExample->gamePadState.axisRight.y = AMotionEvent_getAxisValue(event, AMOTION_EVENT_AXIS_RZ, 0);
                break;
            }
 
            case AINPUT_SOURCE_TOUCHSCREEN: {
                int32_t action = AMotionEvent_getAction(event);
 
                switch (action) {
                    case AMOTION_EVENT_ACTION_UP: {
                        vulkanExample->lastTapTime = AMotionEvent_getEventTime(event);
                        vulkanExample->touchPos.x = AMotionEvent_getX(event, 0);
                        vulkanExample->touchPos.y = AMotionEvent_getY(event, 0);
                        vulkanExample->touchTimer = 0.0;
                        vulkanExample->touchDown = false;
                        vulkanExample->camera.keys.up = false;
 
                        // Detect single tap
                        int64_t eventTime = AMotionEvent_getEventTime(event);
                        int64_t downTime = AMotionEvent_getDownTime(event);
                        if (eventTime - downTime <= vks::android::TAP_TIMEOUT) {
                            float deadZone = (160.f / vks::android::screenDensity) * vks::android::TAP_SLOP * vks::android::TAP_SLOP;
                            float x = AMotionEvent_getX(event, 0) - vulkanExample->touchPos.x;
                            float y = AMotionEvent_getY(event, 0) - vulkanExample->touchPos.y;
                            if ((x * x + y * y) < deadZone) {
                                vulkanExample->mouseButtons.left = true;
                            }
                        };
 
                        return 1;
                        break;
                    }
                    case AMOTION_EVENT_ACTION_DOWN: {
                        // Detect double tap
                        int64_t eventTime = AMotionEvent_getEventTime(event);
                        if (eventTime - vulkanExample->lastTapTime <= vks::android::DOUBLE_TAP_TIMEOUT) {
                            float deadZone = (160.f / vks::android::screenDensity) * vks::android::DOUBLE_TAP_SLOP * vks::android::DOUBLE_TAP_SLOP;
                            float x = AMotionEvent_getX(event, 0) - vulkanExample->touchPos.x;
                            float y = AMotionEvent_getY(event, 0) - vulkanExample->touchPos.y;
                            if ((x * x + y * y) < deadZone) {
                                vulkanExample->keyPressed(TOUCH_DOUBLE_TAP);
                                vulkanExample->touchDown = false;
                            }
                        }
                        else {
                            vulkanExample->touchDown = true;
                        }
                        vulkanExample->touchPos.x = AMotionEvent_getX(event, 0);
                        vulkanExample->touchPos.y = AMotionEvent_getY(event, 0);
                        vulkanExample->mousePos.x = AMotionEvent_getX(event, 0);
                        vulkanExample->mousePos.y = AMotionEvent_getY(event, 0);
                        break;
                    }
                    case AMOTION_EVENT_ACTION_MOVE: {
                        bool handled = false;
                        if (vulkanExample->settings.overlay) {
                            ImGuiIO& io = ImGui::GetIO();
                            handled = io.WantCaptureMouse;
                        }
                        if (!handled) {
                            int32_t eventX = AMotionEvent_getX(event, 0);
                            int32_t eventY = AMotionEvent_getY(event, 0);
 
                            float deltaX = (float)(vulkanExample->touchPos.y - eventY) * vulkanExample->camera.rotationSpeed * 0.5f;
                            float deltaY = (float)(vulkanExample->touchPos.x - eventX) * vulkanExample->camera.rotationSpeed * 0.5f;
 
                            vulkanExample->camera.rotate(glm::vec3(deltaX, 0.0f, 0.0f));
                            vulkanExample->camera.rotate(glm::vec3(0.0f, -deltaY, 0.0f));
 
                            vulkanExample->viewChanged();
 
                            vulkanExample->touchPos.x = eventX;
                            vulkanExample->touchPos.y = eventY;
                        }
                        break;
                    }
                    default:
                        return 1;
                        break;
                }
            }
 
            return 1;
        }
    }
 
    if (AInputEvent_getType(event) == AINPUT_EVENT_TYPE_KEY)
    {
        int32_t keyCode = AKeyEvent_getKeyCode((const AInputEvent*)event);
        int32_t action = AKeyEvent_getAction((const AInputEvent*)event);
        int32_t button = 0;
 
        if (action == AKEY_EVENT_ACTION_UP)
            return 0;
 
        switch (keyCode)
        {
        case AKEYCODE_BUTTON_A:
            vulkanExample->keyPressed(GAMEPAD_BUTTON_A);
            break;
        case AKEYCODE_BUTTON_B:
            vulkanExample->keyPressed(GAMEPAD_BUTTON_B);
            break;
        case AKEYCODE_BUTTON_X:
            vulkanExample->keyPressed(GAMEPAD_BUTTON_X);
            break;
        case AKEYCODE_BUTTON_Y:
            vulkanExample->keyPressed(GAMEPAD_BUTTON_Y);
            break;
        case AKEYCODE_BUTTON_L1:
            vulkanExample->keyPressed(GAMEPAD_BUTTON_L1);
            break;
        case AKEYCODE_BUTTON_R1:
            vulkanExample->keyPressed(GAMEPAD_BUTTON_R1);
            break;
        case AKEYCODE_BUTTON_START:
            vulkanExample->paused = !vulkanExample->paused;
            break;
        };
 
        LOGD("Button %d pressed", keyCode);
    }
 
    return 0;
}
 
void VkApp::handleAppCommand(android_app * app, int32_t cmd)
{
    assert(app->userData != NULL);
    VkApp* vulkanExample = reinterpret_cast<VkApp*>(app->userData);
    switch (cmd)
    {
    case APP_CMD_SAVE_STATE:
        LOGD("APP_CMD_SAVE_STATE");
        /*
        vulkanExample->app->savedState = malloc(sizeof(struct saved_state));
        *((struct saved_state*)vulkanExample->app->savedState) = vulkanExample->state;
        vulkanExample->app->savedStateSize = sizeof(struct saved_state);
        */
        break;
    case APP_CMD_INIT_WINDOW:
        LOGD("APP_CMD_INIT_WINDOW");
        if (androidApp->window != NULL)
        {
            if (vulkanExample->initVulkan()) {
                vulkanExample->prepare();
                assert(vulkanExample->prepared);
                vulkanExample->swapChainCleaned = false;
            }
            else {
                LOGE("Could not initialize Vulkan, exiting!");
                androidApp->destroyRequested = 1;
            }
        }
        else
        {
            LOGE("No window assigned!");
        }
        break;
    case APP_CMD_LOST_FOCUS:
        LOGD("APP_CMD_LOST_FOCUS");
        vulkanExample->focused = false;
        break;
    case APP_CMD_GAINED_FOCUS:
        LOGD("APP_CMD_GAINED_FOCUS");
        vulkanExample->focused = true;
        break;
    case APP_CMD_TERM_WINDOW:
        // Window is hidden or closed, clean up resources
        LOGD("APP_CMD_TERM_WINDOW");
        if (vulkanExample->prepared) {
            vulkanExample->swapChain.cleanup();
            vulkanExample->swapChainCleaned = true;
        }
        break;
    case APP_CMD_CONFIG_CHANGED:
        LOGD("APP_CMD_CONFIG_CHANGED");
        break;
    case APP_CMD_START:
        LOGD("APP_CMD_START");
        break;
    case APP_CMD_RESUME:
        LOGD("APP_CMD_RESUME");
        break;
    case APP_CMD_PAUSE:
        LOGD("APP_CMD_PAUSE");
        break;
    case APP_CMD_STOP:
        LOGD("APP_CMD_STOP");
        break;
    case APP_CMD_DESTROY:
        LOGD("APP_CMD_DESTROY");
        dyno::SceneGraphFactory::instance()->active()->invalid();
        break;
    }
}
#endif
 
void VkApp::render()
{
#if defined(_WIN32)
    if (!paused) {
        dyno::SceneGraphFactory::instance()->active()->takeOneFrame();
    }
#elif defined(VK_USE_PLATFORM_ANDROID_KHR)
    dyno::SceneGraphFactory::instance()->active()->takeOneFrame();
#endif
    dyno::SceneGraphFactory::instance()->active()->updateGraphicsContext();
    if (!prepared || swapChainCleaned)
        return;
 
    // Submit graphics commands
    VkApp::prepareFrame();
 
    submitInfo.commandBufferCount = 1;
    submitInfo.pCommandBuffers = &drawCmdBuffers[currentBuffer];
    VK_CHECK_RESULT(vkQueueSubmit(ctx->graphicsQueueHandle(), 1, &submitInfo, VK_NULL_HANDLE));
 
    VkApp::submitFrame();
}
void VkApp::render() {…}
 
void VkApp::viewChanged() 
{
    auto scn = dyno::SceneGraphFactory::instance()->active();
 
    for (auto it = scn->begin(); it != scn->end(); it++)
    {
        for (auto iter : it->graphicsPipeline()->activeModules())
        {
            auto m = dynamic_cast<dyno::VkVisualModule*>(iter.get());
            if (m && m->isVisible())
            {
                m->viewChanged(camera.matrices.perspective, camera.matrices.view);
            }
        }
    }
}
void VkApp::viewChanged()  {…}
 
void VkApp::keyPressed(uint32_t) {}
 
void VkApp::mouseMoved(double x, double y, bool & handled) {}
 
void VkApp::buildCommandBuffers()
{
    VkCommandBufferBeginInfo cmdBufInfo = vks::initializers::commandBufferBeginInfo();
 
    VkClearValue clearValues[2];
    clearValues[0].color = { { 0.0f, 0.0f, 0.0f, 1.0f } };;
    clearValues[1].depthStencil = { 1.0f, 0 };
 
    VkRenderPassBeginInfo renderPassBeginInfo = vks::initializers::renderPassBeginInfo();
    renderPassBeginInfo.renderPass = renderPass;
    renderPassBeginInfo.renderArea.offset.x = 0;
    renderPassBeginInfo.renderArea.offset.y = 0;
    renderPassBeginInfo.renderArea.extent.width = width;
    renderPassBeginInfo.renderArea.extent.height = height;
    renderPassBeginInfo.clearValueCount = 2;
    renderPassBeginInfo.pClearValues = clearValues;
 
    for (int32_t i = 0; i < drawCmdBuffers.size(); ++i)
    {
        // Set target frame buffer
        renderPassBeginInfo.framebuffer = frameBuffers[i];
 
        VK_CHECK_RESULT(vkBeginCommandBuffer(drawCmdBuffers[i], &cmdBufInfo));
 
        // Draw the particle system using the update vertex buffer
 
        vkCmdBeginRenderPass(drawCmdBuffers[i], &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);
 
        VkViewport viewport = vks::initializers::viewport((float)width, (float)height, 0.0f, 1.0f);
        vkCmdSetViewport(drawCmdBuffers[i], 0, 1, &viewport);
 
        VkRect2D scissor = vks::initializers::rect2D(width, height, 0, 0);
        vkCmdSetScissor(drawCmdBuffers[i], 0, 1, &scissor);
 
        buildCustomCommandBuffer(drawCmdBuffers[i]);
 
        drawUI(drawCmdBuffers[i]);
 
        vkCmdEndRenderPass(drawCmdBuffers[i]);
 
        VK_CHECK_RESULT(vkEndCommandBuffer(drawCmdBuffers[i]));
    }
 
}
void VkApp::buildCommandBuffers() {…}
 
void VkApp::createSynchronizationPrimitives()
{
    // Wait fences to sync command buffer access
    VkFenceCreateInfo fenceCreateInfo = vks::initializers::fenceCreateInfo(VK_FENCE_CREATE_SIGNALED_BIT);
    waitFences.resize(drawCmdBuffers.size());
    for (auto& fence : waitFences) {
        VK_CHECK_RESULT(vkCreateFence(ctx->deviceHandle(), &fenceCreateInfo, nullptr, &fence));
    }
}
void VkApp::createSynchronizationPrimitives() {…}
 
void VkApp::createCommandPool()
{
    VkCommandPoolCreateInfo cmdPoolInfo = {};
    cmdPoolInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
    cmdPoolInfo.queueFamilyIndex = swapChain.queueNodeIndex;
    cmdPoolInfo.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
    VK_CHECK_RESULT(vkCreateCommandPool(ctx->deviceHandle(), &cmdPoolInfo, nullptr, &cmdPool));
}
void VkApp::createCommandPool() {…}
 
void VkApp::setupDepthStencil()
{
    VkImageCreateInfo imageCI{};
    imageCI.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
    imageCI.imageType = VK_IMAGE_TYPE_2D;
    imageCI.format = depthFormat;
    imageCI.extent = { width, height, 1 };
    imageCI.mipLevels = 1;
    imageCI.arrayLayers = 1;
    imageCI.samples = VK_SAMPLE_COUNT_1_BIT;
    imageCI.tiling = VK_IMAGE_TILING_OPTIMAL;
    imageCI.usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
 
    VK_CHECK_RESULT(vkCreateImage(ctx->deviceHandle(), &imageCI, nullptr, &depthStencil.image));
    VkMemoryRequirements memReqs{};
    vkGetImageMemoryRequirements(ctx->deviceHandle(), depthStencil.image, &memReqs);
 
    VkMemoryAllocateInfo memAllloc{};
    memAllloc.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
    memAllloc.allocationSize = memReqs.size;
    memAllloc.memoryTypeIndex = ctx->getMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
    VK_CHECK_RESULT(vkAllocateMemory(ctx->deviceHandle(), &memAllloc, nullptr, &depthStencil.mem));
    VK_CHECK_RESULT(vkBindImageMemory(ctx->deviceHandle(), depthStencil.image, depthStencil.mem, 0));
 
    VkImageViewCreateInfo imageViewCI{};
    imageViewCI.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
    imageViewCI.viewType = VK_IMAGE_VIEW_TYPE_2D;
    imageViewCI.image = depthStencil.image;
    imageViewCI.format = depthFormat;
    imageViewCI.subresourceRange.baseMipLevel = 0;
    imageViewCI.subresourceRange.levelCount = 1;
    imageViewCI.subresourceRange.baseArrayLayer = 0;
    imageViewCI.subresourceRange.layerCount = 1;
    imageViewCI.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
    // Stencil aspect should only be set on depth + stencil formats (VK_FORMAT_D16_UNORM_S8_UINT..VK_FORMAT_D32_SFLOAT_S8_UINT
    if (depthFormat >= VK_FORMAT_D16_UNORM_S8_UINT) {
        imageViewCI.subresourceRange.aspectMask |= VK_IMAGE_ASPECT_STENCIL_BIT;
    }
    VK_CHECK_RESULT(vkCreateImageView(ctx->deviceHandle(), &imageViewCI, nullptr, &depthStencil.view));
}
void VkApp::setupDepthStencil() {…}
 
void VkApp::setupFrameBuffer()
{
    VkImageView attachments[2];
 
    // Depth/Stencil attachment is the same for all frame buffers
    attachments[1] = depthStencil.view;
 
    VkFramebufferCreateInfo frameBufferCreateInfo = {};
    frameBufferCreateInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
    frameBufferCreateInfo.pNext = NULL;
    frameBufferCreateInfo.renderPass = renderPass;
    frameBufferCreateInfo.attachmentCount = 2;
    frameBufferCreateInfo.pAttachments = attachments;
    frameBufferCreateInfo.width = width;
    frameBufferCreateInfo.height = height;
    frameBufferCreateInfo.layers = 1;
 
    // Create frame buffers for every swap chain image
    frameBuffers.resize(swapChain.imageCount);
    for (uint32_t i = 0; i < frameBuffers.size(); i++)
    {
        attachments[0] = swapChain.buffers[i].view;
        VK_CHECK_RESULT(vkCreateFramebuffer(ctx->deviceHandle(), &frameBufferCreateInfo, nullptr, &frameBuffers[i]));
    }
}
void VkApp::setupFrameBuffer() {…}
 
void VkApp::setupRenderPass()
{
    std::array<VkAttachmentDescription, 2> attachments = {};
    // Color attachment
    attachments[0].format = 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_UNDEFINED;
    attachments[0].finalLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
    // Depth attachment
    attachments[1].format = depthFormat;
    attachments[1].samples = VK_SAMPLE_COUNT_1_BIT;
    attachments[1].loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
    attachments[1].storeOp = VK_ATTACHMENT_STORE_OP_STORE;
    attachments[1].stencilLoadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
    attachments[1].stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
    attachments[1].initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
    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 subpassDescription = {};
    subpassDescription.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
    subpassDescription.colorAttachmentCount = 1;
    subpassDescription.pColorAttachments = &colorReference;
    subpassDescription.pDepthStencilAttachment = &depthReference;
    subpassDescription.inputAttachmentCount = 0;
    subpassDescription.pInputAttachments = nullptr;
    subpassDescription.preserveAttachmentCount = 0;
    subpassDescription.pPreserveAttachments = nullptr;
    subpassDescription.pResolveAttachments = nullptr;
 
    // Subpass dependencies for layout transitions
    std::array<VkSubpassDependency, 2> dependencies;
 
    dependencies[0].srcSubpass = VK_SUBPASS_EXTERNAL;
    dependencies[0].dstSubpass = 0;
    dependencies[0].srcStageMask = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;
    dependencies[0].dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
    dependencies[0].srcAccessMask = VK_ACCESS_MEMORY_READ_BIT;
    dependencies[0].dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
    dependencies[0].dependencyFlags = VK_DEPENDENCY_BY_REGION_BIT;
 
    dependencies[1].srcSubpass = 0;
    dependencies[1].dstSubpass = VK_SUBPASS_EXTERNAL;
    dependencies[1].srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
    dependencies[1].dstStageMask = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;
    dependencies[1].srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
    dependencies[1].dstAccessMask = VK_ACCESS_MEMORY_READ_BIT;
    dependencies[1].dependencyFlags = VK_DEPENDENCY_BY_REGION_BIT;
 
    VkRenderPassCreateInfo renderPassInfo = {};
    renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
    renderPassInfo.attachmentCount = static_cast<uint32_t>(attachments.size());
    renderPassInfo.pAttachments = attachments.data();
    renderPassInfo.subpassCount = 1;
    renderPassInfo.pSubpasses = &subpassDescription;
    renderPassInfo.dependencyCount = static_cast<uint32_t>(dependencies.size());
    renderPassInfo.pDependencies = dependencies.data();
 
    VK_CHECK_RESULT(vkCreateRenderPass(ctx->deviceHandle(), &renderPassInfo, nullptr, &renderPass));
}
void VkApp::setupRenderPass() {…}
 
void VkApp::getEnabledFeatures() {}
 
void VkApp::windowResize()
{
    if (!prepared)
    {
        return;
    }
    prepared = false;
    resized = true;
 
    // Ensure all operations on the device have been finished before destroying resources
    vkDeviceWaitIdle(ctx->deviceHandle());
 
    // Recreate swap chain
    width = destWidth;
    height = destHeight;
    setupSwapChain();
 
    // Recreate the frame buffers
    vkDestroyImageView(ctx->deviceHandle(), depthStencil.view, nullptr);
    vkDestroyImage(ctx->deviceHandle(), depthStencil.image, nullptr);
    vkFreeMemory(ctx->deviceHandle(), depthStencil.mem, nullptr);
    setupDepthStencil();
    for (uint32_t i = 0; i < frameBuffers.size(); i++) {
        vkDestroyFramebuffer(ctx->deviceHandle(), frameBuffers[i], nullptr);
    }
    setupFrameBuffer();
 
    if ((width > 0.0f) && (height > 0.0f)) {
        if (settings.overlay) {
            UIOverlay.resize(width, height);
        }
    }
 
    // Command buffers need to be recreated as they may store
    // references to the recreated frame buffer
    destroyCommandBuffers();
    createCommandBuffers();
    buildCommandBuffers();
 
    vkDeviceWaitIdle(ctx->deviceHandle());
 
    if ((width > 0.0f) && (height > 0.0f)) {
        camera.updateAspectRatio((float)width / (float)height);
    }
 
    // Notify derived class
    windowResized();
    viewChanged();
 
    prepared = true;
}
void VkApp::windowResize() {…}
 
void VkApp::handleMouseMove(int32_t x, int32_t y)
{
    int32_t dx = (int32_t)mousePos.x - x;
    int32_t dy = (int32_t)mousePos.y - y;
 
    bool handled = false;
 
    if (settings.overlay) {
        ImGuiIO& io = ImGui::GetIO();
        handled = io.WantCaptureMouse;
    }
    mouseMoved((float)x, (float)y, handled);
 
    if (handled) {
        mousePos = glm::vec2((float)x, (float)y);
        return;
    }
 
    if (mouseButtons.left) {
        camera.rotate(glm::vec3(dy * camera.rotationSpeed, -dx * camera.rotationSpeed, 0.0f));
        viewUpdated = true;
    }
    if (mouseButtons.right) {
        camera.translate(glm::vec3(-0.0f, 0.0f, dy * .005f));
        viewUpdated = true;
    }
    if (mouseButtons.middle) {
        camera.translate(glm::vec3(-dx * 0.01f, -dy * 0.01f, 0.0f));
        viewUpdated = true;
    }
    mousePos = glm::vec2((float)x, (float)y);
}
void VkApp::handleMouseMove(int32_t x, int32_t y) {…}
 
void VkApp::windowResized() {}
 
void VkApp::initSwapchain()
{
#if defined(_WIN32)
    swapChain.initSurface(windowInstance, window);
#elif defined(VK_USE_PLATFORM_ANDROID_KHR)
    swapChain.initSurface(androidApp->window);
#endif
}
void VkApp::initSwapchain() {…}
 
void VkApp::setupSwapChain()
{
    swapChain.create(&width, &height, settings.vsync);
}
void VkApp::setupSwapChain() {…}
 
void VkApp::OnUpdateUIOverlay(vks::UIOverlay *overlay) {}
 
void VkApp::buildCustomCommandBuffer(VkCommandBuffer commandBuffer)
{
    auto scn = dyno::SceneGraphFactory::instance()->active();
 
    for (auto it = scn->begin(); it != scn->end(); it++)
    {
        for (auto iter : it->graphicsPipeline()->activeModules())
        {
            auto m = dynamic_cast<dyno::VkVisualModule*>(iter.get());
            if (m && m->isVisible())
            {
                //m->update();
                m->buildCommandBuffers(commandBuffer);
            }
        }
    }
}
void VkApp::buildCustomCommandBuffer(VkCommandBuffer commandBuffer) {…}
 
 
void VkApp::prepare(VkRenderPass renderPass)
{
    auto scn = dyno::SceneGraphFactory::instance()->active();
 
    for (auto it = scn->begin(); it != scn->end(); it++)
    {
        for (auto iter : it->graphicsPipeline()->activeModules())
        {
            auto m = dynamic_cast<dyno::VkVisualModule*>(iter.get());
            if (m && m->isVisible())
            {
                m->prepare(renderPass);
            }
        }
    }
}
void VkApp::prepare(VkRenderPass renderPass) {…}
 
 
void VkApp::setWindowTitle(std::string name)
{
    title = name;
}
void VkApp::setWindowTitle(std::string name) {…}
 
void VkApp::setSceneGraph(std::shared_ptr<dyno::SceneGraph> scn)
{
    dyno::SceneGraphFactory::instance()->pushScene(scn);
}
void VkApp::setSceneGraph(std::shared_ptr<dyno::SceneGraph> scn) {…}