godot version 3.4.5

Haxe/C# externs for the Godot game engine

collections
AABB

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

AESContext

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

AESContext_Mode

ARVRAnchor

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.

ARVRCamera

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.

ARVRController

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.

ARVRInterface

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.

ARVRInterfaceGDNative

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.

ARVRInterface_Capabilities

ARVRInterface_Eyes

ARVRInterface_Tracking_status

ARVROrigin

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.

ARVRPositionalTracker

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.

ARVRPositionalTracker_TrackerHand

ARVRServer

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

ARVRServer_RotationMode

ARVRServer_TrackerType

AStar

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.

AStar2D

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

AcceptDialog

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

Action

The list of actions defined in the project settings.

AnimatedSprite

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

AnimatedSprite3D

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

AnimatedTexture

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.

Animation

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.

AnimationNode

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

AnimationNodeAdd2

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

AnimationNodeAdd3

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.

AnimationNodeAnimation

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.

AnimationNodeBlend2

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

AnimationNodeBlend3

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.

AnimationNodeBlendSpace1D

A resource to add to an godot.AnimationNodeBlendTree.

AnimationNodeBlendSpace2D

A resource to add to an godot.AnimationNodeBlendTree.

AnimationNodeBlendSpace2D_BlendModeEnum

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.

AnimationNodeOneShot

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.

AnimationNodeOneShot_MixModeEnum

AnimationNodeOutput

AnimationNodeStateMachine

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.

AnimationNodeStateMachinePlayback

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

AnimationNodeStateMachineTransition

AnimationNodeStateMachineTransition_SwitchModeEnum

AnimationNodeTimeScale

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

AnimationNodeTimeSeek

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.

AnimationNodeTransition

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.

AnimationNode_FilterAction

AnimationPlayer

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.

AnimationPlayer_AnimationMethodCallMode

AnimationPlayer_AnimationProcessMode

AnimationRootNode

AnimationTree

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

AnimationTreePlayer

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.

AnimationTreePlayer_AnimationProcessMode

AnimationTreePlayer_NodeType

AnimationTree_AnimationProcessMode

Animation_InterpolationType

Animation_TrackType

Animation_UpdateMode

Area

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.

Area2D

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.

Area2D_SpaceOverrideEnum

Area_SpaceOverrideEnum

ArrayMesh

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

ArrayMesh_ArrayFormat

ArrayMesh_ArrayType

AspectRatioContainer

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.

AspectRatioContainer_AlignMode

AspectRatioContainer_StretchModeEnum

AtlasTexture

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.

AudioBusLayout

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

AudioEffect

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

AudioEffectAmplify

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

AudioEffectBandLimitFilter

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

AudioEffectBandPassFilter

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

AudioEffectCapture

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

AudioEffectChorus

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

AudioEffectCompressor

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

AudioEffectDelay

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

AudioEffectDistortion

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

AudioEffectDistortion_ModeEnum

AudioEffectEQ

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

AudioEffectEQ10

Frequency bands:

AudioEffectEQ21

Frequency bands:

AudioEffectEQ6

Frequency bands:

AudioEffectFilter

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

AudioEffectFilter_FilterDB

AudioEffectHighPassFilter

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

AudioEffectHighShelfFilter

AudioEffectInstance

AudioEffectLimiter

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

AudioEffectLowPassFilter

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

AudioEffectLowShelfFilter

AudioEffectNotchFilter

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

AudioEffectPanner

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

AudioEffectPhaser

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

AudioEffectPitchShift

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

AudioEffectPitchShift_FFT_Size

AudioEffectRecord

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

AudioEffectReverb

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

AudioEffectSpectrumAnalyzer

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

AudioEffectSpectrumAnalyzerInstance

AudioEffectSpectrumAnalyzerInstance_MagnitudeMode

AudioEffectSpectrumAnalyzer_FFT_Size

AudioEffectStereoEnhance

AudioServer

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.

AudioServer_SpeakerMode

AudioStream

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.

AudioStreamGenerator

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

AudioStreamGeneratorPlayback

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

AudioStreamMP3

MP3 audio stream driver.

AudioStreamMicrophone

AudioStreamOGGVorbis

OGG Vorbis audio stream driver.

AudioStreamPlayback

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

AudioStreamPlaybackResampled

AudioStreamPlayer

Plays an audio stream non-positionally.

AudioStreamPlayer2D

Plays audio that dampens with distance from screen center.

AudioStreamPlayer3D

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.

AudioStreamPlayer3D_AttenuationModelEnum

AudioStreamPlayer3D_DopplerTrackingEnum

AudioStreamPlayer3D_OutOfRangeModeEnum

AudioStreamPlayer_MixTargetEnum

AudioStreamRandomPitch

