EditorUIHookManager.h

Go to the documentation of this file.

#pragma once
 
#if EDITOR
 
#include "Plugins/EditorUIHooks.h"
#include "Packaging/BuildTargetRegistry.h"
 
#include <string>
#include <vector>
#include <unordered_map>
#include <functional>
 
struct RegisteredMenuItem
{
    HookId mHookId;
    std::string mMenuPath;
    std::string mItemPath;
    MenuCallback mCallback;
    void* mUserData;
    std::string mShortcut;
    bool mIsSeparator = false;
};
 
struct RegisteredWindow
{
    HookId mHookId;
    std::string mWindowName;
    std::string mWindowId;
    WindowDrawCallback mDrawFunc;
    void* mUserData;
    bool mIsOpen = false;
};
 
struct RegisteredInspector
{
    HookId mHookId;
    std::string mNodeTypeName;
    InspectorDrawCallback mDrawFunc;
    void* mUserData;
};
 
struct RegisteredContextItem
{
    HookId mHookId;
    std::string mItemPath;
    std::string mAssetTypeFilter;  // Empty for node context, or asset type for asset context
    MenuCallback mCallback;
    void* mUserData;
    bool mIsNodeContext;  // true for node context, false for asset context
};
 
struct RegisteredEventCallback
{
    HookId mHookId;
    EventCallback mCallback;
    void* mUserData;
};
 
struct RegisteredStringEventCallback
{
    HookId mHookId;
    StringEventCallback mCallback;
    void* mUserData;
};
 
struct RegisteredPlatformEventCallback
{
    HookId mHookId;
    PlatformEventCallback mCallback;
    void* mUserData;
};
 
struct RegisteredPackageFinishedCallback
{
    HookId mHookId;
    PackageFinishedCallback mCallback;
    void* mUserData;
};
 
struct RegisteredPlayModeCallback
{
    HookId mHookId;
    PlayModeCallback mCallback;
    void* mUserData;
};
 
struct RegisteredTopLevelMenu
{
    HookId mHookId;
    std::string mMenuName;
    TopLevelMenuDrawCallback mDrawFunc;
    void* mUserData;
    // Position of this menu in the main menu bar:
    //   -1 = append after all menus (legacy default)
    //    0 = after File
    //    1 = after Edit
    //    2 = after View
    //    3 = after World
    //    4 = after Tools (formerly "Developer" — same integer for compatibility)
    //    5 = legacy "after Addons" — top-level Addons menu was folded into
    //        Tools > Addons; addons registered against 5 now render between
    //        Tools and Help (the slot the Addons menu used to occupy).
    //    6 = legacy "after Extra"  — top-level Extra menu was removed; addons
    //        registered against 6 also render between Tools and Help.
    int32_t mPosition = -1;
};
 
struct RegisteredToolbarItem
{
    HookId mHookId;
    std::string mItemName;
    ToolbarDrawCallback mDrawFunc;
    void* mUserData;
};
 
struct RegisteredMenuItemEx
{
    HookId mHookId;
    std::string mMenuPath;
    std::string mItemPath;
    MenuCallback mCallback;
    void* mUserData;
    std::string mShortcut;
    MenuValidationCallback mValidateFunc;
};
 
struct RegisteredNodeMenuItems
{
    HookId mHookId;
    std::string mCategory;
    MenuSectionDrawCallback mDrawFunc;
    void* mUserData;
};
 
struct RegisteredCreateAssetItems
{
    HookId mHookId;
    MenuSectionDrawCallback mDrawFunc;
    void* mUserData;
};
 
struct RegisteredCreateAssetItem
{
    HookId mHookId;
    std::string mPath;
    MenuCallback mCallback;
    void* mUserData;
};
 
struct RegisteredSpawnItems
{
    HookId mHookId;
    MenuSectionDrawCallback mDrawFunc;
    void* mUserData;
};
 
struct RegisteredSceneType
{
    HookId mHookId;
    std::string mTypeName;
    SceneCreationCallback mCreateFunc;
    void* mUserData;
};
 
struct RegisteredViewportContextItem
{
    HookId mHookId;
    std::string mItemPath;
    MenuCallback mCallback;
    void* mUserData;
};
 
