Namespace Godot

AStar2D

An implementation of the A* algorithm, used to find the shortest path between two vertices on a connected graph in 2D space.

See AStar3D for a more thorough explanation on how to use this class. AStar2D is a wrapper for AStar3D that enforces 2D coordinates.

AStar2D.MethodName

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

AStar2D.PropertyName

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

AStar2D.SignalName

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

AStar3D

A* (A star) is a computer algorithm used in pathfinding and graph traversal, the process of plotting short paths among vertices (points), passing through a given set of edges (segments). It enjoys widespread use due to its performance and accuracy. Godot's A* implementation uses points in 3D space and Euclidean distances by default.

You must add points manually with AddPoint(long, Vector3, float) and create segments manually with ConnectPoints(long, long, bool). Once done, you can test if there is a path between two points with the ArePointsConnected(long, long, bool) function, get a path containing indices by GetIdPath(long, long), or one containing actual coordinates with GetPointPath(long, long).

It is also possible to use non-Euclidean distances. To do so, create a class that extends AStar3D and override methods _ComputeCost(long, long) and _EstimateCost(long, long). Both take two indices and return a length, as is shown in the following example.

public partial class MyAStar : AStar3D
  {
      public override float _ComputeCost(long fromId, long toId)
      {
          return Mathf.Abs((int)(fromId - toId));
      }
  public override float _EstimateCost(long fromId, long toId)
  {
      return Mathf.Min(0, Mathf.Abs((int)(fromId - toId)) - 1);
  }

}

_EstimateCost(long, long) should return a lower bound of the distance, i.e. _estimate_cost(u, v) <= _compute_cost(u, v). This serves as a hint to the algorithm because the custom _ComputeCost(long, long) might be computation-heavy. If this is not the case, make _EstimateCost(long, long) return the same value as _ComputeCost(long, long) to provide the algorithm with the most accurate information.

If the default _EstimateCost(long, long) and _ComputeCost(long, long) methods are used, or if the supplied _EstimateCost(long, long) method returns a lower bound of the cost, then the paths returned by A* will be the lowest-cost paths. Here, the cost of a path equals the sum of the _ComputeCost(long, long) results of all segments in the path multiplied by the weight_scales of the endpoints of the respective segments. If the default methods are used and the weight_scales of all points are set to 1.0, then this equals the sum of Euclidean distances of all segments in the path.

AStar3D.MethodName

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

AStar3D.PropertyName

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

AStar3D.SignalName

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

AStarGrid2D

AStarGrid2D is a variant of AStar2D that is specialized for partial 2D grids. It is simpler to use because it doesn't require you to manually create points and connect them together. This class also supports multiple types of heuristics, modes for diagonal movement, and a jumping mode to speed up calculations.

To use AStarGrid2D, you only need to set the Region of the grid, optionally set the CellSize, and then call the Update() method:

AStarGrid2D astarGrid = new AStarGrid2D();
  astarGrid.Region = new Rect2I(0, 0, 32, 32);
  astarGrid.CellSize = new Vector2I(16, 16);
  astarGrid.Update();
  GD.Print(astarGrid.GetIdPath(Vector2I.Zero, new Vector2I(3, 4))); // prints (0, 0), (1, 1), (2, 2), (3, 3), (3, 4)
  GD.Print(astarGrid.GetPointPath(Vector2I.Zero, new Vector2I(3, 4))); // prints (0, 0), (16, 16), (32, 32), (48, 48), (48, 64)

To remove a point from the pathfinding grid, it must be set as "solid" with SetPointSolid(Vector2I, bool).

AStarGrid2D.MethodName

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

AStarGrid2D.PropertyName

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

AStarGrid2D.SignalName

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

AcceptDialog

The default use of AcceptDialog is to allow it to only be accepted or closed, with the same result. However, the Confirmed and Canceled signals allow to make the two actions different, and the AddButton(string, bool, string) method allows to add custom buttons and actions.

AcceptDialog.MethodName

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

AcceptDialog.PropertyName

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

AcceptDialog.SignalName

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

AesContext

This class holds the context information required for encryption and decryption operations with AES (Advanced Encryption Standard). Both AES-ECB and AES-CBC modes are supported.

using Godot;
  using System.Diagnostics;
public partial class MyNode : Node
{
private AesContext _aes = new AesContext();
  public override void _Ready()
  {
      string key = "My secret key!!!"; // Key must be either 16 or 32 bytes.
      string data = "My secret text!!"; // Data size must be multiple of 16 bytes, apply padding if needed.
      // Encrypt ECB
      _aes.Start(AesContext.Mode.EcbEncrypt, key.ToUtf8Buffer());
      byte[] encrypted = _aes.Update(data.ToUtf8Buffer());
      _aes.Finish();
      // Decrypt ECB
      _aes.Start(AesContext.Mode.EcbDecrypt, key.ToUtf8Buffer());
      byte[] decrypted = _aes.Update(encrypted);
      _aes.Finish();
      // Check ECB
      Debug.Assert(decrypted == data.ToUtf8Buffer());

      string iv = "My secret iv!!!!"; // IV must be of exactly 16 bytes.
      // Encrypt CBC
      _aes.Start(AesContext.Mode.EcbEncrypt, key.ToUtf8Buffer(), iv.ToUtf8Buffer());
      encrypted = _aes.Update(data.ToUtf8Buffer());
      _aes.Finish();
      // Decrypt CBC
      _aes.Start(AesContext.Mode.EcbDecrypt, key.ToUtf8Buffer(), iv.ToUtf8Buffer());
      decrypted = _aes.Update(encrypted);
      _aes.Finish();
      // Check CBC
      Debug.Assert(decrypted == data.ToUtf8Buffer());
  }

}

AesContext.MethodName

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

AesContext.PropertyName

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

AesContext.SignalName

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

AnimatableBody2D

An animatable 2D physics body. It can't be moved by external forces or contacts, but can be moved manually by other means such as code, AnimationMixers (with CallbackModeProcess set to Physics), and RemoteTransform2D.

When AnimatableBody2D is moved, its linear and angular velocity are estimated and used to affect other physics bodies in its path. This makes it useful for moving platforms, doors, and other moving objects.

AnimatableBody2D.MethodName

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

AnimatableBody2D.PropertyName

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

AnimatableBody2D.SignalName

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

AnimatableBody3D

An animatable 3D physics body. It can't be moved by external forces or contacts, but can be moved manually by other means such as code, AnimationMixers (with CallbackModeProcess set to Physics), and RemoteTransform3D.

When AnimatableBody3D is moved, its linear and angular velocity are estimated and used to affect other physics bodies in its path. This makes it useful for moving platforms, doors, and other moving objects.

AnimatableBody3D.MethodName

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

AnimatableBody3D.PropertyName

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

AnimatableBody3D.SignalName

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

AnimatedSprite2D

AnimatedSprite2D is similar to the Sprite2D node, except it carries multiple textures as animation frames. Animations are created using a SpriteFrames resource, which allows you to import image files (or a folder containing said files) to provide the animation frames for the sprite. The SpriteFrames resource can be configured in the editor via the SpriteFrames bottom panel.

AnimatedSprite2D.MethodName

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

AnimatedSprite2D.PropertyName

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

AnimatedSprite2D.SignalName

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

AnimatedSprite3D

AnimatedSprite3D is similar to the Sprite3D node, except it carries multiple textures as animation SpriteFrames. Animations are created using a SpriteFrames resource, which allows you to import image files (or a folder containing said files) to provide the animation frames for the sprite. The SpriteFrames resource can be configured in the editor via the SpriteFrames bottom panel.

AnimatedSprite3D.MethodName

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

AnimatedSprite3D.PropertyName

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

AnimatedSprite3D.SignalName

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

AnimatedTexture

AnimatedTexture is a resource format for frame-based animations, where multiple textures can be chained automatically with a predefined delay for each frame. Unlike AnimationPlayer or AnimatedSprite2D, it isn't a Node, but has the advantage of being usable anywhere a Texture2D resource can be used, e.g. in a TileSet.

The playback of the animation is controlled by the SpeedScale property, as well as each frame's duration (see SetFrameDuration(int, float)). The animation loops, i.e. it will restart at frame 0 automatically after playing the last frame.

AnimatedTexture currently requires all frame textures to have the same size, otherwise the bigger ones will be cropped to match the smallest one.

Note: AnimatedTexture doesn't support using AtlasTextures. Each frame needs to be a separate Texture2D.

Warning: The current implementation is not efficient for the modern renderers.

Deprecated. This class is deprecated, and might be removed in a future release.

AnimatedTexture.MethodName

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

AnimatedTexture.PropertyName

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

AnimatedTexture.SignalName

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

Animation

This resource holds data that can be used to animate anything in the engine. Animations are divided into tracks and each track must be linked to a node. The state of that node can be changed through time, by adding timed keys (events) to the track.

// This creates an animation that makes the node "Enemy" move to the right by
  // 100 pixels in 2.0 seconds.
  var animation = new Animation();
  int trackIndex = animation.AddTrack(Animation.TrackType.Value);
  animation.TrackSetPath(trackIndex, "Enemy:position:x");
  animation.TrackInsertKey(trackIndex, 0.0f, 0);
  animation.TrackInsertKey(trackIndex, 2.0f, 100);
  animation.Length = 2.0f;

Animations are just data containers, and must be added to nodes such as an AnimationPlayer to be played back. Animation tracks have different types, each with its own set of dedicated methods. Check Animation.TrackType to see available types.

Note: For 3D position/rotation/scale, using the dedicated Position3D, Rotation3D and Scale3D track types instead of Value is recommended for performance reasons.

Animation.MethodName

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

Animation.PropertyName

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

Animation.SignalName

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

AnimationLibrary

An animation library stores a set of animations accessible through StringName keys, for use with AnimationPlayer nodes.

AnimationLibrary.MethodName

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

AnimationLibrary.PropertyName

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

AnimationLibrary.SignalName

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

AnimationMixer

Base class for AnimationPlayer and AnimationTree to manage animation lists. It also has general properties and methods for playback and blending.

After instantiating the playback information data within the extended class, the blending is processed by the AnimationMixer.

AnimationMixer.MethodName

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

AnimationMixer.PropertyName

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

AnimationMixer.SignalName

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

AnimationNode

Base resource for AnimationTree nodes. In general, it's not used directly, but you can create custom ones with custom blending formulas.

Inherit this when creating animation nodes mainly for use in AnimationNodeBlendTree, otherwise AnimationRootNode should be used instead.

AnimationNode.MethodName

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

AnimationNode.PropertyName

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

AnimationNode.SignalName

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

AnimationNodeAdd2

A resource to add to an AnimationNodeBlendTree. Blends two animations additively based on the amount value.

If the amount is greater than 1.0, the animation connected to "in" port is blended with the amplified animation connected to "add" port.

If the amount is less than 0.0, the animation connected to "in" port is blended with the inverted animation connected to "add" port.

AnimationNodeAdd2.MethodName

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

AnimationNodeAdd2.PropertyName

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

AnimationNodeAdd2.SignalName

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

AnimationNodeAdd3

A resource to add to an AnimationNodeBlendTree. Blends two animations out of three additively out of three based on the amount value.

This animation node has three inputs:

- The base animation to add to

- A "-add" animation to blend with when the blend amount is negative

- A "+add" animation to blend with when the blend amount is positive

If the absolute value of the amount is greater than 1.0, the animation connected to "in" port is blended with the amplified animation connected to "-add"/"+add" port.

AnimationNodeAdd3.MethodName

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

AnimationNodeAdd3.PropertyName

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

AnimationNodeAdd3.SignalName

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

AnimationNodeAnimation

A resource to add to an AnimationNodeBlendTree. Only has one output port using the Animation property. Used as an input for AnimationNodes that blend animations together.

AnimationNodeAnimation.MethodName

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

AnimationNodeAnimation.PropertyName

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

AnimationNodeAnimation.SignalName

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

AnimationNodeBlend2

A resource to add to an AnimationNodeBlendTree. Blends two animations linearly based on the amount value.

In general, the blend value should be in the [0.0, 1.0] range. Values outside of this range can blend amplified or inverted animations, however, AnimationNodeAdd2 works better for this purpose.

AnimationNodeBlend2.MethodName

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

AnimationNodeBlend2.PropertyName

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

AnimationNodeBlend2.SignalName

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

AnimationNodeBlend3

A resource to add to an AnimationNodeBlendTree. Blends two animations out of three linearly out of three based on the amount value.

This animation node has three inputs:

- The base animation to blend with

- A "-blend" animation to blend with when the blend amount is negative value

- A "+blend" animation to blend with when the blend amount is positive value

In general, the blend value should be in the [-1.0, 1.0] range. Values outside of this range can blend amplified animations, however, AnimationNodeAdd3 works better for this purpose.

AnimationNodeBlend3.MethodName

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

AnimationNodeBlend3.PropertyName

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

AnimationNodeBlend3.SignalName

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

AnimationNodeBlendSpace1D

A resource used by AnimationNodeBlendTree.

AnimationNodeBlendSpace1D represents a virtual axis on which any type of AnimationRootNodes can be added using AddBlendPoint(AnimationRootNode, float, int). Outputs the linear blend of the two AnimationRootNodes adjacent to the current value.

You can set the extents of the axis with MinSpace and MaxSpace.

AnimationNodeBlendSpace1D.MethodName

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

AnimationNodeBlendSpace1D.PropertyName

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

AnimationNodeBlendSpace1D.SignalName

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

AnimationNodeBlendSpace2D

A resource used by AnimationNodeBlendTree.

AnimationNodeBlendSpace1D represents a virtual 2D space on which AnimationRootNodes are placed. Outputs the linear blend of the three adjacent animations using a Vector2 weight. Adjacent in this context means the three AnimationRootNodes making up the triangle that contains the current value.

You can add vertices to the blend space with AddBlendPoint(AnimationRootNode, Vector2, int) and automatically triangulate it by setting AutoTriangles to true. Otherwise, use AddTriangle(int, int, int, int) and RemoveTriangle(int) to triangulate the blend space by hand.

AnimationNodeBlendSpace2D.MethodName

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

AnimationNodeBlendSpace2D.PropertyName

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

AnimationNodeBlendSpace2D.SignalName

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

AnimationNodeBlendTree

This animation node may contain a sub-tree of any other type animation nodes, such as AnimationNodeTransition, AnimationNodeBlend2, AnimationNodeBlend3, AnimationNodeOneShot, etc. This is one of the most commonly used animation node roots.

An AnimationNodeOutput node named output is created by default.

AnimationNodeBlendTree.MethodName

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

AnimationNodeBlendTree.PropertyName

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

AnimationNodeBlendTree.SignalName

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

AnimationNodeOneShot

A resource to add to an AnimationNodeBlendTree. This animation node will execute a sub-animation and return once it finishes. Blend times for fading in and out can be customized, as well as filters.

After setting the request and changing the animation playback, the one-shot node automatically clears the request on the next process frame by setting its request value to None.

// Play child animation connected to "shot" port.
  animationTree.Set("parameters/OneShot/request", (int)AnimationNodeOneShot.OneShotRequest.Fire);
// Abort child animation connected to "shot" port.
animationTree.Set("parameters/OneShot/request", (int)AnimationNodeOneShot.OneShotRequest.Abort);
// Abort child animation with fading out connected to "shot" port.
animationTree.Set("parameters/OneShot/request", (int)AnimationNodeOneShot.OneShotRequest.FadeOut);
// Get current state (read-only).
animationTree.Get("parameters/OneShot/active");
// Get current internal state (read-only).
animationTree.Get("parameters/OneShot/internal_active");

AnimationNodeOneShot.MethodName

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

AnimationNodeOneShot.PropertyName

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

AnimationNodeOneShot.SignalName

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

AnimationNodeOutput

A node created automatically in an AnimationNodeBlendTree that outputs the final animation.

AnimationNodeOutput.MethodName

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

AnimationNodeOutput.PropertyName

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

AnimationNodeOutput.SignalName

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

AnimationNodeStateMachine

Contains multiple AnimationRootNodes representing animation states, connected in a graph. State transitions can be configured to happen automatically or via code, using a shortest-path algorithm. Retrieve the AnimationNodeStateMachinePlayback object from the AnimationTree node to control it programmatically.

Example:

var stateMachine = GetNode<AnimationTree>("AnimationTree").Get("parameters/playback") as AnimationNodeStateMachinePlayback;
  stateMachine.Travel("some_state");

AnimationNodeStateMachine.MethodName

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

AnimationNodeStateMachine.PropertyName

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

AnimationNodeStateMachine.SignalName

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

AnimationNodeStateMachinePlayback

Allows control of AnimationTree state machines created with AnimationNodeStateMachine. Retrieve with $AnimationTree.get("parameters/playback").

Example:

var stateMachine = GetNode<AnimationTree>("AnimationTree").Get("parameters/playback").As<AnimationNodeStateMachinePlayback>();
  stateMachine.Travel("some_state");

AnimationNodeStateMachinePlayback.MethodName

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

AnimationNodeStateMachinePlayback.PropertyName

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

AnimationNodeStateMachinePlayback.SignalName

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

AnimationNodeStateMachineTransition

The path generated when using Travel(StringName, bool) is limited to the nodes connected by AnimationNodeStateMachineTransition.

You can set the timing and conditions of the transition in detail.

AnimationNodeStateMachineTransition.MethodName

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

AnimationNodeStateMachineTransition.PropertyName

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

AnimationNodeStateMachineTransition.SignalName

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

AnimationNodeSub2

A resource to add to an AnimationNodeBlendTree. Blends two animations subtractively based on the amount value.

This animation node is usually used for pre-calculation to cancel out any extra poses from the animation for the "add" animation source in AnimationNodeAdd2 or AnimationNodeAdd3.

In general, the blend value should be in the [0.0, 1.0] range, but values outside of this range can be used for amplified or inverted animations.

Note: This calculation is different from using a negative value in AnimationNodeAdd2, since the transformation matrices do not satisfy the commutative law. AnimationNodeSub2 multiplies the transformation matrix of the inverted animation from the left side, while negative AnimationNodeAdd2 multiplies it from the right side.

AnimationNodeSub2.MethodName

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

AnimationNodeSub2.PropertyName

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

AnimationNodeSub2.SignalName

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

AnimationNodeSync

An animation node used to combine, mix, or blend two or more animations together while keeping them synchronized within an AnimationTree.

AnimationNodeSync.MethodName

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

AnimationNodeSync.PropertyName

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

AnimationNodeSync.SignalName

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

AnimationNodeTimeScale

Allows to scale the speed of the animation (or reverse it) in any child AnimationNodes. Setting it to 0.0 will pause the animation.

AnimationNodeTimeScale.MethodName

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

AnimationNodeTimeScale.PropertyName

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

AnimationNodeTimeScale.SignalName

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

AnimationNodeTimeSeek

This animation node can be used to cause a seek command to happen to any sub-children of the animation graph. Use to play an Animation from the start or a certain playback position inside the AnimationNodeBlendTree.

After setting the time and changing the animation playback, the time seek node automatically goes into sleep mode on the next process frame by setting its seek_request value to -1.0.

// Play child animation from the start.
  animationTree.Set("parameters/TimeSeek/seek_request", 0.0);
// Play child animation from 12 second timestamp.
animationTree.Set("parameters/TimeSeek/seek_request", 12.0);

AnimationNodeTimeSeek.MethodName

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

AnimationNodeTimeSeek.PropertyName

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

AnimationNodeTimeSeek.SignalName

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

AnimationNodeTransition

Simple state machine for cases which don't require a more advanced AnimationNodeStateMachine. Animations can be connected to the inputs and transition times can be specified.

After setting the request and changing the animation playback, the transition node automatically clears the request on the next process frame by setting its transition_request value to empty.

Note: When using a cross-fade, current_state and current_index change to the next state immediately after the cross-fade begins.

// Play child animation connected to "state_2" port.
  animationTree.Set("parameters/Transition/transition_request", "state_2");
// Get current state name (read-only).
animationTree.Get("parameters/Transition/current_state");
// Get current state index (read-only).
animationTree.Get("parameters/Transition/current_index");

AnimationNodeTransition.MethodName

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

AnimationNodeTransition.PropertyName

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

AnimationNodeTransition.SignalName

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

AnimationPlayer

An animation player is used for general-purpose playback of animations. It contains a dictionary of AnimationLibrary resources and custom blend times between animation transitions.

Some methods and properties use a single key to reference an animation directly. These keys are formatted as the key for the library, followed by a forward slash, then the key for the animation within the library, for example "movement/run". If the library's key is an empty string (known as the default library), the forward slash is omitted, being the same key used by the library.

AnimationPlayer is better-suited than Tween for more complex animations, for example ones with non-trivial timings. It can also be used over Tween if the animation track editor is more convenient than doing it in code.

Updating the target properties of animations occurs at the process frame.

AnimationPlayer.MethodName

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

AnimationPlayer.PropertyName

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

AnimationPlayer.SignalName

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

AnimationRootNode

AnimationRootNode is a base class for AnimationNodes that hold a complete animation. A complete animation refers to the output of an AnimationNodeOutput in an AnimationNodeBlendTree or the output of another AnimationRootNode. Used for TreeRoot or in other AnimationRootNodes.

Examples of built-in root nodes include AnimationNodeBlendTree (allows blending nodes between each other using various modes), AnimationNodeStateMachine (allows to configure blending and transitions between nodes using a state machine pattern), AnimationNodeBlendSpace2D (allows linear blending between threeAnimationNodes), AnimationNodeBlendSpace1D (allows linear blending only between twoAnimationNodes).

AnimationRootNode.MethodName

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

AnimationRootNode.PropertyName

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

AnimationRootNode.SignalName

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

AnimationTree

A node used for advanced animation transitions in an AnimationPlayer.

Note: When linked with an AnimationPlayer, several properties and methods of the corresponding AnimationPlayer will not function as expected. Playback and transitions should be handled using only the AnimationTree and its constituent AnimationNode(s). The AnimationPlayer node should be used solely for adding, deleting, and editing animations.

AnimationTree.MethodName

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

AnimationTree.PropertyName

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

AnimationTree.SignalName

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

Area2D

Area2D is a region of 2D space defined by one or multiple CollisionShape2D or CollisionPolygon2D child nodes. It detects when other CollisionObject2Ds enter or exit it, and it also keeps track of which collision objects haven't exited it yet (i.e. which one are overlapping it).

This node can also locally alter or override physics parameters (gravity, damping) and route audio to custom audio buses.

Area2D.MethodName

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

Area2D.PropertyName

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

Area2D.SignalName

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

Area3D

Area3D is a region of 3D space defined by one or multiple CollisionShape3D or CollisionPolygon3D child nodes. It detects when other CollisionObject3Ds enter or exit it, and it also keeps track of which collision objects haven't exited it yet (i.e. which one are overlapping it).

This node can also locally alter or override physics parameters (gravity, damping) and route audio to custom audio buses.

Warning: Using a ConcavePolygonShape3D inside a CollisionShape3D child of this node (created e.g. by using the Create Trimesh Collision Sibling option in the Mesh menu that appears when selecting a MeshInstance3D node) may give unexpected results, since this collision shape is hollow. If this is not desired, it has to be split into multiple ConvexPolygonShape3Ds or primitive shapes like BoxShape3D, or in some cases it may be replaceable by a CollisionPolygon3D.

Area3D.MethodName

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

Area3D.PropertyName

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

Area3D.SignalName

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

ArrayMesh