Randomly varies pitch on each start.

AudioStreamSample

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.

AudioStreamSample_FormatEnum

AudioStreamSample_LoopModeEnum

BackBufferCopy

Node for back-buffering the currently-displayed screen. The region defined in the BackBufferCopy node is buffered with the content of the screen it covers, or the entire screen according to the copy mode set. Use the texture(SCREEN_TEXTURE, ...) function in your shader scripts to access the buffer.

BackBufferCopy_CopyModeEnum

BakedLightmap

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.

BakedLightmapData

BakedLightmap_BakeError

BakedLightmap_BakeQuality

BakedLightmap_EnvironmentModeEnum

BaseButton

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.

BaseButton_ActionModeEnum

BaseButton_DrawMode

Basis

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

BitMap

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

BitmapFont

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

Bone2D

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

BoneAttachment

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.

BoxContainer

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

BoxContainer_AlignMode

BoxShape

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

Button

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

ButtonGroup

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

ButtonList

Button_TextAlign

CPUParticles

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

CPUParticles2D

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

CPUParticles2D_DrawOrderEnum

CPUParticles2D_EmissionShapeEnum

CPUParticles2D_Flags

CPUParticles2D_Parameter

CPUParticles_DrawOrderEnum

CPUParticles_EmissionShapeEnum

CPUParticles_Flags

CPUParticles_Parameter

CSGBox

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

CSGCombiner

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.

CSGCylinder

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

CSGMesh

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.

CSGPolygon

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.

CSGPolygon_ModeEnum

CSGPolygon_PathIntervalTypeEnum

CSGPolygon_PathRotationEnum

CSGPrimitive

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.

CSGShape

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

CSGShape_OperationEnum

CSGSphere

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

CSGTorus

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

CSharpScript

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

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.

Camera2D

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.

Camera2D_AnchorModeEnum

Camera2D_Camera2DProcessMode

CameraFeed

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.

CameraFeed_FeedDataType

CameraFeed_FeedPosition

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.

CameraServer_FeedImage

CameraTexture

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

Camera_DopplerTrackingEnum

Camera_KeepAspectEnum

Camera_ProjectionEnum

CanvasItem

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.

CanvasItemMaterial

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.

CanvasItemMaterial_BlendModeEnum

CanvasItemMaterial_LightModeEnum

CanvasItem_BlendMode

CanvasLayer

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

CanvasModulate

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

CapsuleMesh

Class representing a capsule-shaped godot.PrimitiveMesh.

CapsuleShape

Capsule shape for collisions.

CapsuleShape2D

Capsule shape for 2D collisions.

CenterContainer

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

CharFXTransform

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

CheckBox

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

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.

CircleShape2D

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.

ClassDB

Provides access to metadata stored for every available class.

ClippedCamera

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

ClippedCamera_ProcessModeEnum

CollisionObject

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

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.

CollisionPolygon

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.

CollisionPolygon2D

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

CollisionPolygon2D_BuildModeEnum

CollisionShape

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.

CollisionShape2D

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.

Color

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

ColorPicker

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

ColorPickerButton

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

ColorRect

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

Colors

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

ConcavePolygonShape

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

ConcavePolygonShape2D

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.

ConeTwistJoint

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

ConeTwistJoint_Param

ConfigFile

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:

ConfirmationDialog

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

Container

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

Control

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.

Control_Anchor

Control_CursorShape

Control_FocusModeEnum

Control_GrowDirection

Control_LayoutPreset

Control_LayoutPresetMode

Control_MouseFilterEnum

Control_SizeFlags

ConvexPolygonShape

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

ConvexPolygonShape2D

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

Corner

Crypto

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

CryptoKey

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

CubeMap

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.

CubeMap_FlagsEnum

CubeMap_Side

CubeMap_Storage

CubeMesh

Generate an axis-aligned cuboid godot.PrimitiveMesh.

CullInstance

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

CullInstance_PortalModeEnum

Curve

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.

Curve2D

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.

Curve3D

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.

CurveTexture

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

Curve_TangentMode

CustomSignal

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

CylinderMesh

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.

CylinderShape

Cylinder shape for collisions.

DTLSServer

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.

DampedSpringJoint2D

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

DirectionalLight

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.

DirectionalLight_ShadowDepthRange

DirectionalLight_ShadowMode

Directory

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

Dispatcher

DynamicFont

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.

DynamicFontData

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

DynamicFontData_HintingEnum

DynamicFont_SpacingType

EditorExportPlugin

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.

EditorFeatureProfile

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

EditorFeatureProfile_Feature

EditorFileDialog

EditorFileDialog_AccessEnum

EditorFileDialog_DisplayModeEnum

EditorFileDialog_ModeEnum

EditorFileSystem

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

EditorFileSystemDirectory

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

