gd

type AABB ¶

type AABB = gd.AABB

type AESContext ¶

type AESContext = classdb.AESContext

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

var aes = AESContext.new()

func _ready():

var key = "My secret key!!!" # Key must be either 16 or 32 bytes.
var data = "My secret text!!" # Data size must be multiple of 16 bytes, apply padding if needed.
# Encrypt ECB
aes.start(AESContext.MODE_ECB_ENCRYPT, key.to_utf8_buffer())
var encrypted = aes.update(data.to_utf8_buffer())
aes.finish()
# Decrypt ECB
aes.start(AESContext.MODE_ECB_DECRYPT, key.to_utf8_buffer())
var decrypted = aes.update(encrypted)
aes.finish()
# Check ECB
assert(decrypted == data.to_utf8_buffer())

var iv = "My secret iv!!!!" # IV must be of exactly 16 bytes.
# Encrypt CBC
aes.start(AESContext.MODE_CBC_ENCRYPT, key.to_utf8_buffer(), iv.to_utf8_buffer())
encrypted = aes.update(data.to_utf8_buffer())
aes.finish()
# Decrypt CBC
aes.start(AESContext.MODE_CBC_DECRYPT, key.to_utf8_buffer(), iv.to_utf8_buffer())
decrypted = aes.update(encrypted)
aes.finish()
# Check CBC
assert(decrypted == data.to_utf8_buffer())

[/gdscript] [csharp] using Godot; using System.Diagnostics;

public partial class MyNode : Node