struct RegisteredViewportOverlay
{
    HookId mHookId;
    std::string mOverlayName;
    ViewportOverlayCallback mDrawFunc;
    void* mUserData;
};
 
struct RegisteredFileDropHandler
{
    HookId mHookId;
    EditorUIHooks::FileDropCallback mCallback;
    void* mUserData;
};
 
struct RegisteredViewportMode
{
    HookId mHookId;
    std::string mModeId;        // stable id used for selection routing + replace-on-register
    std::string mDisplayName;   // dropdown label
    int32_t mSortOrder = 0;
    EditorUIHooks::ViewportModeCanActivateCallback mCanActivate = nullptr;
    EditorUIHooks::ViewportModeActivateCallback mOnActivate = nullptr;
    EditorUIHooks::ViewportModeDeactivateCallback mOnDeactivate = nullptr;
    EditorUIHooks::ViewportModeTickCallback mTick = nullptr;
    EditorUIHooks::ViewportModeDrawPanelCallback mDrawPanel = nullptr;
    void* mUserData = nullptr;
};
 
struct RegisteredPreferencesPanel
{
    HookId mHookId;
    std::string mPanelName;
    std::string mPanelCategory;
    PreferencesPanelDrawCallback mDrawFunc;
    PreferencesLoadCallback mLoadFunc;
    PreferencesSaveCallback mSaveFunc;
    void* mUserData;
};
 
struct RegisteredShortcut
{
    HookId mHookId;
    std::string mShortcutId;
    std::string mDisplayName;
    std::string mDefaultBinding;
    ShortcutCallback mCallback;
    void* mUserData;
    // Parsed key info
    bool mCtrl = false;
    bool mShift = false;
    bool mAlt = false;
    int32_t mKeyCode = -1;
};
 
struct RegisteredPropertyDrawer
{
    HookId mHookId;
    std::string mPropertyTypeName;
    PropertyDrawCallback mDrawFunc;
    void* mUserData;
};
 
struct RegisteredHierarchyItemGUI
{
    HookId mHookId;
    HierarchyItemGUICallback mDrawFunc;
    void* mUserData;
};
 
struct RegisteredAssetItemGUI
{
    HookId mHookId;
    AssetItemGUICallback mDrawFunc;
    void* mUserData;
};
 
struct RegisteredHierarchyChangedCallback
{
    HookId mHookId;
    HierarchyChangedCallback mCallback;
    void* mUserData;
};
 
struct RegisteredSimpleContextItem
{
    HookId mHookId;
    std::string mItemPath;
    MenuCallback mCallback;
    void* mUserData;
};
 
struct RegisteredGamePreviewResolution
{
    HookId mHookId;
    std::string mName;
    uint32_t mWidth;
    uint32_t mHeight;
};
 
struct RegisteredPlayTarget
{
    HookId mHookId;
    std::string mTargetName;
    std::string mIconText;
    PlayTargetCallback mCallback;
    void* mUserData;
};
 
struct RegisteredDragDropHandler
{
    HookId mHookId;
    std::string mTargetArea;
    DragDropHandlerCallback mHandler;
    void* mUserData;
};
 
struct RegisteredAssetImporter
{
    HookId mHookId;
    std::string mExtension;
    AssetImportCallback mImportFunc;
    void* mUserData;
};
 
struct RegisteredPreImportCallback
{
    HookId mHookId;
    PreImportCallback mCallback;
    void* mUserData;
};
 
struct RegisteredPreBuildCallback
{
    HookId mHookId;
    PreBuildCallback mCallback;
    void* mUserData;
};
 
struct RegisteredEditorModeCallback
{
    HookId mHookId;
    EditorModeCallback mCallback;
    void* mUserData;
};
 
struct RegisteredGizmoTool
{
    HookId mHookId;
    std::string mToolName;
    std::string mIconText;
    std::string mTooltip;
    GizmoToolDrawCallback mDrawFunc;
    void* mUserData;
    bool mIsActive = false;
};
 
struct RegisteredControllerRoute
{
    HookId mHookId;
    std::string mMethod;
    std::string mPath;
    ControllerRouteCallback mCallback;
    void* mUserData;
};
 
struct RegisteredControllerServerEvent
{
    HookId mHookId;
    ControllerServerEventCallback mCallback;
    void* mUserData;
};
 
