EditorPlugin

public void AddAutoloadSingleton(string name, string path);

Adds a script at path to the Autoload list as name.

public void AddContextMenuPlugin(EditorContextMenuPlugin.ContextMenuSlot slot, EditorContextMenuPlugin plugin);

Adds a plugin to the context menu. slot is the context menu where the plugin will be added. Note: A plugin instance can belong only to a single context menu slot.

public Button AddControlToBottomPanel(Control control, string title);

Adds a control to the bottom panel (together with Output, Debug, Animation, etc.). Returns a reference to a button that is outside the scene tree. It's up to you to hide/show the button when needed. When your plugin is deactivated, make sure to remove your custom control with EditorPlugin.RemoveControlFromBottomPanel and free it with Entity.QueueFree. shortcut is a shortcut that, when activated, will toggle the bottom panel's visibility. The shortcut object is only set when this control is added to the bottom panel. Note: See the default editor bottom panel shortcuts in the Editor Settings for inspiration. By convention, they all use the [kbd]Alt[/kbd] modifier.

public Button AddControlToBottomPanel(Control control, string title, Shortcut shortcut = null);

Adds a control to the bottom panel (together with Output, Debug, Animation, etc.). Returns a reference to a button that is outside the scene tree. It's up to you to hide/show the button when needed. When your plugin is deactivated, make sure to remove your custom control with EditorPlugin.RemoveControlFromBottomPanel and free it with Entity.QueueFree. shortcut is a shortcut that, when activated, will toggle the bottom panel's visibility. The shortcut object is only set when this control is added to the bottom panel. Note: See the default editor bottom panel shortcuts in the Editor Settings for inspiration. By convention, they all use the [kbd]Alt[/kbd] modifier.

public void AddControlToContainer(EditorPlugin.CustomControlContainer container, Control control);

Adds a custom control to a container in the editor UI. Please remember that you have to manage the visibility of your custom controls yourself (and likely hide it after adding it). When your plugin is deactivated, make sure to remove your custom control with EditorPlugin.RemoveControlFromContainer and free it with Entity.QueueFree.

public void AddControlToDock(EditorPlugin.DockSlot slot, Control control);

Adds the control to a specific dock slot. If the dock is repositioned and as long as the plugin is active, the editor will save the dock position on further sessions. When your plugin is deactivated, make sure to remove your custom control with EditorPlugin.RemoveControlFromDocks and free it with Entity.QueueFree. Optionally, you can specify a shortcut parameter. When pressed, this shortcut will open and focus the dock.

public void AddControlToDock(EditorPlugin.DockSlot slot, Control control, Shortcut shortcut = null);

Adds the control to a specific dock slot. If the dock is repositioned and as long as the plugin is active, the editor will save the dock position on further sessions. When your plugin is deactivated, make sure to remove your custom control with EditorPlugin.RemoveControlFromDocks and free it with Entity.QueueFree. Optionally, you can specify a shortcut parameter. When pressed, this shortcut will open and focus the dock.

public void AddCustomType(string type, string @base, Script script, Texture2D icon);

Adds a custom type, which will appear in the list of nodes or resources. When a given node or resource is selected, the base type will be instantiated (e.g. "Entity3D", "Control", "Resource"), then the script will be loaded and set to this object. Note: The base type is the base engine class which this type's class hierarchy inherits, not any custom type parent classes. You can use the virtual method EditorPlugin._Handles to check if your custom object is being edited by checking the script or using the is keyword. During run-time, this will be a simple object with a script so this function does not need to be called then. Note: Custom types added this way are not true classes. They are just a helper to create a node with specific script.

public void AddDebuggerPlugin(EditorDebuggerPlugin script);

Adds a Script as debugger plugin to the Debugger. The script must extend EditorDebuggerPlugin.

public void AddDock(EditorDock dock);

Registers an owned EditorDock with the editor dock manager. Set Title and DefaultSlot first; registering the same object twice is rejected. Disable by unregistering and freeing your panel.

public void AddEntity3DGizmoPlugin(EditorEntity3DGizmoPlugin plugin);

Register a 3D gizmo handler. Keep the instance for removal. In 1.0.0 registration does not guarantee rebuilding an already open scene's gizmos; save and reopen it when needed.

public void AddExportPlatform(EditorExportPlatform platform);

Registers a new EditorExportPlatform. Export platforms provides functionality of exporting to the specific platform.

public void AddExportPlugin(EditorExportPlugin plugin);

Registers a new EditorExportPlugin. Export plugins are used to perform tasks when the project is being exported. See EditorPlugin.AddInspectorPlugin for an example of how to register a plugin.