The ArrayMesh is used to construct a Mesh by specifying the attributes as arrays.

The most basic example is the creation of a single triangle:

var vertices = new Vector3[]
  {
      new Vector3(0, 1, 0),
      new Vector3(1, 0, 0),
      new Vector3(0, 0, 1),
  };
// Initialize the ArrayMesh.
var arrMesh = new ArrayMesh();
var arrays = new Godot.Collections.Array();
arrays.Resize((int)Mesh.ArrayType.Max);
arrays[(int)Mesh.ArrayType.Vertex] = vertices;
// Create the Mesh.
arrMesh.AddSurfaceFromArrays(Mesh.PrimitiveType.Triangles, arrays);
var m = new MeshInstance3D();
m.Mesh = arrMesh;

The MeshInstance3D is ready to be added to the SceneTree to be shown.

See also ImmediateMesh, MeshDataTool and SurfaceTool for procedural geometry generation.

Note: Godot uses clockwise winding order for front faces of triangle primitive modes.

ArrayMesh.MethodName

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

ArrayMesh.PropertyName

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

ArrayMesh.SignalName

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

ArrayOccluder3D

ArrayOccluder3D stores an arbitrary 3D polygon shape that can be used by the engine's occlusion culling system. This is analogous to ArrayMesh, but for occluders.

See OccluderInstance3D's documentation for instructions on setting up occlusion culling.

ArrayOccluder3D.MethodName

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

ArrayOccluder3D.PropertyName

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

ArrayOccluder3D.SignalName

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

AspectRatioContainer

A container type that arranges its child controls in a way that preserves their proportions automatically when the container is resized. Useful when a container has a dynamic size and the child nodes must adjust their sizes accordingly without losing their aspect ratios.

AspectRatioContainer.MethodName

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

AspectRatioContainer.PropertyName

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

AspectRatioContainer.SignalName

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

AssemblyHasScriptsAttribute

Attribute that determines that the assembly contains Godot scripts and, optionally, the collection of types that implement scripts; otherwise, retrieving the types requires lookup.

AtlasTexture

Texture2D resource that draws only part of its Atlas texture, as defined by the Region. An additional Margin can also be set, which is useful for small adjustments.

Multiple AtlasTexture resources can be cropped from the same Atlas. Packing many smaller textures into a singular large texture helps to optimize video memory costs and render calls.

Note: AtlasTexture cannot be used in an AnimatedTexture, and may not tile properly in nodes such as TextureRect, when inside other AtlasTexture resources.

AtlasTexture.MethodName

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

AtlasTexture.PropertyName

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

AtlasTexture.SignalName

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

AudioBusLayout

Stores position, muting, solo, bypass, effects, effect position, volume, and the connections between buses. See AudioServer for usage.

AudioBusLayout.MethodName

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

AudioBusLayout.PropertyName

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

AudioBusLayout.SignalName

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

AudioEffect

Base resource for audio bus. Applies an audio effect on the bus that the resource is applied on.

AudioEffect.MethodName

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

AudioEffect.PropertyName

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

AudioEffect.SignalName

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

AudioEffectAmplify

Increases or decreases the volume being routed through the audio bus.

AudioEffectAmplify.MethodName

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

AudioEffectAmplify.PropertyName

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

AudioEffectAmplify.SignalName

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

AudioEffectBandLimitFilter

Limits the frequencies in a range around the CutoffHz and allows frequencies outside of this range to pass.

AudioEffectBandLimitFilter.MethodName

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

AudioEffectBandLimitFilter.PropertyName

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

AudioEffectBandLimitFilter.SignalName

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

AudioEffectBandPassFilter

Attenuates the frequencies inside of a range around the CutoffHz and cuts frequencies outside of this band.

AudioEffectBandPassFilter.MethodName

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

AudioEffectBandPassFilter.PropertyName

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

AudioEffectBandPassFilter.SignalName

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

AudioEffectCapture

AudioEffectCapture is an AudioEffect which copies all audio frames from the attached audio effect bus into its internal ring buffer.

Application code should consume these audio frames from this ring buffer using GetBuffer(int) and process it as needed, for example to capture data from an AudioStreamMicrophone, implement application-defined effects, or to transmit audio over the network. When capturing audio data from a microphone, the format of the samples will be stereo 32-bit floating point PCM.

Note: ProjectSettings.audio/driver/enable_input must be true for audio input to work. See also that setting's description for caveats related to permissions and operating system privacy settings.

AudioEffectCapture.MethodName

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

AudioEffectCapture.PropertyName

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

AudioEffectCapture.SignalName

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

AudioEffectChorus

Adds a chorus audio effect. The effect applies a filter with voices to duplicate the audio source and manipulate it through the filter.

AudioEffectChorus.MethodName

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

AudioEffectChorus.PropertyName

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

AudioEffectChorus.SignalName

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

AudioEffectCompressor

Dynamic range compressor reduces the level of the sound when the amplitude goes over a certain threshold in Decibels. One of the main uses of a compressor is to increase the dynamic range by clipping as little as possible (when sound goes over 0dB).

Compressor has many uses in the mix:

- In the Master bus to compress the whole output (although an AudioEffectLimiter is probably better).

- In voice channels to ensure they sound as balanced as possible.

- Sidechained. This can reduce the sound level sidechained with another audio bus for threshold detection. This technique is common in video game mixing to the level of music and SFX while voices are being heard.

- Accentuates transients by using a wider attack, making effects sound more punchy.

AudioEffectCompressor.MethodName

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

AudioEffectCompressor.PropertyName

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

AudioEffectCompressor.SignalName

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

AudioEffectDelay

Plays input signal back after a period of time. The delayed signal may be played back multiple times to create the sound of a repeating, decaying echo. Delay effects range from a subtle echo effect to a pronounced blending of previous sounds with new sounds.

AudioEffectDelay.MethodName

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

AudioEffectDelay.PropertyName

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

AudioEffectDelay.SignalName

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

AudioEffectDistortion

Different types are available: clip, tan, lo-fi (bit crushing), overdrive, or waveshape.

By distorting the waveform the frequency content changes, which will often make the sound "crunchy" or "abrasive". For games, it can simulate sound coming from some saturated device or speaker very efficiently.

AudioEffectDistortion.MethodName

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

AudioEffectDistortion.PropertyName

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

AudioEffectDistortion.SignalName

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

AudioEffectEQ

AudioEffectEQ gives you control over frequencies. Use it to compensate for existing deficiencies in audio. AudioEffectEQs are useful on the Master bus to completely master a mix and give it more character. They are also useful when a game is run on a mobile device, to adjust the mix to that kind of speakers (it can be added but disabled when headphones are plugged).

AudioEffectEQ.MethodName

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

AudioEffectEQ.PropertyName

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

AudioEffectEQ.SignalName

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

AudioEffectEQ10

Frequency bands:

Band 1: 31 Hz

Band 2: 62 Hz

Band 3: 125 Hz

Band 4: 250 Hz

Band 5: 500 Hz

Band 6: 1000 Hz

Band 7: 2000 Hz

Band 8: 4000 Hz

Band 9: 8000 Hz

Band 10: 16000 Hz

AudioEffectEQ10.MethodName

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

AudioEffectEQ10.PropertyName

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

AudioEffectEQ10.SignalName

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

AudioEffectEQ21

Frequency bands:

Band 1: 22 Hz

Band 2: 32 Hz

Band 3: 44 Hz

Band 4: 63 Hz

Band 5: 90 Hz

Band 6: 125 Hz

Band 7: 175 Hz

Band 8: 250 Hz

Band 9: 350 Hz

Band 10: 500 Hz

Band 11: 700 Hz

Band 12: 1000 Hz

Band 13: 1400 Hz

Band 14: 2000 Hz

Band 15: 2800 Hz

Band 16: 4000 Hz

Band 17: 5600 Hz

Band 18: 8000 Hz

Band 19: 11000 Hz

Band 20: 16000 Hz

Band 21: 22000 Hz

AudioEffectEQ21.MethodName

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

AudioEffectEQ21.PropertyName

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

AudioEffectEQ21.SignalName

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

AudioEffectEQ6

Frequency bands:

Band 1: 32 Hz

Band 2: 100 Hz

Band 3: 320 Hz

Band 4: 1000 Hz

Band 5: 3200 Hz

Band 6: 10000 Hz

AudioEffectEQ6.MethodName

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

AudioEffectEQ6.PropertyName

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

AudioEffectEQ6.SignalName

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

AudioEffectFilter

Allows frequencies other than the CutoffHz to pass.

AudioEffectFilter.MethodName

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

AudioEffectFilter.PropertyName

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

AudioEffectFilter.SignalName

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

AudioEffectHighPassFilter

Cuts frequencies lower than the CutoffHz and allows higher frequencies to pass.

AudioEffectHighPassFilter.MethodName

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

AudioEffectHighPassFilter.PropertyName

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

AudioEffectHighPassFilter.SignalName

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

AudioEffectHighShelfFilter

Reduces all frequencies above the CutoffHz.

AudioEffectHighShelfFilter.MethodName

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

AudioEffectHighShelfFilter.PropertyName

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

AudioEffectHighShelfFilter.SignalName

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

AudioEffectInstance

AudioEffectInstance.MethodName

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

AudioEffectInstance.PropertyName

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

AudioEffectInstance.SignalName

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

AudioEffectLimiter

A limiter is similar to a compressor, but it's less flexible and designed to disallow sound going over a given dB threshold. Adding one in the Master bus is always recommended to reduce the effects of clipping.

Soft clipping starts to reduce the peaks a little below the threshold level and progressively increases its effect as the input level increases such that the threshold is never exceeded.

AudioEffectLimiter.MethodName

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

AudioEffectLimiter.PropertyName

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

AudioEffectLimiter.SignalName

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

AudioEffectLowPassFilter

Cuts frequencies higher than the CutoffHz and allows lower frequencies to pass.

AudioEffectLowPassFilter.MethodName

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

AudioEffectLowPassFilter.PropertyName

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

AudioEffectLowPassFilter.SignalName

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

AudioEffectLowShelfFilter

Reduces all frequencies below the CutoffHz.

AudioEffectLowShelfFilter.MethodName

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

AudioEffectLowShelfFilter.PropertyName

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

AudioEffectLowShelfFilter.SignalName

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

AudioEffectNotchFilter

Attenuates frequencies in a narrow band around the CutoffHz and cuts frequencies outside of this range.

AudioEffectNotchFilter.MethodName

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

AudioEffectNotchFilter.PropertyName

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

AudioEffectNotchFilter.SignalName

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

AudioEffectPanner

Determines how much of an audio signal is sent to the left and right buses.

AudioEffectPanner.MethodName

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

AudioEffectPanner.PropertyName

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

AudioEffectPanner.SignalName

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

AudioEffectPhaser

Combines phase-shifted signals with the original signal. The movement of the phase-shifted signals is controlled using a low-frequency oscillator.

AudioEffectPhaser.MethodName

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

AudioEffectPhaser.PropertyName

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

AudioEffectPhaser.SignalName

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

AudioEffectPitchShift

Allows modulation of pitch independently of tempo. All frequencies can be increased/decreased with minimal effect on transients.

AudioEffectPitchShift.MethodName

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

AudioEffectPitchShift.PropertyName

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

AudioEffectPitchShift.SignalName

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

AudioEffectRecord

Allows the user to record the sound from an audio bus. This can include all audio output by Godot when used on the "Master" audio bus.

Can be used (with an AudioStreamMicrophone) to record from a microphone.

It sets and gets the format in which the audio file will be recorded (8-bit, 16-bit, or compressed). It checks whether or not the recording is active, and if it is, records the sound. It then returns the recorded sample.

AudioEffectRecord.MethodName

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

AudioEffectRecord.PropertyName

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

AudioEffectRecord.SignalName

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

AudioEffectReverb

Simulates the sound of acoustic environments such as rooms, concert halls, caverns, or an open spaces.

AudioEffectReverb.MethodName

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

AudioEffectReverb.PropertyName

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

AudioEffectReverb.SignalName

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

AudioEffectSpectrumAnalyzer

This audio effect does not affect sound output, but can be used for real-time audio visualizations.

See also AudioStreamGenerator for procedurally generating sounds.

AudioEffectSpectrumAnalyzer.MethodName

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

AudioEffectSpectrumAnalyzer.PropertyName

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

AudioEffectSpectrumAnalyzer.SignalName

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

AudioEffectSpectrumAnalyzerInstance

AudioEffectSpectrumAnalyzerInstance.MethodName

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

AudioEffectSpectrumAnalyzerInstance.PropertyName

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

AudioEffectSpectrumAnalyzerInstance.SignalName

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

AudioEffectStereoEnhance

An audio effect that can be used to adjust the intensity of stereo panning.

AudioEffectStereoEnhance.MethodName

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

AudioEffectStereoEnhance.PropertyName

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

AudioEffectStereoEnhance.SignalName

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

AudioListener2D

Once added to the scene tree and enabled using MakeCurrent(), this node will override the location sounds are heard from. Only one AudioListener2D can be current. Using MakeCurrent() will disable the previous AudioListener2D.

If there is no active AudioListener2D in the current Viewport, center of the screen will be used as a hearing point for the audio. AudioListener2D needs to be inside SceneTree to function.

AudioListener2D.MethodName

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

AudioListener2D.PropertyName

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

AudioListener2D.SignalName

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

AudioListener3D

Once added to the scene tree and enabled using MakeCurrent(), this node will override the location sounds are heard from. This can be used to listen from a location different from the Camera3D.

AudioListener3D.MethodName

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

AudioListener3D.PropertyName

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

AudioListener3D.SignalName

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

AudioServer

AudioServer is a low-level server interface for audio access. It is in charge of creating sample data (playable audio) as well as its playback via a voice interface.

AudioServer.MethodName

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

AudioServer.PropertyName

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

AudioServer.SignalName

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

AudioServerInstance

AudioServer is a low-level server interface for audio access. It is in charge of creating sample data (playable audio) as well as its playback via a voice interface.

AudioServerInstance.MethodName

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

AudioServerInstance.PropertyName

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

AudioServerInstance.SignalName

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

AudioStream

Base class for audio streams. Audio streams are used for sound effects and music playback, and support WAV (via AudioStreamWav) and Ogg (via AudioStreamOggVorbis) file formats.

AudioStream.MethodName

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

AudioStream.PropertyName

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

AudioStream.SignalName

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

AudioStreamGenerator

AudioStreamGenerator is a type of audio stream that does not play back sounds on its own; instead, it expects a script to generate audio data for it. See also AudioStreamGeneratorPlayback.

Here's a sample on how to use it to generate a sine wave:

[Export] public AudioStreamPlayer Player { get; set; }
private AudioStreamGeneratorPlayback _playback; // Will hold the AudioStreamGeneratorPlayback.
private float _sampleHz;
private float _pulseHz = 440.0f; // The frequency of the sound wave.
public override void _Ready()
{
if (Player.Stream is AudioStreamGenerator generator) // Type as a generator to access MixRate.
{
_sampleHz = generator.MixRate;
Player.Play();
_playback = (AudioStreamGeneratorPlayback)Player.GetStreamPlayback();
FillBuffer();
}
}
public void FillBuffer()
{
double phase = 0.0;
float increment = _pulseHz / _sampleHz;
int framesAvailable = _playback.GetFramesAvailable();
  for (int i = 0; i < framesAvailable; i++)
  {
      _playback.PushFrame(Vector2.One * (float)Mathf.Sin(phase * Mathf.Tau));
      phase = Mathf.PosMod(phase + increment, 1.0);
  }

}

In the example above, the "AudioStreamPlayer" node must use an AudioStreamGenerator as its stream. The fill_buffer function provides audio data for approximating a sine wave.

See also AudioEffectSpectrumAnalyzer for performing real-time audio spectrum analysis.

Note: Due to performance constraints, this class is best used from C# or from a compiled language via GDExtension. If you still want to use this class from GDScript, consider using a lower MixRate such as 11,025 Hz or 22,050 Hz.

AudioStreamGenerator.MethodName

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

AudioStreamGenerator.PropertyName

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

AudioStreamGenerator.SignalName

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

AudioStreamGeneratorPlayback

This class is meant to be used with AudioStreamGenerator to play back the generated audio in real-time.

AudioStreamGeneratorPlayback.MethodName

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

AudioStreamGeneratorPlayback.PropertyName

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

AudioStreamGeneratorPlayback.SignalName

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

AudioStreamMP3

MP3 audio stream driver. See Data if you want to load an MP3 file at run-time.

AudioStreamMP3.MethodName

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

AudioStreamMP3.PropertyName

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

AudioStreamMP3.SignalName

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

AudioStreamMicrophone

When used directly in an AudioStreamPlayer node, AudioStreamMicrophone plays back microphone input in real-time. This can be used in conjunction with AudioEffectCapture to process the data or save it.

Note: ProjectSettings.audio/driver/enable_input must be true for audio input to work. See also that setting's description for caveats related to permissions and operating system privacy settings.

AudioStreamMicrophone.MethodName

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

AudioStreamMicrophone.PropertyName

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

AudioStreamMicrophone.SignalName

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

AudioStreamOggVorbis

The AudioStreamOggVorbis class is a specialized AudioStream for handling Ogg Vorbis file formats. It offers functionality for loading and playing back Ogg Vorbis files, as well as managing looping and other playback properties. This class is part of the audio stream system, which also supports WAV files through the AudioStreamWav class.

AudioStreamOggVorbis.MethodName

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

AudioStreamOggVorbis.PropertyName

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

AudioStreamOggVorbis.SignalName

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

AudioStreamPlayback

Can play, loop, pause a scroll through audio. See AudioStream and AudioStreamOggVorbis for usage.

AudioStreamPlayback.MethodName

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

AudioStreamPlayback.PropertyName

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

AudioStreamPlayback.SignalName

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

AudioStreamPlaybackOggVorbis

AudioStreamPlaybackOggVorbis.MethodName

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

AudioStreamPlaybackOggVorbis.PropertyName

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

AudioStreamPlaybackOggVorbis.SignalName

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

AudioStreamPlaybackPolyphonic

Playback instance for AudioStreamPolyphonic. After setting the stream property of AudioStreamPlayer, AudioStreamPlayer2D, or AudioStreamPlayer3D, the playback instance can be obtained by calling GetStreamPlayback(), GetStreamPlayback() or GetStreamPlayback() methods.

AudioStreamPlaybackPolyphonic.MethodName

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

AudioStreamPlaybackPolyphonic.PropertyName

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

AudioStreamPlaybackPolyphonic.SignalName

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

AudioStreamPlaybackResampled

AudioStreamPlaybackResampled.MethodName

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

AudioStreamPlaybackResampled.PropertyName

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

AudioStreamPlaybackResampled.SignalName

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

AudioStreamPlayer

Plays an audio stream non-positionally.

To play audio positionally, use AudioStreamPlayer2D or AudioStreamPlayer3D instead of AudioStreamPlayer.

AudioStreamPlayer.MethodName

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

AudioStreamPlayer.PropertyName

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

AudioStreamPlayer.SignalName

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

AudioStreamPlayer2D

Plays audio that is attenuated with distance to the listener.

By default, audio is heard from the screen center. This can be changed by adding an AudioListener2D node to the scene and enabling it by calling MakeCurrent() on it.

See also AudioStreamPlayer to play a sound non-positionally.

Note: Hiding an AudioStreamPlayer2D node does not disable its audio output. To temporarily disable an AudioStreamPlayer2D's audio output, set VolumeDb to a very low value like -100 (which isn't audible to human hearing).

AudioStreamPlayer2D.MethodName

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

AudioStreamPlayer2D.PropertyName

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

AudioStreamPlayer2D.SignalName

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

AudioStreamPlayer3D

Plays audio with positional sound effects, based on the relative position of the audio listener. Positional effects include distance attenuation, directionality, and the Doppler effect. For greater realism, a low-pass filter is applied to distant sounds. This can be disabled by setting AttenuationFilterCutoffHz to 20500.

By default, audio is heard from the camera position. This can be changed by adding an AudioListener3D node to the scene and enabling it by calling MakeCurrent() on it.

See also AudioStreamPlayer to play a sound non-positionally.

Note: Hiding an AudioStreamPlayer3D node does not disable its audio output. To temporarily disable an AudioStreamPlayer3D's audio output, set VolumeDb to a very low value like -100 (which isn't audible to human hearing).

AudioStreamPlayer3D.MethodName

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

AudioStreamPlayer3D.PropertyName

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

AudioStreamPlayer3D.SignalName

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

AudioStreamPolyphonic

AudioStream that lets the user play custom streams at any time from code, simultaneously using a single player.

Playback control is done via the AudioStreamPlaybackPolyphonic instance set inside the player, which can be obtained via GetStreamPlayback(), GetStreamPlayback() or GetStreamPlayback() methods. Obtaining the playback instance is only valid after the stream property is set as an AudioStreamPolyphonic in those players.

AudioStreamPolyphonic.MethodName

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

AudioStreamPolyphonic.PropertyName

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

AudioStreamPolyphonic.SignalName

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

AudioStreamRandomizer

Picks a random AudioStream from the pool, depending on the playback mode, and applies random pitch shifting and volume shifting during playback.

AudioStreamRandomizer.MethodName

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

AudioStreamRandomizer.PropertyName

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

AudioStreamRandomizer.SignalName

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

AudioStreamWav

AudioStreamWAV stores sound samples loaded from WAV files. To play the stored sound, use an AudioStreamPlayer (for non-positional audio) or AudioStreamPlayer2D/AudioStreamPlayer3D (for positional audio). The sound can be looped.

This class can also be used to store dynamically-generated PCM audio data. See also AudioStreamGenerator for procedural audio generation.

AudioStreamWav.MethodName

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

AudioStreamWav.PropertyName

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

AudioStreamWav.SignalName

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

BackBufferCopy

Node for back-buffering the currently-displayed screen. The region defined in the BackBufferCopy node is buffered with the content of the screen it covers, or the entire screen according to the CopyMode. It can be accessed in shader scripts using the screen texture (i.e. a uniform sampler with hint_screen_texture).

Note: Since this node inherits from Node2D (and not Control), anchors and margins won't apply to child Control-derived nodes. This can be problematic when resizing the window. To avoid this, add Control-derived nodes as siblings to the BackBufferCopy node instead of adding them as children.

BackBufferCopy.MethodName

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

BackBufferCopy.PropertyName

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

BackBufferCopy.SignalName

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

BaseButton

BaseButton is an abstract base class for GUI buttons. It doesn't display anything by itself.

BaseButton.MethodName

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

BaseButton.PropertyName

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

BaseButton.SignalName

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

BaseMaterial3D

This class serves as a default material with a wide variety of rendering features and properties without the need to write shader code. See the tutorial below for details.

BaseMaterial3D.MethodName

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

BaseMaterial3D.PropertyName

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

BaseMaterial3D.SignalName

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

Bitmap

A two-dimensional array of boolean values, can be used to efficiently store a binary matrix (every matrix element takes only one bit) and query the values using natural cartesian coordinates.

Bitmap.MethodName

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

Bitmap.PropertyName

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

Bitmap.SignalName

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

Bone2D

A hierarchy of Bone2Ds can be bound to a Skeleton2D to control and animate other Node2D nodes.

You can use Bone2D and Skeleton2D nodes to animate 2D meshes created with the Polygon2D UV editor.

Each bone has a Rest transform that you can reset to with ApplyRest(). These rest poses are relative to the bone's parent.