{
    private AesContext _aes = new AesContext();

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

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

[/csharp] [/codeblocks]

type AESContextMode ¶

type AESContextMode = classdb.AESContextMode

const (
	/*AES electronic codebook encryption mode.*/
	AESContextModeEcbEncrypt AESContextMode = 0
	/*AES electronic codebook decryption mode.*/
	AESContextModeEcbDecrypt AESContextMode = 1
	/*AES cipher blocker chaining encryption mode.*/
	AESContextModeCbcEncrypt AESContextMode = 2
	/*AES cipher blocker chaining decryption mode.*/
	AESContextModeCbcDecrypt AESContextMode = 3
	/*Maximum value for the mode enum.*/
	AESContextModeMax AESContextMode = 4
)

type AStar2D ¶

type AStar2D = classdb.AStar2D

An implementation of the A* algorithm, used to find the shortest path between two vertices on a connected graph in 2D space. See AStar3D for a more thorough explanation on how to use this class. AStar2D is a wrapper for AStar3D that enforces 2D coordinates.

// AStar2D methods that can be overridden by a [Class] that extends it.
type AStar2D interface {
	//Called when estimating the cost between a point and the path's ending point.
	//Note that this function is hidden in the default [AStar2D] class.
	EstimateCost(godot Context, from_id gd.Int, to_id gd.Int) gd.Float
	//Called when computing the cost between two connected points.
	//Note that this function is hidden in the default [AStar2D] class.
	ComputeCost(godot Context, from_id gd.Int, to_id gd.Int) gd.Float
}

type AStar3D ¶

type AStar3D = classdb.AStar3D

A* (A star) is a computer algorithm used in pathfinding and graph traversal, the process of plotting short paths among vertices (points), passing through a given set of edges (segments). It enjoys widespread use due to its performance and accuracy. Godot's A* implementation uses points in 3D space and Euclidean distances by default. You must add points manually with [method add_point] and create segments manually with [method connect_points]. Once done, you can test if there is a path between two points with the [method are_points_connected] function, get a path containing indices by [method get_id_path], or one containing actual coordinates with [method get_point_path]. It is also possible to use non-Euclidean distances. To do so, create a class that extends AStar3D and override methods [method _compute_cost] and [method _estimate_cost]. Both take two indices and return a length, as is shown in the following example. [codeblocks] [gdscript] class MyAStar:

extends AStar3D

func _compute_cost(u, v):
    return abs(u - v)

func _estimate_cost(u, v):
    return min(0, abs(u - v) - 1)

[/gdscript] [csharp] public partial class MyAStar : AStar3D

{
    public override float _ComputeCost(long fromId, long toId)
    {
        return Mathf.Abs((int)(fromId - toId));
    }

    public override float _EstimateCost(long fromId, long toId)
    {
        return Mathf.Min(0, Mathf.Abs((int)(fromId - toId)) - 1);
    }
}

[/csharp] [/codeblocks] [method _estimate_cost] should return a lower bound of the distance, i.e. [code]_estimate_cost(u, v) <= _compute_cost(u, v)[/code]. This serves as a hint to the algorithm because the custom [method _compute_cost] might be computation-heavy. If this is not the case, make [method _estimate_cost] return the same value as [method _compute_cost] to provide the algorithm with the most accurate information. If the default [method _estimate_cost] and [method _compute_cost] methods are used, or if the supplied [method _estimate_cost] method returns a lower bound of the cost, then the paths returned by A* will be the lowest-cost paths. Here, the cost of a path equals the sum of the [method _compute_cost] results of all segments in the path multiplied by the [code]weight_scale[/code]s of the endpoints of the respective segments. If the default methods are used and the [code]weight_scale[/code]s of all points are set to [code]1.0[/code], then this equals the sum of Euclidean distances of all segments in the path.

// AStar3D methods that can be overridden by a [Class] that extends it.
type AStar3D interface {
	//Called when estimating the cost between a point and the path's ending point.
	//Note that this function is hidden in the default [AStar3D] class.
	EstimateCost(godot Context, from_id gd.Int, to_id gd.Int) gd.Float
	//Called when computing the cost between two connected points.
	//Note that this function is hidden in the default [AStar3D] class.
	ComputeCost(godot Context, from_id gd.Int, to_id gd.Int) gd.Float
}

type AStarGrid2D ¶

type AStarGrid2D = classdb.AStarGrid2D

AStarGrid2D is a variant of AStar2D that is specialized for partial 2D grids. It is simpler to use because it doesn't require you to manually create points and connect them together. This class also supports multiple types of heuristics, modes for diagonal movement, and a jumping mode to speed up calculations. To use AStarGrid2D, you only need to set the [member region] of the grid, optionally set the [member cell_size], and then call the [method update] method: [codeblocks] [gdscript] var astar_grid = AStarGrid2D.new() astar_grid.region = Rect2i(0, 0, 32, 32) astar_grid.cell_size = Vector2(16, 16) astar_grid.update() print(astar_grid.get_id_path(Vector2i(0, 0), Vector2i(3, 4))) # prints (0, 0), (1, 1), (2, 2), (3, 3), (3, 4) print(astar_grid.get_point_path(Vector2i(0, 0), Vector2i(3, 4))) # prints (0, 0), (16, 16), (32, 32), (48, 48), (48, 64) [/gdscript] [csharp] AStarGrid2D astarGrid = new AStarGrid2D(); astarGrid.Region = new Rect2I(0, 0, 32, 32); astarGrid.CellSize = new Vector2I(16, 16); astarGrid.Update(); GD.Print(astarGrid.GetIdPath(Vector2I.Zero, new Vector2I(3, 4))); // prints (0, 0), (1, 1), (2, 2), (3, 3), (3, 4) GD.Print(astarGrid.GetPointPath(Vector2I.Zero, new Vector2I(3, 4))); // prints (0, 0), (16, 16), (32, 32), (48, 48), (48, 64) [/csharp] [/codeblocks] To remove a point from the pathfinding grid, it must be set as "solid" with [method set_point_solid].

// AStarGrid2D methods that can be overridden by a [Class] that extends it.
type AStarGrid2D interface {
	//Called when estimating the cost between a point and the path's ending point.
	//Note that this function is hidden in the default [AStarGrid2D] class.
	EstimateCost(godot Context, from_id gd.Vector2i, to_id gd.Vector2i) gd.Float
	//Called when computing the cost between two connected points.
	//Note that this function is hidden in the default [AStarGrid2D] class.
	ComputeCost(godot Context, from_id gd.Vector2i, to_id gd.Vector2i) gd.Float
}

type AStarGrid2DDiagonalMode ¶

type AStarGrid2DDiagonalMode = classdb.AStarGrid2DDiagonalMode

const (
	/*The pathfinding algorithm will ignore solid neighbors around the target cell and allow passing using diagonals.*/
	AStarGrid2DDiagonalModeAlways AStarGrid2DDiagonalMode = 0
	/*The pathfinding algorithm will ignore all diagonals and the way will be always orthogonal.*/
	AStarGrid2DDiagonalModeNever AStarGrid2DDiagonalMode = 1
	/*The pathfinding algorithm will avoid using diagonals if at least two obstacles have been placed around the neighboring cells of the specific path segment.*/
	AStarGrid2DDiagonalModeAtLeastOneWalkable AStarGrid2DDiagonalMode = 2
	/*The pathfinding algorithm will avoid using diagonals if any obstacle has been placed around the neighboring cells of the specific path segment.*/
	AStarGrid2DDiagonalModeOnlyIfNoObstacles AStarGrid2DDiagonalMode = 3
	/*Represents the size of the [enum DiagonalMode] enum.*/
	AStarGrid2DDiagonalModeMax AStarGrid2DDiagonalMode = 4
)

type AStarGrid2DHeuristic ¶

type AStarGrid2DHeuristic = classdb.AStarGrid2DHeuristic

const (
	/*The [url=https://en.wikipedia.org/wiki/Euclidean_distance]Euclidean heuristic[/url] to be used for the pathfinding using the following formula:
	  [codeblock]
	  dx = abs(to_id.x - from_id.x)
	  dy = abs(to_id.y - from_id.y)
	  result = sqrt(dx * dx + dy * dy)
	  [/codeblock]
	  [b]Note:[/b] This is also the internal heuristic used in [AStar3D] and [AStar2D] by default (with the inclusion of possible z-axis coordinate).*/
	AStarGrid2DHeuristicEuclidean AStarGrid2DHeuristic = 0
	/*The [url=https://en.wikipedia.org/wiki/Taxicab_geometry]Manhattan heuristic[/url] to be used for the pathfinding using the following formula:
	  [codeblock]
	  dx = abs(to_id.x - from_id.x)
	  dy = abs(to_id.y - from_id.y)
	  result = dx + dy
	  [/codeblock]
	  [b]Note:[/b] This heuristic is intended to be used with 4-side orthogonal movements, provided by setting the [member diagonal_mode] to [constant DIAGONAL_MODE_NEVER].*/
	AStarGrid2DHeuristicManhattan AStarGrid2DHeuristic = 1
	/*The Octile heuristic to be used for the pathfinding using the following formula:
	  [codeblock]
	  dx = abs(to_id.x - from_id.x)
	  dy = abs(to_id.y - from_id.y)
	  f = sqrt(2) - 1
	  result = (dx < dy) ? f * dx + dy : f * dy + dx;
	  [/codeblock]*/
	AStarGrid2DHeuristicOctile AStarGrid2DHeuristic = 2
	/*The [url=https://en.wikipedia.org/wiki/Chebyshev_distance]Chebyshev heuristic[/url] to be used for the pathfinding using the following formula:
	  [codeblock]
	  dx = abs(to_id.x - from_id.x)
	  dy = abs(to_id.y - from_id.y)
	  result = max(dx, dy)
	  [/codeblock]*/
	AStarGrid2DHeuristicChebyshev AStarGrid2DHeuristic = 3
	/*Represents the size of the [enum Heuristic] enum.*/
	AStarGrid2DHeuristicMax AStarGrid2DHeuristic = 4
)

type AcceptDialog ¶

type AcceptDialog = classdb.AcceptDialog

The default use of AcceptDialog is to allow it to only be accepted or closed, with the same result. However, the [signal confirmed] and [signal canceled] signals allow to make the two actions different, and the [method add_button] method allows to add custom buttons and actions.

type AnimatableBody2D ¶

type AnimatableBody2D = classdb.AnimatableBody2D

An animatable 2D physics body. It can't be moved by external forces or contacts, but can be moved manually by other means such as code, [AnimationMixer]s (with [member AnimationMixer.callback_mode_process] set to [constant AnimationMixer.ANIMATION_CALLBACK_MODE_PROCESS_PHYSICS]), and RemoteTransform2D. When AnimatableBody2D is moved, its linear and angular velocity are estimated and used to affect other physics bodies in its path. This makes it useful for moving platforms, doors, and other moving objects.

type AnimatableBody3D ¶

type AnimatableBody3D = classdb.AnimatableBody3D

An animatable 3D physics body. It can't be moved by external forces or contacts, but can be moved manually by other means such as code, [AnimationMixer]s (with [member AnimationMixer.callback_mode_process] set to [constant AnimationMixer.ANIMATION_CALLBACK_MODE_PROCESS_PHYSICS]), and RemoteTransform3D. When AnimatableBody3D is moved, its linear and angular velocity are estimated and used to affect other physics bodies in its path. This makes it useful for moving platforms, doors, and other moving objects.

type AnimatedSprite2D ¶

type AnimatedSprite2D = classdb.AnimatedSprite2D

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

type AnimatedSprite3D ¶

type AnimatedSprite3D = classdb.AnimatedSprite3D

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

type AnimatedTexture ¶

type AnimatedTexture = classdb.AnimatedTexture

AnimatedTexture is a resource format for frame-based animations, where multiple textures can be chained automatically with a predefined delay for each frame. Unlike AnimationPlayer or AnimatedSprite2D, it isn't a Node, but has the advantage of being usable anywhere a Texture2D resource can be used, e.g. in a TileSet. The playback of the animation is controlled by the [member speed_scale] property, as well as each frame's duration (see [method set_frame_duration]). The animation loops, i.e. it will restart at frame 0 automatically after playing the last frame. AnimatedTexture currently requires all frame textures to have the same size, otherwise the bigger ones will be cropped to match the smallest one. [b]Note:[/b] AnimatedTexture doesn't support using [AtlasTexture]s. Each frame needs to be a separate Texture2D. [b]Warning:[/b] The current implementation is not efficient for the modern renderers. [i]Deprecated.[/i] This class is deprecated, and might be removed in a future release.

type Animation ¶

type Animation = classdb.Animation

This resource holds data that can be used to animate anything in the engine. Animations are divided into tracks and each track must be linked to a node. The state of that node can be changed through time, by adding timed keys (events) to the track. [codeblocks] [gdscript] # This creates an animation that makes the node "Enemy" move to the right by # 100 pixels in 2.0 seconds. var animation = Animation.new() var track_index = animation.add_track(Animation.TYPE_VALUE) animation.track_set_path(track_index, "Enemy:position:x") animation.track_insert_key(track_index, 0.0, 0) animation.track_insert_key(track_index, 2.0, 100) animation.length = 2.0 [/gdscript] [csharp] // This creates an animation that makes the node "Enemy" move to the right by // 100 pixels in 2.0 seconds. var animation = new Animation(); int trackIndex = animation.AddTrack(Animation.TrackType.Value); animation.TrackSetPath(trackIndex, "Enemy:position:x"); animation.TrackInsertKey(trackIndex, 0.0f, 0); animation.TrackInsertKey(trackIndex, 2.0f, 100); animation.Length = 2.0f; [/csharp] [/codeblocks] Animations are just data containers, and must be added to nodes such as an AnimationPlayer to be played back. Animation tracks have different types, each with its own set of dedicated methods. Check [enum TrackType] to see available types. [b]Note:[/b] For 3D position/rotation/scale, using the dedicated [constant TYPE_POSITION_3D], [constant TYPE_ROTATION_3D] and [constant TYPE_SCALE_3D] track types instead of [constant TYPE_VALUE] is recommended for performance reasons.

type AnimationFindMode ¶

type AnimationFindMode = classdb.AnimationFindMode

const (
	/*Finds the nearest time key.*/
	AnimationFindModeNearest AnimationFindMode = 0
	/*Finds only the key with approximating the time.*/
	AnimationFindModeApprox AnimationFindMode = 1
	/*Finds only the key with matching the time.*/
	AnimationFindModeExact AnimationFindMode = 2
)

type AnimationInterpolationType ¶

type AnimationInterpolationType = classdb.AnimationInterpolationType

const (
	/*No interpolation (nearest value).*/
	AnimationInterpolationNearest AnimationInterpolationType = 0
	/*Linear interpolation.*/
	AnimationInterpolationLinear AnimationInterpolationType = 1
	/*Cubic interpolation. This looks smoother than linear interpolation, but is more expensive to interpolate. Stick to [constant INTERPOLATION_LINEAR] for complex 3D animations imported from external software, even if it requires using a higher animation framerate in return.*/
	AnimationInterpolationCubic AnimationInterpolationType = 2
	/*Linear interpolation with shortest path rotation.
	  [b]Note:[/b] The result value is always normalized and may not match the key value.*/
	AnimationInterpolationLinearAngle AnimationInterpolationType = 3
	/*Cubic interpolation with shortest path rotation.
	  [b]Note:[/b] The result value is always normalized and may not match the key value.*/
	AnimationInterpolationCubicAngle AnimationInterpolationType = 4
)

type AnimationLibrary ¶

type AnimationLibrary = classdb.AnimationLibrary

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

type AnimationLoopMode ¶

type AnimationLoopMode = classdb.AnimationLoopMode

const (
	/*At both ends of the animation, the animation will stop playing.*/
	AnimationLoopNone AnimationLoopMode = 0
	/*At both ends of the animation, the animation will be repeated without changing the playback direction.*/
	AnimationLoopLinear AnimationLoopMode = 1
	/*Repeats playback and reverse playback at both ends of the animation.*/
	AnimationLoopPingpong AnimationLoopMode = 2
)

type AnimationLoopedFlag ¶

type AnimationLoopedFlag = classdb.AnimationLoopedFlag

const (
	/*This flag indicates that the animation proceeds without any looping.*/
	AnimationLoopedFlagNone AnimationLoopedFlag = 0
	/*This flag indicates that the animation has reached the end of the animation and just after loop processed.*/
	AnimationLoopedFlagEnd AnimationLoopedFlag = 1
	/*This flag indicates that the animation has reached the start of the animation and just after loop processed.*/
	AnimationLoopedFlagStart AnimationLoopedFlag = 2
)

type AnimationMixer ¶

type AnimationMixer = classdb.AnimationMixer

Base class for AnimationPlayer and AnimationTree to manage animation lists. It also has general properties and methods for playback and blending. After instantiating the playback information data within the extended class, the blending is processed by the AnimationMixer.

// AnimationMixer methods that can be overridden by a [Class] that extends it.
type AnimationMixer interface {
	//A virtual function for processing after key getting during playback.
	PostProcessKeyValue(godot Context, animation Animation, track gd.Int, value gd.Variant, object gd.Object, object_idx gd.Int) gd.Variant
}

type AnimationMixerAnimationCallbackModeMethod ¶

type AnimationMixerAnimationCallbackModeMethod = classdb.AnimationMixerAnimationCallbackModeMethod

const (
	/*Batch method calls during the animation process, then do the calls after events are processed. This avoids bugs involving deleting nodes or modifying the AnimationPlayer while playing.*/
	AnimationMixerAnimationCallbackModeMethodDeferred AnimationMixerAnimationCallbackModeMethod = 0
	/*Make method calls immediately when reached in the animation.*/
	AnimationMixerAnimationCallbackModeMethodImmediate AnimationMixerAnimationCallbackModeMethod = 1
)

type AnimationMixerAnimationCallbackModeProcess ¶

type AnimationMixerAnimationCallbackModeProcess = classdb.AnimationMixerAnimationCallbackModeProcess

const (
	/*Process animation during physics frames (see [constant Node.NOTIFICATION_INTERNAL_PHYSICS_PROCESS]). This is especially useful when animating physics bodies.*/
	AnimationMixerAnimationCallbackModeProcessPhysics AnimationMixerAnimationCallbackModeProcess = 0
	/*Process animation during process frames (see [constant Node.NOTIFICATION_INTERNAL_PROCESS]).*/
	AnimationMixerAnimationCallbackModeProcessIdle AnimationMixerAnimationCallbackModeProcess = 1
	/*Do not process animation. Use [method advance] to process the animation manually.*/
	AnimationMixerAnimationCallbackModeProcessManual AnimationMixerAnimationCallbackModeProcess = 2
)

type AnimationNode ¶

type AnimationNode = classdb.AnimationNode

Base resource for AnimationTree nodes. In general, it's not used directly, but you can create custom ones with custom blending formulas. Inherit this when creating animation nodes mainly for use in AnimationNodeBlendTree, otherwise AnimationRootNode should be used instead.

// AnimationNode methods that can be overridden by a [Class] that extends it.
type AnimationNode interface {
	//When inheriting from [AnimationRootNode], implement this virtual method to return all child animation nodes in order as a [code]name: node[/code] dictionary.
	GetChildNodes(godot Context) gd.Dictionary
	//When inheriting from [AnimationRootNode], implement this virtual method to return a list of the properties on this animation node. Parameters are custom local memory used for your animation nodes, given a resource can be reused in multiple trees. Format is similar to [method Object.get_property_list].
	GetParameterList(godot Context) gd.Array
	//When inheriting from [AnimationRootNode], implement this virtual method to return a child animation node by its [param name].
	GetChildByName(godot Context, name gd.StringName) AnimationNode
	//When inheriting from [AnimationRootNode], implement this virtual method to return the default value of a [param parameter]. Parameters are custom local memory used for your animation nodes, given a resource can be reused in multiple trees.
	GetParameterDefaultValue(godot Context, parameter gd.StringName) gd.Variant
	//When inheriting from [AnimationRootNode], implement this virtual method to return whether the [param parameter] is read-only. Parameters are custom local memory used for your animation nodes, given a resource can be reused in multiple trees.
	IsParameterReadOnly(godot Context, parameter gd.StringName) bool
	//When inheriting from [AnimationRootNode], implement this virtual method to run some code when this animation node is processed. The [param time] parameter is a relative delta, unless [param seek] is [code]true[/code], in which case it is absolute.
	//Here, call the [method blend_input], [method blend_node] or [method blend_animation] functions. You can also use [method get_parameter] and [method set_parameter] to modify local memory.
	//This function should return the time left for the current animation to finish (if unsure, pass the value from the main blend being called).
	Process(godot Context, time gd.Float, seek bool, is_external_seeking bool, test_only bool) gd.Float
	//When inheriting from [AnimationRootNode], implement this virtual method to override the text caption for this animation node.
	GetCaption(godot Context) gd.String
	//When inheriting from [AnimationRootNode], implement this virtual method to return whether the blend tree editor should display filter editing on this animation node.
	HasFilter(godot Context) bool
}

type AnimationNodeAdd2 ¶

type AnimationNodeAdd2 = classdb.AnimationNodeAdd2

A resource to add to an AnimationNodeBlendTree. Blends two animations additively based on the amount value. If the amount is greater than [code]1.0[/code], the animation connected to "in" port is blended with the amplified animation connected to "add" port. If the amount is less than [code]0.0[/code], the animation connected to "in" port is blended with the inverted animation connected to "add" port.

type AnimationNodeAdd3 ¶

type AnimationNodeAdd3 = classdb.AnimationNodeAdd3

A resource to add to an AnimationNodeBlendTree. Blends two animations out of three additively out of three based on the amount value. This animation node has three inputs: - The base animation to add to - A "-add" animation to blend with when the blend amount is negative - A "+add" animation to blend with when the blend amount is positive If the absolute value of the amount is greater than [code]1.0[/code], the animation connected to "in" port is blended with the amplified animation connected to "-add"/"+add" port.

type AnimationNodeAnimation ¶

type AnimationNodeAnimation = classdb.AnimationNodeAnimation

A resource to add to an AnimationNodeBlendTree. Only has one output port using the [member animation] property. Used as an input for [AnimationNode]s that blend animations together.

type AnimationNodeAnimationPlayMode ¶

type AnimationNodeAnimationPlayMode = classdb.AnimationNodeAnimationPlayMode

const (
	/*Plays animation in forward direction.*/
	AnimationNodeAnimationPlayModeForward AnimationNodeAnimationPlayMode = 0
	/*Plays animation in backward direction.*/
	AnimationNodeAnimationPlayModeBackward AnimationNodeAnimationPlayMode = 1
)

type AnimationNodeBlend2 ¶

type AnimationNodeBlend2 = classdb.AnimationNodeBlend2

A resource to add to an AnimationNodeBlendTree. Blends two animations linearly based on the amount value. In general, the blend value should be in the [code][0.0, 1.0][/code] range. Values outside of this range can blend amplified or inverted animations, however, AnimationNodeAdd2 works better for this purpose.

type AnimationNodeBlend3 ¶

type AnimationNodeBlend3 = classdb.AnimationNodeBlend3

A resource to add to an AnimationNodeBlendTree. Blends two animations out of three linearly out of three based on the amount value. This animation node has three inputs: - The base animation to blend with - A "-blend" animation to blend with when the blend amount is negative value - A "+blend" animation to blend with when the blend amount is positive value In general, the blend value should be in the [code][-1.0, 1.0][/code] range. Values outside of this range can blend amplified animations, however, AnimationNodeAdd3 works better for this purpose.

type AnimationNodeBlendSpace1D ¶

type AnimationNodeBlendSpace1D = classdb.AnimationNodeBlendSpace1D

A resource used by AnimationNodeBlendTree. AnimationNodeBlendSpace1D represents a virtual axis on which any type of [AnimationRootNode]s can be added using [method add_blend_point]. Outputs the linear blend of the two [AnimationRootNode]s adjacent to the current value. You can set the extents of the axis with [member min_space] and [member max_space].

type AnimationNodeBlendSpace1DBlendMode ¶

type AnimationNodeBlendSpace1DBlendMode = classdb.AnimationNodeBlendSpace1DBlendMode

const (
	/*The interpolation between animations is linear.*/
	AnimationNodeBlendSpace1DBlendModeInterpolated AnimationNodeBlendSpace1DBlendMode = 0
	/*The blend space plays the animation of the animation node which blending position is closest to. Useful for frame-by-frame 2D animations.*/
	AnimationNodeBlendSpace1DBlendModeDiscrete AnimationNodeBlendSpace1DBlendMode = 1
	/*Similar to [constant BLEND_MODE_DISCRETE], but starts the new animation at the last animation's playback position.*/
	AnimationNodeBlendSpace1DBlendModeDiscreteCarry AnimationNodeBlendSpace1DBlendMode = 2
)

type AnimationNodeBlendSpace2D ¶

type AnimationNodeBlendSpace2D = classdb.AnimationNodeBlendSpace2D

A resource used by AnimationNodeBlendTree. AnimationNodeBlendSpace1D represents a virtual 2D space on which [AnimationRootNode]s are placed. Outputs the linear blend of the three adjacent animations using a Vector2 weight. Adjacent in this context means the three [AnimationRootNode]s making up the triangle that contains the current value. You can add vertices to the blend space with [method add_blend_point] and automatically triangulate it by setting [member auto_triangles] to [code]true[/code]. Otherwise, use [method add_triangle] and [method remove_triangle] to triangulate the blend space by hand.

type AnimationNodeBlendSpace2DBlendMode ¶

type AnimationNodeBlendSpace2DBlendMode = classdb.AnimationNodeBlendSpace2DBlendMode

const (
	/*The interpolation between animations is linear.*/
	AnimationNodeBlendSpace2DBlendModeInterpolated AnimationNodeBlendSpace2DBlendMode = 0
	/*The blend space plays the animation of the animation node which blending position is closest to. Useful for frame-by-frame 2D animations.*/
	AnimationNodeBlendSpace2DBlendModeDiscrete AnimationNodeBlendSpace2DBlendMode = 1
	/*Similar to [constant BLEND_MODE_DISCRETE], but starts the new animation at the last animation's playback position.*/
	AnimationNodeBlendSpace2DBlendModeDiscreteCarry AnimationNodeBlendSpace2DBlendMode = 2
)

type AnimationNodeBlendTree ¶

type AnimationNodeBlendTree = classdb.AnimationNodeBlendTree

This animation node may contain a sub-tree of any other type animation nodes, such as AnimationNodeTransition, AnimationNodeBlend2, AnimationNodeBlend3, AnimationNodeOneShot, etc. This is one of the most commonly used animation node roots. An AnimationNodeOutput node named [code]output[/code] is created by default.

type AnimationNodeFilterAction ¶

type AnimationNodeFilterAction = classdb.AnimationNodeFilterAction

const (
	/*Do not use filtering.*/
	AnimationNodeFilterIgnore AnimationNodeFilterAction = 0
	/*Paths matching the filter will be allowed to pass.*/
	AnimationNodeFilterPass AnimationNodeFilterAction = 1
	/*Paths matching the filter will be discarded.*/
	AnimationNodeFilterStop AnimationNodeFilterAction = 2
	/*Paths matching the filter will be blended (by the blend value).*/
	AnimationNodeFilterBlend AnimationNodeFilterAction = 3
)

type AnimationNodeOneShot ¶

type AnimationNodeOneShot = classdb.AnimationNodeOneShot

A resource to add to an AnimationNodeBlendTree. This animation node will execute a sub-animation and return once it finishes. Blend times for fading in and out can be customized, as well as filters. After setting the request and changing the animation playback, the one-shot node automatically clears the request on the next process frame by setting its [code]request[/code] value to [constant ONE_SHOT_REQUEST_NONE]. [codeblocks] [gdscript] # Play child animation connected to "shot" port. animation_tree.set("parameters/OneShot/request", AnimationNodeOneShot.ONE_SHOT_REQUEST_FIRE) # Alternative syntax (same result as above). animation_tree["parameters/OneShot/request"] = AnimationNodeOneShot.ONE_SHOT_REQUEST_FIRE

# Abort child animation connected to "shot" port. animation_tree.set("parameters/OneShot/request", AnimationNodeOneShot.ONE_SHOT_REQUEST_ABORT) # Alternative syntax (same result as above). animation_tree["parameters/OneShot/request"] = AnimationNodeOneShot.ONE_SHOT_REQUEST_ABORT

# Abort child animation with fading out connected to "shot" port. animation_tree.set("parameters/OneShot/request", AnimationNodeOneShot.ONE_SHOT_REQUEST_FADE_OUT) # Alternative syntax (same result as above). animation_tree["parameters/OneShot/request"] = AnimationNodeOneShot.ONE_SHOT_REQUEST_FADE_OUT

# Get current state (read-only). animation_tree.get("parameters/OneShot/active") # Alternative syntax (same result as above). animation_tree["parameters/OneShot/active"]

# Get current internal state (read-only). animation_tree.get("parameters/OneShot/internal_active") # Alternative syntax (same result as above). animation_tree["parameters/OneShot/internal_active"] [/gdscript] [csharp] // Play child animation connected to "shot" port. animationTree.Set("parameters/OneShot/request", (int)AnimationNodeOneShot.OneShotRequest.Fire);

// Abort child animation connected to "shot" port. animationTree.Set("parameters/OneShot/request", (int)AnimationNodeOneShot.OneShotRequest.Abort);

// Abort child animation with fading out connected to "shot" port. animationTree.Set("parameters/OneShot/request", (int)AnimationNodeOneShot.OneShotRequest.FadeOut);

// Get current state (read-only). animationTree.Get("parameters/OneShot/active");

// Get current internal state (read-only). animationTree.Get("parameters/OneShot/internal_active"); [/csharp] [/codeblocks]

type AnimationNodeOneShotMixMode ¶

type AnimationNodeOneShotMixMode = classdb.AnimationNodeOneShotMixMode

const (
	/*Blends two animations. See also [AnimationNodeBlend2].*/
	AnimationNodeOneShotMixModeBlend AnimationNodeOneShotMixMode = 0
	/*Blends two animations additively. See also [AnimationNodeAdd2].*/
	AnimationNodeOneShotMixModeAdd AnimationNodeOneShotMixMode = 1
)

type AnimationNodeOneShotOneShotRequest ¶

type AnimationNodeOneShotOneShotRequest = classdb.AnimationNodeOneShotOneShotRequest

const (
	/*The default state of the request. Nothing is done.*/
	AnimationNodeOneShotOneShotRequestNone AnimationNodeOneShotOneShotRequest = 0
	/*The request to play the animation connected to "shot" port.*/
	AnimationNodeOneShotOneShotRequestFire AnimationNodeOneShotOneShotRequest = 1
	/*The request to stop the animation connected to "shot" port.*/
	AnimationNodeOneShotOneShotRequestAbort AnimationNodeOneShotOneShotRequest = 2
	/*The request to fade out the animation connected to "shot" port.*/
	AnimationNodeOneShotOneShotRequestFadeOut AnimationNodeOneShotOneShotRequest = 3
)

type AnimationNodeOutput ¶

type AnimationNodeOutput = classdb.AnimationNodeOutput

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

type AnimationNodeStateMachine ¶

type AnimationNodeStateMachine = classdb.AnimationNodeStateMachine

Contains multiple [AnimationRootNode]s representing animation states, connected in a graph. State transitions can be configured to happen automatically or via code, using a shortest-path algorithm. Retrieve the AnimationNodeStateMachinePlayback object from the AnimationTree node to control it programmatically. [b]Example:[/b] [codeblocks] [gdscript] var state_machine = $AnimationTree.get("parameters/playback") state_machine.travel("some_state") [/gdscript] [csharp] var stateMachine = GetNode<AnimationTree>("AnimationTree").Get("parameters/playback") as AnimationNodeStateMachinePlayback; stateMachine.Travel("some_state"); [/csharp] [/codeblocks]

type AnimationNodeStateMachinePlayback ¶

type AnimationNodeStateMachinePlayback = classdb.AnimationNodeStateMachinePlayback

Allows control of AnimationTree state machines created with AnimationNodeStateMachine. Retrieve with [code]$AnimationTree.get("parameters/playback")[/code]. [b]Example:[/b] [codeblocks] [gdscript] var state_machine = $AnimationTree.get("parameters/playback") state_machine.travel("some_state") [/gdscript] [csharp] var stateMachine = GetNode<AnimationTree>("AnimationTree").Get("parameters/playback").As<AnimationNodeStateMachinePlayback>(); stateMachine.Travel("some_state"); [/csharp] [/codeblocks]

type AnimationNodeStateMachineStateMachineType ¶

type AnimationNodeStateMachineStateMachineType = classdb.AnimationNodeStateMachineStateMachineType

const (
	/*Seeking to the beginning is treated as playing from the start state. Transition to the end state is treated as exiting the state machine.*/
	AnimationNodeStateMachineStateMachineTypeRoot AnimationNodeStateMachineStateMachineType = 0
	/*Seeking to the beginning is treated as seeking to the beginning of the animation in the current state. Transition to the end state, or the absence of transitions in each state, is treated as exiting the state machine.*/
	AnimationNodeStateMachineStateMachineTypeNested AnimationNodeStateMachineStateMachineType = 1
	/*This is a grouped state machine that can be controlled from a parent state machine. It does not work independently. There must be a state machine with [member state_machine_type] of [constant STATE_MACHINE_TYPE_ROOT] or [constant STATE_MACHINE_TYPE_NESTED] in the parent or ancestor.*/
	AnimationNodeStateMachineStateMachineTypeGrouped AnimationNodeStateMachineStateMachineType = 2
)

type AnimationNodeStateMachineTransition ¶

type AnimationNodeStateMachineTransition = classdb.AnimationNodeStateMachineTransition

The path generated when using [method AnimationNodeStateMachinePlayback.travel] is limited to the nodes connected by AnimationNodeStateMachineTransition. You can set the timing and conditions of the transition in detail.

type AnimationNodeStateMachineTransitionAdvanceMode ¶

type AnimationNodeStateMachineTransitionAdvanceMode = classdb.AnimationNodeStateMachineTransitionAdvanceMode

const (
	/*Don't use this transition.*/
	AnimationNodeStateMachineTransitionAdvanceModeDisabled AnimationNodeStateMachineTransitionAdvanceMode = 0
	/*Only use this transition during [method AnimationNodeStateMachinePlayback.travel].*/
	AnimationNodeStateMachineTransitionAdvanceModeEnabled AnimationNodeStateMachineTransitionAdvanceMode = 1
	/*Automatically use this transition if the [member advance_condition] and [member advance_expression] checks are true (if assigned).*/
	AnimationNodeStateMachineTransitionAdvanceModeAuto AnimationNodeStateMachineTransitionAdvanceMode = 2
)

type AnimationNodeStateMachineTransitionSwitchMode ¶

type AnimationNodeStateMachineTransitionSwitchMode = classdb.AnimationNodeStateMachineTransitionSwitchMode

const (
	/*Switch to the next state immediately. The current state will end and blend into the beginning of the new one.*/
	AnimationNodeStateMachineTransitionSwitchModeImmediate AnimationNodeStateMachineTransitionSwitchMode = 0
	/*Switch to the next state immediately, but will seek the new state to the playback position of the old state.*/
	AnimationNodeStateMachineTransitionSwitchModeSync AnimationNodeStateMachineTransitionSwitchMode = 1
	/*Wait for the current state playback to end, then switch to the beginning of the next state animation.*/
	AnimationNodeStateMachineTransitionSwitchModeAtEnd AnimationNodeStateMachineTransitionSwitchMode = 2
)

type AnimationNodeSub2 ¶

type AnimationNodeSub2 = classdb.AnimationNodeSub2

A resource to add to an AnimationNodeBlendTree. Blends two animations subtractively based on the amount value. This animation node is usually used for pre-calculation to cancel out any extra poses from the animation for the "add" animation source in AnimationNodeAdd2 or AnimationNodeAdd3. In general, the blend value should be in the [code][0.0, 1.0][/code] range, but values outside of this range can be used for amplified or inverted animations. [b]Note:[/b] This calculation is different from using a negative value in AnimationNodeAdd2, since the transformation matrices do not satisfy the commutative law. AnimationNodeSub2 multiplies the transformation matrix of the inverted animation from the left side, while negative AnimationNodeAdd2 multiplies it from the right side.

type AnimationNodeSync ¶

type AnimationNodeSync = classdb.AnimationNodeSync

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

type AnimationNodeTimeScale ¶

type AnimationNodeTimeScale = classdb.AnimationNodeTimeScale

Allows to scale the speed of the animation (or reverse it) in any child [AnimationNode]s. Setting it to [code]0.0[/code] will pause the animation.

type AnimationNodeTimeSeek ¶

type AnimationNodeTimeSeek = classdb.AnimationNodeTimeSeek

This animation node can be used to cause a seek command to happen to any sub-children of the animation graph. Use to play an Animation from the start or a certain playback position inside the AnimationNodeBlendTree. After setting the time and changing the animation playback, the time seek node automatically goes into sleep mode on the next process frame by setting its [code]seek_request[/code] value to [code]-1.0[/code]. [codeblocks] [gdscript] # Play child animation from the start. animation_tree.set("parameters/TimeSeek/seek_request", 0.0) # Alternative syntax (same result as above). animation_tree["parameters/TimeSeek/seek_request"] = 0.0

# Play child animation from 12 second timestamp. animation_tree.set("parameters/TimeSeek/seek_request", 12.0) # Alternative syntax (same result as above). animation_tree["parameters/TimeSeek/seek_request"] = 12.0 [/gdscript] [csharp] // Play child animation from the start. animationTree.Set("parameters/TimeSeek/seek_request", 0.0);

// Play child animation from 12 second timestamp. animationTree.Set("parameters/TimeSeek/seek_request", 12.0); [/csharp] [/codeblocks]

type AnimationNodeTransition ¶

type AnimationNodeTransition = classdb.AnimationNodeTransition

Simple state machine for cases which don't require a more advanced AnimationNodeStateMachine. Animations can be connected to the inputs and transition times can be specified. After setting the request and changing the animation playback, the transition node automatically clears the request on the next process frame by setting its [code]transition_request[/code] value to empty. [b]Note:[/b] When using a cross-fade, [code]current_state[/code] and [code]current_index[/code] change to the next state immediately after the cross-fade begins. [codeblocks] [gdscript] # Play child animation connected to "state_2" port. animation_tree.set("parameters/Transition/transition_request", "state_2") # Alternative syntax (same result as above). animation_tree["parameters/Transition/transition_request"] = "state_2"

# Get current state name (read-only). animation_tree.get("parameters/Transition/current_state") # Alternative syntax (same result as above). animation_tree["parameters/Transition/current_state"]

# Get current state index (read-only). animation_tree.get("parameters/Transition/current_index") # Alternative syntax (same result as above). animation_tree["parameters/Transition/current_index"] [/gdscript] [csharp] // Play child animation connected to "state_2" port. animationTree.Set("parameters/Transition/transition_request", "state_2");

// Get current state name (read-only). animationTree.Get("parameters/Transition/current_state");

// Get current state index (read-only). animationTree.Get("parameters/Transition/current_index"); [/csharp] [/codeblocks]

type AnimationPlayer ¶

type AnimationPlayer = classdb.AnimationPlayer

An animation player is used for general-purpose playback of animations. It contains a dictionary of AnimationLibrary resources and custom blend times between animation transitions. Some methods and properties use a single key to reference an animation directly. These keys are formatted as the key for the library, followed by a forward slash, then the key for the animation within the library, for example [code]"movement/run"[/code]. If the library's key is an empty string (known as the default library), the forward slash is omitted, being the same key used by the library. AnimationPlayer is better-suited than Tween for more complex animations, for example ones with non-trivial timings. It can also be used over Tween if the animation track editor is more convenient than doing it in code. Updating the target properties of animations occurs at the process frame.

type AnimationPlayerAnimationMethodCallMode ¶

type AnimationPlayerAnimationMethodCallMode = classdb.AnimationPlayerAnimationMethodCallMode

const (
	/*For backward compatibility. See [constant AnimationMixer.ANIMATION_CALLBACK_MODE_METHOD_DEFERRED].*/
	AnimationPlayerAnimationMethodCallDeferred AnimationPlayerAnimationMethodCallMode = 0
	/*For backward compatibility. See [constant AnimationMixer.ANIMATION_CALLBACK_MODE_METHOD_IMMEDIATE].*/
	AnimationPlayerAnimationMethodCallImmediate AnimationPlayerAnimationMethodCallMode = 1
)

type AnimationPlayerAnimationProcessCallback ¶

type AnimationPlayerAnimationProcessCallback = classdb.AnimationPlayerAnimationProcessCallback

const (
	/*For backward compatibility. See [constant AnimationMixer.ANIMATION_CALLBACK_MODE_PROCESS_PHYSICS].*/
	AnimationPlayerAnimationProcessPhysics AnimationPlayerAnimationProcessCallback = 0
	/*For backward compatibility. See [constant AnimationMixer.ANIMATION_CALLBACK_MODE_PROCESS_IDLE].*/
	AnimationPlayerAnimationProcessIdle AnimationPlayerAnimationProcessCallback = 1
	/*For backward compatibility. See [constant AnimationMixer.ANIMATION_CALLBACK_MODE_PROCESS_MANUAL].*/
	AnimationPlayerAnimationProcessManual AnimationPlayerAnimationProcessCallback = 2
)

type AnimationRootNode ¶

type AnimationRootNode = classdb.AnimationRootNode

AnimationRootNode is a base class for [AnimationNode]s that hold a complete animation. A complete animation refers to the output of an AnimationNodeOutput in an AnimationNodeBlendTree or the output of another AnimationRootNode. Used for [member AnimationTree.tree_root] or in other [AnimationRootNode]s. Examples of built-in root nodes include AnimationNodeBlendTree (allows blending nodes between each other using various modes), AnimationNodeStateMachine (allows to configure blending and transitions between nodes using a state machine pattern), AnimationNodeBlendSpace2D (allows linear blending between [b]three[/b] [AnimationNode]s), AnimationNodeBlendSpace1D (allows linear blending only between [b]two[/b] [AnimationNode]s).

type AnimationTrackType ¶

type AnimationTrackType = classdb.AnimationTrackType

const (
	/*Value tracks set values in node properties, but only those which can be interpolated. For 3D position/rotation/scale, using the dedicated [constant TYPE_POSITION_3D], [constant TYPE_ROTATION_3D] and [constant TYPE_SCALE_3D] track types instead of [constant TYPE_VALUE] is recommended for performance reasons.*/
	AnimationTypeValue AnimationTrackType = 0
	/*3D position track (values are stored in [Vector3]s).*/
	AnimationTypePosition3d AnimationTrackType = 1
	/*3D rotation track (values are stored in [Quaternion]s).*/
	AnimationTypeRotation3d AnimationTrackType = 2
	/*3D scale track (values are stored in [Vector3]s).*/
	AnimationTypeScale3d AnimationTrackType = 3
	/*Blend shape track.*/
	AnimationTypeBlendShape AnimationTrackType = 4
	/*Method tracks call functions with given arguments per key.*/
	AnimationTypeMethod AnimationTrackType = 5
	/*Bezier tracks are used to interpolate a value using custom curves. They can also be used to animate sub-properties of vectors and colors (e.g. alpha value of a [Color]).*/
	AnimationTypeBezier AnimationTrackType = 6
	/*Audio tracks are used to play an audio stream with either type of [AudioStreamPlayer]. The stream can be trimmed and previewed in the animation.*/
	AnimationTypeAudio AnimationTrackType = 7
	/*Animation tracks play animations in other [AnimationPlayer] nodes.*/
	AnimationTypeAnimation AnimationTrackType = 8
)

type AnimationTree ¶

type AnimationTree = classdb.AnimationTree

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

type AnimationTreeAnimationProcessCallback ¶

type AnimationTreeAnimationProcessCallback = classdb.AnimationTreeAnimationProcessCallback

const (
	/*For backward compatibility. See [constant AnimationMixer.ANIMATION_CALLBACK_MODE_PROCESS_PHYSICS].*/
	AnimationTreeAnimationProcessPhysics AnimationTreeAnimationProcessCallback = 0
	/*For backward compatibility. See [constant AnimationMixer.ANIMATION_CALLBACK_MODE_PROCESS_IDLE].*/
	AnimationTreeAnimationProcessIdle AnimationTreeAnimationProcessCallback = 1
	/*For backward compatibility. See [constant AnimationMixer.ANIMATION_CALLBACK_MODE_PROCESS_MANUAL].*/
	AnimationTreeAnimationProcessManual AnimationTreeAnimationProcessCallback = 2
)

type AnimationUpdateMode ¶

type AnimationUpdateMode = classdb.AnimationUpdateMode

const (
	/*Update between keyframes and hold the value.*/
	AnimationUpdateContinuous AnimationUpdateMode = 0
	/*Update at the keyframes.*/
	AnimationUpdateDiscrete AnimationUpdateMode = 1
	/*Same as linear interpolation, but also interpolates from the current value (i.e. dynamically at runtime) if the first key isn't at 0 seconds.*/
	AnimationUpdateCapture AnimationUpdateMode = 2
)

type Area2D ¶

type Area2D = classdb.Area2D

Area2D is a region of 2D space defined by one or multiple CollisionShape2D or CollisionPolygon2D child nodes. It detects when other [CollisionObject2D]s enter or exit it, and it also keeps track of which collision objects haven't exited it yet (i.e. which one are overlapping it). This node can also locally alter or override physics parameters (gravity, damping) and route audio to custom audio buses.

type Area2DSpaceOverride ¶

type Area2DSpaceOverride = classdb.Area2DSpaceOverride

const (
	/*This area does not affect gravity/damping.*/
	Area2DSpaceOverrideDisabled Area2DSpaceOverride = 0
	/*This area adds its gravity/damping values to whatever has been calculated so far (in [member priority] order).*/
	Area2DSpaceOverrideCombine Area2DSpaceOverride = 1
	/*This area adds its gravity/damping values to whatever has been calculated so far (in [member priority] order), ignoring any lower priority areas.*/
	Area2DSpaceOverrideCombineReplace Area2DSpaceOverride = 2
	/*This area replaces any gravity/damping, even the defaults, ignoring any lower priority areas.*/
	Area2DSpaceOverrideReplace Area2DSpaceOverride = 3
	/*This area replaces any gravity/damping calculated so far (in [member priority] order), but keeps calculating the rest of the areas.*/
	Area2DSpaceOverrideReplaceCombine Area2DSpaceOverride = 4
)

type Area3D ¶

type Area3D = classdb.Area3D

Area3D is a region of 3D space defined by one or multiple CollisionShape3D or CollisionPolygon3D child nodes. It detects when other [CollisionObject3D]s enter or exit it, and it also keeps track of which collision objects haven't exited it yet (i.e. which one are overlapping it). This node can also locally alter or override physics parameters (gravity, damping) and route audio to custom audio buses. [b]Warning:[/b] Using a ConcavePolygonShape3D inside a CollisionShape3D child of this node (created e.g. by using the [b]Create Trimesh Collision Sibling[/b] option in the [b]Mesh[/b] menu that appears when selecting a MeshInstance3D node) may give unexpected results, since this collision shape is hollow. If this is not desired, it has to be split into multiple [ConvexPolygonShape3D]s or primitive shapes like BoxShape3D, or in some cases it may be replaceable by a CollisionPolygon3D.

type Area3DSpaceOverride ¶

type Area3DSpaceOverride = classdb.Area3DSpaceOverride

const (
	/*This area does not affect gravity/damping.*/
	Area3DSpaceOverrideDisabled Area3DSpaceOverride = 0
	/*This area adds its gravity/damping values to whatever has been calculated so far (in [member priority] order).*/
	Area3DSpaceOverrideCombine Area3DSpaceOverride = 1
	/*This area adds its gravity/damping values to whatever has been calculated so far (in [member priority] order), ignoring any lower priority areas.*/
	Area3DSpaceOverrideCombineReplace Area3DSpaceOverride = 2
	/*This area replaces any gravity/damping, even the defaults, ignoring any lower priority areas.*/
	Area3DSpaceOverrideReplace Area3DSpaceOverride = 3
	/*This area replaces any gravity/damping calculated so far (in [member priority] order), but keeps calculating the rest of the areas.*/
	Area3DSpaceOverrideReplaceCombine Area3DSpaceOverride = 4
)

type Array ¶

type Array = gd.Array

type ArrayMesh ¶

type ArrayMesh = classdb.ArrayMesh

The ArrayMesh is used to construct a Mesh by specifying the attributes as arrays. The most basic example is the creation of a single triangle: [codeblocks] [gdscript] var vertices = PackedVector3Array() vertices.push_back(Vector3(0, 1, 0)) vertices.push_back(Vector3(1, 0, 0)) vertices.push_back(Vector3(0, 0, 1))

# Initialize the ArrayMesh. var arr_mesh = ArrayMesh.new() var arrays = [] arrays.resize(Mesh.ARRAY_MAX) arrays[Mesh.ARRAY_VERTEX] = vertices

# Create the Mesh. arr_mesh.add_surface_from_arrays(Mesh.PRIMITIVE_TRIANGLES, arrays) var m = MeshInstance3D.new() m.mesh = arr_mesh [/gdscript] [csharp] var vertices = new Vector3[]

{
    new Vector3(0, 1, 0),
    new Vector3(1, 0, 0),
    new Vector3(0, 0, 1),
};

// Initialize the ArrayMesh. var arrMesh = new ArrayMesh(); var arrays = new Godot.Collections.Array(); arrays.Resize((int)Mesh.ArrayType.Max); arrays[(int)Mesh.ArrayType.Vertex] = vertices;

// Create the Mesh. arrMesh.AddSurfaceFromArrays(Mesh.PrimitiveType.Triangles, arrays); var m = new MeshInstance3D(); m.Mesh = arrMesh; [/csharp] [/codeblocks] The MeshInstance3D is ready to be added to the SceneTree to be shown. See also ImmediateMesh, MeshDataTool and SurfaceTool for procedural geometry generation. [b]Note:[/b] Godot uses clockwise [url=https://learnopengl.com/Advanced-OpenGL/Face-culling]winding order[/url] for front faces of triangle primitive modes.

type ArrayOccluder3D ¶

type ArrayOccluder3D = classdb.ArrayOccluder3D

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

type ArrayOf ¶

type ArrayOf[T any] interface {
	gd.IsArray
	gd.IsArrayType[T]
	mmm.ManagedPointer[uintptr]

	All(method Callable) bool
	Any(method Callable) bool
	Append(value T)
	AppendArray(array gd.ArrayOf[T])
	Assign(array gd.ArrayOf[T])
	Back(ctx Context) T
	Bsearch(value T, before bool) int64
	BsearchCustom(value T, fn Callable, before bool) int64
	Clear()
	Count(value T) int64
	Duplicate(ctx Context, deep bool) gd.ArrayOf[T]
	Erase(value T)
	Fill(value T)
	Filter(ctx Context, method Callable) gd.ArrayOf[T]
	Find(what T, from int64) int64
	Free()
	Front(ctx Context) T
	GetTypedBuiltin() int64
	GetTypedClassName(ctx Context) StringName
	GetTypedScript(ctx Context) Variant
	Has(value T) bool
	Hash() int64
	Index(ctx Context, index int64) T
	Insert(position int64, value T) int64
	IsEmpty() bool
	IsReadOnly() bool
	IsSameTyped(array Array) bool
	IsTyped() bool
	MakeReadOnly()
	Map(ctx Context, method Callable) gd.ArrayOf[T]
	Max(ctx Context) T
	Min(ctx Context) T
	PickRandom(ctx Context) T
	PopAt(ctx Context, position int64) T
	PopBack(ctx Context) T
	PopFront(ctx Context) T
	PushBack(value T)
	PushFront(value T)
	Reduce(ctx Context, method Callable, accum T) T
	RemoveAt(position int64)
	Resize(size int64) int64
	Reverse()
	Rfind(what T, from int64) int64
	SetIndex(index int64, value T)
	Shuffle()
	Size() int64
	Slice(ctx Context, begin int64, end int64, step int64, deep bool) gd.ArrayOf[T]
	Sort()
	SortCustom(fn Callable)
}

func NewArrayOf[T any](godot Context) ArrayOf[T]

type AspectRatioContainer ¶

type AspectRatioContainer = classdb.AspectRatioContainer

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

type AspectRatioContainerAlignmentMode ¶

type AspectRatioContainerAlignmentMode = classdb.AspectRatioContainerAlignmentMode

const (
	/*Aligns child controls with the beginning (left or top) of the container.*/
	AspectRatioContainerAlignmentBegin AspectRatioContainerAlignmentMode = 0
	/*Aligns child controls with the center of the container.*/
	AspectRatioContainerAlignmentCenter AspectRatioContainerAlignmentMode = 1
	/*Aligns child controls with the end (right or bottom) of the container.*/
	AspectRatioContainerAlignmentEnd AspectRatioContainerAlignmentMode = 2
)

type AspectRatioContainerStretchMode ¶

type AspectRatioContainerStretchMode = classdb.AspectRatioContainerStretchMode

const (
	/*The height of child controls is automatically adjusted based on the width of the container.*/
	AspectRatioContainerStretchWidthControlsHeight AspectRatioContainerStretchMode = 0
	/*The width of child controls is automatically adjusted based on the height of the container.*/
	AspectRatioContainerStretchHeightControlsWidth AspectRatioContainerStretchMode = 1
	/*The bounding rectangle of child controls is automatically adjusted to fit inside the container while keeping the aspect ratio.*/
	AspectRatioContainerStretchFit AspectRatioContainerStretchMode = 2
	/*The width and height of child controls is automatically adjusted to make their bounding rectangle cover the entire area of the container while keeping the aspect ratio.
	  When the bounding rectangle of child controls exceed the container's size and [member Control.clip_contents] is enabled, this allows to show only the container's area restricted by its own bounding rectangle.*/
	AspectRatioContainerStretchCover AspectRatioContainerStretchMode = 3
)

type AtlasTexture ¶

type AtlasTexture = classdb.AtlasTexture

Texture2D resource that draws only part of its [member atlas] texture, as defined by the [member region]. An additional [member margin] can also be set, which is useful for small adjustments. Multiple AtlasTexture resources can be cropped from the same [member atlas]. Packing many smaller textures into a singular large texture helps to optimize video memory costs and render calls. [b]Note:[/b] AtlasTexture cannot be used in an AnimatedTexture, and may not tile properly in nodes such as TextureRect, when inside other AtlasTexture resources.

type AudioBusLayout ¶

type AudioBusLayout = classdb.AudioBusLayout

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

type AudioEffect ¶

type AudioEffect = classdb.AudioEffect

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

// AudioEffect methods that can be overridden by a [Class] that extends it.
type AudioEffect interface {
	Instantiate(godot Context) AudioEffectInstance
}

type AudioEffectAmplify ¶

type AudioEffectAmplify = classdb.AudioEffectAmplify

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

type AudioEffectBandLimitFilter ¶

type AudioEffectBandLimitFilter = classdb.AudioEffectBandLimitFilter

Limits the frequencies in a range around the [member AudioEffectFilter.cutoff_hz] and allows frequencies outside of this range to pass.

type AudioEffectBandPassFilter ¶

type AudioEffectBandPassFilter = classdb.AudioEffectBandPassFilter

Attenuates the frequencies inside of a range around the [member AudioEffectFilter.cutoff_hz] and cuts frequencies outside of this band.

type AudioEffectCapture ¶

type AudioEffectCapture = classdb.AudioEffectCapture

AudioEffectCapture is an AudioEffect which copies all audio frames from the attached audio effect bus into its internal ring buffer. Application code should consume these audio frames from this ring buffer using [method get_buffer] and process it as needed, for example to capture data from an AudioStreamMicrophone, implement application-defined effects, or to transmit audio over the network. When capturing audio data from a microphone, the format of the samples will be stereo 32-bit floating point PCM. [b]Note:[/b] [member ProjectSettings.audio/driver/enable_input] must be [code]true[/code] for audio input to work. See also that setting's description for caveats related to permissions and operating system privacy settings.

type AudioEffectChorus ¶

type AudioEffectChorus = classdb.AudioEffectChorus

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

type AudioEffectCompressor ¶

type AudioEffectCompressor = classdb.AudioEffectCompressor

Dynamic range compressor reduces the level of the sound when the amplitude goes over a certain threshold in Decibels. One of the main uses of a compressor is to increase the dynamic range by clipping as little as possible (when sound goes over 0dB). Compressor has many uses in the mix: - In the Master bus to compress the whole output (although an AudioEffectLimiter is probably better). - In voice channels to ensure they sound as balanced as possible. - Sidechained. This can reduce the sound level sidechained with another audio bus for threshold detection. This technique is common in video game mixing to the level of music and SFX while voices are being heard. - Accentuates transients by using a wider attack, making effects sound more punchy.

type AudioEffectDelay ¶

type AudioEffectDelay = classdb.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.

type AudioEffectDistortion ¶

type AudioEffectDistortion = classdb.AudioEffectDistortion

Different types are available: clip, tan, lo-fi (bit crushing), overdrive, or waveshape. By distorting the waveform the frequency content changes, which will often make the sound "crunchy" or "abrasive". For games, it can simulate sound coming from some saturated device or speaker very efficiently.

type AudioEffectDistortionMode ¶

type AudioEffectDistortionMode = classdb.AudioEffectDistortionMode

const (
	/*Digital distortion effect which cuts off peaks at the top and bottom of the waveform.*/
	AudioEffectDistortionModeClip AudioEffectDistortionMode = 0
	AudioEffectDistortionModeAtan AudioEffectDistortionMode = 1
	/*Low-resolution digital distortion effect (bit depth reduction). You can use it to emulate the sound of early digital audio devices.*/
	AudioEffectDistortionModeLofi AudioEffectDistortionMode = 2
	/*Emulates the warm distortion produced by a field effect transistor, which is commonly used in solid-state musical instrument amplifiers. The [member drive] property has no effect in this mode.*/
	AudioEffectDistortionModeOverdrive AudioEffectDistortionMode = 3
	/*Waveshaper distortions are used mainly by electronic musicians to achieve an extra-abrasive sound.*/
	AudioEffectDistortionModeWaveshape AudioEffectDistortionMode = 4
)

type AudioEffectEQ ¶

type AudioEffectEQ = classdb.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).

