Namespace Godot

Classes

Object that holds all the available Commands and their shortcuts text. These Commands can be accessed through Editor > Command Palette menu.

Command key names use slash delimiters to distinguish sections, for example: "example/command1" then example will be the section name.

EditorCommandPalette commandPalette = EditorInterface.Singleton.GetCommandPalette();
  // ExternalCommand is a function that will be called with the command is executed.
  Callable commandCallable = new Callable(this, MethodName.ExternalCommand);
  commandPalette.AddCommand("command", "test/command", commandCallable)

Note: This class shouldn't be instantiated directly. Instead, access the singleton using GetCommandPalette().

EditorCommandPalette.MethodName: Cached StringNames for the methods contained in this class, for fast lookup.

EditorCommandPalette.PropertyName: Cached StringNames for the properties and fields contained in this class, for fast lookup.

EditorCommandPalette.SignalName: Cached StringNames for the signals contained in this class, for fast lookup.

EditorDebuggerPlugin

EditorDebuggerPlugin provides functions related to the editor side of the debugger.

To interact with the debugger, an instance of this class must be added to the editor via AddDebuggerPlugin(EditorDebuggerPlugin).

Once added, the _SetupSession(int) callback will be called for every EditorDebuggerSession available to the plugin, and when new ones are created (the sessions may be inactive during this stage).

You can retrieve the available EditorDebuggerSessions via GetSessions() or get a specific one via GetSession(int).

EditorDebuggerPlugin.MethodName: Cached StringNames for the methods contained in this class, for fast lookup.

EditorDebuggerPlugin.PropertyName: Cached StringNames for the properties and fields contained in this class, for fast lookup.

EditorDebuggerPlugin.SignalName: Cached StringNames for the signals contained in this class, for fast lookup.

EditorDebuggerSession

This class cannot be directly instantiated and must be retrieved via a EditorDebuggerPlugin.

You can add tabs to the session UI via AddSessionTab(Control), send messages via SendMessage(string, Array), and toggle EngineProfilers via ToggleProfiler(string, bool, Array).

EditorDebuggerSession.MethodName: Cached StringNames for the methods contained in this class, for fast lookup.

EditorDebuggerSession.PropertyName: Cached StringNames for the properties and fields contained in this class, for fast lookup.

EditorDebuggerSession.SignalName: Cached StringNames for the signals contained in this class, for fast lookup.

EditorExportPlatform

Base resource that provides the functionality of exporting a release build of a project to a platform, from the editor. Stores platform-specific metadata such as the name and supported features of the platform, and performs the exporting of projects, PCK files, and ZIP files. Uses an export template for the platform provided at the time of project exporting.

Used in scripting by EditorExportPlugin to configure platform-specific customization of scenes and resources. See _BeginCustomizeScenes(EditorExportPlatform, string[]) and _BeginCustomizeResources(EditorExportPlatform, string[]) for more details.

EditorExportPlatform.MethodName: Cached StringNames for the methods contained in this class, for fast lookup.

EditorExportPlatform.PropertyName: Cached StringNames for the properties and fields contained in this class, for fast lookup.

EditorExportPlatform.SignalName: Cached StringNames for the signals contained in this class, for fast lookup.

EditorExportPlatformAndroid

EditorExportPlatformAndroid.MethodName: Cached StringNames for the methods contained in this class, for fast lookup.

EditorExportPlatformAndroid.PropertyName: Cached StringNames for the properties and fields contained in this class, for fast lookup.

EditorExportPlatformAndroid.SignalName: Cached StringNames for the signals contained in this class, for fast lookup.

EditorExportPlatformIos

EditorExportPlatformIos.MethodName: Cached StringNames for the methods contained in this class, for fast lookup.

EditorExportPlatformIos.PropertyName: Cached StringNames for the properties and fields contained in this class, for fast lookup.

EditorExportPlatformIos.SignalName: Cached StringNames for the signals contained in this class, for fast lookup.

EditorExportPlatformLinuxBsd

EditorExportPlatformLinuxBsd.MethodName: Cached StringNames for the methods contained in this class, for fast lookup.

EditorExportPlatformLinuxBsd.PropertyName: Cached StringNames for the properties and fields contained in this class, for fast lookup.

EditorExportPlatformLinuxBsd.SignalName: Cached StringNames for the signals contained in this class, for fast lookup.

EditorExportPlatformMacOS

EditorExportPlatformMacOS.MethodName: Cached StringNames for the methods contained in this class, for fast lookup.

EditorExportPlatformMacOS.PropertyName: Cached StringNames for the properties and fields contained in this class, for fast lookup.

EditorExportPlatformMacOS.SignalName: Cached StringNames for the signals contained in this class, for fast lookup.

EditorExportPlatformPC

EditorExportPlatformPC.MethodName: Cached StringNames for the methods contained in this class, for fast lookup.

EditorExportPlatformPC.PropertyName: Cached StringNames for the properties and fields contained in this class, for fast lookup.

EditorExportPlatformPC.SignalName: Cached StringNames for the signals contained in this class, for fast lookup.

EditorExportPlatformWeb

The Web exporter customizes how a web build is handled. In the editor's "Export" window, it is created when adding a new "Web" preset.

Note: Godot on Web is rendered inside a <canvas> tag. Normally, the canvas cannot be positioned or resized manually, but otherwise acts as the main Window of the application.

EditorExportPlatformWeb.MethodName: Cached StringNames for the methods contained in this class, for fast lookup.

