EditorState.h

Go to the documentation of this file.

#pragma once
 
#if EDITOR
 
#include <array>
#include <string>
#include <set>
#include <unordered_map>
#include <vector>
#include "Maths.h"
#include "AssetRef.h"
#include "SmartPointer.h"
#include "Property.h"
#include "Enums.h"
#include "EditorTypes.h"
#include "Nodes/Widgets/Text.h"
#include "imgui.h"
#include "./ImGuizmo/ImGuizmo.h"
 
class Node;
class Scene;
class Timeline;
class TimelineInstance;
class Widget;
class Text;
class Asset;
struct AssetStub;
class AssetDir;
class ActionList;
class Canvas;
class Camera3D;
class Viewport3D;
class Viewport2D;
class PaintManager;
class VoxelSculptManager;
class TilePaintManager;
struct SubSceneOverride;
 
enum class ControlMode
{
    Default,
    Pilot,
    Translate,
    Rotate,
    Scale,
    Pan,
    Orbit
};
 
enum class TransformLock
{
    None,
    AxisX,
    AxisY,
    AxisZ,
    PlaneYZ,
    PlaneXZ,
    PlaneXY,
    Count
};
 
enum class EditorMode
{
    Scene,
    Scene2D,
    Scene3D,
 
    Count
};
 
enum class PaintMode
{
    None,
    Color,
    Instance,
    Voxel,
    Terrain,
    TilePaint,
 
    Count
};
 
enum class AssetBrowserTab
{
    Project = 0,
    Addons = 1,
    Count
};
 
struct LinkedSceneProps
{
    Node* mNode = nullptr;
    std::vector<Property> mProps;
    std::vector<SubSceneOverride> mSubSceneOverrides;
};
 
struct EditScene
{
    SceneRef mSceneAsset;
    NodePtr mRootNode;
    glm::mat4 mCameraTransform;
    std::vector<LinkedSceneProps> mLinkedSceneProps;
};
 
struct RecentScene
{
    std::string mSceneName;
    uint64_t mTimestamp = 0;
};
 
// Editor 3D viewport camera bookmark. One of 10 per-scene slots driven by the
// `View_SaveBookmark*` / `View_GotoBookmark*` editor actions. Persisted in
// EditorProject.sav, keyed by scene name.
constexpr int32_t kEditorCameraBookmarkSlotCount = 10;
 
struct EditorCameraBookmark
{
    bool mValid = false;
    glm::vec3 mPosition = { 0.0f, 0.0f, 0.0f };
    glm::quat mRotation = { 1.0f, 0.0f, 0.0f, 0.0f };
    ProjectionMode mProjectionMode = ProjectionMode::PERSPECTIVE;
    float mPerspectiveNearZ = 0.25f;
    float mPerspectiveFarZ  = 4096.0f;
    float mPerspectiveFov   = 70.0f;
    float mOrthoNearZ = -2048.0f;
    float mOrthoFarZ  = 2048.0f;
    float mOrthoWidth = 12.8f;
    float mFocalDistance = 10.0f;
};
 
using EditorCameraBookmarkArray = std::array<EditorCameraBookmark, kEditorCameraBookmarkSlotCount>;
 
// Per-asset state captured at BeginPlayInEditor and re-applied at
// EndPlayInEditor so script mutations during play don't leak into the editor.
struct PieAssetSnapshot
{
    std::vector<uint8_t> mBytes;
    bool mWasDirty = false;
};
 
struct EditorState
{
    // Data
    EditorMode mMode;
    std::vector<Node*> mSelectedNodes;
    Node* mShiftSelectAnchor = nullptr;
    int32_t mSelectedInstance = -1;
    std::vector<EditScene> mEditScenes;
    AssetStub* mSelectedAssetStub = nullptr;
    std::vector<AssetStub*> mSelectedAssetStubs;
    ControlMode mControlMode = ControlMode::Default;
    TransformLock mTransformLock = TransformLock::None;
    SharedPtr<Camera3D> mEditorCamera;
    float mPerspectiveNearZ = 0.25f;
    float mPerspectiveFarZ = 4096.0f;
    float mPerspectiveFov = 70.0f;
    float mOrthoNearZ = -2048.0f;
    float mOrthoFarZ = 2048.0f;
    float mOrthoWidth = 12.8f;
    bool mMouseNeedsRecenter = false;
    bool mUiEnabled = true;
    // Editor frame-rate cap in frames per second, 0 = uncapped. Applied at
    // the end of Engine::Update outside Play In Editor so an idle editor does
    // not spin at the display's refresh rate. Set from Preferences > General.
    int32_t mEditorFrameRateCap = 60;
    bool mPlayInEditor = false;
    bool mPlayInGameWindow = false;
    bool mEjected = false;
    bool mPaused = false;
    bool mHasEjectedOnce = false;
    bool mSavedGridEnabled = false;
 
