EditorUIHooks.h

Go to the documentation of this file.

#pragma once
 
#if EDITOR
 
#include <stdint.h>
 
// ===== Callback Types =====
 
typedef void (*MenuCallback)(void* userData);
 
typedef void (*WindowDrawCallback)(void* userData);
 
typedef void (*InspectorDrawCallback)(void* node, void* userData);
 
typedef void (*EventCallback)(void* userData);
 
typedef void (*StringEventCallback)(const char* str, void* userData);
 
typedef void (*PlatformEventCallback)(int32_t platform, void* userData);
 
typedef void (*PackageFinishedCallback)(int32_t platform, bool success, void* userData);
 
typedef void (*PlayModeCallback)(int32_t state, void* userData);
 
typedef void (*TopLevelMenuDrawCallback)(void* userData);
 
typedef void (*ToolbarDrawCallback)(void* userData);
 
typedef bool (*MenuValidationCallback)(void* userData);
 
typedef void (*MenuSectionDrawCallback)(void* parentNode, void* userData);
 
typedef void (*ViewportOverlayCallback)(float viewportX, float viewportY, float viewportW, float viewportH, void* userData);
 
typedef void (*PreferencesPanelDrawCallback)(void* userData);
 
typedef void (*PreferencesLoadCallback)(void* userData);
typedef void (*PreferencesSaveCallback)(void* userData);
 
typedef void (*ShortcutCallback)(void* userData);
 
typedef bool (*PropertyDrawCallback)(const char* propertyName, void* propertyOwner, int32_t propertyType, void* userData);
 
typedef void (*HierarchyItemGUICallback)(void* node, float rowX, float rowY, float rowW, float rowH, void* userData);
 
typedef void (*AssetItemGUICallback)(const char* assetName, const char* assetType, float rowX, float rowY, float rowW, float rowH, void* userData);
 
typedef void (*HierarchyChangedCallback)(int32_t changeType, void* node, void* userData);
 
typedef bool (*DragDropHandlerCallback)(const char* payloadType, const void* payloadData, int32_t payloadSize, void* userData);
 
typedef bool (*AssetImportCallback)(const char* filePath, const char* extension, void* userData);
 
typedef bool (*PreImportCallback)(const char* filePath, void* userData);
 
typedef bool (*PreBuildCallback)(int32_t platform, void* userData);
 
typedef void (*EditorModeCallback)(int32_t newMode, void* userData);
 
typedef void (*GizmoToolDrawCallback)(void* selectedNode, void* userData);
 
typedef void (*PlayTargetCallback)(void* userData);
 
typedef void (*SceneCreationCallback)(const char* sceneName, void* rootNode, void* userData);
 
// ===== Controller Server Hooks =====
 
typedef void (*ControllerRouteCallback)(const char* method, const char* path, const char* body, char* responseBuffer, int32_t bufferSize, void* userData);
 
typedef void (*ControllerServerEventCallback)(int32_t state, void* userData);
 
typedef uint64_t HookId;
 
struct EditorUIHooks
{
    // ===== Menu Extensions =====
 
    void (*AddMenuItem)(
        HookId hookId,
        const char* menuPath,
        const char* itemPath,
        MenuCallback callback,
        void* userData,
        const char* shortcut
    );
 
    void (*AddMenuSeparator)(HookId hookId, const char* menuPath);
 
    void (*RemoveMenuItem)(HookId hookId, const char* menuPath, const char* itemPath);
 
    // ===== Custom Windows =====
 
    void (*RegisterWindow)(
        HookId hookId,
        const char* windowName,
        const char* windowId,
        WindowDrawCallback drawFunc,
        void* userData
    );
 
    void (*UnregisterWindow)(HookId hookId, const char* windowId);
 
    void (*OpenWindow)(const char* windowId);
 
    void (*CloseWindow)(const char* windowId);
 
    bool (*IsWindowOpen)(const char* windowId);
 
    // ===== Inspector Extensions =====
 
    void (*RegisterInspector)(
        HookId hookId,
        const char* nodeTypeName,
        InspectorDrawCallback drawFunc,
        void* userData
    );
 
    void (*UnregisterInspector)(HookId hookId, const char* nodeTypeName);
 
    // ===== Context Menu Extensions =====
 
    void (*AddNodeContextItem)(
        HookId hookId,
        const char* itemPath,
        MenuCallback callback,
        void* userData
    );
 
    void (*AddAssetContextItem)(
        HookId hookId,
        const char* itemPath,
        const char* assetTypeFilter,
        MenuCallback callback,
        void* userData
    );
 
