godot version 3.4.5

Axis-Aligned Bounding Box. AABB consists of a position, a size, and several utility functions. It is typically used for fast overlap tests.

This class provides access to AES encryption/decryption of raw data. Both AES-ECB and AES-CBC mode are supported.

The godot.ARVRAnchor point is a spatial node that maps a real world location identified by the AR platform to a position within the game world. For example, as long as plane detection in ARKit is on, ARKit will identify and update the position of planes (tables, floors, etc) and create anchors for them.

This is a helper spatial node for our camera; note that, if stereoscopic rendering is applicable (VR-HMD), most of the camera properties are ignored, as the HMD information overrides them. The only properties that can be trusted are the near and far planes.

This is a helper spatial node that is linked to the tracking of controllers. It also offers several handy passthroughs to the state of buttons and such on the controllers.

This class needs to be implemented to make an AR or VR platform available to Godot and these should be implemented as C++ modules or GDNative modules (note that for GDNative the subclass ARVRScriptInterface should be used). Part of the interface is exposed to GDScript so you can detect, enable and configure an AR or VR platform.

This is a wrapper class for GDNative implementations of the ARVR interface. To use a GDNative ARVR interface, simply instantiate this object and set your GDNative library containing the ARVR interface implementation.

This is a special node within the AR/VR system that maps the physical location of the center of our tracking space to the virtual location within our game world.

An instance of this object represents a device that is tracked, such as a controller or anchor point. HMDs aren't represented here as they are handled internally.

The AR/VR server is the heart of our Advanced and Virtual Reality solution and handles all the processing.

A (A star) is a computer algorithm that is widely 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 three-dimensional space and Euclidean distances by default.

This is a wrapper for the godot.AStar class which uses 2D vectors instead of 3D vectors.

This dialog is useful for small notifications to the user about an event. It can only be accepted or closed, with the same result.

Animations are created using a godot.SpriteFrames resource, which can be configured in the editor via the SpriteFrames panel.

Animations are created using a godot.SpriteFrames resource, which can be configured in the editor via the SpriteFrames panel.

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

An Animation resource contains data used to animate everything 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.

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

A resource to add to an godot.AnimationNodeBlendTree. Blends two animations additively based on an amount value in the [0.0, 1.0] range.

A resource to add to an godot.AnimationNodeBlendTree. Blends two animations together additively out of three based on a value in the [-1.0, 1.0] range.

A resource to add to an godot.AnimationNodeBlendTree. Only features one output set using the godot.AnimationNodeAnimation.animation property. Use it as an input for godot.AnimationNode that blend animations together.

A resource to add to an godot.AnimationNodeBlendTree. Blends two animations linearly based on an amount value in the [0.0, 1.0] range.

A resource to add to an godot.AnimationNodeBlendTree. Blends two animations together linearly out of three based on a value in the [-1.0, 1.0] range.

A resource to add to an godot.AnimationNodeBlendTree.

A resource to add to an godot.AnimationNodeBlendTree.

This node may contain a sub-tree of any other blend type nodes, such as mix, blend2, blend3, one shot, etc. This is one of the most commonly used roots.

A resource to add to an godot.AnimationNodeBlendTree. This 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.

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

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

Allows scaling the speed of the animation (or reversing it) in any children nodes. Setting it to 0 will pause the animation.

This node can be used to cause a seek command to happen to any sub-children of the animation graph. Use this node type to play an godot.Animation from the start or a certain playback position inside the godot.AnimationNodeBlendTree. After setting the time and changing the animation playback, the seek node automatically goes into sleep mode on the next process frame by setting its seek_position value to -1.0.

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

An animation player is used for general-purpose playback of godot.Animation resources. It contains a dictionary of animations (referenced by name) and custom blend times between their transitions. Additionally, animations can be played and blended in different channels.

A node to be used for advanced animation transitions in an godot.AnimationPlayer.

Deprecated. A node graph tool for blending multiple animations bound to an godot.AnimationPlayer. Especially useful for animating characters or other skeleton-based rigs. It can combine several animations to form a desired pose.

3D area that detects godot.CollisionObject nodes overlapping, entering, or exiting. Can also alter or override local physics parameters (gravity, damping) and route audio to custom audio buses.

2D area that detects godot.CollisionObject2D nodes overlapping, entering, or exiting. Can also alter or override local physics parameters (gravity, damping) and route audio to a custom audio bus.

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

Arranges child controls in a way to preserve their aspect ratio automatically whenever the container is resized. Solves the problem where the container size is dynamic and the contents' size needs to adjust accordingly without losing proportions.

godot.Texture resource that crops out one part of the godot.AtlasTexture.atlas texture, defined by godot.AtlasTexture.region. The main use case is cropping out textures from a texture atlas, which is a big texture file that packs multiple smaller textures. Consists of a godot.Texture for the godot.AtlasTexture.atlas, a godot.AtlasTexture.region that defines the area of godot.AtlasTexture.atlas to use, and a godot.AtlasTexture.margin that defines the border width.

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

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

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

Limits the frequencies in a range around the godot.AudioEffectFilter.cutoffHz and allows frequencies outside of this range to pass.

Attenuates the frequencies inside of a range around the godot.AudioEffectFilter.cutoffHz and cuts frequencies outside of this band.

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

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

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).

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.

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

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).

Frequency bands:

Frequency bands:

Frequency bands:

Allows frequencies other than the godot.AudioEffectFilter.cutoffHz to pass.

Cuts frequencies lower than the godot.AudioEffectFilter.cutoffHz and allows higher frequencies to pass.

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.

Cuts frequencies higher than the godot.AudioEffectFilter.cutoffHz and allows lower frequencies to pass.

Attenuates frequencies in a narrow band around the godot.AudioEffectFilter.cutoffHz and cuts frequencies outside of this range.

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

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

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

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.

Simulates rooms of different sizes. Its parameters can be adjusted to simulate the sound of a specific room.

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

godot.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.

Base class for audio streams. Audio streams are used for sound effects and music playback, and support WAV (via godot.AudioStreamSample) and OGG (via godot.AudioStreamOGGVorbis) file formats.

This audio stream does not play back sounds, but expects a script to generate audio data for it instead. See also godot.AudioStreamGeneratorPlayback.

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

MP3 audio stream driver.

OGG Vorbis audio stream driver.

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

Plays an audio stream non-positionally.

Plays audio that dampens with distance from screen center.

Plays a sound effect with directed sound effects, dampens with distance if needed, generates effect of hearable position in space. For greater realism, a low-pass filter is automatically applied to distant sounds. This can be disabled by setting godot.AudioStreamPlayer3D.attenuationFilterCutoffHz to 20500.

Randomly varies pitch on each start.

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

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 copy mode set. Use the texture(SCREEN_TEXTURE, ...) function in your shader scripts to access the buffer.

Baked lightmaps are an alternative workflow for adding indirect (or baked) lighting to a scene. Unlike the godot.GIProbe approach, baked lightmaps work fine on low-end PCs and mobile devices as they consume almost no resources in run-time.

BaseButton is the abstract base class for buttons, so it shouldn't be used directly (it doesn't display anything). Other types of buttons inherit from it.

3×3 matrix used for 3D rotation and scale. Almost always used as an orthogonal basis for a Transform.

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.

Renders text using *.fnt fonts containing texture atlases. Supports distance fields. For using vector font files like TTF directly, see godot.DynamicFont.

Use a hierarchy of Bone2D bound to a godot.Skeleton2D to control, and animate other godot.Node2D nodes.

This node must be the child of a godot.Skeleton node. You can then select a bone for this node to attach to. The BoneAttachment node will copy the transform of the selected bone.

Arranges child controls vertically or horizontally, and rearranges the controls automatically when their minimum size changes.

3D box shape that can be a child of a godot.PhysicsBody or godot.Area.

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

Group of godot.Button. All direct and indirect children buttons become radios. Only one allows being pressed.

CPU-based 3D particle node used to create a variety of particle systems and effects.

CPU-based 2D particle node used to create a variety of particle systems and effects.

This node allows you to create a box for use with the CSG system.

For complex arrangements of shapes, it is sometimes needed to add structure to your CSG nodes. The CSGCombiner node allows you to create this structure. The node encapsulates the result of the CSG operations of its children. In this way, it is possible to do operations on one set of shapes that are children of one CSGCombiner node, and a set of separate operations on a second set of shapes that are children of a second CSGCombiner node, and then do an operation that takes the two end results as its input to create the final shape.

This node allows you to create a cylinder (or cone) for use with the CSG system.

This CSG node allows you to use any mesh resource as a CSG shape, provided it is closed, does not self-intersect, does not contain internal faces and has no edges that connect to more than two faces. See also godot.CSGPolygon for drawing 2D extruded polygons to be used as CSG nodes.

An array of 2D points is extruded to quickly and easily create a variety of 3D meshes. See also godot.CSGMesh for using 3D meshes as CSG nodes.

Parent class for various CSG primitives. It contains code and functionality that is common between them. It cannot be used directly. Instead use one of the various classes that inherit from it.

This is the CSG base class that provides CSG operation support to the various CSG nodes in Godot.