    // One-frame latch consumed by Viewport3D's left-click selection path.
    // Set true to make the next left-click release inside the viewport NOT
    // change the selection. Plugin tools that handle their own clicks
    // (Level Builder placement etc.) set this every frame they're armed
    // via EditorUIHooks::Viewport_SuppressNextSelectionClick. Read-and-
    // cleared in Viewport3D::HandleDefaultControls, so a stale flag never
    // survives a real click.
    bool mSuppressNextSelectionClick = false;
    glm::vec4 mSavedEditorClearColor = glm::vec4(0.0f, 0.0f, 0.0f, 1.0f);
    int32_t mSavedWindowRect[4] = {}; // x, y, w, h — saved before Play Full Screen resize
    bool mSavedWindowMaximized = false; // saved before Play Full Screen resize
    bool mSavedFullscreenForPie = false; // true if BeginPlayInEditor put us in fullscreen
    int32_t mEditSceneIndex = -1;
    int32_t mPieEditSceneIdx = -1;
    std::unordered_map<Asset*, PieAssetSnapshot> mPieAssetSnapshots;
    // Lazy cache of instantiated default trees for sub-scene source assets,
    // used by the inspector to detect overridden properties and revert them.
    // Keyed by source Scene*. Invalidated when an EditScene closes, on
    // editor shutdown, and whenever a source Scene is reimported/saved.
    std::unordered_map<Scene*, NodePtr> mInspectorDefaultCache;
    // Deferred dispatch for long-running editor operations: the click/hotkey
    // handler sets the appropriate *AtEndOfFrame flag, and EditorMain.cpp
    // picks them up *after* EditorImguiDraw has returned and runs the work
    // synchronously. The EditorProgress modal pumps additional ImGui frames
    // during the work so the user sees animated progress instead of a freeze.
    bool mBeginPieAtEndOfFrame = false;
    bool mEndPieAtEndOfFrame = false;
    bool mSaveSceneAtEndOfFrame = false;
    bool mSaveSelectedAssetAtEndOfFrame = false;
    bool mResaveAllAtEndOfFrame = false;
    bool mBakeOcclusionAtEndOfFrame = false;
    bool mClearOcclusionAtEndOfFrame = false;
    // Set by World::ResolveOccludees when a baked occluder no longer matches;
    // drawn as a toast with a Re-bake button by EditorImgui.
    bool mOcclusionStaleNotice = false;
    bool mReloadScriptsAtEndOfFrame = false;
    bool mOpenProjectAtEndOfFrame = false;
    std::string mPendingOpenProjectPath;
    // Deferred "close current project" — used by File > Close Project and as
    // a precondition for Tier-2 recovery. Drained by EditorMain's per-frame
    // dispatcher alongside the open/save deferreds.
    bool mCloseProjectAtEndOfFrame = false;
    // Deferred Tier-2 recovery: drop addon DLLs, kill mspdbsrv, wipe
    // Intermediate/Plugins, reopen project. mPendingAddonRecoveryReason is
    // surfaced in logs.
    bool mAddonRecoveryAtEndOfFrame = false;
    std::string mPendingAddonRecoveryReason;
    // Deferred Tier-3 recovery: spawn a fresh editor with --addon-recovery
    // and quit the current one. The new instance does the wipe + reopen.
    bool mEditorRestartAtEndOfFrame = false;
    std::string mPendingEditorRestartReason;
    // Deferred addon install. The Addons window Download/Install buttons and
    // the native addon problem modal only queue ids here; the dispatcher runs
    // AddonsWindow::ProcessPendingInstalls outside the ImGui frame so the
    // synchronous curl download can sit under an EditorProgress modal, and
    // any native package that arrived is then rebuilt through the
    // project-restart reload.
    bool mInstallAddonsAtEndOfFrame = false;
    std::vector<std::string> mPendingAddonInstalls;
    // Deferred addon removal (ids queued dependents-first by the Addons
    // window's Remove modal). AddonsWindow::ProcessPendingUninstalls runs
    // outside the ImGui frame; loaded native addons route through the
    // project-restart machine so their DLLs unload with no scenes open.
    bool mUninstallAddonsAtEndOfFrame = false;
    std::vector<std::string> mPendingAddonUninstalls;
    // Deferred "Check for Updates": synchronous GitHub API calls sit under
    // an EditorProgress modal via AddonsWindow::ProcessPendingUpdateCheck.
    bool mCheckAddonUpdatesAtEndOfFrame = false;
    // Deferred OpenScene. Either a stub (preferred -- path is captured at
    // request time so a later directory rename doesn't break it) or empty
    // to trigger the OS file dialog inside the worker. Scene* is held as
    // a raw pointer; the asset map owns the lifetime and the dispatcher
    // runs same-tick so dangling is not realistic.
    bool mOpenSceneAtEndOfFrame = false;
    AssetStub* mPendingOpenSceneStub = nullptr;
 