EditorImportPlugin

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.

EditorInspector

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.

EditorInspectorPlugin

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

EditorInterface

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

EditorPlugin

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

EditorPlugin_CustomControlContainer

EditorPlugin_DockSlot

EditorProperty

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

EditorResourcePicker

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.

EditorResourcePreview

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

EditorResourcePreviewGenerator

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

EditorSceneImporter

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

EditorSceneImporterFBX

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

EditorScenePostImport

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

EditorScript

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.

EditorScriptPicker

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.

EditorSelection

This object manages the SceneTree selection in the editor.

EditorSettings

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

EditorSpatialGizmo

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

EditorSpatialGizmoPlugin

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.

EditorSpinSlider

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.

EditorVCSInterface

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.

EncodedObjectAsID

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.

Engine

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.

Environment

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:

Environment_BGMode

Environment_DOFBlurQuality

Environment_GlowBlendModeEnum

Environment_SSAOBlur

Environment_SSAOQuality

Environment_ToneMapper

Error

ExportAttribute

Expression

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.

ExternalTexture

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

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

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.

FileDialog_AccessEnum

FileDialog_ModeEnum

FileSystemDock

File_CompressionMode

File_ModeFlags

Font

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.

FuncRef

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.

GD

Godot's global functions.

GDNative

GDNativeLibrary

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.

GDScript

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

GDScriptFunctionState

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.

GIProbe

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.

GIProbeData

GIProbe_SubdivEnum

GLTFLight

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.

Generic6DOFJoint

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.

Generic6DOFJoint_Flag

Generic6DOFJoint_Param

Geometry

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

GeometryInstance

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

GeometryInstance_Flags

GeometryInstance_LightmapScaleEnum

GeometryInstance_ShadowCastingSetting

Geometry_PolyBooleanOperation

Geometry_PolyEndType

Geometry_PolyJoinType

GodotSharp

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.

GodotSynchronizationContext

GodotTaskScheduler

Gradient

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

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

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.

GraphNode

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.

GraphNode_OverlayEnum

GridContainer

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

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.

GrooveJoint2D

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

HAlign

HBoxContainer

Horizontal box container. See godot.BoxContainer.

HMACContext

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

HScrollBar

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

HSeparator

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

HSlider

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

HSplitContainer

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

HTTPClient

Hyper-text transfer protocol client (sometimes called "User Agent"). Used to make HTTP requests to download web content, upload files and other data or to communicate with various services, among other use cases. See the godot.HTTPRequest node for a higher-level alternative.

HTTPClient_Method

HTTPClient_ResponseCode

HTTPClient_Status

HTTPRequest

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

HTTPRequest_Result

HashingContext

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

HashingContext_HashType

HeightMapShape

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

HingeJoint

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.

HingeJoint_Flag

HingeJoint_Param

IAwaitable

IAwaitable_1

IAwaiter

IAwaiter_1

IP

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.

IP_ResolverStatus

IP_Type

ISerializationListener

Image

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.

ImageTexture

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:

ImageTexture_StorageEnum

Image_AlphaMode

Image_CompressMode

Image_CompressSource

Image_Format

Image_Interpolation

ImmediateGeometry

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

Input

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.

InputEvent

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

InputEventAction

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.

InputEventGesture

InputEventJoypadButton

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

InputEventJoypadMotion

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

InputEventKey

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

InputEventMIDI

InputEventMagnifyGesture

InputEventMouse

Stores general mouse events information.

InputEventMouseButton

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

InputEventMouseMotion

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

InputEventPanGesture

InputEventScreenDrag

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

InputEventScreenTouch

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

InputEventWithModifiers

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

InputMap

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.

Input_CursorShape

Input_MouseMode

InstancePlaceholder

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.

InterpolatedCamera

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.

ItemList

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.

ItemList_IconModeEnum

ItemList_SelectModeEnum

JNISingleton

The JNISingleton is implemented only in the Android export. It's used to call methods and connect signals from an Android plugin written in Java or Kotlin. Methods and signals can be called and connected to the JNISingleton as if it is a Node. See [https://en.wikipedia.org/wiki/Java_Native_Interface](Java Native Interface - Wikipedia) for more information.

JSON

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

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.

JSONRPC

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

JSONRPC_ErrorCode

JavaScript

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

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

Joint

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.

Joint2D

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

JoystickList

KeyList

KeyModifierMask

KinematicBody

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:

KinematicBody2D

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:

KinematicCollision

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.

KinematicCollision2D

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

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.

Label_AlignEnum

Label_VAlign

LargeTexture

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

Light

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.

Light2D

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

Light2D_ModeEnum

Light2D_ShadowFilterEnum

LightOccluder2D

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.

Light_BakeMode

Light_Param

