VkApp.h

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)
*/
 
#pragma once
 
#ifdef _WIN32
#pragma comment(linker, "/subsystem:windows")
#include <windows.h>
#include <fcntl.h>
#include <io.h>
#include <ShellScalingAPI.h>
#elif defined(VK_USE_PLATFORM_ANDROID_KHR)
#include <android/native_activity.h>
#include <android/asset_manager.h>
#include <android_native_app_glue.h>
#include <sys/system_properties.h>
#include "VulkanAndroid.h"
#endif
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <vector>
#include <array>
#include <numeric>
#include <ctime>
#include <iostream>
#include <chrono>
#include <random>
#include <algorithm>
#include <sys/stat.h>
 
#define GLM_FORCE_RADIANS
#define GLM_FORCE_DEPTH_ZERO_TO_ONE
#define GLM_ENABLE_EXPERIMENTAL
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/matrix_inverse.hpp>
#include <glm/gtc/type_ptr.hpp>
#include <string>
#include <numeric>
#include <array>
 
#include "vulkan/vulkan.h"
 
#include "Keys.h"
#include "VulkanTools.h"
#include "VulkanDebug.h"
#include "VulkanUIOverlay.h"
#include "VulkanSwapChain.h"
#include "VulkanBuffer.h"
#include "VulkanTexture.h"
 
#include "VulkanInitializers.hpp"
#include "Camera.h"
 
#include "VkContext.h"
 
namespace dyno
{
    class SceneGraph;
}
 
 
class VkApp
{
private:
    std::string getWindowTitle();
    bool viewUpdated = false;
    uint32_t destWidth;
    uint32_t destHeight;
    bool resizing = false;
    void windowResize();
    void handleMouseMove(int32_t x, int32_t y);
    void nextFrame();
    void updateOverlay();
    void createCommandPool();
    void createSynchronizationPrimitives();
    void initSwapchain();
    void setupSwapChain();
    void createCommandBuffers();
    void destroyCommandBuffers();
    std::string shaderDir = "glsl";
protected:
    // Returns the path to the root of the glsl or hlsl shader directory.
    std::string getShadersPath() const;
 
    // Frame counter to display fps
    uint32_t frameCounter = 0;
    uint32_t lastFPS = 0;
    std::chrono::time_point<std::chrono::high_resolution_clock> lastTimestamp;
    // Vulkan instance, stores all per-application states

    std::vector<const char*> enabledDeviceExtensions;
    std::vector<const char*> enabledInstanceExtensions;
    void* deviceCreatepNextChain = nullptr;
    //VkDevice device;
    // Handle to the device graphics queue that command buffers are submitted to
    //VkQueue queue;
    // Depth buffer format (selected during Vulkan initialization)
    VkFormat depthFormat;
    // Command buffer pool
    VkCommandPool cmdPool;
    VkPipelineStageFlags submitPipelineStages = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
    // Contains command buffers and semaphores to be presented to the queue
    VkSubmitInfo submitInfo;
    // Command buffers used for rendering
    std::vector<VkCommandBuffer> drawCmdBuffers;
    // Global render pass for frame buffer writes
    VkRenderPass renderPass;
    // List of available frame buffers (same as number of swap chain images)
    std::vector<VkFramebuffer>frameBuffers;
    // Active frame buffer index
    uint32_t currentBuffer = 0;
    // Descriptor set pool
    VkDescriptorPool descriptorPool = VK_NULL_HANDLE;
    // List of shader modules created (stored for cleanup)
    std::vector<VkShaderModule> shaderModules;
//  // Pipeline cache object
//  VkPipelineCache pipelineCache;
    // Wraps the swap chain to present images (framebuffers) to the windowing system
    VulkanSwapChain swapChain;
    // Synchronization semaphores
    struct {
        // Swap chain image presentation
        VkSemaphore presentComplete;
        // Command buffer submission and execution
        VkSemaphore renderComplete;
    } semaphores;
    std::vector<VkFence> waitFences;
public:
    bool swapChainCleaned = false;
    bool prepared = false;
    bool resized = false;
    uint32_t width = 1280;
    uint32_t height = 720;
 
    vks::UIOverlay UIOverlay;

    float frameTimer = 1.0f;
 
    dyno::VkContext* ctx;

    struct Settings {
        bool validation = false;
        bool fullscreen = false;
        bool vsync = false;
        bool overlay = false;
    } settings;
 
    VkClearColorValue defaultClearColor = { { 0.025f, 0.025f, 0.025f, 1.0f } };
 
    static std::vector<const char*> args;
 
    // 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;
    bool paused = false;
 
    Camera camera;
    glm::vec2 mousePos;
 
    std::string title = "Vulkan Example";
    std::string name = "vulkanExample";
    uint32_t apiVersion = VK_API_VERSION_1_0;
 
    struct {
        VkImage image;
        VkDeviceMemory mem;
        VkImageView view;
    } depthStencil;
 
    struct {
        glm::vec2 axisLeft = glm::vec2(0.0f);
        glm::vec2 axisRight = glm::vec2(0.0f);
    } gamePadState;
 
    struct {
        bool left = false;
        bool right = false;
        bool middle = false;
    } mouseButtons;
 
    // OS specific
#if defined(_WIN32)
    HWND window;
    HINSTANCE windowInstance;
#elif defined(VK_USE_PLATFORM_ANDROID_KHR)
    // true if application has focused, false if moved to background
    bool focused = false;
    struct TouchPos {
        int32_t x;
        int32_t y;
    } touchPos;
    bool touchDown = false;
    double touchTimer = 0.0;
    int64_t lastTapTime = 0;
#endif
 
    VkApp(bool enableValidation = false);
    virtual ~VkApp();
    bool initVulkan();
 
#if defined(_WIN32)
    void setupConsole(std::string title);
    void setupDPIAwareness();
    HWND setupWindow(HINSTANCE hinstance, WNDPROC wndproc);
    void handleMessages(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
#elif defined(VK_USE_PLATFORM_ANDROID_KHR)
    static int32_t handleAppInput(struct android_app* app, AInputEvent* event);
    static void handleAppCommand(android_app* app, int32_t cmd);
#endif
    virtual void render();
    virtual void viewChanged();
    virtual void keyPressed(uint32_t);
    virtual void mouseMoved(double x, double y, bool &handled);
    virtual void windowResized();
    virtual void buildCommandBuffers();
    virtual void setupDepthStencil();
    virtual void setupFrameBuffer();
    virtual void setupRenderPass();
    virtual void getEnabledFeatures();

    virtual void prepare();

    VkPipelineShaderStageCreateInfo loadShader(std::string fileName, VkShaderStageFlagBits stage);

    void renderLoop();

    void drawUI(const VkCommandBuffer commandBuffer);

    void prepareFrame();
    void submitFrame();
    virtual void renderFrame();

    virtual void OnUpdateUIOverlay(vks::UIOverlay *overlay);
 
 
    void buildCustomCommandBuffer(VkCommandBuffer commandBuffer);
 
    void prepare(VkRenderPass renderPass);
 
    void setWindowTitle(std::string name);
 
    void setSceneGraph(std::shared_ptr<dyno::SceneGraph> scn);
};