    // Generic progress modal state, consumed by DrawProgressModal and driven
    // by the EditorProgress::* API. Negative fraction = indeterminate sine
    // marquee; non-negative = determinate 0..1 fill.
    bool        mProgressActive = false;
    // True only while EditorProgress is rendering one of its pumped frames.
    // Everything drawn during that frame is running nested inside whatever
    // long operation asked for the pump, so handlers that must not reenter
    // that work check this. See IsInsideProgressPump() in EditorState.cpp.
    bool        mProgressPumping = false;
    bool        mProgressCancellable = false;
    bool        mProgressCancelRequested = false;
    std::string mProgressTitle;
    std::string mProgressStatus;
    float       mProgressFraction = -1.0f;
    double      mProgressLastPumpTime = 0.0;
    AssetBrowserTab mActiveAssetTab = AssetBrowserTab::Project;
    AssetDir* mTabCurrentDir[(int)AssetBrowserTab::Count] = {};
    std::vector<AssetDir*> mTabDirPast[(int)AssetBrowserTab::Count];
    std::vector<AssetDir*> mTabDirFuture[(int)AssetBrowserTab::Count];
    std::string mTabFilterStr[(int)AssetBrowserTab::Count];
    std::vector<AssetStub*> mTabFilteredStubs[(int)AssetBrowserTab::Count];
    std::vector<Object*> mInspectPast;
    std::vector<Object*> mInspectFuture;
    Object* mInspectedObject;
    Object* mPrevInspectedObject;
    AssetRef mInspectedAsset;
    bool mInspectLocked = false;
    Viewport3D* mViewport3D = nullptr;
    Viewport2D* mViewport2D = nullptr;
    std::string mIOAssetPath;
    bool mRequestSaveSceneAs = false;
    bool mTrackSelectedAsset = false;
    bool mTrackSelectedNode = false;
    // Pending Scripts-panel reveal request. Exactly one of these is set at a
    // time; the panel consumes and clears both on the next frame it draws.
    std::string mRevealScriptName = "";
    std::string mRevealScriptPath = "";
    std::set<AssetDir*> mRevealAssetExpandDirs;
    uint32_t mViewportX = 0;
    uint32_t mViewportY = 0;
    uint32_t mViewportWidth = 100;
    uint32_t mViewportHeight = 100;
    glm::uvec4 mPrevViewport = {};
    bool mShowLeftPane = true;
    bool mShowRightPane = true;
    bool mShowInterface = true;
    bool mPreviewLighting = true;
    SharedPtr<Text> mOverlayText = nullptr;
    std::vector<std::string> mFavoritedDirs;
    std::vector<std::string> mRecentProjects;
    std::vector<RecentScene> mRecentScenes;
 
    // Per-scene camera bookmark slots, keyed by Scene asset name. Saved
    // and restored from EditorProject.sav (kEditorProjectSaveVersion >= 4).
    // Unsaved / untitled scenes use the empty-string key — those bookmarks
    // work within the session but never persist.
    std::unordered_map<std::string, EditorCameraBookmarkArray> mCameraBookmarks;
    PaintMode mPaintMode = PaintMode::None;
    PaintManager* mPaintManager = nullptr;
    VoxelSculptManager* mVoxelSculptManager = nullptr;
    class TerrainSculptManager* mTerrainSculptManager = nullptr;
    TilePaintManager* mTilePaintManager = nullptr;
 