Line2D

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

Line2D_LineCapMode

Line2D_LineJointMode

Line2D_LineTextureMode

LineEdit

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

LineEdit_AlignEnum

LineEdit_MenuItems

LineShape2D

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.

LinkButton

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

LinkButton_UnderlineMode

Listener

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.

Listener2D

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.

MainLoop

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.

Margin

MarginContainer

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.

Marshalls

Provides data transformation and encoding utility functions.

MasterAttribute

MasterSyncAttribute

Material

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.

Mathf

Provides constants and static methods for common mathematical functions.

MenuButton

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

Mesh

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

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

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.

MeshInstance2D

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

MeshLibrary

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.

MeshTexture

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

Mesh_ArrayFormat

Mesh_ArrayType

Mesh_BlendShapeMode

Mesh_PrimitiveType

MethodFlags

MidiMessageList

MobileVRInterface

This is a generic mobile VR implementation where you need to provide details about the phone and HMD used. It does not rely on any existing framework. This is the most basic interface we have. For the best effect, you need a mobile phone with a gyroscope and accelerometer.

MultiMesh

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.

MultiMeshInstance

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

MultiMeshInstance2D

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

MultiMesh_ColorFormatEnum

MultiMesh_CustomDataFormatEnum

MultiMesh_TransformFormatEnum

MultiplayerAPI

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

MultiplayerAPI_RPCMode

MultiplayerPeerGDNative

Mutex

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.

NativeScript

Navigation

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

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.

NavigationMesh

A navigation mesh is a collection of polygons that define which areas of an environment are traversable to aid agents in pathfinding through complicated spaces.

NavigationMeshInstance

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

NavigationMesh_ParsedGeometryType

NavigationMesh_SamplePartitionType

NavigationMesh_SourceGeometryMode

NavigationPolygon

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

NavigationPolygonInstance

NetworkedMultiplayerENet

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.

NetworkedMultiplayerENet_CompressionModeEnum

NetworkedMultiplayerPeer

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

NetworkedMultiplayerPeer_ConnectionStatus

NetworkedMultiplayerPeer_TransferModeEnum

NinePatchRect

Also known as 9-slice panels, NinePatchRect produces clean panels of any size, based on a small texture. To do so, it splits the texture in a 3×3 grid. When you scale the node, it tiles the texture's sides horizontally or vertically, the center on both axes but it doesn't scale or tile the corners.

NinePatchRect_AxisStretchMode

Node

Nodes are Godot's building blocks. They can be assigned as the child of another node, resulting in a tree arrangement. A given node can contain any number of nodes as children with the requirement that all siblings (direct children of a node) should have unique names.

Node2D

A 2D game object, with a transform (position, rotation, and scale). All 2D nodes, including physics objects and sprites, inherit from Node2D. Use Node2D as a parent node to move, scale and rotate children in a 2D project. Also gives control of the node's render order.

NodePath

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.

Node_DuplicateFlags

Node_PauseModeEnum

NoiseTexture

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.

OS

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.

OS_HandleType

OS_Month

OS_PowerState

OS_ScreenOrientationEnum

OS_SystemDir

OS_VideoDriver

OS_Weekday

Object

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

Object_ConnectFlags

Occluder

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.

OccluderPolygon2D

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

OccluderPolygon2D_CullModeEnum

OccluderShape

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

OccluderShapeSphere

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

OmniLight

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.

OmniLight_ShadowDetail

OmniLight_ShadowMode

OpenSimplexNoise

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

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.

Orientation

PCKPacker

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

PHashTranslation

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

PackedDataContainer

PackedDataContainerRef

PackedScene

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

PackedScene_GenEditState

PacketPeer

PacketPeer is an abstraction and base class for packet-based protocols (such as UDP). It provides an API for sending and receiving packets both as raw data or variables. This makes it easy to transfer data over a protocol, without having to encode data as low-level bytes or having to worry about network ordering.

PacketPeerDTLS

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

PacketPeerDTLS_Status

PacketPeerGDNative

PacketPeerStream

PacketStreamPeer provides a wrapper for working using packets over a stream. This allows for using packet based code with StreamPeers. PacketPeerStream implements a custom protocol over the StreamPeer, so the user should not read or write to the wrapped StreamPeer directly.

PacketPeerUDP

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

Panel

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.

PanelContainer

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

PanoramaSky

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.

ParallaxBackground

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.

ParallaxLayer

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.

Particles

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.

Particles2D

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.

Particles2D_DrawOrderEnum

ParticlesMaterial

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

ParticlesMaterial_EmissionShapeEnum

ParticlesMaterial_Flags

ParticlesMaterial_Parameter

Particles_DrawOrderEnum

Path

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

Path2D

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

PathFollow

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