If in the editor, you can set the rest pose of an entire skeleton using a menu option, from the code, you need to iterate over the bones to set their individual rest poses.

Bone2D.MethodName

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

Bone2D.PropertyName

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

Bone2D.SignalName

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

BoneAttachment3D

This node selects a bone in a Skeleton3D and attaches to it. This means that the BoneAttachment3D node will either dynamically copy or override the 3D transform of the selected bone.

BoneAttachment3D.MethodName

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

BoneAttachment3D.PropertyName

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

BoneAttachment3D.SignalName

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

BoneMap

This class contains a dictionary that uses a list of bone names in SkeletonProfile as key names.

By assigning the actual Skeleton3D bone name as the key value, it maps the Skeleton3D to the SkeletonProfile.

BoneMap.MethodName

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

BoneMap.PropertyName

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

BoneMap.SignalName

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

BoxContainer

A container that arranges its child controls horizontally or vertically, rearranging them automatically when their minimum size changes.

BoxContainer.MethodName

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

BoxContainer.PropertyName

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

BoxContainer.SignalName

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

BoxMesh

Generate an axis-aligned box PrimitiveMesh.

The box's UV layout is arranged in a 3×2 layout that allows texturing each face individually. To apply the same texture on all faces, change the material's UV property to Vector3(3, 2, 1). This is equivalent to adding UV *= vec2(3.0, 2.0) in a vertex shader.

Note: When using a large textured BoxMesh (e.g. as a floor), you may stumble upon UV jittering issues depending on the camera angle. To solve this, increase SubdivideDepth, SubdivideHeight and SubdivideWidth until you no longer notice UV jittering.

BoxMesh.MethodName

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

BoxMesh.PropertyName

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

BoxMesh.SignalName

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

BoxOccluder3D

BoxOccluder3D stores a cuboid shape that can be used by the engine's occlusion culling system.

See OccluderInstance3D's documentation for instructions on setting up occlusion culling.

BoxOccluder3D.MethodName

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

BoxOccluder3D.PropertyName

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

BoxOccluder3D.SignalName

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

BoxShape3D

A 3D box shape, intended for use in physics. Usually used to provide a shape for a CollisionShape3D.

Performance: BoxShape3D is fast to check collisions against. It is faster than CapsuleShape3D and CylinderShape3D, but slower than SphereShape3D.

BoxShape3D.MethodName

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

BoxShape3D.PropertyName

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

BoxShape3D.SignalName

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

Button

Button is the standard themed button. It can contain text and an icon, and it will display them according to the current Theme.

Example of creating a button and assigning an action when pressed by code:

public override void _Ready()
  {
      var button = new Button();
      button.Text = "Click me";
      button.Pressed += ButtonPressed;
      AddChild(button);
  }
private void ButtonPressed()
{
GD.Print("Hello world!");
}

See also BaseButton which contains common properties and methods associated with this node.

Note: Buttons do not interpret touch input and therefore don't support multitouch, since mouse emulation can only press one button at a given time. Use TouchScreenButton for buttons that trigger gameplay movement or actions.

Button.MethodName

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

Button.PropertyName

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

Button.SignalName

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

ButtonGroup

A group of BaseButton-derived buttons. The buttons in a ButtonGroup are treated like radio buttons: No more than one button can be pressed at a time. Some types of buttons (such as CheckBox) may have a special appearance in this state.

Every member of a ButtonGroup should have ToggleMode set to true.

ButtonGroup.MethodName

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

ButtonGroup.PropertyName

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

ButtonGroup.SignalName

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

CSharpScript

This class represents a C# script. It is the C# equivalent of the GDScript class and is only available in Mono-enabled Godot builds.

See also CSharpScript.

GodotSharpInstance.MethodName

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

GodotSharpInstance.PropertyName

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

GodotSharpInstance.SignalName

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

GodotSynchronizationContext

GodotTaskScheduler

GodotTaskScheduler contains a linked list of tasks to perform as a queue. Methods within the class are used to control the queue and perform the contained tasks.

GodotThread

A unit of execution in a process. Can run methods on GodotObjects simultaneously. The use of synchronization via Mutex or Semaphore is advised if working with shared objects.

Warning:

To ensure proper cleanup without crashes or deadlocks, when a GodotThread's reference count reaches zero and it is therefore destroyed, the following conditions must be met:

- It must not have any Mutex objects locked.

- It must not be waiting on any Semaphore objects.

- WaitToFinish() should have been called on it.

GodotThread.MethodName

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

GodotThread.PropertyName

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

GodotThread.SignalName

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

GpuParticles2D

2D particle node used to create a variety of particle systems and effects. GpuParticles2D features an emitter that generates some number of particles at a given rate.

Use the ProcessMaterial property to add a ParticleProcessMaterial to configure particle appearance and behavior. Alternatively, you can add a ShaderMaterial which will be applied to all particles.

2D particles can optionally collide with LightOccluder2D, but they don't collide with PhysicsBody2D nodes.

GpuParticles2D.MethodName

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

GpuParticles2D.PropertyName

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

GpuParticles2D.SignalName

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

GpuParticles3D

3D particle node used to create a variety of particle systems and effects. GpuParticles3D features an emitter that generates some number of particles at a given rate.

Use ProcessMaterial to add a ParticleProcessMaterial to configure particle appearance and behavior. Alternatively, you can add a ShaderMaterial which will be applied to all particles.

GpuParticles3D.MethodName

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

GpuParticles3D.PropertyName

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

GpuParticles3D.SignalName

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

GpuParticlesAttractor3D

Particle attractors can be used to attract particles towards the attractor's origin, or to push them away from the attractor's origin.

Particle attractors work in real-time and can be moved, rotated and scaled during gameplay. Unlike collision shapes, non-uniform scaling of attractors is also supported.

Attractors can be temporarily disabled by hiding them, or by setting their Strength to 0.0.

Note: Particle attractors only affect GpuParticles3D, not CpuParticles3D.

GpuParticlesAttractor3D.MethodName

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

GpuParticlesAttractor3D.PropertyName

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

GpuParticlesAttractor3D.SignalName

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

GpuParticlesAttractorBox3D

A box-shaped attractor that influences particles from GpuParticles3D nodes. Can be used to attract particles towards its origin, or to push them away from its origin.

Particle attractors work in real-time and can be moved, rotated and scaled during gameplay. Unlike collision shapes, non-uniform scaling of attractors is also supported.

Note: Particle attractors only affect GpuParticles3D, not CpuParticles3D.

GpuParticlesAttractorBox3D.MethodName

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

GpuParticlesAttractorBox3D.PropertyName

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

GpuParticlesAttractorBox3D.SignalName

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

GpuParticlesAttractorSphere3D

A spheroid-shaped attractor that influences particles from GpuParticles3D nodes. Can be used to attract particles towards its origin, or to push them away from its origin.

Particle attractors work in real-time and can be moved, rotated and scaled during gameplay. Unlike collision shapes, non-uniform scaling of attractors is also supported.

Note: Particle attractors only affect GpuParticles3D, not CpuParticles3D.

GpuParticlesAttractorSphere3D.MethodName

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

GpuParticlesAttractorSphere3D.PropertyName

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

GpuParticlesAttractorSphere3D.SignalName

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

GpuParticlesAttractorVectorField3D

A box-shaped attractor with varying directions and strengths defined in it that influences particles from GpuParticles3D nodes.

Unlike GpuParticlesAttractorBox3D, GpuParticlesAttractorVectorField3D uses a Texture to affect attraction strength within the box. This can be used to create complex attraction scenarios where particles travel in different directions depending on their location. This can be useful for weather effects such as sandstorms.

Particle attractors work in real-time and can be moved, rotated and scaled during gameplay. Unlike collision shapes, non-uniform scaling of attractors is also supported.

Note: Particle attractors only affect GpuParticles3D, not CpuParticles3D.

GpuParticlesAttractorVectorField3D.MethodName

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

GpuParticlesAttractorVectorField3D.PropertyName

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

GpuParticlesAttractorVectorField3D.SignalName

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

GpuParticlesCollision3D

Particle collision shapes can be used to make particles stop or bounce against them.

Particle collision shapes work in real-time and can be moved, rotated and scaled during gameplay. Unlike attractors, non-uniform scaling of collision shapes is not supported.

Particle collision shapes can be temporarily disabled by hiding them.

Note: CollisionMode must be Rigid or HideOnContact on the GpuParticles3D's process material for collision to work.

Note: Particle collision only affects GpuParticles3D, not CpuParticles3D.

Note: Particles pushed by a collider that is being moved will not be interpolated, which can result in visible stuttering. This can be alleviated by setting FixedFps to 0 or a value that matches or exceeds the target framerate.

GpuParticlesCollision3D.MethodName

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

GpuParticlesCollision3D.PropertyName

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

GpuParticlesCollision3D.SignalName

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

GpuParticlesCollisionBox3D

A box-shaped 3D particle collision shape affecting GpuParticles3D nodes.

Particle collision shapes work in real-time and can be moved, rotated and scaled during gameplay. Unlike attractors, non-uniform scaling of collision shapes is not supported.

Note: CollisionMode must be Rigid or HideOnContact on the GpuParticles3D's process material for collision to work.

Note: Particle collision only affects GpuParticles3D, not CpuParticles3D.

GpuParticlesCollisionBox3D.MethodName

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

GpuParticlesCollisionBox3D.PropertyName

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

GpuParticlesCollisionBox3D.SignalName

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

GpuParticlesCollisionHeightField3D

A real-time heightmap-shaped 3D particle collision shape affecting GpuParticles3D nodes.

Heightmap shapes allow for efficiently representing collisions for convex and concave objects with a single "floor" (such as terrain). This is less flexible than GpuParticlesCollisionSdf3D, but it doesn't require a baking step.

GpuParticlesCollisionHeightField3D can also be regenerated in real-time when it is moved, when the camera moves, or even continuously. This makes GpuParticlesCollisionHeightField3D a good choice for weather effects such as rain and snow and games with highly dynamic geometry. However, this class is limited since heightmaps cannot represent overhangs (e.g. indoors or caves).

Note: CollisionMode must be true on the GpuParticles3D's process material for collision to work.

Note: Particle collision only affects GpuParticles3D, not CpuParticles3D.

GpuParticlesCollisionHeightField3D.MethodName

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

GpuParticlesCollisionHeightField3D.PropertyName

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

GpuParticlesCollisionHeightField3D.SignalName

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

GpuParticlesCollisionSdf3D

A baked signed distance field 3D particle collision shape affecting GpuParticles3D nodes.

Signed distance fields (SDF) allow for efficiently representing approximate collision shapes for convex and concave objects of any shape. This is more flexible than GpuParticlesCollisionHeightField3D, but it requires a baking step.

Baking: The signed distance field texture can be baked by selecting the GpuParticlesCollisionSdf3D node in the editor, then clicking Bake SDF at the top of the 3D viewport. Any visibleMeshInstance3Ds within the Size will be taken into account for baking, regardless of their GIMode.

Note: Baking a GpuParticlesCollisionSdf3D's Texture is only possible within the editor, as there is no bake method exposed for use in exported projects. However, it's still possible to load pre-baked Texture3Ds into its Texture property in an exported project.

Note: CollisionMode must be Rigid or HideOnContact on the GpuParticles3D's process material for collision to work.

Note: Particle collision only affects GpuParticles3D, not CpuParticles3D.

GpuParticlesCollisionSdf3D.MethodName

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

GpuParticlesCollisionSdf3D.PropertyName

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

GpuParticlesCollisionSdf3D.SignalName

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

GpuParticlesCollisionSphere3D

A sphere-shaped 3D particle collision shape affecting GpuParticles3D nodes.

Particle collision shapes work in real-time and can be moved, rotated and scaled during gameplay. Unlike attractors, non-uniform scaling of collision shapes is not supported.

Note: CollisionMode must be Rigid or HideOnContact on the GpuParticles3D's process material for collision to work.

Note: Particle collision only affects GpuParticles3D, not CpuParticles3D.

GpuParticlesCollisionSphere3D.MethodName

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

GpuParticlesCollisionSphere3D.PropertyName

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

GpuParticlesCollisionSphere3D.SignalName

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

Gradient

This resource describes a color transition by defining a set of colored points and how to interpolate between them.

See also Curve which supports more complex easing methods, but does not support colors.

Gradient.MethodName

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

Gradient.PropertyName

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

Gradient.SignalName

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

GradientTexture1D

A 1D texture that obtains colors from a Gradient to fill the texture data. The texture is filled by sampling the gradient for each pixel. Therefore, the texture does not necessarily represent an exact copy of the gradient, as it may miss some colors if there are not enough pixels. See also GradientTexture2D, CurveTexture and CurveXyzTexture.

GradientTexture1D.MethodName

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

GradientTexture1D.PropertyName

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

GradientTexture1D.SignalName

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

GradientTexture2D

A 2D texture that obtains colors from a Gradient to fill the texture data. This texture is able to transform a color transition into different patterns such as a linear or a radial gradient. The gradient is sampled individually for each pixel so it does not necessarily represent an exact copy of the gradient(see Width and Height). See also GradientTexture1D, CurveTexture and CurveXyzTexture.

GradientTexture2D.MethodName

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

GradientTexture2D.PropertyName

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

GradientTexture2D.SignalName

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

GraphEdit

GraphEdit provides tools for creation, manipulation, and display of various graphs. Its main purpose in the engine is to power the visual programming systems, such as visual shaders, but it is also available for use in user projects.

GraphEdit by itself is only an empty container, representing an infinite grid where GraphNodes can be placed. Each GraphNode represents a node in the graph, a single unit of data in the connected scheme. GraphEdit, in turn, helps to control various interactions with nodes and between nodes. When the user attempts to connect, disconnect, or delete a GraphNode, a signal is emitted in the GraphEdit, but no action is taken by default. It is the responsibility of the programmer utilizing this control to implement the necessary logic to determine how each request should be handled.

Performance: It is greatly advised to enable low-processor usage mode (see LowProcessorUsageMode) when using GraphEdits.

GraphEdit.MethodName

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

GraphEdit.PropertyName

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

GraphEdit.SignalName

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

GraphElement

GraphElement allows to create custom elements for a GraphEdit graph. By default such elements can be selected, resized, and repositioned, but they cannot be connected. For a graph element that allows for connections see GraphNode.

GraphElement.MethodName

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

GraphElement.PropertyName

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

GraphElement.SignalName

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

GraphNode

GraphNode allows to create nodes for a GraphEdit graph with customizable content based on its child controls. GraphNode is derived from Container and it is responsible for placing its children on screen. This works similar to VBoxContainer. Children, in turn, provide GraphNode with so-called slots, each of which can have a connection port on either side.

Each GraphNode slot is defined by its index and can provide the node with up to two ports: one on the left, and one on the right. By convention the left port is also referred to as the input port and the right port is referred to as the output port. Each port can be enabled and configured individually, using different type and color. The type is an arbitrary value that you can define using your own considerations. The parent GraphEdit will receive this information on each connect and disconnect request.

Slots can be configured in the Inspector dock once you add at least one child Control. The properties are grouped by each slot's index in the "Slot" section.

Note: While GraphNode is set up using slots and slot indices, connections are made between the ports which are enabled. Because of that GraphEdit uses the port's index and not the slot's index. You can use GetInputPortSlot(int) and GetOutputPortSlot(int) to get the slot index from the port index.

GraphNode.MethodName

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

GraphNode.PropertyName

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

GraphNode.SignalName

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

GridContainer

GridContainer arranges its child controls in a grid layout. The number of columns is specified by the Columns property, whereas the number of rows depends on how many are needed for the child controls. The number of rows and columns is preserved for every size of the container.

Note: GridContainer only works with child nodes inheriting from Control. It won't rearrange child nodes inheriting from Node2D.

GridContainer.MethodName

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

GridContainer.PropertyName

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

GridContainer.SignalName

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

GridMap

GridMap lets you place meshes on a grid interactively. It works both from the editor and from scripts, which can help you create in-game level editors.

GridMaps use a MeshLibrary which contains a list of tiles. Each tile is a mesh with materials plus optional collision and navigation shapes.

A GridMap contains a collection of cells. Each grid cell refers to a tile in the MeshLibrary. All cells in the map have the same dimensions.

Internally, a GridMap is split into a sparse collection of octants for efficient rendering and physics processing. Every octant has the same dimensions and can contain several cells.

Note: GridMap doesn't extend VisualInstance3D and therefore can't be hidden or cull masked based on Layers. If you make a light not affect the first layer, the whole GridMap won't be lit by the light in question.

GridMap.MethodName

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

GridMap.PropertyName

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

GridMap.SignalName

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

GrooveJoint2D

A physics joint that restricts the movement of two 2D physics bodies to a fixed axis. For example, a StaticBody2D representing a piston base can be attached to a RigidBody2D representing the piston head, moving up and down.

GrooveJoint2D.MethodName

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

GrooveJoint2D.PropertyName

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

GrooveJoint2D.SignalName

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

HBoxContainer

A variant of BoxContainer that can only arrange its child controls horizontally. Child controls are rearranged automatically when their minimum size changes.

HBoxContainer.MethodName

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

HBoxContainer.PropertyName

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

HBoxContainer.SignalName

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

HFlowContainer

A variant of FlowContainer that can only arrange its child controls horizontally, wrapping them around at the borders. This is similar to how text in a book wraps around when no more words can fit on a line.

HFlowContainer.MethodName

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

HFlowContainer.PropertyName

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

HFlowContainer.SignalName

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

HScrollBar

A horizontal scrollbar, typically used to navigate through content that extends beyond the visible width of a control. It is a Range-based control and goes from left (min) to right (max).

HScrollBar.MethodName

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

HScrollBar.PropertyName

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

HScrollBar.SignalName

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

HSeparator

A horizontal separator used for separating other controls that are arranged vertically. HSeparator is purely visual and normally drawn as a StyleBoxLine.

HSeparator.MethodName

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

HSeparator.PropertyName

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

HSeparator.SignalName

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

HSlider

A horizontal slider, used to adjust a value by moving a grabber along a horizontal axis. It is a Range-based control and goes from left (min) to right (max).

HSlider.MethodName

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

HSlider.PropertyName

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

HSlider.SignalName

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

HSplitContainer

A container that accepts only two child controls, then arranges them horizontally and creates a divisor between them. The divisor can be dragged around to change the size relation between the child controls.

HSplitContainer.MethodName

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

HSplitContainer.PropertyName

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

HSplitContainer.SignalName

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

HashingContext

The HashingContext class provides an interface for computing cryptographic hashes over multiple iterations. Useful for computing hashes of big files (so you don't have to load them all in memory), network streams, and data streams in general (so you don't have to hold buffers).

The HashingContext.HashType enum shows the supported hashing algorithms.

public const int ChunkSize = 1024;
public void HashFile(string path)
{
// Check that file exists.
if (!FileAccess.FileExists(path))
{
return;
}
// Start a SHA-256 context.
var ctx = new HashingContext();
ctx.Start(HashingContext.HashType.Sha256);
// Open the file to hash.
using var file = FileAccess.Open(path, FileAccess.ModeFlags.Read);
// Update the context after reading each chunk.
while (!file.EofReached())
{
ctx.Update(file.GetBuffer(ChunkSize));
}
// Get the computed hash.
byte[] res = ctx.Finish();
// Print the result as hex string and array.
GD.PrintT(res.HexEncode(), (Variant)res);
}

HashingContext.MethodName

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

HashingContext.PropertyName

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

HashingContext.SignalName

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

HeightMapShape3D

A 3D heightmap shape, intended for use in physics. Usually used to provide a shape for a CollisionShape3D. This is useful for terrain, but it is limited as overhangs (such as caves) cannot be stored. Holes in a HeightMapShape3D are created by assigning very low values to points in the desired area.

Performance: HeightMapShape3D is faster to check collisions against than ConcavePolygonShape3D, but it is significantly slower than primitive shapes like BoxShape3D.

HeightMapShape3D.MethodName

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

HeightMapShape3D.PropertyName

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

HeightMapShape3D.SignalName

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

HingeJoint3D

A physics joint that restricts the rotation of a 3D physics body around an axis relative to another physics body. For example, Body A can be a StaticBody3D representing a door hinge that a RigidBody3D rotates around.

HingeJoint3D.MethodName

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

HingeJoint3D.PropertyName

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

HingeJoint3D.SignalName

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

HmacContext

The HMACContext class is useful for advanced HMAC use cases, such as streaming the message as it supports creating the message over time rather than providing it all at once.

using Godot;
  using System.Diagnostics;
public partial class MyNode : Node
{
private HmacContext _ctx = new HmacContext();
  public override void _Ready()
  {
      byte[] key = "supersecret".ToUtf8Buffer();
      Error err = _ctx.Start(HashingContext.HashType.Sha256, key);
      Debug.Assert(err == Error.Ok);
      byte[] msg1 = "this is ".ToUtf8Buffer();
      byte[] msg2 = "super duper secret".ToUtf8Buffer();
      err = _ctx.Update(msg1);
      Debug.Assert(err == Error.Ok);
      err = _ctx.Update(msg2);
      Debug.Assert(err == Error.Ok);
      byte[] hmac = _ctx.Finish();
      GD.Print(hmac.HexEncode());
  }

}

HmacContext.MethodName

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

HmacContext.PropertyName

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

HmacContext.SignalName

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

HttpClient

Hyper-text transfer protocol client (sometimes called "User Agent"). Used to make HTTP requests to download web content, upload files and other data or to communicate with various services, among other use cases.

See the HttpRequest node for a higher-level alternative.

Note: This client only needs to connect to a host once (see ConnectToHost(string, int, TlsOptions)) to send multiple requests. Because of this, methods that take URLs usually take just the part after the host instead of the full URL, as the client is already connected to a host. See Request(Method, string, string[], string) for a full example and to get started.

A HttpClient should be reused between multiple requests or to connect to different hosts instead of creating one client per request. Supports Transport Layer Security (TLS), including server certificate verification. HTTP status codes in the 2xx range indicate success, 3xx redirection (i.e. "try again, but over here"), 4xx something was wrong with the request, and 5xx something went wrong on the server's side.

For more information on HTTP, see MDN's documentation on HTTP (or read RFC 2616 to get it straight from the source).

Note: When exporting to Android, make sure to enable the INTERNET permission in the Android export preset before exporting the project or using one-click deploy. Otherwise, network communication of any kind will be blocked by Android.

Note: It's recommended to use transport encryption (TLS) and to avoid sending sensitive information (such as login credentials) in HTTP GET URL parameters. Consider using HTTP POST requests or HTTP headers for such information instead.

Note: When performing HTTP requests from a project exported to Web, keep in mind the remote server may not allow requests from foreign origins due to CORS. If you host the server in question, you should modify its backend to allow requests from foreign origins by adding the Access-Control-Allow-Origin: * HTTP header.

Note: TLS support is currently limited to TLS 1.0, TLS 1.1, and TLS 1.2. Attempting to connect to a TLS 1.3-only server will return an error.

Warning: TLS certificate revocation and certificate pinning are currently not supported. Revoked certificates are accepted as long as they are otherwise valid. If this is a concern, you may want to use automatically managed certificates with a short validity period.

HttpClient.MethodName

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

HttpClient.PropertyName

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

HttpClient.SignalName

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

HttpRequest

A node with the ability to send HTTP requests. Uses HttpClient internally.

Can be used to make HTTP requests, i.e. download or upload files or web content via HTTP.

Warning: See the notes and warnings on HttpClient for limitations, especially regarding TLS security.