    // ID of the currently-active addon viewport mode (Batch 15), empty when
    // no addon mode is active. Activation is mutually exclusive with the
    // built-in PaintMode: selecting an addon mode forces mMode=Scene3D and
    // mPaintMode=None; selecting any built-in entry clears this string.
    // Cross-reference: EditorUIHookManager owns the mode registrations
    // (RegisteredViewportMode) — this struct only holds the active id and
    // fires activate/deactivate callbacks via the manager on transition.
    std::string mActiveAddonViewportModeId;
 
    // Tile-paint mode stashes the editor camera's previous projection AND
    // transform so it can switch to a top-down orthographic view of the
    // currently-selected TileMap2D and restore the original camera on exit.
    bool mTilePaintProjectionStashed = false;
    bool mTilePaintPrevWasPerspective = true;
    bool mTilePaintTransformStashed = false;
    glm::vec3 mTilePaintPrevCameraPosition = { 0.0f, 0.0f, 0.0f };
    glm::quat mTilePaintPrevCameraRotation = { 1.0f, 0.0f, 0.0f, 0.0f };
    bool mNodePropertySelect = false;
    int32_t mNodePropertySelectIndex = 0;
    std::string mNodePropertySelectName = "";
    std::string mPendingSceneImportPath = "";
    std::vector<std::string> mPendingMeshImportPaths;
    // Non-mesh asset imports are queued here from ImGui-context callers
    // (menu, asset browser, OS drag-drop) and drained at end-of-frame by
    // ActionManager::ImportPendingAssets under an EditorProgress modal, so
    // multi-file WAV/PNG imports show progress instead of freezing.
    bool mImportAssetsAtEndOfFrame = false;
    std::vector<std::string> mPendingAssetImportPaths;
    std::vector<std::string> mPendingSceneImportQueue;
 
    // AssetDir row the mouse is over in the asset browser this frame. Reset
    // at the top of EditorImguiDraw, set whenever a dir TreeNodeEx / Selectable
    // reports IsItemHovered. Used by the OS file-drop modal so dropping onto
    // a specific folder lands the files there instead of the active folder.
    AssetDir* mMouseHoveredAssetDir = nullptr;
 
    // Import-time name-clash queue. Filled by ActionManager::ImportAsset when
    // the source file's basename collides with an existing asset of a different
    // type (e.g. importing `tent.glb` as StaticMesh while `tent.oct` is already
    // a Texture). Drained by the "Asset Name Clash" modal in EditorImgui, which
    // lets the user rename or cancel before any pointers get rebound.
    struct PendingImportClash
    {
        std::string mSourcePath;       // file the user dropped / picked
        std::string mOriginalBaseName; // basename derived from the source file (what would have been used)
        std::string mProposedName;     // user-editable; pre-filled with first free `name_N`
        std::string mExistingTypeName;
        std::string mImportTypeName;
        bool mCombined = false;        // true if it came in via ImportAssetCombined
        MeshImportOptions mMeshOpts;   // forwarded from the "Import Mesh Asset" modal so the re-driven import keeps Place-in-subdir / Import Materials / Shading Model / etc.
        bool mHasMeshOpts = false;     // true when mMeshOpts was populated from a mesh-import flow
    };
    std::vector<PendingImportClash> mPendingImportClashes;
    AssetStub* mPendingReimportSceneStub = nullptr;
    std::string mPendingReimportScenePath = "";
    bool mShutdownUnsavedCheck = false;
    bool mDevMode = false;
    bool mShowBottomPane = true;
    float mBottomPaneHeight = 180.0f;
    bool mShowProjectUpgradeModal = false;
    bool mProjectUpgradeInProgress = false;
    std::vector<AssetStub*> mAssetsNeedingUpgrade;
 
    // 3DS Preview Panel state
    bool mShow3DSPreview = false;
    int32_t mSceneScreenFilter = -1;  // -1 = All Screens, 0 = Top Screen, 1 = Bottom Screen
 
    // Game Preview Panel state
    bool mShowGamePreview = false;
    bool mGamePreviewCaptured = false;
 