EditorExportPlatformWeb.PropertyName: Cached StringNames for the properties and fields contained in this class, for fast lookup.

EditorExportPlatformWeb.SignalName: Cached StringNames for the signals contained in this class, for fast lookup.

EditorExportPlatformWindows

EditorExportPlatformWindows.MethodName: Cached StringNames for the methods contained in this class, for fast lookup.

EditorExportPlatformWindows.PropertyName: Cached StringNames for the properties and fields contained in this class, for fast lookup.

EditorExportPlatformWindows.SignalName: Cached StringNames for the signals contained in this class, for fast lookup.

EditorExportPlugin

EditorExportPlugins are automatically invoked whenever the user exports the project. Their most common use is to determine what files are being included in the exported project. For each plugin, _ExportBegin(string[], bool, string, uint) is called at the beginning of the export process and then _ExportFile(string, string, string[]) is called for each exported file.

To use EditorExportPlugin, register it using the AddExportPlugin(EditorExportPlugin) method first.

EditorExportPlugin.MethodName: Cached StringNames for the methods contained in this class, for fast lookup.

EditorExportPlugin.PropertyName: Cached StringNames for the properties and fields contained in this class, for fast lookup.

EditorExportPlugin.SignalName: Cached StringNames for the signals contained in this class, for fast lookup.

EditorFeatureProfile

An editor feature profile can be used to disable specific features of the Godot editor. When disabled, the features won't appear in the editor, which makes the editor less cluttered. This is useful in education settings to reduce confusion or when working in a team. For example, artists and level designers could use a feature profile that disables the script editor to avoid accidentally making changes to files they aren't supposed to edit.

To manage editor feature profiles visually, use Editor > Manage Feature Profiles... at the top of the editor window.

EditorFeatureProfile.MethodName: Cached StringNames for the methods contained in this class, for fast lookup.

EditorFeatureProfile.PropertyName: Cached StringNames for the properties and fields contained in this class, for fast lookup.

EditorFeatureProfile.SignalName: Cached StringNames for the signals contained in this class, for fast lookup.

EditorFileDialog: EditorFileDialog is an enhanced version of FileDialog available only to editor plugins. Additional features include list of favorited/recent files and the ability to see files as thumbnails grid instead of list.

EditorFileDialog.MethodName: Cached StringNames for the methods contained in this class, for fast lookup.

EditorFileDialog.PropertyName: Cached StringNames for the properties and fields contained in this class, for fast lookup.

EditorFileDialog.SignalName: Cached StringNames for the signals contained in this class, for fast lookup.

EditorFileSystem

This object holds information of all resources in the filesystem, their types, etc.

Note: This class shouldn't be instantiated directly. Instead, access the singleton using GetResourceFilesystem().

EditorFileSystem.MethodName: Cached StringNames for the methods contained in this class, for fast lookup.

EditorFileSystem.PropertyName: Cached StringNames for the properties and fields contained in this class, for fast lookup.

EditorFileSystem.SignalName: Cached StringNames for the signals contained in this class, for fast lookup.

EditorFileSystemDirectory: A more generalized, low-level variation of the directory concept.

EditorFileSystemDirectory.MethodName: Cached StringNames for the methods contained in this class, for fast lookup.

EditorFileSystemDirectory.PropertyName: Cached StringNames for the properties and fields contained in this class, for fast lookup.

EditorFileSystemDirectory.SignalName: Cached StringNames for the signals contained in this class, for fast lookup.

EditorFileSystemImportFormatSupportQuery: This class is used to query and configure a certain import format. It is used in conjunction with asset format import plugins.

EditorFileSystemImportFormatSupportQuery.MethodName: Cached StringNames for the methods contained in this class, for fast lookup.

EditorFileSystemImportFormatSupportQuery.PropertyName: Cached StringNames for the properties and fields contained in this class, for fast lookup.

EditorFileSystemImportFormatSupportQuery.SignalName: Cached StringNames for the signals contained in this class, for fast lookup.

EditorImportPlugin

EditorImportPlugins provide a way to extend the editor's resource import functionality. Use them to import resources from custom files or to provide alternatives to the editor's existing importers.

EditorImportPlugins work by associating with specific file extensions and a resource type. See _GetRecognizedExtensions() and _GetResourceType(). They may optionally specify some import presets that affect the import process. EditorImportPlugins are responsible for creating the resources and saving them in the .godot/imported directory (see ProjectSettings.application/config/use_hidden_project_data_directory).

Below is an example EditorImportPlugin that imports a Mesh from a file with the extension ".special" or ".spec":

using Godot;
public partial class MySpecialPlugin : EditorImportPlugin
{
public override string _GetImporterName()
{
return "my.special.plugin";
}
  public override string _GetVisibleName()
  {
      return "Special Mesh";
  }

  public override string[] _GetRecognizedExtensions()
  {
      return new string[] { "special", "spec" };
  }

  public override string _GetSaveExtension()
  {
      return "mesh";
  }

  public override string _GetResourceType()
  {
      return "Mesh";
  }

  public override int _GetPresetCount()
  {
      return 1;
  }

  public override string _GetPresetName(int presetIndex)
  {
      return "Default";
  }

  public override Godot.Collections.Array<Godot.Collections.Dictionary> _GetImportOptions(string path, int presetIndex)
  {
      return new Godot.Collections.Array<Godot.Collections.Dictionary>
      {
          new Godot.Collections.Dictionary
          {
              { "name", "myOption" },
              { "default_value", false },
          }
      };
  }