PathFollow2D

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

PathFollow_RotationModeEnum

Performance

This class provides access to a number of different monitors related to performance, such as memory usage, draw calls, and FPS. These are the same as the values displayed in the Monitor tab in the editor's Debugger panel. By using the godot.Performance.getMonitor method of this class, you can access this data from your code.

Performance_Monitor

PhysicalBone

PhysicalBone_JointTypeEnum

Physics2DDirectBodyState

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.

Physics2DDirectSpaceState

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

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.

Physics2DServer_AreaBodyStatus

Physics2DServer_AreaParameter

Physics2DServer_AreaSpaceOverrideMode

Physics2DServer_BodyMode

Physics2DServer_BodyParameter

Physics2DServer_BodyState

Physics2DServer_CCDMode

Physics2DServer_DampedStringParam

Physics2DServer_JointParam

Physics2DServer_JointType

Physics2DServer_ProcessInfo

Physics2DServer_ShapeType

Physics2DServer_SpaceParameter

Physics2DShapeQueryParameters

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

Physics2DTestMotionResult

PhysicsBody

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

PhysicsBody2D

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

PhysicsDirectBodyState

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.

PhysicsDirectSpaceState

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.

PhysicsMaterial

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

PhysicsServer

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.

PhysicsServer_AreaBodyStatus

PhysicsServer_AreaParameter

PhysicsServer_AreaSpaceOverrideMode

PhysicsServer_BodyAxis

PhysicsServer_BodyMode

PhysicsServer_BodyParameter

PhysicsServer_BodyState

PhysicsServer_ConeTwistJointParam

PhysicsServer_G6DOFJointAxisFlag

PhysicsServer_G6DOFJointAxisParam

PhysicsServer_HingeJointFlag

PhysicsServer_HingeJointParam

PhysicsServer_JointType

PhysicsServer_PinJointParam

PhysicsServer_ProcessInfo

PhysicsServer_ShapeType

PhysicsServer_SliderJointParam

PhysicsServer_SpaceParameter

PhysicsShapeQueryParameters

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

PhysicsTestMotionResult

PinJoint

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

PinJoint2D

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

PinJoint_Param

Plane

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

PlaneMesh

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.

PlaneShape

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.

PluginScript

PointMesh

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

Polygon2D

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.

PolygonPathFinder

Popup

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

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

PopupMenu

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

PopupPanel

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.

Portal

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.

Position2D

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.

Position3D

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.

PrimitiveMesh

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.

PrismMesh

Class representing a prism-shaped godot.PrimitiveMesh.

ProceduralSky

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.

ProceduralSky_TextureSizeEnum

ProgressBar

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

ProjectSettings

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.

PropertyHint

PropertyUsageFlags

ProximityGroup

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.

ProximityGroup_DispatchModeEnum

ProxyTexture

PuppetAttribute

PuppetSyncAttribute

QuadMesh

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.

Quat

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

RID

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

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

Range

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.

RayCast

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.

RayCast2D

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.

RayShape

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.

RayShape2D

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.

Rect2

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

RectangleShape2D

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

Reference

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

ReferenceRect

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.

ReflectionProbe

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

ReflectionProbe_UpdateModeEnum

RegEx

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.

RegExMatch

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.

RemoteAttribute

RemoteSyncAttribute

RemoteTransform

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

RemoteTransform2D

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

Resource

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.

ResourceFormatLoader

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.

ResourceFormatSaver

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.

ResourceImporter

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

ResourceImporter_ImportOrder

ResourceInteractiveLoader

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.

ResourceLoader

Singleton used to load resource files from the filesystem.

ResourcePreloader

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.

ResourceSaver

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

ResourceSaver_SaverFlags

RichTextEffect

A custom effect for use with godot.RichTextLabel.

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.

RichTextLabel_Align

RichTextLabel_ItemType

RichTextLabel_ListType

RigidBody

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.

RigidBody2D

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.

RigidBody2D_CCDMode

RigidBody2D_ModeEnum

RigidBody_ModeEnum

Room

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

RoomGroup

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

RoomManager

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.

RoomManager_PVSMode

SceneState

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

SceneState_GenEditState

SceneTree

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.

SceneTreeTimer

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

SceneTree_GroupCallFlags

SceneTree_StretchAspect

SceneTree_StretchMode

Script

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

ScriptCreateDialog

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.

ScriptEditor

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

ScrollBar

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.

ScrollContainer

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

SegmentShape2D

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

Semaphore

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

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.

Shader

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.

ShaderMaterial

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.

Shader_Mode

Shape

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.

Shape2D

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

ShortCut

A shortcut for binding input.

Signal

Typesafe signal.

SignalAttribute

SignalAwaiter

Skeleton

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

Skeleton2D

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

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.