Note: When exporting to Android, make sure to enable the INTERNET permission in the Android export preset before exporting the project or using one-click deploy. Otherwise, network communication of any kind will be blocked by Android.

Example of contacting a REST API and printing one of its returned fields:

public override void _Ready()
  {
      // Create an HTTP request node and connect its completion signal.
      var httpRequest = new HttpRequest();
      AddChild(httpRequest);
      httpRequest.RequestCompleted += HttpRequestCompleted;
  // Perform a GET request. The URL below returns JSON as of writing.
  Error error = httpRequest.Request("https://httpbin.org/get");
  if (error != Error.Ok)
  {
      GD.PushError("An error occurred in the HTTP request.");
  }

  // Perform a POST request. The URL below returns JSON as of writing.
  // Note: Don't make simultaneous requests using a single HTTPRequest node.
  // The snippet below is provided for reference only.
  string body = new Json().Stringify(new Godot.Collections.Dictionary
  {
      { "name", "Godette" }
  });
  error = httpRequest.Request("https://httpbin.org/post", null, HttpClient.Method.Post, body);
  if (error != Error.Ok)
  {
      GD.PushError("An error occurred in the HTTP request.");
  }

}
// Called when the HTTP request is completed.
private void HttpRequestCompleted(long result, long responseCode, string[] headers, byte[] body)
{
var json = new Json();
json.Parse(body.GetStringFromUtf8());
var response = json.GetData().AsGodotDictionary();
  // Will print the user agent string used by the HTTPRequest node (as recognized by httpbin.org).
  GD.Print((response["headers"].AsGodotDictionary())["User-Agent"]);

}

Example of loading and displaying an image using HTTPRequest:

public override void _Ready()
  {
      // Create an HTTP request node and connect its completion signal.
      var httpRequest = new HttpRequest();
      AddChild(httpRequest);
      httpRequest.RequestCompleted += HttpRequestCompleted;
  // Perform the HTTP request. The URL below returns a PNG image as of writing.
  Error error = httpRequest.Request("https://via.placeholder.com/512");
  if (error != Error.Ok)
  {
      GD.PushError("An error occurred in the HTTP request.");
  }

}
// Called when the HTTP request is completed.
private void HttpRequestCompleted(long result, long responseCode, string[] headers, byte[] body)
{
if (result != (long)HttpRequest.Result.Success)
{
GD.PushError("Image couldn't be downloaded. Try a different image.");
}
var image = new Image();
Error error = image.LoadPngFromBuffer(body);
if (error != Error.Ok)
{
GD.PushError("Couldn't load the image.");
}
  var texture = ImageTexture.CreateFromImage(image);

  // Display the image in a TextureRect node.
  var textureRect = new TextureRect();
  AddChild(textureRect);
  textureRect.Texture = texture;

}

Gzipped response bodies: HTTPRequest will automatically handle decompression of response bodies. A Accept-Encoding header will be automatically added to each of your requests, unless one is already specified. Any response with a Content-Encoding: gzip header will automatically be decompressed and delivered to you as uncompressed bytes.

HttpRequest.MethodName

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

HttpRequest.PropertyName

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

HttpRequest.SignalName

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

IP

IP contains support functions for the Internet Protocol (IP). TCP/IP support is in different classes (see StreamPeerTcp and TcpServer). IP provides DNS hostname resolution support, both blocking and threaded.

IP.MethodName

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

IP.PropertyName

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

IP.SignalName

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

IPInstance

IP contains support functions for the Internet Protocol (IP). TCP/IP support is in different classes (see StreamPeerTcp and TcpServer). IP provides DNS hostname resolution support, both blocking and threaded.

IPInstance.MethodName

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

IPInstance.PropertyName

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

IPInstance.SignalName

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

IconAttribute

Specifies a custom icon for representing this class in the Godot Editor.

Image

Native image datatype. Contains image data which can be converted to an ImageTexture and provides commonly used image processing methods. The maximum width and height for an Image are MaxWidth and MaxHeight.

An Image cannot be assigned to a texture property of an object directly (such as Texture), and has to be converted manually to an ImageTexture first.

Note: The maximum image size is 16384×16384 pixels due to graphics hardware limitations. Larger images may fail to import.

Image.MethodName

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

Image.PropertyName

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

Image.SignalName

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

ImageFormatLoader

The engine supports multiple image formats out of the box (PNG, SVG, JPEG, WebP to name a few), but you can choose to implement support for additional image formats by extending ImageFormatLoaderExtension.

ImageFormatLoader.MethodName

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

ImageFormatLoader.PropertyName

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

ImageFormatLoader.SignalName

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

ImageFormatLoaderExtension

The engine supports multiple image formats out of the box (PNG, SVG, JPEG, WebP to name a few), but you can choose to implement support for additional image formats by extending this class.

Be sure to respect the documented return types and values. You should create an instance of it, and call AddFormatLoader() to register that loader during the initialization phase.

ImageFormatLoaderExtension.MethodName

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

ImageFormatLoaderExtension.PropertyName

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

ImageFormatLoaderExtension.SignalName

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

ImageTexture

A Texture2D based on an Image. For an image to be displayed, an ImageTexture has to be created from it using the CreateFromImage(Image) method:

var image = Image.load_from_file("res://icon.svg")
  var texture = ImageTexture.create_from_image(image)
  $Sprite2D.texture = texture

This way, textures can be created at run-time by loading images both from within the editor and externally.

Warning: Prefer to load imported textures with @GDScript.load over loading them from within the filesystem dynamically with Load(string), as it may not work in exported projects:

var texture = load("res://icon.svg")
  $Sprite2D.texture = texture

This is because images have to be imported as a CompressedTexture2D first to be loaded with @GDScript.load. If you'd still like to load an image file just like any other Resource, import it as an Image resource instead, and then load it normally using the @GDScript.load method.

Note: The image can be retrieved from an imported texture using the GetImage() method, which returns a copy of the image:

var texture = load("res://icon.svg")
  var image: Image = texture.get_image()

An ImageTexture is not meant to be operated from within the editor interface directly, and is mostly useful for rendering images on screen dynamically via code. If you need to generate images procedurally from within the editor, consider saving and importing images as custom texture resources implementing a new EditorImportPlugin.

Note: The maximum texture size is 16384×16384 pixels due to graphics hardware limitations.

ImageTexture.MethodName

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

ImageTexture.PropertyName

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

ImageTexture.SignalName

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

ImageTexture3D

ImageTexture3D is a 3-dimensional ImageTexture that has a width, height, and depth. See also ImageTextureLayered.

3D textures are typically used to store density maps for FogMaterial, color correction LUTs for Environment, vector fields for GpuParticlesAttractorVectorField3D and collision maps for GpuParticlesCollisionSdf3D. 3D textures can also be used in custom shaders.

ImageTexture3D.MethodName

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

ImageTexture3D.PropertyName

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

ImageTexture3D.SignalName

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

ImageTextureLayered

Base class for Texture2DArray, Cubemap and CubemapArray. Cannot be used directly, but contains all the functions necessary for accessing the derived resource types. See also Texture3D.

ImageTextureLayered.MethodName

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

ImageTextureLayered.PropertyName

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

ImageTextureLayered.SignalName

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

ImmediateMesh

A mesh type optimized for creating geometry manually, similar to OpenGL 1.x immediate mode.

Here's a sample on how to generate a triangular face:

var mesh = new ImmediateMesh();
  mesh.SurfaceBegin(Mesh.PrimitiveType.Triangles);
  mesh.SurfaceAddVertex(Vector3.Left);
  mesh.SurfaceAddVertex(Vector3.Forward);
  mesh.SurfaceAddVertex(Vector3.Zero);
  mesh.SurfaceEnd();

Note: Generating complex geometries with ImmediateMesh is highly inefficient. Instead, it is designed to generate simple geometry that changes often.

ImmediateMesh.MethodName

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

ImmediateMesh.PropertyName

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

ImmediateMesh.SignalName

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

ImporterMesh

ImporterMesh is a type of Resource analogous to ArrayMesh. It contains vertex array-based geometry, divided in surfaces. Each surface contains a completely separate array and a material used to draw it. Design wise, a mesh with multiple surfaces is preferred to a single surface, because objects created in 3D editing software commonly contain multiple materials.

Unlike its runtime counterpart, ImporterMesh contains mesh data before various import steps, such as lod and shadow mesh generation, have taken place. Modify surface data by calling Clear(), followed by AddSurface(PrimitiveType, Array, Array<Array>, Dictionary, Material, string, ulong) for each surface.

ImporterMesh.MethodName

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

ImporterMesh.PropertyName

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

ImporterMesh.SignalName

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

ImporterMeshInstance3D

ImporterMeshInstance3D.MethodName

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

ImporterMeshInstance3D.PropertyName

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

ImporterMeshInstance3D.SignalName

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

Input

The Input singleton handles key presses, mouse buttons and movement, gamepads, and input actions. Actions and their events can be set in the Input Map tab in Project > Project Settings, or with the InputMap class.

Note: Input's methods reflect the global input state and are not affected by AcceptEvent() or SetInputAsHandled(), as those methods only deal with the way input is propagated in the SceneTree.

Input.MethodName

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

Input.PropertyName

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

Input.SignalName

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

InputEvent

Abstract base class of all types of input events. See _Input(InputEvent).

InputEvent.MethodName

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

InputEvent.PropertyName

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

InputEvent.SignalName

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

InputEventAction

Contains a generic action which can be targeted from several types of inputs. Actions and their events can be set in the Input Map tab in Project > Project Settings, or with the InputMap class.

Note: Unlike the other InputEvent subclasses which map to unique physical events, this virtual one is not emitted by the engine. This class is useful to emit actions manually with ParseInputEvent(InputEvent), which are then received in _Input(InputEvent). To check if a physical event matches an action from the Input Map, use IsAction(StringName, bool) and IsActionPressed(StringName, bool, bool).

InputEventAction.MethodName

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

InputEventAction.PropertyName

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

InputEventAction.SignalName

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

InputEventFromWindow

InputEventFromWindow represents events specifically received by windows. This includes mouse events, keyboard events in focused windows or touch screen actions.

InputEventFromWindow.MethodName

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

InputEventFromWindow.PropertyName

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

InputEventFromWindow.SignalName

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

InputEventGesture

InputEventGestures are sent when a user performs a supported gesture on a touch screen. Gestures can't be emulated using mouse, because they typically require multi-touch.

InputEventGesture.MethodName

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

InputEventGesture.PropertyName

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

InputEventGesture.SignalName

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

InputEventJoypadButton

Input event type for gamepad buttons. For gamepad analog sticks and joysticks, see InputEventJoypadMotion.

InputEventJoypadButton.MethodName

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

InputEventJoypadButton.PropertyName

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

InputEventJoypadButton.SignalName

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

InputEventJoypadMotion

Stores information about joystick motions. One InputEventJoypadMotion represents one axis at a time. For gamepad buttons, see InputEventJoypadButton.

InputEventJoypadMotion.MethodName

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

InputEventJoypadMotion.PropertyName

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

InputEventJoypadMotion.SignalName

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

InputEventKey

An input event for keys on a keyboard. Supports key presses, key releases and Echo events. It can also be received in _UnhandledKeyInput(InputEvent).

Note: Events received from the keyboard usually have all properties set. Event mappings should have only one of the Keycode, PhysicalKeycode or Unicode set.

When events are compared, properties are checked in the following priority - Keycode, PhysicalKeycode and Unicode. Events with the first matching value will be considered equal.

InputEventKey.MethodName

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

InputEventKey.PropertyName

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

InputEventKey.SignalName

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

InputEventMagnifyGesture

Stores the factor of a magnifying touch gesture. This is usually performed when the user pinches the touch screen and used for zooming in/out.

Note: On Android, this requires the ProjectSettings.input_devices/pointing/android/enable_pan_and_scale_gestures project setting to be enabled.

InputEventMagnifyGesture.MethodName

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

InputEventMagnifyGesture.PropertyName

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

InputEventMagnifyGesture.SignalName

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

InputEventMidi

InputEventMIDI stores information about messages from MIDI (Musical Instrument Digital Interface) devices. These may include musical keyboards, synthesizers, and drum machines.

MIDI messages can be received over a 5-pin MIDI connector or over USB. If your device supports both be sure to check the settings in the device to see which output it is using.

By default, Godot does not detect MIDI devices. You need to call OpenMidiInputs(), first. You can check which devices are detected with GetConnectedMidiInputs(), and close the connection with CloseMidiInputs().

public override void _Ready()
  {
      OS.OpenMidiInputs();
      GD.Print(OS.GetConnectedMidiInputs());
  }
public override void _Input(InputEvent inputEvent)
{
if (inputEvent is InputEventMidi midiEvent)
{
PrintMIDIInfo(midiEvent);
}
}
private void PrintMIDIInfo(InputEventMidi midiEvent)
{
GD.Print(midiEvent);
GD.Print($"Channel {midiEvent.Channel}");
GD.Print($"Message {midiEvent.Message}");
GD.Print($"Pitch {midiEvent.Pitch}");
GD.Print($"Velocity {midiEvent.Velocity}");
GD.Print($"Instrument {midiEvent.Instrument}");
GD.Print($"Pressure {midiEvent.Pressure}");
GD.Print($"Controller number: {midiEvent.ControllerNumber}");
GD.Print($"Controller value: {midiEvent.ControllerValue}");
}

Note: Godot does not support MIDI output, so there is no way to emit MIDI messages from Godot. Only MIDI input is supported.

InputEventMidi.MethodName

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

InputEventMidi.PropertyName

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

InputEventMidi.SignalName

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

InputEventMouse

Stores general information about mouse events.

InputEventMouse.MethodName

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

InputEventMouse.PropertyName

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

InputEventMouse.SignalName

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

InputEventMouseButton

Stores information about mouse click events. See _Input(InputEvent).

InputEventMouseButton.MethodName

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

InputEventMouseButton.PropertyName

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

InputEventMouseButton.SignalName

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

InputEventMouseMotion

Stores information about a mouse or a pen motion. This includes relative position, absolute position, and velocity. See _Input(InputEvent).

Note: By default, this event is only emitted once per frame rendered at most. If you need more precise input reporting, set UseAccumulatedInput to false to make events emitted as often as possible. If you use InputEventMouseMotion to draw lines, consider implementing Bresenham's line algorithm as well to avoid visible gaps in lines if the user is moving the mouse quickly.

InputEventMouseMotion.MethodName

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

InputEventMouseMotion.PropertyName

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

InputEventMouseMotion.SignalName

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

InputEventPanGesture

Stores information about pan gestures. A pan gesture is performed when the user swipes the touch screen with two fingers. It's typically used for panning/scrolling.

Note: On Android, this requires the ProjectSettings.input_devices/pointing/android/enable_pan_and_scale_gestures project setting to be enabled.

InputEventPanGesture.MethodName

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

InputEventPanGesture.PropertyName

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

InputEventPanGesture.SignalName

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

InputEventScreenDrag

Stores information about screen drag events. See _Input(InputEvent).

InputEventScreenDrag.MethodName

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

InputEventScreenDrag.PropertyName

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

InputEventScreenDrag.SignalName

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

InputEventScreenTouch

Stores information about multi-touch press/release input events. Supports touch press, touch release and Index for multi-touch count and order.

InputEventScreenTouch.MethodName

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

InputEventScreenTouch.PropertyName

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

InputEventScreenTouch.SignalName

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

InputEventShortcut

InputEventShortcut is a special event that can be received in _UnhandledKeyInput(InputEvent). It is typically sent by the editor's Command Palette to trigger actions, but can also be sent manually using PushInput(InputEvent, bool).

InputEventShortcut.MethodName

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

InputEventShortcut.PropertyName

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

InputEventShortcut.SignalName

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

InputEventWithModifiers

Stores information about mouse, keyboard, and touch gesture input events. This includes information about which modifier keys are pressed, such as Shift or Alt. See _Input(InputEvent).

InputEventWithModifiers.MethodName

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

InputEventWithModifiers.PropertyName

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

InputEventWithModifiers.SignalName

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

InputInstance

The Input singleton handles key presses, mouse buttons and movement, gamepads, and input actions. Actions and their events can be set in the Input Map tab in Project > Project Settings, or with the InputMap class.

Note: Input's methods reflect the global input state and are not affected by AcceptEvent() or SetInputAsHandled(), as those methods only deal with the way input is propagated in the SceneTree.

InputInstance.MethodName

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

InputInstance.PropertyName

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

InputInstance.SignalName

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

InputMap

Manages all InputEventAction which can be created/modified from the project settings menu Project > Project Settings > Input Map or in code with AddAction(StringName, float) and ActionAddEvent(StringName, InputEvent). See _Input(InputEvent).

InputMap.MethodName

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

InputMap.PropertyName

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

InputMap.SignalName

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

InputMapInstance

Manages all InputEventAction which can be created/modified from the project settings menu Project > Project Settings > Input Map or in code with AddAction(StringName, float) and ActionAddEvent(StringName, InputEvent). See _Input(InputEvent).

InputMapInstance.MethodName

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

InputMapInstance.PropertyName

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

InputMapInstance.SignalName

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

InstancePlaceholder

Turning on the option Load As Placeholder for an instantiated scene in the editor causes it to be replaced by an InstancePlaceholder when running the game, this will not replace the node in the editor. This makes it possible to delay actually loading the scene until calling CreateInstance(bool, PackedScene). This is useful to avoid loading large scenes all at once by loading parts of it selectively.

The InstancePlaceholder does not have a transform. This causes any child nodes to be positioned relatively to the Viewport from point (0,0), rather than their parent as displayed in the editor. Replacing the placeholder with a scene with a transform will transform children relatively to their parent again.

InstancePlaceholder.MethodName

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

InstancePlaceholder.PropertyName

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

InstancePlaceholder.SignalName

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

IntervalTweener

IntervalTweener is used to make delays in a tweening sequence. See TweenInterval(double) for more usage information.

Note: TweenInterval(double) is the only correct way to create IntervalTweener. Any IntervalTweener created manually will not function correctly.

IntervalTweener.MethodName

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

IntervalTweener.PropertyName

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

IntervalTweener.SignalName

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

ItemList

This control provides a vertical list of selectable items that may be in a single or in multiple columns, with each item having options for text and an icon. Tooltips are supported and may be different for every item in the list.

Selectable items in the list may be selected or deselected and multiple selection may be enabled. Selection with right mouse button may also be enabled to allow use of popup context menus. Items may also be "activated" by double-clicking them or by pressing Enter.

Item text only supports single-line strings. Newline characters (e.g. \n) in the string won't produce a newline. Text wrapping is enabled in Top mode, but the column's width is adjusted to fully fit its content by default. You need to set FixedColumnWidth greater than zero to wrap the text.

All set_* methods allow negative item indices, i.e. -1 to access the last item, -2 to select the second-to-last item, and so on.

Incremental search: Like PopupMenu and Tree, ItemList supports searching within the list while the control is focused. Press a key that matches the first letter of an item's name to select the first item starting with the given letter. After that point, there are two ways to perform incremental search: 1) Press the same key again before the timeout duration to select the next item starting with the same letter. 2) Press letter keys that match the rest of the word before the timeout duration to match to select the item in question directly. Both of these actions will be reset to the beginning of the list if the timeout duration has passed since the last keystroke was registered. You can adjust the timeout duration by changing ProjectSettings.gui/timers/incremental_search_max_interval_msec.

ItemList.MethodName

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

ItemList.PropertyName

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

ItemList.SignalName

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

JavaClass

JavaClass.MethodName

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

JavaClass.PropertyName

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

JavaClass.SignalName

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

JavaClassWrapper

JavaClassWrapper.MethodName

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

JavaClassWrapper.PropertyName

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

JavaClassWrapper.SignalName

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

JavaClassWrapperInstance

JavaClassWrapperInstance.MethodName

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

JavaClassWrapperInstance.PropertyName

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

JavaClassWrapperInstance.SignalName

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

JavaScriptBridge

The JavaScriptBridge singleton is implemented only in the Web export. It's used to access the browser's JavaScript context. This allows interaction with embedding pages or calling third-party JavaScript APIs.

Note: This singleton can be disabled at build-time to improve security. By default, the JavaScriptBridge singleton is enabled. Official export templates also have the JavaScriptBridge singleton enabled. See Compiling for the Web in the documentation for more information.

JavaScriptBridge.MethodName

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

JavaScriptBridge.PropertyName

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

JavaScriptBridge.SignalName

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

JavaScriptBridgeInstance

The JavaScriptBridge singleton is implemented only in the Web export. It's used to access the browser's JavaScript context. This allows interaction with embedding pages or calling third-party JavaScript APIs.

Note: This singleton can be disabled at build-time to improve security. By default, the JavaScriptBridge singleton is enabled. Official export templates also have the JavaScriptBridge singleton enabled. See Compiling for the Web in the documentation for more information.

JavaScriptBridgeInstance.MethodName

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

JavaScriptBridgeInstance.PropertyName

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

JavaScriptBridgeInstance.SignalName

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

JavaScriptObject

JavaScriptObject is used to interact with JavaScript objects retrieved or created via GetInterface(string), CreateObject(string, params Variant[]), or CreateCallback(Callable).

Example:

extends Node
var _my_js_callback = JavaScriptBridge.create_callback(myCallback) # This reference must be kept
var console = JavaScriptBridge.get_interface("console")
func _init():
var buf = JavaScriptBridge.create_object("ArrayBuffer", 10) # new ArrayBuffer(10)
print(buf) # prints [JavaScriptObject:OBJECT_ID]
var uint8arr = JavaScriptBridge.create_object("Uint8Array", buf) # new Uint8Array(buf)
uint8arr[1] = 255
prints(uint8arr[1], uint8arr.byteLength) # prints 255 10
console.log(uint8arr) # prints in browser console "Uint8Array(10) [ 0, 255, 0, 0, 0, 0, 0, 0, 0, 0 ]"
  # Equivalent of JavaScriptBridge: Array.from(uint8arr).forEach(myCallback)
  JavaScriptBridge.get_interface("Array").from(uint8arr).forEach(_my_js_callback)

func myCallback(args):
# Will be called with the parameters passed to the "forEach" callback
# [0, 0, [JavaScriptObject:1173]]
# [255, 1, [JavaScriptObject:1173]]
# ...
# [0, 9, [JavaScriptObject:1180]]
print(args)

Note: Only available in the Web platform.

JavaScriptObject.MethodName

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

JavaScriptObject.PropertyName

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

JavaScriptObject.SignalName

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

JniSingleton

The JNISingleton is implemented only in the Android export. It's used to call methods and connect signals from an Android plugin written in Java or Kotlin. Methods and signals can be called and connected to the JNISingleton as if it is a Node. See Java Native Interface - Wikipedia for more information.

JniSingleton.MethodName

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

JniSingleton.PropertyName

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

JniSingleton.SignalName

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

Joint2D

Abstract base class for all joints in 2D physics. 2D joints bind together two physics bodies and apply a constraint.

Joint2D.MethodName

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

Joint2D.PropertyName

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

Joint2D.SignalName

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

Joint3D

Abstract base class for all joints in 3D physics. 3D joints bind together two physics bodies and apply a constraint.

Joint3D.MethodName

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

Joint3D.PropertyName

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

Joint3D.SignalName

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

Json

The Json enables all data types to be converted to and from a JSON string. This useful for serializing data to save to a file or send over the network.

Stringify(Variant, string, bool, bool) is used to convert any data type into a JSON string.