  public override int _Import(string sourceFile, string savePath, Godot.Collections.Dictionary options, Godot.Collections.Array<string> platformVariants, Godot.Collections.Array<string> genFiles)
  {
      using var file = FileAccess.Open(sourceFile, FileAccess.ModeFlags.Read);
      if (file.GetError() != Error.Ok)
      {
          return (int)Error.Failed;
      }

      var mesh = new ArrayMesh();
      // Fill the Mesh with data read in "file", left as an exercise to the reader.
      string filename = $"{savePath}.{_GetSaveExtension()}";
      return (int)ResourceSaver.Save(mesh, filename);
  }

}

To use EditorImportPlugin, register it using the AddImportPlugin(EditorImportPlugin, bool) method first.

EditorImportPlugin.MethodName: Cached StringNames for the methods contained in this class, for fast lookup.

EditorImportPlugin.PropertyName: Cached StringNames for the properties and fields contained in this class, for fast lookup.

EditorImportPlugin.SignalName: Cached StringNames for the signals contained in this class, for fast lookup.

EditorInspector

This is the control that implements property editing in the editor's Settings dialogs, the Inspector dock, etc. To get the EditorInspector used in the editor's Inspector dock, use GetInspector().

EditorInspector will show properties in the same order as the array returned by GetPropertyList().

If a property's name is path-like (i.e. if it contains forward slashes), EditorInspector will create nested sections for "directories" along the path. For example, if a property is named highlighting/gdscript/node_path_color, it will be shown as "Node Path Color" inside the "GDScript" section nested inside the "Highlighting" section.

If a property has Group usage, it will group subsequent properties whose name starts with the property's hint string. The group ends when a property does not start with that hint string or when a new group starts. An empty group name effectively ends the current group. EditorInspector will create a top-level section for each group. For example, if a property with group usage is named Collide With and its hint string is collide_with_, a subsequent collide_with_area property will be shown as "Area" inside the "Collide With" section. There is also a special case: when the hint string contains the name of a property, that property is grouped too. This is mainly to help grouping properties like font, font_color and font_size (using the hint string font_).

If a property has Subgroup usage, a subgroup will be created in the same way as a group, and a second-level section will be created for each subgroup.

Note: Unlike sections created from path-like property names, EditorInspector won't capitalize the name for sections created from groups. So properties with group usage usually use capitalized names instead of snake_cased names.

EditorInspector.MethodName: Cached StringNames for the methods contained in this class, for fast lookup.

EditorInspector.PropertyName: Cached StringNames for the properties and fields contained in this class, for fast lookup.

EditorInspector.SignalName: Cached StringNames for the signals contained in this class, for fast lookup.

EditorInspectorPlugin

EditorInspectorPlugin allows adding custom property editors to EditorInspector.

When an object is edited, the _CanHandle(GodotObject) function is called and must return true if the object type is supported.

If supported, the function _ParseBegin(GodotObject) will be called, allowing to place custom controls at the beginning of the class.

Subsequently, the _ParseCategory(GodotObject, string) and _ParseProperty(GodotObject, Type, string, PropertyHint, string, PropertyUsageFlags, bool) are called for every category and property. They offer the ability to add custom controls to the inspector too.

Finally, _ParseEnd(GodotObject) will be called.

On each of these calls, the "add" functions can be called.

To use EditorInspectorPlugin, register it using the AddInspectorPlugin(EditorInspectorPlugin) method first.

EditorInspectorPlugin.MethodName: Cached StringNames for the methods contained in this class, for fast lookup.

EditorInspectorPlugin.PropertyName: Cached StringNames for the properties and fields contained in this class, for fast lookup.

EditorInspectorPlugin.SignalName: Cached StringNames for the signals contained in this class, for fast lookup.

EditorInterface

EditorInterface gives you control over Godot editor's window. It allows customizing the window, saving and (re-)loading scenes, rendering mesh previews, inspecting and editing resources and objects, and provides access to EditorSettings, EditorFileSystem, EditorResourcePreview, ScriptEditor, the editor viewport, and information about scenes.

Note: This class shouldn't be instantiated directly. Instead, access the singleton directly by its name.

// In C# you can access it via the static Singleton property.
  EditorSettings settings = EditorInterface.Singleton.GetEditorSettings();

EditorInterface.MethodName: Cached StringNames for the methods contained in this class, for fast lookup.

EditorInterface.PropertyName: Cached StringNames for the properties and fields contained in this class, for fast lookup.

EditorInterface.SignalName: Cached StringNames for the signals contained in this class, for fast lookup.

EditorNode3DGizmo: Gizmo that is used for providing custom visualization and editing (handles and subgizmos) for Node3D objects. Can be overridden to create custom gizmos, but for simple gizmos creating a EditorNode3DGizmoPlugin is usually recommended.

EditorNode3DGizmo.MethodName: Cached StringNames for the methods contained in this class, for fast lookup.

EditorNode3DGizmo.PropertyName: Cached StringNames for the properties and fields contained in this class, for fast lookup.

EditorNode3DGizmo.SignalName: Cached StringNames for the signals contained in this class, for fast lookup.

EditorNode3DGizmoPlugin

EditorNode3DGizmoPlugin allows you to define a new type of Gizmo. There are two main ways to do so: extending EditorNode3DGizmoPlugin for the simpler gizmos, or creating a new EditorNode3DGizmo type. See the tutorial in the documentation for more info.

To use EditorNode3DGizmoPlugin, register it using the AddNode3DGizmoPlugin(EditorNode3DGizmoPlugin) method first.