type AudioEffectEQ10 ¶

type AudioEffectEQ10 = classdb.AudioEffectEQ10

Frequency bands: Band 1: 31 Hz Band 2: 62 Hz Band 3: 125 Hz Band 4: 250 Hz Band 5: 500 Hz Band 6: 1000 Hz Band 7: 2000 Hz Band 8: 4000 Hz Band 9: 8000 Hz Band 10: 16000 Hz See also AudioEffectEQ, AudioEffectEQ6, AudioEffectEQ21.

type AudioEffectEQ21 ¶

type AudioEffectEQ21 = classdb.AudioEffectEQ21

Frequency bands: Band 1: 22 Hz Band 2: 32 Hz Band 3: 44 Hz Band 4: 63 Hz Band 5: 90 Hz Band 6: 125 Hz Band 7: 175 Hz Band 8: 250 Hz Band 9: 350 Hz Band 10: 500 Hz Band 11: 700 Hz Band 12: 1000 Hz Band 13: 1400 Hz Band 14: 2000 Hz Band 15: 2800 Hz Band 16: 4000 Hz Band 17: 5600 Hz Band 18: 8000 Hz Band 19: 11000 Hz Band 20: 16000 Hz Band 21: 22000 Hz See also AudioEffectEQ, AudioEffectEQ6, AudioEffectEQ10.