    // ===== Top-Level Menus =====
 
    void (*AddTopLevelMenuItem)(HookId hookId, const char* menuName,
                                TopLevelMenuDrawCallback drawFunc, void* userData);
 
    void (*RemoveTopLevelMenuItem)(HookId hookId, const char* menuName);
 
    // ===== Toolbar =====
 
    void (*AddToolbarItem)(HookId hookId, const char* itemName,
                           ToolbarDrawCallback drawFunc, void* userData);
 
    void (*RemoveToolbarItem)(HookId hookId, const char* itemName);
 
    // ===== Project Lifecycle Events =====
 
    void (*RegisterOnProjectOpen)(HookId hookId, StringEventCallback cb, void* userData);
 
    void (*RegisterOnProjectClose)(HookId hookId, StringEventCallback cb, void* userData);
 
    void (*RegisterOnProjectSave)(HookId hookId, StringEventCallback cb, void* userData);
 
    // ===== Scene Lifecycle Events =====
 
    void (*RegisterOnSceneOpen)(HookId hookId, StringEventCallback cb, void* userData);
 
    void (*RegisterOnSceneClose)(HookId hookId, StringEventCallback cb, void* userData);
 
    // ===== Packaging/Build Events =====
 
    void (*RegisterOnPackageStarted)(HookId hookId, PlatformEventCallback cb, void* userData);
 
    void (*RegisterOnPackageFinished)(HookId hookId, PackageFinishedCallback cb, void* userData);
 
    // ===== Editor State Events =====
 
    void (*RegisterOnSelectionChanged)(HookId hookId, EventCallback cb, void* userData);
 
    void (*RegisterOnPlayModeChanged)(HookId hookId, PlayModeCallback cb, void* userData);
 
    void (*RegisterOnEditorShutdown)(HookId hookId, EventCallback cb, void* userData);
 
    // ===== Asset Pipeline Events =====
 
    void (*RegisterOnAssetImported)(HookId hookId, StringEventCallback cb, void* userData);
 
    void (*RegisterOnAssetDeleted)(HookId hookId, StringEventCallback cb, void* userData);
 
    void (*RegisterOnAssetSaved)(HookId hookId, StringEventCallback cb, void* userData);
 
    // ===== Asset Open Events =====
 
    void (*RegisterOnAssetOpen)(HookId hookId, StringEventCallback cb, void* userData);
 
    void (*RegisterOnAssetOpened)(HookId hookId, StringEventCallback cb, void* userData);
 
    // ===== Undo/Redo =====
 
    void (*RegisterOnUndoRedo)(HookId hookId, EventCallback cb, void* userData);
 
    // ===== Drag-and-Drop Events =====
 
    void (*RegisterOnAssetDropHierarchy)(HookId hookId, StringEventCallback cb, void* userData);
 
    void (*RegisterOnAssetDropViewport)(HookId hookId, StringEventCallback cb, void* userData);
 
    // ===== Batch 1: Menu Positioning & Top-Level Menu Control =====
 
    void (*AddTopLevelMenuItemEx)(
        HookId hookId,
        const char* menuName,
        TopLevelMenuDrawCallback drawFunc,
        void* userData,
        int32_t position
    );
 
    void (*AddMenuItemEx)(
        HookId hookId,
        const char* menuPath,
        const char* itemPath,
        MenuCallback callback,
        void* userData,
        const char* shortcut,
        MenuValidationCallback validateFunc
    );
 
    // ===== Batch 2: Create/Spawn Menu Extensions =====
 
    void (*AddNodeMenuItems)(HookId hookId, const char* category, MenuSectionDrawCallback drawFunc, void* userData);
 
    void (*RemoveNodeMenuItems)(HookId hookId, const char* category);
 
    void (*AddCreateAssetItems)(HookId hookId, MenuSectionDrawCallback drawFunc, void* userData);
 
    void (*RemoveCreateAssetItems)(HookId hookId);
 
    void (*AddSpawnBasic3dItems)(HookId hookId, MenuSectionDrawCallback drawFunc, void* userData);
 
    void (*AddSpawnBasicWidgetItems)(HookId hookId, MenuSectionDrawCallback drawFunc, void* userData);
 
    // ===== Scene Type Registration =====
 
    void (*RegisterSceneType)(HookId hookId, const char* typeName, SceneCreationCallback createFunc, void* userData);
 
    void (*UnregisterSceneType)(HookId hookId, const char* typeName);
 
    // ===== Batch 3: Viewport Context Menu & Overlay Drawing =====
 