Parse(string, bool) is used to convert any existing JSON data into a Variant that can be used within Godot. If successfully parsed, use Data to retrieve the Variant, and use typeof to check if the Variant's type is what you expect. JSON Objects are converted into a Dictionary, but JSON data can be used to store Arrays, numbers, strings and even just a boolean.

Example

var data_to_send = ["a", "b", "c"]
  var json_string = JSON.stringify(data_to_send)
  # Save data
  # ...
  # Retrieve data
  var json = JSON.new()
  var error = json.parse(json_string)
  if error == OK:
      var data_received = json.data
      if typeof(data_received) == TYPE_ARRAY:
          print(data_received) # Prints array
      else:
          print("Unexpected data")
  else:
      print("JSON Parse Error: ", json.get_error_message(), " in ", json_string, " at line ", json.get_error_line())

Alternatively, you can parse string using the static ParseString(string) method, but it doesn't allow to handle errors.

var data = JSON.parse_string(json_string) # Returns null if parsing failed.

Note: Both parse methods do not fully comply with the JSON specification:

- Trailing commas in arrays or objects are ignored, instead of causing a parser error.

- New line and tab characters are accepted in string literals, and are treated like their corresponding escape sequences \n and \t.

- Numbers are parsed using String.to_float which is generally more lax than the JSON specification.

- Certain errors, such as invalid Unicode sequences, do not cause a parser error. Instead, the string is cleansed and an error is logged to the console.

Json.MethodName

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

Json.PropertyName

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

Json.SignalName

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

JsonRpc

JSON-RPC is a standard which wraps a method call in a Json object. The object has a particular structure and identifies which method is called, the parameters to that function, and carries an ID to keep track of responses. This class implements that standard on top of Dictionary; you will have to convert between a Dictionary and Json with other functions.

JsonRpc.MethodName

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

JsonRpc.PropertyName

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

JsonRpc.SignalName

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

KinematicCollision2D

Holds collision data from the movement of a PhysicsBody2D, usually from MoveAndCollide(Vector2, bool, float, bool). When a PhysicsBody2D is moved, it stops if it detects a collision with another body. If a collision is detected, a KinematicCollision2D object is returned.

The collision data includes the colliding object, the remaining motion, and the collision position. This data can be used to determine a custom response to the collision.

KinematicCollision2D.MethodName

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

KinematicCollision2D.PropertyName

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

KinematicCollision2D.SignalName

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

KinematicCollision3D

Holds collision data from the movement of a PhysicsBody3D, usually from MoveAndCollide(Vector3, bool, float, bool, int). When a PhysicsBody3D is moved, it stops if it detects a collision with another body. If a collision is detected, a KinematicCollision3D object is returned.

The collision data includes the colliding object, the remaining motion, and the collision position. This data can be used to determine a custom response to the collision.

KinematicCollision3D.MethodName

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

KinematicCollision3D.PropertyName

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

KinematicCollision3D.SignalName

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

Label

A control for displaying plain text. It gives you control over the horizontal and vertical alignment and can wrap the text inside the node's bounding rectangle. It doesn't support bold, italics, or other rich text formatting. For that, use RichTextLabel instead.

Label.MethodName

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

Label.PropertyName

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

Label.SignalName

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

Label3D

A node for displaying plain text in 3D space. By adjusting various properties of this node, you can configure things such as the text's appearance and whether it always faces the camera.

Label3D.MethodName

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

Label3D.PropertyName

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

Label3D.SignalName

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

LabelSettings

LabelSettings is a resource that provides common settings to customize the text in a Label. It will take priority over the properties defined in Theme. The resource can be shared between multiple labels and changed on the fly, so it's convenient and flexible way to setup text style.

LabelSettings.MethodName

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

LabelSettings.PropertyName

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

LabelSettings.SignalName

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

Light2D

Casts light in a 2D environment. A light is defined as a color, an energy value, a mode (see constants), and various other parameters (range and shadows-related).

Light2D.MethodName

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

Light2D.PropertyName

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

Light2D.SignalName

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

Light3D

Light3D is the abstract base class for light nodes. As it can't be instantiated, it shouldn't be used directly. Other types of light nodes inherit from it. Light3D contains the common variables and parameters used for lighting.

Light3D.MethodName

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

Light3D.PropertyName

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

Light3D.SignalName

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

LightOccluder2D

Occludes light cast by a Light2D, casting shadows. The LightOccluder2D must be provided with an OccluderPolygon2D in order for the shadow to be computed.

LightOccluder2D.MethodName

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

LightOccluder2D.PropertyName

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

LightOccluder2D.SignalName

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

LightmapGI

The LightmapGI node is used to compute and store baked lightmaps. Lightmaps are used to provide high-quality indirect lighting with very little light leaking. LightmapGI can also provide rough reflections using spherical harmonics if Directional is enabled. Dynamic objects can receive indirect lighting thanks to light probes, which can be automatically placed by setting GenerateProbesSubdiv to a value other than Disabled. Additional lightmap probes can also be added by creating LightmapProbe nodes. The downside is that lightmaps are fully static and cannot be baked in an exported project. Baking a LightmapGI node is also slower compared to VoxelGI.

Procedural generation: Lightmap baking functionality is only available in the editor. This means LightmapGI is not suited to procedurally generated or user-built levels. For procedurally generated or user-built levels, use VoxelGI or SDFGI instead (see SdfgiEnabled).

Performance: LightmapGI provides the best possible run-time performance for global illumination. It is suitable for low-end hardware including integrated graphics and mobile devices.

Note: Due to how lightmaps work, most properties only have a visible effect once lightmaps are baked again.

Note: Lightmap baking on CsgShape3Ds and PrimitiveMeshes is not supported, as these cannot store UV2 data required for baking.

Note: If no custom lightmappers are installed, LightmapGI can only be baked when using the Vulkan backend (Forward+ or Mobile), not OpenGL. Additionally, LightmapGI rendering is not currently supported when using the OpenGL backend (Compatibility).

LightmapGI.MethodName

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

LightmapGI.PropertyName

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

LightmapGI.SignalName

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

LightmapGIData

LightmapGIData contains baked lightmap and dynamic object probe data for LightmapGI. It is replaced every time lightmaps are baked in LightmapGI.

LightmapGIData.MethodName

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

LightmapGIData.PropertyName

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

LightmapGIData.SignalName

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

LightmapProbe

LightmapProbe represents the position of a single manually placed probe for dynamic object lighting with LightmapGI.

Typically, LightmapGI probes are placed automatically by setting GenerateProbesSubdiv to a value other than Disabled. By creating LightmapProbe nodes before baking lightmaps, you can add more probes in specific areas for greater detail, or disable automatic generation and rely only on manually placed probes instead.

LightmapProbe.MethodName

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

LightmapProbe.PropertyName

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

LightmapProbe.SignalName

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

Lightmapper

This class should be extended by custom lightmapper classes. Lightmappers can then be used with LightmapGI to provide fast baked global illumination in 3D.

Godot contains a built-in GPU-based lightmapper LightmapperRD that uses compute shaders, but custom lightmappers can be implemented by C++ modules.

Lightmapper.MethodName

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

Lightmapper.PropertyName

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

Lightmapper.SignalName

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

LightmapperRD

LightmapperRD ("RD" stands for RenderingDevice) is the built-in GPU-based lightmapper for use with LightmapGI. On most dedicated GPUs, it can bake lightmaps much faster than most CPU-based lightmappers. LightmapperRD uses compute shaders to bake lightmaps, so it does not require CUDA or OpenCL libraries to be installed to be usable.

Note: Only usable when using the Vulkan backend (Forward+ or Mobile), not OpenGL.

LightmapperRD.MethodName

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

LightmapperRD.PropertyName

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

LightmapperRD.SignalName

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

Line2D

This node draws a 2D polyline, i.e. a shape consisting of several points connected by segments. Line2D is not a mathematical polyline, i.e. the segments are not infinitely thin. It is intended for rendering and it can be colored and optionally textured.

Warning: Certain configurations may be impossible to draw nicely, such as very sharp angles. In these situations, the node uses fallback drawing logic to look decent.

Note: Line2D is drawn using a 2D mesh.

Line2D.MethodName

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

Line2D.PropertyName

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

Line2D.SignalName

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

LineEdit

LineEdit provides an input field for editing a single line of text. It features many built-in shortcuts that are always available (Ctrl here maps to Cmd on macOS):

- Ctrl + C: Copy

- Ctrl + X: Cut

- Ctrl + V or Ctrl + Y: Paste/"yank"

- Ctrl + Z: Undo

- Ctrl + ~: Swap input direction.

- Ctrl + Shift + Z: Redo

- Ctrl + U: Delete text from the caret position to the beginning of the line

- Ctrl + K: Delete text from the caret position to the end of the line

- Ctrl + A: Select all text

- Up Arrow/Down Arrow: Move the caret to the beginning/end of the line

On macOS, some extra keyboard shortcuts are available:

- Cmd + F: Same as Right Arrow, move the caret one character right

- Cmd + B: Same as Left Arrow, move the caret one character left

- Cmd + P: Same as Up Arrow, move the caret to the previous line

- Cmd + N: Same as Down Arrow, move the caret to the next line

- Cmd + D: Same as Delete, delete the character on the right side of caret

- Cmd + H: Same as Backspace, delete the character on the left side of the caret

- Cmd + A: Same as Home, move the caret to the beginning of the line

- Cmd + E: Same as End, move the caret to the end of the line

- Cmd + Left Arrow: Same as Home, move the caret to the beginning of the line

- Cmd + Right Arrow: Same as End, move the caret to the end of the line

LineEdit.MethodName

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

LineEdit.PropertyName

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

LineEdit.SignalName

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

LinkButton

A button that represents a link. This type of button is primarily used for interactions that cause a context change (like linking to a web page).

See also BaseButton which contains common properties and methods associated with this node.

LinkButton.MethodName

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

LinkButton.PropertyName

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

LinkButton.SignalName

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

MainLoop

MainLoop is the abstract base class for a Godot project's game loop. It is inherited by SceneTree, which is the default game loop implementation used in Godot projects, though it is also possible to write and use one's own MainLoop subclass instead of the scene tree.

Upon the application start, a MainLoop implementation must be provided to the OS; otherwise, the application will exit. This happens automatically (and a SceneTree is created) unless a MainLoop Script is provided from the command line (with e.g. godot -s my_loop.gd) or the "Main Loop Type" project setting is overwritten.

Here is an example script implementing a simple MainLoop:

using Godot;
[GlobalClass]
public partial class CustomMainLoop : MainLoop
{
private double _timeElapsed = 0;
  public override void _Initialize()
  {
      GD.Print("Initialized:");
      GD.Print($"  Starting Time: {_timeElapsed}");
  }

  public override bool _Process(double delta)
  {
      _timeElapsed += delta;
      // Return true to end the main loop.
      return Input.GetMouseButtonMask() != 0 || Input.IsKeyPressed(Key.Escape);
  }

  private void _Finalize()
  {
      GD.Print("Finalized:");
      GD.Print($"  End Time: {_timeElapsed}");
  }

}

MainLoop.MethodName

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

MainLoop.PropertyName

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

MainLoop.SignalName

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

MarginContainer

MarginContainer adds an adjustable margin on each side of its child controls. The margins are added around all children, not around each individual one. To control the MarginContainer's margins, use the margin_* theme properties listed below.

Note: The margin sizes are theme overrides, not normal properties. This is an example of how to change them in code:

// This code sample assumes the current script is extending MarginContainer.
  int marginValue = 100;
  AddThemeConstantOverride("margin_top", marginValue);
  AddThemeConstantOverride("margin_left", marginValue);
  AddThemeConstantOverride("margin_bottom", marginValue);
  AddThemeConstantOverride("margin_right", marginValue);

MarginContainer.MethodName

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

MarginContainer.PropertyName

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

MarginContainer.SignalName

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

Marker2D

Generic 2D position hint for editing. It's just like a plain Node2D, but it displays as a cross in the 2D editor at all times. You can set the cross' visual size by using the gizmo in the 2D editor while the node is selected.

Marker2D.MethodName

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

Marker2D.PropertyName

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

Marker2D.SignalName

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

Marker3D

Generic 3D position hint for editing. It's just like a plain Node3D, but it displays as a cross in the 3D editor at all times.

Marker3D.MethodName

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

Marker3D.PropertyName

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

Marker3D.SignalName

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

Marshalls

Provides data transformation and encoding utility functions.

Marshalls.MethodName

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

Marshalls.PropertyName

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

Marshalls.SignalName

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

MarshallsInstance

Provides data transformation and encoding utility functions.

MarshallsInstance.MethodName

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

MarshallsInstance.PropertyName

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

MarshallsInstance.SignalName

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

Material

Material is a base resource used for coloring and shading geometry. All materials inherit from it and almost all VisualInstance3D derived nodes carry a Material. A few flags and parameters are shared between all material types and are configured here.

Importantly, you can inherit from Material to create your own custom material type in script or in GDExtension.

Material.MethodName

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

Material.PropertyName

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

Material.SignalName

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

Mathf

Provides constants and static methods for common mathematical functions.

MenuBar

A horizontal menu bar that creates a MenuButton for each PopupMenu child. New items are created by adding PopupMenus to this node.

MenuBar.MethodName

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

MenuBar.PropertyName

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

MenuBar.SignalName

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

MenuButton

A button that brings up a PopupMenu when clicked. To create new items inside this PopupMenu, use get_popup().add_item("My Item Name"). You can also create them directly from Godot editor's inspector.

See also BaseButton which contains common properties and methods associated with this node.

MenuButton.MethodName

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

MenuButton.PropertyName

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

MenuButton.SignalName

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

Mesh

Mesh is a type of Resource that contains vertex array-based geometry, divided in surfaces. Each surface contains a completely separate array and a material used to draw it. Design wise, a mesh with multiple surfaces is preferred to a single surface, because objects created in 3D editing software commonly contain multiple materials.

Mesh.MethodName

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

Mesh.PropertyName

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

Mesh.SignalName

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

MeshConvexDecompositionSettings

Parameters to be used with a Mesh convex decomposition operation.

MeshConvexDecompositionSettings.MethodName

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

MeshConvexDecompositionSettings.PropertyName

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

MeshConvexDecompositionSettings.SignalName

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

MeshDataTool

MeshDataTool provides access to individual vertices in a Mesh. It allows users to read and edit vertex data of meshes. It also creates an array of faces and edges.

To use MeshDataTool, load a mesh with CreateFromSurface(ArrayMesh, int). When you are finished editing the data commit the data to a mesh with CommitToSurface(ArrayMesh, ulong).

Below is an example of how MeshDataTool may be used.

var mesh = new ArrayMesh();
  mesh.AddSurfaceFromArrays(Mesh.PrimitiveType.Triangles, new BoxMesh().GetMeshArrays());
  var mdt = new MeshDataTool();
  mdt.CreateFromSurface(mesh, 0);
  for (var i = 0; i < mdt.GetVertexCount(); i++)
  {
      Vector3 vertex = mdt.GetVertex(i);
      // In this example we extend the mesh by one unit, which results in separated faces as it is flat shaded.
      vertex += mdt.GetVertexNormal(i);
      // Save your change.
      mdt.SetVertex(i, vertex);
  }
  mesh.ClearSurfaces();
  mdt.CommitToSurface(mesh);
  var mi = new MeshInstance();
  mi.Mesh = mesh;
  AddChild(mi);

See also ArrayMesh, ImmediateMesh and SurfaceTool for procedural geometry generation.

Note: Godot uses clockwise winding order for front faces of triangle primitive modes.

MeshDataTool.MethodName

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

MeshDataTool.PropertyName

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

MeshDataTool.SignalName

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

MeshInstance2D

Node used for displaying a Mesh in 2D. A MeshInstance2D can be automatically created from an existing Sprite2D via a tool in the editor toolbar. Select the Sprite2D node, then choose Sprite2D > Convert to MeshInstance2D at the top of the 2D editor viewport.

MeshInstance2D.MethodName

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

MeshInstance2D.PropertyName

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

MeshInstance2D.SignalName

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

MeshInstance3D

MeshInstance3D is a node that takes a Mesh resource and adds it to the current scenario by creating an instance of it. This is the class most often used render 3D geometry and can be used to instance a single Mesh in many places. This allows reusing geometry, which can save on resources. When a Mesh has to be instantiated more than thousands of times at close proximity, consider using a MultiMesh in a MultiMeshInstance3D instead.

MeshInstance3D.MethodName

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

MeshInstance3D.PropertyName

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

MeshInstance3D.SignalName

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

MeshLibrary

A library of meshes. Contains a list of Mesh resources, each with a name and ID. Each item can also include collision and navigation shapes. This resource is used in GridMap.

MeshLibrary.MethodName

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

MeshLibrary.PropertyName

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

MeshLibrary.SignalName

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

MeshTexture

Simple texture that uses a mesh to draw itself. It's limited because flags can't be changed and region drawing is not supported.

MeshTexture.MethodName

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

MeshTexture.PropertyName

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

MeshTexture.SignalName

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

MethodTweener

MethodTweener is similar to a combination of CallbackTweener and PropertyTweener. It calls a method providing an interpolated value as a parameter. See TweenMethod(Callable, Variant, Variant, double) for more usage information.

The tweener will finish automatically if the callback's target object is freed.

Note: TweenMethod(Callable, Variant, Variant, double) is the only correct way to create MethodTweener. Any MethodTweener created manually will not function correctly.

MethodTweener.MethodName

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

MethodTweener.PropertyName

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

MethodTweener.SignalName

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

MissingNode

This is an internal editor class intended for keeping data of nodes of unknown type (most likely this type was supplied by an extension that is no longer loaded). It can't be manually instantiated or placed in the scene. Ignore it if you don't know what it is.

MissingNode.MethodName

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

MissingNode.PropertyName

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

MissingNode.SignalName

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

MissingResource

This is an internal editor class intended for keeping data of resources of unknown type (most likely this type was supplied by an extension that is no longer loaded). It can't be manually instantiated or placed in the scene. Ignore it if you don't know what it is.

MissingResource.MethodName

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

MissingResource.PropertyName

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

MissingResource.SignalName

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

MobileVRInterface

This is a generic mobile VR implementation where you need to provide details about the phone and HMD used. It does not rely on any existing framework. This is the most basic interface we have. For the best effect, you need a mobile phone with a gyroscope and accelerometer.

Note that even though there is no positional tracking, the camera will assume the headset is at a height of 1.85 meters. You can change this by setting EyeHeight.

You can initialize this interface as follows:

var interface = XRServer.find_interface("Native mobile")
  if interface and interface.initialize():
      get_viewport().xr = true

MobileVRInterface.MethodName

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

MobileVRInterface.PropertyName

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

MobileVRInterface.SignalName

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

MovieWriter

Godot can record videos with non-real-time simulation. Like the --fixed-fpscommand line argument, this forces the reported delta in _Process(double) functions to be identical across frames, regardless of how long it actually took to render the frame. This can be used to record high-quality videos with perfect frame pacing regardless of your hardware's capabilities.

Godot has 2 built-in MovieWriters:

- AVI container with MJPEG for video and uncompressed audio (.avi file extension). Lossy compression, medium file sizes, fast encoding. The lossy compression quality can be adjusted by changing ProjectSettings.editor/movie_writer/mjpeg_quality. The resulting file can be viewed in most video players, but it must be converted to another format for viewing on the web or by Godot with VideoStreamPlayer. MJPEG does not support transparency. AVI output is currently limited to a file of 4 GB in size at most.

- PNG image sequence for video and WAV for audio (.png file extension). Lossless compression, large file sizes, slow encoding. Designed to be encoded to a video file with another tool such as FFmpeg after recording. Transparency is currently not supported, even if the root viewport is set to be transparent.

If you need to encode to a different format or pipe a stream through third-party software, you can extend the MovieWriter class to create your own movie writers. This should typically be done using GDExtension for performance reasons.

Editor usage: A default movie file path can be specified in ProjectSettings.editor/movie_writer/movie_file. Alternatively, for running single scenes, a movie_file metadata can be added to the root node, specifying the path to a movie file that will be used when recording that scene. Once a path is set, click the video reel icon in the top-right corner of the editor to enable Movie Maker mode, then run any scene as usual. The engine will start recording as soon as the splash screen is finished, and it will only stop recording when the engine quits. Click the video reel icon again to disable Movie Maker mode. Note that toggling Movie Maker mode does not affect project instances that are already running.

Note: MovieWriter is available for use in both the editor and exported projects, but it is not designed for use by end users to record videos while playing. Players wishing to record gameplay videos should install tools such as OBS Studio or SimpleScreenRecorder instead.

MovieWriter.MethodName

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

MovieWriter.PropertyName

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

MovieWriter.SignalName

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

MultiMesh

MultiMesh provides low-level mesh instancing. Drawing thousands of MeshInstance3D nodes can be slow, since each object is submitted to the GPU then drawn individually.

MultiMesh is much faster as it can draw thousands of instances with a single draw call, resulting in less API overhead.

As a drawback, if the instances are too far away from each other, performance may be reduced as every single instance will always render (they are spatially indexed as one, for the whole object).

Since instances may have any behavior, the AABB used for visibility must be provided by the user.

Note: A MultiMesh is a single object, therefore the same maximum lights per object restriction applies. This means, that once the maximum lights are consumed by one or more instances, the rest of the MultiMesh instances will not receive any lighting.

Note: Blend Shapes will be ignored if used in a MultiMesh.

MultiMesh.MethodName

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

MultiMesh.PropertyName

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

MultiMesh.SignalName

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

MultiMeshInstance2D

MultiMeshInstance2D is a specialized node to instance a MultiMesh resource in 2D.

Usage is the same as MultiMeshInstance3D.

MultiMeshInstance2D.MethodName

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

MultiMeshInstance2D.PropertyName

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

MultiMeshInstance2D.SignalName

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

MultiMeshInstance3D

MultiMeshInstance3D is a specialized node to instance GeometryInstance3Ds based on a MultiMesh resource.

This is useful to optimize the rendering of a high number of instances of a given mesh (for example trees in a forest or grass strands).

MultiMeshInstance3D.MethodName

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

MultiMeshInstance3D.PropertyName

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

MultiMeshInstance3D.SignalName

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

MultiplayerApi

Base class for high-level multiplayer API implementations. See also MultiplayerPeer.

By default, SceneTree has a reference to an implementation of this class and uses it to provide multiplayer capabilities (i.e. RPCs) across the whole scene.

It is possible to override the MultiplayerAPI instance used by specific tree branches by calling the SetMultiplayer(MultiplayerApi, NodePath) method, effectively allowing to run both client and server in the same scene.

It is also possible to extend or replace the default implementation via scripting or native extensions. See MultiplayerApiExtension for details about extensions, SceneMultiplayer for the details about the default implementation.

MultiplayerApi.MethodName

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

MultiplayerApi.PropertyName

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

MultiplayerApi.SignalName

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

MultiplayerApiExtension

This class can be used to augment or replace the default MultiplayerApi implementation via script or extensions.

The following example augment the default implementation (SceneMultiplayer) by logging every RPC being made, and every object being configured for replication.

Then in your main scene or in an autoload call SetMultiplayer(MultiplayerApi, NodePath) to start using your custom MultiplayerApi:

Native extensions can alternatively use the SetDefaultInterface(StringName) method during initialization to configure themselves as the default implementation.

MultiplayerApiExtension.MethodName

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

MultiplayerApiExtension.PropertyName

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