public void AddImportPlugin(EditorImportPlugin importer, bool firstPriority = false);

Register an editor resource importer. Keep its reference for removal when disabling the plugin. After the initial scan, registration schedules another scan through a deferred call.

public void AddInspectorPlugin(EditorInspectorPlugin plugin);

Registers a ref-counted Inspector plugin. An already open object can need reparse/reselection: registration does not rebuild every existing property editor.

public void AddResourceConversionPlugin(EditorResourceConversionPlugin plugin);

Registers a new EditorResourceConversionPlugin. Resource conversion plugins are used to add custom resource converters to the editor inspector. See EditorResourceConversionPlugin for an example of how to create a resource conversion plugin.

public void AddSceneFormatImporterPlugin(EditorSceneFormatImporter sceneFormatImporter, bool firstPriority = false);

Registers a new EditorSceneFormatImporter. Scene importers are used to import custom 3D asset formats as scenes. If first_priority is true, the new import plugin is inserted first in the list and takes precedence over pre-existing plugins.

public void AddScenePostImportPlugin(EditorScenePostImportPlugin sceneImportPlugin, bool firstPriority = false);

Add an EditorScenePostImportPlugin. These plugins allow customizing the import process of 3D assets by adding new options to the import dialogs. If first_priority is true, the new import plugin is inserted first in the list and takes precedence over pre-existing plugins.

public void AddToolMenuItem(string name, Callable callable);

Adds a command to the project tools menu. Register once on plugin entry and remove on exit. Adding the same name again does not itself replace the previous item.

public void AddToolSubmenuItem(string name, PopupMenu submenu);

Adds a custom PopupMenu submenu under Project > Tools > name. Use EditorPlugin.RemoveToolMenuItem on plugin clean up to remove the menu.

public void AddTranslationParserPlugin(EditorTranslationParserPlugin parser);

Registers a custom translation parser plugin for extracting translatable strings from custom files.

public void AddUndoRedoInspectorHookCallback(Callable callable);

Hooks a callback into the undo/redo action creation when a property is modified in the inspector. This allows, for example, to save other properties that may be lost when a given property is modified. The callback should have 4 arguments: ReckfellObject undo_redo, ReckfellObject modified_object, string property and Variant new_value. They are, respectively, the UndoRedo object used by the inspector, the currently modified object, the name of the modified property and the new value the property is about to take.

public EditorInterface GetEditorInterface();

Returns the EditorInterface singleton instance.

public PopupMenu GetExportAsMenu();

Returns the PopupMenu under Scene > Export As....

public string GetPluginVersion();

Provide the version of the plugin declared in the plugin.cfg config file.

public ScriptCreateDialog GetScriptCreateDialog();

Gets the Editor's dialog used for making scripts. Note: Users can configure it before use. Warning: Removing and freeing this node will render a part of the editor useless and may cause a crash.

public EditorUndoRedoManager GetUndoRedo();

Gets the undo/redo object. Most actions in the editor can be undoable, so use this object to make sure this happens when it's worth it.

public void HideBottomPanel();

Minimizes the bottom panel.

public void MakeBottomPanelItemVisible(Control item);

Makes a specific item in the bottom panel visible.

public void QueueSaveLayout();

Queue save the project's editor layout.

public void RemoveAutoloadSingleton(string name);

Removes an Autoload name from the list.

public void RemoveContextMenuPlugin(EditorContextMenuPlugin plugin);

Removes the specified context menu plugin.

public void RemoveControlFromBottomPanel(Control control);

Removes the control from the bottom panel. You have to manually Entity.QueueFree the control.

public void RemoveControlFromContainer(EditorPlugin.CustomControlContainer container, Control control);

Removes the control from the specified container. You have to manually Entity.QueueFree the control.

public void RemoveControlFromDocks(Control control);

Removes the control from the dock. You have to manually Entity.QueueFree the control.

public void RemoveCustomType(string type);

Removes a custom type added by EditorPlugin.AddCustomType.

public void RemoveDebuggerPlugin(EditorDebuggerPlugin script);

Removes the debugger plugin with given script from the Debugger.

public void RemoveDock(EditorDock dock);

Unregisters a dock and detaches it from the manager. Does not free the object: separately QueueFree a plugin-owned panel.

public void RemoveEntity3DGizmoPlugin(EditorEntity3DGizmoPlugin plugin);

Unregister a handler. Pass the same instance, then release your owned reference. Do not delete user Entities.

public void RemoveExportPlatform(EditorExportPlatform platform);