EditorNode3DGizmoPlugin.MethodName: Cached StringNames for the methods contained in this class, for fast lookup.

EditorNode3DGizmoPlugin.PropertyName: Cached StringNames for the properties and fields contained in this class, for fast lookup.

EditorNode3DGizmoPlugin.SignalName: Cached StringNames for the signals contained in this class, for fast lookup.

EditorPaths

This editor-only singleton returns OS-specific paths to various data folders and files. It can be used in editor plugins to ensure files are saved in the correct location on each operating system.

Note: This singleton is not accessible in exported projects. Attempting to access it in an exported project will result in a script error as the singleton won't be declared. To prevent script errors in exported projects, use HasSingleton(StringName) to check whether the singleton is available before using it.

Note: On the Linux/BSD platform, Godot complies with the XDG Base Directory Specification. You can override environment variables following the specification to change the editor and project data paths.

EditorPaths.MethodName: Cached StringNames for the methods contained in this class, for fast lookup.

EditorPaths.PropertyName: Cached StringNames for the properties and fields contained in this class, for fast lookup.

EditorPaths.SignalName: Cached StringNames for the signals contained in this class, for fast lookup.

EditorPlugin

Plugins are used by the editor to extend functionality. The most common types of plugins are those which edit a given node or resource type, import plugins and export plugins. See also EditorScript to add functions to the editor.

Note: Some names in this class contain "left" or "right" (e.g. LeftUl). These APIs assume left-to-right layout, and would be backwards when using right-to-left layout. These names are kept for compatibility reasons.

EditorPlugin.MethodName: Cached StringNames for the methods contained in this class, for fast lookup.

EditorPlugin.PropertyName: Cached StringNames for the properties and fields contained in this class, for fast lookup.

EditorPlugin.SignalName: Cached StringNames for the signals contained in this class, for fast lookup.

EditorProperty: A custom control for editing properties that can be added to the EditorInspector. It is added via EditorInspectorPlugin.

EditorProperty.MethodName: Cached StringNames for the methods contained in this class, for fast lookup.

EditorProperty.PropertyName: Cached StringNames for the properties and fields contained in this class, for fast lookup.

EditorProperty.SignalName: Cached StringNames for the signals contained in this class, for fast lookup.

EditorResourceConversionPlugin

EditorResourceConversionPlugin is invoked when the context menu is brought up for a resource in the editor inspector. Relevant conversion plugins will appear as menu options to convert the given resource to a target type.

Below shows an example of a basic plugin that will convert an ImageTexture to a PortableCompressedTexture2D.

To use an EditorResourceConversionPlugin, register it using the AddResourceConversionPlugin(EditorResourceConversionPlugin) method first.

EditorResourceConversionPlugin.MethodName: Cached StringNames for the methods contained in this class, for fast lookup.

EditorResourceConversionPlugin.PropertyName: Cached StringNames for the properties and fields contained in this class, for fast lookup.

EditorResourceConversionPlugin.SignalName: Cached StringNames for the signals contained in this class, for fast lookup.

EditorResourcePicker

This Control node is used in the editor's Inspector dock to allow editing of Resource type properties. It provides options for creating, loading, saving and converting resources. Can be used with EditorInspectorPlugin to recreate the same behavior.

Note: This Control does not include any editor for the resource, as editing is controlled by the Inspector dock itself or sub-Inspectors.

EditorResourcePicker.MethodName: Cached StringNames for the methods contained in this class, for fast lookup.

EditorResourcePicker.PropertyName: Cached StringNames for the properties and fields contained in this class, for fast lookup.

EditorResourcePicker.SignalName: Cached StringNames for the signals contained in this class, for fast lookup.

EditorResourcePreview

This node is used to generate previews for resources or files.

Note: This class shouldn't be instantiated directly. Instead, access the singleton using GetResourcePreviewer().

EditorResourcePreview.MethodName: Cached StringNames for the methods contained in this class, for fast lookup.

EditorResourcePreview.PropertyName: Cached StringNames for the properties and fields contained in this class, for fast lookup.

EditorResourcePreview.SignalName: Cached StringNames for the signals contained in this class, for fast lookup.

EditorResourcePreviewGenerator: Custom code to generate previews. Please check file_dialog/thumbnail_size in EditorSettings to find out the right size to do previews at.

EditorResourcePreviewGenerator.MethodName: Cached StringNames for the methods contained in this class, for fast lookup.

EditorResourcePreviewGenerator.PropertyName: Cached StringNames for the properties and fields contained in this class, for fast lookup.

EditorResourcePreviewGenerator.SignalName: Cached StringNames for the signals contained in this class, for fast lookup.

EditorResourceTooltipPlugin

Resource tooltip plugins are used by FileSystemDock to generate customized tooltips for specific resources. E.g. tooltip for a Texture2D displays a bigger preview and the texture's dimensions.

A plugin must be first registered with AddResourceTooltipPlugin(EditorResourceTooltipPlugin). When the user hovers a resource in filesystem dock which is handled by the plugin, _MakeTooltipForPath(string, Dictionary, Control) is called to create the tooltip. It works similarly to _MakeCustomTooltip(string).

EditorResourceTooltipPlugin.MethodName: Cached StringNames for the methods contained in this class, for fast lookup.

EditorResourceTooltipPlugin.PropertyName: Cached StringNames for the properties and fields contained in this class, for fast lookup.