MultiplayerApiExtension.SignalName

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

MultiplayerPeer

Manages the connection with one or more remote peers acting as server or client and assigning unique IDs to each of them. See also MultiplayerApi.

Note: The MultiplayerApi protocol is an implementation detail and isn't meant to be used by non-Godot servers. It may change without notice.

Note: When exporting to Android, make sure to enable the INTERNET permission in the Android export preset before exporting the project or using one-click deploy. Otherwise, network communication of any kind will be blocked by Android.

MultiplayerPeer.MethodName

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

MultiplayerPeer.PropertyName

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

MultiplayerPeer.SignalName

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

MultiplayerPeerExtension

This class is designed to be inherited from a GDExtension plugin to implement custom networking layers for the multiplayer API (such as WebRTC). All the methods below must be implemented to have a working custom multiplayer implementation. See also MultiplayerApi.

MultiplayerPeerExtension.MethodName

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

MultiplayerPeerExtension.PropertyName

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

MultiplayerPeerExtension.SignalName

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

MultiplayerSpawner

Spawnable scenes can be configured in the editor or through code (see AddSpawnableScene(string)).

Also supports custom node spawns through Spawn(Variant), calling SpawnFunction on all peers.

Internally, MultiplayerSpawner uses ObjectConfigurationAdd(GodotObject, Variant) to notify spawns passing the spawned node as the object and itself as the configuration, and ObjectConfigurationRemove(GodotObject, Variant) to notify despawns in a similar way.

MultiplayerSpawner.MethodName

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

MultiplayerSpawner.PropertyName

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

MultiplayerSpawner.SignalName

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

MultiplayerSynchronizer

By default, MultiplayerSynchronizer synchronizes configured properties to all peers.

Visibility can be handled directly with SetVisibilityFor(int, bool) or as-needed with AddVisibilityFilter(Callable) and UpdateVisibility(int).

MultiplayerSpawners will handle nodes according to visibility of synchronizers as long as the node at RootPath was spawned by one.

Internally, MultiplayerSynchronizer uses ObjectConfigurationAdd(GodotObject, Variant) to notify synchronization start passing the Node at RootPath as the object and itself as the configuration, and uses ObjectConfigurationRemove(GodotObject, Variant) to notify synchronization end in a similar way.

Note: Synchronization is not supported for GodotObject type properties, like Resource. Properties that are unique to each peer, like the instance IDs of GodotObjects (see GetInstanceId()) or Rids, will also not work in synchronization.

MultiplayerSynchronizer.MethodName

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

MultiplayerSynchronizer.PropertyName

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

MultiplayerSynchronizer.SignalName

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

MustBeVariantAttribute

Attribute that restricts generic type parameters to be only types that can be marshaled from/to a Variant.

Mutex

A synchronization mutex (mutual exclusion). This is used to synchronize multiple GodotThreads, and is equivalent to a binary Semaphore. It guarantees that only one thread can access a critical section at a time.

This is a reentrant mutex, meaning that it can be locked multiple times by one thread, provided it also unlocks it as many times.

Warning: Mutexes must be used carefully to avoid deadlocks.

Warning: To ensure proper cleanup without crashes or deadlocks, the following conditions must be met:

- When a Mutex's reference count reaches zero and it is therefore destroyed, no threads (including the one on which the destruction will happen) must have it locked.

- When a GodotThread's reference count reaches zero and it is therefore destroyed, it must not have any mutex locked.

Mutex.MethodName

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

Mutex.PropertyName

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

Mutex.SignalName

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

NavigationAgent2D

A 2D agent used to pathfind to a position while avoiding static and dynamic obstacles. The calculation can be used by the parent node to dynamically move it along the path. Requires navigation data to work correctly.

Dynamic obstacles are avoided using RVO collision avoidance. Avoidance is computed before physics, so the pathfinding information can be used safely in the physics step.

Note: After setting the TargetPosition property, the GetNextPathPosition() method must be used once every physics frame to update the internal path logic of the navigation agent. The vector position it returns should be used as the next movement position for the agent's parent node.

NavigationAgent2D.MethodName

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

NavigationAgent2D.PropertyName

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

NavigationAgent2D.SignalName

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

NavigationAgent3D

A 3D agent used to pathfind to a position while avoiding static and dynamic obstacles. The calculation can be used by the parent node to dynamically move it along the path. Requires navigation data to work correctly.

Dynamic obstacles are avoided using RVO collision avoidance. Avoidance is computed before physics, so the pathfinding information can be used safely in the physics step.

Note: After setting the TargetPosition property, the GetNextPathPosition() method must be used once every physics frame to update the internal path logic of the navigation agent. The vector position it returns should be used as the next movement position for the agent's parent node.

NavigationAgent3D.MethodName

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

NavigationAgent3D.PropertyName

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

NavigationAgent3D.SignalName

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

NavigationLink2D

A link between two positions on NavigationRegion2Ds that agents can be routed through. These positions can be on the same NavigationRegion2D or on two different ones. Links are useful to express navigation methods other than traveling along the surface of the navigation polygon, such as ziplines, teleporters, or gaps that can be jumped across.

NavigationLink2D.MethodName

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

NavigationLink2D.PropertyName

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

NavigationLink2D.SignalName

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

NavigationLink3D

A link between two positions on NavigationRegion3Ds that agents can be routed through. These positions can be on the same NavigationRegion3D or on two different ones. Links are useful to express navigation methods other than traveling along the surface of the navigation mesh, such as ziplines, teleporters, or gaps that can be jumped across.

NavigationLink3D.MethodName

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

NavigationLink3D.PropertyName

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

NavigationLink3D.SignalName

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

NavigationMesh

A navigation mesh is a collection of polygons that define which areas of an environment are traversable to aid agents in pathfinding through complicated spaces.

NavigationMesh.MethodName

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

NavigationMesh.PropertyName

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

NavigationMesh.SignalName

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

NavigationMeshGenerator

This class is responsible for creating and clearing 3D navigation meshes used as NavigationMesh resources inside NavigationRegion3D. The NavigationMeshGenerator has very limited to no use for 2D as the navigation mesh baking process expects 3D node types and 3D source geometry to parse.

The entire navigation mesh baking is best done in a separate thread as the voxelization, collision tests and mesh optimization steps involved are very performance and time hungry operations.

Navigation mesh baking happens in multiple steps and the result depends on 3D source geometry and properties of the NavigationMesh resource. In the first step, starting from a root node and depending on NavigationMesh properties all valid 3D source geometry nodes are collected from the SceneTree. Second, all collected nodes are parsed for their relevant 3D geometry data and a combined 3D mesh is build. Due to the many different types of parsable objects, from normal MeshInstance3Ds to CsgShape3Ds or various CollisionObject3Ds, some operations to collect geometry data can trigger RenderingServer and PhysicsServer3D synchronizations. Server synchronization can have a negative effect on baking time or framerate as it often involves Mutex locking for thread security. Many parsable objects and the continuous synchronization with other threaded Servers can increase the baking time significantly. On the other hand only a few but very large and complex objects will take some time to prepare for the Servers which can noticeably stall the next frame render. As a general rule the total number of parsable objects and their individual size and complexity should be balanced to avoid framerate issues or very long baking times. The combined mesh is then passed to the Recast Navigation Object to test the source geometry for walkable terrain suitable to NavigationMesh agent properties by creating a voxel world around the meshes bounding area.

The finalized navigation mesh is then returned and stored inside the NavigationMesh for use as a resource inside NavigationRegion3D nodes.

Note: Using meshes to not only define walkable surfaces but also obstruct navigation baking does not always work. The navigation baking has no concept of what is a geometry "inside" when dealing with mesh source geometry and this is intentional. Depending on current baking parameters, as soon as the obstructing mesh is large enough to fit a navigation mesh area inside, the baking will generate navigation mesh areas that are inside the obstructing source geometry mesh.

NavigationMeshGenerator.MethodName

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

NavigationMeshGenerator.PropertyName

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

NavigationMeshGenerator.SignalName

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

NavigationMeshGeneratorInstance

This class is responsible for creating and clearing 3D navigation meshes used as NavigationMesh resources inside NavigationRegion3D. The NavigationMeshGenerator has very limited to no use for 2D as the navigation mesh baking process expects 3D node types and 3D source geometry to parse.

The entire navigation mesh baking is best done in a separate thread as the voxelization, collision tests and mesh optimization steps involved are very performance and time hungry operations.

Navigation mesh baking happens in multiple steps and the result depends on 3D source geometry and properties of the NavigationMesh resource. In the first step, starting from a root node and depending on NavigationMesh properties all valid 3D source geometry nodes are collected from the SceneTree. Second, all collected nodes are parsed for their relevant 3D geometry data and a combined 3D mesh is build. Due to the many different types of parsable objects, from normal MeshInstance3Ds to CsgShape3Ds or various CollisionObject3Ds, some operations to collect geometry data can trigger RenderingServer and PhysicsServer3D synchronizations. Server synchronization can have a negative effect on baking time or framerate as it often involves Mutex locking for thread security. Many parsable objects and the continuous synchronization with other threaded Servers can increase the baking time significantly. On the other hand only a few but very large and complex objects will take some time to prepare for the Servers which can noticeably stall the next frame render. As a general rule the total number of parsable objects and their individual size and complexity should be balanced to avoid framerate issues or very long baking times. The combined mesh is then passed to the Recast Navigation Object to test the source geometry for walkable terrain suitable to NavigationMesh agent properties by creating a voxel world around the meshes bounding area.

The finalized navigation mesh is then returned and stored inside the NavigationMesh for use as a resource inside NavigationRegion3D nodes.

Note: Using meshes to not only define walkable surfaces but also obstruct navigation baking does not always work. The navigation baking has no concept of what is a geometry "inside" when dealing with mesh source geometry and this is intentional. Depending on current baking parameters, as soon as the obstructing mesh is large enough to fit a navigation mesh area inside, the baking will generate navigation mesh areas that are inside the obstructing source geometry mesh.

NavigationMeshGeneratorInstance.MethodName

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

NavigationMeshGeneratorInstance.PropertyName

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

NavigationMeshGeneratorInstance.SignalName

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

NavigationMeshSourceGeometryData2D

Container for parsed source geometry data used in navigation mesh baking.

NavigationMeshSourceGeometryData2D.MethodName

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

NavigationMeshSourceGeometryData2D.PropertyName

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

NavigationMeshSourceGeometryData2D.SignalName

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

NavigationMeshSourceGeometryData3D

Container for parsed source geometry data used in navigation mesh baking.

NavigationMeshSourceGeometryData3D.MethodName

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

NavigationMeshSourceGeometryData3D.PropertyName

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

NavigationMeshSourceGeometryData3D.SignalName

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

NavigationObstacle2D

2D Obstacle used in navigation to constrain avoidance controlled agents outside or inside an area. The obstacle needs a navigation map and outline vertices defined to work correctly.

If the obstacle's vertices are winded in clockwise order, avoidance agents will be pushed in by the obstacle, otherwise, avoidance agents will be pushed out. Outlines must not cross or overlap.

Obstacles are not a replacement for a (re)baked navigation mesh. Obstacles don't change the resulting path from the pathfinding, obstacles only affect the navigation avoidance agent movement by altering the suggested velocity of the avoidance agent.

Obstacles using vertices can warp to a new position but should not moved every frame as each move requires a rebuild of the avoidance map.

NavigationObstacle2D.MethodName

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

NavigationObstacle2D.PropertyName

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

NavigationObstacle2D.SignalName

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

NavigationObstacle3D

3D Obstacle used in navigation to constrain avoidance controlled agents outside or inside an area. The obstacle needs a navigation map and outline vertices defined to work correctly.

If the obstacle's vertices are winded in clockwise order, avoidance agents will be pushed in by the obstacle, otherwise, avoidance agents will be pushed out. Outlines must not cross or overlap.

Obstacles are not a replacement for a (re)baked navigation mesh. Obstacles don't change the resulting path from the pathfinding, obstacles only affect the navigation avoidance agent movement by altering the suggested velocity of the avoidance agent.

Obstacles using vertices can warp to a new position but should not moved every frame as each move requires a rebuild of the avoidance map.

NavigationObstacle3D.MethodName

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

NavigationObstacle3D.PropertyName

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

NavigationObstacle3D.SignalName

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

NavigationPathQueryParameters2D

By changing various properties of this object, such as the start and target position, you can configure path queries to the NavigationServer2D.

NavigationPathQueryParameters2D.MethodName

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

NavigationPathQueryParameters2D.PropertyName

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

NavigationPathQueryParameters2D.SignalName

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

NavigationPathQueryParameters3D

By changing various properties of this object, such as the start and target position, you can configure path queries to the NavigationServer3D.

NavigationPathQueryParameters3D.MethodName

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

NavigationPathQueryParameters3D.PropertyName

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

NavigationPathQueryParameters3D.SignalName

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

NavigationPathQueryResult2D

This class stores the result of a 2D navigation path query from the NavigationServer2D.

NavigationPathQueryResult2D.MethodName

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

NavigationPathQueryResult2D.PropertyName

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

NavigationPathQueryResult2D.SignalName

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

NavigationPathQueryResult3D

This class stores the result of a 3D navigation path query from the NavigationServer3D.

NavigationPathQueryResult3D.MethodName

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

NavigationPathQueryResult3D.PropertyName

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

NavigationPathQueryResult3D.SignalName

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

NavigationPolygon

A navigation mesh can be created either by baking it with the help of the NavigationServer2D, or by adding vertices and convex polygon indices arrays manually.

To bake a navigation mesh at least one outline needs to be added that defines the outer bounds of the baked area.

var newNavigationMesh = new NavigationPolygon();
  var boundingOutline = new Vector2[] { new Vector2(0, 0), new Vector2(0, 50), new Vector2(50, 50), new Vector2(50, 0) };
  newNavigationMesh.AddOutline(boundingOutline);
  NavigationServer2D.BakeFromSourceGeometryData(newNavigationMesh, new NavigationMeshSourceGeometryData2D());
  GetNode<NavigationRegion2D>("NavigationRegion2D").NavigationPolygon = newNavigationMesh;

Adding vertices and polygon indices manually.

var newNavigationMesh = new NavigationPolygon();
  var newVertices = new Vector2[] { new Vector2(0, 0), new Vector2(0, 50), new Vector2(50, 50), new Vector2(50, 0) };
  newNavigationMesh.Vertices = newVertices;
  var newPolygonIndices = new int[] { 0, 1, 2, 3 };
  newNavigationMesh.AddPolygon(newPolygonIndices);
  GetNode<NavigationRegion2D>("NavigationRegion2D").NavigationPolygon = newNavigationMesh;

NavigationPolygon.MethodName

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

NavigationPolygon.PropertyName

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

NavigationPolygon.SignalName

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

NavigationRegion2D

A traversable 2D region based on a NavigationPolygon that NavigationAgent2Ds can use for pathfinding.

Two regions can be connected to each other if they share a similar edge. You can set the minimum distance between two vertices required to connect two edges by using MapSetEdgeConnectionMargin(Rid, float).

Note: Overlapping two regions' navigation polygons is not enough for connecting two regions. They must share a similar edge.

The pathfinding cost of entering a region from another region can be controlled with the EnterCost value.

Note: This value is not added to the path cost when the start position is already inside this region.

The pathfinding cost of traveling distances inside this region can be controlled with the TravelCost multiplier.

Note: This node caches changes to its properties, so if you make changes to the underlying region Rid in NavigationServer2D, they will not be reflected in this node's properties.

NavigationRegion2D.MethodName

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

NavigationRegion2D.PropertyName

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

NavigationRegion2D.SignalName

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

NavigationRegion3D

A traversable 3D region based on a NavigationMesh that NavigationAgent3Ds can use for pathfinding.

Two regions can be connected to each other if they share a similar edge. You can set the minimum distance between two vertices required to connect two edges by using MapSetEdgeConnectionMargin(Rid, float).

Note: Overlapping two regions' navigation meshes is not enough for connecting two regions. They must share a similar edge.

The cost of entering this region from another region can be controlled with the EnterCost value.

Note: This value is not added to the path cost when the start position is already inside this region.

The cost of traveling distances inside this region can be controlled with the TravelCost multiplier.

Note: This node caches changes to its properties, so if you make changes to the underlying region Rid in NavigationServer3D, they will not be reflected in this node's properties.

NavigationRegion3D.MethodName

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

NavigationRegion3D.PropertyName

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

NavigationRegion3D.SignalName

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

NavigationServer2D

NavigationServer2D is the server that handles navigation maps, regions and agents. It does not handle A* navigation from AStar2D or AStarGrid2D.

Maps are made up of regions, which are made of navigation polygons. Together, they define the traversable areas in the 2D world.

Note: Most NavigationServer2D changes take effect after the next physics frame and not immediately. This includes all changes made to maps, regions or agents by navigation-related nodes in the scene tree or made through scripts.

For two regions to be connected to each other, they must share a similar edge. An edge is considered connected to another if both of its two vertices are at a distance less than edge_connection_margin to the respective other edge's vertex.

You may assign navigation layers to regions with RegionSetNavigationLayers(Rid, uint), which then can be checked upon when requesting a path with MapGetPath(Rid, Vector2, Vector2, bool, uint). This can be used to allow or deny certain areas for some objects.

To use the collision avoidance system, you may use agents. You can set an agent's target velocity, then the servers will emit a callback with a modified velocity.

Note: The collision avoidance system ignores regions. Using the modified velocity directly may move an agent outside of the traversable area. This is a limitation of the collision avoidance system, any more complex situation may require the use of the physics engine.

This server keeps tracks of any call and executes them during the sync phase. This means that you can request any change to the map, using any thread, without worrying.

NavigationServer2D.MethodName

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

NavigationServer2D.PropertyName

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

NavigationServer2D.SignalName

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

NavigationServer2DInstance

NavigationServer2D is the server that handles navigation maps, regions and agents. It does not handle A* navigation from AStar2D or AStarGrid2D.

Maps are made up of regions, which are made of navigation polygons. Together, they define the traversable areas in the 2D world.

Note: Most NavigationServer2D changes take effect after the next physics frame and not immediately. This includes all changes made to maps, regions or agents by navigation-related nodes in the scene tree or made through scripts.

For two regions to be connected to each other, they must share a similar edge. An edge is considered connected to another if both of its two vertices are at a distance less than edge_connection_margin to the respective other edge's vertex.

You may assign navigation layers to regions with RegionSetNavigationLayers(Rid, uint), which then can be checked upon when requesting a path with MapGetPath(Rid, Vector2, Vector2, bool, uint). This can be used to allow or deny certain areas for some objects.

To use the collision avoidance system, you may use agents. You can set an agent's target velocity, then the servers will emit a callback with a modified velocity.

Note: The collision avoidance system ignores regions. Using the modified velocity directly may move an agent outside of the traversable area. This is a limitation of the collision avoidance system, any more complex situation may require the use of the physics engine.

This server keeps tracks of any call and executes them during the sync phase. This means that you can request any change to the map, using any thread, without worrying.

NavigationServer2DInstance.MethodName

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

NavigationServer2DInstance.PropertyName

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

NavigationServer2DInstance.SignalName

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

NavigationServer3D

NavigationServer3D is the server that handles navigation maps, regions and agents. It does not handle A* navigation from AStar3D.

Maps are made up of regions, which are made of navigation meshes. Together, they define the navigable areas in the 3D world.

Note: Most NavigationServer3D changes take effect after the next physics frame and not immediately. This includes all changes made to maps, regions or agents by navigation-related nodes in the scene tree or made through scripts.

For two regions to be connected to each other, they must share a similar edge. An edge is considered connected to another if both of its two vertices are at a distance less than edge_connection_margin to the respective other edge's vertex.

You may assign navigation layers to regions with RegionSetNavigationLayers(Rid, uint), which then can be checked upon when requesting a path with MapGetPath(Rid, Vector3, Vector3, bool, uint). This can be used to allow or deny certain areas for some objects.

To use the collision avoidance system, you may use agents. You can set an agent's target velocity, then the servers will emit a callback with a modified velocity.

Note: The collision avoidance system ignores regions. Using the modified velocity directly may move an agent outside of the traversable area. This is a limitation of the collision avoidance system, any more complex situation may require the use of the physics engine.

This server keeps tracks of any call and executes them during the sync phase. This means that you can request any change to the map, using any thread, without worrying.

NavigationServer3D.MethodName

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

NavigationServer3D.PropertyName

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

NavigationServer3D.SignalName

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

NavigationServer3DInstance

NavigationServer3D is the server that handles navigation maps, regions and agents. It does not handle A* navigation from AStar3D.

Maps are made up of regions, which are made of navigation meshes. Together, they define the navigable areas in the 3D world.

Note: Most NavigationServer3D changes take effect after the next physics frame and not immediately. This includes all changes made to maps, regions or agents by navigation-related nodes in the scene tree or made through scripts.

For two regions to be connected to each other, they must share a similar edge. An edge is considered connected to another if both of its two vertices are at a distance less than edge_connection_margin to the respective other edge's vertex.

You may assign navigation layers to regions with RegionSetNavigationLayers(Rid, uint), which then can be checked upon when requesting a path with MapGetPath(Rid, Vector3, Vector3, bool, uint). This can be used to allow or deny certain areas for some objects.

To use the collision avoidance system, you may use agents. You can set an agent's target velocity, then the servers will emit a callback with a modified velocity.

Note: The collision avoidance system ignores regions. Using the modified velocity directly may move an agent outside of the traversable area. This is a limitation of the collision avoidance system, any more complex situation may require the use of the physics engine.

This server keeps tracks of any call and executes them during the sync phase. This means that you can request any change to the map, using any thread, without worrying.

NavigationServer3DInstance.MethodName

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

NavigationServer3DInstance.PropertyName

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

NavigationServer3DInstance.SignalName

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

NinePatchRect

Also known as 9-slice panels, NinePatchRect produces clean panels of any size based on a small texture. To do so, it splits the texture in a 3×3 grid. When you scale the node, it tiles the texture's edges horizontally or vertically, tiles the center on both axes, and leaves the corners unchanged.

NinePatchRect.MethodName

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

NinePatchRect.PropertyName

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

NinePatchRect.SignalName

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

Node

Nodes are Godot's building blocks. They can be assigned as the child of another node, resulting in a tree arrangement. A given node can contain any number of nodes as children with the requirement that all siblings (direct children of a node) should have unique names.

A tree of nodes is called a scene. Scenes can be saved to the disk and then instantiated into other scenes. This allows for very high flexibility in the architecture and data model of Godot projects.

Scene tree: The SceneTree contains the active tree of nodes. When a node is added to the scene tree, it receives the NotificationEnterTree notification and its _EnterTree() callback is triggered. Child nodes are always added after their parent node, i.e. the _EnterTree() callback of a parent node will be triggered before its child's.

Once all nodes have been added in the scene tree, they receive the NotificationReady notification and their respective _Ready() callbacks are triggered. For groups of nodes, the _Ready() callback is called in reverse order, starting with the children and moving up to the parent nodes.

This means that when adding a node to the scene tree, the following order will be used for the callbacks: _EnterTree() of the parent, _EnterTree() of the children, _Ready() of the children and finally _Ready() of the parent (recursively for the entire scene tree).

Processing: Nodes can override the "process" state, so that they receive a callback on each frame requesting them to process (do something). Normal processing (callback _Process(double), toggled with SetProcess(bool)) happens as fast as possible and is dependent on the frame rate, so the processing time delta (in seconds) is passed as an argument. Physics processing (callback _PhysicsProcess(double), toggled with SetPhysicsProcess(bool)) happens a fixed number of times per second (60 by default) and is useful for code related to the physics engine.