    void (*AddViewportContextItem)(HookId hookId, const char* itemPath, MenuCallback callback, void* userData);
 
    void (*RemoveViewportContextItem)(HookId hookId, const char* itemPath);
 
    void (*RegisterViewportOverlay)(HookId hookId, const char* overlayName, ViewportOverlayCallback drawFunc, void* userData);
 
    void (*UnregisterViewportOverlay)(HookId hookId, const char* overlayName);
 
    // ===== Batch 4: Custom Preferences/Settings Pages =====
 
    void (*RegisterPreferencesPanel)(
        HookId hookId,
        const char* panelName,
        const char* panelCategory,
        PreferencesPanelDrawCallback drawFunc,
        PreferencesLoadCallback loadFunc,
        PreferencesSaveCallback saveFunc,
        void* userData
    );
 
    void (*UnregisterPreferencesPanel)(HookId hookId, const char* panelName);
 
    // ===== Batch 5: Custom Keyboard Shortcuts =====
 
    void (*RegisterShortcut)(
        HookId hookId,
        const char* shortcutId,
        const char* displayName,
        const char* defaultBinding,
        ShortcutCallback callback,
        void* userData
    );
 
    void (*UnregisterShortcut)(HookId hookId, const char* shortcutId);
 
    // ===== Batch 6: Property Drawer System =====
 
    void (*RegisterPropertyDrawer)(HookId hookId, const char* propertyTypeName, PropertyDrawCallback drawFunc, void* userData);
 
    void (*UnregisterPropertyDrawer)(HookId hookId, const char* propertyTypeName);
 
    // ===== Batch 7: Hierarchy & Asset Browser Extensions =====
 
    void (*RegisterHierarchyItemGUI)(HookId hookId, HierarchyItemGUICallback drawFunc, void* userData);
 
    void (*UnregisterHierarchyItemGUI)(HookId hookId);
 
    void (*RegisterAssetItemGUI)(HookId hookId, AssetItemGUICallback drawFunc, void* userData);
 
    void (*UnregisterAssetItemGUI)(HookId hookId);
 
    void (*RegisterOnHierarchyChanged)(HookId hookId, HierarchyChangedCallback cb, void* userData);
 
    // ===== Batch 8: Additional Context Menus =====
 
    void (*AddSceneTabContextItem)(HookId hookId, const char* itemPath, MenuCallback callback, void* userData);
 
    void (*AddDebugLogContextItem)(HookId hookId, const char* itemPath, MenuCallback callback, void* userData);
 
    void (*AddImportMenuItem)(HookId hookId, const char* itemPath, MenuCallback callback, void* userData);
 
    void (*AddAddonsMenuItem)(HookId hookId, const char* itemPath, MenuCallback callback, void* userData);
 
    void (*AddPlayTarget)(HookId hookId, const char* targetName, const char* iconText, PlayTargetCallback callback, void* userData);
 
    void (*RemovePlayTarget)(HookId hookId, const char* targetName);
 
    // ===== Batch 9: Drag-Drop Enhancement & Asset Pipeline =====
 
    void (*RegisterDragDropHandler)(HookId hookId, const char* targetArea, DragDropHandlerCallback handler, void* userData);
 
    void (*RegisterAssetImporter)(HookId hookId, const char* extension, AssetImportCallback importFunc, void* userData);
 
    void (*UnregisterAssetImporter)(HookId hookId, const char* extension);
 
    void (*RegisterOnPreAssetImport)(HookId hookId, PreImportCallback cb, void* userData);
 
    void (*RegisterOnPostAssetImport)(HookId hookId, StringEventCallback cb, void* userData);
 
    // ===== Batch 10: Build Pipeline & Editor State =====
 
    void (*RegisterOnPreBuild)(HookId hookId, PreBuildCallback cb, void* userData);
 
    void (*RegisterOnPostBuild)(HookId hookId, PackageFinishedCallback cb, void* userData);
 
    void (*RegisterOnEditorModeChanged)(HookId hookId, EditorModeCallback cb, void* userData);
 
    void (*RegisterGizmoTool)(
        HookId hookId,
        const char* toolName,
        const char* iconText,
        const char* tooltip,
        GizmoToolDrawCallback drawFunc,
        void* userData
    );
 
    void (*UnregisterGizmoTool)(HookId hookId, const char* toolName);
 
    // ===== Game Preview Resolution Presets =====
 
    void (*AddGamePreviewResolution)(HookId hookId, const char* name, uint32_t width, uint32_t height);
 
