Editor.hpp

Go to the documentation of this file.

 
#pragma once
#include "Engine.hpp"
#include "EditorCamera.hpp"
#include "EditorCommands.hpp"
 
#include "EditorProperties.hpp"
#include "ProjectProperties.hpp"
 
#include "Tools/EditorMenuBar.hpp"
#include "Tools/AssetBrowser.hpp"
 
#include "components/DebugConsole.hpp"
 
#include <ImGuizmo.h>
#include <nlohmann/json.hpp>
 
#include <memory>
#include <deque>
#include <stack>
 
namespace vex {
 
    struct SceneRenderData;

    class Editor : public Engine {
    public:

        Editor(const char* title, int width, int height, GameInfo gInfo, const std::string& projectBinaryPath);
        ~Editor(){}

        void render() override;

        void update(float deltaTime) override;

        void processEvent(const SDL_Event& event, float deltaTime) override;

        void setFullscreen(bool enabled, bool exclusive = false) override { /*pass*/ };

        void requestSceneReload(const std::string& scenePath);

        std::string getProjectBinaryPath() const { return m_projectBinaryPath; }

        AssetBrowser* getAssetBrowser() const { return m_assetBrowser.get(); }

        const BrowserIcons& GetEditorIcons() const { return m_icons; }

        EditorProperties* getEditorProperties() { return &m_editorProperties; }

        ProjectProperties* getProjectProperties() { return &m_projectProperties; }

        void HandleMeshDrop(const std::string& filepath, vex::Entity parent = vex::NULL_ENTITY);

        void OnHotReload();

        void refreshForObject() override {
            m_frame = 0;
            m_refresh = true;
        }

        void ProcessEditorShortcuts();

        void CopySelectedObject();

        void PasteObjectToScene();

        void DuplicateSelectedObject();

        void DeleteSelectedObject();

        void Undo();

        void Redo();

        bool IsEditor() override { return true; }

        void ShowConsole() {
            showConsole = true;
        }
    private:
        void drawEditorLayout(const SceneRenderData& data, glm::uvec2& outNewResolution);

        void drawGizmo(const glm::vec2& viewportPos, const glm::vec2& viewportSize);

        void loadAssetIcons();

        float raySphereIntersect(const glm::vec3& rayOrigin, const glm::vec3& rayDir, const glm::vec3& sphereCenter, float sphereRadius);

        float rayTriangleIntersect(const glm::vec3& rayOrigin, const glm::vec3& rayDir, const glm::vec3& v0, const glm::vec3& v1, const glm::vec3& v2);

        void ExtractObjectByEntity(vex::Entity entity, std::pair<bool, vex::GameObject*>& selectedObject);

        void SaveConfig(const EditorProperties& data, const std::string& filename) {
            std::ofstream file(filename);
            if (file.is_open()) {
                nlohmann::json j = data;
                file << j.dump(4);
            }
        }

        void LoadConfig(EditorProperties& data, const std::string& filename) {
            std::ifstream file(filename);
            if (file.is_open()) {
                try {
                    nlohmann::json j;
                    file >> j;
                    data = j;
                } catch (const std::exception& e) {
                    //std::cerr << "JSON parsing error: " << e.what() << std::endl;
                    vex::handle_exception(e);
                }
            }
        }

        void SaveProjectConfig(const ProjectProperties& data, const std::string& filename) {
            std::ofstream file(filename);
            if (file.is_open()) {
                nlohmann::json j = data;
                file << j.dump(4);
            }
        }

        void LoadProjectConfig(ProjectProperties& data, const std::string& filename) {
            std::ifstream file(filename);
            if (file.is_open()) {
                try {
                    nlohmann::json j;
                    file >> j;
                    data = j;
                } catch (const std::exception& e) {
                    //std::cerr << "JSON parsing error: " << e.what() << std::endl;
                    vex::handle_exception(e);
                }
            }
        }
 
        std::deque<std::unique_ptr<ICommand>> m_undoStack;
        std::deque<std::unique_ptr<ICommand>> m_redoStack;
        const size_t MAX_UNDO_STEPS = 50;

        void PushCommand(ICommand* cmd) {
            m_undoStack.push_back(std::unique_ptr<ICommand>(cmd));
            if (m_undoStack.size() > MAX_UNDO_STEPS) m_undoStack.pop_front();
            m_redoStack.clear();
        }
 
        struct CopiedObjectData {
            std::string name;
            std::string type;
            std::unordered_map<std::string, nlohmann::json> components;
            bool hasData = false;
        } m_clipboard;
 
        bool m_gizmoWasUsing = false;
        glm::vec3 m_gizmoStartPos;
        glm::vec3 m_gizmoStartRot;
        glm::vec3 m_gizmoStartScale;
 
        bool m_isAssetBrowserFocused = false;
 
        glm::uvec2 m_viewportSize = {1280, 720};
        std::unique_ptr<EditorCameraObject> m_camera;
        std::unique_ptr<EditorMenuBar> m_editorMenuBar;
        std::pair<bool, GameObject*> m_selectedObject = {false, nullptr};
        std::unique_ptr<AssetBrowser> m_assetBrowser;
        BrowserIcons m_icons;
 
        std::string m_pendingSceneToLoad = "";
        bool m_waitForGui = true;
 
        std::string m_projectBinaryPath;
 
        ImGuizmo::OPERATION m_currentGizmoOperation = ImGuizmo::TRANSLATE;
        ImGuizmo::MODE m_currentGizmoMode = ImGuizmo::WORLD;
        bool m_useSnap = false;
        float m_snapValue[3] = { 0.5f, 0.5f, 0.5f };
 
        bool m_isHoveringGizmoUI = false;
 
        EditorProperties m_editorProperties;
        EditorProperties m_SavedEditorProperties;
 
        ProjectProperties m_projectProperties;
        ProjectProperties m_SavedProjectProperties;
 
        int m_fps = 0;
 
        bool m_refresh = false;
        bool showConsole = false;
    };
 
}