    // Play target (shared between viewport toolbar and Game Preview)
    int32_t mPlayTarget = 0;  // 0=PlayInEditor, 1=PlayFullScreen, 2=Dolphin, 3=Azahar, 4=Standalone, 5=Send3dsLink
 
    // Node Graph Panel state
    bool mShowNodeGraphPanel = false;
 
    // Timeline Panel state
    bool mShowTimelinePanel = false;
 
    // Profiling Panel state
    bool mShowProfilingPanel = false;
 
    // Input Tester Panel state
    bool mShowInputTesterPanel = false;
 
    // Texture Atlas Viewer state
    bool mShowTextureAtlasViewer = false;
 
    // Git Panel state
    bool mShowGitPanel = false;
 
    // Animation Browser Panel state
    bool mShowAnimationBrowser = false;
    // Bone Mask Editor Panel state
    bool mShowBoneMaskEditor = false;
    TimelineRef mEditedTimelineRef;
    TimelineInstance* mTimelinePreviewInstance = nullptr;
    float mTimelinePlayheadTime = 0.0f;
    bool mTimelinePreviewing = false;
    float mTimelineZoom = 100.0f;
    float mTimelineScrollX = 0.0f;
    float mTimelineSnapInterval = 0.1f;
    int32_t mTimelineSelectedTrack = -1;
    int32_t mTimelineSelectedClip = -1;
    int32_t mTimelineSelectedKeyframe = -1;
 
    // ImGuizmo state
    ImGuizmo::OPERATION mGizmoOperation = ImGuizmo::TRANSLATE;
    ImGuizmo::MODE mGizmoMode = ImGuizmo::WORLD;
    bool mGizmoBlockedBySelection = false;
 
    // Methods
    void Init();
    void Shutdown();
    void Update(float deltaTime);
 
    void GatherProperties(std::vector<Property>& props);
 
    void SetEditorMode(EditorMode mode);
    EditorMode GetEditorMode();
 
    void SetPaintMode(PaintMode paintMode);
    PaintMode GetPaintMode();
 
    // ===== Batch 15: Addon viewport mode helpers =====
 
    void SetActiveAddonViewportMode(const std::string& modeId);
 
    void ClearActiveAddonViewportMode();
 
    bool HasActiveAddonViewportMode() const { return !mActiveAddonViewportModeId.empty(); }
 
    const std::string& GetActiveAddonViewportModeId() const { return mActiveAddonViewportModeId; }
 
    void ReadEditorSave();
    void WriteEditorSave();
 
    void ReadEditorProjectSave();
    void WriteEditorProjectSave();
 
    void HandleNodeDestroy(Node* node);
 
    void SetSelectedNode(Node* newNode);
    void AddSelectedNode(Node* node, bool addAllChildren);
    void SelectNodesInRange(Node* rootNode, Node* endNode);
    void RemoveSelectedNode(Node* node);
    void SetSelectedAssetStub(AssetStub* newStub);
    void AddSelectedAssetStub(AssetStub* stub);
    void RemoveSelectedAssetStub(AssetStub* stub);
    void ClearSelectedAssetStubs();
    const std::vector<AssetStub*>& GetSelectedAssetStubs();
    bool IsAssetStubSelected(AssetStub* stub);
    void SetControlMode(ControlMode newMode);
 
    void BeginPlayInEditor();
    void EndPlayInEditor();
    // Defer the start/stop by one frame so the loading modal can render
    // before the (potentially slow) snapshot/clone or restore work runs.
    void RequestBeginPlayInEditor();
    void RequestEndPlayInEditor();
    // Defer a Lua "Reload All Scripts" until end-of-frame so the progress
    // modal can render before the script reload loop blocks. The worker is
    // the global ::ReloadAllScripts() in Engine.cpp.
    void RequestReloadAllScripts();
    void EjectPlayInEditor();
    void InjectPlayInEditor();
    void SnapshotAssetsForPie();
    void RestoreAssetsFromPie();
 
    // Sub-scene override inspector helpers. The cache holds an instantiated
    // copy of each source Scene asset that's currently being inspected; the
    // inspector compares the live node's property values against the
    // corresponding default node in the cached tree to detect overrides.
    // Pass nullptr to InvalidateSubSceneDefaultCache to clear everything.
    Node* GetSubSceneDefaultTree(Scene* src);
    void InvalidateSubSceneDefaultCache(Scene* src = nullptr);
    bool IsPropertyOverridden(Node* node, const std::string& propName);
    void RevertPropertyToSource(Node* node, const std::string& propName);
    void SetPlayInEditorPaused(bool paused);
    bool IsPlayInEditorPaused();
 