EditorResourceTooltipPlugin.SignalName: Cached StringNames for the signals contained in this class, for fast lookup.

EditorSceneFormatImporter

EditorSceneFormatImporter allows to define an importer script for a third-party 3D format.

To use EditorSceneFormatImporter, register it using the AddSceneFormatImporterPlugin(EditorSceneFormatImporter, bool) method first.

EditorSceneFormatImporter.MethodName: Cached StringNames for the methods contained in this class, for fast lookup.

EditorSceneFormatImporter.PropertyName: Cached StringNames for the properties and fields contained in this class, for fast lookup.

EditorSceneFormatImporter.SignalName: Cached StringNames for the signals contained in this class, for fast lookup.

EditorSceneFormatImporterBlend

Imports Blender scenes in the .blend file format through the glTF 2.0 3D import pipeline. This importer requires Blender to be installed by the user, so that it can be used to export the scene as glTF 2.0.

The location of the Blender binary is set via the filesystem/import/blender/blender3_path editor setting.

This importer is only used if ProjectSettings.filesystem/import/blender/enabled is enabled, otherwise .blend files present in the project folder are not imported.

Blend import requires Blender 3.0.

Internally, the EditorSceneFormatImporterBlend uses the Blender glTF "Use Original" mode to reference external textures.

EditorSceneFormatImporterBlend.MethodName: Cached StringNames for the methods contained in this class, for fast lookup.

EditorSceneFormatImporterBlend.PropertyName: Cached StringNames for the properties and fields contained in this class, for fast lookup.

EditorSceneFormatImporterBlend.SignalName: Cached StringNames for the signals contained in this class, for fast lookup.

EditorSceneFormatImporterFbx

Imports Autodesk FBX 3D scenes by way of converting them to glTF 2.0 using the FBX2glTF command line tool.

The location of the FBX2glTF binary is set via the filesystem/import/fbx/fbx2gltf_path editor setting.

This importer is only used if ProjectSettings.filesystem/import/fbx/enabled is enabled, otherwise .fbx files present in the project folder are not imported.

EditorSceneFormatImporterFbx.MethodName: Cached StringNames for the methods contained in this class, for fast lookup.

EditorSceneFormatImporterFbx.PropertyName: Cached StringNames for the properties and fields contained in this class, for fast lookup.

EditorSceneFormatImporterFbx.SignalName: Cached StringNames for the signals contained in this class, for fast lookup.

EditorSceneFormatImporterGltf

EditorSceneFormatImporterGltf.MethodName: Cached StringNames for the methods contained in this class, for fast lookup.

EditorSceneFormatImporterGltf.PropertyName: Cached StringNames for the properties and fields contained in this class, for fast lookup.

EditorSceneFormatImporterGltf.SignalName: Cached StringNames for the signals contained in this class, for fast lookup.

EditorScenePostImport

Imported scenes can be automatically modified right after import by setting their Custom Script Import property to a tool script that inherits from this class.

The _PostImport(Node) callback receives the imported scene's root node and returns the modified version of the scene. Usage example:

using Godot;
// This sample changes all node names.
// Called right after the scene is imported and gets the root node.
[Tool]
public partial class NodeRenamer : EditorScenePostImport
{
public override GodotObject PostImport(Node scene)
{
// Change all node names to "modified[oldnodename]"
Iterate(scene);
return scene; // Remember to return the imported scene
}
  public void Iterate(Node node)
  {
      if (node != null)
      {
          node.Name = $"modified_{node.Name}";
          foreach (Node child in node.GetChildren())
          {
              Iterate(child);
          }
      }
  }

}

EditorScenePostImport.MethodName: Cached StringNames for the methods contained in this class, for fast lookup.

EditorScenePostImport.PropertyName: Cached StringNames for the properties and fields contained in this class, for fast lookup.

EditorScenePostImport.SignalName: Cached StringNames for the signals contained in this class, for fast lookup.

EditorScenePostImportPlugin: This plugin type exists to modify the process of importing scenes, allowing to change the content as well as add importer options at every stage of the process.

EditorScenePostImportPlugin.MethodName: Cached StringNames for the methods contained in this class, for fast lookup.

EditorScenePostImportPlugin.PropertyName: Cached StringNames for the properties and fields contained in this class, for fast lookup.

EditorScenePostImportPlugin.SignalName: Cached StringNames for the signals contained in this class, for fast lookup.

EditorScript

Scripts extending this class and implementing its _Run() method can be executed from the Script Editor's File > Run menu option (or by pressing Ctrl + Shift + X) while the editor is running. This is useful for adding custom in-editor functionality to Godot. For more complex additions, consider using EditorPlugins instead.

Note: Extending scripts need to have tool mode enabled.

Example script:

using Godot;
[Tool]
public partial class HelloEditor : EditorScript
{
public override void _Run()
{
GD.Print("Hello from the Godot Editor!");
}
}

Note: The script is run in the Editor context, which means the output is visible in the console window started with the Editor (stdout) instead of the usual Godot Output dock.

Note: EditorScript is RefCounted, meaning it is destroyed when nothing references it. This can cause errors during asynchronous operations if there are no references to the script.

EditorScript.MethodName: Cached StringNames for the methods contained in this class, for fast lookup.

EditorScript.PropertyName: Cached StringNames for the properties and fields contained in this class, for fast lookup.

EditorScript.SignalName: Cached StringNames for the signals contained in this class, for fast lookup.

EditorScriptPicker

