App.h

Go to the documentation of this file.

 
#pragma once

 
#include "Asset/AssetLoader.h"
#include "Conf/Constants.h"
#include "Core/AppSettings.h"
#include "Core/Manager.h"
#include "Drawing/EditorController.h"
#include "Keybinds/Keybinds.h"
#include "Platform/Window.h"
#include "Project/Project.h"
#include "Registries/PopupRegistry.h"
#include "UI/Themes.h"
#include "UI/UIManager.h"
#include "Util/Ptr.h"
#include "Util/UUID.h"
 
#include <chrono>
#include <functional>
#include <string>
 
namespace FuncDoodle {
    class Application {
        public:
        Application();
        ~Application();
        static Application* Get() { return s_Instance; };
        void Run();
        void InitImGui();
        void RenderImGui();

        void RenderFrame(double dt);
        void OpenFileDialog(std::function<void()> done);
        void SaveFileDialog(std::function<void()> done);
        void ReadProjectFile();
        void SaveProjectFile();
        void RegisterKeybinds();
        void OpenSaveChangesDialog();
        bool SaveChangesDialogOpen() {
            return m_UiManager.GetPopups().IsOpen("save_changes");
        }

        void HideCursor();
        void ShowCursor();

        static void ApplyThemeStyle(const ImGuiStyle& themeStyle) {
            ImGuiStyle& style = ImGui::GetStyle();
            style = themeStyle;
            if (ImGui::GetIO().ConfigFlags & ImGuiConfigFlags_ViewportsEnable) {
                style.WindowRounding = 1.0f;
            }
        }

        static void ApplyThemeUuid(const FuncDoodle::UUID& uuid) {
            auto it = FuncDoodle::Themes::g_Themes.find(uuid);
            if (it != FuncDoodle::Themes::g_Themes.end()) {
                ApplyThemeStyle(it->second.Style);
                return;
            }
            auto defUuid = FuncDoodle::UUID::FromString(
                FuncDoodle::Themes::s_DefaultTheme);
            auto defIt = FuncDoodle::Themes::g_Themes.find(defUuid);
            if (defIt != FuncDoodle::Themes::g_Themes.end()) {
                ApplyThemeStyle(defIt->second.Style);
            }
        }

        std::chrono::time_point<std::chrono::high_resolution_clock>
        GetLastFrame() {
            return m_LastFrame;
        }

        SharedPtr<ProjectFile> GetCurProj() { return m_CurrentProj; }

        void SetCurProj(SharedPtr<ProjectFile> proj) { m_CurrentProj = proj; }
        SharedPtr<ProjectFile> GetCacheProj() { return m_CacheProj; }
        void SetCacheProj(SharedPtr<ProjectFile> proj) { m_CacheProj = proj; }
        AssetLoader* GetAssetLoader() { return m_AssetLoader.get(); }
        bool GetShouldClose() const { return m_ShouldClose; }
        UUID GetTheme() { return m_Theme; }
        void SetTheme(UUID theme) { m_Theme = theme; }
        void SetFrameLimit(double frameLimit) {
            m_Settings.FrameLimit = frameLimit;
        }

        void SetShouldClose(bool shouldClose) { m_ShouldClose = shouldClose; }

        Platform::Window* GetWindow() { return &m_Window; }
        AppSettings& GetSettings() { return m_Settings; }
        double GetFrameTime() const { return 1.0 / m_Settings.FrameLimit; }
        KeybindsRegistry& GetKeybinds() { return m_Keybinds; }
        ExportFormat GetExportFormat() const { return m_ExportFormat; }
        UIManager& GetUiManager() { return m_UiManager; }
        ExportFormat& GetExportFormatPtr() { return m_ExportFormat; }
        std::filesystem::path GetThemesPath() { return m_ThemesPath; }
        double& GetFrameLimitCache() { return m_FrameLimitCache; }
        void SetExportFormat(ExportFormat format) { m_ExportFormat = format; }

        AnimationManager* GetManager() { return m_Manager.get(); }

        SharedPtr<EditorController> GetController() {
            return m_EditorController;
        }

        [[nodiscard]] Platform::Window GetWindow() const { return m_Window; }

        void UpdateFPS(double deltaTime);
        void DropCallback(int count, const char** paths);
        void Update();
        void Save(bool exit = false);
        void CloseCurrentProject();
        void SaveAt(const char* path);
        void RenderRotate();

        inline double GetDt() { return m_DeltaTime; }

        void Rotate(int32_t deg);
 
        // lol idk what to call this
        enum class Where { Before = 0, After = 1 };
        void Import(Where where);

        void DeleteCurrentSelection();
        void MoveCurrentSelection(Direction direction);
        static bool IsPosInFrame(ImVec2 pos);
 
        private:
        std::string m_FilePath;
        UIManager m_UiManager;
        AppSettings m_Settings;
        KeybindsRegistry m_Keybinds;
        SharedPtr<ProjectFile> m_CurrentProj;
        SharedPtr<ProjectFile> m_CacheProj;
        UniquePtr<AnimationManager> m_Manager;
        Platform::Window m_Window;
        UniquePtr<AssetLoader> m_AssetLoader;
        SharedPtr<EditorController> m_EditorController;
        ExportFormat m_ExportFormat = ExportFormat::MP4;
        UUID m_Theme;
        bool m_ShouldClose = false;
        bool m_ShowTests = true;
        double m_FrameLimitCache = 1000.0;
        double m_LastFrameTime = 0.0;
        std::chrono::time_point<std::chrono::high_resolution_clock> m_LastFrame;
        double m_FPS = 0.0;
        std::array<float, 3> m_CacheBGCol;
        std::filesystem::path m_ThemesPath;
        double m_DeltaTime;
        static Application* s_Instance;
    };
}  // namespace FuncDoodle