application.h

Go to the documentation of this file.

/* Conquer Space
 * Copyright (C) 2021-2025 Conquer Space
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
#pragma once
 
#include <RmlUi/Config/Config.h>
#include <RmlUi/Core/Context.h>
#include <RmlUi/Core/Element.h>
#include <RmlUi/Core/ElementDocument.h>
#include <RmlUi/Core/ElementInstancer.h>
#include <RmlUi/Core/Event.h>
#include <RmlUi/Core/EventListener.h>
#include <RmlUi/Core/EventListenerInstancer.h>
#include <RmlUi/Core/FileInterface.h>
#include <RmlUi/Core/RenderInterface.h>
#include <RmlUi/Core/Types.h>
#include <glad/glad.h>
#include <imgui_node_editor.h>
#include <spdlog/spdlog.h>
 
#include <algorithm>
#include <map>
#include <memory>
#include <string>
#include <utility>
#include <vector>
 
#include <glm/fwd.hpp>
 
#include "core/game.h"
#include "engine/asset/assetmanager.h"
#include "engine/asset/vfs/vfs.h"
#include "engine/audio/iaudiointerface.h"
#include "engine/clientoptions.h"
#include "engine/engine.h"
#include "engine/gamestate.h"
#include "engine/graphics/text.h"
#include "engine/gui.h"
#include "engine/scene.h"
#include "engine/scenemanager.h"
#include "engine/ui/RmlUi_Platform_GLFW.h"
#include "engine/ui/numberelement.h"
#include "engine/userinput.h"
#include "engine/window.h"
#include "graphics/shader.h"
 
namespace cqsp::engine {
class Application {
 public:
    Application(int _argc, char* _argv[]);
 
    /*
    * Runs the entire application.
    */
    void run();
 
    client::ClientOptions& GetClientOptions() { return m_client_options; }
 
    int GetWindowHeight() const { return m_window->GetWindowHeight(); }
 
    int GetWindowWidth() const { return m_window->GetWindowWidth(); }
 
    double GetDeltaTime() const { return deltaTime; }
    double GetFps() const { return fps; }
 
    asset::AssetManager& GetAssetManager() { return manager; }
 
    bool ShouldExit();
 
    void ExitApplication();
 
    /*
    * Sets the next scene which will be run in the next frame.
    */
    template <class T>
    void SetScene() {
        std::unique_ptr<Scene> ptr = std::make_unique<T>(*this);
        m_scene_manager.SetScene(std::move(ptr));
    }
 
    template <class T, typename... Args>
    void SetScene(Args&&... args) {
        std::unique_ptr<Scene> ptr = std::make_unique<T>(*this, std::forward<Args>(args)...);
        m_scene_manager.SetScene(std::move(ptr));
    }
 
    GameState* GetGame() { return m_game.get(); }
 
    audio::IAudioInterface& GetAudioInterface() { return *m_audio_interface; }
 
    bool ButtonIsHeld(int btn) { return m_window->ButtonIsHeld(btn); }
    bool ButtonIsHeld(KeyInput btn) { return ButtonIsHeld(GetGlfwKey(btn)); }
 
    bool ButtonIsReleased(int btn) { return m_window->ButtonIsReleased(btn); }
    bool ButtonIsReleased(KeyInput btn) { return ButtonIsReleased(GetGlfwKey(btn)); }
 
    bool ButtonIsPressed(int btn) { return m_window->ButtonIsPressed(btn); }
    bool ButtonIsPressed(KeyInput btn) { return ButtonIsPressed(GetGlfwKey(btn)); }
 
    double MouseButtonLastReleased(int btn) { return m_window->MouseButtonLastReleased(btn); }
    bool MouseButtonDoubleClicked(int btn) { return m_window->MouseButtonDoubleClicked(btn); }
 
    double GetScrollAmount() { return m_window->GetScrollAmount(); }
 
    double GetMouseX() { return m_window->GetMouseX(); }
    double GetMouseY() { return m_window->GetMouseY(); }
 
    bool MouseButtonIsHeld(int btn) { return m_window->MouseButtonIsHeld(btn); }
    bool MouseButtonIsReleased(int btn) { return m_window->MouseButtonIsReleased(btn); }
    bool MouseButtonIsPressed(int btn) { return m_window->MouseButtonIsPressed(btn); }
 
    Rml::ElementDocument* LoadDocument(const std::string& path);
    void CloseDocument(const std::string& path);
    bool DocumentIsLoaded(const std::string& path) { return loaded_documents.contains(path); }
 
    Rml::ElementDocument* ReloadDocument(const std::string& path);
 
    Window* GetWindow() { return m_window; }
 
    asset::Font*& GetFont() { return m_font; }
    void DrawText(const std::string& text, float x, float y);
    void DrawText(const std::string& text, const glm::vec3& color, float x, float y);
    void DrawText(const std::string& text, float x, float y, float size);
    void DrawText(const std::string& text, const glm::vec3& color, float x, float y, float size);
    // Draw text based on normalized device coordinates
    void DrawTextNormalized(const std::string& text, float x, float y);
 
    void SetFont(asset::Font* font) { m_font = font; }
    void SetFontShader(asset::ShaderProgram* shader) { fontShader = shader; }
 
    double GetTime();
 
    bool MouseDragged() { return m_window->MouseDragged(); }
    bool MouseMoved() { return m_window->MouseMoved(); }
 
    void SetWindowDimensions(int width, int height);
    void SetFullScreen(bool screen);
 
    bool HoveringOnRmluiComponent();
 
    glm::mat4 Get2DProj() { return two_dim_projection; }
    glm::mat4 Get3DProj() { return three_dim_projection; }
    glm::mat4 GetRmlUiProj() { return rmlui_projection; }
 
    std::vector<std::string>& GetCmdLineArgs() { return cmd_line_args; }
 
    bool HasCmdLineArgs(const std::string& arg) {
        return (std::find(GetCmdLineArgs().begin(), GetCmdLineArgs().end(), arg) != GetCmdLineArgs().end());
    }
    bool Screenshot(const char* path = NULL);
 
    Rml::Context* GetRmlUiContext() { return rml_context; }
 
    class CqspEventInstancer : public Rml::EventListenerInstancer {
     public:
        CqspEventInstancer();
        virtual ~CqspEventInstancer();
 
        Rml::EventListener* InstanceEventListener(const Rml::String& value, Rml::Element* element) override;
    };
 
    typedef void (*EventListener)(Rml::Event&);
 
    class CqspEventListener : public Rml::EventListener {
     public:
        explicit CqspEventListener(const std::string& name) : name(name) {}
        ~CqspEventListener();
        void ProcessEvent(Rml::Event& event);
        std::string name;
    };
 
    template <class T>
    void InitGame() {
        m_game = std::make_unique<T>();
    }
 
    sol::state& GetSolState() { return lua_state; }
 
    bool RmlUiKeyboardProcessed() { return m_window->RmlUiCapturedKeyboardInput(); }
    bool RmlUiMouseProcessed() { return m_window->RmlUiCapturedMouseInput(); }
    bool RmlUiTextProcessed() { return m_window->RmlUiCapturedTextInput(); }
    bool KeyboardInteractingWithUi();
 
 private:
    void InitFonts();
 
    void SetIcon();
 
    bool GlInit();
    void LoggerInit();
    void LogInfo();
 
    void InitRmlUi();
    void InitImgui();
 
    void InitAudio();
 
    void UpdateScene();
    void ComputeFramerate();
    void UpdateFonts();
 
    /*
     * Intializes glfw and imgui.
     */
    int init();
 
    void ResetGame() { m_game.reset(); }
 
    /*
     * Releases all data.
     */
    int destroy();
 
    void CalculateProjections();
 
    class RmlFileInterface : public Rml::FileInterface {
     public:
        RmlFileInterface();
        ~RmlFileInterface();
        Rml::FileHandle Open(const Rml::String& path);
        // Closes a previously opened file.
        void Close(Rml::FileHandle file);
        // Reads data from a previously opened file.
        size_t Read(void* buffer, size_t size, Rml::FileHandle file);
 
        // Seeks to a point in a previously opened file.
        bool Seek(Rml::FileHandle file, long offset, int origin);
 
        // Returns the current position of the file pointer.
        size_t Tell(Rml::FileHandle file);
        std::string root;
    };
 
    std::vector<std::string> cmd_line_args;
    bool full_screen;
    Window* m_window;
    std::string icon_path;
 
    Rml::Context* rml_context;
    std::unique_ptr<SystemInterface_GLFW> m_system_interface;
    std::unique_ptr<Rml::FileInterface> m_file_interface;
    std::unique_ptr<Rml::RenderInterface> m_render_interface;
    ax::NodeEditor::EditorContext* m_ne_context = nullptr;
 
    std::unique_ptr<CqspEventInstancer> m_event_instancer;
 
    SceneManager m_scene_manager;
 
    client::ClientOptions m_client_options;
 
    double fps;
 
    double deltaTime, lastFrame;
 
    std::string locale;
 
    asset::AssetManager manager;
 
    std::unique_ptr<GameState> m_game;
 
    asset::Font* m_font = nullptr;
    asset::ShaderProgram* fontShader = nullptr;
 
    std::map<std::string, std::string> properties;
 
    audio::IAudioInterface* m_audio_interface;
 
    std::map<std::string, Rml::ElementDocument*> loaded_documents;
 
    glm::mat4 two_dim_projection;
    glm::mat4 three_dim_projection;
    glm::mat4 rmlui_projection;
    bool to_halt;
    sol::state lua_state;
    Rml::DataViewInstancerDefault<ui::DataViewNumber> instancer;
 
    bool draw_fps = false;
 
    ax::NodeEditor::Config node_editor_config;
};
}  // namespace cqsp::engine