Nodes can also process input events. When present, the _Input(InputEvent) function will be called for each input that the program receives. In many cases, this can be overkill (unless used for simple projects), and the _UnhandledInput(InputEvent) function might be preferred; it is called when the input event was not handled by anyone else (typically, GUI Control nodes), ensuring that the node only receives the events that were meant for it.

To keep track of the scene hierarchy (especially when instantiating scenes into other scenes), an "owner" can be set for the node with the Owner property. This keeps track of who instantiated what. This is mostly useful when writing editors and tools, though.

Finally, when a node is freed with Free() or QueueFree(), it will also free all its children.

Groups: Nodes can be added to as many groups as you want to be easy to manage, you could create groups like "enemies" or "collectables" for example, depending on your game. See AddToGroup(StringName, bool), IsInGroup(StringName) and RemoveFromGroup(StringName). You can then retrieve all nodes in these groups, iterate them and even call methods on groups via the methods on SceneTree.

Networking with nodes: After connecting to a server (or making one, see ENetMultiplayerPeer), it is possible to use the built-in RPC (remote procedure call) system to communicate over the network. By calling Rpc(StringName, params Variant[]) with a method name, it will be called locally and in all connected peers (peers = clients and the server that accepts connections). To identify which node receives the RPC call, Godot will use its NodePath (make sure node names are the same on all peers). Also, take a look at the high-level networking tutorial and corresponding demos.

Note: The script property is part of the GodotObject class, not Node. It isn't exposed like most properties but does have a setter and getter (see SetScript(Variant) and GetScript()).

Node.MethodName

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

Node.PropertyName

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

Node.SignalName

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

Node2D

A 2D game object, with a transform (position, rotation, and scale). All 2D nodes, including physics objects and sprites, inherit from Node2D. Use Node2D as a parent node to move, scale and rotate children in a 2D project. Also gives control of the node's render order.

Node2D.MethodName

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

Node2D.PropertyName

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

Node2D.SignalName

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

Node3D

Most basic 3D game object, with a Transform3D and visibility settings. All other 3D game objects inherit from Node3D. Use Node3D as a parent node to move, scale, rotate and show/hide children in a 3D project.

Affine operations (rotate, scale, translate) happen in parent's local coordinate system, unless the Node3D object is set as top-level. Affine operations in this coordinate system correspond to direct affine operations on the Node3D's transform. The word local below refers to this coordinate system. The coordinate system that is attached to the Node3D object itself is referred to as object-local coordinate system.

Note: Unless otherwise specified, all methods that have angle parameters must have angles specified as radians. To convert degrees to radians, use @GlobalScope.deg_to_rad.

Note: Be aware that "Spatial" nodes are now called "Node3D" starting with Godot 4. Any Godot 3.x references to "Spatial" nodes refer to "Node3D" in Godot 4.

Node3D.MethodName

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

Node3D.PropertyName

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

Node3D.SignalName

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

Node3DGizmo

This abstract class helps connect the Node3D scene with the editor-specific EditorNode3DGizmo class.

Node3DGizmo by itself has no exposed API, refer to AddGizmo(Node3DGizmo) and pass it an EditorNode3DGizmo instance.

Node3DGizmo.MethodName

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

Node3DGizmo.PropertyName

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

Node3DGizmo.SignalName

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

NodePath

A pre-parsed relative or absolute path in a scene tree, for use with GetNode(NodePath) and similar functions. It can reference a node, a resource within a node, or a property of a node or resource. For instance, "Path2D/PathFollow2D/Sprite2D:texture:size" would refer to the size property of the texture resource on the node named "Sprite2D" which is a child of the other named nodes in the path. You will usually just pass a string to GetNode(NodePath) and it will be automatically converted, but you may occasionally want to parse a path ahead of time with NodePath. Exporting a NodePath variable will give you a node selection widget in the properties panel of the editor, which can often be useful. A NodePath is composed of a list of slash-separated node names (like a filesystem path) and an optional colon-separated list of "subnames" which can be resources or properties.

Note: In the editor, NodePath properties are automatically updated when moving, renaming or deleting a node in the scene tree, but they are never updated at runtime.

Noise

This class defines the interface for noise generation libraries to inherit from.

A default GetSeamlessImage(int, int, bool, bool, float, bool) implementation is provided for libraries that do not provide seamless noise. This function requests a larger image from the GetImage(int, int, bool, bool, bool) method, reverses the quadrants of the image, then uses the strips of extra width to blend over the seams.

Inheriting noise classes can optionally override this function to provide a more optimal algorithm.

Noise.MethodName

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

Noise.PropertyName

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

Noise.SignalName

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

NoiseTexture2D

Uses the FastNoiseLite library or other noise generators to fill the texture data of your desired size. NoiseTexture2D can also generate normal map textures.

The class uses GodotThreads to generate the texture data internally, so GetImage() may return null if the generation process has not completed yet. In that case, you need to wait for the texture to be generated before accessing the image and the generated byte data:

var texture = NoiseTexture2D.new()
  texture.noise = FastNoiseLite.new()
  await texture.changed
  var image = texture.get_image()
  var data = image.get_data()

NoiseTexture2D.MethodName

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

NoiseTexture2D.PropertyName

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

NoiseTexture2D.SignalName

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

NoiseTexture3D

Uses the FastNoiseLite library or other noise generators to fill the texture data of your desired size.

The class uses GodotThreads to generate the texture data internally, so GetData() may return null if the generation process has not completed yet. In that case, you need to wait for the texture to be generated before accessing the image:

var texture = NoiseTexture3D.new()
  texture.noise = FastNoiseLite.new()
  await texture.changed
  var data = texture.get_data()

NoiseTexture3D.MethodName

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

NoiseTexture3D.PropertyName

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

NoiseTexture3D.SignalName

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

OS

This class wraps the most common functionalities for communicating with the host operating system, such as the video driver, delays, environment variables, execution of binaries, command line, etc.

Note: In Godot 4, OS functions related to window management were moved to the DisplayServer singleton.

OS.MethodName

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

OS.PropertyName

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

OS.SignalName

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

OSInstance

This class wraps the most common functionalities for communicating with the host operating system, such as the video driver, delays, environment variables, execution of binaries, command line, etc.

Note: In Godot 4, OS functions related to window management were moved to the DisplayServer singleton.

OSInstance.MethodName

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

OSInstance.PropertyName

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

OSInstance.SignalName

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

Occluder3D

Occluder3D stores an occluder shape that can be used by the engine's occlusion culling system.

See OccluderInstance3D's documentation for instructions on setting up occlusion culling.

Occluder3D.MethodName

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

Occluder3D.PropertyName

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

Occluder3D.SignalName

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

OccluderInstance3D

Occlusion culling can improve rendering performance in closed/semi-open areas by hiding geometry that is occluded by other objects.

The occlusion culling system is mostly static. OccluderInstance3Ds can be moved or hidden at run-time, but doing so will trigger a background recomputation that can take several frames. It is recommended to only move OccluderInstance3Ds sporadically (e.g. for procedural generation purposes), rather than doing so every frame.

The occlusion culling system works by rendering the occluders on the CPU in parallel using Embree, drawing the result to a low-resolution buffer then using this to cull 3D nodes individually. In the 3D editor, you can preview the occlusion culling buffer by choosing Perspective > Debug Advanced... > Occlusion Culling Buffer in the top-left corner of the 3D viewport. The occlusion culling buffer quality can be adjusted in the Project Settings.

Baking: Select an OccluderInstance3D node, then use the Bake Occluders button at the top of the 3D editor. Only opaque materials will be taken into account; transparent materials (alpha-blended or alpha-tested) will be ignored by the occluder generation.

Note: Occlusion culling is only effective if ProjectSettings.rendering/occlusion_culling/use_occlusion_culling is true. Enabling occlusion culling has a cost on the CPU. Only enable occlusion culling if you actually plan to use it. Large open scenes with few or no objects blocking the view will generally not benefit much from occlusion culling. Large open scenes generally benefit more from mesh LOD and visibility ranges (VisibilityRangeBegin and VisibilityRangeEnd) compared to occlusion culling.

Note: Due to memory constraints, occlusion culling is not supported by default in Web export templates. It can be enabled by compiling custom Web export templates with module_raycast_enabled=yes.

OccluderInstance3D.MethodName

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

OccluderInstance3D.PropertyName

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

OccluderInstance3D.SignalName

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

OccluderPolygon2D

Editor facility that helps you draw a 2D polygon used as resource for LightOccluder2D.

OccluderPolygon2D.MethodName

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

OccluderPolygon2D.PropertyName

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

OccluderPolygon2D.SignalName

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

OfflineMultiplayerPeer

This is the default MultiplayerPeer for the Multiplayer. It mimics the behavior of a server with no peers connected.

This means that the SceneTree will act as the multiplayer authority by default. Calls to IsServer() will return true, and calls to GetUniqueId() will return TargetPeerServer.

OfflineMultiplayerPeer.MethodName

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

OfflineMultiplayerPeer.PropertyName

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

OfflineMultiplayerPeer.SignalName

Cached StringNames for the signals contained in this class, for fast lookup.

OggPacketSequence

A sequence of Ogg packets.

OggPacketSequence.MethodName

Cached StringNames for the methods contained in this class, for fast lookup.

OggPacketSequence.PropertyName

Cached StringNames for the properties and fields contained in this class, for fast lookup.

OggPacketSequence.SignalName

Cached StringNames for the signals contained in this class, for fast lookup.

OggPacketSequencePlayback

OggPacketSequencePlayback.MethodName

Cached StringNames for the methods contained in this class, for fast lookup.

OggPacketSequencePlayback.PropertyName

Cached StringNames for the properties and fields contained in this class, for fast lookup.

OggPacketSequencePlayback.SignalName

Cached StringNames for the signals contained in this class, for fast lookup.

OmniLight3D

An Omnidirectional light is a type of Light3D that emits light in all directions. The light is attenuated by distance and this attenuation can be configured by changing its energy, radius, and attenuation parameters.

Note: When using the Mobile rendering method, only 8 omni lights can be displayed on each mesh resource. Attempting to display more than 8 omni lights on a single mesh resource will result in omni lights flickering in and out as the camera moves. When using the Compatibility rendering method, only 8 omni lights can be displayed on each mesh resource by default, but this can be increased by adjusting ProjectSettings.rendering/limits/opengl/max_lights_per_object.

Note: When using the Mobile or Compatibility rendering methods, omni lights will only correctly affect meshes whose visibility AABB intersects with the light's AABB. If using a shader to deform the mesh in a way that makes it go outside its AABB, ExtraCullMargin must be increased on the mesh. Otherwise, the light may not be visible on the mesh.

OmniLight3D.MethodName

Cached StringNames for the methods contained in this class, for fast lookup.

OmniLight3D.PropertyName

Cached StringNames for the properties and fields contained in this class, for fast lookup.

OmniLight3D.SignalName

Cached StringNames for the signals contained in this class, for fast lookup.

OpenXRAction

This resource defines an OpenXR action. Actions can be used both for inputs (buttons/joystick/trigger/etc) and outputs (haptics).

OpenXR performs automatic conversion between action type and input type whenever possible. An analog trigger bound to a boolean action will thus return false if the trigger is depressed and true if pressed fully.

Actions are not directly bound to specific devices, instead OpenXR recognizes a limited number of top level paths that identify devices by usage. We can restrict which devices an action can be bound to by these top level paths. For instance an action that should only be used for hand held controllers can have the top level paths "/user/hand/left" and "/user/hand/right" associated with them. See the reserved path section in the OpenXR specification for more info on the top level paths.

Note that the name of the resource is used to register the action with.

OpenXRAction.MethodName

Cached StringNames for the methods contained in this class, for fast lookup.

OpenXRAction.PropertyName

Cached StringNames for the properties and fields contained in this class, for fast lookup.

OpenXRAction.SignalName

Cached StringNames for the signals contained in this class, for fast lookup.

OpenXRActionMap

OpenXR uses an action system similar to Godots Input map system to bind inputs and outputs on various types of XR controllers to named actions. OpenXR specifies more detail on these inputs and outputs than Godot supports.

Another important distinction is that OpenXR offers no control over these bindings. The bindings we register are suggestions, it is up to the XR runtime to offer users the ability to change these bindings. This allows the XR runtime to fill in the gaps if new hardware becomes available.

The action map therefore needs to be loaded at startup and can't be changed afterwards. This resource is a container for the entire action map.

OpenXRActionMap.MethodName

Cached StringNames for the methods contained in this class, for fast lookup.

OpenXRActionMap.PropertyName

Cached StringNames for the properties and fields contained in this class, for fast lookup.

OpenXRActionMap.SignalName

Cached StringNames for the signals contained in this class, for fast lookup.

OpenXRActionSet

Action sets in OpenXR define a collection of actions that can be activated in unison. This allows games to easily change between different states that require different inputs or need to reinterpret inputs. For instance we could have an action set that is active when a menu is open, an action set that is active when the player is freely walking around and an action set that is active when the player is controlling a vehicle.

Action sets can contain the same action with the same name, if such action sets are active at the same time the action set with the highest priority defines which binding is active.

OpenXRActionSet.MethodName

Cached StringNames for the methods contained in this class, for fast lookup.

OpenXRActionSet.PropertyName

Cached StringNames for the properties and fields contained in this class, for fast lookup.

OpenXRActionSet.SignalName

Cached StringNames for the signals contained in this class, for fast lookup.

OpenXRApiExtension

OpenXRApiExtension makes OpenXR available for GDExtension. It provides the OpenXR API to GDExtension through the GetInstanceProcAddr(string) method, and the OpenXR instance through GetInstance().

It also provides methods for querying the status of OpenXR initialization, and helper methods for ease of use of the API with GDExtension.

OpenXRApiExtension.MethodName

Cached StringNames for the methods contained in this class, for fast lookup.

OpenXRApiExtension.PropertyName

Cached StringNames for the properties and fields contained in this class, for fast lookup.

OpenXRApiExtension.SignalName

Cached StringNames for the signals contained in this class, for fast lookup.

OpenXRExtensionWrapperExtension

OpenXRExtensionWrapperExtension allows clients to implement OpenXR extensions with GDExtension. The extension should be registered with RegisterExtensionWrapper().

OpenXRExtensionWrapperExtension.MethodName

Cached StringNames for the methods contained in this class, for fast lookup.

OpenXRExtensionWrapperExtension.PropertyName

Cached StringNames for the properties and fields contained in this class, for fast lookup.

OpenXRExtensionWrapperExtension.SignalName

Cached StringNames for the signals contained in this class, for fast lookup.

OpenXRHand

This node enables OpenXR's hand tracking functionality. The node should be a child node of an XROrigin3D node, tracking will update its position to where the player's actual hand is positioned. This node also updates the skeleton of a properly skinned hand model. The hand mesh should be a child node of this node.

OpenXRHand.MethodName

Cached StringNames for the methods contained in this class, for fast lookup.

OpenXRHand.PropertyName

Cached StringNames for the properties and fields contained in this class, for fast lookup.

OpenXRHand.SignalName

Cached StringNames for the signals contained in this class, for fast lookup.

OpenXRIPBinding

This binding resource binds an OpenXRAction to inputs or outputs. As most controllers have left hand and right versions that are handled by the same interaction profile we can specify multiple bindings. For instance an action "Fire" could be bound to both "/user/hand/left/input/trigger" and "/user/hand/right/input/trigger".

OpenXRIPBinding.MethodName

Cached StringNames for the methods contained in this class, for fast lookup.

OpenXRIPBinding.PropertyName

Cached StringNames for the properties and fields contained in this class, for fast lookup.

OpenXRIPBinding.SignalName

Cached StringNames for the signals contained in this class, for fast lookup.

OpenXRInteractionProfile

This object stores suggested bindings for an interaction profile. Interaction profiles define the metadata for a tracked XR device such as an XR controller.

For more information see the interaction profiles info in the OpenXR specification.

OpenXRInteractionProfile.MethodName

Cached StringNames for the methods contained in this class, for fast lookup.

OpenXRInteractionProfile.PropertyName

Cached StringNames for the properties and fields contained in this class, for fast lookup.

OpenXRInteractionProfile.SignalName

Cached StringNames for the signals contained in this class, for fast lookup.

OpenXRInteractionProfileMetadata

This class allows OpenXR core and extensions to register metadata relating to supported interaction devices such as controllers, trackers, haptic devices, etc. It is primarily used by the action map editor and to sanitize any action map by removing extension-dependent entries when applicable.

OpenXRInteractionProfileMetadata.MethodName

Cached StringNames for the methods contained in this class, for fast lookup.

OpenXRInteractionProfileMetadata.PropertyName

Cached StringNames for the properties and fields contained in this class, for fast lookup.

OpenXRInteractionProfileMetadata.SignalName

Cached StringNames for the signals contained in this class, for fast lookup.

OpenXRInterface

The OpenXR interface allows Godot to interact with OpenXR runtimes and make it possible to create XR experiences and games.

Due to the needs of OpenXR this interface works slightly different than other plugin based XR interfaces. It needs to be initialized when Godot starts. You need to enable OpenXR, settings for this can be found in your games project settings under the XR heading. You do need to mark a viewport for use with XR in order for Godot to know which render result should be output to the headset.

OpenXRInterface.MethodName

Cached StringNames for the methods contained in this class, for fast lookup.

OpenXRInterface.PropertyName

Cached StringNames for the properties and fields contained in this class, for fast lookup.

OpenXRInterface.SignalName

Cached StringNames for the signals contained in this class, for fast lookup.

OptimizedTranslation

An optimized translation, used by default for CSV Translations. Uses real-time compressed translations, which results in very small dictionaries.

OptimizedTranslation.MethodName

Cached StringNames for the methods contained in this class, for fast lookup.

OptimizedTranslation.PropertyName

Cached StringNames for the properties and fields contained in this class, for fast lookup.

OptimizedTranslation.SignalName

Cached StringNames for the signals contained in this class, for fast lookup.

OptionButton

OptionButton is a type of button that brings up a dropdown with selectable items when pressed. The item selected becomes the "current" item and is displayed as the button text.

See also BaseButton which contains common properties and methods associated with this node.

Note: The ID values used for items are limited to 32 bits, not full 64 bits of int. This has a range of -2^32 to 2^32 - 1, i.e. -2147483648 to 2147483647.

Note: The Text and Icon properties are set automatically based on the selected item. They shouldn't be changed manually.

OptionButton.MethodName

Cached StringNames for the methods contained in this class, for fast lookup.

OptionButton.PropertyName

Cached StringNames for the properties and fields contained in this class, for fast lookup.

OptionButton.SignalName

Cached StringNames for the signals contained in this class, for fast lookup.

OrmMaterial3D

ORMMaterial3D's properties are inherited from BaseMaterial3D. Unlike StandardMaterial3D, ORMMaterial3D uses a single texture for ambient occlusion, roughness and metallic maps, known as an ORM texture.

OrmMaterial3D.MethodName

Cached StringNames for the methods contained in this class, for fast lookup.

OrmMaterial3D.PropertyName

Cached StringNames for the properties and fields contained in this class, for fast lookup.

OrmMaterial3D.SignalName

Cached StringNames for the signals contained in this class, for fast lookup.

PackedDataContainer

PackedDataContainer can be used to efficiently store data from untyped containers. The data is packed into raw bytes and can be saved to file. Only Array and Dictionary can be stored this way.

You can retrieve the data by iterating on the container, which will work as if iterating on the packed data itself. If the packed container is a Dictionary, the data can be retrieved by key names (string/StringName only).

var data = { "key": "value", "another_key": 123, "lock": Vector2() }
  var packed = PackedDataContainer.new()
  packed.pack(data)
  ResourceSaver.save(packed, "packed_data.res")

var container = load("packed_data.res")
  for key in container:
      prints(key, container[key])
Prints:
key value
lock (0, 0)
another_key 123

Nested containers will be packed recursively. While iterating, they will be returned as PackedDataContainerRef.

PackedDataContainer.MethodName

Cached StringNames for the methods contained in this class, for fast lookup.

PackedDataContainer.PropertyName

Cached StringNames for the properties and fields contained in this class, for fast lookup.

PackedDataContainer.SignalName

Cached StringNames for the signals contained in this class, for fast lookup.

PackedDataContainerRef

When packing nested containers using PackedDataContainer, they are recursively packed into PackedDataContainerRef (only applies to Array and Dictionary). Their data can be retrieved the same way as from PackedDataContainer.

var packed = PackedDataContainer.new()
  packed.pack([1, 2, 3, ["abc", "def"], 4, 5, 6])
for element in packed:
if element is PackedDataContainerRef:
for subelement in element:
print("::", subelement)
else:
print(element)
Prints:
1
2
3
::abc
::def
4
5
6

PackedDataContainerRef.MethodName

Cached StringNames for the methods contained in this class, for fast lookup.

PackedDataContainerRef.PropertyName

Cached StringNames for the properties and fields contained in this class, for fast lookup.

PackedDataContainerRef.SignalName

Cached StringNames for the signals contained in this class, for fast lookup.

PackedScene

A simplified interface to a scene file. Provides access to operations and checks that can be performed on the scene resource itself.

Can be used to save a node to a file. When saving, the node as well as all the nodes it owns get saved (see Owner property).

Note: The node doesn't need to own itself.

Example of loading a saved scene:

// C# has no preload, so you have to always use ResourceLoader.Load<PackedScene>().
  var scene = ResourceLoader.Load<PackedScene>("res://scene.tscn").Instantiate();
  // Add the node as a child of the node the script is attached to.
  AddChild(scene);

Example of saving a node with different owners: The following example creates 3 objects: Node2D (node), RigidBody2D (body) and CollisionObject2D (collision). collision is a child of body which is a child of node. Only body is owned by node and Pack(Node) will therefore only save those two nodes, but not collision.

// Create the objects.
  var node = new Node2D();
  var body = new RigidBody2D();
  var collision = new CollisionShape2D();
// Create the object hierarchy.
body.AddChild(collision);
node.AddChild(body);
// Change owner of body, but not of collision.
body.Owner = node;
var scene = new PackedScene();
// Only node and body are now packed.
Error result = scene.Pack(node);
if (result == Error.Ok)
{
Error error = ResourceSaver.Save(scene, "res://path/name.tscn"); // Or "user://..."
if (error != Error.Ok)
{
GD.PushError("An error occurred while saving the scene to disk.");
}
}

PackedScene.MethodName

Cached StringNames for the methods contained in this class, for fast lookup.

PackedScene.PropertyName

Cached StringNames for the properties and fields contained in this class, for fast lookup.

PackedScene.SignalName

Cached StringNames for the signals contained in this class, for fast lookup.

PacketPeer

PacketPeer is an abstraction and base class for packet-based protocols (such as UDP). It provides an API for sending and receiving packets both as raw data or variables. This makes it easy to transfer data over a protocol, without having to encode data as low-level bytes or having to worry about network ordering.

Note: When exporting to Android, make sure to enable the INTERNET permission in the Android export preset before exporting the project or using one-click deploy. Otherwise, network communication of any kind will be blocked by Android.

PacketPeer.MethodName

Cached StringNames for the methods contained in this class, for fast lookup.

PacketPeer.PropertyName

Cached StringNames for the properties and fields contained in this class, for fast lookup.

PacketPeer.SignalName