class EditorUIHookManager
{
public:
    static void Create();
    static void Destroy();
    static EditorUIHookManager* Get();
 
    EditorUIHooks* GetHooks() { return &mHooks; }
 
    // ===== Menu Items =====
 
    const std::vector<RegisteredMenuItem>& GetMenuItems(const std::string& menuPath) const;
 
    void DrawMenuItems(const std::string& menuPath);
 
    // ===== Custom Windows =====
 
    const std::vector<RegisteredWindow>& GetWindows() const { return mWindows; }
 
    void DrawWindows();
 
    void OpenWindow(const std::string& windowId);
 
    void CloseWindow(const std::string& windowId);
 
    bool IsWindowOpen(const std::string& windowId) const;
 
    // ===== Inspectors =====
 
    const RegisteredInspector* GetInspector(const std::string& nodeTypeName) const;
 
    bool DrawInspector(const std::string& nodeTypeName, void* node);
 
    // ===== Context Menus =====
 
    void DrawNodeContextItems();
 
    void DrawAssetContextItems(const std::string& assetType);
 
    // ===== Top-Level Menus =====
 
    void DrawTopLevelMenus();
 
    void DrawTopLevelMenusAtPosition(int32_t builtinPosition);
 
    // ===== Toolbar =====
 
    void DrawToolbarItems();
 
    // ===== Batch 2: Create/Spawn Menu Extensions =====
 
    void DrawNodeMenuItems(const char* category, void* parentNode);
    void DrawCustomNodeCategories(void* parentNode);
    void DrawCreateAssetItems();
    void DrawSpawnBasic3dItems(void* parentNode);
    void DrawSpawnBasicWidgetItems(void* parentNode);
 
    // ===== Scene Type Registration =====
 
    const std::vector<RegisteredSceneType>& GetSceneTypes() const { return mSceneTypes; }
    void FireSceneCreation(const std::string& typeName, const char* sceneName, void* rootNode);
 
    // ===== Batch 3: Viewport Context Menu & Overlay Drawing =====
 
    void DrawViewportContextItems();
    void DrawViewportOverlays(float viewportX, float viewportY, float viewportW, float viewportH);
    bool HasViewportContextItems() const;
 
    // ===== Batch 4: Custom Preferences =====
 
    const std::vector<RegisteredPreferencesPanel>& GetPreferencesPanels() const { return mPreferencesPanels; }
    void LoadAddonPreferences();
    void SaveAddonPreferences();
 
    // ===== Batch 5: Keyboard Shortcuts =====
 
    void ProcessShortcuts();
 
    // ===== Batch 6: Property Drawers =====
 
    bool DrawPropertyDrawer(const char* propertyTypeName, const char* propertyName, void* propertyOwner, int32_t propertyType);
 
    // ===== Batch 7: Hierarchy & Asset Browser Extensions =====
 
    void DrawHierarchyItemGUI(void* node, float rowX, float rowY, float rowW, float rowH);
    void DrawAssetItemGUI(const char* assetName, const char* assetType, float rowX, float rowY, float rowW, float rowH);
    void FireOnHierarchyChanged(int32_t changeType, void* node);
 
    // ===== Batch 8: Additional Context Menus =====
 
    void DrawSceneTabContextItems();
    void DrawDebugLogContextItems();
    void DrawImportMenuItems();
    void DrawAddonsMenuItems();
    void DrawPlayTargets();
    bool HasPlayTargets() const;
 
    // ===== Game Preview Resolution Presets =====
 
    const std::vector<RegisteredGamePreviewResolution>& GetGamePreviewResolutions() const { return mGamePreviewResolutions; }
 
    // ===== Batch 9: Drag-Drop & Asset Pipeline =====
 
    bool HandleDragDrop(const char* targetArea, const char* payloadType, const void* payloadData, int32_t payloadSize);
    bool HandleAssetImport(const char* filePath, const char* extension);
    bool FireOnPreAssetImport(const char* filePath);
    void FireOnPostAssetImport(const char* assetPath);
 
    // ===== Batch 10: Build Pipeline & Editor State =====
 