Removes an export platform registered by EditorPlugin.AddExportPlatform.

public void RemoveExportPlugin(EditorExportPlugin plugin);

Removes an export plugin registered by EditorPlugin.AddExportPlugin.

public void RemoveImportPlugin(EditorImportPlugin importer);

Unregister a previously added importer. Then release your owned reference; do not delete user source files. An existing cache does not replace the importer when output must be rebuilt.

public void RemoveInspectorPlugin(EditorInspectorPlugin plugin);

Unregisters an Inspector plugin. Does not promise to remove existing widgets from every Inspector; the example separately rebuilds its resource's main Inspector and releases its ref-counted reference.

public void RemoveResourceConversionPlugin(EditorResourceConversionPlugin plugin);

Removes a resource conversion plugin registered by EditorPlugin.AddResourceConversionPlugin.

public void RemoveSceneFormatImporterPlugin(EditorSceneFormatImporter sceneFormatImporter);

Removes a scene format importer registered by EditorPlugin.AddSceneFormatImporterPlugin.

public void RemoveScenePostImportPlugin(EditorScenePostImportPlugin sceneImportPlugin);

Remove the EditorScenePostImportPlugin, added with EditorPlugin.AddScenePostImportPlugin.

public void RemoveToolMenuItem(string name);

Removes a custom tools item by name. Call when disabling your plugin so reenablement leaves no old commands.

public void RemoveTranslationParserPlugin(EditorTranslationParserPlugin parser);

Removes a custom translation parser plugin registered by EditorPlugin.AddTranslationParserPlugin.

public void RemoveUndoRedoInspectorHookCallback(Callable callable);

Removes a callback previously added by EditorPlugin.AddUndoRedoInspectorHookCallback.

public void SetDockTabIcon(Control control, Texture2D icon);

Sets the tab icon for the given control in a dock slot. Setting to null removes the icon.

public void SetForceDrawOverForwardingEnabled();

Enables calling of EditorPlugin._ForwardCanvasForceDrawOverViewport for the 2D editor and EditorPlugin._Forward3DForceDrawOverViewport for the 3D editor when their viewports are updated. You need to call this method only once and it will work permanently for this plugin.

public void SetInputEventForwardingAlwaysEnabled();

Use this method if you always want to receive inputs from 3D view screen inside EditorPlugin._Forward3DGuiInput. It might be especially usable if your plugin will want to use raycast in the scene.

public int UpdateOverlays();

Updates the overlays of the 2D and 3D editor viewport. Causes methods EditorPlugin._ForwardCanvasDrawOverViewport, EditorPlugin._ForwardCanvasForceDrawOverViewport, EditorPlugin._Forward3DDrawOverViewport and EditorPlugin._Forward3DForceDrawOverViewport to be called.

public virtual void _ApplyChanges();

This method is called when the editor is about to save the project, switch to another tab, etc. It asks the plugin to apply any pending state changes to ensure consistency. This is used, for example, in shader editors to let the plugin know that it must apply the shader code being written by the user to the object.

public virtual bool _Build();

This method is called when the editor is about to run the project. The plugin can then perform required operations before the project runs. This method must return a boolean. If this method returns false, the project will not run. The run is aborted immediately, so this also prevents all other plugins' EditorPlugin._Build methods from running.

public virtual void _Clear();

Clear all the state and reset the object being edited to zero. This ensures your plugin does not keep editing a currently existing node, or a node from the wrong scene.

public virtual void _DisablePlugin();

Called by the engine when the user disables the EditorPlugin in the Plugin tab of the project settings window.

public virtual void _Edit(ReckfellObject @object);

This function is used for plugins that edit specific object types (nodes or resources). It requests the editor to edit the given object. object can be null if the plugin was editing an object, but there is no longer any selected object handled by this plugin. It can be used to cleanup editing state.

public virtual void _EnablePlugin();

Called by the engine when the user enables the EditorPlugin in the Plugin tab of the project settings window.

public virtual void _Forward3DDrawOverViewport(Control viewportControl);

Called by the engine when the 3D editor's viewport is updated. viewport_control is an overlay on top of the viewport and it can be used for drawing. You can update the viewport manually by calling EditorPlugin.UpdateOverlays.

public override void _Forward3DDrawOverViewport(Control viewportControl)
{
    // Draw a circle at the cursor's position.
    viewportControl.DrawCircle(viewportControl.GetLocalMousePosition(), 64, Colors.White);
}