This node allows you to create a sphere for use with the CSG system.

This node allows you to create a torus for use with the CSG system.

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

Camera is a special node that displays what is visible from its current location. Cameras register themselves in the nearest godot.Viewport node (when ascending the tree). Only one camera can be active per viewport. If no viewport is available ascending the tree, the camera will register in the global viewport. In other words, a camera just provides 3D display capabilities to a godot.Viewport, and, without one, a scene registered in that godot.Viewport (or higher viewports) can't be displayed.

Camera node for 2D scenes. It forces the screen (current layer) to scroll following this node. This makes it easier (and faster) to program scrollable scenes than manually changing the position of godot.CanvasItem-based nodes.

A camera feed gives you access to a single physical camera attached to your device. When enabled, Godot will start capturing frames from the camera which can then be used. See also godot.CameraServer.

The godot.CameraServer keeps track of different cameras accessible in Godot. These are external cameras such as webcams or the cameras on your phone.

This texture gives access to the camera texture provided by a godot.CameraFeed.

Base class of anything 2D. Canvas items are laid out in a tree; children inherit and extend their parent's transform. godot.CanvasItem is extended by godot.Control for anything GUI-related, and by godot.Node2D for anything related to the 2D engine.

godot.CanvasItemMaterials provide a means of modifying the textures associated with a CanvasItem. They specialize in describing blend and lighting behaviors for textures. Use a godot.ShaderMaterial to more fully customize a material's interactions with a godot.CanvasItem.

Canvas drawing layer. godot.CanvasItem nodes that are direct or indirect children of a godot.CanvasLayer will be drawn in that layer. The layer is a numeric index that defines the draw order. The default 2D scene renders with index 0, so a godot.CanvasLayer with index -1 will be drawn below, and one with index 1 will be drawn above. This is very useful for HUDs (in layer 1+ or above), or backgrounds (in layer -1 or below).

godot.CanvasModulate tints the canvas elements using its assigned godot.CanvasModulate.color.

Class representing a capsule-shaped godot.PrimitiveMesh.

Capsule shape for collisions.

Capsule shape for 2D collisions.

CenterContainer keeps children controls centered. This container keeps all children to their minimum size, in the center.

By setting various properties on this object, you can control how individual characters will be displayed in a godot.RichTextEffect.

A checkbox allows the user to make a binary choice (choosing only one of two possible options). It's similar to godot.CheckButton in functionality, but it has a different appearance. To follow established UX patterns, it's recommended to use CheckBox when toggling it has no immediate effect on something. For instance, it should be used when toggling it will only do something once a confirmation button is pressed.

CheckButton is a toggle button displayed as a check field. It's similar to godot.CheckBox in functionality, but it has a different appearance. To follow established UX patterns, it's recommended to use CheckButton when toggling it has an immediate effect on something. For instance, it should be used if toggling it enables/disables a setting without requiring the user to press a confirmation button.

Circular shape for 2D collisions. This shape is useful for modeling balls or small characters and its collision detection with everything else is very fast.

Provides access to metadata stored for every available class.

This node extends godot.Camera to add collisions with godot.Area and/or godot.PhysicsBody nodes. The camera cannot move through colliding objects.

CollisionObject is the base class for physics objects. It can hold any number of collision godot.Shapes. Each shape must be assigned to a shape owner. The CollisionObject can have any number of shape owners. Shape owners are not nodes and do not appear in the editor, but are accessible through code using the shape_owner_* methods.

CollisionObject2D is the base class for 2D physics objects. It can hold any number of 2D collision godot.Shape2Ds. Each shape must be assigned to a shape owner. The CollisionObject2D can have any number of shape owners. Shape owners are not nodes and do not appear in the editor, but are accessible through code using the shape_owner_* methods.

Allows editing a collision polygon's vertices on a selected plane. Can also set a depth perpendicular to that plane. This class is only available in the editor. It will not appear in the scene tree at run-time. Creates a godot.Shape for gameplay. Properties modified during gameplay will have no effect.

Provides a 2D collision polygon to a godot.CollisionObject2D parent. Polygons can be drawn in the editor or specified by a list of vertices.

Editor facility for creating and editing collision shapes in 3D space. You can use this node to represent all sorts of collision shapes, for example, add this to an godot.Area to give it a detection shape, or add it to a godot.PhysicsBody to create a solid object. IMPORTANT: this is an Editor-only helper to create shapes, use godot.CollisionObject.shapeOwnerGetShape to get the actual shape.

Editor facility for creating and editing collision shapes in 2D space. You can use this node to represent all sorts of collision shapes, for example, add this to an godot.Area2D to give it a detection shape, or add it to a godot.PhysicsBody2D to create a solid object. IMPORTANT: this is an Editor-only helper to create shapes, use godot.CollisionObject2D.shapeOwnerGetShape to get the actual shape.

A color represented by red, green, blue, and alpha (RGBA) components. The alpha component is often used for transparency. Values are in floating-point and usually range from 0 to 1. Some properties (such as godot.CanvasItem.modulate) may accept values greater than 1 (overbright or HDR colors).

Displays a color picker widget. Useful for selecting a color from an RGB/RGBA colorspace.

Encapsulates a godot.ColorPicker making it accessible by pressing a button. Pressing the button will toggle the godot.ColorPicker visibility.

Displays a rectangle filled with a solid godot.ColorRect.color. If you need to display the border alone, consider using godot.ReferenceRect instead.

This class contains color constants created from standardized color names. The standardized color set is based on the X11 and .NET color names.

Concave polygon shape resource, which can be set into a godot.PhysicsBody or area. This shape is created by feeding a list of triangles.

Concave polygon 2D shape resource for physics. It is made out of segments and is optimal for complex polygonal concave collisions. However, it is not advised to use for godot.RigidBody2D nodes. A CollisionPolygon2D in convex decomposition mode (solids) or several convex objects are advised for that instead. Otherwise, a concave polygon 2D shape is better for static collisions.

The joint can rotate the bodies across an axis defined by the local x-axes of the godot.Joint.

This helper class can be used to store Variant values on the filesystem using INI-style formatting. The stored values are identified by a section and a key:

Dialog for confirmation of actions. This dialog inherits from godot.AcceptDialog, but has by default an OK and Cancel button (in host OS order).

Base node for containers. A godot.Container contains other controls and automatically arranges them in a certain way.

Base class for all UI-related nodes. godot.Control features a bounding rectangle that defines its extents, an anchor position relative to its parent control or the current viewport, and margins that represent an offset to the anchor. The margins update automatically when the node, any of its parents, or the screen size change.

Convex polygon shape resource, which can be added to a godot.PhysicsBody or area.

Convex polygon shape for 2D physics. A convex polygon, whatever its shape, is internally decomposed into as many convex polygons as needed to ensure all collision checks against it are always done on convex polygons (which are faster to check).

The Crypto class allows you to access some more advanced cryptographic functionalities in Godot.

The CryptoKey class represents a cryptographic key. Keys can be loaded and saved like any other godot.Resource.

A 6-sided 3D texture typically used for faking reflections. It can be used to make an object look as if it's reflecting its surroundings. This usually delivers much better performance than other reflection methods.

Generate an axis-aligned cuboid godot.PrimitiveMesh.

Provides common functionality to nodes that can be culled by the godot.Portal system.

A curve that can be saved and re-used for other objects. By default, it ranges between 0 and 1 on the Y axis and positions points relative to the 0.5 Y position.

This class describes a Bézier curve in 2D space. It is mainly used to give a shape to a godot.Path2D, but can be manually sampled for other purposes.

This class describes a Bézier curve in 3D space. It is mainly used to give a shape to a godot.Path, but can be manually sampled for other purposes.

Renders a given godot.Curve provided to it. Simplifies the task of drawing curves and/or saving them as image files.

User custom signal with the same api as the built-in signals.

Class representing a cylindrical godot.PrimitiveMesh. This class can be used to create cones by setting either the godot.CylinderMesh.topRadius or godot.CylinderMesh.bottomRadius properties to 0.0.

Cylinder shape for collisions.

This class is used to store the state of a DTLS server. Upon godot.DTLSServer.setup it converts connected godot.PacketPeerUDP to godot.PacketPeerDTLS accepting them via godot.DTLSServer.takeConnection as DTLS clients. Under the hood, this class is used to store the DTLS state and cookies of the server. The reason of why the state and cookies are needed is outside of the scope of this documentation.

Damped spring constraint for 2D physics. This resembles a spring joint that always wants to go back to a given length.

A directional light is a type of godot.Light node that models an infinite number of parallel rays covering the entire scene. It is used for lights with strong intensity that are located far away from the scene to model sunlight or moonlight. The worldspace location of the DirectionalLight transform (origin) is ignored. Only the basis is used to determine light direction.

Directory type. It is used to manage directories and their content (not restricted to the project folder).

DynamicFont renders vector font files dynamically at runtime instead of using a prerendered texture atlas like godot.BitmapFont. This trades the faster loading time of godot.BitmapFonts for the ability to change font parameters like size and spacing during runtime. godot.DynamicFontData is used for referencing the font file paths. DynamicFont also supports defining one or more fallback fonts, which will be used when displaying a character not supported by the main font.