    bool FireOnPreBuild(int32_t platform);
    void FireOnPostBuild(int32_t platform, bool success);
    void FireOnEditorModeChanged(int32_t newMode);
    void DrawGizmoTools(void* selectedNode);
    const std::vector<RegisteredGizmoTool>& GetGizmoTools() const { return mGizmoTools; }
 
    // ===== Event Dispatchers =====
 
    void FireOnProjectOpen(const char* projectPath);
    void FireOnProjectClose(const char* projectPath);
    void FireOnProjectSave(const char* filePath);
    void FireOnSceneOpen(const char* scenePath);
    void FireOnSceneClose(const char* scenePath);
    void FireOnPackageStarted(int32_t platform);
    void FireOnPackageFinished(int32_t platform, bool success);
    void FireOnSelectionChanged();
    void FireOnPlayModeChanged(int32_t state);
    void FireOnEditorShutdown();
    void FireOnAssetImported(const char* assetPath);
    void FireOnAssetDeleted(const char* assetPath);
    void FireOnAssetSaved(const char* assetPath);
    void FireOnAssetOpen(const char* assetName);
    void FireOnAssetOpened(const char* assetName);
    void FireOnUndoRedo();
    void FireOnAssetDropHierarchy(const char* assetName);
    void FireOnAssetDropViewport(const char* assetName);
 
    // ===== Controller Server Extension =====
 
    const std::vector<RegisteredControllerRoute>& GetControllerRoutes() const { return mControllerRoutes; }
    void FireOnControllerServerStateChanged(int32_t state);
 
    // ===== Batch 15: Viewport Mode dropdown =====
 
    const std::vector<RegisteredViewportMode>& GetViewportModes() const { return mViewportModes; }
 
    std::vector<const RegisteredViewportMode*> GetViewportModesSorted() const;
 
    const RegisteredViewportMode* FindViewportMode(const std::string& modeId) const;
 
    void FireViewportModeActivate(const std::string& modeId);
 
    void FireViewportModeDeactivate(const std::string& modeId);
 
    bool CanActivateViewportMode(const std::string& modeId);
 
    void TickActiveViewportMode(float deltaTime);
 
    void DrawActiveViewportModePanel();
 
    // ===== Cleanup =====
 
    void RemoveAllHooks(HookId hookId);
 
    // ===== Batch 14: OS file-drop dispatch =====
 
    bool DispatchFileDrop(const std::vector<std::string>& paths);
 
private:
    static EditorUIHookManager* sInstance;
    EditorUIHookManager();
    ~EditorUIHookManager();
 
    void InitializeHooks();
 
    // Hook storage
    std::unordered_map<std::string, std::vector<RegisteredMenuItem>> mMenuItems;
    std::vector<RegisteredWindow> mWindows;
    std::vector<RegisteredInspector> mInspectors;
    std::vector<RegisteredContextItem> mContextItems;
 
    // New hook storage
    std::vector<RegisteredTopLevelMenu> mTopLevelMenus;
    std::vector<RegisteredToolbarItem> mToolbarItems;
    std::vector<RegisteredStringEventCallback> mOnProjectOpen;
    std::vector<RegisteredStringEventCallback> mOnProjectClose;
    std::vector<RegisteredStringEventCallback> mOnProjectSave;
    std::vector<RegisteredStringEventCallback> mOnSceneOpen;
    std::vector<RegisteredStringEventCallback> mOnSceneClose;
    std::vector<RegisteredPlatformEventCallback> mOnPackageStarted;
    std::vector<RegisteredPackageFinishedCallback> mOnPackageFinished;
    std::vector<RegisteredEventCallback> mOnSelectionChanged;
    std::vector<RegisteredPlayModeCallback> mOnPlayModeChanged;
    std::vector<RegisteredEventCallback> mOnEditorShutdown;
    std::vector<RegisteredStringEventCallback> mOnAssetImported;
    std::vector<RegisteredStringEventCallback> mOnAssetDeleted;
    std::vector<RegisteredStringEventCallback> mOnAssetSaved;
    std::vector<RegisteredStringEventCallback> mOnAssetOpen;
    std::vector<RegisteredStringEventCallback> mOnAssetOpened;
    std::vector<RegisteredEventCallback> mOnUndoRedo;
    std::vector<RegisteredStringEventCallback> mOnAssetDropHierarchy;
    std::vector<RegisteredStringEventCallback> mOnAssetDropViewport;
 