Similar to EditorResourcePicker this Control node is used in the editor's Inspector dock, but only to edit the script property of a Node. Default options for creating new resources of all possible subtypes are replaced with dedicated buttons that open the "Attach Node Script" dialog. Can be used with EditorInspectorPlugin to recreate the same behavior.

Note: You must set the ScriptOwner for the custom context menu items to work.

EditorScriptPicker.MethodName: Cached StringNames for the methods contained in this class, for fast lookup.

EditorScriptPicker.PropertyName: Cached StringNames for the properties and fields contained in this class, for fast lookup.

EditorScriptPicker.SignalName: Cached StringNames for the signals contained in this class, for fast lookup.

EditorSelection

This object manages the SceneTree selection in the editor.

Note: This class shouldn't be instantiated directly. Instead, access the singleton using GetSelection().

EditorSelection.MethodName: Cached StringNames for the methods contained in this class, for fast lookup.

EditorSelection.PropertyName: Cached StringNames for the properties and fields contained in this class, for fast lookup.

EditorSelection.SignalName: Cached StringNames for the signals contained in this class, for fast lookup.

EditorSettings

Object that holds the project-independent editor settings. These settings are generally visible in the Editor > Editor Settings menu.

Property names use slash delimiters to distinguish sections. Setting values can be of any Variant type. It's recommended to use snake_case for editor settings to be consistent with the Godot editor itself.

Accessing the settings can be done using the following methods, such as:

EditorSettings settings = EditorInterface.Singleton.GetEditorSettings();
  // `settings.set("some/property", value)` also works as this class overrides `_set()` internally.
  settings.SetSetting("some/property", Value);
  // `settings.get("some/property", value)` also works as this class overrides `_get()` internally.
  settings.GetSetting("some/property");
  Godot.Collections.Array<Godot.Collections.Dictionary> listOfSettings = settings.GetPropertyList();

Note: This class shouldn't be instantiated directly. Instead, access the singleton using GetEditorSettings().

EditorSettings.MethodName: Cached StringNames for the methods contained in this class, for fast lookup.

EditorSettings.PropertyName: Cached StringNames for the properties and fields contained in this class, for fast lookup.

EditorSettings.SignalName: Cached StringNames for the signals contained in this class, for fast lookup.

EditorSpinSlider

This Control node is used in the editor's Inspector dock to allow editing of numeric values. Can be used with EditorInspectorPlugin to recreate the same behavior.

If the Step value is 1, the EditorSpinSlider will display up/down arrows, similar to SpinBox. If the Step value is not 1, a slider will be displayed instead.

EditorSpinSlider.MethodName: Cached StringNames for the methods contained in this class, for fast lookup.

EditorSpinSlider.PropertyName: Cached StringNames for the properties and fields contained in this class, for fast lookup.

EditorSpinSlider.SignalName: Cached StringNames for the signals contained in this class, for fast lookup.

EditorSyntaxHighlighter

Base class that all SyntaxHighlighters used by the ScriptEditor extend from.

Add a syntax highlighter to an individual script by calling AddSyntaxHighlighter(EditorSyntaxHighlighter). To apply to all scripts on open, call RegisterSyntaxHighlighter(EditorSyntaxHighlighter).

EditorSyntaxHighlighter.MethodName: Cached StringNames for the methods contained in this class, for fast lookup.

EditorSyntaxHighlighter.PropertyName: Cached StringNames for the properties and fields contained in this class, for fast lookup.

EditorSyntaxHighlighter.SignalName: Cached StringNames for the signals contained in this class, for fast lookup.

EditorTranslationParserPlugin

EditorTranslationParserPlugin is invoked when a file is being parsed to extract strings that require translation. To define the parsing and string extraction logic, override the _ParseFile(string, Array<string>, Array<Array>) method in script.

Add the extracted strings to argument msgids or msgids_context_plural if context or plural is used.

When adding to msgids_context_plural, you must add the data using the format ["A", "B", "C"], where A represents the extracted string, B represents the context, and C represents the plural version of the extracted string. If you want to add only context but not plural, put "" for the plural slot. The idea is the same if you only want to add plural but not context. See the code below for concrete examples.

The extracted strings will be written into a POT file selected by user under "POT Generation" in "Localization" tab in "Project Settings" menu.

Below shows an example of a custom parser that extracts strings from a CSV file to write into a POT.

using Godot;
[Tool]
public partial class CustomParser : EditorTranslationParserPlugin
{
public override void _ParseFile(string path, Godot.Collections.Array<string> msgids, Godot.Collections.Array<Godot.Collections.Array> msgidsContextPlural)
{
using var file = FileAccess.Open(path, FileAccess.ModeFlags.Read);
string text = file.GetAsText();
string[] splitStrs = text.Split(",", allowEmpty: false);
foreach (string s in splitStrs)
{
msgids.Add(s);
//GD.Print($"Extracted string: {s}");
}
}
  public override string[] _GetRecognizedExtensions()
  {
      return new string[] { "csv" };
  }

}

To add a translatable string associated with context or plural, add it to msgids_context_plural:

// This will add a message with msgid "Test 1", msgctxt "context", and msgid_plural "test 1 plurals".
  msgidsContextPlural.Add(new Godot.Collections.Array{"Test 1", "context", "test 1 Plurals"});
  // This will add a message with msgid "A test without context" and msgid_plural "plurals".
  msgidsContextPlural.Add(new Godot.Collections.Array{"A test without context", "", "plurals"});
  // This will add a message with msgid "Only with context" and msgctxt "a friendly context".
  msgidsContextPlural.Add(new Godot.Collections.Array{"Only with context", "a friendly context", ""});