    void SetNodePropertySelect(bool enable, int32_t index, const std::string& propName);
    void ClearNodePropertySelect();
    void AssignNodePropertySelect(Node* targetNode);
 
    POLYPHASE_API Camera3D* GetEditorCamera();
    void ToggleEditorCameraProjection();
    void ApplyEditorCameraSettings();
 
    // Camera bookmarks. Slots are 0..kEditorCameraBookmarkSlotCount-1; the
    // hotkey labels (1..0) correspond to slots 0..9. Save captures the editor
    // camera's transform / projection / focal distance, Restore re-applies
    // them, and Has reports whether a slot has been populated. Restore is
    // intentionally NOT undoable — it changes editor view state, not scene
    // content.
    void SaveCameraBookmark(int32_t slot);
    void RestoreCameraBookmark(int32_t slot);
    bool HasCameraBookmark(int32_t slot) const;
    const EditorCameraBookmarkArray* GetActiveSceneCameraBookmarks() const;
    EditorCameraBookmarkArray* GetOrCreateActiveSceneCameraBookmarks();
 
    void LoadStartupScene();
 
    Node* GetSelectedNode();
    Widget* GetSelectedWidget();
    const std::vector<Node*>& GetSelectedNodes();
    bool IsNodeSelected(Node* node);
    void DeselectNode(Node* node);
    int32_t GetSelectedInstance();
    void SetSelectedInstance(int32_t instance);
    //void ShowTextPrompt(const char* title, TextFieldHandlerFP confirmHandler, const char* defaultText = nullptr);
 
    POLYPHASE_API void OpenEditScene(Scene* scene);
    void OpenEditScene(int32_t idx);
    void CloseEditScene(int32_t idx);
    void ShelveEditScene();
    EditScene* GetEditScene(int32_t idx = -1);
    void CloseAllEditScenes();
    void EnsureActiveScene();
 
    void ShowEditorUi(bool show);
 
    Asset* GetSelectedAsset();
    AssetStub* GetSelectedAssetStub();
    ControlMode GetControlMode();
    glm::vec3 GetTransformLockVector(TransformLock lock);
    void SetTransformLock(TransformLock lock);
 
    Object* GetInspectedObject();
    Node* GetInspectedNode();
    Asset* GetInspectedAsset();
    void InspectObject(Object* obj, bool force = false, bool recordHistory = true);
    void LockInspect(bool lock);
    bool IsInspectLocked();
    void RecordInspectHistory();
    void ClearInspectHistory();
    void RemoveFromInspectHistory(Object* obj);
    void ProgressInspectFuture();
    void RegressInspectPast();
    void ClearAssetDirHistory();
    POLYPHASE_API void SetAssetDirectory(AssetDir* assetDir, bool recordHistory);
    POLYPHASE_API AssetDir* GetAssetDirectory();
    void BrowseToAsset(const std::string& name);
    void BrowseToScript(const std::string& scriptName);
    void BrowseToScriptPath(const std::string& fullPath);
 
    void CaptureAndSaveScene(AssetStub* stub, Node* rootNode);
    void DuplicateAsset(AssetStub* srcStub, const char* overrideName = nullptr);
 
    void ProgressDirFuture();
    void RegressDirPast();
 
    void RemoveFilteredAssetStub(AssetStub* stub);
    int ActiveTab() const { return (int)mActiveAssetTab; }
 
    Viewport3D* GetViewport3D();
    Viewport2D* GetViewport2D();
 
    // True when the editor viewport should render lighting faithfully to a
    // retro console target instead of applying desktop conveniences (the
    // synthetic preview directional light, unclamped HDR light colors).
    // Driven by the project's current build target, or - when no target is
    // set - by the Game Preview panel's selected console resolution preset.
    bool ShouldPreviewConsoleLighting();
 
    bool IsDirFavorited(const std::string& dirPath);
    void AddFavoriteDir(const std::string& dirPath);
    void RemoveFavoriteDir(const std::string& dirPath);
 
    void AddRecentProject(const std::string& projPath);
    void AddRecentScene(const std::string& sceneName);
};
 
POLYPHASE_API EditorState* GetEditorState();
 
#endif