    // Batch 1: Menu items with validation
    std::vector<RegisteredMenuItemEx> mMenuItemsEx;
 
    // Batch 2: Create/Spawn menu extensions
    std::vector<RegisteredNodeMenuItems> mNodeMenuItems;
    std::vector<RegisteredCreateAssetItems> mCreateAssetItems;
    std::vector<RegisteredCreateAssetItem>  mCreateAssetItemSingles;
    std::vector<RegisteredSpawnItems> mSpawnBasic3dItems;
    std::vector<RegisteredSpawnItems> mSpawnBasicWidgetItems;
 
    // Scene type registration
    std::vector<RegisteredSceneType> mSceneTypes;
 
    // Batch 3: Viewport context + overlays
    std::vector<RegisteredViewportContextItem> mViewportContextItems;
    std::vector<RegisteredViewportOverlay> mViewportOverlays;
 
    // Batch 4: Preferences panels
    std::vector<RegisteredPreferencesPanel> mPreferencesPanels;
 
    // Batch 5: Keyboard shortcuts
    std::vector<RegisteredShortcut> mShortcuts;
 
    // Batch 6: Property drawers
    std::vector<RegisteredPropertyDrawer> mPropertyDrawers;
 
    // Batch 7: Hierarchy & asset browser
    std::vector<RegisteredHierarchyItemGUI> mHierarchyItemGUI;
    std::vector<RegisteredAssetItemGUI> mAssetItemGUI;
    std::vector<RegisteredHierarchyChangedCallback> mOnHierarchyChanged;
 
    // Game Preview resolution presets
    std::vector<RegisteredGamePreviewResolution> mGamePreviewResolutions;
 
    // Batch 8: Additional context menus
    std::vector<RegisteredSimpleContextItem> mSceneTabContextItems;
    std::vector<RegisteredSimpleContextItem> mDebugLogContextItems;
    std::vector<RegisteredSimpleContextItem> mImportMenuItems;
    std::vector<RegisteredSimpleContextItem> mAddonsMenuItems;
    std::vector<RegisteredPlayTarget> mPlayTargets;
 
    // Batch 14: OS file-drop dispatch
    std::vector<RegisteredFileDropHandler> mFileDropHandlers;
 
    // Batch 15: Addon-contributed viewport modes (dropdown entries).
    // Insertion order is preserved; GetViewportModesSorted() applies sortOrder
    // at read time. The active mode id lives on EditorState, not here.
    std::vector<RegisteredViewportMode> mViewportModes;
 
    // Batch 9: Drag-drop & asset pipeline
    std::vector<RegisteredDragDropHandler> mDragDropHandlers;
    std::vector<RegisteredAssetImporter> mAssetImporters;
    std::vector<RegisteredPreImportCallback> mOnPreAssetImport;
    std::vector<RegisteredStringEventCallback> mOnPostAssetImport;
 
    // Batch 10: Build pipeline & editor state
    std::vector<RegisteredPreBuildCallback> mOnPreBuild;
    std::vector<RegisteredPackageFinishedCallback> mOnPostBuild;
    std::vector<RegisteredEditorModeCallback> mOnEditorModeChanged;
    std::vector<RegisteredGizmoTool> mGizmoTools;
 
    // Controller Server hooks
    std::vector<RegisteredControllerRoute> mControllerRoutes;
    std::vector<RegisteredControllerServerEvent> mOnControllerServerStateChanged;
 
    // Batch 11: Build target registry (addon-provided + engine built-ins)
    BuildTargetRegistry mBuildTargets;
 
public:
    BuildTargetRegistry& GetBuildTargets() { return mBuildTargets; }
    const BuildTargetRegistry& GetBuildTargets() const { return mBuildTargets; }
 
private:
    // Empty vector for returning when menu not found
    std::vector<RegisteredMenuItem> mEmptyMenuItems;
 
    // Hooks struct passed to plugins
    EditorUIHooks mHooks;
 
    // Helper: Parse key binding string to shortcut fields
    void ParseKeyBinding(RegisteredShortcut& shortcut);
};
 
HookId GenerateHookId(const char* identifier);
 
#endif // EDITOR