Skin

SkinReference

Sky

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

Sky_RadianceSizeEnum

SlaveAttribute

Slider

Base class for GUI sliders.

SliderJoint

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

SliderJoint_Param

SoftBody

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

Spatial

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.

SpatialGizmo

SpatialMaterial

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.

SpatialMaterial_BillboardMode

SpatialMaterial_BlendMode

SpatialMaterial_CullMode

SpatialMaterial_DepthDrawMode

SpatialMaterial_DetailUV

SpatialMaterial_DiffuseMode

SpatialMaterial_DistanceFadeModeEnum

SpatialMaterial_EmissionOperatorEnum

SpatialMaterial_Feature

SpatialMaterial_Flags

SpatialMaterial_SpecularMode

SpatialMaterial_TextureChannel

SpatialMaterial_TextureParam

SpatialVelocityTracker

SphereMesh

Class representing a spherical godot.PrimitiveMesh.

SphereShape

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

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

SplitContainer

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

SplitContainer_DraggerVisibilityEnum

SpotLight

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.

SpringArm

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.

Sprite

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.

Sprite3D

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.

SpriteBase3D

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

SpriteBase3D_AlphaCutMode

SpriteBase3D_DrawFlags

SpriteFrames

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

StaticBody

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.

StaticBody2D

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

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.

StreamPeerBuffer

StreamPeerGDNative

StreamPeerSSL

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

StreamPeerSSL_Status

StreamPeerTCP

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

StreamPeerTCP_Status

StreamTexture

A texture that is loaded from a .stex file.

StringExtensions

Extension methods to manipulate strings.

StyleBox

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.

StyleBoxEmpty

Empty stylebox (really does not display anything).

StyleBoxFlat

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

StyleBoxLine

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

StyleBoxTexture

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.

StyleBoxTexture_AxisStretchMode

SurfaceTool

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:

SyncAttribute

TCP_Server

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

TabContainer

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.

TabContainer_TabAlignEnum

Tabs

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

Tabs_CloseButtonDisplayPolicy

Tabs_TabAlignEnum

TextEdit

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.

TextEdit_MenuItems

TextEdit_SearchFlags

TextEdit_SearchResult

TextFile

Texture

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

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

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.

TextureButton

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.

TextureButton_StretchModeEnum

TextureLayered

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.

TextureLayered_FlagsEnum

TextureProgress

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.

TextureProgress_FillModeEnum

TextureRect

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.

TextureRect_StretchModeEnum

Texture_FlagsEnum

Theme

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.

Theme_DataType

Thread

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.

Thread_Priority

TileMap

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.

TileMap_HalfOffset

TileMap_ModeEnum

TileMap_TileOrigin

TileSet

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.

TileSet_AutotileBindings

TileSet_BitmaskMode

TileSet_TileMode

Timer

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

Timer_TimerProcessMode

ToolAttribute

ToolButton

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

TouchScreenButton

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.

TouchScreenButton_VisibilityModeEnum

Transform

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

Transform2D

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.

Translation

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

TranslationServer

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

Tree

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.

TreeItem

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

TreeItem_TextAlign

TreeItem_TreeCellMode

Tree_DropModeFlagsEnum

Tree_SelectModeEnum

TriangleMesh

Mesh type used internally for collision calculations.

Tween

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.

Tween_EaseType

Tween_TransitionType

Tween_TweenProcessMode

UDPServer

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

UPNP

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.

UPNPDevice

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.

UPNPDevice_IGDStatus

UPNP_UPNPResult

UndoRedo

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

UndoRedo_MergeMode

UnhandledExceptionArgs

Event arguments for when unhandled exceptions occur.

Utils

VAlign

VBoxContainer

Vertical box container. See godot.BoxContainer.

VScrollBar

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

VSeparator

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

VSlider

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

VSplitContainer

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

Variant

Variant_Operator

Variant_Type

Vector2

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

Vector2_Axis

Enumerated index values for the axes. Returned by godot.Vector2.maxAxis and godot.Vector2.minAxis.

Vector3

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

Vector3_Axis

Enumerated index values for the axes. Returned by godot.Vector3.maxAxis and godot.Vector3.minAxis.

VehicleBody

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.

VehicleWheel

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.

VideoPlayer

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

VideoStream

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.

VideoStreamGDNative

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

VideoStreamTheora

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.

VideoStreamWebm

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.

Viewport

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.

ViewportContainer

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

ViewportTexture

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.

Viewport_ClearMode

Viewport_DebugDrawEnum

Viewport_MSAA

Viewport_RenderInfo

Viewport_ShadowAtlasQuadrantSubdiv

Viewport_UpdateMode

Viewport_UsageEnum

VisibilityEnabler

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.

VisibilityEnabler2D

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.