    void (*RemoveGamePreviewResolution)(HookId hookId, const char* name);
 
    // ===== Controller Server Extension =====
 
    void (*RegisterControllerRoute)(HookId hookId, const char* method, const char* path, ControllerRouteCallback callback, void* userData);
 
    void (*UnregisterControllerRoute)(HookId hookId, const char* path);
 
    void (*RegisterOnControllerServerStateChanged)(HookId hookId, ControllerServerEventCallback callback, void* userData);
 
    // ===== Profiling Window Extension =====
 
    void (*RegisterProfilingStat)(HookId hookId, const char* statName, const char* category, float maxValue, bool showAsBar);
 
    void (*UnregisterProfilingStat)(HookId hookId, const char* statName);
 
    void (*SetProfilingStatValue)(const char* statName, float value);
 
    typedef void (*ProfilingSectionDrawCallback)(void* userData);
 
    void (*RegisterProfilingSection)(HookId hookId, const char* sectionName, void (*drawFunc)(void*), void* userData);
 
    void (*UnregisterProfilingSection)(HookId hookId, const char* sectionName);
 
    // ===== Cleanup =====
 
    void (*RemoveAllHooks)(HookId hookId);
 
    // ===== Late additions (appended to preserve ABI) ====================
    //
    // New function pointers must go AT THE END of this struct so prebuilt
    // plugins compiled against older headers keep finding existing hooks
    // at their original offsets. Plugin loaders must check each function
    // pointer for nullptr before calling it — older engine binaries will
    // leave fields they don't know about as nullptr.
 
    void (*AddCreateAssetItem)(HookId hookId, const char* itemPath,
                               MenuCallback callback, void* userData);
 
    // ===== Batch 11: Build Targets =====
    //
    // Lets an addon register an entire build/packaging target — compile,
    // cook, finalize, run. See PolyphaseBuildTargetAPI.h for the descriptor
    // shape. The descriptor is deep-copied; the addon may free its source
    // strings immediately after this returns. The registration is scoped to
    // hookId and is automatically cleared by RemoveAllHooks(hookId), so
    // hot-reload is safe.
    //
    // Registering twice with the same targetId replaces the previous entry;
    // this is what makes addon hot-reload swap in fresh function pointers
    // without leaving stale ones in the registry.
 
    void (*RegisterBuildTarget)(HookId hookId, const struct PolyphaseBuildTargetDesc* desc);
 
    void (*UnregisterBuildTarget)(HookId hookId, const char* targetId);
 
    // ===== Batch 12: Viewport input polling for addons =====
    //
    // Poll-style helpers for tools (e.g. Level Builder) that want to react
    // to mouse hover and clicks inside the 3D viewport. There is no HookId
    // because nothing is allocated — old engines simply leave these fields
    // null and addons must null-check before calling.
    //
    // Both calls are intended to be invoked from inside a
    // RegisterViewportOverlay callback (which fires mid-frame with the
    // viewport rect already laid out).
    //
    // Screen coordinates are unscaled ImGui pixels (i.e. ImGui::GetIO().MousePos);
    // the implementation multiplies by EngineConfig::mEditorInterfaceScale
    // internally to match Renderer pixel space.
 
    bool (*Viewport_RaycastUnderMouse)(float screenX, float screenY,
                                       float fallbackPlaneY,
                                       float* outHitX, float* outHitY, float* outHitZ,
                                       float* outNormalX, float* outNormalY, float* outNormalZ,
                                       void** outHitNode);
 
    void (*Viewport_GetMouseState)(float* outViewportX, float* outViewportY,
                                   float* outViewportW, float* outViewportH,
                                   float* outMouseX,    float* outMouseY,
                                   int* outHovered, int* outLeftClicked,
                                   int* outLeftDown, int* outRightClicked);
 
    // ===== Batch 13: Selection control (additive — safe for older addons) =====
 
    void (*Viewport_SuppressNextSelectionClick)();
 
    void (*Selection_Clear)();
 
    // ===== Batch 14: File dialogs + OS file-drop dispatch ==================
    //
    // Thin wrappers over the existing SYS_OpenFileDialog / SYS_SaveFileDialog
    // / SYS_SelectFolderDialog calls + the SYS_DrainDroppedFiles polling
    // mechanism, exposed so plugins (Level Builder share UI, asset importers,
    // settings panels) don't have to vendor their own platform code.
    //
    // All dialogs are SYNCHRONOUS — the call blocks until the user picks or
    // cancels. UI threads call them from a button click; no callback needed.
    // The file-drop hook IS callback-based since drops can land any frame.
 