Note: If you override parsing logic for standard script types (GDScript, C#, etc.), it would be better to load the path argument using Load(string, string, CacheMode). This is because built-in scripts are loaded as Resource type, not FileAccess type.

For example:

public override void _ParseFile(string path, Godot.Collections.Array<string> msgids, Godot.Collections.Array<Godot.Collections.Array> msgidsContextPlural)
  {
      var res = ResourceLoader.Load<Script>(path, "Script");
      string text = res.SourceCode;
      // Parsing logic.
  }
public override string[] _GetRecognizedExtensions()
{
return new string[] { "gd" };
}

To use EditorTranslationParserPlugin, register it using the AddTranslationParserPlugin(EditorTranslationParserPlugin) method first.

EditorTranslationParserPlugin.MethodName: Cached StringNames for the methods contained in this class, for fast lookup.

EditorTranslationParserPlugin.PropertyName: Cached StringNames for the properties and fields contained in this class, for fast lookup.

EditorTranslationParserPlugin.SignalName: Cached StringNames for the signals contained in this class, for fast lookup.

EditorUndoRedoManager

EditorUndoRedoManager is a manager for UndoRedo objects associated with edited scenes. Each scene has its own undo history and EditorUndoRedoManager ensures that each action performed in the editor gets associated with a proper scene. For actions not related to scenes (ProjectSettings edits, external resources, etc.), a separate global history is used.

The usage is mostly the same as UndoRedo. You create and commit actions and the manager automatically decides under-the-hood what scenes it belongs to. The scene is deduced based on the first operation in an action, using the object from the operation. The rules are as follows:

- If the object is a Node, use the currently edited scene;

- If the object is a built-in resource, use the scene from its path;

- If the object is external resource or anything else, use global history.

This guessing can sometimes yield false results, so you can provide a custom context object when creating an action.

EditorUndoRedoManager is intended to be used by Godot editor plugins. You can obtain it using GetUndoRedo(). For non-editor uses or plugins that don't need to integrate with the editor's undo history, use UndoRedo instead.

The manager's API is mostly the same as in UndoRedo, so you can refer to its documentation for more examples. The main difference is that EditorUndoRedoManager uses object + method name for actions, instead of Callable.

EditorUndoRedoManager.MethodName: Cached StringNames for the methods contained in this class, for fast lookup.

EditorUndoRedoManager.PropertyName: Cached StringNames for the properties and fields contained in this class, for fast lookup.

EditorUndoRedoManager.SignalName: Cached StringNames for the signals contained in this class, for fast lookup.

EditorVcsInterface: Defines the API that the editor uses to extract information from the underlying VCS. The implementation of this API is included in VCS plugins, which are GDExtension plugins that inherit EditorVcsInterface and are attached (on demand) to the singleton instance of EditorVcsInterface. Instead of performing the task themselves, all the virtual functions listed below are calling the internally overridden functions in the VCS plugins to provide a plug-n-play experience. A custom VCS plugin is supposed to inherit from EditorVcsInterface and override each of these virtual functions.

EditorVcsInterface.MethodName: Cached StringNames for the methods contained in this class, for fast lookup.

EditorVcsInterface.PropertyName: Cached StringNames for the properties and fields contained in this class, for fast lookup.

EditorVcsInterface.SignalName: Cached StringNames for the signals contained in this class, for fast lookup.

FileSystemDock

This class is available only in EditorPlugins and can't be instantiated. You can access it using GetFileSystemDock().

While FileSystemDock doesn't expose any methods for file manipulation, it can listen for various file-related signals.

FileSystemDock.MethodName: Cached StringNames for the methods contained in this class, for fast lookup.

FileSystemDock.PropertyName: Cached StringNames for the properties and fields contained in this class, for fast lookup.

FileSystemDock.SignalName: Cached StringNames for the signals contained in this class, for fast lookup.

ResourceImporterBMFont

The BMFont format is a format created by the BMFont program. Many BMFont-compatible programs also exist, like BMGlyph.

Compared to ResourceImporterImageFont, ResourceImporterBMFont supports bitmap fonts with varying glyph widths/heights.

Enums

EditorFeatureProfile.Feature

EditorFileDialog.AccessEnum

EditorFileDialog.DisplayModeEnum

EditorFileDialog.FileModeEnum

EditorPlugin.AfterGuiInput

EditorPlugin.CustomControlContainer

EditorPlugin.DockSlot

EditorScenePostImportPlugin.InternalImportCategory

EditorUndoRedoManager.SpecialHistory

EditorVcsInterface.ChangeType

EditorVcsInterface.TreeArea

Delegates

EditorDebuggerSession.BreakedEventHandler: Represents the method that handles the Breaked event of a EditorDebuggerSession class.

EditorFileDialog.DirSelectedEventHandler: Represents the method that handles the DirSelected event of a EditorFileDialog class.

EditorFileDialog.FileSelectedEventHandler: Represents the method that handles the FileSelected event of a EditorFileDialog class.

EditorFileDialog.FilesSelectedEventHandler: Represents the method that handles the FilesSelected event of a EditorFileDialog class.

EditorFileSystem.ResourcesReimportedEventHandler: Represents the method that handles the ResourcesReimported event of a EditorFileSystem class.

EditorFileSystem.ResourcesReloadEventHandler: Represents the method that handles the ResourcesReload event of a EditorFileSystem class.

EditorFileSystem.SourcesChangedEventHandler: Represents the method that handles the SourcesChanged event of a EditorFileSystem class.

EditorInspector.ObjectIdSelectedEventHandler: Represents the method that handles the ObjectIdSelected event of a EditorInspector class.

EditorInspector.PropertyDeletedEventHandler: Represents the method that handles the PropertyDeleted event of a EditorInspector class.

EditorInspector.PropertyEditedEventHandler: Represents the method that handles the PropertyEdited event of a EditorInspector class.

EditorInspector.PropertyKeyedEventHandler: Represents the method that handles the PropertyKeyed event of a EditorInspector class.

EditorInspector.PropertySelectedEventHandler: Represents the method that handles the PropertySelected event of a EditorInspector class.

EditorInspector.PropertyToggledEventHandler: Represents the method that handles the PropertyToggled event of a EditorInspector class.

EditorInspector.ResourceSelectedEventHandler: Represents the method that handles the ResourceSelected event of a EditorInspector class.

EditorPlugin.MainScreenChangedEventHandler: Represents the method that handles the MainScreenChanged event of a EditorPlugin class.

EditorPlugin.ResourceSavedEventHandler: Represents the method that handles the ResourceSaved event of a EditorPlugin class.

EditorPlugin.SceneChangedEventHandler: Represents the method that handles the SceneChanged event of a EditorPlugin class.

EditorPlugin.SceneClosedEventHandler: Represents the method that handles the SceneClosed event of a EditorPlugin class.

EditorProperty.MultiplePropertiesChangedEventHandler: Represents the method that handles the MultiplePropertiesChanged event of a EditorProperty class.

EditorProperty.ObjectIdSelectedEventHandler: Represents the method that handles the ObjectIdSelected event of a EditorProperty class.

EditorProperty.PropertyCanRevertChangedEventHandler: Represents the method that handles the PropertyCanRevertChanged event of a EditorProperty class.

EditorProperty.PropertyChangedEventHandler: Represents the method that handles the PropertyChanged event of a EditorProperty class.

EditorProperty.PropertyCheckedEventHandler: Represents the method that handles the PropertyChecked event of a EditorProperty class.

EditorProperty.PropertyDeletedEventHandler: Represents the method that handles the PropertyDeleted event of a EditorProperty class.

EditorProperty.PropertyKeyedEventHandler: Represents the method that handles the PropertyKeyed event of a EditorProperty class.

EditorProperty.PropertyKeyedWithValueEventHandler: Represents the method that handles the PropertyKeyedWithValue event of a EditorProperty class.

EditorProperty.PropertyPinnedEventHandler: Represents the method that handles the PropertyPinned event of a EditorProperty class.

EditorProperty.ResourceSelectedEventHandler: Represents the method that handles the ResourceSelected event of a EditorProperty class.

EditorProperty.SelectedEventHandler: Represents the method that handles the Selected event of a EditorProperty class.

EditorResourcePicker.ResourceChangedEventHandler: Represents the method that handles the ResourceChanged event of a EditorResourcePicker class.

EditorResourcePicker.ResourceSelectedEventHandler: Represents the method that handles the ResourceSelected event of a EditorResourcePicker class.

EditorResourcePreview.PreviewInvalidatedEventHandler: Represents the method that handles the PreviewInvalidated event of a EditorResourcePreview class.

FileSystemDock.FileRemovedEventHandler: Represents the method that handles the FileRemoved event of a FileSystemDock class.

FileSystemDock.FilesMovedEventHandler: Represents the method that handles the FilesMoved event of a FileSystemDock class.

FileSystemDock.FolderMovedEventHandler: Represents the method that handles the FolderMoved event of a FileSystemDock class.

FileSystemDock.FolderRemovedEventHandler: Represents the method that handles the FolderRemoved event of a FileSystemDock class.

FileSystemDock.InheritEventHandler: Represents the method that handles the Inherit event of a FileSystemDock class.

FileSystemDock.InstantiateEventHandler: Represents the method that handles the Instantiate event of a FileSystemDock class.

FileSystemDock.ResourceRemovedEventHandler: Represents the method that handles the ResourceRemoved event of a FileSystemDock class.

ScriptCreateDialog.ScriptCreatedEventHandler: Represents the method that handles the ScriptCreated event of a ScriptCreateDialog class.

ScriptEditor.EditorScriptChangedEventHandler: Represents the method that handles the EditorScriptChanged event of a ScriptEditor class.

ScriptEditor.ScriptCloseEventHandler: Represents the method that handles the ScriptClose event of a ScriptEditor class.

ScriptEditorBase.GoToHelpEventHandler: Represents the method that handles the GoToHelp event of a ScriptEditorBase class.

ScriptEditorBase.GoToMethodEventHandler: Represents the method that handles the GoToMethod event of a ScriptEditorBase class.

ScriptEditorBase.ReplaceInFilesRequestedEventHandler: Represents the method that handles the ReplaceInFilesRequested event of a ScriptEditorBase class.

ScriptEditorBase.RequestHelpEventHandler: Represents the method that handles the RequestHelp event of a ScriptEditorBase class.

ScriptEditorBase.RequestOpenScriptAtLineEventHandler: Represents the method that handles the RequestOpenScriptAtLine event of a ScriptEditorBase class.

ScriptEditorBase.SearchInFilesRequestedEventHandler: Represents the method that handles the SearchInFilesRequested event of a ScriptEditorBase class.

Table of Contents

Namespace Godot

Classes

Enums

Delegates