type AudioEffectEQ6 ¶

type AudioEffectEQ6 = classdb.AudioEffectEQ6

Frequency bands: Band 1: 32 Hz Band 2: 100 Hz Band 3: 320 Hz Band 4: 1000 Hz Band 5: 3200 Hz Band 6: 10000 Hz See also AudioEffectEQ, AudioEffectEQ10, AudioEffectEQ21.

type AudioEffectFilter ¶

type AudioEffectFilter = classdb.AudioEffectFilter

Allows frequencies other than the [member cutoff_hz] to pass.

type AudioEffectFilterFilterDB ¶

type AudioEffectFilterFilterDB = classdb.AudioEffectFilterFilterDB

const (
	AudioEffectFilterFilter6db  AudioEffectFilterFilterDB = 0
	AudioEffectFilterFilter12db AudioEffectFilterFilterDB = 1
	AudioEffectFilterFilter18db AudioEffectFilterFilterDB = 2
	AudioEffectFilterFilter24db AudioEffectFilterFilterDB = 3
)

type AudioEffectHighPassFilter ¶

type AudioEffectHighPassFilter = classdb.AudioEffectHighPassFilter

Cuts frequencies lower than the [member AudioEffectFilter.cutoff_hz] and allows higher frequencies to pass.

type AudioEffectHighShelfFilter ¶

