GLFWQtWindowImpl.h

Go to the documentation of this file.

#ifndef WINDOW_H
#define WINDOW_H
 
#include <GLFW/glfw3.h>
 
#include <iostream>
#include <memory>
#include <stdexcept>
 
#include "WindowBase.h"
#include "logging/Loggable.h"
#include "utils/misc.h"
#include "window/prompt/GuiMessageBox.h"
#include "window/prompt/TextInputDialog.h"
 
namespace gui::window {
    template <typename RendererImpl, typename Canvas>
    class GLFWQtWindowImpl
        : protected business_logic::Loggable<GLFWQtWindowImpl<RendererImpl, Canvas>>,
          public window::WindowBase<Canvas> {
       public:
        explicit GLFWQtWindowImpl(int width, int height, const char* title)
            : business_logic::Loggable<GLFWQtWindowImpl<RendererImpl, Canvas>>(),
              window::WindowBase<Canvas>(width, height, logger) {
            initGLFW();
 
            initializeGLFWWindow(width, height, title);
 
            postInitialize();
        }
 
        static GLFWQtWindowImpl<RendererImpl, Canvas> MakeFullscreen(const char* title) {
            initGLFW();
 
            // Get primary monitor
            GLFWmonitor* primaryMonitor = glfwGetPrimaryMonitor();
            if (primaryMonitor == nullptr) {
                throw std::runtime_error("Failed to get primary monitor");
            }
 
            // Get video mode (which contains screen width and height)
            const GLFWvidmode* videoMode = glfwGetVideoMode(primaryMonitor);
            if (videoMode == nullptr) {
                throw std::runtime_error("Failed to get primary monitor's video mode");
            }
 
            return GLFWQtWindowImpl<RendererImpl, Canvas>(
                std::round(videoMode->width * 0.6), std::round(videoMode->height * 0.6), title);
        };
 
        // disable copy semantics
        GLFWQtWindowImpl(const GLFWQtWindowImpl&) = delete;
        GLFWQtWindowImpl& operator=(const GLFWQtWindowImpl&) = delete;
 
        // disable move semantics
        GLFWQtWindowImpl(GLFWQtWindowImpl&&) = delete;
        GLFWQtWindowImpl& operator=(GLFWQtWindowImpl&&) = delete;
 
        void postInitialize() {
            // initially invoke window->handleMouseMove
            // NOLINTNEXTLINE(cppcoreguidelines-init-variables)
            double mouseX;
            // NOLINTNEXTLINE(cppcoreguidelines-init-variables)
            double mouseY;
            glfwGetCursorPos(glfwWindow, &mouseX, &mouseY);
 
            this->handleMouseMove(mouseX, mouseY);
        }
 
        ~GLFWQtWindowImpl() override {
            logger->info("GLFWQtWindowImpl {} is being destroyed",
                         business_logic::stringifyAddressOf(this));
 
            if (glfwWindow != nullptr) {
                glfwDestroyWindow(glfwWindow);
            }
            glfwTerminate();
 
            logger->info("GLFWQtWindowImpl {} has been destroyed",
                         business_logic::stringifyAddressOf(this));
        }
 
        void run() override {
            while (!shouldClose()) {
                glfwPollEvents();
 
                renderer->render();
 
                // swap front and back buffers
                glfwSwapBuffers(glfwWindow);
            }
 
            logger->info("shouldClose() returned true, exiting gracefully");
        };
 
        explicit operator GLFWwindow*() const { return glfwWindow; }
 
       private:
        // since Loggable is a template base class, the compiler does not see Logger::logger in the
        // current scope; so as not to use this->logger explicitly each time, the below brings it to
        // the current scope explicitly
        using business_logic::Loggable<GLFWQtWindowImpl<RendererImpl, Canvas>>::logger;
 
        GLFWwindow* glfwWindow{};
        inline static bool initializedGLFW;
 
        std::unique_ptr<RendererImpl> renderer;
 
        static void initGLFW() {
            if (!initializedGLFW) {
                std::cout << "Initializing GLFW" << std::endl;
 
                if (glfwInit() != 0) {
                    glfwSetErrorCallback([](int error, const char* description) {
                        std::cerr << "GLFW Error " << error << ": " << description << std::endl;
                    });
 
                    std::cout << "Initialized GLFW" << std::endl;
 
                    initializedGLFW = true;
                } else {
                    throw std::runtime_error("Failed to initialize GLFW");
                }
            }
        };
 
        bool shouldClose() const override { return glfwWindowShouldClose(glfwWindow) != 0; }
 
        void initializeGLFWWindow(int width, int height, const char* title) {
            glfwWindowHint(GLFW_RESIZABLE, GLFW_TRUE);
            glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
            glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
            glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
            glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
            glfwWindowHint(GLFW_STENCIL_BITS, 0);
            glfwWindowHint(GLFW_DEPTH_BITS, 0);
 
            glfwWindow = glfwCreateWindow(width, height, title, nullptr, nullptr);
 
            logger->info(
                "Creating window with title: {} and initial size: {}x{}", title, width, height);
 
            if (glfwWindow == nullptr) {
                glfwTerminate();
                throw std::runtime_error("Failed to create GLFW window");
            }
 
            glfwMakeContextCurrent(glfwWindow);
            glfwSwapInterval(1);
            glfwSetWindowUserPointer(glfwWindow, this);
            glfwSetWindowSizeCallback(glfwWindow,
                                      [](GLFWwindow* glfwWindow, int winWidth, int winHeight) {
                                          handleWindowResized(glfwWindow, winWidth, winHeight);
                                      });
 
            glfwSetKeyCallback(glfwWindow,
                               [](GLFWwindow* glfwWindow,
                                  int key,
                                  [[maybe_unused]] int scancode,
                                  int action,
                                  [[maybe_unused]] int mods) {
                                   if (action == GLFW_PRESS) {
                                       if (key >= GLFW_KEY_0 && key <= GLFW_KEY_9) {
                                           auto* window = static_cast<WindowBase<Canvas>*>(
                                               glfwGetWindowUserPointer(glfwWindow));
 
                                           int number = key - GLFW_KEY_0;
                                           window->handleNumericKeyPress(number);
                                       } else if (key == GLFW_KEY_ESCAPE) {
                                           auto* window = static_cast<WindowBase<Canvas>*>(
                                               glfwGetWindowUserPointer(glfwWindow));
 
                                           window->handleEscapeKeyPress();
                                       }
                                   }
                               });
 
            glfwSetMouseButtonCallback(
                glfwWindow,
                [](GLFWwindow* glfwWindow, int button, int action, [[maybe_unused]] int mods) {
                    if (button == GLFW_MOUSE_BUTTON_LEFT && action == GLFW_PRESS) {
                        auto* window =
                            static_cast<WindowBase<Canvas>*>(glfwGetWindowUserPointer(glfwWindow));
 
                        window->handleMouseDown();
                    } else if (button == GLFW_MOUSE_BUTTON_LEFT && action == GLFW_RELEASE) {
                        auto* window =
                            static_cast<WindowBase<Canvas>*>(glfwGetWindowUserPointer(glfwWindow));
 
                        window->handleMouseUp();
                    } else if (button == GLFW_MOUSE_BUTTON_RIGHT && action == GLFW_PRESS) {
                        auto* window =
                            static_cast<WindowBase<Canvas>*>(glfwGetWindowUserPointer(glfwWindow));
 
                        window->handleRightClick();
                    }
                });
            glfwSetCursorPosCallback(glfwWindow, [](GLFWwindow* glfwWindow, double x, double y) {
                auto* window =
                    static_cast<WindowBase<Canvas>*>(glfwGetWindowUserPointer(glfwWindow));
 
                window->handleMouseMove(x, y);
            });
 
            // NOLINTNEXTLINE(cppcoreguidelines-init-variables)
            int fbWidth;
            // NOLINTNEXTLINE(cppcoreguidelines-init-variables)
            int fbHeight;
            glfwGetFramebufferSize(glfwWindow, &fbWidth, &fbHeight);
 
            renderer = std::make_unique<RendererImpl>(this, this->blocksManager);
 
            handleWindowResized(glfwWindow, width, height);
        }
 
        static void handleWindowResized(GLFWwindow* window, int winWidth, int winHeight) {
            auto* self = static_cast<GLFWQtWindowImpl*>(glfwGetWindowUserPointer(window));
 
            if (self && self->renderer) {
                // NOLINTNEXTLINE(cppcoreguidelines-init-variables)
                int fbWidth;
                // NOLINTNEXTLINE(cppcoreguidelines-init-variables)
                int fbHeight;
                glfwGetFramebufferSize(window, &fbWidth, &fbHeight);
 
                self->winSize = {.width = winWidth, .height = winHeight};
                self->framebufferSize = {.width = fbWidth, .height = fbHeight};
 
                float xScale = static_cast<float>(fbWidth) / static_cast<float>(winWidth);
                float yScale = static_cast<float>(fbHeight) / static_cast<float>(winHeight);
 
                self->logger->info(
                    "Informing renderer {} of window size change to {}x{}, framebuffer size to "
                    "{}x{} "
                    "and scales to {:.2f}x{:.2f}",
                    business_logic::stringifyAddressOf(self->renderer.get()),
                    winWidth,
                    winHeight,
                    fbWidth,
                    fbHeight,
                    xScale,
                    yScale);
 
                self->renderer->handleWindowResized(self, xScale, yScale);
            }
        }
 
        void focusWindow() override { glfwFocusWindow(glfwWindow); }
 
        void showWarning(const std::string& title, const std::string& message) override {
            gui::window::prompt::GuiMessageBox::showWarning(title, message, this);
        }
 
        std::optional<FloatingPoint> promptFloatingPointInput(
            const std::string& title,
            const std::string& message,
            const std::optional<FloatingPoint>& defaultValue) override {
            return gui::window::prompt::TextInputDialog::promptForFloatingPointInput(
                title, message, defaultValue, this);
        }
 
        bool promptConfirmation(const std::string& title, const std::string& message) override {
            return gui::window::prompt::GuiMessageBox::promptConfirmation(title, message, this);
        }
    };
}  // namespace gui::window
 
#endif  // WINDOW_H