Polyphase Game Engine
Loading...
Searching...
No Matches
EditorUIHookManager.h
Go to the documentation of this file.
1#pragma once
2
11#if EDITOR
12
15
16#include <string>
17#include <vector>
18#include <unordered_map>
19#include <functional>
20
24struct RegisteredMenuItem
25{
26 HookId mHookId;
27 std::string mMenuPath;
28 std::string mItemPath;
29 MenuCallback mCallback;
30 void* mUserData;
31 std::string mShortcut;
32 bool mIsSeparator = false;
33};
34
38struct RegisteredWindow
39{
40 HookId mHookId;
41 std::string mWindowName;
42 std::string mWindowId;
43 WindowDrawCallback mDrawFunc;
44 void* mUserData;
45 bool mIsOpen = false;
46};
47
51struct RegisteredInspector
52{
53 HookId mHookId;
54 std::string mNodeTypeName;
55 InspectorDrawCallback mDrawFunc;
56 void* mUserData;
57};
58
62struct RegisteredContextItem
63{
64 HookId mHookId;
65 std::string mItemPath;
66 std::string mAssetTypeFilter; // Empty for node context, or asset type for asset context
67 MenuCallback mCallback;
68 void* mUserData;
69 bool mIsNodeContext; // true for node context, false for asset context
70};
71
75struct RegisteredEventCallback
76{
77 HookId mHookId;
78 EventCallback mCallback;
79 void* mUserData;
80};
81
85struct RegisteredStringEventCallback
86{
87 HookId mHookId;
88 StringEventCallback mCallback;
89 void* mUserData;
90};
91
95struct RegisteredPlatformEventCallback
96{
97 HookId mHookId;
98 PlatformEventCallback mCallback;
99 void* mUserData;
100};
101
105struct RegisteredPackageFinishedCallback
106{
107 HookId mHookId;
108 PackageFinishedCallback mCallback;
109 void* mUserData;
110};
111
115struct RegisteredPlayModeCallback
116{
117 HookId mHookId;
118 PlayModeCallback mCallback;
119 void* mUserData;
120};
121
125struct RegisteredTopLevelMenu
126{
127 HookId mHookId;
128 std::string mMenuName;
129 TopLevelMenuDrawCallback mDrawFunc;
130 void* mUserData;
131 // Position of this menu in the main menu bar:
132 // -1 = append after all menus (legacy default)
133 // 0 = after File
134 // 1 = after Edit
135 // 2 = after View
136 // 3 = after World
137 // 4 = after Tools (formerly "Developer" — same integer for compatibility)
138 // 5 = legacy "after Addons" — top-level Addons menu was folded into
139 // Tools > Addons; addons registered against 5 now render between
140 // Tools and Help (the slot the Addons menu used to occupy).
141 // 6 = legacy "after Extra" — top-level Extra menu was removed; addons
142 // registered against 6 also render between Tools and Help.
143 int32_t mPosition = -1;
144};
145
149struct RegisteredToolbarItem
150{
151 HookId mHookId;
152 std::string mItemName;
153 ToolbarDrawCallback mDrawFunc;
154 void* mUserData;
155};
156
160struct RegisteredMenuItemEx
161{
162 HookId mHookId;
163 std::string mMenuPath;
164 std::string mItemPath;
165 MenuCallback mCallback;
166 void* mUserData;
167 std::string mShortcut;
168 MenuValidationCallback mValidateFunc;
169};
170
174struct RegisteredNodeMenuItems
175{
176 HookId mHookId;
177 std::string mCategory;
178 MenuSectionDrawCallback mDrawFunc;
179 void* mUserData;
180};
181
185struct RegisteredCreateAssetItems
186{
187 HookId mHookId;
188 MenuSectionDrawCallback mDrawFunc;
189 void* mUserData;
190};
191
200struct RegisteredCreateAssetItem
201{
202 HookId mHookId;
203 std::string mPath;
204 MenuCallback mCallback;
205 void* mUserData;
206};
207
211struct RegisteredSpawnItems
212{
213 HookId mHookId;
214 MenuSectionDrawCallback mDrawFunc;
215 void* mUserData;
216};
217
221struct RegisteredSceneType
222{
223 HookId mHookId;
224 std::string mTypeName;
225 SceneCreationCallback mCreateFunc;
226 void* mUserData;
227};
228
232struct RegisteredViewportContextItem
233{
234 HookId mHookId;
235 std::string mItemPath;
236 MenuCallback mCallback;
237 void* mUserData;
238};
239
243struct RegisteredViewportOverlay
244{
245 HookId mHookId;
246 std::string mOverlayName;
247 ViewportOverlayCallback mDrawFunc;
248 void* mUserData;
249};
250
260struct RegisteredFileDropHandler
261{
262 HookId mHookId;
263 EditorUIHooks::FileDropCallback mCallback;
264 void* mUserData;
265};
266
275struct RegisteredViewportMode
276{
277 HookId mHookId;
278 std::string mModeId; // stable id used for selection routing + replace-on-register
279 std::string mDisplayName; // dropdown label
280 int32_t mSortOrder = 0;
281 EditorUIHooks::ViewportModeCanActivateCallback mCanActivate = nullptr;
282 EditorUIHooks::ViewportModeActivateCallback mOnActivate = nullptr;
283 EditorUIHooks::ViewportModeDeactivateCallback mOnDeactivate = nullptr;
284 EditorUIHooks::ViewportModeTickCallback mTick = nullptr;
285 EditorUIHooks::ViewportModeDrawPanelCallback mDrawPanel = nullptr;
286 void* mUserData = nullptr;
287};
288
292struct RegisteredPreferencesPanel
293{
294 HookId mHookId;
295 std::string mPanelName;
296 std::string mPanelCategory;
297 PreferencesPanelDrawCallback mDrawFunc;
298 PreferencesLoadCallback mLoadFunc;
299 PreferencesSaveCallback mSaveFunc;
300 void* mUserData;
301};
302
306struct RegisteredShortcut
307{
308 HookId mHookId;
309 std::string mShortcutId;
310 std::string mDisplayName;
311 std::string mDefaultBinding;
312 ShortcutCallback mCallback;
313 void* mUserData;
314 // Parsed key info
315 bool mCtrl = false;
316 bool mShift = false;
317 bool mAlt = false;
318 int32_t mKeyCode = -1;
319};
320
324struct RegisteredPropertyDrawer
325{
326 HookId mHookId;
327 std::string mPropertyTypeName;
328 PropertyDrawCallback mDrawFunc;
329 void* mUserData;
330};
331
335struct RegisteredHierarchyItemGUI
336{
337 HookId mHookId;
338 HierarchyItemGUICallback mDrawFunc;
339 void* mUserData;
340};
341
345struct RegisteredAssetItemGUI
346{
347 HookId mHookId;
348 AssetItemGUICallback mDrawFunc;
349 void* mUserData;
350};
351
355struct RegisteredHierarchyChangedCallback
356{
357 HookId mHookId;
358 HierarchyChangedCallback mCallback;
359 void* mUserData;
360};
361
365struct RegisteredSimpleContextItem
366{
367 HookId mHookId;
368 std::string mItemPath;
369 MenuCallback mCallback;
370 void* mUserData;
371};
372
376struct RegisteredGamePreviewResolution
377{
378 HookId mHookId;
379 std::string mName;
380 uint32_t mWidth;
381 uint32_t mHeight;
382};
383
387struct RegisteredPlayTarget
388{
389 HookId mHookId;
390 std::string mTargetName;
391 std::string mIconText;
392 PlayTargetCallback mCallback;
393 void* mUserData;
394};
395
399struct RegisteredDragDropHandler
400{
401 HookId mHookId;
402 std::string mTargetArea;
403 DragDropHandlerCallback mHandler;
404 void* mUserData;
405};
406
410struct RegisteredAssetImporter
411{
412 HookId mHookId;
413 std::string mExtension;
414 AssetImportCallback mImportFunc;
415 void* mUserData;
416};
417
421struct RegisteredPreImportCallback
422{
423 HookId mHookId;
424 PreImportCallback mCallback;
425 void* mUserData;
426};
427
431struct RegisteredPreBuildCallback
432{
433 HookId mHookId;
434 PreBuildCallback mCallback;
435 void* mUserData;
436};
437
441struct RegisteredEditorModeCallback
442{
443 HookId mHookId;
444 EditorModeCallback mCallback;
445 void* mUserData;
446};
447
451struct RegisteredGizmoTool
452{
453 HookId mHookId;
454 std::string mToolName;
455 std::string mIconText;
456 std::string mTooltip;
457 GizmoToolDrawCallback mDrawFunc;
458 void* mUserData;
459 bool mIsActive = false;
460};
461
465struct RegisteredControllerRoute
466{
467 HookId mHookId;
468 std::string mMethod;
469 std::string mPath;
470 ControllerRouteCallback mCallback;
471 void* mUserData;
472};
473
477struct RegisteredControllerServerEvent
478{
479 HookId mHookId;
480 ControllerServerEventCallback mCallback;
481 void* mUserData;
482};
483
487struct RegisteredTargetOptions
488{
489 HookId mHookId;
490 std::string mName;
491 TargetOptionsDrawCallback mDrawFunc;
492 void* mUserData;
493};
494
498struct RegisteredModal
499{
500 HookId mHookId;
501 std::string mTitle;
502 ModalDrawCallback mDrawFunc;
503 void* mUserData;
504 bool mOpenPending; // ImGui::OpenPopup on the next DrawModals
505};
506
512class EditorUIHookManager
513{
514public:
515 static void Create();
516 static void Destroy();
517 static EditorUIHookManager* Get();
518
522 EditorUIHooks* GetHooks() { return &mHooks; }
523
524 // ===== Menu Items =====
525
529 const std::vector<RegisteredMenuItem>& GetMenuItems(const std::string& menuPath) const;
530
535 void DrawMenuItems(const std::string& menuPath);
536
537 // ===== Custom Windows =====
538
542 const std::vector<RegisteredWindow>& GetWindows() const { return mWindows; }
543
547 void DrawWindows();
548
552 void DrawModals();
553
557 void OpenWindow(const std::string& windowId);
558
562 void CloseWindow(const std::string& windowId);
563
567 bool IsWindowOpen(const std::string& windowId) const;
568
569 // ===== Inspectors =====
570
575 const RegisteredInspector* GetInspector(const std::string& nodeTypeName) const;
576
581 bool DrawInspector(const std::string& nodeTypeName, void* node);
582
583 // ===== Context Menus =====
584
588 void DrawNodeContextItems();
589
594 void DrawAssetContextItems(const std::string& assetType);
595
596 // ===== Top-Level Menus =====
597
601 void DrawTopLevelMenus();
602
608 void DrawTopLevelMenusAtPosition(int32_t builtinPosition);
609
610 // ===== Toolbar =====
611
612 void DrawToolbarItems();
613
614 // ===== Batch 2: Create/Spawn Menu Extensions =====
615
616 void DrawNodeMenuItems(const char* category, void* parentNode);
617 void DrawCustomNodeCategories(void* parentNode);
618 void DrawCreateAssetItems();
619 void DrawSpawnBasic3dItems(void* parentNode);
620 void DrawSpawnBasicWidgetItems(void* parentNode);
621
622 // ===== Scene Type Registration =====
623
624 const std::vector<RegisteredSceneType>& GetSceneTypes() const { return mSceneTypes; }
625 void FireSceneCreation(const std::string& typeName, const char* sceneName, void* rootNode);
626
627 // ===== Batch 3: Viewport Context Menu & Overlay Drawing =====
628
629 void DrawViewportContextItems();
630 void DrawViewportOverlays(float viewportX, float viewportY, float viewportW, float viewportH);
631 bool HasViewportContextItems() const;
632
633 // ===== Batch 4: Custom Preferences =====
634
635 const std::vector<RegisteredPreferencesPanel>& GetPreferencesPanels() const { return mPreferencesPanels; }
636 void LoadAddonPreferences();
637 void SaveAddonPreferences();
638
639 // ===== Batch 5: Keyboard Shortcuts =====
640
641 void ProcessShortcuts();
642
643 // ===== Batch 6: Property Drawers =====
644
645 bool DrawPropertyDrawer(const char* propertyTypeName, const char* propertyName, void* propertyOwner, int32_t propertyType);
646
647 // ===== Batch 7: Hierarchy & Asset Browser Extensions =====
648
649 void DrawHierarchyItemGUI(void* node, float rowX, float rowY, float rowW, float rowH);
650 void DrawAssetItemGUI(const char* assetName, const char* assetType, float rowX, float rowY, float rowW, float rowH);
651 void FireOnHierarchyChanged(int32_t changeType, void* node);
652
653 // ===== Batch 8: Additional Context Menus =====
654
655 void DrawSceneTabContextItems();
656 void DrawDebugLogContextItems();
657 void DrawImportMenuItems();
658 void DrawAddonsMenuItems();
659 void DrawPlayTargets();
660 bool HasPlayTargets() const;
661
662 // ===== Game Preview Resolution Presets =====
663
664 const std::vector<RegisteredGamePreviewResolution>& GetGamePreviewResolutions() const { return mGamePreviewResolutions; }
665
666 // ===== Batch 9: Drag-Drop & Asset Pipeline =====
667
668 bool HandleDragDrop(const char* targetArea, const char* payloadType, const void* payloadData, int32_t payloadSize);
669 bool HandleAssetImport(const char* filePath, const char* extension);
670 bool FireOnPreAssetImport(const char* filePath);
671 void FireOnPostAssetImport(const char* assetPath);
672
673 // ===== Batch 10: Build Pipeline & Editor State =====
674
675 bool FireOnPreBuild(int32_t platform);
676 void FireOnPostBuild(int32_t platform, bool success);
677 void FireOnEditorModeChanged(int32_t newMode);
678 void DrawGizmoTools(void* selectedNode);
679 const std::vector<RegisteredGizmoTool>& GetGizmoTools() const { return mGizmoTools; }
680
681 // ===== Event Dispatchers =====
682
683 void FireOnProjectOpen(const char* projectPath);
684 void FireOnProjectClose(const char* projectPath);
685 void FireOnProjectSave(const char* filePath);
686 void FireOnSceneOpen(const char* scenePath);
687 void FireOnSceneClose(const char* scenePath);
688 void FireOnPackageStarted(int32_t platform);
689
691 const std::vector<RegisteredTargetOptions>& GetTargetOptions() const { return mTargetOptions; }
692 void FireOnPackageFinished(int32_t platform, bool success);
693 void FireOnSelectionChanged();
694 void FireOnPlayModeChanged(int32_t state);
695 void FireOnEditorShutdown();
696 void FireOnAssetImported(const char* assetPath);
697 void FireOnAssetDeleted(const char* assetPath);
698 void FireOnAssetSaved(const char* assetPath);
699 void FireOnAssetOpen(const char* assetName);
700 void FireOnAssetOpened(const char* assetName);
701 void FireOnUndoRedo();
702 void FireOnAssetDropHierarchy(const char* assetName);
703 void FireOnAssetDropViewport(const char* assetName);
704
705 // ===== Controller Server Extension =====
706
707 const std::vector<RegisteredControllerRoute>& GetControllerRoutes() const { return mControllerRoutes; }
708 void FireOnControllerServerStateChanged(int32_t state);
709
710 // ===== Batch 15: Viewport Mode dropdown =====
711
718 const std::vector<RegisteredViewportMode>& GetViewportModes() const { return mViewportModes; }
719
724 std::vector<const RegisteredViewportMode*> GetViewportModesSorted() const;
725
727 const RegisteredViewportMode* FindViewportMode(const std::string& modeId) const;
728
734 void FireViewportModeActivate(const std::string& modeId);
735
737 void FireViewportModeDeactivate(const std::string& modeId);
738
740 bool CanActivateViewportMode(const std::string& modeId);
741
743 void TickActiveViewportMode(float deltaTime);
744
746 void DrawActiveViewportModePanel();
747
748 // ===== Cleanup =====
749
753 void RemoveAllHooks(HookId hookId);
754
755 // ===== Batch 14: OS file-drop dispatch =====
756
764 bool DispatchFileDrop(const std::vector<std::string>& paths);
765
766private:
767 static EditorUIHookManager* sInstance;
768 EditorUIHookManager();
769 ~EditorUIHookManager();
770
771 void InitializeHooks();
772
773 // Hook storage
774 std::unordered_map<std::string, std::vector<RegisteredMenuItem>> mMenuItems;
775 std::vector<RegisteredWindow> mWindows;
776 std::vector<RegisteredInspector> mInspectors;
777 std::vector<RegisteredContextItem> mContextItems;
778
779 // New hook storage
780 std::vector<RegisteredTopLevelMenu> mTopLevelMenus;
781 std::vector<RegisteredToolbarItem> mToolbarItems;
782 std::vector<RegisteredStringEventCallback> mOnProjectOpen;
783 std::vector<RegisteredStringEventCallback> mOnProjectClose;
784 std::vector<RegisteredStringEventCallback> mOnProjectSave;
785 std::vector<RegisteredStringEventCallback> mOnSceneOpen;
786 std::vector<RegisteredStringEventCallback> mOnSceneClose;
787 std::vector<RegisteredPlatformEventCallback> mOnPackageStarted;
788 std::vector<RegisteredPackageFinishedCallback> mOnPackageFinished;
789 std::vector<RegisteredEventCallback> mOnSelectionChanged;
790 std::vector<RegisteredPlayModeCallback> mOnPlayModeChanged;
791 std::vector<RegisteredEventCallback> mOnEditorShutdown;
792 std::vector<RegisteredStringEventCallback> mOnAssetImported;
793 std::vector<RegisteredStringEventCallback> mOnAssetDeleted;
794 std::vector<RegisteredStringEventCallback> mOnAssetSaved;
795 std::vector<RegisteredStringEventCallback> mOnAssetOpen;
796 std::vector<RegisteredStringEventCallback> mOnAssetOpened;
797 std::vector<RegisteredEventCallback> mOnUndoRedo;
798 std::vector<RegisteredStringEventCallback> mOnAssetDropHierarchy;
799 std::vector<RegisteredStringEventCallback> mOnAssetDropViewport;
800
801 // Batch 1: Menu items with validation
802 std::vector<RegisteredMenuItemEx> mMenuItemsEx;
803
804 // Batch 2: Create/Spawn menu extensions
805 std::vector<RegisteredNodeMenuItems> mNodeMenuItems;
806 std::vector<RegisteredCreateAssetItems> mCreateAssetItems;
807 std::vector<RegisteredCreateAssetItem> mCreateAssetItemSingles;
808 std::vector<RegisteredSpawnItems> mSpawnBasic3dItems;
809 std::vector<RegisteredSpawnItems> mSpawnBasicWidgetItems;
810
811 // Scene type registration
812 std::vector<RegisteredSceneType> mSceneTypes;
813
814 // Batch 3: Viewport context + overlays
815 std::vector<RegisteredViewportContextItem> mViewportContextItems;
816 std::vector<RegisteredViewportOverlay> mViewportOverlays;
817
818 // Batch 4: Preferences panels
819 std::vector<RegisteredPreferencesPanel> mPreferencesPanels;
820
821 // Batch 5: Keyboard shortcuts
822 std::vector<RegisteredShortcut> mShortcuts;
823
824 // Batch 6: Property drawers
825 std::vector<RegisteredPropertyDrawer> mPropertyDrawers;
826
827 // Batch 7: Hierarchy & asset browser
828 std::vector<RegisteredHierarchyItemGUI> mHierarchyItemGUI;
829 std::vector<RegisteredAssetItemGUI> mAssetItemGUI;
830 std::vector<RegisteredHierarchyChangedCallback> mOnHierarchyChanged;
831
832 // Game Preview resolution presets
833 std::vector<RegisteredGamePreviewResolution> mGamePreviewResolutions;
834
835 // Batch 8: Additional context menus
836 std::vector<RegisteredSimpleContextItem> mSceneTabContextItems;
837 std::vector<RegisteredSimpleContextItem> mDebugLogContextItems;
838 std::vector<RegisteredSimpleContextItem> mImportMenuItems;
839 std::vector<RegisteredSimpleContextItem> mAddonsMenuItems;
840 std::vector<RegisteredPlayTarget> mPlayTargets;
841
842 // Batch 14: OS file-drop dispatch
843 std::vector<RegisteredFileDropHandler> mFileDropHandlers;
844
845 // Batch 15: Addon-contributed viewport modes (dropdown entries).
846 // Insertion order is preserved; GetViewportModesSorted() applies sortOrder
847 // at read time. The active mode id lives on EditorState, not here.
848 std::vector<RegisteredViewportMode> mViewportModes;
849
850 // Batch 9: Drag-drop & asset pipeline
851 std::vector<RegisteredDragDropHandler> mDragDropHandlers;
852 std::vector<RegisteredAssetImporter> mAssetImporters;
853 std::vector<RegisteredPreImportCallback> mOnPreAssetImport;
854 std::vector<RegisteredStringEventCallback> mOnPostAssetImport;
855
856 // Batch 10: Build pipeline & editor state
857 std::vector<RegisteredPreBuildCallback> mOnPreBuild;
858 std::vector<RegisteredPackageFinishedCallback> mOnPostBuild;
859 std::vector<RegisteredEditorModeCallback> mOnEditorModeChanged;
860 std::vector<RegisteredGizmoTool> mGizmoTools;
861
862 // Controller Server hooks
863 std::vector<RegisteredControllerRoute> mControllerRoutes;
864 std::vector<RegisteredControllerServerEvent> mOnControllerServerStateChanged;
865
866 // Batch 11: Build target registry (addon-provided + engine built-ins)
867 BuildTargetRegistry mBuildTargets;
868
869 // Addon sections of "Target Options", drawn for every target
870 std::vector<RegisteredTargetOptions> mTargetOptions;
871
872 // Addon modal dialogs that are open
873 std::vector<RegisteredModal> mModals;
874
875public:
877 BuildTargetRegistry& GetBuildTargets() { return mBuildTargets; }
878 const BuildTargetRegistry& GetBuildTargets() const { return mBuildTargets; }
879
880private:
881 // Empty vector for returning when menu not found
882 std::vector<RegisteredMenuItem> mEmptyMenuItems;
883
884 // Hooks struct passed to plugins. Value-initialized: it's an aggregate of
885 // raw function pointers with no default member initializers, so anything
886 // InitializeHooks misses would otherwise be indeterminate rather than
887 // null — and every doc comment in EditorUIHooks.h tells plugins to
888 // null-check before calling.
889 EditorUIHooks mHooks{};
890
891 // Helper: Parse key binding string to shortcut fields
892 void ParseKeyBinding(RegisteredShortcut& shortcut);
893};
894
898HookId GenerateHookId(const char* identifier);
899
900#endif // EDITOR
Editor UI extension system for native addons.