type AudioEffectHighShelfFilter = classdb.AudioEffectHighShelfFilter

Reduces all frequencies above the [member AudioEffectFilter.cutoff_hz].

type AudioEffectInstance ¶

type AudioEffectInstance = classdb.AudioEffectInstance

type AudioEffectLimiter ¶

type AudioEffectLimiter = classdb.AudioEffectLimiter

A limiter is similar to a compressor, but it's less flexible and designed to disallow sound going over a given dB threshold. Adding one in the Master bus is always recommended to reduce the effects of clipping. Soft clipping starts to reduce the peaks a little below the threshold level and progressively increases its effect as the input level increases such that the threshold is never exceeded.

type AudioEffectLowPassFilter ¶

type AudioEffectLowPassFilter = classdb.AudioEffectLowPassFilter

Cuts frequencies higher than the [member AudioEffectFilter.cutoff_hz] and allows lower frequencies to pass.

type AudioEffectLowShelfFilter ¶

type AudioEffectLowShelfFilter = classdb.AudioEffectLowShelfFilter

Reduces all frequencies below the [member AudioEffectFilter.cutoff_hz].

type AudioEffectNotchFilter ¶

type AudioEffectNotchFilter = classdb.AudioEffectNotchFilter

Attenuates frequencies in a narrow band around the [member AudioEffectFilter.cutoff_hz] and cuts frequencies outside of this range.

type AudioEffectPanner ¶

type AudioEffectPanner = classdb.AudioEffectPanner

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

type AudioEffectPhaser ¶

type AudioEffectPhaser = classdb.AudioEffectPhaser

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

type AudioEffectPitchShift ¶

type AudioEffectPitchShift = classdb.AudioEffectPitchShift

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

type AudioEffectPitchShiftFFTSize ¶

type AudioEffectPitchShiftFFTSize = classdb.AudioEffectPitchShiftFFTSize

const (
	/*Use a buffer of 256 samples for the Fast Fourier transform. Lowest latency, but least stable over time.*/
	AudioEffectPitchShiftFftSize256 AudioEffectPitchShiftFFTSize = 0
	/*Use a buffer of 512 samples for the Fast Fourier transform. Low latency, but less stable over time.*/
	AudioEffectPitchShiftFftSize512 AudioEffectPitchShiftFFTSize = 1
	/*Use a buffer of 1024 samples for the Fast Fourier transform. This is a compromise between latency and stability over time.*/
	AudioEffectPitchShiftFftSize1024 AudioEffectPitchShiftFFTSize = 2
	/*Use a buffer of 2048 samples for the Fast Fourier transform. High latency, but stable over time.*/
	AudioEffectPitchShiftFftSize2048 AudioEffectPitchShiftFFTSize = 3
	/*Use a buffer of 4096 samples for the Fast Fourier transform. Highest latency, but most stable over time.*/
	AudioEffectPitchShiftFftSize4096 AudioEffectPitchShiftFFTSize = 4
	/*Represents the size of the [enum FFTSize] enum.*/
	AudioEffectPitchShiftFftSizeMax AudioEffectPitchShiftFFTSize = 5
)

type AudioEffectRecord ¶

type AudioEffectRecord = classdb.AudioEffectRecord

Allows the user to record the sound from an audio bus. This can include all audio output by Godot when used on the "Master" audio bus. Can be used (with an AudioStreamMicrophone) to record from a microphone. It sets and gets the format in which the audio file will be recorded (8-bit, 16-bit, or compressed). It checks whether or not the recording is active, and if it is, records the sound. It then returns the recorded sample.

type AudioEffectReverb ¶

type AudioEffectReverb = classdb.AudioEffectReverb

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

type AudioEffectSpectrumAnalyzer ¶

type AudioEffectSpectrumAnalyzer = classdb.AudioEffectSpectrumAnalyzer

This audio effect does not affect sound output, but can be used for real-time audio visualizations. See also AudioStreamGenerator for procedurally generating sounds.

type AudioEffectSpectrumAnalyzerFFTSize ¶

type AudioEffectSpectrumAnalyzerFFTSize = classdb.AudioEffectSpectrumAnalyzerFFTSize

const (
	/*Use a buffer of 256 samples for the Fast Fourier transform. Lowest latency, but least stable over time.*/
	AudioEffectSpectrumAnalyzerFftSize256 AudioEffectSpectrumAnalyzerFFTSize = 0
	/*Use a buffer of 512 samples for the Fast Fourier transform. Low latency, but less stable over time.*/
	AudioEffectSpectrumAnalyzerFftSize512 AudioEffectSpectrumAnalyzerFFTSize = 1
	/*Use a buffer of 1024 samples for the Fast Fourier transform. This is a compromise between latency and stability over time.*/
	AudioEffectSpectrumAnalyzerFftSize1024 AudioEffectSpectrumAnalyzerFFTSize = 2
	/*Use a buffer of 2048 samples for the Fast Fourier transform. High latency, but stable over time.*/
	AudioEffectSpectrumAnalyzerFftSize2048 AudioEffectSpectrumAnalyzerFFTSize = 3
	/*Use a buffer of 4096 samples for the Fast Fourier transform. Highest latency, but most stable over time.*/
	AudioEffectSpectrumAnalyzerFftSize4096 AudioEffectSpectrumAnalyzerFFTSize = 4
	/*Represents the size of the [enum FFTSize] enum.*/
	AudioEffectSpectrumAnalyzerFftSizeMax AudioEffectSpectrumAnalyzerFFTSize = 5
)

type AudioEffectSpectrumAnalyzerInstance ¶

type AudioEffectSpectrumAnalyzerInstance = classdb.AudioEffectSpectrumAnalyzerInstance

type AudioEffectSpectrumAnalyzerInstanceMagnitudeMode ¶

type AudioEffectSpectrumAnalyzerInstanceMagnitudeMode = classdb.AudioEffectSpectrumAnalyzerInstanceMagnitudeMode

const (
	/*Use the average value as magnitude.*/
	AudioEffectSpectrumAnalyzerInstanceMagnitudeAverage AudioEffectSpectrumAnalyzerInstanceMagnitudeMode = 0
	/*Use the maximum value as magnitude.*/
	AudioEffectSpectrumAnalyzerInstanceMagnitudeMax AudioEffectSpectrumAnalyzerInstanceMagnitudeMode = 1
)

type AudioEffectStereoEnhance ¶

type AudioEffectStereoEnhance = classdb.AudioEffectStereoEnhance

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

type AudioListener2D ¶

type AudioListener2D = classdb.AudioListener2D

Once added to the scene tree and enabled using [method make_current], this node will override the location sounds are heard from. Only one AudioListener2D can be current. Using [method make_current] will disable the previous AudioListener2D. If there is no active AudioListener2D in the current Viewport, center of the screen will be used as a hearing point for the audio. AudioListener2D needs to be inside SceneTree to function.

type AudioListener3D ¶

type AudioListener3D = classdb.AudioListener3D

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

type AudioServerSpeakerMode ¶

type AudioServerSpeakerMode = classdb.AudioServerSpeakerMode

const (
	/*Two or fewer speakers were detected.*/
	AudioServerSpeakerModeStereo AudioServerSpeakerMode = 0
	/*A 3.1 channel surround setup was detected.*/
	AudioServerSpeakerSurround31 AudioServerSpeakerMode = 1
	/*A 5.1 channel surround setup was detected.*/
	AudioServerSpeakerSurround51 AudioServerSpeakerMode = 2
	/*A 7.1 channel surround setup was detected.*/
	AudioServerSpeakerSurround71 AudioServerSpeakerMode = 3
)

type AudioStream ¶

type AudioStream = classdb.AudioStream

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

// AudioStream methods that can be overridden by a [Class] that extends it.
type AudioStream interface {
	//Override this method to customize the returned value of [method instantiate_playback]. Should returned a new [AudioStreamPlayback] created when the stream is played (such as by an [AudioStreamPlayer])..
	InstantiatePlayback(godot Context) AudioStreamPlayback
	//Override this method to customize the name assigned to this audio stream. Unused by the engine.
	GetStreamName(godot Context) gd.String
	//Override this method to customize the returned value of [method get_length]. Should return the length of this audio stream, in seconds.
	GetLength(godot Context) gd.Float
	//Override this method to customize the returned value of [method is_monophonic]. Should return [code]true[/code] if this audio stream only supports one channel.
	IsMonophonic(godot Context) bool
	//Overridable method. Should return the tempo of this audio stream, in beats per minute (BPM). Used by the engine to determine the position of every beat.
	//Ideally, the returned value should be based off the stream's sample rate ([member AudioStreamWAV.mix_rate], for example).
	GetBpm(godot Context) gd.Float
	//Overridable method. Should return the total number of beats of this audio stream. Used by the engine to determine the position of every beat.
	//Ideally, the returned value should be based off the stream's sample rate ([member AudioStreamWAV.mix_rate], for example).
	GetBeatCount(godot Context) gd.Int
}

type AudioStreamGenerator ¶

type AudioStreamGenerator = classdb.AudioStreamGenerator

AudioStreamGenerator is a type of audio stream that does not play back sounds on its own; instead, it expects a script to generate audio data for it. See also AudioStreamGeneratorPlayback. Here's a sample on how to use it to generate a sine wave: [codeblocks] [gdscript] var playback # Will hold the AudioStreamGeneratorPlayback. @onready var sample_hz = $AudioStreamPlayer.stream.mix_rate var pulse_hz = 440.0 # The frequency of the sound wave.

func _ready():

$AudioStreamPlayer.play()
playback = $AudioStreamPlayer.get_stream_playback()
fill_buffer()

func fill_buffer():

var phase = 0.0
var increment = pulse_hz / sample_hz
var frames_available = playback.get_frames_available()

for i in range(frames_available):
    playback.push_frame(Vector2.ONE * sin(phase * TAU))
    phase = fmod(phase + increment, 1.0)

[/gdscript] [csharp] [Export] public AudioStreamPlayer Player { get; set; }

private AudioStreamGeneratorPlayback _playback; // Will hold the AudioStreamGeneratorPlayback. private float _sampleHz; private float _pulseHz = 440.0f; // The frequency of the sound wave.

public override void _Ready()

{
    if (Player.Stream is AudioStreamGenerator generator) // Type as a generator to access MixRate.
    {
        _sampleHz = generator.MixRate;
        Player.Play();
        _playback = (AudioStreamGeneratorPlayback)Player.GetStreamPlayback();
        FillBuffer();
    }
}

public void FillBuffer()

{
    double phase = 0.0;
    float increment = _pulseHz / _sampleHz;
    int framesAvailable = _playback.GetFramesAvailable();

    for (int i = 0; i < framesAvailable; i++)
    {
        _playback.PushFrame(Vector2.One * (float)Mathf.Sin(phase * Mathf.Tau));
        phase = Mathf.PosMod(phase + increment, 1.0);
    }
}

[/csharp] [/codeblocks] In the example above, the "AudioStreamPlayer" node must use an AudioStreamGenerator as its stream. The [code]fill_buffer[/code] function provides audio data for approximating a sine wave. See also AudioEffectSpectrumAnalyzer for performing real-time audio spectrum analysis. [b]Note:[/b] Due to performance constraints, this class is best used from C# or from a compiled language via GDExtension. If you still want to use this class from GDScript, consider using a lower [member mix_rate] such as 11,025 Hz or 22,050 Hz.

type AudioStreamGeneratorPlayback ¶

type AudioStreamGeneratorPlayback = classdb.AudioStreamGeneratorPlayback

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

type AudioStreamMP3 ¶

type AudioStreamMP3 = classdb.AudioStreamMP3

MP3 audio stream driver. See [member data] if you want to load an MP3 file at run-time.

type AudioStreamMicrophone ¶

type AudioStreamMicrophone = classdb.AudioStreamMicrophone

When used directly in an AudioStreamPlayer node, AudioStreamMicrophone plays back microphone input in real-time. This can be used in conjunction with AudioEffectCapture to process the data or save it. [b]Note:[/b] [member ProjectSettings.audio/driver/enable_input] must be [code]true[/code] for audio input to work. See also that setting's description for caveats related to permissions and operating system privacy settings.

type AudioStreamOggVorbis ¶

type AudioStreamOggVorbis = classdb.AudioStreamOggVorbis

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

type AudioStreamPlayback ¶

type AudioStreamPlayback = classdb.AudioStreamPlayback

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