VisibilityEnabler2D_Enabler

VisibilityEnabler_Enabler

VisibilityNotifier

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.

VisibilityNotifier2D

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.

VisualInstance

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.

VisualScript

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

VisualScriptBasicTypeConstant

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

VisualScriptBuiltinFunc

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

VisualScriptBuiltinFunc_BuiltinFunc

VisualScriptClassConstant

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

VisualScriptComment

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

VisualScriptComposeArray

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.

VisualScriptCondition

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.

VisualScriptConstant

This node returns a constant's value.

VisualScriptConstructor

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

VisualScriptCustomNode

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

VisualScriptCustomNode_StartMode

VisualScriptDeconstruct

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

VisualScriptEditor

VisualScriptEmitSignal

Emits a specified signal when it is executed.

VisualScriptEngineSingleton

A Visual Script node returning a singleton from @GlobalScope.

VisualScriptExpression

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.

VisualScriptFunction

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

VisualScriptFunctionCall

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.

VisualScriptFunctionCall_CallModeEnum

VisualScriptFunctionCall_RPCCallMode

VisualScriptFunctionState

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

VisualScriptGlobalConstant

A Visual Script node returning a constant from @GlobalScope.

VisualScriptIndexGet

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

VisualScriptIndexSet

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

VisualScriptInputAction

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

VisualScriptInputAction_ModeEnum

VisualScriptIterator

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.

VisualScriptLists

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

VisualScriptLocalVar

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

VisualScriptLocalVarSet

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

VisualScriptMathConstant

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

VisualScriptMathConstant_MathConstant

VisualScriptNode

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

VisualScriptOperator

Input Ports:

VisualScriptPreload

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

VisualScriptPropertyGet

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

VisualScriptPropertyGet_CallMode

VisualScriptPropertySet

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

VisualScriptPropertySet_AssignOpEnum

VisualScriptPropertySet_CallMode

VisualScriptResourcePath

VisualScriptReturn

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

VisualScriptSceneNode

A direct reference to a node.

VisualScriptSceneTree

A Visual Script node for accessing godot.SceneTree methods.

VisualScriptSelect

Chooses between two input values based on a Boolean condition.

VisualScriptSelf

Provides a reference to the node running the visual script.

VisualScriptSequence

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

VisualScriptSubCall

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.

VisualScriptSwitch

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.

VisualScriptTypeCast

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

VisualScriptVariableGet

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

VisualScriptVariableSet

Changes a variable's value to the given input.

VisualScriptWhile

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

VisualScriptYield

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

VisualScriptYieldSignal

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

VisualScriptYieldSignal_CallModeEnum

VisualScriptYield_YieldMode

VisualServer

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

VisualServer_ArrayFormat

VisualServer_ArrayType

VisualServer_BlendShapeMode

VisualServer_CanvasLightMode

VisualServer_CanvasLightShadowFilter

VisualServer_CanvasOccluderPolygonCullMode

VisualServer_CubeMapSide

VisualServer_EnvironmentBG

VisualServer_EnvironmentDOFBlurQuality

VisualServer_EnvironmentGlowBlendMode

VisualServer_EnvironmentSSAOBlur

VisualServer_EnvironmentSSAOQuality

VisualServer_EnvironmentToneMapper

VisualServer_Features

VisualServer_InstanceFlags

VisualServer_InstanceType

VisualServer_LightBakeMode

VisualServer_LightDirectionalShadowDepthRangeMode

VisualServer_LightDirectionalShadowMode

VisualServer_LightOmniShadowDetail

VisualServer_LightOmniShadowMode

VisualServer_LightParam

VisualServer_LightType

VisualServer_MultimeshColorFormat

VisualServer_MultimeshCustomDataFormat

VisualServer_MultimeshTransformFormat

VisualServer_NinePatchAxisMode

VisualServer_ParticlesDrawOrder

VisualServer_PrimitiveType

VisualServer_ReflectionProbeUpdateMode

VisualServer_RenderInfo

VisualServer_ScenarioDebugMode

VisualServer_ShaderMode

VisualServer_ShadowCastingSetting

VisualServer_TextureFlags

VisualServer_TextureType

VisualServer_ViewportClearMode

VisualServer_ViewportDebugDraw

VisualServer_ViewportMSAA

VisualServer_ViewportRenderInfo

VisualServer_ViewportUpdateMode

VisualServer_ViewportUsage

VisualShader

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

VisualShaderNode

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.

VisualShaderNodeBooleanConstant

Has only one output port and no inputs.

VisualShaderNodeBooleanUniform

Translated to uniform bool in the shader language.

VisualShaderNodeColorConstant

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

VisualShaderNodeColorFunc

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

VisualShaderNodeColorFunc_FunctionEnum