    int (*ShowOpenFileDialog)(const char* title,
                              const char* filter,
                              const char* initialDir,
                              char* outPath, int outPathSize);
 
    int (*ShowSaveFileDialog)(const char* title,
                              const char* filter,
                              const char* defaultName,
                              char* outPath, int outPathSize);
 
    int (*ShowSelectFolderDialog)(const char* title,
                                  char* outPath, int outPathSize);
 
    typedef bool (*FileDropCallback)(int count, const char** paths, void* userData);
    void (*RegisterFileDropHandler)(HookId hookId, FileDropCallback cb, void* userData);
    void (*UnregisterFileDropHandler)(HookId hookId);
 
    // ===== Batch 15: Viewport Mode dropdown ============================
    //
    // Lets a native addon contribute a new entry to the top-of-editor mode
    // dropdown (Scene / 2D / 3D / Paint Colors / Paint Instances / Voxel /
    // Terrain / Tile Paint). When the user picks an addon mode the editor:
    //   - switches EditorMode to Scene3D (and clears any built-in PaintMode)
    //   - records the active addon mode id on EditorState
    //   - fires OnActivate(userData)
    // Switching to a built-in entry (or another addon entry) fires
    // OnDeactivate(userData) on the previously-active addon mode first.
    //
    // While the addon mode is active the engine calls:
    //   - Tick(deltaTime, userData)  every frame inside the viewport update
    //   - DrawPanel(userData)        every frame in the mode-properties strip
    //
    // Hot-reload safety: re-registering with the same modeId replaces the
    // entry's callbacks (so a freshly reloaded DLL's function pointers
    // overwrite the stale ones). RemoveAllHooks(hookId) deactivates the
    // mode first if it's currently active, then erases the registration.
    //
    // All callbacks are optional — pass nullptr to skip. CanActivate is a
    // gating check: if it returns false the dropdown entry greys out and
    // the editor refuses to switch into the mode. Null CanActivate = always
    // available.
 
    typedef bool (*ViewportModeCanActivateCallback)(void* userData);
 
    typedef void (*ViewportModeActivateCallback)(void* userData);
 
    typedef void (*ViewportModeDeactivateCallback)(void* userData);
 
    typedef void (*ViewportModeTickCallback)(float deltaTime, void* userData);
 
    typedef void (*ViewportModeDrawPanelCallback)(void* userData);
 
    void (*AddViewportMode)(
        HookId hookId,
        const char* modeId,
        const char* displayName,
        int32_t sortOrder,
        ViewportModeCanActivateCallback canActivate,
        ViewportModeActivateCallback onActivate,
        ViewportModeDeactivateCallback onDeactivate,
        ViewportModeTickCallback tick,
        ViewportModeDrawPanelCallback drawPanel,
        void* userData
    );
 
    void (*RemoveViewportMode)(HookId hookId, const char* modeId);
 
    int (*GetActiveViewportMode)(char* outBuffer, int outBufferSize);
 
    // ===== Batch 15 / v8: viewport math for plugin gizmos ==================
    //
    // Mouse → world ray. `mx`/`my` are window-space pixels (same units
    // Viewport_GetMouseState returns). `outOrigin` is the ray's starting
    // point in world space; `outDir` is the normalized direction.
    //
    // Used by plugins that need to roll their own scene intersection —
    // axis-constrained transform gizmos, arbitrary plane intersection,
    // line-to-line distance for rotation rings, etc. The simpler
    // Viewport_RaycastUnderMouse stays for the common "give me the
    // hit point on the scene OR a fallback Y plane" case.
    void (*Viewport_GetMouseWorldRay)(float mx, float my,
                                       float* outOriginX,
                                       float* outOriginY,
                                       float* outOriginZ,
                                       float* outDirX,
                                       float* outDirY,
                                       float* outDirZ);
 
    // World → editor-viewport screen pixels. Returns 1 if the point
    // projects in front of the camera (sx/sy are usable window-space
    // coords); returns 0 if behind (sx/sy still filled but the caller
    // probably wants to skip drawing). The output coordinate system
    // matches Viewport_GetMouseState — i.e. the same window-space
    // pixels you'd hover-test against.
    //
    // Used by plugins that want to overlay ImGui labels / billboards
    // on top of scene objects (e.g. "Socket: Left" text floating
    // over the socket gizmo).
    int  (*Viewport_WorldToScreen)(float wx, float wy, float wz,
                                    float* outSx, float* outSy);
};
 
HookId GenerateHookId(const char* identifier);
 
#endif // EDITOR