// AudioStreamPlayback methods that can be overridden by a [Class] that extends it.
type AudioStreamPlayback interface {
	//Override this method to customize what happens when the playback starts at the given position, such as by calling [method AudioStreamPlayer.play].
	Start(godot Context, from_pos gd.Float)
	//Override this method to customize what happens when the playback is stopped, such as by calling [method AudioStreamPlayer.stop].
	Stop(godot Context)
	//Overridable method. Should return [code]true[/code] if this playback is active and playing its audio stream.
	IsPlaying(godot Context) bool
	//Overridable method. Should return how many times this audio stream has looped. Most built-in playbacks always return [code]0[/code].
	GetLoopCount(godot Context) gd.Int
	//Overridable method. Should return the current progress along the audio stream, in seconds.
	GetPlaybackPosition(godot Context) gd.Float
	//Override this method to customize what happens when seeking this audio stream at the given [param position], such as by calling [method AudioStreamPlayer.seek].
	Seek(godot Context, position gd.Float)
	//Override this method to customize how the audio stream is mixed. This method is called even if the playback is not active.
	//[b]Note:[/b] It is not useful to override this method in GDScript or C#. Only GDExtension can take advantage of it.
	Mix(godot Context, buffer *AudioFrame, rate_scale gd.Float, frames gd.Int) gd.Int
	//Overridable method. Called whenever the audio stream is mixed if the playback is active and [method AudioServer.set_enable_tagging_used_audio_streams] has been set to [code]true[/code]. Editor plugins may use this method to "tag" the current position along the audio stream and display it in a preview.
	TagUsedStreams(godot Context)
}

type AudioStreamPlaybackOggVorbis ¶

type AudioStreamPlaybackOggVorbis = classdb.AudioStreamPlaybackOggVorbis

type AudioStreamPlaybackPolyphonic ¶

type AudioStreamPlaybackPolyphonic = classdb.AudioStreamPlaybackPolyphonic

Playback instance for AudioStreamPolyphonic. After setting the [code]stream[/code] property of AudioStreamPlayer, AudioStreamPlayer2D, or AudioStreamPlayer3D, the playback instance can be obtained by calling [method AudioStreamPlayer.get_stream_playback], [method AudioStreamPlayer2D.get_stream_playback] or [method AudioStreamPlayer3D.get_stream_playback] methods.

type AudioStreamPlaybackResampled ¶

type AudioStreamPlaybackResampled = classdb.AudioStreamPlaybackResampled

type AudioStreamPlayer ¶

type AudioStreamPlayer = classdb.AudioStreamPlayer

Plays an audio stream non-positionally. To play audio positionally, use AudioStreamPlayer2D or AudioStreamPlayer3D instead of AudioStreamPlayer.

type AudioStreamPlayer2D ¶

type AudioStreamPlayer2D = classdb.AudioStreamPlayer2D

Plays audio that is attenuated with distance to the listener. By default, audio is heard from the screen center. This can be changed by adding an AudioListener2D node to the scene and enabling it by calling [method AudioListener2D.make_current] on it. See also AudioStreamPlayer to play a sound non-positionally. [b]Note:[/b] Hiding an AudioStreamPlayer2D node does not disable its audio output. To temporarily disable an AudioStreamPlayer2D's audio output, set [member volume_db] to a very low value like [code]-100[/code] (which isn't audible to human hearing).

type AudioStreamPlayer3D ¶

type AudioStreamPlayer3D = classdb.AudioStreamPlayer3D

Plays audio with positional sound effects, based on the relative position of the audio listener. Positional effects include distance attenuation, directionality, and the Doppler effect. For greater realism, a low-pass filter is applied to distant sounds. This can be disabled by setting [member attenuation_filter_cutoff_hz] to [code]20500[/code]. By default, audio is heard from the camera position. This can be changed by adding an AudioListener3D node to the scene and enabling it by calling [method AudioListener3D.make_current] on it. See also AudioStreamPlayer to play a sound non-positionally. [b]Note:[/b] Hiding an AudioStreamPlayer3D node does not disable its audio output. To temporarily disable an AudioStreamPlayer3D's audio output, set [member volume_db] to a very low value like [code]-100[/code] (which isn't audible to human hearing).

type AudioStreamPlayer3DAttenuationModel ¶

type AudioStreamPlayer3DAttenuationModel = classdb.AudioStreamPlayer3DAttenuationModel

const (
	/*Attenuation of loudness according to linear distance.*/
	AudioStreamPlayer3DAttenuationInverseDistance AudioStreamPlayer3DAttenuationModel = 0
	/*Attenuation of loudness according to squared distance.*/
	AudioStreamPlayer3DAttenuationInverseSquareDistance AudioStreamPlayer3DAttenuationModel = 1
	/*Attenuation of loudness according to logarithmic distance.*/
	AudioStreamPlayer3DAttenuationLogarithmic AudioStreamPlayer3DAttenuationModel = 2
	/*No attenuation of loudness according to distance. The sound will still be heard positionally, unlike an [AudioStreamPlayer]. [constant ATTENUATION_DISABLED] can be combined with a [member max_distance] value greater than [code]0.0[/code] to achieve linear attenuation clamped to a sphere of a defined size.*/
	AudioStreamPlayer3DAttenuationDisabled AudioStreamPlayer3DAttenuationModel = 3
)

type AudioStreamPlayer3DDopplerTracking ¶

type AudioStreamPlayer3DDopplerTracking = classdb.AudioStreamPlayer3DDopplerTracking

const (
	/*Disables doppler tracking.*/
	AudioStreamPlayer3DDopplerTrackingDisabled AudioStreamPlayer3DDopplerTracking = 0
	/*Executes doppler tracking during process frames (see [constant Node.NOTIFICATION_INTERNAL_PROCESS]).*/
	AudioStreamPlayer3DDopplerTrackingIdleStep AudioStreamPlayer3DDopplerTracking = 1
	/*Executes doppler tracking during physics frames (see [constant Node.NOTIFICATION_INTERNAL_PHYSICS_PROCESS]).*/
	AudioStreamPlayer3DDopplerTrackingPhysicsStep AudioStreamPlayer3DDopplerTracking = 2
)

type AudioStreamPlayerMixTarget ¶

type AudioStreamPlayerMixTarget = classdb.AudioStreamPlayerMixTarget

const (
	/*The audio will be played only on the first channel.*/
	AudioStreamPlayerMixTargetStereo AudioStreamPlayerMixTarget = 0
	/*The audio will be played on all surround channels.*/
	AudioStreamPlayerMixTargetSurround AudioStreamPlayerMixTarget = 1
	/*The audio will be played on the second channel, which is usually the center.*/
	AudioStreamPlayerMixTargetCenter AudioStreamPlayerMixTarget = 2
)

type AudioStreamPolyphonic ¶

type AudioStreamPolyphonic = classdb.AudioStreamPolyphonic

AudioStream that lets the user play custom streams at any time from code, simultaneously using a single player. Playback control is done via the AudioStreamPlaybackPolyphonic instance set inside the player, which can be obtained via [method AudioStreamPlayer.get_stream_playback], [method AudioStreamPlayer2D.get_stream_playback] or [method AudioStreamPlayer3D.get_stream_playback] methods. Obtaining the playback instance is only valid after the [code]stream[/code] property is set as an AudioStreamPolyphonic in those players.

type AudioStreamRandomizer ¶

type AudioStreamRandomizer = classdb.AudioStreamRandomizer

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

type AudioStreamRandomizerPlaybackMode ¶

type AudioStreamRandomizerPlaybackMode = classdb.AudioStreamRandomizerPlaybackMode

const (
	/*Pick a stream at random according to the probability weights chosen for each stream, but avoid playing the same stream twice in a row whenever possible. If only 1 sound is present in the pool, the same sound will always play, effectively allowing repeats to occur.*/
	AudioStreamRandomizerPlaybackRandomNoRepeats AudioStreamRandomizerPlaybackMode = 0
	/*Pick a stream at random according to the probability weights chosen for each stream. If only 1 sound is present in the pool, the same sound will always play.*/
	AudioStreamRandomizerPlaybackRandom AudioStreamRandomizerPlaybackMode = 1
	/*Play streams in the order they appear in the stream pool. If only 1 sound is present in the pool, the same sound will always play.*/
	AudioStreamRandomizerPlaybackSequential AudioStreamRandomizerPlaybackMode = 2
)

type AudioStreamWAV ¶

type AudioStreamWAV = classdb.AudioStreamWAV

AudioStreamWAV stores sound samples loaded from WAV files. To play the stored sound, use an AudioStreamPlayer (for non-positional audio) or AudioStreamPlayer2D/AudioStreamPlayer3D (for positional audio). The sound can be looped. This class can also be used to store dynamically-generated PCM audio data. See also AudioStreamGenerator for procedural audio generation.

type AudioStreamWAVFormat ¶

type AudioStreamWAVFormat = classdb.AudioStreamWAVFormat

const (
	/*8-bit audio codec.*/
	AudioStreamWAVFormat8Bits AudioStreamWAVFormat = 0
	/*16-bit audio codec.*/
	AudioStreamWAVFormat16Bits AudioStreamWAVFormat = 1
	/*Audio is compressed using IMA ADPCM.*/
	AudioStreamWAVFormatImaAdpcm AudioStreamWAVFormat = 2
)

type AudioStreamWAVLoopMode ¶

type AudioStreamWAVLoopMode = classdb.AudioStreamWAVLoopMode

const (
	/*Audio does not loop.*/
	AudioStreamWAVLoopDisabled AudioStreamWAVLoopMode = 0
	/*Audio loops the data between [member loop_begin] and [member loop_end], playing forward only.*/
	AudioStreamWAVLoopForward AudioStreamWAVLoopMode = 1
	/*Audio loops the data between [member loop_begin] and [member loop_end], playing back and forth.*/
	AudioStreamWAVLoopPingpong AudioStreamWAVLoopMode = 2
	/*Audio loops the data between [member loop_begin] and [member loop_end], playing backward only.*/
	AudioStreamWAVLoopBackward AudioStreamWAVLoopMode = 3
)

type Axis ¶

type Axis int

const (
	X Axis = iota
	Y
	Z
	W
)

type BackBufferCopy ¶

type BackBufferCopy = classdb.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 [member copy_mode]. It can be accessed in shader scripts using the screen texture (i.e. a uniform sampler with [code]hint_screen_texture[/code]). [b]Note:[/b] Since this node inherits from Node2D (and not Control), anchors and margins won't apply to child Control-derived nodes. This can be problematic when resizing the window. To avoid this, add Control-derived nodes as [i]siblings[/i] to the BackBufferCopy node instead of adding them as children.

type BackBufferCopyCopyMode ¶

type BackBufferCopyCopyMode = classdb.BackBufferCopyCopyMode

const (
	/*Disables the buffering mode. This means the [BackBufferCopy] node will directly use the portion of screen it covers.*/
	BackBufferCopyCopyModeDisabled BackBufferCopyCopyMode = 0
	/*[BackBufferCopy] buffers a rectangular region.*/
	BackBufferCopyCopyModeRect BackBufferCopyCopyMode = 1
	/*[BackBufferCopy] buffers the entire screen.*/
	BackBufferCopyCopyModeViewport BackBufferCopyCopyMode = 2
)

type BaseButton ¶

type BaseButton = classdb.BaseButton

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

// BaseButton methods that can be overridden by a [Class] that extends it.
type BaseButton interface {
	//Called when the button is pressed. If you need to know the button's pressed state (and [member toggle_mode] is active), use [method _toggled] instead.
	Pressed(godot Context)
	//Called when the button is toggled (only if [member toggle_mode] is active).
	Toggled(godot Context, toggled_on bool)
}

type BaseButtonActionMode ¶

type BaseButtonActionMode = classdb.BaseButtonActionMode

const (
	/*Require just a press to consider the button clicked.*/
	BaseButtonActionModeButtonPress BaseButtonActionMode = 0
	/*Require a press and a subsequent release before considering the button clicked.*/
	BaseButtonActionModeButtonRelease BaseButtonActionMode = 1
)

type BaseButtonDrawMode ¶

type BaseButtonDrawMode = classdb.BaseButtonDrawMode

const (
	/*The normal state (i.e. not pressed, not hovered, not toggled and enabled) of buttons.*/
	BaseButtonDrawNormal BaseButtonDrawMode = 0
	/*The state of buttons are pressed.*/
	BaseButtonDrawPressed BaseButtonDrawMode = 1
	/*The state of buttons are hovered.*/
	BaseButtonDrawHover BaseButtonDrawMode = 2
	/*The state of buttons are disabled.*/
	BaseButtonDrawDisabled BaseButtonDrawMode = 3
	/*The state of buttons are both hovered and pressed.*/
	BaseButtonDrawHoverPressed BaseButtonDrawMode = 4
)

type BaseMaterial3D ¶

type BaseMaterial3D = classdb.BaseMaterial3D

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

type BaseMaterial3DAlphaAntiAliasing ¶

type BaseMaterial3DAlphaAntiAliasing = classdb.BaseMaterial3DAlphaAntiAliasing

const (
	/*Disables Alpha AntiAliasing for the material.*/
	BaseMaterial3DAlphaAntialiasingOff BaseMaterial3DAlphaAntiAliasing = 0
	/*Enables AlphaToCoverage. Alpha values in the material are passed to the AntiAliasing sample mask.*/
	BaseMaterial3DAlphaAntialiasingAlphaToCoverage BaseMaterial3DAlphaAntiAliasing = 1
	/*Enables AlphaToCoverage and forces all non-zero alpha values to [code]1[/code]. Alpha values in the material are passed to the AntiAliasing sample mask.*/
	BaseMaterial3DAlphaAntialiasingAlphaToCoverageAndToOne BaseMaterial3DAlphaAntiAliasing = 2
)

type BaseMaterial3DBillboardMode ¶

type BaseMaterial3DBillboardMode = classdb.BaseMaterial3DBillboardMode

const (
	/*Billboard mode is disabled.*/
	BaseMaterial3DBillboardDisabled BaseMaterial3DBillboardMode = 0
	/*The object's Z axis will always face the camera.*/
	BaseMaterial3DBillboardEnabled BaseMaterial3DBillboardMode = 1
	/*The object's X axis will always face the camera.*/
	BaseMaterial3DBillboardFixedY BaseMaterial3DBillboardMode = 2
	/*Used for particle systems when assigned to [GPUParticles3D] and [CPUParticles3D] nodes (flipbook animation). Enables [code]particles_anim_*[/code] properties.
	  The [member ParticleProcessMaterial.anim_speed_min] or [member CPUParticles3D.anim_speed_min] should also be set to a value bigger than zero for the animation to play.*/
	BaseMaterial3DBillboardParticles BaseMaterial3DBillboardMode = 3
)

type BaseMaterial3DBlendMode ¶

type BaseMaterial3DBlendMode = classdb.BaseMaterial3DBlendMode

const (
	/*Default blend mode. The color of the object is blended over the background based on the object's alpha value.*/
	BaseMaterial3DBlendModeMix BaseMaterial3DBlendMode = 0
	/*The color of the object is added to the background.*/
	BaseMaterial3DBlendModeAdd BaseMaterial3DBlendMode = 1
	/*The color of the object is subtracted from the background.*/
	BaseMaterial3DBlendModeSub BaseMaterial3DBlendMode = 2
	/*The color of the object is multiplied by the background.*/
	BaseMaterial3DBlendModeMul BaseMaterial3DBlendMode = 3
)

type BaseMaterial3DCullMode ¶

type BaseMaterial3DCullMode = classdb.BaseMaterial3DCullMode