VisualShaderNodeColorOp

Applies godot.VisualShaderNodeColorOp.operator to two color inputs.

VisualShaderNodeColorOp_OperatorEnum

VisualShaderNodeColorUniform

Translated to uniform vec4 in the shader language.

VisualShaderNodeCompare

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

VisualShaderNodeCompare_ComparisonType

VisualShaderNodeCompare_ConditionEnum

VisualShaderNodeCompare_FunctionEnum

VisualShaderNodeCubeMap

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

VisualShaderNodeCubeMapUniform

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

VisualShaderNodeCubeMap_SourceEnum

VisualShaderNodeCubeMap_TextureTypeEnum

VisualShaderNodeCustom

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.

VisualShaderNodeDeterminant

Translates to determinant(x) in the shader language.

VisualShaderNodeDotProduct

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

VisualShaderNodeExpression

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

VisualShaderNodeFaceForward

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.

VisualShaderNodeFresnel

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

VisualShaderNodeGlobalExpression

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.

VisualShaderNodeGroupBase

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

VisualShaderNodeIf

VisualShaderNodeInput

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

VisualShaderNodeIs

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

VisualShaderNodeIs_FunctionEnum

VisualShaderNodeOuterProduct

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.

VisualShaderNodeOutput

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

VisualShaderNodeScalarClamp

Constrains a value to lie between min and max values.

VisualShaderNodeScalarConstant

VisualShaderNodeScalarDerivativeFunc

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

VisualShaderNodeScalarDerivativeFunc_FunctionEnum

VisualShaderNodeScalarFunc

VisualShaderNodeScalarFunc_FunctionEnum

VisualShaderNodeScalarInterp

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

VisualShaderNodeScalarOp

VisualShaderNodeScalarOp_OperatorEnum

VisualShaderNodeScalarSmoothStep

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

VisualShaderNodeScalarSwitch

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

VisualShaderNodeScalarUniform

VisualShaderNodeSwitch

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

VisualShaderNodeTexture

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

VisualShaderNodeTextureUniform

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

VisualShaderNodeTextureUniformTriplanar

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

VisualShaderNodeTextureUniform_ColorDefaultEnum

VisualShaderNodeTextureUniform_TextureTypeEnum

VisualShaderNodeTexture_SourceEnum

VisualShaderNodeTexture_TextureTypeEnum

VisualShaderNodeTransformCompose

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

VisualShaderNodeTransformConstant

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

VisualShaderNodeTransformDecompose

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

VisualShaderNodeTransformFunc

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

VisualShaderNodeTransformFunc_FunctionEnum

VisualShaderNodeTransformMult

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

VisualShaderNodeTransformMult_OperatorEnum

VisualShaderNodeTransformUniform

Translated to uniform mat4 in the shader language.

VisualShaderNodeTransformVecMult

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

VisualShaderNodeTransformVecMult_OperatorEnum

VisualShaderNodeUniform

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.

VisualShaderNodeUniformRef

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

VisualShaderNodeVec3Constant

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

VisualShaderNodeVec3Uniform

Translated to uniform vec3 in the shader language.

VisualShaderNodeVectorClamp

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

VisualShaderNodeVectorCompose

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

VisualShaderNodeVectorDecompose

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

VisualShaderNodeVectorDerivativeFunc

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

VisualShaderNodeVectorDerivativeFunc_FunctionEnum

VisualShaderNodeVectorDistance

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

VisualShaderNodeVectorFunc

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

VisualShaderNodeVectorFunc_FunctionEnum

VisualShaderNodeVectorInterp

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

VisualShaderNodeVectorLen

Translated to length(p0) in the shader language.

VisualShaderNodeVectorOp

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

VisualShaderNodeVectorOp_OperatorEnum

VisualShaderNodeVectorRefract

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.

VisualShaderNodeVectorScalarMix

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

VisualShaderNodeVectorScalarSmoothStep

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

VisualShaderNodeVectorScalarStep

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

VisualShaderNodeVectorSmoothStep

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

VisualShaderNode_PortType

VisualShader_Type

WeakRef

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.

WebRTCDataChannel

WebRTCDataChannelGDNative

WebRTCDataChannel_ChannelState

WebRTCDataChannel_WriteModeEnum

WebRTCMultiplayer

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

WebRTCPeerConnection

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

WebRTCPeerConnectionGDNative

WebRTCPeerConnection_ConnectionState

WebSocketClient

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

WebSocketMultiplayerPeer

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

WebSocketPeer

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

WebSocketPeer_WriteMode

WebSocketServer

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

WebXRInterface

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

WindowDialog

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.

World

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.

World2D

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.

WorldEnvironment

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

X509Certificate

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

XMLParser

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.

XMLParser_NodeType

YSort

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.