App.h

#pragma once
 
#include "Common.h"
 
#include "Camera.h"
#include "Device.h"
#include "Pass.h"
#include "Pipeline.h"
#include "Swapchain.h"
 
namespace Mandrill
{
    class MANDRILL_API App
    {
    public:
        App(const std::string& title, uint32_t width = 1280, uint32_t height = 720);
 
        ~App();
 
        void run();
 
    protected:
        virtual void update(float delta) = 0;
 
        virtual void render() = 0;
 
        virtual void appGUI(ImGuiContext* pContext) = 0;
 
        // virtual void onMouseEvent() = 0;
 
        void createGUI(ptr<Device> pDevice, ptr<Pass> pPass);
 
        void destroyGUI(ptr<Device> pDevice);
 
        void baseGUI(ptr<Device> pDevice, ptr<Swapchain> pSwapchain, ptr<Pipeline> pPipeline);
 
        void baseGUI(ptr<Device> pDevice, ptr<Swapchain> pSwapchain, std::vector<ptr<Pipeline>> pPipelines);
 
        void renderGUI(VkCommandBuffer cmd) const;
 
        void baseKeyCallback(GLFWwindow* pWindow, int key, int scancode, int action, int mods, ptr<Device> pDevice,
                             ptr<Swapchain> pSwapchain, ptr<Pipeline> pPipeline);
 
        void baseKeyCallback(GLFWwindow* pWindow, int key, int scancode, int action, int mods, ptr<Device> pDevice,
                             ptr<Swapchain> pSwapchain, std::vector<ptr<Pipeline>> pPipelines);
 
        virtual void appKeyCallback(GLFWwindow* pWindow, int key, int scancode, int action, int mods) = 0;
 
        void baseCursorPosCallback(GLFWwindow* pWindow, double xPos, double yPos);
 
        virtual void appCursorPosCallback(GLFWwindow* pWindow, double xPos, double yPos) = 0;
 
        void baseMouseButtonCallback(GLFWwindow* pWindow, int button, int action, int mods, ptr<Camera> pCamera);
 
        virtual void appMouseButtonCallback(GLFWwindow* pWindow, int button, int action, int mods) = 0;
 
        glm::vec2 getCursorDelta() const
        {
            return {mCursorDeltaX, mCursorDeltaY};
        }
 
        bool keyboardCapturedByGUI() const
        {
            return mKeyboardCapturedByGUI;
        }
 
        bool mouseCapturedByGUI() const
        {
            return mMouseCapturedByGUI;
        }
 
        // GLFW window
        GLFWwindow* mpWindow;
 
    protected:
        // Screen resolution
        uint32_t mWidth, mHeight;
 
        // Time since application started in seconds
        float mTime = 0.0f;
 
    private:
        void initGLFW(const std::string& title, uint32_t width, uint32_t height);
 
        void initImGUI();
 
        ImGuiContext* newFrameGUI();
 
        void takeScreenshot(ptr<Swapchain> pSwapchain);
 
        void toggleFullscreen();
 
        void resetFramebufferSize();
 
        static void keyCallbackEntry(GLFWwindow* pWindow, int key, int scancode, int action, int mods);
 
        static void cursorPosCallbackEntry(GLFWwindow* pWindow, double xPos, double yPos);
 
        static void mouseButtonCallbackEntry(GLFWwindow* pWindow, int button, int action, int mods);
 
        // Time since last frame in seconds
        float mDelta = 0.0f;
 
        // Smoothed delta for GUI presentation
        float mDeltaSmooth = 0.0f;
 
        // Give new delta sample 5% weight
        const float kSmoothingFactor = 0.05f;
 
        // Screen mode
        GLFWmonitor* mpMonitor;
        GLFWvidmode mFullscreenMode;
        bool mFullscreen = false;
 
        // Mouse movement
        float mCursorX = 0.0f, mCursorY = 0.0f;
        float mCursorDeltaX = 0.0f, mCursorDeltaY = 0.0f;
        float mCursorPrevX = 0.0f, mCursorPrevY = 0.0f;
 
        // GUI
        bool mCreatedGUI = false;
        bool mShowMainMenu = true;
        bool mShowFrameRate = false;
        bool mShowHelp = false;
        bool mShowAbout = false;
 
        // Flags for GUI input capture
        bool mKeyboardCapturedByGUI;
        bool mMouseCapturedByGUI;
 
        // Descriptor pool for ImGUI
        VkDescriptorPool mDescriptorPool;
 
        // Font for ImGUI
        ImFont* mFont;
    };
} // namespace Mandrill