Used with godot.DynamicFont to describe the location of a vector font file for dynamic rendering at runtime.

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

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

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

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

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

The editor inspector is by default located on the right-hand side of the editor. It's used to edit the properties of the selected node. For example, you can select a node such as godot.Sprite then edit its transform through the inspector tool. The editor inspector is an essential tool in the game development workflow.

godot.EditorInspectorPlugin allows adding custom property editors to godot.EditorInspector.

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

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

This control allows property editing for one or multiple properties into godot.EditorInspector. It is added via godot.EditorInspectorPlugin.

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

This object is used to generate previews for resources of files.

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

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

This is an FBX 3D asset importer with full support for most FBX features.

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

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

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

This object manages the SceneTree selection in the editor.

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

Custom gizmo that is used for providing custom visualization and editing (handles) for 3D Spatial objects. See godot.EditorSpatialGizmoPlugin for more information.

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

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

Used by the editor to display VCS extracted information in the editor. The implementation of this API is included in VCS addons, which are essentially GDNative plugins that need to be put into the project folder. These VCS addons are scripts which are attached (on demand) to the object instance of EditorVCSInterface. All the functions listed below, instead of performing the task themselves, they call the internally defined functions in the VCS addons to provide a plug-n-play experience.

Utility class which holds a reference to the internal identifier of an godot.Object instance, as given by godot.Object.getInstanceId. This ID can then be used to retrieve the object instance with @GDScript.instance_from_id.

The godot.Engine singleton allows you to query and modify the project's run-time parameters, such as frames per second, time scale, and others.

Resource for environment nodes (like godot.WorldEnvironment) that define multiple environment operations (such as background godot.Sky or godot.Color, ambient light, fog, depth-of-field...). These parameters affect the final render of the scene. The order of these operations is:

An expression can be made of any arithmetic operation, built-in math function call, method call of a passed instance, or built-in type construction call.

Enable support for the OpenGL ES external texture extension as defined by [https://www.khronos.org/registry/OpenGL/extensions/OES/OES_EGL_image_external.txt](OES_EGL_image_external).

File type. This is used to permanently store data into the user device's file system and to read from it. This can be used to store game save data or player configuration files, for example.

FileDialog is a preset dialog used to choose files and directories in the filesystem. It supports filter masks. The FileDialog automatically sets its window title according to the godot.FileDialog.mode. If you want to use a custom title, disable this by setting godot.FileDialog.modeOverridesTitle to false.

Font contains a Unicode-compatible character set, as well as the ability to draw it with variable width, ascent, descent and kerning. For creating fonts from TTF files (or other font formats), see the editor support for fonts.

In GDScript, functions are not first-class objects. This means it is impossible to store them directly as variables, return them from another function, or pass them as arguments.

Godot's global functions.

A GDNative library can implement godot.NativeScripts, global functions to call with the godot.GDNative class, or low-level engine extensions through interfaces such as godot.ARVRInterfaceGDNative. The library must be compiled for each platform and architecture that the project will run on.

A script implemented in the GDScript programming language. The script extends the functionality of all objects that instance it.

Calling @GDScript.yield within a function will cause that function to yield and return its current state as an object of this type. The yielded function call can then be resumed later by calling godot.GDScriptFunctionState.resume on this state object.

godot.GIProbes are used to provide high-quality real-time indirect light to scenes. They precompute the effect of objects that emit light and the effect of static geometry to simulate the behavior of complex light in real-time. godot.GIProbes need to be baked before using, however, once baked, dynamic objects will receive light from them. Further, lights can be fully dynamic or baked.

Note: This class is only compiled in editor builds. Run-time glTF loading and saving is not available in exported projects. References to godot.GLTFLight within a script will cause an error in an exported project.

The first 3 DOF axes are linear axes, which represent translation of Bodies, and the latter 3 DOF axes represent the angular motion. Each axis can be either locked, or limited.

Geometry provides users with a set of helper functions to create geometric shapes, compute intersections between shapes, and process various other geometric operations.

Base node for geometry-based visual instances. Shares some common functionality like visibility and custom materials.

This class is a bridge between Godot and the Mono runtime. It exposes several low-level operations and is only available in Mono-enabled Godot builds.

Given a set of colors, this resource will interpolate them in order. This means that if you have color 1, color 2 and color 3, the ramp will interpolate from color 1 to color 2 and from color 2 to color 3. The ramp will initially have 2 colors (black and white), one (black) at ramp lower offset 0 and the other (white) at the ramp higher offset 1.

GradientTexture uses a godot.Gradient to fill the texture data. The gradient will be filled from left to right using colors obtained from the gradient. This means the texture does not necessarily represent an exact copy of the gradient, but instead an interpolation of samples obtained from the gradient at fixed steps (see godot.GradientTexture.width). See also godot.CurveTexture.

GraphEdit manages the showing of GraphNodes it contains, as well as connections and disconnections between them. Signals are sent for each of these two events. Disconnection between GraphNode slots is disabled by default.

A GraphNode is a container. Each GraphNode can have several input and output slots, sometimes referred to as ports, allowing connections between GraphNodes. To add a slot to GraphNode, add any godot.Control-derived child node to it.

GridContainer will arrange its Control-derived children in a grid like structure, the grid columns are specified using the godot.GridContainer.columns property and the number of rows will be equal to the number of children in the container divided by the number of columns. For example, if the container has 5 children, and 2 columns, there will be 3 rows in the container.

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.

Groove constraint for 2D physics. This is useful for making a body "slide" through a segment placed in another.

Horizontal box container. See godot.BoxContainer.

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.

Horizontal version of godot.ScrollBar, which goes from left (min) to right (max).

Horizontal separator. See godot.Separator. Even though it looks horizontal, it is used to separate objects vertically.

Horizontal slider. See godot.Slider. This one goes from left (min) to right (max).

Horizontal split container. See godot.SplitContainer. This goes from left to right.

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 godot.HTTPRequest node for a higher-level alternative.

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

The HashingContext class provides an interface for computing cryptographic hashes over multiple iterations. This is useful for example when 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).

Height map shape resource, which can be added to a godot.PhysicsBody or godot.Area.

A HingeJoint normally uses the Z axis of body A as the hinge axis, another axis can be specified when adding it manually though. See also godot.Generic6DOFJoint.

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

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

A godot.Texture based on an godot.Image. For an image to be displayed, an godot.ImageTexture has to be created from it using the godot.ImageTexture.createFromImage method:

Draws simple geometry from code. Uses a drawing mode similar to OpenGL 1.x.

A singleton that deals with inputs. This includes key presses, mouse buttons and movement, joypads, and input actions. Actions and their events can be set in the Input Map tab in the Project > Project Settings, or with the godot.InputMap class.

Base class of all sort of input event. See godot.Node._Input.

Contains a generic action which can be targeted from several types of inputs. Actions can be created from the Input Map tab in the Project > Project Settings menu. See godot.Node._Input.

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

Stores information about joystick motions. One godot.InputEventJoypadMotion represents one axis at a time.

Stores key presses on the keyboard. Supports key presses, key releases and godot.InputEventKey.echo events.

Stores general mouse events information.

Contains mouse click information. See godot.Node._Input.

Contains mouse and pen motion information. Supports relative, absolute positions and speed. See godot.Node._Input.

Contains screen drag information. See godot.Node._Input.

Stores multi-touch press/release information. Supports touch press, touch release and godot.InputEventScreenTouch.index for multi-touch count and order.

Contains keys events information with modifiers support like Shift or Alt. See godot.Node._Input.

Manages all godot.InputEventAction which can be created/modified from the project settings menu Project > Project Settings > Input Map or in code with godot.InputMap.addAction and godot.InputMap.actionAddEvent. See godot.Node._Input.

Turning on the option Load As Placeholder for an instanced scene in the editor causes it to be replaced by an InstancePlaceholder when running the game. This makes it possible to delay actually loading the scene until calling godot.InstancePlaceholder.replaceByInstance. This is useful to avoid loading large scenes all at once by loading parts of it selectively.

Deprecated (will be removed in Godot 4.0). InterpolatedCamera is a godot.Camera which smoothly moves to match a target node's position and rotation.