public override EditorPlugin.AfterGuiInput _Forward3DGuiInput(Camera3D viewportCamera, InputEvent @event)
{
    if (@event is InputEventMouseMotion)
    {
        // Redraw the viewport when the cursor is moved.
        UpdateOverlays();
        return EditorPlugin.AfterGuiInput.Stop;
    }
    return EditorPlugin.AfterGuiInput.Pass;
}

public virtual void _Forward3DForceDrawOverViewport(Control viewportControl);

This method is the same as EditorPlugin._Forward3DDrawOverViewport, except it draws on top of everything. Useful when you need an extra layer that shows over anything else. You need to enable calling of this method by using EditorPlugin.SetForceDrawOverForwardingEnabled.

public virtual int _Forward3DGuiInput(Camera3D viewportCamera, InputEvent @event);

Called when there is a root node in the current edited scene, EditorPlugin._Handles is implemented, and an InputEvent happens in the 3D viewport. The return value decides whether the InputEvent is consumed or forwarded to other EditorPlugins. See EditorPlugin.AfterGuiInput for options.

// Prevents the InputEvent from reaching other Editor classes.
public override EditorPlugin.AfterGuiInput _Forward3DGuiInput(Camera3D camera, InputEvent @event)
{
    return EditorPlugin.AfterGuiInput.Stop;
}

This method must return EditorPlugin.AfterGuiInput.Pass in order to forward the InputEvent to other Editor classes.

// Consumes InputEventMouseMotion and forwards other InputEvent types.
public override EditorPlugin.AfterGuiInput _Forward3DGuiInput(Camera3D camera, InputEvent @event)
{
    return @event is InputEventMouseMotion ? EditorPlugin.AfterGuiInput.Stop : EditorPlugin.AfterGuiInput.Pass;
}

public virtual void _ForwardCanvasDrawOverViewport(Control viewportControl);

Called by the engine when the 2D editor's viewport is updated. viewport_control is an overlay on top of the viewport and it can be used for drawing. You can update the viewport manually by calling EditorPlugin.UpdateOverlays.

public override void _ForwardCanvasDrawOverViewport(Control viewportControl)
{
    // Draw a circle at the cursor's position.
    viewportControl.DrawCircle(viewportControl.GetLocalMousePosition(), 64, Colors.White);
}

public override bool _ForwardCanvasGuiInput(InputEvent @event)
{
    if (@event is InputEventMouseMotion)
    {
        // Redraw the viewport when the cursor is moved.
        UpdateOverlays();
        return true;
    }
    return false;
}

public virtual void _ForwardCanvasForceDrawOverViewport(Control viewportControl);

This method is the same as EditorPlugin._ForwardCanvasDrawOverViewport, except it draws on top of everything. Useful when you need an extra layer that shows over anything else. You need to enable calling of this method by using EditorPlugin.SetForceDrawOverForwardingEnabled.

public virtual bool _ForwardCanvasGuiInput(InputEvent @event);

Called when there is a root node in the current edited scene, EditorPlugin._Handles is implemented, and an InputEvent happens in the 2D viewport. If this method returns true, event is intercepted by this EditorPlugin, otherwise event is forwarded to other Editor classes.

// Prevents the InputEvent from reaching other Editor classes.
public override bool ForwardCanvasGuiInput(InputEvent @event)
{
    return true;
}

This method must return false in order to forward the InputEvent to other Editor classes.

// Consumes InputEventMouseMotion and forwards other InputEvent types.
public override bool _ForwardCanvasGuiInput(InputEvent @event)
{
    if (@event is InputEventMouseMotion)
    {
        return true;
    }
    return false;
}

public virtual string[] _GetBreakpoints();

This is for editors that edit script-based objects. You can return a list of breakpoints in the format (script:line), for example: asset://path_to_script.cs:25.

public virtual Texture2D _GetPluginIcon();

Override this method in your plugin to return a Texture2D in order to give it an icon. For main screen plugins, this appears at the top of the screen, to the right of the "2D", "3D", "Script", "Game", and "Asset Store" buttons. Ideally, the plugin icon should be white with a transparent background and 16×16 pixels in size.

public override Texture2D _GetPluginIcon()
{
    // You can use a custom icon:
    return ResourceLoader.Load<Texture2D>("asset://addons/my_plugin/my_plugin_icon.svg");
    // Or use a built-in icon:
    return EditorInterface.Singleton.GetEditorTheme().GetIcon("Entity", "EditorIcons");
}

public virtual string _GetPluginName();

Override this method in your plugin to provide the name of the plugin when displayed in the Reckfell editor. For main screen plugins, this appears at the top of the screen, to the right of the "2D", "3D", "Script", "Game", and "Asset Store" buttons. Note: Main screen plugins should instead use EditorDock.Title of a main screen dock.