const (
	/*Default cull mode. The back of the object is culled when not visible. Back face triangles will be culled when facing the camera. This results in only the front side of triangles being drawn. For closed-surface meshes, this means that only the exterior of the mesh will be visible.*/
	BaseMaterial3DCullBack BaseMaterial3DCullMode = 0
	/*Front face triangles will be culled when facing the camera. This results in only the back side of triangles being drawn. For closed-surface meshes, this means that the interior of the mesh will be drawn instead of the exterior.*/
	BaseMaterial3DCullFront BaseMaterial3DCullMode = 1
	/*No face culling is performed; both the front face and back face will be visible.*/
	BaseMaterial3DCullDisabled BaseMaterial3DCullMode = 2
)

type BaseMaterial3DDepthDrawMode ¶

type BaseMaterial3DDepthDrawMode = classdb.BaseMaterial3DDepthDrawMode

const (
	/*Default depth draw mode. Depth is drawn only for opaque objects during the opaque prepass (if any) and during the opaque pass.*/
	BaseMaterial3DDepthDrawOpaqueOnly BaseMaterial3DDepthDrawMode = 0
	/*Objects will write to depth during the opaque and the transparent passes. Transparent objects that are close to the camera may obscure other transparent objects behind them.
	  [b]Note:[/b] This does not influence whether transparent objects are included in the depth prepass or not. For that, see [enum Transparency].*/
	BaseMaterial3DDepthDrawAlways BaseMaterial3DDepthDrawMode = 1
	/*Objects will not write their depth to the depth buffer, even during the depth prepass (if enabled).*/
	BaseMaterial3DDepthDrawDisabled BaseMaterial3DDepthDrawMode = 2
)

type BaseMaterial3DDetailUV ¶

type BaseMaterial3DDetailUV = classdb.BaseMaterial3DDetailUV

const (
	/*Use [code]UV[/code] with the detail texture.*/
	BaseMaterial3DDetailUv1 BaseMaterial3DDetailUV = 0
	/*Use [code]UV2[/code] with the detail texture.*/
	BaseMaterial3DDetailUv2 BaseMaterial3DDetailUV = 1
)

type BaseMaterial3DDiffuseMode ¶

type BaseMaterial3DDiffuseMode = classdb.BaseMaterial3DDiffuseMode

const (
	/*Default diffuse scattering algorithm.*/
	BaseMaterial3DDiffuseBurley BaseMaterial3DDiffuseMode = 0
	/*Diffuse scattering ignores roughness.*/
	BaseMaterial3DDiffuseLambert BaseMaterial3DDiffuseMode = 1
	/*Extends Lambert to cover more than 90 degrees when roughness increases.*/
	BaseMaterial3DDiffuseLambertWrap BaseMaterial3DDiffuseMode = 2
	/*Uses a hard cut for lighting, with smoothing affected by roughness.*/
	BaseMaterial3DDiffuseToon BaseMaterial3DDiffuseMode = 3
)

type BaseMaterial3DDistanceFadeMode ¶

type BaseMaterial3DDistanceFadeMode = classdb.BaseMaterial3DDistanceFadeMode

const (
	/*Do not use distance fade.*/
	BaseMaterial3DDistanceFadeDisabled BaseMaterial3DDistanceFadeMode = 0
	/*Smoothly fades the object out based on each pixel's distance from the camera using the alpha channel.*/
	BaseMaterial3DDistanceFadePixelAlpha BaseMaterial3DDistanceFadeMode = 1
	/*Smoothly fades the object out based on each pixel's distance from the camera using a dithering approach. Dithering discards pixels based on a set pattern to smoothly fade without enabling transparency. On certain hardware, this can be faster than [constant DISTANCE_FADE_PIXEL_ALPHA].*/
	BaseMaterial3DDistanceFadePixelDither BaseMaterial3DDistanceFadeMode = 2
	/*Smoothly fades the object out based on the object's distance from the camera using a dithering approach. Dithering discards pixels based on a set pattern to smoothly fade without enabling transparency. On certain hardware, this can be faster than [constant DISTANCE_FADE_PIXEL_ALPHA] and [constant DISTANCE_FADE_PIXEL_DITHER].*/
	BaseMaterial3DDistanceFadeObjectDither BaseMaterial3DDistanceFadeMode = 3
)

type BaseMaterial3DEmissionOperator ¶

type BaseMaterial3DEmissionOperator = classdb.BaseMaterial3DEmissionOperator

const (
	/*Adds the emission color to the color from the emission texture.*/
	BaseMaterial3DEmissionOpAdd BaseMaterial3DEmissionOperator = 0
	/*Multiplies the emission color by the color from the emission texture.*/
	BaseMaterial3DEmissionOpMultiply BaseMaterial3DEmissionOperator = 1
)

type BaseMaterial3DFeature ¶

type BaseMaterial3DFeature = classdb.BaseMaterial3DFeature

const (
	/*Constant for setting [member emission_enabled].*/
	BaseMaterial3DFeatureEmission BaseMaterial3DFeature = 0
	/*Constant for setting [member normal_enabled].*/
	BaseMaterial3DFeatureNormalMapping BaseMaterial3DFeature = 1
	/*Constant for setting [member rim_enabled].*/
	BaseMaterial3DFeatureRim BaseMaterial3DFeature = 2
	/*Constant for setting [member clearcoat_enabled].*/
	BaseMaterial3DFeatureClearcoat BaseMaterial3DFeature = 3
	/*Constant for setting [member anisotropy_enabled].*/
	BaseMaterial3DFeatureAnisotropy BaseMaterial3DFeature = 4
	/*Constant for setting [member ao_enabled].*/
	BaseMaterial3DFeatureAmbientOcclusion BaseMaterial3DFeature = 5
	/*Constant for setting [member heightmap_enabled].*/
	BaseMaterial3DFeatureHeightMapping BaseMaterial3DFeature = 6
	/*Constant for setting [member subsurf_scatter_enabled].*/
	BaseMaterial3DFeatureSubsurfaceScattering BaseMaterial3DFeature = 7
	/*Constant for setting [member subsurf_scatter_transmittance_enabled].*/
	BaseMaterial3DFeatureSubsurfaceTransmittance BaseMaterial3DFeature = 8
	/*Constant for setting [member backlight_enabled].*/
	BaseMaterial3DFeatureBacklight BaseMaterial3DFeature = 9
	/*Constant for setting [member refraction_enabled].*/
	BaseMaterial3DFeatureRefraction BaseMaterial3DFeature = 10
	/*Constant for setting [member detail_enabled].*/
	BaseMaterial3DFeatureDetail BaseMaterial3DFeature = 11
	/*Represents the size of the [enum Feature] enum.*/
	BaseMaterial3DFeatureMax BaseMaterial3DFeature = 12
)

type BaseMaterial3DFlags ¶

type BaseMaterial3DFlags = classdb.BaseMaterial3DFlags

const (
	/*Disables the depth test, so this object is drawn on top of all others drawn before it. This puts the object in the transparent draw pass where it is sorted based on distance to camera. Objects drawn after it in the draw order may cover it. This also disables writing to depth.*/
	BaseMaterial3DFlagDisableDepthTest BaseMaterial3DFlags = 0
	/*Set [code]ALBEDO[/code] to the per-vertex color specified in the mesh.*/
	BaseMaterial3DFlagAlbedoFromVertexColor BaseMaterial3DFlags = 1
	/*Vertex colors are considered to be stored in sRGB color space and are converted to linear color space during rendering. See also [member vertex_color_is_srgb].
	  [b]Note:[/b] Only effective when using the Forward+ and Mobile rendering methods.*/
	BaseMaterial3DFlagSrgbVertexColor BaseMaterial3DFlags = 2
	/*Uses point size to alter the size of primitive points. Also changes the albedo texture lookup to use [code]POINT_COORD[/code] instead of [code]UV[/code].*/
	BaseMaterial3DFlagUsePointSize BaseMaterial3DFlags = 3
	/*Object is scaled by depth so that it always appears the same size on screen.*/
	BaseMaterial3DFlagFixedSize BaseMaterial3DFlags = 4
	/*Shader will keep the scale set for the mesh. Otherwise the scale is lost when billboarding. Only applies when [member billboard_mode] is [constant BILLBOARD_ENABLED].*/
	BaseMaterial3DFlagBillboardKeepScale BaseMaterial3DFlags = 5
	/*Use triplanar texture lookup for all texture lookups that would normally use [code]UV[/code].*/
	BaseMaterial3DFlagUv1UseTriplanar BaseMaterial3DFlags = 6
	/*Use triplanar texture lookup for all texture lookups that would normally use [code]UV2[/code].*/
	BaseMaterial3DFlagUv2UseTriplanar BaseMaterial3DFlags = 7
	/*Use triplanar texture lookup for all texture lookups that would normally use [code]UV[/code].*/
	BaseMaterial3DFlagUv1UseWorldTriplanar BaseMaterial3DFlags = 8
	/*Use triplanar texture lookup for all texture lookups that would normally use [code]UV2[/code].*/
	BaseMaterial3DFlagUv2UseWorldTriplanar BaseMaterial3DFlags = 9
	/*Use [code]UV2[/code] coordinates to look up from the [member ao_texture].*/
	BaseMaterial3DFlagAoOnUv2 BaseMaterial3DFlags = 10
	/*Use [code]UV2[/code] coordinates to look up from the [member emission_texture].*/
	BaseMaterial3DFlagEmissionOnUv2 BaseMaterial3DFlags = 11
	/*Forces the shader to convert albedo from sRGB space to linear space. See also [member albedo_texture_force_srgb].*/
	BaseMaterial3DFlagAlbedoTextureForceSrgb BaseMaterial3DFlags = 12
	/*Disables receiving shadows from other objects.*/
	BaseMaterial3DFlagDontReceiveShadows BaseMaterial3DFlags = 13
	/*Disables receiving ambient light.*/
	BaseMaterial3DFlagDisableAmbientLight BaseMaterial3DFlags = 14
	/*Enables the shadow to opacity feature.*/
	BaseMaterial3DFlagUseShadowToOpacity BaseMaterial3DFlags = 15
	/*Enables the texture to repeat when UV coordinates are outside the 0-1 range. If using one of the linear filtering modes, this can result in artifacts at the edges of a texture when the sampler filters across the edges of the texture.*/
	BaseMaterial3DFlagUseTextureRepeat BaseMaterial3DFlags = 16
	/*Invert values read from a depth texture to convert them to height values (heightmap).*/
	BaseMaterial3DFlagInvertHeightmap BaseMaterial3DFlags = 17
	/*Enables the skin mode for subsurface scattering which is used to improve the look of subsurface scattering when used for human skin.*/
	BaseMaterial3DFlagSubsurfaceModeSkin BaseMaterial3DFlags = 18
	/*Enables parts of the shader required for [GPUParticles3D] trails to function. This also requires using a mesh with appropriate skinning, such as [RibbonTrailMesh] or [TubeTrailMesh]. Enabling this feature outside of materials used in [GPUParticles3D] meshes will break material rendering.*/
	BaseMaterial3DFlagParticleTrailsMode BaseMaterial3DFlags = 19
	/*Enables multichannel signed distance field rendering shader.*/
	BaseMaterial3DFlagAlbedoTextureMsdf BaseMaterial3DFlags = 20
	/*Disables receiving depth-based or volumetric fog.*/
	BaseMaterial3DFlagDisableFog BaseMaterial3DFlags = 21
	/*Represents the size of the [enum Flags] enum.*/
	BaseMaterial3DFlagMax BaseMaterial3DFlags = 22
)

type BaseMaterial3DShadingMode ¶

type BaseMaterial3DShadingMode = classdb.BaseMaterial3DShadingMode

const (
	/*The object will not receive shadows. This is the fastest to render, but it disables all interactions with lights.*/
	BaseMaterial3DShadingModeUnshaded BaseMaterial3DShadingMode = 0
	/*The object will be shaded per pixel. Useful for realistic shading effects.*/
	BaseMaterial3DShadingModePerPixel BaseMaterial3DShadingMode = 1
	/*The object will be shaded per vertex. Useful when you want cheaper shaders and do not care about visual quality. Not implemented yet (this mode will act like [constant SHADING_MODE_PER_PIXEL]).*/
	BaseMaterial3DShadingModePerVertex BaseMaterial3DShadingMode = 2
	/*Represents the size of the [enum ShadingMode] enum.*/
	BaseMaterial3DShadingModeMax BaseMaterial3DShadingMode = 3
)

type BaseMaterial3DSpecularMode ¶

type BaseMaterial3DSpecularMode = classdb.BaseMaterial3DSpecularMode

const (
	/*Default specular blob.*/
	BaseMaterial3DSpecularSchlickGgx BaseMaterial3DSpecularMode = 0
	/*Toon blob which changes size based on roughness.*/
	BaseMaterial3DSpecularToon BaseMaterial3DSpecularMode = 1
	/*No specular blob. This is slightly faster to render than other specular modes.*/
	BaseMaterial3DSpecularDisabled BaseMaterial3DSpecularMode = 2
)

type BaseMaterial3DTextureChannel ¶

type BaseMaterial3DTextureChannel = classdb.BaseMaterial3DTextureChannel

const (
	/*Used to read from the red channel of a texture.*/
	BaseMaterial3DTextureChannelRed BaseMaterial3DTextureChannel = 0
	/*Used to read from the green channel of a texture.*/
	BaseMaterial3DTextureChannelGreen BaseMaterial3DTextureChannel = 1
	/*Used to read from the blue channel of a texture.*/
	BaseMaterial3DTextureChannelBlue BaseMaterial3DTextureChannel = 2
	/*Used to read from the alpha channel of a texture.*/
	BaseMaterial3DTextureChannelAlpha BaseMaterial3DTextureChannel = 3
	/*Used to read from the linear (non-perceptual) average of the red, green and blue channels of a texture.*/
	BaseMaterial3DTextureChannelGrayscale BaseMaterial3DTextureChannel = 4
)

type BaseMaterial3DTextureFilter ¶

type BaseMaterial3DTextureFilter = classdb.BaseMaterial3DTextureFilter