This control provides a selectable list of items that may be in a single (or multiple columns) with option of text, icons, or both text and icon. Tooltips are supported and may be different for every item in the list.

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 [https://en.wikipedia.org/wiki/Java_Native_Interface](Java Native Interface - Wikipedia) for more information.

Helper class for parsing JSON data. For usage example and other important hints, see godot.JSONParseResult.

Returned by godot.JSON.parse, godot.JSONParseResult contains the decoded JSON or error information if the JSON source wasn't successfully parsed. You can check if the JSON source was successfully parsed with if json_result.error == OK.

[https://www.jsonrpc.org/](JSON-RPC) is a standard which wraps a method call in a godot.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 godot.Collections_Dictionary; you will have to convert between a godot.Collections_Dictionary and godot.JSON with other functions.

The JavaScript singleton is implemented only in the HTML5 export. It's used to access the browser's JavaScript context. This allows interaction with embedding pages or calling third-party JavaScript APIs.

JavaScriptObject is used to interact with JavaScript objects retrieved or created via godot.JavaScript.getInterface, godot.JavaScript.createObject, or godot.JavaScript.createCallback.

Joints are used to bind together two physics bodies. They have a solver priority and can define if the bodies of the two attached nodes should be able to collide with each other.

Base node for all joint constraints in 2D physics. Joints take 2 bodies and apply a custom constraint.

Kinematic bodies are special types of bodies that are meant to be user-controlled. They are not affected by physics at all; to other types of bodies, such as a character or a rigid body, these are the same as a static body. However, they have two main uses:

Kinematic bodies are special types of bodies that are meant to be user-controlled. They are not affected by physics at all; to other types of bodies, such as a character or a rigid body, these are the same as a static body. However, they have two main uses:

Contains collision data for godot.KinematicBody collisions. When a godot.KinematicBody is moved using godot.KinematicBody.moveAndCollide, it stops if it detects a collision with another body. If a collision is detected, a KinematicCollision object is returned.

Contains collision data for godot.KinematicBody2D collisions. When a godot.KinematicBody2D is moved using godot.KinematicBody2D.moveAndCollide, it stops if it detects a collision with another body. If a collision is detected, a KinematicCollision2D object is returned.

Label displays plain text on the screen. 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 formatting. For that, use godot.RichTextLabel instead.

Deprecated (will be removed in Godot 4.0). A godot.Texture capable of storing many smaller textures with offsets.

Light is the abstract base class for light nodes. As it can't be instanced, it shouldn't be used directly. Other types of light nodes inherit from it. Light contains the common variables and parameters used for lighting.

Casts light in a 2D environment. Light is defined by a (usually grayscale) texture, a color, an energy value, a mode (see constants), and various other parameters (range and shadows-related).

Occludes light cast by a Light2D, casting shadows. The LightOccluder2D must be provided with an godot.OccluderPolygon2D in order for the shadow to be computed.

A line through several points in 2D space. Supports varying width and color over the line's length, texturing, and several cap/joint types.

LineEdit provides a single-line string editor, used for text fields.

Line shape for 2D collisions. It works like a 2D plane and will not allow any physics body to go to the negative side. Not recommended for rigid bodies, and usually not recommended for static bodies either because it forces checks against it on every frame.

This kind of button is primarily used when the interaction with the button causes a context change (like linking to a web page).

Once added to the scene tree and enabled using godot.Listener.makeCurrent, this node will override the location sounds are heard from. This can be used to listen from a location different from the godot.Camera.

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

godot.MainLoop is the abstract base class for a Godot project's game loop. It is inherited by godot.SceneTree, which is the default game loop implementation used in Godot projects, though it is also possible to write and use one's own godot.MainLoop subclass instead of the scene tree.

Adds a top, left, bottom, and right margin to all godot.Control nodes that are direct children of the container. To control the godot.MarginContainer's margin, use the margin_* theme properties listed below.

Provides data transformation and encoding utility functions.

Material is a base godot.Resource used for coloring and shading geometry. All materials inherit from it and almost all godot.VisualInstance derived nodes carry a Material. A few flags and parameters are shared between all material types and are configured here.

Provides constants and static methods for common mathematical functions.

Special button that brings up a godot.PopupMenu when clicked.

Mesh is a type of godot.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.

MeshDataTool provides access to individual vertices in a godot.Mesh. It allows users to read and edit vertex data of meshes. It also creates an array of faces and edges.

MeshInstance is a node that takes a godot.Mesh resource and adds it to the current scenario by creating an instance of it. This is the class most often used to get 3D geometry rendered and can be used to instance a single godot.Mesh in many places. This allows reusing geometry, which can save on resources. When a godot.Mesh has to be instanced more than thousands of times at close proximity, consider using a godot.MultiMesh in a godot.MultiMeshInstance instead.

Node used for displaying a godot.Mesh in 2D. Can be constructed from an existing godot.Sprite via a tool in the editor toolbar. Select "Sprite" then "Convert to Mesh2D", select settings in popup and press "Create Mesh2D".

A library of meshes. Contains a list of godot.Mesh resources, each with a name and ID. Each item can also include collision and navigation shapes. This resource is used in godot.GridMap.

Simple texture that uses a mesh to draw itself. It's limited because flags can't be changed and region drawing is not supported.

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.

MultiMesh provides low-level mesh instancing. Drawing thousands of godot.MeshInstance nodes can be slow, since each object is submitted to the GPU then drawn individually.

godot.MultiMeshInstance is a specialized node to instance godot.GeometryInstances based on a godot.MultiMesh resource.

godot.MultiMeshInstance2D is a specialized node to instance a godot.MultiMesh resource in 2D.

This class implements most of the logic behind the high-level multiplayer API. See also godot.NetworkedMultiplayerPeer.

A synchronization mutex (mutual exclusion). This is used to synchronize multiple godot.Threads, and is equivalent to a binary godot.Semaphore. It guarantees that only one thread can ever acquire the lock at a time. A mutex can be used to protect a critical section; however, be careful to avoid deadlocks.

Provides navigation and pathfinding within a collection of godot.NavigationMeshes. By default, these will be automatically collected from child godot.NavigationMeshInstance nodes, but they can also be added on the fly with godot.Navigation.navmeshAdd. In addition to basic pathfinding, this class also assists with aligning navigation agents with the meshes they are navigating on.

Navigation2D provides navigation and pathfinding within a 2D area, specified as a collection of godot.NavigationPolygon resources. By default, these are automatically collected from child godot.NavigationPolygonInstance nodes, but they can also be added on the fly with godot.Navigation2D.navpolyAdd.

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.

NavigationMeshInstance is a node that takes a godot.NavigationMesh resource and adds it to the current scenario by creating an instance of it.

There are two ways to create polygons. Either by using the godot.NavigationPolygon.addOutline method, or using the godot.NavigationPolygon.addPolygon method.

A PacketPeer implementation that should be passed to godot.SceneTree.networkPeer after being initialized as either a client or server. Events can then be handled by connecting to godot.SceneTree signals.

Manages the connection to network peers. Assigns unique IDs to each client connected to the server. See also godot.MultiplayerAPI.

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 sides horizontally or vertically, the center on both axes but it doesn't scale or tile the corners.

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 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.

A pre-parsed relative or absolute path in a scene tree, for use with godot.Node.getNode 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 godot.Node.getNode 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.

Uses an godot.OpenSimplexNoise to fill the texture data. You can specify the texture size but keep in mind that larger textures will take longer to generate and seamless noise only works with square sized textures.

Operating System functions. OS wraps the most common functionality to communicate with the host operating system, such as the clipboard, video driver, date and time, timers, environment variables, execution of binaries, command line, etc.

Every class which is not a built-in type inherits from this class.

godot.Occluders that are placed within your scene will automatically cull objects that are hidden from view by the occluder. This can increase performance by decreasing the amount of objects drawn.

Editor facility that helps you draw a 2D polygon used as resource for godot.LightOccluder2D.

godot.Occluders can use any primitive shape derived from godot.OccluderShape.

godot.OccluderShapes are resources used by godot.Occluder nodes, allowing geometric occlusion culling.

An Omnidirectional light is a type of godot.Light 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.

This resource allows you to configure and sample a fractal noise space. Here is a brief usage example that configures an OpenSimplexNoise and gets samples at various positions and dimensions:

OptionButton is a type button that provides a selectable list of items when pressed. The item selected becomes the "current" item and is displayed as the button text.

The godot.PCKPacker is used to create packages that can be loaded into a running project using godot.ProjectSettings.loadResourcePack.

Optimized translation. Uses real-time compressed translations, which results in very small dictionaries.

A simplified interface to a scene file. Provides access to operations and checks that can be performed on the scene resource itself.

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.

This class represents a DTLS peer connection. It can be used to connect to a DTLS server, and is returned by godot.DTLSServer.takeConnection.

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.

UDP packet peer. Can be used to send raw UDP packets as well as Variants.

Panel is a godot.Control that displays an opaque background. It's commonly used as a parent and container for other types of godot.Control nodes.

Panel container type. This container fits controls inside of the delimited area of a stylebox. It's useful for giving controls an outline.

A resource referenced in an godot.Environment that is used to draw a background. The Panorama sky functions similar to skyboxes in other engines, except it uses an equirectangular sky map instead of a cube map.

A ParallaxBackground uses one or more godot.ParallaxLayer child nodes to create a parallax effect. Each godot.ParallaxLayer can move at a different speed using godot.ParallaxLayer.motionOffset. This creates an illusion of depth in a 2D game. If not used with a godot.Camera2D, you must manually calculate the godot.ParallaxBackground.scrollOffset.

A ParallaxLayer must be the child of a godot.ParallaxBackground node. Each ParallaxLayer can be set to move at different speeds relative to the camera movement or the godot.ParallaxBackground.scrollOffset value.

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

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

ParticlesMaterial defines particle properties and behavior. It is used in the process_material of godot.Particles and godot.Particles2D emitter nodes.

Can have godot.PathFollow child nodes moving along the godot.Curve3D. See godot.PathFollow for more information on the usage.

Can have godot.PathFollow2D child nodes moving along the godot.Curve2D. See godot.PathFollow2D for more information on usage.

This node takes its parent godot.Path, and returns the coordinates of a point within it, given a distance from the first vertex.

This node takes its parent godot.Path2D, and returns the coordinates of a point within it, given a distance from the first vertex.

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 godot.Performance.getMonitor method of this class, you can access this data from your code.

Provides direct access to a physics body in the godot.Physics2DServer, allowing safe changes to physics properties. This object is passed via the direct state callback of rigid/character bodies, and is intended for changing the direct state of that body. See godot.RigidBody2D._IntegrateForces.

Direct access object to a space in the godot.Physics2DServer. It's used mainly to do queries against objects and areas residing in a given space.

Physics2DServer is the server responsible for all 2D physics. It can create many kinds of physics objects, but does not insert them on the node tree.

This class contains the shape and other parameters for 2D intersection/collision queries.

PhysicsBody is an abstract base class for implementing a physics body. All *Body types inherit from it.

PhysicsBody2D is an abstract base class for implementing a physics body. All *Body2D types inherit from it.

Provides direct access to a physics body in the godot.PhysicsServer, allowing safe changes to physics properties. This object is passed via the direct state callback of rigid/character bodies, and is intended for changing the direct state of that body. See godot.RigidBody._IntegrateForces.

Direct access object to a space in the godot.PhysicsServer. It's used mainly to do queries against objects and areas residing in a given space.

Provides a means of modifying the collision properties of a godot.PhysicsBody.

PhysicsServer is the server responsible for all 3D physics. It can create many kinds of physics objects, but does not insert them on the node tree.

This class contains the shape and other parameters for 3D intersection/collision queries.

Pin joint for 3D rigid bodies. It pins 2 bodies (rigid or static) together. See also godot.Generic6DOFJoint.

Pin Joint for 2D rigid bodies. It pins two bodies (rigid or static) together.

Plane represents a normalized plane equation. "Over" or "Above" the plane is considered the side of the plane towards where the normal is pointing.

Class representing a planar godot.PrimitiveMesh. This flat mesh does not have a thickness. By default, this mesh is aligned on the X and Z axes; this default rotation isn't suited for use with billboarded materials. For billboarded materials, use godot.QuadMesh instead.

An infinite plane shape for 3D collisions. Note that the godot.Plane's normal matters; anything "below" the plane will collide with it. If the godot.PlaneShape is used in a godot.PhysicsBody, it will cause colliding objects placed "below" it to teleport "above" the plane.

The PointMesh is made from a single point. Instead of relying on triangles, points are rendered as a single rectangle on the screen with a constant size. They are intended to be used with Particle systems, but can be used as a cheap way to render constant size billboarded sprites (for example in a point cloud).

A Polygon2D is defined by a set of points. Each point is connected to the next, with the final point being connected to the first, resulting in a closed polygon. Polygon2Ds can be filled with color (solid or gradient) or filled with a given texture.

Popup is a base godot.Control used to show dialogs and popups. It's a subwindow and modal by default (see godot.Control) and has helpers for custom popup behavior. All popup methods ensure correct placement within the viewport.

PopupDialog is a base class for popup dialogs, along with godot.WindowDialog.

godot.PopupMenu is a godot.Control that displays a list of options. They are popular in toolbars or context menus.

Class for displaying popups with a panel background. In some cases it might be simpler to use than godot.Popup, since it provides a configurable background. If you are making windows, better check godot.WindowDialog.

godot.Portals are a special type of godot.MeshInstance that allow the portal culling system to 'see' from one room to the next. They often correspond to doors and windows in level geometry. By only allowing godot.Cameras to see through portals, this allows the system to cull out all the objects in rooms that cannot be seen through portals. This is a form of occlusion culling, and can greatly increase performance.

Generic 2D position hint for editing. It's just like a plain godot.Node2D, but it displays as a cross in the 2D editor at all times. You can set cross' visual size by using the gizmo in the 2D editor while the node is selected.

Generic 3D position hint for editing. It's just like a plain godot.Spatial, but it displays as a cross in the 3D editor at all times.

Base class for all primitive meshes. Handles applying a godot.Material to a primitive mesh. Examples include godot.CapsuleMesh, godot.CubeMesh, godot.CylinderMesh, godot.PlaneMesh, godot.PrismMesh, godot.QuadMesh, and godot.SphereMesh.

Class representing a prism-shaped godot.PrimitiveMesh.

ProceduralSky provides a way to create an effective background quickly by defining procedural parameters for the sun, the sky and the ground. The sky and ground are very similar, they are defined by a color at the horizon, another color, and finally an easing curve to interpolate between these two colors. Similarly, the sun is described by a position in the sky, a color, and an easing curve. However, the sun also defines a minimum and maximum angle, these two values define at what distance the easing curve begins and ends from the sun, and thus end up defining the size of the sun in the sky.

General-purpose progress bar. Shows fill percentage from right to left.

Contains global variables accessible from everywhere. Use godot.ProjectSettings.getSetting, godot.ProjectSettings.setSetting or godot.ProjectSettings.hasSetting to access them. Variables stored in project.godot are also loaded into ProjectSettings, making this object very useful for reading custom game configuration options.

General-purpose proximity detection node. godot.ProximityGroup can be used for approximate distance checks, which are faster than exact distance checks using Vector3.distance_to or Vector3.distance_squared_to.

Class representing a square godot.PrimitiveMesh. This flat mesh does not have a thickness. By default, this mesh is aligned on the X and Y axes; this default rotation is more suited for use with billboarded materials. Unlike godot.PlaneMesh, this mesh doesn't provide subdivision options.

A unit quaternion used for representing 3D rotations. Quaternions need to be normalized to be used for rotation.

The RID type is used to access the unique integer ID of a resource. They are opaque, which means they do not grant access to the associated resource by themselves. They are used by and with the low-level Server classes such as godot.VisualServer.

RandomNumberGenerator is a class for generating pseudo-random numbers. It currently uses [http://www.pcg-random.org/](PCG32).

Range is a base class for godot.Control nodes that change a floating-point value between a minimum and a maximum, using step and page, for example a godot.ScrollBar.

A RayCast represents a line from its origin to its destination position, cast_to. It is used to query the 3D space in order to find the closest object along the path of the ray.

A RayCast represents a line from its origin to its destination position, cast_to. It is used to query the 2D space in order to find the closest object along the path of the ray.

Ray shape for 3D collisions, which can be set into a godot.PhysicsBody or godot.Area. A ray is not really a collision body; instead, it tries to separate itself from whatever is touching its far endpoint. It's often useful for characters.

Ray shape for 2D collisions. A ray is not really a collision body; instead, it tries to separate itself from whatever is touching its far endpoint. It's often useful for characters.

2D axis-aligned bounding box. Rect2 consists of a position, a size, and several utility functions. It is typically used for fast overlap tests.

Rectangle shape for 2D collisions. This shape is useful for modeling box-like 2D objects.

Base class for any object that keeps a reference count. godot.Resource and many other helper objects inherit this class.

A rectangle box that displays only a godot.ReferenceRect.borderColor border color around its rectangle. godot.ReferenceRect has no fill godot.Color. If you need to display a rectangle filled with a solid color, consider using godot.ColorRect instead.

Capture its surroundings as a dual paraboloid image, and stores versions of it with increasing levels of blur to simulate different material roughnesses.

A regular expression (or regex) is a compact language that can be used to recognise strings that follow a specific pattern, such as URLs, email addresses, complete sentences, etc. For instance, a regex of ab[0-9] would find any string that is ab followed by any number from 0 to 9. For a more in-depth look, you can easily find various tutorials and detailed explanations on the Internet.

Contains the results of a single godot.RegEx match returned by godot.RegEx.search and godot.RegEx.searchAll. It can be used to find the position and range of the match and its capturing groups, and it can extract its substring for you.

RemoteTransform pushes its own godot.Transform to another godot.Spatial derived Node (called the remote node) in the scene.

RemoteTransform2D pushes its own godot.Transform2D to another godot.CanvasItem derived Node (called the remote node) in the scene.

Resource is the base class for all Godot-specific resource types, serving primarily as data containers. Since they inherit from godot.Reference, resources are reference-counted and freed when no longer in use. They are also cached once loaded from disk, so that any further attempts to load a resource from a given path will return the same reference (all this in contrast to a godot.Node, which is not reference-counted and can be instanced from disk as many times as desired). Resources can be saved externally on disk or bundled into another object, such as a godot.Node or another resource.

Godot loads resources in the editor or in exported games using ResourceFormatLoaders. They are queried automatically via the godot.ResourceLoader singleton, or when a resource with internal dependencies is loaded. Each file type may load as a different resource type, so multiple ResourceFormatLoaders are registered in the engine.

The engine can save resources when you do it from the editor, or when you use the godot.ResourceSaver singleton. This is accomplished thanks to multiple godot.ResourceFormatSavers, each handling its own format and called automatically by the engine.

This is the base class for the resource importers implemented in core. To implement your own resource importers using editor plugins, see Godot.EditorImportPlugin.

Interactive godot.Resource loader. This object is returned by godot.ResourceLoader when performing an interactive load. It allows loading resources with high granularity, which makes it mainly useful for displaying loading bars or percentages.

Singleton used to load resource files from the filesystem.

This node is used to preload sub-resources inside a scene, so when the scene is loaded, all the resources are ready to use and can be retrieved from the preloader.

Singleton for saving Godot-specific resource types to the filesystem.

A custom effect for use with godot.RichTextLabel.

Rich text can contain custom text, fonts, images and some basic formatting. The label manages these as an internal tag stack. It also adapts itself to given width/heights.

This is the node that implements full 3D physics. This means that you do not control a RigidBody directly. Instead, you can apply forces to it (gravity, impulses, etc.), and the physics simulation will calculate the resulting movement, collision, bouncing, rotating, etc.

This node implements simulated 2D physics. You do not control a RigidBody2D directly. Instead, you apply forces to it (gravity, impulses, etc.) and the physics simulation calculates the resulting movement based on its mass, friction, and other physical properties.

The godot.Portal culling system requires levels to be built using objects grouped together by location in areas called godot.Rooms. In many cases these will correspond to actual rooms in buildings, but not necessarily (a canyon area may be treated as a room).

Although godot.Room behaviour can be specified individually, sometimes it is faster and more convenient to write functionality for a group of rooms.

In order to utilize the portal occlusion culling system, you must build your level using godot.Rooms and godot.Portals. Before these can be used at runtime, they must undergo a short conversion process to build the room graph, runtime data needed for portal culling. The room graph is controlled by the godot.RoomManager node, and the godot.RoomManager also contains settings that are common throughout the portal system.

Maintains a list of resources, nodes, exported, and overridden properties, and built-in scripts associated with a scene.

As one of the most important classes, the godot.SceneTree manages the hierarchy of nodes in a scene as well as scenes themselves. Nodes can be added, retrieved and removed. The whole scene tree (and thus the current scene) can be paused. Scenes can be loaded, switched and reloaded.

A one-shot timer managed by the scene tree, which emits timeout on completion. See also godot.SceneTree.createTimer.

A class stored as a resource. A script extends the functionality of all objects that instance it.

The godot.ScriptCreateDialog creates script files according to a given template for a given scripting language. The standard use is to configure its fields prior to calling one of the godot.Popup.popup_ methods.

Note: This class shouldn't be instantiated directly. Instead, access the singleton using godot.EditorInterface.getScriptEditor.

Scrollbars are a godot.Range-based godot.Control, that display a draggable area (the size of the page). Horizontal (godot.HScrollBar) and Vertical (godot.VScrollBar) versions are available.

A ScrollContainer node meant to contain a godot.Control child. ScrollContainers will automatically create a scrollbar child (godot.HScrollBar, godot.VScrollBar, or both) when needed and will only draw the Control within the ScrollContainer area. Scrollbars will automatically be drawn at the right (for vertical) or bottom (for horizontal) and will enable dragging to move the viewable Control (and its children) within the ScrollContainer. Scrollbars will also automatically resize the grabber based on the godot.Control.rectMinSize of the Control relative to the ScrollContainer. Works great with a godot.Panel control. You can set EXPAND on the children's size flags, so they will upscale to the ScrollContainer's size if it's larger (scroll is invisible for the chosen dimension).

Segment shape for 2D collisions. Consists of two points, a and b.

A synchronization semaphore which can be used to synchronize multiple godot.Threads. Initialized to zero on creation. Be careful to avoid deadlocks. For a binary version, see godot.Mutex.

Separator is a godot.Control used for separating other controls. It's purely a visual decoration. Horizontal (godot.HSeparator) and Vertical (godot.VSeparator) versions are available.

This class allows you to define a custom shader program that can be used by a godot.ShaderMaterial. Shaders allow you to write your own custom behavior for rendering objects or updating particle information. For a detailed explanation and usage, please see the tutorials linked below.

A material that uses a custom godot.Shader program to render either items to screen or process particles. You can create multiple materials for the same shader but configure different values for the uniforms defined in the shader.

Base class for all 3D shape resources. Nodes that inherit from this can be used as shapes for a godot.PhysicsBody or godot.Area objects.

Base class for all 2D shapes. All 2D shape types inherit from this.

A shortcut for binding input.

Typesafe signal.

Skeleton provides a hierarchical interface for managing bones, including pose, rest and animation (see godot.Animation). It can also use ragdoll physics.

Skeleton2D parents a hierarchy of godot.Bone2D objects. It is a requirement of godot.Bone2D. Skeleton2D holds a reference to the rest pose of its children and acts as a single point of access to its bones.

SkeletonIK is used to place the end bone of a godot.Skeleton bone chain at a certain point in 3D by rotating all bones in the chain accordingly. A typical scenario for IK in games is to place a characters feet on the ground or a characters hands on a currently hold object. SkeletonIK uses FabrikInverseKinematic internally to solve the bone chain and applies the results to the godot.Skeleton bones_global_pose_override property for all affected bones in the chain. If fully applied this overwrites any bone transform from godot.Animations or bone custom poses set by users. The applied amount can be controlled with the interpolation property.

The base class for godot.PanoramaSky and godot.ProceduralSky.

Base class for GUI sliders.

Slides across the X axis of the pivot object. See also godot.Generic6DOFJoint.

A deformable physics body. Used to create elastic or deformable objects such as cloth, rubber, or other flexible materials.

Most basic 3D game object, with a 3D godot.Transform and visibility settings. All other 3D game objects inherit from Spatial. Use godot.Spatial as a parent node to move, scale, rotate and show/hide children in a 3D project.

This provides 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.

Class representing a spherical godot.PrimitiveMesh.

Sphere shape for 3D collisions, which can be set into a godot.PhysicsBody or godot.Area. This shape is useful for modeling sphere-like 3D objects.

SpinBox is a numerical input text field. It allows entering integers and floats.

Container for splitting two godot.Controls vertically or horizontally, with a grabber that allows adjusting the split offset or ratio.

A Spotlight is a type of godot.Light node that emits lights in a specific direction, in the shape of a cone. The light is attenuated through the distance. This attenuation can be configured by changing the energy, radius and attenuation parameters of godot.Light.

The SpringArm node is a node that casts a ray (or collision shape) along its z axis and moves all its direct children to the collision point, minus a margin.

A node that displays a 2D texture. The texture displayed can be a region from a larger atlas texture, or a frame from a sprite sheet animation.

A node that displays a 2D texture in a 3D environment. The texture displayed can be a region from a larger atlas texture, or a frame from a sprite sheet animation.

A node that displays 2D texture information in a 3D environment.

Sprite frame library for an godot.AnimatedSprite or godot.AnimatedSprite3D node. Contains frames and animation data for playback.

Static body for 3D physics. A static body is a simple body that is not intended to move. In contrast to godot.RigidBody, they don't consume any CPU resources as long as they don't move.

Static body for 2D physics. A StaticBody2D is a body that is not intended to move. It is ideal for implementing objects in the environment, such as walls or platforms.

StreamPeer is an abstraction and base class for stream-based protocols (such as TCP). It provides an API for sending and receiving data through streams as raw data or strings.

SSL stream peer. This object can be used to connect to an SSL server or accept a single SSL client connection.

TCP stream peer. This object can be used to connect to TCP servers, or also is returned by a TCP server.

A texture that is loaded from a .stex file.

Extension methods to manipulate strings.

StyleBox is godot.Resource that provides an abstract base class for drawing stylized boxes for the UI. StyleBoxes are used for drawing the styles of buttons, line edit backgrounds, tree backgrounds, etc. and also for testing a transparency mask for pointer signals. If mask test fails on a StyleBox assigned as mask to a control, clicks and motion signals will go through it to the one below.

Empty stylebox (really does not display anything).

This godot.StyleBox can be used to achieve all kinds of looks without the need of a texture. The following properties are customizable:

godot.StyleBox that displays a single line of a given color and thickness. It can be used to draw things like separators.

Texture-based nine-patch godot.StyleBox, in a way similar to godot.NinePatchRect. This stylebox performs a 3×3 scaling of a texture, where only the center cell is fully stretched. This makes it possible to design bordered styles regardless of the stylebox's size.

The godot.SurfaceTool is used to construct a godot.Mesh by specifying vertex attributes individually. It can be used to construct a godot.Mesh from a script. All properties except indices need to be added before calling godot.SurfaceTool.addVertex. For example, to add vertex colors and UVs:

A TCP server. Listens to connections on a port and returns a godot.StreamPeerTCP when it gets an incoming connection.

Arranges godot.Control children into a tabbed view, creating a tab for each one. The active tab's corresponding godot.Control has its visible property set to true, and all other children's to false.

Simple tabs control, similar to godot.TabContainer but is only in charge of drawing tabs, not interacting with children.

TextEdit is meant for editing large, multiline text. It also has facilities for editing code, such as syntax highlighting support and multiple levels of undo/redo.

A texture works by registering an image in the video hardware, which then can be used in 3D models or 2D godot.Sprite or GUI godot.Control.

Texture3D is a 3-dimensional godot.Texture that has a width, height, and depth. See also godot.TextureArray.

godot.TextureArrays store an array of godot.Images in a single godot.Texture primitive. Each layer of the texture array has its own mipmap chain. This makes it is a good alternative to texture atlases. See also godot.Texture3D.

godot.TextureButton has the same functionality as godot.Button, except it uses sprites instead of Godot's godot.Theme resource. It is faster to create, but it doesn't support localization like more complex godot.Controls.

Base class for godot.Texture3D and godot.TextureArray. Cannot be used directly, but contains all the functions necessary for accessing and using godot.Texture3D and godot.TextureArray. Data is set on a per-layer basis. For godot.Texture3Ds, the layer specifies the depth or Z-index, they can be treated as a bunch of 2D slices. Similarly, for godot.TextureArrays, the layer specifies the array layer.

TextureProgress works like godot.ProgressBar, but uses up to 3 textures instead of Godot's godot.Theme resource. It can be used to create horizontal, vertical and radial progress bars.

Used to draw icons and sprites in a user interface. The texture's placement can be controlled with the godot.TextureRect.stretchMode property. It can scale, tile, or stay centered inside its bounding rectangle.

A theme for skinning controls. Controls can be skinned individually, but for complex applications, it's more practical to just create a global theme that defines everything. This theme can be applied to any godot.Control; the Control and its children will automatically use it.

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

Node for 2D tile-based maps. Tilemaps use a godot.TileSet which contain a list of tiles (textures plus optional collision, navigation, and/or occluder shapes) which are used to create grid-based maps.

A TileSet is a library of tiles for a godot.TileMap. It contains a list of tiles, each consisting of a sprite and optional collision shapes.

Counts down a specified interval and emits a signal on reaching 0. Can be set to repeat or "one-shot" mode.

This is a helper class to generate a flat godot.Button (see godot.Button.flat), creating a godot.ToolButton is equivalent to:

TouchScreenButton allows you to create on-screen buttons for touch devices. It's intended for gameplay use, such as a unit you have to touch to move. Unlike godot.Button, TouchScreenButton supports multitouch out of the box. Several TouchScreenButtons can be pressed at the same time with touch input.

3×4 matrix (3 rows, 4 columns) used for 3D linear transformations. It can represent transformations such as translation, rotation, or scaling. It consists of a godot.Basis (first 3 columns) and a godot.Vector3 for the origin (last column).

2×3 matrix (2 rows, 3 columns) used for 2D linear transformations. It can represent transformations such as translation, rotation, or scaling. It consists of a three godot.Vector2 values: x, y, and the origin.

Translations are resources that can be loaded and unloaded on demand. They map a string to another string.

Server that manages all translations. Translations can be set to it and removed from it.

This shows a tree of items that can be selected, expanded and collapsed. The tree can have multiple columns with custom controls like text editing, buttons and popups. It can be useful for structured displays and interactions.

Control for a single item inside a godot.Tree. May have child godot.TreeItems and be styled as well as contain buttons.

Mesh type used internally for collision calculations.

Tweens are useful for animations requiring a numerical property to be interpolated over a range of values. The name tween comes from in-betweening, an animation technique where you specify keyframes and the computer interpolates the frames that appear between them.

A simple server that opens a UDP socket and returns connected godot.PacketPeerUDP upon receiving new packets. See also godot.PacketPeerUDP.connectToHost.

Provides UPNP functionality to discover godot.UPNPDevices on the local network and execute commands on them, like managing port mappings (port forwarding) and querying the local and remote network IP address. Note that methods on this class are synchronous and block the calling thread.

UPNP device. See godot.UPNP for UPNP discovery and utility functions. Provides low-level access to UPNP control commands. Allows to manage port mappings (port forwarding) and to query network information of the device (like local and external IP address and status). Note that methods on this class are synchronous and block the calling thread.

Helper to manage undo/redo operations in the editor or custom tools. It works by registering methods and property changes inside "actions".

Event arguments for when unhandled exceptions occur.

Vertical box container. See godot.BoxContainer.

Vertical version of godot.ScrollBar, which goes from top (min) to bottom (max).

Vertical version of godot.Separator. Even though it looks vertical, it is used to separate objects horizontally.

Vertical slider. See godot.Slider. This one goes from bottom (min) to top (max).

Vertical split container. See godot.SplitContainer. This goes from top to bottom.

2-element structure that can be used to represent positions in 2D space or any other pair of numeric values.

3-element structure that can be used to represent positions in 3D space or any other pair of numeric values.

This node implements all the physics logic needed to simulate a car. It is based on the raycast vehicle system commonly found in physics engines. You will need to add a godot.CollisionShape for the main body of your vehicle and add godot.VehicleWheel nodes for the wheels. You should also add a godot.MeshInstance to this node for the 3D model of your car but this model should not include meshes for the wheels. You should control the vehicle by using the godot.VehicleBody.brake, godot.VehicleBody.engineForce, and godot.VehicleBody.steering properties and not change the position or orientation of this node directly.

This node needs to be used as a child node of godot.VehicleBody and simulates the behavior of one of its wheels. This node also acts as a collider to detect if the wheel is touching a surface.

Control node for playing video streams using godot.VideoStream resources.

Base resource type for all video streams. Classes that derive from godot.VideoStream can all be used as resource types to play back videos in godot.VideoPlayer.

godot.VideoStream resource for for video formats implemented via GDNative.

godot.VideoStream resource handling the [https://www.theora.org/](Ogg Theora) video format with .ogv extension. The Theora codec is less efficient than godot.VideoStreamWebm's VP8 and VP9, but it requires less CPU resources to decode. The Theora codec is decoded on the CPU.

godot.VideoStream resource handling the [https://www.webmproject.org/](WebM) video format with .webm extension. Both the VP8 and VP9 codecs are supported. The VP8 and VP9 codecs are more efficient than godot.VideoStreamTheora, but they require more CPU resources to decode (especially VP9). Both the VP8 and VP9 codecs are decoded on the CPU.

A Viewport creates a different view into the screen, or a sub-view inside another viewport. Children 2D Nodes will display on it, and children Camera 3D nodes will render on it too.

A godot.Container node that holds a godot.Viewport, automatically setting its size.

Displays the content of a godot.Viewport node as a dynamic godot.Texture. This can be used to mix controls, 2D, and 3D elements in the same scene.

The VisibilityEnabler will disable godot.RigidBody and godot.AnimationPlayer nodes when they are not visible. It will only affect other nodes within the same scene as the VisibilityEnabler itself.

The VisibilityEnabler2D will disable godot.RigidBody2D, godot.AnimationPlayer, and other nodes when they are not visible. It will only affect nodes with the same root node as the VisibilityEnabler2D, and the root node itself.

The VisibilityNotifier detects when it is visible on the screen. It also notifies when its bounding rectangle enters or exits the screen or a godot.Camera's view.

The VisibilityNotifier2D detects when it is visible on the screen. It also notifies when its bounding rectangle enters or exits the screen or a viewport.

The godot.VisualInstance is used to connect a resource to a visual representation. All visual 3D nodes inherit from the godot.VisualInstance. In general, you should not access the godot.VisualInstance properties directly as they are accessed and managed by the nodes that inherit from godot.VisualInstance. godot.VisualInstance is the node representation of the godot.VisualServer instance.

A script implemented in the Visual Script programming environment. The script extends the functionality of all objects that instance it.

A Visual Script node representing a constant from base types, such as Vector3.AXIS_X.

A built-in function used inside a godot.VisualScript. It is usually a math function or an utility function.

This node returns a constant from a given class, such as TYPE_INT. See the given class' documentation for available constants.

A Visual Script node used to display annotations in the script, so that code may be documented.

A Visual Script Node used to compose array from the list of elements provided with custom in-graph UI hard coded in the VisualScript Editor.

A Visual Script node that checks a Bool input port. If true, it will exit via the "true" sequence port. If false, it will exit via the "false" sequence port. After exiting either, it exits via the "done" port. Sequence ports may be left disconnected.

This node returns a constant's value.

A Visual Script node which calls a base type constructor. It can be used for type conversion as well.

A custom Visual Script node which can be scripted in powerful ways.

A Visual Script node which deconstructs a base type instance into its parts.

Emits a specified signal when it is executed.

A Visual Script node returning a singleton from @GlobalScope.

A Visual Script node that can execute a custom expression. Values can be provided for the input and the expression result can be retrieved from the output.

godot.VisualScriptFunction represents a function header. It is the starting point for the function body and can be used to tweak the function's properties (e.g. RPC mode).

godot.VisualScriptFunctionCall is created when you add or drag and drop a function onto the Visual Script graph. It allows to tweak parameters of the call, e.g. what object the function is called on.

godot.VisualScriptFunctionState is returned from godot.VisualScriptYield and can be used to resume a paused function call.

A Visual Script node returning a constant from @GlobalScope.

godot.VisualScriptIndexGet will return the value stored in an array or a dictionary under the given index.

godot.VisualScriptIndexSet will set the value stored in an array or a dictionary under the given index to the provided new value.

godot.VisualScriptInputAction can be used to check if an action is pressed or released.

This node steps through each item in a given input. Input can be any sequence data type, such as an godot.Collections_Array or String. When each item has been processed, execution passed out the exit Sequence port.

A Visual Script virtual class that defines the shape and the default behavior of the nodes that have to be in-graph editable nodes.

Returns a local variable's value. "Var Name" must be supplied, with an optional type.

Changes a local variable's value to the given input. The new value is also provided on an output Data port.

Provides common math constants, such as Pi, on an output Data port.

A node which is part of a godot.VisualScript. Not to be confused with godot.Node, which is a part of a godot.SceneTree.

Input Ports:

Creates a new godot.Resource or loads one from the filesystem.

godot.VisualScriptPropertyGet can return a value of any property from the current object or other objects.

godot.VisualScriptPropertySet can set the value of any property from the current object or other objects.

Ends the execution of a function and returns control to the calling function. Optionally, it can return a Variant value.

A direct reference to a node.

A Visual Script node for accessing godot.SceneTree methods.

Chooses between two input values based on a Boolean condition.

Provides a reference to the node running the visual script.

Steps through a series of one or more output Sequence ports. The current data port outputs the currently executing item.

godot.VisualScriptSubCall will call method named _subcall in the current script. It will fail if the method doesn't exist or the provided arguments are wrong.

Branches the flow based on an input's value. Use Case Count in the Inspector to set the number of branches and each comparison's optional type.

godot.VisualScriptTypeCast will perform a type conversion to an godot.Object-derived type.

Returns a variable's value. "Var Name" must be supplied, with an optional type.

Changes a variable's value to the given input.

Loops while a condition is true. Execution continues out the exit Sequence port when the loop terminates.

godot.VisualScriptYield will pause the function call and return godot.VisualScriptFunctionState, which can be used to resume the function.

godot.VisualScriptYieldSignal will pause the function execution until the provided signal is emitted.

Server for anything visible. The visual server is the API backend for everything visible. The whole scene system mounts on it to display.

This class allows you to define a custom shader program that can be used for various materials to render objects.

Visual shader graphs consist of various nodes. Each node in the graph is a separate object and they are represented as a rectangular boxes with title and a set of properties. Each node has also connection ports that allow to connect it to another nodes and control the flow of the shader.

Has only one output port and no inputs.

Translated to uniform bool in the shader language.

Has two output ports representing RGB and alpha channels of godot.Color.

Accept a godot.Color to the input port and transform it according to godot.VisualShaderNodeColorFunc.function.

Applies godot.VisualShaderNodeColorOp.operator to two color inputs.

Translated to uniform vec4 in the shader language.

Compares a and b of godot.VisualShaderNodeCompare.type by godot.VisualShaderNodeCompare.function. Returns a boolean scalar. Translates to if instruction in shader code.

Translated to texture(cubemap, vec3) in the shader language. Returns a color vector and alpha channel as scalar.

Translated to uniform samplerCube in the shader language. The output value can be used as port for godot.VisualShaderNodeCubeMap.

By inheriting this class you can create a custom godot.VisualShader script addon which will be automatically added to the Visual Shader Editor. The godot.VisualShaderNode's behavior is defined by overriding the provided virtual methods.

Translates to determinant(x) in the shader language.

Translates to dot(a, b) in the shader language.

Custom Godot Shading Language expression, with a custom amount of input and output ports.

Translates to faceforward(N, I, Nref) in the shader language. The function has three vector parameters: N, the vector to orient, I, the incident vector, and Nref, the reference vector. If the dot product of I and Nref is smaller than zero the return value is N. Otherwise, -N is returned.

Returns falloff based on the dot product of surface normal and view direction of camera (pass associated inputs to it).

Custom Godot Shader Language expression, which is placed on top of the generated shader. You can place various function definitions inside to call later in godot.VisualShaderNodeExpressions (which are injected in the main shader functions). You can also declare varyings, uniforms and global constants.

Currently, has no direct usage, use the derived classes instead.

Gives access to input variables (built-ins) available for the shader. See the shading reference for the list of available built-ins for each shader type (check Tutorials section for link).

Returns the boolean result of the comparison between INF or NaN and a scalar parameter.

OuterProduct treats the first parameter c as a column vector (matrix with one column) and the second parameter r as a row vector (matrix with one row) and does a linear algebraic matrix multiply c * r, yielding a matrix whose number of rows is the number of components in c and whose number of columns is the number of components in r.

This visual shader node is present in all shader graphs in form of "Output" block with multiple output value ports.

Constrains a value to lie between min and max values.

This node is only available in Fragment and Light visual shaders.

Translates to mix(a, b, weight) in the shader language.

Translates to smoothstep(edge0, edge1, x) in the shader language.

Returns an associated scalar if the provided boolean value is true or false.

Returns an associated vector if the provided boolean value is true or false.

Performs a lookup operation on the provided texture, with support for multiple texture sources to choose from.

Performs a lookup operation on the texture provided as a uniform for the shader.

Performs a lookup operation on the texture provided as a uniform for the shader, with support for triplanar mapping.

Creates a 4x4 transform matrix using four vectors of type vec3. Each vector is one row in the matrix and the last column is a vec4(0, 0, 0, 1).

A constant godot.Transform, which can be used as an input node.

Takes a 4x4 transform matrix and decomposes it into four vec3 values, one from each row of the matrix.

Computes an inverse or transpose function on the provided godot.Transform.

A multiplication operation on two transforms (4x4 matrices), with support for different multiplication operators.

Translated to uniform mat4 in the shader language.

A multiplication operation on a transform (4x4 matrix) and a vector, with support for different multiplication operators.

A uniform represents a variable in the shader which is set externally, i.e. from the godot.ShaderMaterial. Uniforms are exposed as properties in the godot.ShaderMaterial and can be assigned from the inspector or from a script.

Creating a reference to a godot.VisualShaderNodeUniform allows you to reuse this uniform in different shaders or shader stages easily.

A constant godot.Vector3, which can be used as an input node.

Translated to uniform vec3 in the shader language.

Constrains a value to lie between min and max values. The operation is performed on each component of the vector individually.

Creates a vec3 using three scalar values that can be provided from separate inputs.

Takes a vec3 and decomposes it into three scalar values that can be used as separate inputs.

This node is only available in Fragment and Light visual shaders.

Calculates distance from point represented by vector p0 to vector p1.

A visual shader node able to perform different functions using vectors.

Translates to mix(a, b, weight) in the shader language, where weight is a godot.Vector3 with weights for each component.

Translated to length(p0) in the shader language.

A visual shader node for use of vector operators. Operates on vector a and vector b.

Translated to refract(I, N, eta) in the shader language, where I is the incident vector, N is the normal vector and eta is the ratio of the indices of the refraction.

Translates to mix(a, b, weight) in the shader language, where a and b are vectors and weight is a scalar.

Translates to smoothstep(edge0, edge1, x) in the shader language, where x is a scalar.

Translates to step(edge, x) in the shader language.

Translates to smoothstep(edge0, edge1, x) in the shader language, where x is a vector.

A weakref can hold a godot.Reference, without contributing to the reference counter. A weakref can be created from an godot.Object using @GDScript.weakref. If this object is not a reference, weakref still works, however, it does not have any effect on the object. Weakrefs are useful in cases where multiple classes have variables that refer to each other. Without weakrefs, using these classes could lead to memory leaks, since both references keep each other from being released. Making part of the variables a weakref can prevent this cyclic dependency, and allows the references to be released.

This class constructs a full mesh of godot.WebRTCPeerConnection (one connection for each peer) that can be used as a godot.MultiplayerAPI.networkPeer.

A WebRTC connection between the local computer and a remote peer. Provides an interface to connect, maintain and monitor the connection.

This class implements a WebSocket client compatible with any RFC 6455-compliant WebSocket server.

Base class for WebSocket server and client, allowing them to be used as network peer for the godot.MultiplayerAPI.

This class represents a specific WebSocket connection, allowing you to do lower level operations with it.

This class implements a WebSocket server that can also support the high-level multiplayer API.

WebXR is an open standard that allows creating VR and AR applications that run in the web browser.

Windowdialog is the base class for all window-based dialogs. It's a by-default toplevel godot.Control that draws a window decoration and allows motion and resizing.

Class that has everything pertaining to a world. A physics space, a visual scenario and a sound space. Spatial nodes register their resources into the current world.

Class that has everything pertaining to a 2D world. A physics space, a visual scenario and a sound space. 2D nodes register their resources into the current 2D world.

The godot.WorldEnvironment node is used to configure the default godot.Environment for the scene.

The X509Certificate class represents an X509 certificate. Certificates can be loaded and saved like any other godot.Resource.

This class can serve as base to make custom XML parsers. Since XML is a very flexible standard, this interface is low-level so it can be applied to any possible schema.

Sort all child nodes based on their Y positions. The child node must inherit from godot.CanvasItem for it to be sorted. Nodes that have a higher Y position will be drawn later, so they will appear on top of nodes that have a lower Y position.