public virtual Reckfell.Collections.Dictionary _GetState();

Override this method to provide a state data you want to be saved, like view position, grid settings, folding, etc. This is used when saving the scene (so state is kept when opening it again) and for switching tabs (so state can be restored when the tab returns). This data is automatically saved for each scene in an editstate file in the editor metadata folder. If you want to store global (scene-independent) editor data for your plugin, you can use EditorPlugin._GetWindowLayout instead. Use EditorPlugin._SetState to restore your saved state. Note: This method should not be used to save important settings that should persist with the project. Note: You must implement EditorPlugin._GetPluginName for the state to be stored and restored correctly.

public virtual string _GetUnsavedStatus(string forScene);

Override this method to provide a custom message that lists unsaved changes. The editor will call this method when exiting or when closing a scene, and display the returned string in a confirmation dialog. Return empty string if the plugin has no unsaved changes. When closing a scene, for_scene is the path to the scene being closed. You can use it to handle built-in resources in that scene. If the user confirms saving, EditorPlugin._SaveExternalData will be called, before closing the editor.

If the plugin has no scene-specific changes, you can ignore the calls when closing scenes:

public virtual void _GetWindowLayout(ConfigFile configuration);

Override this method to provide the GUI layout of the plugin or any other data you want to be stored. This is used to save the project's editor layout when EditorPlugin.QueueSaveLayout is called or the editor layout was changed (for example changing the position of a dock). The data is stored in the editor_layout.cfg file in the editor metadata directory. Use EditorPlugin._SetWindowLayout to restore your saved layout.

public virtual bool _Handles(ReckfellObject @object);

Implement this function if your plugin edits a specific type of object (Resource or Entity). If you return true, then you will get the functions EditorPlugin._Edit and EditorPlugin._MakeVisible called when the editor requests them. If you have declared the methods EditorPlugin._ForwardCanvasGuiInput and EditorPlugin._Forward3DGuiInput these will be called too. Note: Each plugin should handle only one type of objects at a time. If a plugin handles more types of objects and they are edited at the same time, it will result in errors.

public virtual bool _HasMainScreen();

Return true if this is a main screen editor plugin (it goes in the workspace selector together with 2D, 3D, Script, Game, and Asset Store). You can add a main screen dock by using EditorDock with EditorDock.DockLayout.MainScreen as available layout.

public virtual void _MakeVisible(bool visible);

This function will be called when the editor is requested to become visible. It is used for plugins that edit a specific object type. Remember that you have to manage the visibility of all your editor controls manually.

public virtual string[] _RunScene(string scene, string[] args);

This function is called when an individual scene is about to be played in the editor. args is a list of command line arguments that will be passed to the new Reckfell instance, which will be replaced by the list returned by this function.

Note: Text that is printed in this method will not be visible in the editor's Output panel unless EditorSettings.run/output/always_clear_output_on_play is false.

public virtual void _SaveExternalData();

This method is called after the editor saves the project or when it's closed. It asks the plugin to save edited external scenes/resources.

public virtual void _SetState(Reckfell.Collections.Dictionary state);

Restore the state saved by EditorPlugin._GetState. This method is called when the current scene tab is changed in the editor. Note: Your plugin must implement EditorPlugin._GetPluginName, otherwise it will not be recognized and this method will not be called.

public virtual void _SetWindowLayout(ConfigFile configuration);

Restore the plugin GUI layout and data saved by EditorPlugin._GetWindowLayout. This method is called for every plugin on editor startup. Use the provided configuration file to read your saved data.

public event EditorPlugin.MainScreenChangedEventHandler MainScreenChanged;

Emitted when user changes the workspace (2D, 3D, Script, Game, Asset Store). Also works with custom screens defined by plugins.

public event Action ProjectSettingsChanged;

Emitted when any project setting has changed.

public event EditorPlugin.ResourceSavedEventHandler ResourceSaved;

Emitted when the given resource was saved on disc. See also EditorPlugin.SceneSaved.

public event EditorPlugin.SceneChangedEventHandler SceneChanged;

Emitted when the scene is changed in the editor. The argument will return the root node of the scene that has just become active. If this scene is new and empty, the argument will be null.

public event EditorPlugin.SceneClosedEventHandler SceneClosed;

Emitted when user closes a scene. The argument is a file path to the closed scene.

public event EditorPlugin.SceneSavedEventHandler SceneSaved;

Emitted when a scene was saved on disc. The argument is a file path to the saved scene. See also EditorPlugin.ResourceSaved.