const (
	/*The texture filter reads from the nearest pixel only. This makes the texture look pixelated from up close, and grainy from a distance (due to mipmaps not being sampled).*/
	BaseMaterial3DTextureFilterNearest BaseMaterial3DTextureFilter = 0
	/*The texture filter blends between the nearest 4 pixels. This makes the texture look smooth from up close, and grainy from a distance (due to mipmaps not being sampled).*/
	BaseMaterial3DTextureFilterLinear BaseMaterial3DTextureFilter = 1
	/*The texture filter reads from the nearest pixel and blends between the nearest 2 mipmaps (or uses the nearest mipmap if [member ProjectSettings.rendering/textures/default_filters/use_nearest_mipmap_filter] is [code]true[/code]). This makes the texture look pixelated from up close, and smooth from a distance.*/
	BaseMaterial3DTextureFilterNearestWithMipmaps BaseMaterial3DTextureFilter = 2
	/*The texture filter blends between the nearest 4 pixels and between the nearest 2 mipmaps (or uses the nearest mipmap if [member ProjectSettings.rendering/textures/default_filters/use_nearest_mipmap_filter] is [code]true[/code]). This makes the texture look smooth from up close, and smooth from a distance.*/
	BaseMaterial3DTextureFilterLinearWithMipmaps BaseMaterial3DTextureFilter = 3
	/*The texture filter reads from the nearest pixel and blends between 2 mipmaps (or uses the nearest mipmap if [member ProjectSettings.rendering/textures/default_filters/use_nearest_mipmap_filter] is [code]true[/code]) based on the angle between the surface and the camera view. This makes the texture look pixelated from up close, and smooth from a distance. Anisotropic filtering improves texture quality on surfaces that are almost in line with the camera, but is slightly slower. The anisotropic filtering level can be changed by adjusting [member ProjectSettings.rendering/textures/default_filters/anisotropic_filtering_level].*/
	BaseMaterial3DTextureFilterNearestWithMipmapsAnisotropic BaseMaterial3DTextureFilter = 4
	/*The texture filter blends between the nearest 4 pixels and blends between 2 mipmaps (or uses the nearest mipmap if [member ProjectSettings.rendering/textures/default_filters/use_nearest_mipmap_filter] is [code]true[/code]) based on the angle between the surface and the camera view. This makes the texture look smooth from up close, and smooth from a distance. Anisotropic filtering improves texture quality on surfaces that are almost in line with the camera, but is slightly slower. The anisotropic filtering level can be changed by adjusting [member ProjectSettings.rendering/textures/default_filters/anisotropic_filtering_level].*/
	BaseMaterial3DTextureFilterLinearWithMipmapsAnisotropic BaseMaterial3DTextureFilter = 5
	/*Represents the size of the [enum TextureFilter] enum.*/
	BaseMaterial3DTextureFilterMax BaseMaterial3DTextureFilter = 6
)

type BaseMaterial3DTextureParam ¶

type BaseMaterial3DTextureParam = classdb.BaseMaterial3DTextureParam

const (
	/*Texture specifying per-pixel color.*/
	BaseMaterial3DTextureAlbedo BaseMaterial3DTextureParam = 0
	/*Texture specifying per-pixel metallic value.*/
	BaseMaterial3DTextureMetallic BaseMaterial3DTextureParam = 1
	/*Texture specifying per-pixel roughness value.*/
	BaseMaterial3DTextureRoughness BaseMaterial3DTextureParam = 2
	/*Texture specifying per-pixel emission color.*/
	BaseMaterial3DTextureEmission BaseMaterial3DTextureParam = 3
	/*Texture specifying per-pixel normal vector.*/
	BaseMaterial3DTextureNormal BaseMaterial3DTextureParam = 4
	/*Texture specifying per-pixel rim value.*/
	BaseMaterial3DTextureRim BaseMaterial3DTextureParam = 5
	/*Texture specifying per-pixel clearcoat value.*/
	BaseMaterial3DTextureClearcoat BaseMaterial3DTextureParam = 6
	/*Texture specifying per-pixel flowmap direction for use with [member anisotropy].*/
	BaseMaterial3DTextureFlowmap BaseMaterial3DTextureParam = 7
	/*Texture specifying per-pixel ambient occlusion value.*/
	BaseMaterial3DTextureAmbientOcclusion BaseMaterial3DTextureParam = 8
	/*Texture specifying per-pixel height.*/
	BaseMaterial3DTextureHeightmap BaseMaterial3DTextureParam = 9
	/*Texture specifying per-pixel subsurface scattering.*/
	BaseMaterial3DTextureSubsurfaceScattering BaseMaterial3DTextureParam = 10
	/*Texture specifying per-pixel transmittance for subsurface scattering.*/
	BaseMaterial3DTextureSubsurfaceTransmittance BaseMaterial3DTextureParam = 11
	/*Texture specifying per-pixel backlight color.*/
	BaseMaterial3DTextureBacklight BaseMaterial3DTextureParam = 12
	/*Texture specifying per-pixel refraction strength.*/
	BaseMaterial3DTextureRefraction BaseMaterial3DTextureParam = 13
	/*Texture specifying per-pixel detail mask blending value.*/
	BaseMaterial3DTextureDetailMask BaseMaterial3DTextureParam = 14
	/*Texture specifying per-pixel detail color.*/
	BaseMaterial3DTextureDetailAlbedo BaseMaterial3DTextureParam = 15
	/*Texture specifying per-pixel detail normal.*/
	BaseMaterial3DTextureDetailNormal BaseMaterial3DTextureParam = 16
	/*Texture holding ambient occlusion, roughness, and metallic.*/
	BaseMaterial3DTextureOrm BaseMaterial3DTextureParam = 17
	/*Represents the size of the [enum TextureParam] enum.*/
	BaseMaterial3DTextureMax BaseMaterial3DTextureParam = 18
)

type BaseMaterial3DTransparency ¶

type BaseMaterial3DTransparency = classdb.BaseMaterial3DTransparency

const (
	/*The material will not use transparency. This is the fastest to render.*/
	BaseMaterial3DTransparencyDisabled BaseMaterial3DTransparency = 0
	/*The material will use the texture's alpha values for transparency. This is the slowest to render, and disables shadow casting.*/
	BaseMaterial3DTransparencyAlpha BaseMaterial3DTransparency = 1
	/*The material will cut off all values below a threshold, the rest will remain opaque. The opaque portions will be rendered in the depth prepass. This is faster to render than alpha blending, but slower than opaque rendering. This also supports casting shadows.*/
	BaseMaterial3DTransparencyAlphaScissor BaseMaterial3DTransparency = 2
	/*The material will cut off all values below a spatially-deterministic threshold, the rest will remain opaque. This is faster to render than alpha blending, but slower than opaque rendering. This also supports casting shadows. Alpha hashing is suited for hair rendering.*/
	BaseMaterial3DTransparencyAlphaHash BaseMaterial3DTransparency = 3
	/*The material will use the texture's alpha value for transparency, but will discard fragments with an alpha of less than 0.99 during the depth prepass and fragments with an alpha less than 0.1 during the shadow pass. This also supports casting shadows.*/
	BaseMaterial3DTransparencyAlphaDepthPrePass BaseMaterial3DTransparency = 4
	/*Represents the size of the [enum Transparency] enum.*/
	BaseMaterial3DTransparencyMax BaseMaterial3DTransparency = 5
)

type Basis ¶

type Basis = gd.Basis

func NewBasisRotatedAround(axis Vector3, angle Radians) Basis

func NewBasisScaledBy(scale Vector3) Basis

type BitMap ¶

type BitMap = classdb.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.

type Bone2D ¶

type Bone2D = classdb.Bone2D

A hierarchy of [Bone2D]s can be bound to a Skeleton2D to control and animate other Node2D nodes. You can use Bone2D and Skeleton2D nodes to animate 2D meshes created with the Polygon2D UV editor. Each bone has a [member rest] transform that you can reset to with [method apply_rest]. These rest poses are relative to the bone's parent. If in the editor, you can set the rest pose of an entire skeleton using a menu option, from the code, you need to iterate over the bones to set their individual rest poses.

type BoneAttachment3D ¶

type BoneAttachment3D = classdb.BoneAttachment3D

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

type BoneMap ¶

type BoneMap = classdb.BoneMap

This class contains a dictionary that uses a list of bone names in SkeletonProfile as key names. By assigning the actual Skeleton3D bone name as the key value, it maps the Skeleton3D to the SkeletonProfile.

type Bool ¶

type Bool = gd.Bool

type BoxContainer ¶

type BoxContainer = classdb.BoxContainer

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

type BoxContainerAlignmentMode ¶

type BoxContainerAlignmentMode = classdb.BoxContainerAlignmentMode

const (
	/*The child controls will be arranged at the beginning of the container, i.e. top if orientation is vertical, left if orientation is horizontal (right for RTL layout).*/
	BoxContainerAlignmentBegin BoxContainerAlignmentMode = 0
	/*The child controls will be centered in the container.*/
	BoxContainerAlignmentCenter BoxContainerAlignmentMode = 1
	/*The child controls will be arranged at the end of the container, i.e. bottom if orientation is vertical, right if orientation is horizontal (left for RTL layout).*/
	BoxContainerAlignmentEnd BoxContainerAlignmentMode = 2
)

type BoxMesh ¶

type BoxMesh = classdb.BoxMesh

Generate an axis-aligned box PrimitiveMesh. The box's UV layout is arranged in a 3×2 layout that allows texturing each face individually. To apply the same texture on all faces, change the material's UV property to [code]Vector3(3, 2, 1)[/code]. This is equivalent to adding [code]UV *= vec2(3.0, 2.0)[/code] in a vertex shader. [b]Note:[/b] When using a large textured BoxMesh (e.g. as a floor), you may stumble upon UV jittering issues depending on the camera angle. To solve this, increase [member subdivide_depth], [member subdivide_height] and [member subdivide_width] until you no longer notice UV jittering.

type BoxOccluder3D ¶

type BoxOccluder3D = classdb.BoxOccluder3D

BoxOccluder3D stores a cuboid shape that can be used by the engine's occlusion culling system. See OccluderInstance3D's documentation for instructions on setting up occlusion culling.

type BoxShape3D ¶

type BoxShape3D = classdb.BoxShape3D

A 3D box shape, intended for use in physics. Usually used to provide a shape for a CollisionShape3D. [b]Performance:[/b] BoxShape3D is fast to check collisions against. It is faster than CapsuleShape3D and CylinderShape3D, but slower than SphereShape3D.

type Button ¶

type Button = classdb.Button

Button is the standard themed button. It can contain text and an icon, and it will display them according to the current Theme. [b]Example of creating a button and assigning an action when pressed by code:[/b] [codeblocks] [gdscript] func _ready():

var button = Button.new()
button.text = "Click me"
button.pressed.connect(self._button_pressed)
add_child(button)

func _button_pressed():

print("Hello world!")

[/gdscript] [csharp] public override void _Ready()

{
    var button = new Button();
    button.Text = "Click me";
    button.Pressed += ButtonPressed;
    AddChild(button);
}

private void ButtonPressed()

{
    GD.Print("Hello world!");
}

[/csharp] [/codeblocks] See also BaseButton which contains common properties and methods associated with this node. [b]Note:[/b] Buttons do not interpret touch input and therefore don't support multitouch, since mouse emulation can only press one button at a given time. Use TouchScreenButton for buttons that trigger gameplay movement or actions.

type ButtonGroup ¶

type ButtonGroup = classdb.ButtonGroup

A group of BaseButton-derived buttons. The buttons in a ButtonGroup are treated like radio buttons: No more than one button can be pressed at a time. Some types of buttons (such as CheckBox) may have a special appearance in this state. Every member of a ButtonGroup should have [member BaseButton.toggle_mode] set to [code]true[/code].

type CPUParticles2D ¶

type CPUParticles2D = classdb.CPUParticles2D

CPU-based 2D particle node used to create a variety of particle systems and effects. See also GPUParticles2D, which provides the same functionality with hardware acceleration, but may not run on older devices.

type CPUParticles2DDrawOrder ¶

type CPUParticles2DDrawOrder = classdb.CPUParticles2DDrawOrder

const (
	/*Particles are drawn in the order emitted.*/
	CPUParticles2DDrawOrderIndex CPUParticles2DDrawOrder = 0
	/*Particles are drawn in order of remaining lifetime. In other words, the particle with the highest lifetime is drawn at the front.*/
	CPUParticles2DDrawOrderLifetime CPUParticles2DDrawOrder = 1
)

type CPUParticles2DEmissionShape ¶

type CPUParticles2DEmissionShape = classdb.CPUParticles2DEmissionShape

const (
	/*All particles will be emitted from a single point.*/
	CPUParticles2DEmissionShapePoint CPUParticles2DEmissionShape = 0
	/*Particles will be emitted in the volume of a sphere flattened to two dimensions.*/
	CPUParticles2DEmissionShapeSphere CPUParticles2DEmissionShape = 1
	/*Particles will be emitted on the surface of a sphere flattened to two dimensions.*/
	CPUParticles2DEmissionShapeSphereSurface CPUParticles2DEmissionShape = 2
	/*Particles will be emitted in the area of a rectangle.*/
	CPUParticles2DEmissionShapeRectangle CPUParticles2DEmissionShape = 3
	/*Particles will be emitted at a position chosen randomly among [member emission_points]. Particle color will be modulated by [member emission_colors].*/
	CPUParticles2DEmissionShapePoints CPUParticles2DEmissionShape = 4
	/*Particles will be emitted at a position chosen randomly among [member emission_points]. Particle velocity and rotation will be set based on [member emission_normals]. Particle color will be modulated by [member emission_colors].*/
	CPUParticles2DEmissionShapeDirectedPoints CPUParticles2DEmissionShape = 5
	/*Represents the size of the [enum EmissionShape] enum.*/
	CPUParticles2DEmissionShapeMax CPUParticles2DEmissionShape = 6
)

type CPUParticles2DParameter ¶

type CPUParticles2DParameter = classdb.CPUParticles2DParameter

const (
	/*Use with [method set_param_min], [method set_param_max], and [method set_param_curve] to set initial velocity properties.*/
	CPUParticles2DParamInitialLinearVelocity CPUParticles2DParameter = 0
	/*Use with [method set_param_min], [method set_param_max], and [method set_param_curve] to set angular velocity properties.*/
	CPUParticles2DParamAngularVelocity CPUParticles2DParameter = 1
	/*Use with [method set_param_min], [method set_param_max], and [method set_param_curve] to set orbital velocity properties.*/
	CPUParticles2DParamOrbitVelocity CPUParticles2DParameter = 2
	/*Use with [method set_param_min], [method set_param_max], and [method set_param_curve] to set linear acceleration properties.*/
	CPUParticles2DParamLinearAccel CPUParticles2DParameter = 3
	/*Use with [method set_param_min], [method set_param_max], and [method set_param_curve] to set radial acceleration properties.*/
	CPUParticles2DParamRadialAccel CPUParticles2DParameter = 4
	/*Use with [method set_param_min], [method set_param_max], and [method set_param_curve] to set tangential acceleration properties.*/
	CPUParticles2DParamTangentialAccel CPUParticles2DParameter = 5
	/*Use with [method set_param_min], [method set_param_max], and [method set_param_curve] to set damping properties.*/
	CPUParticles2DParamDamping CPUParticles2DParameter = 6
	/*Use with [method set_param_min], [method set_param_max], and [method set_param_curve] to set angle properties.*/
	CPUParticles2DParamAngle CPUParticles2DParameter = 7
	/*Use with [method set_param_min], [method set_param_max], and [method set_param_curve] to set scale properties.*/
	CPUParticles2DParamScale CPUParticles2DParameter = 8
	/*Use with [method set_param_min], [method set_param_max], and [method set_param_curve] to set hue variation properties.*/
	CPUParticles2DParamHueVariation CPUParticles2DParameter = 9
	/*Use with [method set_param_min], [method set_param_max], and [method set_param_curve] to set animation speed properties.*/
	CPUParticles2DParamAnimSpeed CPUParticles2DParameter = 10
	/*Use with [method set_param_min], [method set_param_max], and [method set_param_curve] to set animation offset properties.*/
	CPUParticles2DParamAnimOffset CPUParticles2DParameter = 11
	/*Represents the size of the [enum Parameter] enum.*/
	CPUParticles2DParamMax CPUParticles2DParameter = 12
)