Cached StringNames for the signals contained in this class, for fast lookup.

PacketPeerDtls

This class represents a DTLS peer connection. It can be used to connect to a DTLS server, and is returned by TakeConnection(PacketPeerUdp).

Note: When exporting to Android, make sure to enable the INTERNET permission in the Android export preset before exporting the project or using one-click deploy. Otherwise, network communication of any kind will be blocked by Android.

Warning: TLS certificate revocation and certificate pinning are currently not supported. Revoked certificates are accepted as long as they are otherwise valid. If this is a concern, you may want to use automatically managed certificates with a short validity period.

PacketPeerDtls.MethodName

Cached StringNames for the methods contained in this class, for fast lookup.

PacketPeerDtls.PropertyName

Cached StringNames for the properties and fields contained in this class, for fast lookup.

PacketPeerDtls.SignalName

Cached StringNames for the signals contained in this class, for fast lookup.

PacketPeerExtension

PacketPeerExtension.MethodName

Cached StringNames for the methods contained in this class, for fast lookup.

PacketPeerExtension.PropertyName

Cached StringNames for the properties and fields contained in this class, for fast lookup.

PacketPeerExtension.SignalName

Cached StringNames for the signals contained in this class, for fast lookup.

PacketPeerStream

PacketStreamPeer provides a wrapper for working using packets over a stream. This allows for using packet based code with StreamPeers. PacketPeerStream implements a custom protocol over the StreamPeer, so the user should not read or write to the wrapped StreamPeer directly.

Note: When exporting to Android, make sure to enable the INTERNET permission in the Android export preset before exporting the project or using one-click deploy. Otherwise, network communication of any kind will be blocked by Android.

PacketPeerStream.MethodName

Cached StringNames for the methods contained in this class, for fast lookup.

PacketPeerStream.PropertyName

Cached StringNames for the properties and fields contained in this class, for fast lookup.

PacketPeerStream.SignalName

Cached StringNames for the signals contained in this class, for fast lookup.

PacketPeerUdp

UDP packet peer. Can be used to send raw UDP packets as well as Variants.

Note: When exporting to Android, make sure to enable the INTERNET permission in the Android export preset before exporting the project or using one-click deploy. Otherwise, network communication of any kind will be blocked by Android.

PacketPeerUdp.MethodName

Cached StringNames for the methods contained in this class, for fast lookup.

PacketPeerUdp.PropertyName

Cached StringNames for the properties and fields contained in this class, for fast lookup.

PacketPeerUdp.SignalName

Cached StringNames for the signals contained in this class, for fast lookup.

Panel

Panel is a GUI control that displays a StyleBox. See also PanelContainer.

Panel.MethodName

Cached StringNames for the methods contained in this class, for fast lookup.

Panel.PropertyName

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Panel.SignalName

Cached StringNames for the signals contained in this class, for fast lookup.

PanelContainer

A container that keeps its child controls within the area of a StyleBox. Useful for giving controls an outline.

PanelContainer.MethodName

Cached StringNames for the methods contained in this class, for fast lookup.

PanelContainer.PropertyName

Cached StringNames for the properties and fields contained in this class, for fast lookup.

PanelContainer.SignalName

Cached StringNames for the signals contained in this class, for fast lookup.

PanoramaSkyMaterial

A resource referenced in a Sky that is used to draw a background. PanoramaSkyMaterial functions similar to skyboxes in other engines, except it uses an equirectangular sky map instead of a Cubemap.

Using an HDR panorama is strongly recommended for accurate, high-quality reflections. Godot supports the Radiance HDR (.hdr) and OpenEXR (.exr) image formats for this purpose.

You can use this tool to convert a cubemap to an equirectangular sky map.

PanoramaSkyMaterial.MethodName

Cached StringNames for the methods contained in this class, for fast lookup.

PanoramaSkyMaterial.PropertyName

Cached StringNames for the properties and fields contained in this class, for fast lookup.

PanoramaSkyMaterial.SignalName

Cached StringNames for the signals contained in this class, for fast lookup.

ParallaxBackground

A ParallaxBackground uses one or more ParallaxLayer child nodes to create a parallax effect. Each ParallaxLayer can move at a different speed using MotionOffset. This creates an illusion of depth in a 2D game. If not used with a Camera2D, you must manually calculate the ScrollOffset.

Note: Each ParallaxBackground is drawn on one specific Viewport and cannot be shared between multiple Viewports, see CustomViewport. When using multiple Viewports, for example in a split-screen game, you need create an individual ParallaxBackground for each Viewport you want it to be drawn on.

ParallaxBackground.MethodName

Cached StringNames for the methods contained in this class, for fast lookup.

ParallaxBackground.PropertyName

Cached StringNames for the properties and fields contained in this class, for fast lookup.

ParallaxBackground.SignalName

Cached StringNames for the signals contained in this class, for fast lookup.

ParallaxLayer

A ParallaxLayer must be the child of a ParallaxBackground node. Each ParallaxLayer can be set to move at different speeds relative to the camera movement or the ScrollOffset value.

This node's children will be affected by its scroll offset.

Note: Any changes to this node's position and scale made after it enters the scene will be ignored.

ParallaxLayer.MethodName

Cached StringNames for the methods contained in this class, for fast lookup.

ParallaxLayer.PropertyName

Cached StringNames for the properties and fields contained in this class, for fast lookup.

ParallaxLayer.SignalName

Cached StringNames for the signals contained in this class, for fast lookup.

ParticleProcessMaterial

ParticleProcessMaterial defines particle properties and behavior. It is used in the process_material of the GpuParticles2D and GpuParticles3D nodes. Some of this material's properties are applied to each particle when emitted, while others can have a CurveTexture or a GradientTexture1D applied to vary numerical or color values over the lifetime of the particle.

ParticleProcessMaterial.MethodName

Cached StringNames for the methods contained in this class, for fast lookup.

ParticleProcessMaterial.PropertyName

Cached StringNames for the properties and fields contained in this class, for fast lookup.

ParticleProcessMaterial.SignalName

Cached StringNames for the signals contained in this class, for fast lookup.

Path2D

Can have PathFollow2D child nodes moving along the Curve2D. See PathFollow2D for more information on usage.

Note: The path is considered as relative to the moved nodes (children of PathFollow2D). As such, the curve should usually start with a zero vector ((0, 0)).

Path2D.MethodName

Cached StringNames for the methods contained in this class, for fast lookup.

Path2D.PropertyName

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Path2D.SignalName

Cached StringNames for the signals contained in this class, for fast lookup.

Path3D

Can have PathFollow3D child nodes moving along the Curve3D. See PathFollow3D for more information on the usage.

Note that the path is considered as relative to the moved nodes (children of PathFollow3D). As such, the curve should usually start with a zero vector (0, 0, 0).

Path3D.MethodName

Cached StringNames for the methods contained in this class, for fast lookup.

Path3D.PropertyName

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Path3D.SignalName

Cached StringNames for the signals contained in this class, for fast lookup.

PathFollow2D

This node takes its parent Path2D, and returns the coordinates of a point within it, given a distance from the first vertex.

It is useful for making other nodes follow a path, without coding the movement pattern. For that, the nodes must be children of this node. The descendant nodes will then move accordingly when setting the Progress in this node.

PathFollow2D.MethodName

Cached StringNames for the methods contained in this class, for fast lookup.

PathFollow2D.PropertyName

Cached StringNames for the properties and fields contained in this class, for fast lookup.

PathFollow2D.SignalName

Cached StringNames for the signals contained in this class, for fast lookup.

PathFollow3D

This node takes its parent Path3D, and returns the coordinates of a point within it, given a distance from the first vertex.

It is useful for making other nodes follow a path, without coding the movement pattern. For that, the nodes must be children of this node. The descendant nodes will then move accordingly when setting the Progress in this node.

PathFollow3D.MethodName

Cached StringNames for the methods contained in this class, for fast lookup.

PathFollow3D.PropertyName

Cached StringNames for the properties and fields contained in this class, for fast lookup.

PathFollow3D.SignalName

Cached StringNames for the signals contained in this class, for fast lookup.

PckPacker

The PckPacker is used to create packages that can be loaded into a running project using LoadResourcePack(string, bool, int).

var packer = new PckPacker();
  packer.PckStart("test.pck");
  packer.AddFile("res://text.txt", "text.txt");
  packer.Flush();

The above PckPacker creates package test.pck, then adds a file named text.txt at the root of the package.

PckPacker.MethodName

Cached StringNames for the methods contained in this class, for fast lookup.

PckPacker.PropertyName

Cached StringNames for the properties and fields contained in this class, for fast lookup.

PckPacker.SignalName

Cached StringNames for the signals contained in this class, for fast lookup.

Performance

This class provides access to a number of different monitors related to performance, such as memory usage, draw calls, and FPS. These are the same as the values displayed in the Monitor tab in the editor's Debugger panel. By using the GetMonitor(Monitor) method of this class, you can access this data from your code.

You can add custom monitors using the AddCustomMonitor(StringName, Callable, Array) method. Custom monitors are available in Monitor tab in the editor's Debugger panel together with built-in monitors.

Note: Some of the built-in monitors are only available in debug mode and will always return 0 when used in a project exported in release mode.

Note: Some of the built-in monitors are not updated in real-time for performance reasons, so there may be a delay of up to 1 second between changes.

Note: Custom monitors do not support negative values. Negative values are clamped to 0.

Performance.MethodName

Cached StringNames for the methods contained in this class, for fast lookup.

Performance.PropertyName

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Performance.SignalName

Cached StringNames for the signals contained in this class, for fast lookup.

PerformanceInstance

This class provides access to a number of different monitors related to performance, such as memory usage, draw calls, and FPS. These are the same as the values displayed in the Monitor tab in the editor's Debugger panel. By using the GetMonitor(Monitor) method of this class, you can access this data from your code.

You can add custom monitors using the AddCustomMonitor(StringName, Callable, Array) method. Custom monitors are available in Monitor tab in the editor's Debugger panel together with built-in monitors.

Note: Some of the built-in monitors are only available in debug mode and will always return 0 when used in a project exported in release mode.

Note: Some of the built-in monitors are not updated in real-time for performance reasons, so there may be a delay of up to 1 second between changes.

Note: Custom monitors do not support negative values. Negative values are clamped to 0.

PerformanceInstance.MethodName

Cached StringNames for the methods contained in this class, for fast lookup.

PerformanceInstance.PropertyName

Cached StringNames for the properties and fields contained in this class, for fast lookup.

PerformanceInstance.SignalName

Cached StringNames for the signals contained in this class, for fast lookup.

PhysicalBone2D

The PhysicalBone2D node is a RigidBody2D-based node that can be used to make Bone2Ds in a Skeleton2D react to physics.

Note: To make the Bone2Ds visually follow the PhysicalBone2D node, use a SkeletonModification2DPhysicalBones modification on the Skeleton2D parent.

Note: The PhysicalBone2D node does not automatically create a Joint2D node to keep PhysicalBone2D nodes together. They must be created manually. For most cases, you want to use a PinJoint2D node. The PhysicalBone2D node will automatically configure the Joint2D node once it's been added as a child node.

PhysicalBone2D.MethodName

Cached StringNames for the methods contained in this class, for fast lookup.

PhysicalBone2D.PropertyName

Cached StringNames for the properties and fields contained in this class, for fast lookup.

PhysicalBone2D.SignalName

Cached StringNames for the signals contained in this class, for fast lookup.

PhysicalBone3D

The PhysicalBone3D node is a physics body that can be used to make bones in a Skeleton3D react to physics.

PhysicalBone3D.MethodName

Cached StringNames for the methods contained in this class, for fast lookup.

PhysicalBone3D.PropertyName

Cached StringNames for the properties and fields contained in this class, for fast lookup.

PhysicalBone3D.SignalName

Cached StringNames for the signals contained in this class, for fast lookup.

PhysicalSkyMaterial

The PhysicalSkyMaterial uses the Preetham analytic daylight model to draw a sky based on physical properties. This results in a substantially more realistic sky than the ProceduralSkyMaterial, but it is slightly slower and less flexible.

The PhysicalSkyMaterial only supports one sun. The color, energy, and direction of the sun are taken from the first DirectionalLight3D in the scene tree.

As it is based on a daylight model, the sky fades to black as the sunset ends. If you want a full day/night cycle, you will have to add a night sky by converting this to a ShaderMaterial and adding a night sky directly into the resulting shader.

PhysicalSkyMaterial.MethodName

Cached StringNames for the methods contained in this class, for fast lookup.

PhysicalSkyMaterial.PropertyName

Cached StringNames for the properties and fields contained in this class, for fast lookup.

PhysicalSkyMaterial.SignalName

Cached StringNames for the signals contained in this class, for fast lookup.

PhysicsBody2D

PhysicsBody2D is an abstract base class for 2D game objects affected by physics. All 2D physics bodies inherit from it.

PhysicsBody2D.MethodName

Cached StringNames for the methods contained in this class, for fast lookup.

PhysicsBody2D.PropertyName

Cached StringNames for the properties and fields contained in this class, for fast lookup.

PhysicsBody2D.SignalName

Cached StringNames for the signals contained in this class, for fast lookup.

PhysicsBody3D

PhysicsBody3D is an abstract base class for 3D game objects affected by physics. All 3D physics bodies inherit from it.

Warning: With a non-uniform scale, this node will likely not behave as expected. It is advised to keep its scale the same on all axes and adjust its collision shape(s) instead.

PhysicsBody3D.MethodName

Cached StringNames for the methods contained in this class, for fast lookup.

PhysicsBody3D.PropertyName

Cached StringNames for the properties and fields contained in this class, for fast lookup.

PhysicsBody3D.SignalName

Cached StringNames for the signals contained in this class, for fast lookup.

PhysicsDirectBodyState2D

Provides direct access to a physics body in the PhysicsServer2D, allowing safe changes to physics properties. This object is passed via the direct state callback of RigidBody2D, and is intended for changing the direct state of that body. See _IntegrateForces(PhysicsDirectBodyState2D).

PhysicsDirectBodyState2D.MethodName

Cached StringNames for the methods contained in this class, for fast lookup.

PhysicsDirectBodyState2D.PropertyName

Cached StringNames for the properties and fields contained in this class, for fast lookup.

PhysicsDirectBodyState2D.SignalName

Cached StringNames for the signals contained in this class, for fast lookup.

PhysicsDirectBodyState2DExtension

This class extends PhysicsDirectBodyState2D by providing additional virtual methods that can be overridden. When these methods are overridden, they will be called instead of the internal methods of the physics server.

Intended for use with GDExtension to create custom implementations of PhysicsDirectBodyState2D.

PhysicsDirectBodyState2DExtension.MethodName

Cached StringNames for the methods contained in this class, for fast lookup.

PhysicsDirectBodyState2DExtension.PropertyName

Cached StringNames for the properties and fields contained in this class, for fast lookup.

PhysicsDirectBodyState2DExtension.SignalName

Cached StringNames for the signals contained in this class, for fast lookup.

PhysicsDirectBodyState3D

Provides direct access to a physics body in the PhysicsServer3D, allowing safe changes to physics properties. This object is passed via the direct state callback of RigidBody3D, and is intended for changing the direct state of that body. See _IntegrateForces(PhysicsDirectBodyState3D).

PhysicsDirectBodyState3D.MethodName

Cached StringNames for the methods contained in this class, for fast lookup.

PhysicsDirectBodyState3D.PropertyName

Cached StringNames for the properties and fields contained in this class, for fast lookup.

PhysicsDirectBodyState3D.SignalName

Cached StringNames for the signals contained in this class, for fast lookup.

PhysicsDirectBodyState3DExtension

This class extends PhysicsDirectBodyState3D by providing additional virtual methods that can be overridden. When these methods are overridden, they will be called instead of the internal methods of the physics server.

Intended for use with GDExtension to create custom implementations of PhysicsDirectBodyState3D.

PhysicsDirectBodyState3DExtension.MethodName

Cached StringNames for the methods contained in this class, for fast lookup.

PhysicsDirectBodyState3DExtension.PropertyName

Cached StringNames for the properties and fields contained in this class, for fast lookup.

PhysicsDirectBodyState3DExtension.SignalName

Cached StringNames for the signals contained in this class, for fast lookup.

PhysicsDirectSpaceState2D

Provides direct access to a physics space in the PhysicsServer2D. It's used mainly to do queries against objects and areas residing in a given space.

PhysicsDirectSpaceState2D.MethodName

Cached StringNames for the methods contained in this class, for fast lookup.

PhysicsDirectSpaceState2D.PropertyName

Cached StringNames for the properties and fields contained in this class, for fast lookup.

PhysicsDirectSpaceState2D.SignalName

Cached StringNames for the signals contained in this class, for fast lookup.

PhysicsDirectSpaceState2DExtension

This class extends PhysicsDirectSpaceState2D by providing additional virtual methods that can be overridden. When these methods are overridden, they will be called instead of the internal methods of the physics server.

Intended for use with GDExtension to create custom implementations of PhysicsDirectSpaceState2D.

PhysicsDirectSpaceState2DExtension.MethodName

Cached StringNames for the methods contained in this class, for fast lookup.

PhysicsDirectSpaceState2DExtension.PropertyName

Cached StringNames for the properties and fields contained in this class, for fast lookup.

PhysicsDirectSpaceState2DExtension.SignalName

Cached StringNames for the signals contained in this class, for fast lookup.

PhysicsDirectSpaceState3D

Provides direct access to a physics space in the PhysicsServer3D. It's used mainly to do queries against objects and areas residing in a given space.

PhysicsDirectSpaceState3D.MethodName

Cached StringNames for the methods contained in this class, for fast lookup.

PhysicsDirectSpaceState3D.PropertyName

Cached StringNames for the properties and fields contained in this class, for fast lookup.

PhysicsDirectSpaceState3D.SignalName

Cached StringNames for the signals contained in this class, for fast lookup.

PhysicsDirectSpaceState3DExtension

This class extends PhysicsDirectSpaceState3D by providing additional virtual methods that can be overridden. When these methods are overridden, they will be called instead of the internal methods of the physics server.

Intended for use with GDExtension to create custom implementations of PhysicsDirectSpaceState3D.

PhysicsDirectSpaceState3DExtension.MethodName

Cached StringNames for the methods contained in this class, for fast lookup.

PhysicsDirectSpaceState3DExtension.PropertyName

Cached StringNames for the properties and fields contained in this class, for fast lookup.

PhysicsDirectSpaceState3DExtension.SignalName

Cached StringNames for the signals contained in this class, for fast lookup.

PhysicsMaterial

Holds physics-related properties of a surface, namely its roughness and bounciness. This class is used to apply these properties to a physics body.

PhysicsMaterial.MethodName

Cached StringNames for the methods contained in this class, for fast lookup.

PhysicsMaterial.PropertyName

Cached StringNames for the properties and fields contained in this class, for fast lookup.

PhysicsMaterial.SignalName

Cached StringNames for the signals contained in this class, for fast lookup.

PhysicsPointQueryParameters2D

By changing various properties of this object, such as the point position, you can configure the parameters for IntersectPoint(PhysicsPointQueryParameters2D, int).

PhysicsPointQueryParameters2D.MethodName

Cached StringNames for the methods contained in this class, for fast lookup.

PhysicsPointQueryParameters2D.PropertyName

Cached StringNames for the properties and fields contained in this class, for fast lookup.

PhysicsPointQueryParameters2D.SignalName

Cached StringNames for the signals contained in this class, for fast lookup.

PhysicsPointQueryParameters3D

By changing various properties of this object, such as the point position, you can configure the parameters for IntersectPoint(PhysicsPointQueryParameters3D, int).

PhysicsPointQueryParameters3D.MethodName

Cached StringNames for the methods contained in this class, for fast lookup.

PhysicsPointQueryParameters3D.PropertyName

Cached StringNames for the properties and fields contained in this class, for fast lookup.

PhysicsPointQueryParameters3D.SignalName

Cached StringNames for the signals contained in this class, for fast lookup.

PhysicsRayQueryParameters2D

By changing various properties of this object, such as the ray position, you can configure the parameters for IntersectRay(PhysicsRayQueryParameters2D).

PhysicsRayQueryParameters2D.MethodName

Cached StringNames for the methods contained in this class, for fast lookup.

PhysicsRayQueryParameters2D.PropertyName

Cached StringNames for the properties and fields contained in this class, for fast lookup.

PhysicsRayQueryParameters2D.SignalName

Cached StringNames for the signals contained in this class, for fast lookup.

PhysicsRayQueryParameters3D

By changing various properties of this object, such as the ray position, you can configure the parameters for IntersectRay(PhysicsRayQueryParameters3D).

PhysicsRayQueryParameters3D.MethodName

Cached StringNames for the methods contained in this class, for fast lookup.

PhysicsRayQueryParameters3D.PropertyName

Cached StringNames for the properties and fields contained in this class, for fast lookup.

PhysicsRayQueryParameters3D.SignalName

Cached StringNames for the signals contained in this class, for fast lookup.

PhysicsServer2D

PhysicsServer2D is the server responsible for all 2D physics. It can directly create and manipulate all physics objects:

- A space is a self-contained world for a physics simulation. It contains bodies, areas, and joints. Its state can be queried for collision and intersection information, and several parameters of the simulation can be modified.

- A shape is a geometric shape such as a circle, a rectangle, a capsule, or a polygon. It can be used for collision detection by adding it to a body/area, possibly with an extra transformation relative to the body/area's origin. Bodies/areas can have multiple (transformed) shapes added to them, and a single shape can be added to bodies/areas multiple times with different local transformations.

- A body is a physical object which can be in static, kinematic, or rigid mode. Its state (such as position and velocity) can be queried and updated. A force integration callback can be set to customize the body's physics.

- An area is a region in space which can be used to detect bodies and areas entering and exiting it. A body monitoring callback can be set to report entering/exiting body shapes, and similarly an area monitoring callback can be set. Gravity and damping can be overridden within the area by setting area parameters.

- A joint is a constraint, either between two bodies or on one body relative to a point. Parameters such as the joint bias and the rest length of a spring joint can be adjusted.

Physics objects in PhysicsServer2D may be created and manipulated independently; they do not have to be tied to nodes in the scene tree.

Note: All the 2D physics nodes use the physics server internally. Adding a physics node to the scene tree will cause a corresponding physics object to be created in the physics server. A rigid body node registers a callback that updates the node's transform with the transform of the respective body object in the physics server (every physics update). An area node registers a callback to inform the area node about overlaps with the respective area object in the physics server. The raycast node queries the direct state of the relevant space in the physics server.

PhysicsServer2D.MethodName

Cached StringNames for the methods contained in this class, for fast lookup.

PhysicsServer2D.PropertyName

Cached StringNames for the properties and fields contained in this class, for fast lookup.

PhysicsServer2D.SignalName

Cached StringNames for the signals contained in this class, for fast lookup.

PhysicsServer2DExtension

This class extends PhysicsServer2D by providing additional virtual methods that can be overridden. When these methods are overridden, they will be called instead of the internal methods of the physics server.

Intended for use with GDExtension to create custom implementations of PhysicsServer2D.

PhysicsServer2DExtension.MethodName

Cached StringNames for the methods contained in this class, for fast lookup.

PhysicsServer2DExtension.PropertyName

Cached StringNames for the properties and fields contained in this class, for fast lookup.

PhysicsServer2DExtension.SignalName

Cached StringNames for the signals contained in this class, for fast lookup.

PhysicsServer2DInstance