Class reference

@GlobalScope

Global scope constants and functions.

Description

A list of global scope enumerated constants and built-in functions. This is all that resides in the globals, constants regarding error codes, keycodes, property hints, etc. Singletons are also documented here, since they can be accessed from anywhere. For the entries that can only be accessed from scripts written in GDScript, see @GDScript.

Properties

IP IP

The IP singleton.

OS OS

The OS singleton.

Methods

Variant abs(Variant x)

Returns the absolute value of a Variant parameter x (i.e. non-negative value). Supported types: int, float, Vector2, Vector2i, Vector3, Vector3i, Vector4, Vector4i.

				var a = abs(-1)
				# a is 1

				var b = abs(-1.2)
				# b is 1.2

				var c = abs(Vector2(-3.5, -4))
				# c is (3.5, 4)

				var d = abs(Vector2i(-5, -6))
				# d is (5, 6)

				var e = abs(Vector3(-7, 8.5, -3.8))
				# e is (7, 8.5, 3.8)

				var f = abs(Vector3i(-7, -8, -9))
				# f is (7, 8, 9)

Note: For better type safety, use absf(), absi(), Vector2.abs(), Vector2i.abs(), Vector3.abs(), Vector3i.abs(), Vector4.abs(), or Vector4i.abs().

float absf(float x)

Returns the absolute value of float parameter x (i.e. positive value).

				# a is 1.2
				var a = absf(-1.2)

int absi(int x)

Returns the absolute value of int parameter x (i.e. positive value).

				# a is 1
				var a = absi(-1)

float acos(float x)

Returns the arc cosine of x in radians. Use to get the angle of cosine x. x will be clamped between -1.0 and 1.0 (inclusive), in order to prevent acos() from returning @GDScript.NAN.

				# c is 0.523599 or 30 degrees if converted with rad_to_deg(c)
				var c = acos(0.866025)

float acosh(float x)

Returns the hyperbolic arc (also called inverse) cosine of x, returning a value in radians. Use it to get the angle from an angle's cosine in hyperbolic space if x is larger or equal to 1. For values of x lower than 1, it will return 0, in order to prevent acosh() from returning @GDScript.NAN.

				var a = acosh(2) # Returns 1.31695789692482
				cosh(a) # Returns 2

				var b = acosh(-1) # Returns 0

float angle_difference(float from, float to)

Returns the difference between the two angles (in radians), in the range of [-PI, +PI]. When from and to are opposite, returns -PI if from is smaller than to, or PI otherwise.

float asin(float x)

Returns the arc sine of x in radians. Use to get the angle of sine x. x will be clamped between -1.0 and 1.0 (inclusive), in order to prevent asin() from returning @GDScript.NAN.

				# s is 0.523599 or 30 degrees if converted with rad_to_deg(s)
				var s = asin(0.5)

float asinh(float x)

Returns the hyperbolic arc (also called inverse) sine of x, returning a value in radians. Use it to get the angle from an angle's sine in hyperbolic space.

				var a = asinh(0.9) # Returns 0.8088669356527824
				sinh(a) # Returns 0.9

float atan(float x)

Returns the arc tangent of x in radians. Use it to get the angle from an angle's tangent in trigonometry. The method cannot know in which quadrant the angle should fall. See atan2() if you have both y and [code skip-lint]x[/code].

				var a = atan(0.5) # a is 0.463648

If x is between -PI / 2 and PI / 2 (inclusive), atan(tan(x)) is equal to x.

float atan2(float y, float x)

Returns the arc tangent of y/x in radians. Use to get the angle of tangent y/x. To compute the value, the method takes into account the sign of both arguments in order to determine the quadrant. Important note: The Y coordinate comes first, by convention.

				var a = atan2(0, -1) # a is 3.141593

float atanh(float x)

Returns the hyperbolic arc (also called inverse) tangent of x, returning a value in radians. Use it to get the angle from an angle's tangent in hyperbolic space if x is between -1 and 1 (non-inclusive). In mathematics, the inverse hyperbolic tangent is only defined for -1 < x < 1 in the real set, so values equal or lower to -1 for x return negative @GDScript.INF and values equal or higher than 1 return positive @GDScript.INF in order to prevent atanh() from returning @GDScript.NAN.

				var a = atanh(0.9) # Returns 1.47221948958322
				tanh(a) # Returns 0.9

				var b = atanh(-2) # Returns -inf
				tanh(b) # Returns -1

float bezier_derivative(float start, float control_1, float control_2, float end, float t)

Returns the derivative at the given t on a one-dimensional Bézier curve defined by the given control_1, control_2, and end points.

float bezier_interpolate(float start, float control_1, float control_2, float end, float t)

Returns the point at the given t on a one-dimensional Bézier curve defined by the given control_1, control_2, and end points.

Variant bytes_to_var_with_objects(PackedByteArray bytes)

Decodes a byte array back to a Variant value. Decoding objects is allowed. Warning: Deserialized object can contain code which gets executed. Do not use this option if the serialized object comes from untrusted sources to avoid potential security threats (remote code execution).

float ceilf(float x)

Rounds x upward (towards positive infinity), returning the smallest whole number that is not less than x. A type-safe version of ceil(), returning a float.

int ceili(float x)

Rounds x upward (towards positive infinity), returning the smallest whole number that is not less than x. A type-safe version of ceil(), returning an int.

Variant clamp(Variant value, Variant min, Variant max)

Clamps the value, returning a Variant not less than min and not more than max. Any values that can be compared with the less than and greater than operators will work.

				var a = clamp(-10, -1, 5)
				# a is -1

				var b = clamp(8.1, 0.9, 5.5)
				# b is 5.5

Note: For better type safety, use clampf(), clampi(), Vector2.clamp(), Vector2i.clamp(), Vector3.clamp(), Vector3i.clamp(), Vector4.clamp(), Vector4i.clamp(), or Color.clamp() (not currently supported by this method). Note: When using this on vectors it will not perform component-wise clamping, and will pick min if value < min or max if value > max. To perform component-wise clamping use the methods listed above.

float clampf(float value, float min, float max)

Clamps the value, returning a float not less than min and not more than max.

				var speed = 42.1
				var a = clampf(speed, 1.0, 20.5) # a is 20.5

				speed = -10.0
				var b = clampf(speed, -1.0, 1.0) # b is -1.0

int clampi(int value, int min, int max)

Clamps the value, returning an int not less than min and not more than max.

				var speed = 42
				var a = clampi(speed, 1, 20) # a is 20

				speed = -10
				var b = clampi(speed, -1, 1) # b is -1

float cos(float angle_rad)

Returns the cosine of angle angle_rad in radians.

				cos(PI * 2)         # Returns 1.0
				cos(PI)             # Returns -1.0
				cos(deg_to_rad(90)) # Returns 0.0

float cosh(float x)

Returns the hyperbolic cosine of x in radians.

				print(cosh(1)) # Prints 1.543081

float cubic_interpolate(float from, float to, float pre, float post, float weight)

Cubic interpolates between two values by the factor defined in weight with pre and post values.

float cubic_interpolate_angle(float from, float to, float pre, float post, float weight)

Cubic interpolates between two rotation values with shortest path by the factor defined in weight with pre and post values. See also lerp_angle().

float db_to_linear(float db)

Converts from decibels to linear energy (audio).

float deg_to_rad(float deg)

Converts an angle expressed in degrees to radians.

				var r = deg_to_rad(180) # r is 3.141593

float ease(float x, float curve)

Returns an "eased" value of x based on an easing function defined with curve. This easing function is based on an exponent. The curve can be any floating-point number, with specific values leading to the following behaviors:

				- Lower than -1.0 (exclusive): Ease in-out
				- -1.0: Linear
				- Between -1.0 and 0.0 (exclusive): Ease out-in
				- 0.0: Constant
				- Between 0.0 to 1.0 (exclusive): Ease out
				- 1.0: Linear
				- Greater than 1.0 (exclusive): Ease in

ease() curve values cheatsheet See also smoothstep(). If you need to perform more advanced transitions, use Tween.interpolate_value().

String error_string(int error)

Returns a human-readable name for the given Error code.

				print(OK)                              # Prints 0
				print(error_string(OK))                # Prints "OK"
				print(error_string(ERR_BUSY))          # Prints "Busy"
				print(error_string(ERR_OUT_OF_MEMORY)) # Prints "Out of memory"

float exp(float x)

The natural exponential function. It raises the mathematical constant e to the power of x and returns it. e has an approximate value of 2.71828, and can be obtained with exp(1). For exponents to other bases use the method pow().

				var a = exp(2) # Approximately 7.39

float floorf(float x)

Rounds x downward (towards negative infinity), returning the largest whole number that is not more than x. A type-safe version of floor(), returning a float.

int floori(float x)

Rounds x downward (towards negative infinity), returning the largest whole number that is not more than x. A type-safe version of floor(), returning an int. Note: This function is not the same as int(x), which rounds towards 0.

float fmod(float x, float y)

Returns the floating-point remainder of x divided by y, keeping the sign of x.

				var remainder = fmod(7, 5.5) # remainder is 1.5

For the integer remainder operation, use the % operator.

float fposmod(float x, float y)

Returns the floating-point modulus of x divided by y, wrapping equally in positive and negative.

				print(" (x)  (fmod(x, 1.5))   (fposmod(x, 1.5))")
				for i in 7:
					var x = i * 0.5 - 1.5
					print("%4.1f           %4.1f  | %4.1f" % [x, fmod(x, 1.5), fposmod(x, 1.5)])

Prints:

				 (x)  (fmod(x, 1.5))   (fposmod(x, 1.5))
				-1.5           -0.0  |  0.0
				-1.0           -1.0  |  0.5
				-0.5           -0.5  |  1.0
				 0.0            0.0  |  0.0
				 0.5            0.5  |  0.5
				 1.0            1.0  |  1.0
				 1.5            0.0  |  0.0

int hash(Variant variable)

Returns the integer hash of the passed variable.

				print(hash("a")) # Prints 177670
				
				GD.Print(GD.Hash("a")); // Prints 177670

Object instance_from_id(int instance_id)

Returns the Object that corresponds to instance_id. All Objects have a unique instance ID. See also Object.get_instance_id().

				var drink = "water"

				func _ready():
					var id = get_instance_id()
					var instance = instance_from_id(id)
					print(instance.drink) # Prints "water"
				
				public partial class MyNode : Node
				{
					public string Drink { get; set; } = "water";

					public override void _Ready()
					{
						ulong id = GetInstanceId();
						var instance = (MyNode)InstanceFromId(Id);
						GD.Print(instance.Drink); // Prints "water"
					}
				}

float inverse_lerp(float from, float to, float weight)

Returns an interpolation or extrapolation factor considering the range specified in from and to, and the interpolated value specified in weight. The returned value will be between 0.0 and 1.0 if weight is between from and to (inclusive). If weight is located outside this range, then an extrapolation factor will be returned (return value lower than 0.0 or greater than 1.0). Use clamp() on the result of inverse_lerp() if this is not desired.

				# The interpolation ratio in the `lerp()` call below is 0.75.
				var middle = lerp(20, 30, 0.75)
				# middle is now 27.5.

				# Now, we pretend to have forgotten the original ratio and want to get it back.
				var ratio = inverse_lerp(20, 30, 27.5)
				# ratio is now 0.75.

See also lerp(), which performs the reverse of this operation, and remap() to map a continuous series of values to another.

bool is_equal_approx(float a, float b)

Returns true if a and b are approximately equal to each other. Here, "approximately equal" means that a and b are within a small internal epsilon of each other, which scales with the magnitude of the numbers. Infinity values of the same sign are considered equal.

bool is_instance_id_valid(int id)

Returns true if the Object that corresponds to id is a valid object (e.g. has not been deleted from memory). All Objects have a unique instance ID.

bool is_instance_valid(Variant instance)

Returns true if instance is a valid Object (e.g. has not been deleted from memory).

bool is_nan(float x)

Returns true if x is a NaN ("Not a Number" or invalid) value. This method is needed as @GDScript.NAN is not equal to itself, which means x == NAN can't be used to check whether a value is a NaN.

bool is_same(Variant a, Variant b)

Returns true, for value types, if a and b share the same value. Returns true, for reference types, if the references of a and b are the same.

				# Vector2 is a value type
				var vec2_a = Vector2(0, 0)
				var vec2_b = Vector2(0, 0)
				var vec2_c = Vector2(1, 1)
				is_same(vec2_a, vec2_a)  # true
				is_same(vec2_a, vec2_b)  # true
				is_same(vec2_a, vec2_c)  # false

				# Array is a reference type
				var arr_a = []
				var arr_b = []
				is_same(arr_a, arr_a)  # true
				is_same(arr_a, arr_b)  # false

These are Variant value types: null, bool, int, float, String, StringName, Vector2, Vector2i, Vector3, Vector3i, Vector4, Vector4i, Rect2, Rect2i, Transform2D, Transform3D, Plane, Quaternion, AABB, Basis, Projection, Color, NodePath, RID, Callable and Signal. These are Variant reference types: Object, Dictionary, Array, PackedByteArray, PackedInt32Array, PackedInt64Array, PackedFloat32Array, PackedFloat64Array, PackedStringArray, PackedVector2Array, PackedVector3Array, PackedVector4Array, and PackedColorArray.

bool is_zero_approx(float x)

Returns true if x is zero or almost zero. The comparison is done using a tolerance calculation with a small internal epsilon. This function is faster than using is_equal_approx() with one value as zero.

Variant lerp(Variant from, Variant to, float weight)

Linearly interpolates between two values by the factor defined in weight. To perform interpolation, weight should be between 0.0 and 1.0 (inclusive). However, values outside this range are allowed and can be used to perform extrapolation. If this is not desired, use clampf() to limit weight. Both from and to must be the same type. Supported types: int, float, Vector2, Vector3, Vector4, Color, Quaternion, Basis, Transform2D, Transform3D.

				lerp(0, 4, 0.75) # Returns 3.0

See also inverse_lerp() which performs the reverse of this operation. To perform eased interpolation with lerp(), combine it with ease() or smoothstep(). See also remap() to map a continuous series of values to another. Note: For better type safety, use lerpf(), Vector2.lerp(), Vector3.lerp(), Vector4.lerp(), Color.lerp(), Quaternion.slerp(), Basis.slerp(), Transform2D.interpolate_with(), or Transform3D.interpolate_with().

float lerp_angle(float from, float to, float weight)

Linearly interpolates between two angles (in radians) by a weight value between 0.0 and 1.0. Similar to lerp(), but interpolates correctly when the angles wrap around @GDScript.TAU. To perform eased interpolation with lerp_angle(), combine it with ease() or smoothstep().

				extends Sprite
				var elapsed = 0.0
				func _process(delta):
					var min_angle = deg_to_rad(0.0)
					var max_angle = deg_to_rad(90.0)
					rotation = lerp_angle(min_angle, max_angle, elapsed)
					elapsed += delta

Note: This function lerps through the shortest path between from and to. However, when these two angles are approximately PI + k * TAU apart for any integer k, it's not obvious which way they lerp due to floating-point precision errors. For example, lerp_angle(0, PI, weight) lerps counter-clockwise, while lerp_angle(0, PI + 5 * TAU, weight) lerps clockwise.

float lerpf(float from, float to, float weight)

Linearly interpolates between two values by the factor defined in weight. To perform interpolation, weight should be between 0.0 and 1.0 (inclusive). However, values outside this range are allowed and can be used to perform extrapolation. If this is not desired, use clampf() on the result of this function.

				lerpf(0, 4, 0.75) # Returns 3.0

See also inverse_lerp() which performs the reverse of this operation. To perform eased interpolation with lerp(), combine it with ease() or smoothstep().

float linear_to_db(float lin)

Converts from linear energy to decibels (audio). Since volume is not normally linear, this can be used to implement volume sliders that behave as expected. Example: Change the Master bus's volume through a Slider node, which ranges from 0.0 to 1.0:

				AudioServer.set_bus_volume_db(AudioServer.get_bus_index("Master"), linear_to_db($Slider.value))

float log(float x)

Returns the natural logarithm of x (base e, with e being approximately 2.71828). This is the amount of time needed to reach a certain level of continuous growth. Note: This is not the same as the "log" function on most calculators, which uses a base 10 logarithm. To use base 10 logarithm, use log(x) / log(10).

				log(10) # Returns 2.302585

Note: The logarithm of 0 returns -inf, while negative values return -nan.

float maxf(float a, float b)

Returns the maximum of two float values.

				maxf(3.6, 24)   # Returns 24.0
				maxf(-3.99, -4) # Returns -3.99

int maxi(int a, int b)

Returns the maximum of two int values.

				maxi(1, 2)   # Returns 2
				maxi(-3, -4) # Returns -3

float minf(float a, float b)

Returns the minimum of two float values.

				minf(3.6, 24)   # Returns 3.6
				minf(-3.99, -4) # Returns -4.0

int mini(int a, int b)

Returns the minimum of two int values.

				mini(1, 2)   # Returns 1
				mini(-3, -4) # Returns -4

float monotonic_cubic_interpolate(float from, float to, float pre, float post, float weight)

Performs monotonic cubic interpolation between from and to using neighboring values pre and post. The interpolation factor weight is typically between 0.0 and 1.0.

Unlike cubic_interpolate(), this method preserves monotonicity by automatically limiting tangents to prevent overshoot between key values. This makes it suitable for animation tracks and other data where values should not exceed surrounding keyframes.

float monotonic_cubic_interpolate_angle(float from, float to, float pre, float post, float weight)

Performs monotonic cubic interpolation between angular values, rotating along the shortest path between from and to.

The neighboring angles pre and post are used to compute shape-preserving tangents while accounting for angle wrapping. This prevents overshoot while maintaining continuous rotation. See also lerp_angle().

float monotonic_cubic_interpolate_angle_in_time(float from, float to, float pre, float post, float weight, float to_t, float pre_t, float post_t)

Time-aware version of monotonic_cubic_interpolate_angle().

The interpolation factor is derived from the provided keyframe times, allowing unevenly spaced keyframes to influence tangent calculation. This produces consistent motion when animation keys are not uniformly distributed in time while still preventing overshoot.

float monotonic_cubic_interpolate_in_time(float from, float to, float pre, float post, float weight, float to_t, float pre_t, float post_t)

Time-aware version of monotonic_cubic_interpolate().

The interpolation parameter is normalized using the supplied keyframe times, allowing interpolation to account for non-uniform spacing between values. Tangents are computed in a way that preserves monotonicity and prevents overshoot between keyframes.

float move_toward(float from, float to, float delta)

Moves from toward to by the delta amount. Will not go past to. Use a negative delta value to move away.

				move_toward(5, 10, 4)    # Returns 9
				move_toward(10, 5, 4)    # Returns 6
				move_toward(5, 10, 9)    # Returns 10
				move_toward(10, 5, -1.5) # Returns 11.5

int nearest_po2(int value)

Returns the smallest integer power of 2 that is greater than or equal to value.

				nearest_po2(3) # Returns 4
				nearest_po2(4) # Returns 4
				nearest_po2(5) # Returns 8

				nearest_po2(0)  # Returns 0 (this may not be expected)
				nearest_po2(-1) # Returns 0 (this may not be expected)

Warning: Due to its implementation, this method returns 0 rather than 1 for values less than or equal to 0, with an exception for value being the smallest negative 64-bit integer (-9223372036854775808) in which case the value is returned unchanged.

float pingpong(float value, float length)

Wraps value between 0 and the length. If the limit is reached, the next value the function returns is decreased to the 0 side or increased to the length side (like a triangle wave). If length is less than zero, it becomes positive.

				pingpong(-3.0, 3.0) # Returns 3.0
				pingpong(-2.0, 3.0) # Returns 2.0
				pingpong(-1.0, 3.0) # Returns 1.0
				pingpong(0.0, 3.0)  # Returns 0.0
				pingpong(1.0, 3.0)  # Returns 1.0
				pingpong(2.0, 3.0)  # Returns 2.0
				pingpong(3.0, 3.0)  # Returns 3.0
				pingpong(4.0, 3.0)  # Returns 2.0
				pingpong(5.0, 3.0)  # Returns 1.0
				pingpong(6.0, 3.0)  # Returns 0.0

int posmod(int x, int y)

Returns the integer modulus of x divided by y that wraps equally in positive and negative.

				print("#(i)  (i % 3)   (posmod(i, 3))")
				for i in range(-3, 4):
					print("%2d       %2d  | %2d" % [i, i % 3, posmod(i, 3)])

Prints:

				(i)  (i % 3)   (posmod(i, 3))
				-3        0  |  0
				-2       -2  |  1
				-1       -1  |  2
				 0        0  |  0
				 1        1  |  1
				 2        2  |  2
				 3        0  |  0

float pow(float base, float exp)

Returns the result of base raised to the power of exp. In GDScript, this is the equivalent of the ** operator.

				pow(2, 5)   # Returns 32.0
				pow(4, 1.5) # Returns 8.0

void print() vararg

Converts one or more arguments of any type to string in the best way possible and prints them to the console.

				var a = [1, 2, 3]
				print("a", "b", a) # Prints "ab[1, 2, 3]"
				
				Godot.Collections.Array a = [1, 2, 3];
				GD.Print("a", "b", a); // Prints "ab[1, 2, 3]"

Note: Consider using push_error() and push_warning() to print error and warning messages instead of print() or print_rich(). This distinguishes them from print messages used for debugging purposes, while also displaying a stack trace when an error or warning is printed. See also Engine.print_to_stdout and ProjectSettings.application/run/disable_stdout.

void print_rich() vararg

Converts one or more arguments of any type to string in the best way possible and prints them to the console. The following BBCode tags are supported: b, i, u, s, indent, code, url, center, right, color, bgcolor, fgcolor. URL tags only support URLs wrapped by a URL tag, not URLs with a different title. When printing to standard output, the supported subset of BBCode is converted to ANSI escape codes for the terminal emulator to display. Support for ANSI escape codes varies across terminal emulators, especially for italic and strikethrough. In standard output, code is represented with faint text but without any font change. Unsupported tags are left as-is in standard output.

				[gdscript skip-lint]
				print_rich("[color=green][b]Hello world![/b][/color]") # Prints "Hello world!", in green with a bold font.
				[/gdscript]
				[csharp skip-lint]
				GD.PrintRich("[color=green][b]Hello world![/b][/color]"); // Prints "Hello world!", in green with a bold font.
				[/csharp]

Note: Consider using push_error() and push_warning() to print error and warning messages instead of print() or print_rich(). This distinguishes them from print messages used for debugging purposes, while also displaying a stack trace when an error or warning is printed. Note: Output displayed in the editor supports clickable [code skip-lint]text[/code] tags. The [code skip-lint][url][/code] tag's address value is handled by OS.shell_open() when clicked.

void print_verbose() vararg

If verbose mode is enabled (OS.is_stdout_verbose() returning true), converts one or more arguments of any type to string in the best way possible and prints them to the console.

void printerr() vararg

Prints one or more arguments to strings in the best way possible to standard error line.

				printerr("prints to stderr")
				
				GD.PrintErr("prints to stderr");

void printraw() vararg

Prints one or more arguments to strings in the best way possible to the OS terminal. Unlike print(), no newline is automatically added at the end. Note: The OS terminal is not the same as the editor's Output dock. The output sent to the OS terminal can be seen when running Redot from a terminal. On Windows, this requires using the console.exe executable.

				# Prints "ABC" to terminal.
				printraw("A")
				printraw("B")
				printraw("C")
				
				// Prints "ABC" to terminal.
				GD.PrintRaw("A");
				GD.PrintRaw("B");
				GD.PrintRaw("C");

void prints() vararg

Prints one or more arguments to the console with a space between each argument.

				prints("A", "B", "C") # Prints "A B C"
				
				GD.PrintS("A", "B", "C"); // Prints "A B C"

void printt() vararg

Prints one or more arguments to the console with a tab between each argument.

				printt("A", "B", "C") # Prints "A       B       C"
				
				GD.PrintT("A", "B", "C"); // Prints "A       B       C"

void push_error() vararg

Pushes an error message to Redot's built-in debugger and to the OS terminal.

				push_error("test error") # Prints "test error" to debugger and terminal as an error.
				
				GD.PushError("test error"); // Prints "test error" to debugger and terminal as an error.

Note: This function does not pause project execution. To print an error message and pause project execution in debug builds, use assert(false, "test error") instead.

void push_warning() vararg

Pushes a warning message to Redot's built-in debugger and to the OS terminal.

				push_warning("test warning") # Prints "test warning" to debugger and terminal as a warning.
				
				GD.PushWarning("test warning"); // Prints "test warning" to debugger and terminal as a warning.

float rad_to_deg(float rad)

Converts an angle expressed in radians to degrees.

				rad_to_deg(0.523599) # Returns 30
				rad_to_deg(PI)       # Returns 180
				rad_to_deg(PI * 2)   # Returns 360

PackedInt64Array rand_from_seed(int seed)

Given a seed, returns a PackedInt64Array of size 2, where its first element is the randomized int value, and the second element is the same as seed. Passing the same seed consistently returns the same array. Note: "Seed" here refers to the internal state of the pseudo random number generator, currently implemented as a 64 bit integer.

				var a = rand_from_seed(4)

				print(a[0]) # Prints 2879024997
				print(a[1]) # Prints 4

float randf()

Returns a random floating-point value between 0.0 and 1.0 (inclusive).

				randf() # Returns e.g. 0.375671
				
				GD.Randf(); // Returns e.g. 0.375671

float randf_range(float from, float to)

Returns a random floating-point value between from and to (inclusive).

				randf_range(0, 20.5) # Returns e.g. 7.45315
				randf_range(-10, 10) # Returns e.g. -3.844535
				
				GD.RandRange(0.0, 20.5);   // Returns e.g. 7.45315
				GD.RandRange(-10.0, 10.0); // Returns e.g. -3.844535

int randi()

Returns a random unsigned 32-bit integer. Use remainder to obtain a random value in the interval [0, N - 1] (where N is smaller than 2^32).

				randi()           # Returns random integer between 0 and 2^32 - 1
				randi() % 20      # Returns random integer between 0 and 19
				randi() % 100     # Returns random integer between 0 and 99
				randi() % 100 + 1 # Returns random integer between 1 and 100
				
				GD.Randi();           // Returns random integer between 0 and 2^32 - 1
				GD.Randi() % 20;      // Returns random integer between 0 and 19
				GD.Randi() % 100;     // Returns random integer between 0 and 99
				GD.Randi() % 100 + 1; // Returns random integer between 1 and 100

int randi_range(int from, int to)

Returns a random signed 32-bit integer between from and to (inclusive). If to is lesser than from, they are swapped.

				randi_range(0, 1)      # Returns either 0 or 1
				randi_range(-10, 1000) # Returns random integer between -10 and 1000
				
				GD.RandRange(0, 1);      // Returns either 0 or 1
				GD.RandRange(-10, 1000); // Returns random integer between -10 and 1000

void randomize()

Randomizes the seed (or the internal state) of the random number generator. The current implementation uses a number based on the device's time. Note: This function is called automatically when the project is run. If you need to fix the seed to have consistent, reproducible results, use seed() to initialize the random number generator.

float remap(float value, float istart, float istop, float ostart, float ostop)

Maps a value from range [istart, istop] to [ostart, ostop]. See also lerp() and inverse_lerp(). If value is outside [istart, istop], then the resulting value will also be outside [ostart, ostop]. If this is not desired, use clamp() on the result of this function.

				remap(75, 0, 100, -1, 1) # Returns 0.5

For complex use cases where multiple ranges are needed, consider using Curve or Gradient instead. Note: If istart == istop, the return value is undefined (most likely NaN, INF, or -INF). See also remap_default().

float remap_default(float value, float istart, float istop, float ostart, float ostop, float default_value)

Maps a value from range [istart, istop] to [ostart, ostop] and returns default_value if remap() would've returned INF or NAN. See also remap(), lerp() and inverse_lerp(). If value is outside [istart, istop], then the resulting value will also be outside [ostart, ostop]. If this is not desired, use clamp() on the result of this function.

				remap_default(75, 0, 100, -1, 1, 3) # Returns 0.5
				remap_default(75, 0, 0, -1, 1, 3) # Returns 3.0

For complex use cases where multiple ranges are needed, consider using Curve or Gradient instead.

int rid_allocate_id()

Allocates a unique ID which can be used by the implementation to construct an RID. This is used mainly from native extensions to implement servers.

RID rid_from_int64(int base)

Creates an RID from a base. This is used mainly from native extensions to build servers.

float rotate_toward(float from, float to, float delta)

Rotates from toward to by the delta amount. Will not go past to. Similar to move_toward(), but interpolates correctly when the angles wrap around @GDScript.TAU. If delta is negative, this function will rotate away from to, toward the opposite angle, and will not go past the opposite angle.

float roundf(float x)

Rounds x to the nearest whole number, with halfway cases rounded away from 0. A type-safe version of round(), returning a float.

int roundi(float x)

Rounds x to the nearest whole number, with halfway cases rounded away from 0. A type-safe version of round(), returning an int.

void seed(int base)

Sets the seed for the random number generator to base. Setting the seed manually can ensure consistent, repeatable results for most random functions.

				var my_seed = "Redot Rocks".hash()
				seed(my_seed)
				var a = randf() + randi()
				seed(my_seed)
				var b = randf() + randi()
				# a and b are now identical
				
				ulong mySeed = (ulong)GD.Hash("Redot Rocks");
				GD.Seed(mySeed);
				var a = GD.Randf() + GD.Randi();
				GD.Seed(mySeed);
				var b = GD.Randf() + GD.Randi();
				// a and b are now identical

float sigmoid(float x)

Computes the sigmoid for x, which maps the input value into the range (0, 1). The sigmoid function is defined as:

				sigmoid(x) = 1 / (1 + exp(-x))

This is the most accurate implementation of the sigmoid.

				var result = sigmoid(0.0)  # result is 0.5
				var result = sigmoid(1.0)  # result is approximately 0.7310
				var result = sigmoid(-1.0) # result is approximately 0.2689
				var result = sigmoid(5.0)  # result is approximately 0.9933

Note: For faster but less accurate approximation, see sigmoid_approx().

float sigmoid_affine(float x, float amplitude, float y_translation)

Computes an affine-transformed sigmoid for x, which allows scaling by amplitude and translation by y_translation. The affine sigmoid function is defined as:

				sigmoid_affine(x, amplitude, y_translation) = (amplitude / (1 + exp(-x))) + y_translation

This function modifies the standard sigmoid by introducing scaling and vertical translation.

				var result = sigmoid_affine(0.0, 1.0, 0.0)  # result is 0.5
				var result = sigmoid_affine(1.0, 2.0, -1.0) # result is approximately 0.4621
				var result = sigmoid_affine(-1.0, 3.0, 2.0) # result is approximately 2.8068
				var result = sigmoid_affine(1.0, 2.0, 2.5) # result is approximately 3.9621

Note: This is a more accurate but computationally heavier version of the affine sigmoid. For faster approximations, see sigmoid_affine_approx().

float sigmoid_affine_approx(float x, float amplitude, float y_translation)

Computes an approximation of the affine-transformed sigmoid function for x, allowing scaling by amplitude and translation by y_translation. The approximation function is defined as:

				affine_sigmoid_approx(x, amplitude, y_translation) = amplitude * (0.5 + (x / (4 + abs(x)))) + y_translation

This function approximates the affine sigmoid, offering faster computation at the cost of some precision. It is useful in performance-sensitive environments where both transformation and speed are needed.

				var result = sigmoid_affine_approx(0.0, 1.0, 0.0)  # result is 0.5
				var result = sigmoid_affine_approx(2.0, 2.0, 1.0)  # result is approximately 2.6667
				var result = sigmoid_affine_approx(-1.0, 3.0, 0.5) # result is 1.4
				var result = sigmoid_affine_approx(1.0, 2.0, 2.5) # result is 3.9

float sigmoid_approx(float x)

Computes an approximation of the sigmoid function for x, which maps the input value into the range (0, 1). The approximation function is defined as:

				sigmoid_approx(x) = 0.5 + (x / (4 + abs(x)))

This function is faster than the standard sigmoid(), especially useful in performance-sensitive environments where a balance between accuracy and speed is desired.

				var result = sigmoid_approx(0.0)  # result is 0.5
				var result = sigmoid_approx(2.0)  # result is approximately 0.8333
				var result = sigmoid_approx(-1.0) # result is 0.3
				var result = sigmoid_approx(5.0)  # result is approximately 1.0555

Variant sign(Variant x)

Returns the same type of Variant as x, with -1 for negative values, 1 for positive values, and 0 for zeros. For nan values it returns 0. Supported types: int, float, Vector2, Vector2i, Vector3, Vector3i, Vector4, Vector4i.

				sign(-6.0) # Returns -1
				sign(0.0)  # Returns 0
				sign(6.0)  # Returns 1
				sign(NAN)  # Returns 0

				sign(Vector3(-6.0, 0.0, 6.0)) # Returns (-1, 0, 1)

Note: For better type safety, use signf(), signi(), Vector2.sign(), Vector2i.sign(), Vector3.sign(), Vector3i.sign(), Vector4.sign(), or Vector4i.sign().

float signf(float x)

Returns -1.0 if x is negative, 1.0 if x is positive, and 0.0 if x is zero. For nan values of x it returns 0.0.

				signf(-6.5) # Returns -1.0
				signf(0.0)  # Returns 0.0
				signf(6.5)  # Returns 1.0
				signf(NAN)  # Returns 0.0

int signi(int x)

Returns -1 if x is negative, 1 if x is positive, and 0 if x is zero.

				signi(-6) # Returns -1
				signi(0)  # Returns 0
				signi(6)  # Returns 1

float sin(float angle_rad)

Returns the sine of angle angle_rad in radians.

				sin(0.523599)       # Returns 0.5
				sin(deg_to_rad(90)) # Returns 1.0

float sinh(float x)

Returns the hyperbolic sine of x.

				var a = log(2.0) # Returns 0.693147
				sinh(a) # Returns 0.75

float smoothstep(float from, float to, float x)

Returns a smooth cubic Hermite interpolation between 0 and 1. For positive ranges (when from <= to) the return value is 0 when x <= from, and 1 when x >= to. If x lies between from and to, the return value follows an S-shaped curve that smoothly transitions from 0 to 1. For negative ranges (when from > to) the function is mirrored and returns 1 when x <= to and 0 when x >= from. This S-shaped curve is the cubic Hermite interpolator, given by f(y) = 3*y^2 - 2*y^3 where y = (x-from) / (to-from).

				smoothstep(0, 2, -5.0) # Returns 0.0
				smoothstep(0, 2, 0.5) # Returns 0.15625
				smoothstep(0, 2, 1.0) # Returns 0.5
				smoothstep(0, 2, 2.0) # Returns 1.0

Compared to ease() with a curve value of -1.6521, smoothstep() returns the smoothest possible curve with no sudden changes in the derivative. If you need to perform more advanced transitions, use Tween or AnimationPlayer. Comparison between smoothstep() and ease(x, -1.6521) return values Smoothstep() return values with positive, zero, and negative ranges

Variant snapped(Variant x, Variant step)

Returns the multiple of step that is the closest to x. This can also be used to round a floating-point number to an arbitrary number of decimals. The returned value is the same type of Variant as step. Supported types: int, float, Vector2, Vector2i, Vector3, Vector3i, Vector4, Vector4i.

				snapped(100, 32)  # Returns 96
				snapped(3.14159, 0.01)  # Returns 3.14

				snapped(Vector2(34, 70), Vector2(8, 8))  # Returns (32, 72)

See also ceil(), floor(), and round(). Note: For better type safety, use snappedf(), snappedi(), Vector2.snapped(), Vector2i.snapped(), Vector3.snapped(), Vector3i.snapped(), Vector4.snapped(), or Vector4i.snapped().

float snappedf(float x, float step)

Returns the multiple of step that is the closest to x. This can also be used to round a floating-point number to an arbitrary number of decimals. A type-safe version of snapped(), returning a float.

				snappedf(32.0, 2.5)  # Returns 32.5
				snappedf(3.14159, 0.01)  # Returns 3.14

int snappedi(float x, int step)

Returns the multiple of step that is the closest to x. A type-safe version of snapped(), returning an int.

				snappedi(53, 16)  # Returns 48
				snappedi(4096, 100)  # Returns 4100

float sqrt(float x)

Returns the square root of x, where x is a non-negative number.

				sqrt(9)     # Returns 3
				sqrt(10.24) # Returns 3.2
				sqrt(-1)    # Returns NaN

Note: Negative values of x return NaN ("Not a Number"). In C#, if you need negative inputs, use System.Numerics.Complex.

int step_decimals(float x)

Returns the position of the first non-zero digit, after the decimal point. Note that the maximum return value is 10, which is a design decision in the implementation.

				var n = step_decimals(5)       # n is 0
				n = step_decimals(1.0005)      # n is 4
				n = step_decimals(0.000000005) # n is 9

String str() vararg

Converts one or more arguments of any Variant type to a String in the best way possible.

				var a = [10, 20, 30]
				var b = str(a)
				print(len(a)) # Prints 3 (the number of elements in the array).
				print(len(b)) # Prints 12 (the length of the string "[10, 20, 30]").

Variant str_to_var(String string)

Converts a formatted string that was returned by var_to_str() to the equivalent Variant, without decoding objects. Note: If you need object deserialization, see str_to_var_with_objects().

				var data = '{ "a": 1, "b": 2 }' # data is a String
				var dict = str_to_var(data)     # dict is a Dictionary
				print(dict["a"])                # Prints 1
				
				string data = "{ \"a\": 1, \"b\": 2 }";           // data is a string
				var dict = GD.StrToVar(data).AsGodotDictionary(); // dict is a Dictionary
				GD.Print(dict["a"]);                              // Prints 1

Variant str_to_var_with_objects(String string)

Converts a formatted string that was returned by var_to_str_with_objects() to the equivalent Variant. Decoding objects is allowed. Warning: Deserialized object can contain code which gets executed. Do not use this option if the serialized object comes from untrusted sources to avoid potential security threats (remote code execution).

float tan(float angle_rad)

Returns the tangent of angle angle_rad in radians.

				tan(deg_to_rad(45)) # Returns 1

float tanh(float x)

Returns the hyperbolic tangent of x.

				var a = log(2.0) # Returns 0.693147
				tanh(a)          # Returns 0.6

Variant type_convert(Variant variant, int type)

Converts the given variant to the given type, using the Variant.Type values. This method is generous with how it handles types, it can automatically convert between array types, convert numeric Strings to int, and converting most things to String. If the type conversion cannot be done, this method will return the default value for that type, for example converting Rect2 to Vector2 will always return Vector2.ZERO. This method will never show error messages as long as type is a valid Variant type. The returned value is a Variant, but the data inside and its type will be the same as the requested type.

				type_convert("Hi!", TYPE_INT) # Returns 0
				type_convert("123", TYPE_INT) # Returns 123
				type_convert(123.4, TYPE_INT) # Returns 123
				type_convert(5, TYPE_VECTOR2) # Returns (0, 0)
				type_convert("Hi!", TYPE_NIL) # Returns null

String type_string(int type)

Returns a human-readable name of the given type, using the Variant.Type values.

				print(TYPE_INT) # Prints 2
				print(type_string(TYPE_INT)) # Prints "int"
				print(type_string(TYPE_STRING)) # Prints "String"

See also typeof().

int typeof(Variant variable)

Returns the internal type of the given variable, using the Variant.Type values.

				var json = JSON.new()
				json.parse('["a", "b", "c"]')
				var result = json.get_data()
				if result is Array:
					print(result[0]) # Prints "a"
				else:
					print("Unexpected result!")

See also type_string().

PackedByteArray var_to_bytes_with_objects(Variant variable)

Encodes a Variant value to a byte array. Encoding objects is allowed (and can potentially include executable code). Deserialization can be done with bytes_to_var_with_objects(). Note: Encoding Callable is not supported and will result in an empty value, regardless of the data.

String var_to_str(Variant variable)

Converts a Variant variable to a formatted String that can then be parsed using str_to_var(), without encoding objects. Note: If you need object serialization, see var_to_str_with_objects().

				var a = { "a": 1, "b": 2 }
				print(var_to_str(a))
				
				var a = new Godot.Collections.Dictionary { ["a"] = 1, ["b"] = 2 };
				GD.Print(GD.VarToStr(a));

Prints:

				{
					"a": 1,
					"b": 2
				}

Note: Converting Signal or Callable is not supported and will result in an empty value for these types, regardless of their data.

Variant weakref(Variant obj)

Returns a WeakRef instance holding a weak reference to obj. Returns an empty WeakRef instance if obj is null. Prints an error and returns null if obj is neither Object-derived nor null. A weak reference to an object is not enough to keep the object alive: when the only remaining references to a referent are weak references, garbage collection is free to destroy the referent and reuse its memory for something else. However, until the object is actually destroyed the weak reference may return the object even if there are no strong references to it.

Variant wrap(Variant value, Variant min, Variant max)

Wraps the Variant value between min and max. min is inclusive while max is exclusive. This can be used for creating loop-like behavior or infinite surfaces. Variant types int and float are supported. If any of the arguments is float, this function returns a float, otherwise it returns an int.

				var a = wrap(4, 5, 10)
				# a is 9 (int)

				var a = wrap(7, 5, 10)
				# a is 7 (int)

				var a = wrap(10.5, 5, 10)
				# a is 5.5 (float)

float wrapf(float value, float min, float max)

Wraps the float value between min and max. min is inclusive while max is exclusive. This can be used for creating loop-like behavior or infinite surfaces.

				# Infinite loop between 5.0 and 9.9
				value = wrapf(value + 0.1, 5.0, 10.0)
				
				# Infinite rotation (in radians)
				angle = wrapf(angle + 0.1, 0.0, TAU)
				
				# Infinite rotation (in radians)
				angle = wrapf(angle + 0.1, -PI, PI)

Note: If min is 0, this is equivalent to fposmod(), so prefer using that instead. wrapf() is more flexible than using the fposmod() approach by giving the user control over the minimum value.

int wrapi(int value, int min, int max)

Wraps the integer value between min and max. min is inclusive while max is exclusive. This can be used for creating loop-like behavior or infinite surfaces.

				# Infinite loop between 5 and 9
				frame = wrapi(frame + 1, 5, 10)
				
				# result is -2
				var result = wrapi(-6, -5, -1)

Constants

SIDE_LEFT = 0

Enum: Side

Left side, usually used for Control or StyleBox-derived classes.

SIDE_TOP = 1

Enum: Side

Top side, usually used for Control or StyleBox-derived classes.

SIDE_RIGHT = 2

Enum: Side

Right side, usually used for Control or StyleBox-derived classes.

SIDE_BOTTOM = 3

Enum: Side

Bottom side, usually used for Control or StyleBox-derived classes.

CORNER_TOP_LEFT = 0

Enum: Corner

Top-left corner.

CORNER_TOP_RIGHT = 1

Enum: Corner

Top-right corner.

CORNER_BOTTOM_RIGHT = 2

Enum: Corner

Bottom-right corner.

CORNER_BOTTOM_LEFT = 3

Enum: Corner

Bottom-left corner.

CLOCKWISE = 0

Enum: ClockDirection

Clockwise rotation. Used by some methods (e.g. Image.rotate_90()).

COUNTERCLOCKWISE = 1

Enum: ClockDirection

Counter-clockwise rotation. Used by some methods (e.g. Image.rotate_90()).

HORIZONTAL_ALIGNMENT_LEFT = 0

Enum: HorizontalAlignment

Horizontal left alignment, usually for text-derived classes.

HORIZONTAL_ALIGNMENT_CENTER = 1

Enum: HorizontalAlignment

Horizontal center alignment, usually for text-derived classes.

HORIZONTAL_ALIGNMENT_RIGHT = 2

Enum: HorizontalAlignment

Horizontal right alignment, usually for text-derived classes.

HORIZONTAL_ALIGNMENT_FILL = 3

Enum: HorizontalAlignment

Expand row to fit width, usually for text-derived classes.

VERTICAL_ALIGNMENT_TOP = 0

Enum: VerticalAlignment

Vertical top alignment, usually for text-derived classes.

VERTICAL_ALIGNMENT_CENTER = 1

Enum: VerticalAlignment

Vertical center alignment, usually for text-derived classes.

VERTICAL_ALIGNMENT_BOTTOM = 2

Enum: VerticalAlignment

Vertical bottom alignment, usually for text-derived classes.

VERTICAL_ALIGNMENT_FILL = 3

Enum: VerticalAlignment

Expand rows to fit height, usually for text-derived classes.

INLINE_ALIGNMENT_TOP_TO = 0

Enum: InlineAlignment

Aligns the top of the inline object (e.g. image, table) to the position of the text specified by INLINE_ALIGNMENT_TO_* constant.

INLINE_ALIGNMENT_CENTER_TO = 1

Enum: InlineAlignment

Aligns the center of the inline object (e.g. image, table) to the position of the text specified by INLINE_ALIGNMENT_TO_* constant.

INLINE_ALIGNMENT_BASELINE_TO = 3

Enum: InlineAlignment

Aligns the baseline (user defined) of the inline object (e.g. image, table) to the position of the text specified by INLINE_ALIGNMENT_TO_* constant.

INLINE_ALIGNMENT_BOTTOM_TO = 2

Enum: InlineAlignment

Aligns the bottom of the inline object (e.g. image, table) to the position of the text specified by INLINE_ALIGNMENT_TO_* constant.

INLINE_ALIGNMENT_TO_TOP = 0

Enum: InlineAlignment

Aligns the position of the inline object (e.g. image, table) specified by INLINE_ALIGNMENT_*_TO constant to the top of the text.

INLINE_ALIGNMENT_TO_CENTER = 4

Enum: InlineAlignment

Aligns the position of the inline object (e.g. image, table) specified by INLINE_ALIGNMENT_*_TO constant to the center of the text.

INLINE_ALIGNMENT_TO_BASELINE = 8

Enum: InlineAlignment

Aligns the position of the inline object (e.g. image, table) specified by INLINE_ALIGNMENT_*_TO constant to the baseline of the text.

INLINE_ALIGNMENT_TO_BOTTOM = 12

Enum: InlineAlignment

Aligns inline object (e.g. image, table) to the bottom of the text.

INLINE_ALIGNMENT_TOP = 0

Enum: InlineAlignment

Aligns top of the inline object (e.g. image, table) to the top of the text. Equivalent to INLINE_ALIGNMENT_TOP_TO | INLINE_ALIGNMENT_TO_TOP.

INLINE_ALIGNMENT_CENTER = 5

Enum: InlineAlignment

Aligns center of the inline object (e.g. image, table) to the center of the text. Equivalent to INLINE_ALIGNMENT_CENTER_TO | INLINE_ALIGNMENT_TO_CENTER.

INLINE_ALIGNMENT_BOTTOM = 14

Enum: InlineAlignment

Aligns bottom of the inline object (e.g. image, table) to the bottom of the text. Equivalent to INLINE_ALIGNMENT_BOTTOM_TO | INLINE_ALIGNMENT_TO_BOTTOM.

INLINE_ALIGNMENT_IMAGE_MASK = 3

Enum: InlineAlignment

A bit mask for INLINE_ALIGNMENT_*_TO alignment constants.

INLINE_ALIGNMENT_TEXT_MASK = 12

Enum: InlineAlignment

A bit mask for INLINE_ALIGNMENT_TO_* alignment constants.

EULER_ORDER_XYZ = 0

Enum: EulerOrder

Specifies that Euler angles should be in XYZ order. When composing, the order is X, Y, Z. When decomposing, the order is reversed, first Z, then Y, and X last.

EULER_ORDER_XZY = 1

Enum: EulerOrder

Specifies that Euler angles should be in XZY order. When composing, the order is X, Z, Y. When decomposing, the order is reversed, first Y, then Z, and X last.

EULER_ORDER_YXZ = 2

Enum: EulerOrder

Specifies that Euler angles should be in YXZ order. When composing, the order is Y, X, Z. When decomposing, the order is reversed, first Z, then X, and Y last.

EULER_ORDER_YZX = 3

Enum: EulerOrder

Specifies that Euler angles should be in YZX order. When composing, the order is Y, Z, X. When decomposing, the order is reversed, first X, then Z, and Y last.

EULER_ORDER_ZXY = 4

Enum: EulerOrder

Specifies that Euler angles should be in ZXY order. When composing, the order is Z, X, Y. When decomposing, the order is reversed, first Y, then X, and Z last.

EULER_ORDER_ZYX = 5

Enum: EulerOrder

Specifies that Euler angles should be in ZYX order. When composing, the order is Z, Y, X. When decomposing, the order is reversed, first X, then Y, and Z last.

KEY_NONE = 0

Enum: Key

Enum value which doesn't correspond to any key. This is used to initialize Key properties with a generic state.

KEY_SPECIAL = 4194304

Enum: Key

Keycodes with this bit applied are non-printable.

KEY_ESCAPE = 4194305

Enum: Key

Escape key.

KEY_TAB = 4194306

Enum: Key

Tab key.

KEY_BACKTAB = 4194307

Enum: Key

Shift + Tab key.

KEY_BACKSPACE = 4194308

Enum: Key

Backspace key.

KEY_ENTER = 4194309

Enum: Key

Return key (on the main keyboard).

KEY_KP_ENTER = 4194310

Enum: Key

Enter key on the numeric keypad.

KEY_INSERT = 4194311

Enum: Key

Insert key.

KEY_DELETE = 4194312

Enum: Key

Delete key.

KEY_PAUSE = 4194313

Enum: Key

Pause key.

KEY_PRINT = 4194314

Enum: Key

Print Screen key.

KEY_SYSREQ = 4194315

Enum: Key

System Request key.

KEY_CLEAR = 4194316

Enum: Key

Clear key.

KEY_HOME = 4194317

Enum: Key

Home key.

KEY_END = 4194318

Enum: Key

End key.

KEY_LEFT = 4194319

Enum: Key

Left arrow key.

KEY_UP = 4194320

Enum: Key

Up arrow key.

KEY_RIGHT = 4194321

Enum: Key

Right arrow key.

KEY_DOWN = 4194322

Enum: Key

Down arrow key.

KEY_PAGEUP = 4194323

Enum: Key

Page Up key.

KEY_PAGEDOWN = 4194324

Enum: Key

Page Down key.

KEY_SHIFT = 4194325

Enum: Key

Shift key.

KEY_CTRL = 4194326

Enum: Key

Control key.

KEY_META = 4194327

Enum: Key

Meta key.

KEY_ALT = 4194328

Enum: Key

Alt key.

KEY_CAPSLOCK = 4194329

Enum: Key

Caps Lock key.

KEY_NUMLOCK = 4194330

Enum: Key

Num Lock key.

KEY_SCROLLLOCK = 4194331

Enum: Key

Scroll Lock key.

KEY_F1 = 4194332

Enum: Key

F1 key.

KEY_F2 = 4194333

Enum: Key

F2 key.

KEY_F3 = 4194334

Enum: Key

F3 key.

KEY_F4 = 4194335

Enum: Key

F4 key.

KEY_F5 = 4194336

Enum: Key

F5 key.

KEY_F6 = 4194337

Enum: Key

F6 key.

KEY_F7 = 4194338

Enum: Key

F7 key.

KEY_F8 = 4194339

Enum: Key

F8 key.

KEY_F9 = 4194340

Enum: Key

F9 key.

KEY_F10 = 4194341

Enum: Key

F10 key.

KEY_F11 = 4194342

Enum: Key

F11 key.

KEY_F12 = 4194343

Enum: Key

F12 key.

KEY_F13 = 4194344

Enum: Key

F13 key.

KEY_F14 = 4194345

Enum: Key

F14 key.

KEY_F15 = 4194346

Enum: Key

F15 key.

KEY_F16 = 4194347

Enum: Key

F16 key.

KEY_F17 = 4194348

Enum: Key

F17 key.

KEY_F18 = 4194349

Enum: Key

F18 key.

KEY_F19 = 4194350

Enum: Key

F19 key.

KEY_F20 = 4194351

Enum: Key

F20 key.

KEY_F21 = 4194352

Enum: Key

F21 key.

KEY_F22 = 4194353

Enum: Key

F22 key.

KEY_F23 = 4194354

Enum: Key

F23 key.

KEY_F24 = 4194355

Enum: Key

F24 key.

KEY_F25 = 4194356

Enum: Key

F25 key. Only supported on macOS and Linux due to a Windows limitation.

KEY_F26 = 4194357

Enum: Key

F26 key. Only supported on macOS and Linux due to a Windows limitation.

KEY_F27 = 4194358

Enum: Key

F27 key. Only supported on macOS and Linux due to a Windows limitation.

KEY_F28 = 4194359

Enum: Key

F28 key. Only supported on macOS and Linux due to a Windows limitation.

KEY_F29 = 4194360

Enum: Key

F29 key. Only supported on macOS and Linux due to a Windows limitation.

KEY_F30 = 4194361

Enum: Key

F30 key. Only supported on macOS and Linux due to a Windows limitation.

KEY_F31 = 4194362

Enum: Key

F31 key. Only supported on macOS and Linux due to a Windows limitation.

KEY_F32 = 4194363

Enum: Key

F32 key. Only supported on macOS and Linux due to a Windows limitation.

KEY_F33 = 4194364

Enum: Key

F33 key. Only supported on macOS and Linux due to a Windows limitation.

KEY_F34 = 4194365

Enum: Key

F34 key. Only supported on macOS and Linux due to a Windows limitation.

KEY_F35 = 4194366

Enum: Key

F35 key. Only supported on macOS and Linux due to a Windows limitation.

KEY_KP_MULTIPLY = 4194433

Enum: Key

Multiply (*) key on the numeric keypad.

KEY_KP_DIVIDE = 4194434

Enum: Key

Divide (/) key on the numeric keypad.

KEY_KP_SUBTRACT = 4194435

Enum: Key

Subtract (-) key on the numeric keypad.

KEY_KP_PERIOD = 4194436

Enum: Key

Period (.) key on the numeric keypad.

KEY_KP_ADD = 4194437

Enum: Key

Add (+) key on the numeric keypad.

KEY_KP_0 = 4194438

Enum: Key

Number 0 on the numeric keypad.

KEY_KP_1 = 4194439

Enum: Key

Number 1 on the numeric keypad.

KEY_KP_2 = 4194440

Enum: Key

Number 2 on the numeric keypad.

KEY_KP_3 = 4194441

Enum: Key

Number 3 on the numeric keypad.

KEY_KP_4 = 4194442

Enum: Key

Number 4 on the numeric keypad.

KEY_KP_5 = 4194443

Enum: Key

Number 5 on the numeric keypad.

KEY_KP_6 = 4194444

Enum: Key

Number 6 on the numeric keypad.

KEY_KP_7 = 4194445

Enum: Key

Number 7 on the numeric keypad.

KEY_KP_8 = 4194446

Enum: Key

Number 8 on the numeric keypad.

KEY_KP_9 = 4194447

Enum: Key

Number 9 on the numeric keypad.

KEY_MENU = 4194370

Enum: Key

Context menu key.

KEY_HYPER = 4194371

Enum: Key

Hyper key. (On Linux/X11 only).

KEY_HELP = 4194373

Enum: Key

Help key.

KEY_BACK = 4194376

Enum: Key

Back key.

KEY_FORWARD = 4194377

Enum: Key

Forward key.

KEY_STOP = 4194378

Enum: Key

Media stop key.

KEY_REFRESH = 4194379

Enum: Key

Refresh key.

KEY_VOLUMEDOWN = 4194380

Enum: Key

Volume down key.

KEY_VOLUMEMUTE = 4194381

Enum: Key

Mute volume key.

KEY_VOLUMEUP = 4194382

Enum: Key

Volume up key.

KEY_MEDIAPLAY = 4194388

Enum: Key

Media play key.

KEY_MEDIASTOP = 4194389

Enum: Key

Media stop key.

KEY_MEDIAPREVIOUS = 4194390

Enum: Key

Previous song key.

KEY_MEDIANEXT = 4194391

Enum: Key

Next song key.

KEY_MEDIARECORD = 4194392

Enum: Key

Media record key.

KEY_HOMEPAGE = 4194393

Enum: Key

Home page key.

KEY_FAVORITES = 4194394

Enum: Key

Favorites key.

Enum: Key

Search key.

KEY_STANDBY = 4194396

Enum: Key

Standby key.

KEY_OPENURL = 4194397

Enum: Key

Open URL / Launch Browser key.

KEY_LAUNCHMAIL = 4194398

Enum: Key

Launch Mail key.

KEY_LAUNCHMEDIA = 4194399

Enum: Key

Launch Media key.

KEY_LAUNCH0 = 4194400

Enum: Key

Launch Shortcut 0 key.

KEY_LAUNCH1 = 4194401

Enum: Key

Launch Shortcut 1 key.

KEY_LAUNCH2 = 4194402

Enum: Key

Launch Shortcut 2 key.

KEY_LAUNCH3 = 4194403

Enum: Key

Launch Shortcut 3 key.

KEY_LAUNCH4 = 4194404

Enum: Key

Launch Shortcut 4 key.

KEY_LAUNCH5 = 4194405

Enum: Key

Launch Shortcut 5 key.

KEY_LAUNCH6 = 4194406

Enum: Key

Launch Shortcut 6 key.

KEY_LAUNCH7 = 4194407

Enum: Key

Launch Shortcut 7 key.

KEY_LAUNCH8 = 4194408

Enum: Key

Launch Shortcut 8 key.

KEY_LAUNCH9 = 4194409

Enum: Key

Launch Shortcut 9 key.

KEY_LAUNCHA = 4194410

Enum: Key

Launch Shortcut A key.

KEY_LAUNCHB = 4194411

Enum: Key

Launch Shortcut B key.

KEY_LAUNCHC = 4194412

Enum: Key

Launch Shortcut C key.

KEY_LAUNCHD = 4194413

Enum: Key

Launch Shortcut D key.

KEY_LAUNCHE = 4194414

Enum: Key

Launch Shortcut E key.

KEY_LAUNCHF = 4194415

Enum: Key

Launch Shortcut F key.

KEY_GLOBE = 4194416

Enum: Key

"Globe" key on Mac / iPad keyboard.

KEY_KEYBOARD = 4194417

Enum: Key

"On-screen keyboard" key on iPad keyboard.

KEY_JIS_EISU = 4194418

Enum: Key

英数 key on Mac keyboard.

KEY_JIS_KANA = 4194419

Enum: Key

かな key on Mac keyboard.

KEY_UNKNOWN = 8388607

Enum: Key

Unknown key.

KEY_SPACE = 32

Enum: Key

Space key.

KEY_EXCLAM = 33

Enum: Key

Exclamation mark (!) key.

KEY_QUOTEDBL = 34

Enum: Key

Double quotation mark (") key.

KEY_NUMBERSIGN = 35

Enum: Key

Number sign or hash (#) key.

KEY_DOLLAR = 36

Enum: Key

Dollar sign ($) key.

KEY_PERCENT = 37

Enum: Key

Percent sign (%) key.

KEY_AMPERSAND = 38

Enum: Key

Ampersand (&) key.

KEY_APOSTROPHE = 39

Enum: Key

Apostrophe (') key.

KEY_PARENLEFT = 40

Enum: Key

Left parenthesis (() key.

KEY_PARENRIGHT = 41

Enum: Key

Right parenthesis ()) key.

KEY_ASTERISK = 42

Enum: Key

Asterisk (*) key.

KEY_PLUS = 43

Enum: Key

Plus (+) key.

KEY_COMMA = 44

Enum: Key

Comma (,) key.

KEY_MINUS = 45

Enum: Key

Minus (-) key.

KEY_PERIOD = 46

Enum: Key

Period (.) key.

KEY_SLASH = 47

Enum: Key

Slash (/) key.

KEY_0 = 48

Enum: Key

Number 0 key.

KEY_1 = 49

Enum: Key

Number 1 key.

KEY_2 = 50

Enum: Key

Number 2 key.

KEY_3 = 51

Enum: Key

Number 3 key.

KEY_4 = 52

Enum: Key

Number 4 key.

KEY_5 = 53

Enum: Key

Number 5 key.

KEY_6 = 54

Enum: Key

Number 6 key.

KEY_7 = 55

Enum: Key

Number 7 key.

KEY_8 = 56

Enum: Key

Number 8 key.

KEY_9 = 57

Enum: Key

Number 9 key.

KEY_COLON = 58

Enum: Key

Colon (:) key.

KEY_SEMICOLON = 59

Enum: Key

Semicolon (;) key.

KEY_LESS = 60

Enum: Key

Less-than sign (<) key.

KEY_EQUAL = 61

Enum: Key

Equal sign (=) key.

KEY_GREATER = 62

Enum: Key

Greater-than sign (>) key.

KEY_QUESTION = 63

Enum: Key

Question mark (?) key.

KEY_AT = 64

Enum: Key

At sign (@) key.

KEY_A = 65

Enum: Key

A key.

KEY_B = 66

Enum: Key

B key.

KEY_C = 67

Enum: Key

C key.

KEY_D = 68

Enum: Key

D key.

KEY_E = 69

Enum: Key

E key.

KEY_F = 70

Enum: Key

F key.

KEY_G = 71

Enum: Key

G key.

KEY_H = 72

Enum: Key

H key.

KEY_I = 73

Enum: Key

I key.

KEY_J = 74

Enum: Key

J key.

KEY_K = 75

Enum: Key

K key.

KEY_L = 76

Enum: Key

L key.

KEY_M = 77

Enum: Key

M key.

KEY_N = 78

Enum: Key

N key.

KEY_O = 79

Enum: Key

O key.

KEY_P = 80

Enum: Key

P key.

KEY_Q = 81

Enum: Key

Q key.

KEY_R = 82

Enum: Key

R key.

KEY_S = 83

Enum: Key

S key.

KEY_T = 84

Enum: Key

T key.

KEY_U = 85

Enum: Key

U key.

KEY_V = 86

Enum: Key

V key.

KEY_W = 87

Enum: Key

W key.

KEY_X = 88

Enum: Key

X key.

KEY_Y = 89

Enum: Key

Y key.

KEY_Z = 90

Enum: Key

Z key.

KEY_BRACKETLEFT = 91

Enum: Key

Left bracket ([lb]) key.

KEY_BACKSLASH = 92

Enum: Key

Backslash (\) key.

KEY_BRACKETRIGHT = 93

Enum: Key

Right bracket ([rb]) key.

KEY_ASCIICIRCUM = 94

Enum: Key

Caret (^) key.

KEY_UNDERSCORE = 95

Enum: Key

Underscore (_) key.

KEY_QUOTELEFT = 96

Enum: Key

Backtick (`) key.

KEY_BRACELEFT = 123

Enum: Key

Left brace ({) key.

KEY_BAR = 124

Enum: Key

Vertical bar or pipe (|) key.

KEY_BRACERIGHT = 125

Enum: Key

Right brace (}) key.

KEY_ASCIITILDE = 126

Enum: Key

Tilde (~) key.

KEY_YEN = 165

Enum: Key

Yen symbol (¥) key.

KEY_SECTION = 167

Enum: Key

Section sign (§) key.

KEY_CODE_MASK = 8388607

Enum: KeyModifierMask

Key Code mask.

KEY_MODIFIER_MASK = 2130706432

Enum: KeyModifierMask

Modifier key mask.

KEY_MASK_CMD_OR_CTRL = 16777216

Enum: KeyModifierMask

Automatically remapped to KEY_META on macOS and KEY_CTRL on other platforms, this mask is never set in the actual events, and should be used for key mapping only.

KEY_MASK_SHIFT = 33554432

Enum: KeyModifierMask

Shift key mask.

KEY_MASK_ALT = 67108864

Enum: KeyModifierMask

Alt or Option (on macOS) key mask.

KEY_MASK_META = 134217728

Enum: KeyModifierMask

Command (on macOS) or Meta/Windows key mask.

KEY_MASK_CTRL = 268435456

Enum: KeyModifierMask

Control key mask.

KEY_MASK_KPAD = 536870912

Enum: KeyModifierMask

Keypad key mask.

KEY_MASK_GROUP_SWITCH = 1073741824

Enum: KeyModifierMask

Group Switch key mask.

KEY_LOCATION_UNSPECIFIED = 0

Enum: KeyLocation

Used for keys which only appear once, or when a comparison doesn't need to differentiate the LEFT and RIGHT versions. For example, when using InputEvent.is_match(), an event which has KEY_LOCATION_UNSPECIFIED will match any KeyLocation on the passed event.

KEY_LOCATION_LEFT = 1

Enum: KeyLocation

A key which is to the left of its twin.

KEY_LOCATION_RIGHT = 2

Enum: KeyLocation

A key which is to the right of its twin.

MOUSE_BUTTON_NONE = 0

Enum: MouseButton

Enum value which doesn't correspond to any mouse button. This is used to initialize MouseButton properties with a generic state.

MOUSE_BUTTON_LEFT = 1

Enum: MouseButton

Primary mouse button, usually assigned to the left button.

MOUSE_BUTTON_RIGHT = 2

Enum: MouseButton

Secondary mouse button, usually assigned to the right button.

MOUSE_BUTTON_MIDDLE = 3

Enum: MouseButton

Middle mouse button.

MOUSE_BUTTON_WHEEL_UP = 4

Enum: MouseButton

Mouse wheel scrolling up.

MOUSE_BUTTON_WHEEL_DOWN = 5

Enum: MouseButton

Mouse wheel scrolling down.

MOUSE_BUTTON_WHEEL_LEFT = 6

Enum: MouseButton

Mouse wheel left button (only present on some mice).

MOUSE_BUTTON_WHEEL_RIGHT = 7

Enum: MouseButton

Mouse wheel right button (only present on some mice).

MOUSE_BUTTON_XBUTTON1 = 8

Enum: MouseButton

Extra mouse button 1. This is sometimes present, usually to the sides of the mouse.

MOUSE_BUTTON_XBUTTON2 = 9

Enum: MouseButton

Extra mouse button 2. This is sometimes present, usually to the sides of the mouse.

MOUSE_BUTTON_MASK_LEFT = 1

Enum: MouseButtonMask

Primary mouse button mask, usually for the left button.

MOUSE_BUTTON_MASK_RIGHT = 2

Enum: MouseButtonMask

Secondary mouse button mask, usually for the right button.

MOUSE_BUTTON_MASK_MIDDLE = 4

Enum: MouseButtonMask

Middle mouse button mask.

MOUSE_BUTTON_MASK_MB_XBUTTON1 = 128

Enum: MouseButtonMask

Extra mouse button 1 mask.

MOUSE_BUTTON_MASK_MB_XBUTTON2 = 256

Enum: MouseButtonMask

Extra mouse button 2 mask.

JOY_BUTTON_INVALID = -1

Enum: JoyButton

An invalid game controller button.

JOY_BUTTON_A = 0

Enum: JoyButton

Game controller SDL button A. Corresponds to the bottom action button: Sony Cross, Xbox A, Nintendo B.

JOY_BUTTON_B = 1

Enum: JoyButton

Game controller SDL button B. Corresponds to the right action button: Sony Circle, Xbox B, Nintendo A.

JOY_BUTTON_X = 2

Enum: JoyButton

Game controller SDL button X. Corresponds to the left action button: Sony Square, Xbox X, Nintendo Y.

JOY_BUTTON_Y = 3

Enum: JoyButton

Game controller SDL button Y. Corresponds to the top action button: Sony Triangle, Xbox Y, Nintendo X.

JOY_BUTTON_BACK = 4

Enum: JoyButton

Game controller SDL back button. Corresponds to the Sony Select, Xbox Back, Nintendo - button.

JOY_BUTTON_GUIDE = 5

Enum: JoyButton

Game controller SDL guide button. Corresponds to the Sony PS, Xbox Home button.

JOY_BUTTON_START = 6

Enum: JoyButton

Game controller SDL start button. Corresponds to the Sony Options, Xbox Menu, Nintendo + button.

JOY_BUTTON_LEFT_STICK = 7

Enum: JoyButton

Game controller SDL left stick button. Corresponds to the Sony L3, Xbox L/LS button.

JOY_BUTTON_RIGHT_STICK = 8

Enum: JoyButton

Game controller SDL right stick button. Corresponds to the Sony R3, Xbox R/RS button.

JOY_BUTTON_LEFT_SHOULDER = 9

Enum: JoyButton

Game controller SDL left shoulder button. Corresponds to the Sony L1, Xbox LB button.

JOY_BUTTON_RIGHT_SHOULDER = 10

Enum: JoyButton

Game controller SDL right shoulder button. Corresponds to the Sony R1, Xbox RB button.

JOY_BUTTON_DPAD_UP = 11

Enum: JoyButton

Game controller D-pad up button.

JOY_BUTTON_DPAD_DOWN = 12

Enum: JoyButton

Game controller D-pad down button.

JOY_BUTTON_DPAD_LEFT = 13

Enum: JoyButton

Game controller D-pad left button.

JOY_BUTTON_DPAD_RIGHT = 14

Enum: JoyButton

Game controller D-pad right button.

JOY_BUTTON_MISC1 = 15

Enum: JoyButton

Game controller SDL miscellaneous button. Corresponds to Xbox share button, PS5 microphone button, Nintendo Switch capture button.

JOY_BUTTON_PADDLE1 = 16

Enum: JoyButton

Game controller SDL paddle 1 button.

JOY_BUTTON_PADDLE2 = 17

Enum: JoyButton

Game controller SDL paddle 2 button.

JOY_BUTTON_PADDLE3 = 18

Enum: JoyButton

Game controller SDL paddle 3 button.

JOY_BUTTON_PADDLE4 = 19

Enum: JoyButton

Game controller SDL paddle 4 button.

JOY_BUTTON_TOUCHPAD = 20

Enum: JoyButton

Game controller SDL touchpad button.

JOY_BUTTON_SDL_MAX = 21

Enum: JoyButton

The number of SDL game controller buttons.

JOY_BUTTON_MAX = 128

Enum: JoyButton

The maximum number of game controller buttons supported by the engine. The actual limit may be lower on specific platforms: - Android: Up to 36 buttons. - Linux: Up to 80 buttons. - Windows and macOS: Up to 128 buttons.

JOY_AXIS_INVALID = -1

Enum: JoyAxis

An invalid game controller axis.

JOY_AXIS_LEFT_X = 0

Enum: JoyAxis

Game controller left joystick x-axis.

JOY_AXIS_LEFT_Y = 1

Enum: JoyAxis

Game controller left joystick y-axis.

JOY_AXIS_RIGHT_X = 2

Enum: JoyAxis

Game controller right joystick x-axis.

JOY_AXIS_RIGHT_Y = 3

Enum: JoyAxis

Game controller right joystick y-axis.

JOY_AXIS_TRIGGER_LEFT = 4

Enum: JoyAxis

Game controller left trigger axis.

JOY_AXIS_TRIGGER_RIGHT = 5

Enum: JoyAxis

Game controller right trigger axis.

JOY_AXIS_SDL_MAX = 6

Enum: JoyAxis

The number of SDL game controller axes.

JOY_AXIS_MAX = 10

Enum: JoyAxis

The maximum number of game controller axes: OpenVR supports up to 5 Joysticks making a total of 10 axes.

MIDI_MESSAGE_NONE = 0

Enum: MIDIMessage

Does not correspond to any MIDI message. This is the default value of InputEventMIDI.message.

MIDI_MESSAGE_NOTE_ON = 9

Enum: MIDIMessage

MIDI message sent when a note is pressed.

MIDI_MESSAGE_AFTERTOUCH = 10

Enum: MIDIMessage

MIDI message sent to indicate a change in pressure while a note is being pressed down, also called aftertouch.

MIDI_MESSAGE_CONTROL_CHANGE = 11

Enum: MIDIMessage

MIDI message sent when a controller value changes. In a MIDI device, a controller is any input that doesn't play notes. These may include sliders for volume, balance, and panning, as well as switches and pedals. See the General MIDI specification for a small list.

MIDI_MESSAGE_PROGRAM_CHANGE = 12

Enum: MIDIMessage

MIDI message sent when the MIDI device changes its current instrument (also called program or preset).

MIDI_MESSAGE_CHANNEL_PRESSURE = 13

Enum: MIDIMessage

MIDI message sent to indicate a change in pressure for the whole channel. Some MIDI devices may send this instead of MIDI_MESSAGE_AFTERTOUCH.

MIDI_MESSAGE_PITCH_BEND = 14

Enum: MIDIMessage

MIDI message sent when the value of the pitch bender changes, usually a wheel on the MIDI device.

MIDI_MESSAGE_SYSTEM_EXCLUSIVE = 240

Enum: MIDIMessage

MIDI system exclusive (SysEx) message. This type of message is not standardized and it's highly dependent on the MIDI device sending it. Note: Getting this message's data from InputEventMIDI is not implemented.

MIDI_MESSAGE_QUARTER_FRAME = 241

Enum: MIDIMessage

MIDI message sent every quarter frame to keep connected MIDI devices synchronized. Related to MIDI_MESSAGE_TIMING_CLOCK. Note: Getting this message's data from InputEventMIDI is not implemented.

MIDI_MESSAGE_SONG_POSITION_POINTER = 242

Enum: MIDIMessage

MIDI message sent to jump onto a new position in the current sequence or song. Note: Getting this message's data from InputEventMIDI is not implemented.

MIDI_MESSAGE_SONG_SELECT = 243

Enum: MIDIMessage

MIDI message sent to select a sequence or song to play. Note: Getting this message's data from InputEventMIDI is not implemented.

MIDI_MESSAGE_TUNE_REQUEST = 246

Enum: MIDIMessage

MIDI message sent to request a tuning calibration. Used on analog synthesizers. Most modern MIDI devices do not need this message.

MIDI_MESSAGE_TIMING_CLOCK = 248

Enum: MIDIMessage

MIDI message sent 24 times after MIDI_MESSAGE_QUARTER_FRAME, to keep connected MIDI devices synchronized.

MIDI_MESSAGE_START = 250

Enum: MIDIMessage

MIDI message sent to start the current sequence or song from the beginning.

MIDI_MESSAGE_CONTINUE = 251

Enum: MIDIMessage

MIDI message sent to resume from the point the current sequence or song was paused.

MIDI_MESSAGE_STOP = 252

Enum: MIDIMessage

MIDI message sent to pause the current sequence or song.

MIDI_MESSAGE_ACTIVE_SENSING = 254

Enum: MIDIMessage

MIDI message sent repeatedly while the MIDI device is idle, to tell the receiver that the connection is alive. Most MIDI devices do not send this message.

MIDI_MESSAGE_SYSTEM_RESET = 255

Enum: MIDIMessage

MIDI message sent to reset a MIDI device to its default state, as if it was just turned on. It should not be sent when the MIDI device is being turned on.

OK = 0

Enum: Error

Methods that return Error return OK when no error occurred. Since OK has value 0, and all other error constants are positive integers, it can also be used in boolean checks.

			var error = method_that_returns_error()
			if error != OK:
				printerr("Failure!")

			# Or, alternatively:
			if error:
				printerr("Still failing!")

Note: Many functions do not return an error code, but will print error messages to standard output.

FAILED = 1

Enum: Error

Generic error.

ERR_UNAVAILABLE = 2

Enum: Error

Unavailable error.

ERR_UNCONFIGURED = 3

Enum: Error

Unconfigured error.

ERR_UNAUTHORIZED = 4

Enum: Error

Unauthorized error.

ERR_PARAMETER_RANGE_ERROR = 5

Enum: Error

Parameter range error.

ERR_OUT_OF_MEMORY = 6

Enum: Error

Out of memory (OOM) error.

ERR_FILE_NOT_FOUND = 7

Enum: Error

File: Not found error.

ERR_FILE_BAD_DRIVE = 8

Enum: Error

File: Bad drive error.

ERR_FILE_BAD_PATH = 9

Enum: Error

File: Bad path error.

ERR_FILE_NO_PERMISSION = 10

Enum: Error

File: No permission error.

ERR_FILE_ALREADY_IN_USE = 11

Enum: Error

File: Already in use error.

ERR_FILE_CANT_OPEN = 12

Enum: Error

File: Can't open error.

ERR_FILE_CANT_WRITE = 13

Enum: Error

File: Can't write error.

ERR_FILE_CANT_READ = 14

Enum: Error

File: Can't read error.

ERR_FILE_UNRECOGNIZED = 15

Enum: Error

File: Unrecognized error.

ERR_FILE_CORRUPT = 16

Enum: Error

File: Corrupt error.

ERR_FILE_MISSING_DEPENDENCIES = 17

Enum: Error

File: Missing dependencies error.

ERR_FILE_EOF = 18

Enum: Error

File: End of file (EOF) error.

ERR_CANT_OPEN = 19

Enum: Error

Can't open error.

ERR_CANT_CREATE = 20

Enum: Error

Can't create error.

ERR_QUERY_FAILED = 21

Enum: Error

Query failed error.

ERR_ALREADY_IN_USE = 22

Enum: Error

Already in use error.

ERR_LOCKED = 23

Enum: Error

Locked error.

ERR_TIMEOUT = 24

Enum: Error

Timeout error.

ERR_CANT_CONNECT = 25

Enum: Error

Can't connect error.

ERR_CANT_RESOLVE = 26

Enum: Error

Can't resolve error.

ERR_CONNECTION_ERROR = 27

Enum: Error

Connection error.

ERR_CANT_ACQUIRE_RESOURCE = 28

Enum: Error

Can't acquire resource error.

ERR_CANT_FORK = 29

Enum: Error

Can't fork process error.

ERR_INVALID_DATA = 30

Enum: Error

Invalid data error.

ERR_INVALID_PARAMETER = 31

Enum: Error

Invalid parameter error.

ERR_ALREADY_EXISTS = 32

Enum: Error

Already exists error.

ERR_DOES_NOT_EXIST = 33

Enum: Error

Does not exist error.

ERR_DATABASE_CANT_READ = 34

Enum: Error

Database: Read error.

ERR_DATABASE_CANT_WRITE = 35

Enum: Error

Database: Write error.

ERR_COMPILATION_FAILED = 36

Enum: Error

Compilation failed error.

ERR_METHOD_NOT_FOUND = 37

Enum: Error

Method not found error.

Enum: Error

Linking failed error.

ERR_SCRIPT_FAILED = 39

Enum: Error

Script failed error.

Enum: Error

Cycling link (import cycle) error.

ERR_INVALID_DECLARATION = 41

Enum: Error

Invalid declaration error.

ERR_DUPLICATE_SYMBOL = 42

Enum: Error

Duplicate symbol error.

ERR_PARSE_ERROR = 43

Enum: Error

Parse error.

ERR_BUSY = 44

Enum: Error

Busy error.

ERR_SKIP = 45

Enum: Error

Skip error.

ERR_HELP = 46

Enum: Error

Help error. Used internally when passing --version or --help as executable options.

ERR_BUG = 47

Enum: Error

Bug error, caused by an implementation issue in the method. Note: If a built-in method returns this code, please open an issue on the GitHub Issue Tracker.

ERR_PRINTER_ON_FIRE = 48

Enum: Error

Printer on fire error (This is an easter egg, no built-in methods return this error code).

PROPERTY_HINT_NONE = 0

Enum: PropertyHint

The property has no hint for the editor.

PROPERTY_HINT_RANGE = 1

Enum: PropertyHint

Hints that an int or float property should be within a range specified via the hint string "min,max" or "min,max,step". The hint string can optionally include "or_greater" and/or "or_less" to allow manual input going respectively above the max or below the min values. Example: "-360,360,1,or_greater,or_less". Additionally, other keywords can be included: "exp" for exponential range editing, "radians_as_degrees" for editing radian angles in degrees (the range values are also in degrees), "degrees" to hint at an angle and "hide_slider" to hide the slider.

PROPERTY_HINT_ENUM = 2

Enum: PropertyHint

Hints that an int or String property is an enumerated value to pick in a list specified via a hint string. The hint string is a comma separated list of names such as "Hello,Something,Else". Whitespaces are not removed from either end of a name. For integer properties, the first name in the list has value 0, the next 1, and so on. Explicit values can also be specified by appending :integer to the name, e.g. "Zero,One,Three:3,Four,Six:6".

PROPERTY_HINT_ENUM_SUGGESTION = 3

Enum: PropertyHint

Hints that a String property can be an enumerated value to pick in a list specified via a hint string such as "Hello,Something,Else". Unlike PROPERTY_HINT_ENUM, a property with this hint still accepts arbitrary values and can be empty. The list of values serves to suggest possible values.

PROPERTY_HINT_EXP_EASING = 4

Enum: PropertyHint

Hints that a float property should be edited via an exponential easing function. The hint string can include "attenuation" to flip the curve horizontally and/or "positive_only" to exclude in/out easing and limit values to be greater than or equal to zero.

Enum: PropertyHint

Hints that a vector property should allow its components to be linked. For example, this allows Vector2.x and Vector2.y to be edited together.

PROPERTY_HINT_FLAGS = 6

Enum: PropertyHint

Hints that an int property is a bitmask with named bit flags. The hint string is a comma separated list of names such as "Bit0,Bit1,Bit2,Bit3". Whitespaces are not removed from either end of a name. The first name in the list has value 1, the next 2, then 4, 8, 16 and so on. Explicit values can also be specified by appending :integer to the name, e.g. "A:4,B:8,C:16". You can also combine several flags ("A:4,B:8,AB:12,C:16"). Note: A flag value must be at least 1 and at most 2 ** 32 - 1. Note: Unlike PROPERTY_HINT_ENUM, the previous explicit value is not taken into account. For the hint "A:16,B,C", A is 16, B is 2, C is 4.

PROPERTY_HINT_LAYERS_2D_RENDER = 7

Enum: PropertyHint

Hints that an int property is a bitmask using the optionally named 2D render layers.

PROPERTY_HINT_LAYERS_2D_PHYSICS = 8

Enum: PropertyHint

Hints that an int property is a bitmask using the optionally named 2D physics layers.

PROPERTY_HINT_LAYERS_2D_NAVIGATION = 9

Enum: PropertyHint

Hints that an int property is a bitmask using the optionally named 2D navigation layers.

PROPERTY_HINT_LAYERS_3D_RENDER = 10

Enum: PropertyHint

Hints that an int property is a bitmask using the optionally named 3D render layers.

PROPERTY_HINT_LAYERS_3D_PHYSICS = 11

Enum: PropertyHint

Hints that an int property is a bitmask using the optionally named 3D physics layers.

PROPERTY_HINT_LAYERS_3D_NAVIGATION = 12

Enum: PropertyHint

Hints that an int property is a bitmask using the optionally named 3D navigation layers.

PROPERTY_HINT_LAYERS_AVOIDANCE = 37

Enum: PropertyHint

Hints that an integer property is a bitmask using the optionally named avoidance layers.

PROPERTY_HINT_FILE = 13

Enum: PropertyHint

Hints that a String property is a path to a file. Editing it will show a file dialog for picking the path. The hint string can be a set of filters with wildcards like "*.png,*.jpg". By default the file will be stored as UID whenever available. You can use ResourceUID methods to convert it back to path. For storing a raw path, use PROPERTY_HINT_FILE_PATH.

PROPERTY_HINT_DIR = 14

Enum: PropertyHint

Hints that a String property is a path to a directory. Editing it will show a file dialog for picking the path.

PROPERTY_HINT_GLOBAL_FILE = 15

Enum: PropertyHint

Hints that a String property is an absolute path to a file outside the project folder. Editing it will show a file dialog for picking the path. The hint string can be a set of filters with wildcards, like "*.png,*.jpg".

PROPERTY_HINT_GLOBAL_DIR = 16

Enum: PropertyHint

Hints that a String property is an absolute path to a directory outside the project folder. Editing it will show a file dialog for picking the path.

PROPERTY_HINT_RESOURCE_TYPE = 17

Enum: PropertyHint

Hints that a property is an instance of a Resource-derived type, optionally specified via the hint string (e.g. "Texture2D"). Editing it will show a popup menu of valid resource types to instantiate.

PROPERTY_HINT_MULTILINE_TEXT = 18

Enum: PropertyHint

Hints that a String property is text with line breaks. Editing it will show a text input field where line breaks can be typed.

PROPERTY_HINT_EXPRESSION = 19

Enum: PropertyHint

Hints that a String property is an Expression.

PROPERTY_HINT_PLACEHOLDER_TEXT = 20

Enum: PropertyHint

Hints that a String property should show a placeholder text on its input field, if empty. The hint string is the placeholder text to use.

PROPERTY_HINT_COLOR_NO_ALPHA = 21

Enum: PropertyHint

Hints that a Color property should be edited without affecting its transparency (Color.a is not editable).

PROPERTY_HINT_OBJECT_ID = 22

Enum: PropertyHint

Hints that the property's value is an object encoded as object ID, with its type specified in the hint string. Used by the debugger.

PROPERTY_HINT_TYPE_STRING = 23

Enum: PropertyHint

If a property is String, hints that the property represents a particular type (class). This allows to select a type from the create dialog. The property will store the selected type as a string. If a property is Array, hints the editor how to show elements. The hint_string must encode nested types using ":" and "/". If a property is Dictionary, hints the editor how to show elements. The hint_string is the same as Array, with a ";" separating the key and value.

			# Array of elem_type.
			hint_string = "%d:" % [elem_type]
			hint_string = "%d/%d:%s" % [elem_type, elem_hint, elem_hint_string]
			# Two-dimensional array of elem_type (array of arrays of elem_type).
			hint_string = "%d:%d:" % [TYPE_ARRAY, elem_type]
			hint_string = "%d:%d/%d:%s" % [TYPE_ARRAY, elem_type, elem_hint, elem_hint_string]
			# Three-dimensional array of elem_type (array of arrays of arrays of elem_type).
			hint_string = "%d:%d:%d:" % [TYPE_ARRAY, TYPE_ARRAY, elem_type]
			hint_string = "%d:%d:%d/%d:%s" % [TYPE_ARRAY, TYPE_ARRAY, elem_type, elem_hint, elem_hint_string]
			
			// Array of elemType.
			hintString = $"{elemType:D}:";
			hintString = $"{elemType:}/{elemHint:D}:{elemHintString}";
			// Two-dimensional array of elemType (array of arrays of elemType).
			hintString = $"{Variant.Type.Array:D}:{elemType:D}:";
			hintString = $"{Variant.Type.Array:D}:{elemType:D}/{elemHint:D}:{elemHintString}";
			// Three-dimensional array of elemType (array of arrays of arrays of elemType).
			hintString = $"{Variant.Type.Array:D}:{Variant.Type.Array:D}:{elemType:D}:";
			hintString = $"{Variant.Type.Array:D}:{Variant.Type.Array:D}:{elemType:D}/{elemHint:D}:{elemHintString}";

Examples:

			hint_string = "%d:" % [TYPE_INT] # Array of integers.
			hint_string = "%d/%d:1,10,1" % [TYPE_INT, PROPERTY_HINT_RANGE] # Array of integers (in range from 1 to 10).
			hint_string = "%d/%d:Zero,One,Two" % [TYPE_INT, PROPERTY_HINT_ENUM] # Array of integers (an enum).
			hint_string = "%d/%d:Zero,One,Three:3,Six:6" % [TYPE_INT, PROPERTY_HINT_ENUM] # Array of integers (an enum).
			hint_string = "%d/%d:*.png" % [TYPE_STRING, PROPERTY_HINT_FILE] # Array of strings (file paths).
			hint_string = "%d/%d:Texture2D" % [TYPE_OBJECT, PROPERTY_HINT_RESOURCE_TYPE] # Array of textures.

			hint_string = "%d:%d:" % [TYPE_ARRAY, TYPE_FLOAT] # Two-dimensional array of floats.
			hint_string = "%d:%d/%d:" % [TYPE_ARRAY, TYPE_STRING, PROPERTY_HINT_MULTILINE_TEXT] # Two-dimensional array of multiline strings.
			hint_string = "%d:%d/%d:-1,1,0.1" % [TYPE_ARRAY, TYPE_FLOAT, PROPERTY_HINT_RANGE] # Two-dimensional array of floats (in range from -1 to 1).
			hint_string = "%d:%d/%d:Texture2D" % [TYPE_ARRAY, TYPE_OBJECT, PROPERTY_HINT_RESOURCE_TYPE] # Two-dimensional array of textures.
			
			hintString = $"{Variant.Type.Int:D}/{PropertyHint.Range:D}:1,10,1"; // Array of integers (in range from 1 to 10).
			hintString = $"{Variant.Type.Int:D}/{PropertyHint.Enum:D}:Zero,One,Two"; // Array of integers (an enum).
			hintString = $"{Variant.Type.Int:D}/{PropertyHint.Enum:D}:Zero,One,Three:3,Six:6"; // Array of integers (an enum).
			hintString = $"{Variant.Type.String:D}/{PropertyHint.File:D}:*.png"; // Array of strings (file paths).
			hintString = $"{Variant.Type.Object:D}/{PropertyHint.ResourceType:D}:Texture2D"; // Array of textures.

			hintString = $"{Variant.Type.Array:D}:{Variant.Type.Float:D}:"; // Two-dimensional array of floats.
			hintString = $"{Variant.Type.Array:D}:{Variant.Type.String:D}/{PropertyHint.MultilineText:D}:"; // Two-dimensional array of multiline strings.
			hintString = $"{Variant.Type.Array:D}:{Variant.Type.Float:D}/{PropertyHint.Range:D}:-1,1,0.1"; // Two-dimensional array of floats (in range from -1 to 1).
			hintString = $"{Variant.Type.Array:D}:{Variant.Type.Object:D}/{PropertyHint.ResourceType:D}:Texture2D"; // Two-dimensional array of textures.

Note: The trailing colon is required for properly detecting built-in types.

PROPERTY_HINT_NODE_PATH_TO_EDITED_NODE = 24

Enum: PropertyHint

Deprecated.

This hint is not used by the engine.

PROPERTY_HINT_OBJECT_TOO_BIG = 25

Enum: PropertyHint

Hints that an object is too big to be sent via the debugger.

PROPERTY_HINT_NODE_PATH_VALID_TYPES = 26

Enum: PropertyHint

Hints that the hint string specifies valid node types for property of type NodePath.

PROPERTY_HINT_SAVE_FILE = 27

Enum: PropertyHint

Hints that a String property is a path to a file. Editing it will show a file dialog for picking the path for the file to be saved at. The dialog has access to the project's directory. The hint string can be a set of filters with wildcards like "*.png,*.jpg". See also FileDialog.filters.

PROPERTY_HINT_GLOBAL_SAVE_FILE = 28

Enum: PropertyHint

Hints that a String property is a path to a file. Editing it will show a file dialog for picking the path for the file to be saved at. The dialog has access to the entire filesystem. The hint string can be a set of filters with wildcards like "*.png,*.jpg". See also FileDialog.filters.

PROPERTY_HINT_INT_IS_OBJECTID = 29

Enum: PropertyHint

Deprecated.

This hint is not used by the engine.

PROPERTY_HINT_INT_IS_POINTER = 30

Enum: PropertyHint

Hints that an int property is a pointer. Used by GDExtension.

PROPERTY_HINT_ARRAY_TYPE = 31

Enum: PropertyHint

Hints that a property is an Array with the stored type specified in the hint string. The hint string contains the type of the array (e.g. "String"). Use the hint string format from PROPERTY_HINT_TYPE_STRING for more control over the stored type.

PROPERTY_HINT_DICTIONARY_TYPE = 38

Enum: PropertyHint

Hints that a property is a Dictionary with the stored types specified in the hint string. The hint string contains the key and value types separated by a semicolon (e.g. "int;String"). Use the hint string format from PROPERTY_HINT_TYPE_STRING for more control over the stored types.

PROPERTY_HINT_LOCALE_ID = 32

Enum: PropertyHint

Hints that a string property is a locale code. Editing it will show a locale dialog for picking language and country.

PROPERTY_HINT_LOCALIZABLE_STRING = 33

Enum: PropertyHint

Hints that a dictionary property is string translation map. Dictionary keys are locale codes and, values are translated strings.

PROPERTY_HINT_NODE_TYPE = 34

Enum: PropertyHint

Hints that a property is an instance of a Node-derived type, optionally specified via the hint string (e.g. "Node2D"). Editing it will show a dialog for picking a node from the scene.

PROPERTY_HINT_HIDE_QUATERNION_EDIT = 35

Enum: PropertyHint

Hints that a quaternion property should disable the temporary euler editor.

PROPERTY_HINT_PASSWORD = 36

Enum: PropertyHint

Hints that a string property is a password, and every character is replaced with the secret character.

PROPERTY_HINT_TOOL_BUTTON = 39

Enum: PropertyHint

Hints that a Callable property should be displayed as a clickable button. When the button is pressed, the callable is called. The hint string specifies the button text and optionally an icon from the "EditorIcons" theme type.

			"Click me!" - A button with the text "Click me!" and the default "Callable" icon.
			"Click me!,ColorRect" - A button with the text "Click me!" and the "ColorRect" icon.

Note: A Callable cannot be properly serialized and stored in a file, so it is recommended to use PROPERTY_USAGE_EDITOR instead of PROPERTY_USAGE_DEFAULT.

PROPERTY_HINT_GROUP_ENABLE = 42

Enum: PropertyHint

Hints that a boolean property will enable the feature associated with the group that it occurs in. The property will be displayed as a checkbox on the group header. Only works within a group or subgroup. By default, disabling the property hides all properties in the group. Use the optional hint string "checkbox_only" to disable this behavior.

PROPERTY_HINT_INPUT_NAME = 43

Enum: PropertyHint

Hints that a String or StringName property is the name of an input action. This allows the selection of any action name from the Input Map in the Project Settings. The hint string may contain two options separated by commas: - If it contains "show_builtin", built-in input actions are included in the selection. - If it contains "loose_mode", loose mode is enabled. This allows inserting any action name even if it's not present in the input map.

PROPERTY_HINT_FILE_PATH = 44

Enum: PropertyHint

Like PROPERTY_HINT_FILE, but the property is stored as a raw path, not UID. That means the reference will be broken if you move the file. Consider using PROPERTY_HINT_FILE when possible.

PROPERTY_HINT_MAX = 45

Enum: PropertyHint

Represents the size of the PropertyHint enum.

PROPERTY_USAGE_NONE = 0

Enum: PropertyUsageFlags

The property is not stored, and does not display in the editor. This is the default for non-exported properties.

PROPERTY_USAGE_STORAGE = 2

Enum: PropertyUsageFlags

The property is serialized and saved in the scene file (default for exported properties).

PROPERTY_USAGE_EDITOR = 4

Enum: PropertyUsageFlags

The property is shown in the EditorInspector (default for exported properties).

PROPERTY_USAGE_INTERNAL = 8

Enum: PropertyUsageFlags

The property is excluded from the class reference.

PROPERTY_USAGE_CHECKABLE = 16

Enum: PropertyUsageFlags

The property can be checked in the EditorInspector.

PROPERTY_USAGE_CHECKED = 32

Enum: PropertyUsageFlags

The property is checked in the EditorInspector.

PROPERTY_USAGE_GROUP = 64

Enum: PropertyUsageFlags

Used to group properties together in the editor. See EditorInspector.

PROPERTY_USAGE_CATEGORY = 128

Enum: PropertyUsageFlags

Used to categorize properties together in the editor.

PROPERTY_USAGE_SUBGROUP = 256

Enum: PropertyUsageFlags

Used to group properties together in the editor in a subgroup (under a group). See EditorInspector.

PROPERTY_USAGE_CLASS_IS_BITFIELD = 512

Enum: PropertyUsageFlags

The property is a bitfield, i.e. it contains multiple flags represented as bits.

PROPERTY_USAGE_NO_INSTANCE_STATE = 1024

Enum: PropertyUsageFlags

The property does not save its state in PackedScene.

PROPERTY_USAGE_RESTART_IF_CHANGED = 2048

Enum: PropertyUsageFlags

Editing the property prompts the user for restarting the editor.

PROPERTY_USAGE_STORE_IF_NULL = 8192

Enum: PropertyUsageFlags

The property value of type Object will be stored even if its value is null.

PROPERTY_USAGE_UPDATE_ALL_IF_MODIFIED = 16384

Enum: PropertyUsageFlags

If this property is modified, all inspector fields will be refreshed.

PROPERTY_USAGE_SCRIPT_DEFAULT_VALUE = 32768

Enum: PropertyUsageFlags

Deprecated.

This flag is not used by the engine.

PROPERTY_USAGE_CLASS_IS_ENUM = 65536

Enum: PropertyUsageFlags

The property is a variable of enum type, i.e. it only takes named integer constants from its associated enumeration.

PROPERTY_USAGE_NIL_IS_VARIANT = 131072

Enum: PropertyUsageFlags

If property has nil as default value, its type will be Variant.

PROPERTY_USAGE_ARRAY = 262144

Enum: PropertyUsageFlags

The property is an array.

PROPERTY_USAGE_ALWAYS_DUPLICATE = 524288

Enum: PropertyUsageFlags

When duplicating a resource with Resource.duplicate(), and this flag is set on a property of that resource, the property should always be duplicated, regardless of the subresources bool parameter.

PROPERTY_USAGE_NEVER_DUPLICATE = 1048576

Enum: PropertyUsageFlags

When duplicating a resource with Resource.duplicate(), and this flag is set on a property of that resource, the property should never be duplicated, regardless of the subresources bool parameter.

PROPERTY_USAGE_HIGH_END_GFX = 2097152

Enum: PropertyUsageFlags

The property is only shown in the editor if modern renderers are supported (the Compatibility rendering method is excluded).

PROPERTY_USAGE_NODE_PATH_FROM_SCENE_ROOT = 4194304

Enum: PropertyUsageFlags

The NodePath property will always be relative to the scene's root. Mostly useful for local resources.

PROPERTY_USAGE_RESOURCE_NOT_PERSISTENT = 8388608

Enum: PropertyUsageFlags

Use when a resource is created on the fly, i.e. the getter will always return a different instance. ResourceSaver needs this information to properly save such resources.

PROPERTY_USAGE_KEYING_INCREMENTS = 16777216

Enum: PropertyUsageFlags

Inserting an animation key frame of this property will automatically increment the value, allowing to easily keyframe multiple values in a row.

PROPERTY_USAGE_DEFERRED_SET_RESOURCE = 33554432

Enum: PropertyUsageFlags

Deprecated.

This flag is not used by the engine.

PROPERTY_USAGE_EDITOR_INSTANTIATE_OBJECT = 67108864

Enum: PropertyUsageFlags

When this property is a Resource and base object is a Node, a resource instance will be automatically created whenever the node is created in the editor.

PROPERTY_USAGE_EDITOR_BASIC_SETTING = 134217728

Enum: PropertyUsageFlags

The property is considered a basic setting and will appear even when advanced mode is disabled. Used for project settings.

PROPERTY_USAGE_READ_ONLY = 268435456

Enum: PropertyUsageFlags

The property is read-only in the EditorInspector.

PROPERTY_USAGE_SECRET = 536870912

Enum: PropertyUsageFlags

An export preset property with this flag contains confidential information and is stored separately from the rest of the export preset configuration.

PROPERTY_USAGE_DEFAULT = 6

Enum: PropertyUsageFlags

Default usage (storage and editor).

PROPERTY_USAGE_NO_EDITOR = 2

Enum: PropertyUsageFlags

Default usage but without showing the property in the editor (storage).

METHOD_FLAG_NORMAL = 1

Enum: MethodFlags

Flag for a normal method.

METHOD_FLAG_EDITOR = 2

Enum: MethodFlags

Flag for an editor method.

METHOD_FLAG_CONST = 4

Enum: MethodFlags

Flag for a constant method.

METHOD_FLAG_VIRTUAL = 8

Enum: MethodFlags

Flag for a virtual method.

METHOD_FLAG_VARARG = 16

Enum: MethodFlags

Flag for a method with a variable number of arguments.

METHOD_FLAG_STATIC = 32

Enum: MethodFlags

Flag for a static method.

METHOD_FLAG_OBJECT_CORE = 64

Enum: MethodFlags

Used internally. Allows to not dump core virtual methods (such as Object._notification()) to the JSON API.

METHOD_FLAG_VIRTUAL_REQUIRED = 128

Enum: MethodFlags

Flag for a virtual method that is required. In GDScript, this flag is set for abstract functions.

METHOD_FLAGS_DEFAULT = 1

Enum: MethodFlags

Default method flags (normal).

TYPE_NIL = 0

Enum: Variant.Type

Variable is null.

TYPE_BOOL = 1

Enum: Variant.Type

Variable is of type bool.

TYPE_INT = 2

Enum: Variant.Type

Variable is of type int.

TYPE_FLOAT = 3

Enum: Variant.Type

Variable is of type float.

TYPE_STRING = 4

Enum: Variant.Type

Variable is of type String.

TYPE_VECTOR2 = 5

Enum: Variant.Type

Variable is of type Vector2.

TYPE_VECTOR2I = 6

Enum: Variant.Type

Variable is of type Vector2i.

TYPE_RECT2 = 7

Enum: Variant.Type

Variable is of type Rect2.

TYPE_RECT2I = 8

Enum: Variant.Type

Variable is of type Rect2i.

TYPE_VECTOR3 = 9

Enum: Variant.Type

Variable is of type Vector3.

TYPE_VECTOR3I = 10

Enum: Variant.Type

Variable is of type Vector3i.

TYPE_TRANSFORM2D = 11

Enum: Variant.Type

Variable is of type Transform2D.

TYPE_VECTOR4 = 12

Enum: Variant.Type

Variable is of type Vector4.

TYPE_VECTOR4I = 13

Enum: Variant.Type

Variable is of type Vector4i.

TYPE_PLANE = 14

Enum: Variant.Type

Variable is of type Plane.

TYPE_QUATERNION = 15

Enum: Variant.Type

Variable is of type Quaternion.

TYPE_AABB = 16

Enum: Variant.Type

Variable is of type AABB.

TYPE_BASIS = 17

Enum: Variant.Type

Variable is of type Basis.

TYPE_TRANSFORM3D = 18

Enum: Variant.Type

Variable is of type Transform3D.

TYPE_PROJECTION = 19

Enum: Variant.Type

Variable is of type Projection.

TYPE_COLOR = 20

Enum: Variant.Type

Variable is of type Color.

TYPE_STRING_NAME = 21

Enum: Variant.Type

Variable is of type StringName.

TYPE_NODE_PATH = 22

Enum: Variant.Type

Variable is of type NodePath.

TYPE_RID = 23

Enum: Variant.Type

Variable is of type RID.

TYPE_OBJECT = 24

Enum: Variant.Type

Variable is of type Object.

TYPE_CALLABLE = 25

Enum: Variant.Type

Variable is of type Callable.

TYPE_SIGNAL = 26

Enum: Variant.Type

Variable is of type Signal.

TYPE_DICTIONARY = 27

Enum: Variant.Type

Variable is of type Dictionary.

TYPE_ARRAY = 28

Enum: Variant.Type

Variable is of type Array.

TYPE_PACKED_BYTE_ARRAY = 29

Enum: Variant.Type

Variable is of type PackedByteArray.

TYPE_PACKED_INT32_ARRAY = 30

Enum: Variant.Type

Variable is of type PackedInt32Array.

TYPE_PACKED_INT64_ARRAY = 31

Enum: Variant.Type

Variable is of type PackedInt64Array.

TYPE_PACKED_STRING_ARRAY = 34

Enum: Variant.Type

Variable is of type PackedStringArray.

TYPE_PACKED_COLOR_ARRAY = 37

Enum: Variant.Type

Variable is of type PackedColorArray.

TYPE_STRUCT = 39

Enum: Variant.Type

Variable is of type Struct.

TYPE_MAX = 40

Enum: Variant.Type

Represents the size of the Variant.Type enum.

OP_EQUAL = 0

Enum: Variant.Operator

Equality operator (==).

OP_NOT_EQUAL = 1

Enum: Variant.Operator

Inequality operator (!=).

OP_LESS = 2

Enum: Variant.Operator

Less than operator (<).

OP_LESS_EQUAL = 3

Enum: Variant.Operator

Less than or equal operator (<=).

OP_GREATER = 4

Enum: Variant.Operator

Greater than operator (>).

OP_GREATER_EQUAL = 5

Enum: Variant.Operator

Greater than or equal operator (>=).

OP_ADD = 6

Enum: Variant.Operator

Addition operator (+).

OP_SUBTRACT = 7

Enum: Variant.Operator

Subtraction operator (-).

OP_MULTIPLY = 8

Enum: Variant.Operator

Multiplication operator (*).

OP_DIVIDE = 9

Enum: Variant.Operator

Division operator (/).

OP_NEGATE = 10

Enum: Variant.Operator

Unary negation operator (-).

OP_POSITIVE = 11

Enum: Variant.Operator

Unary plus operator (+).

OP_MODULE = 12

Enum: Variant.Operator

Remainder/modulo operator (%).

OP_POWER = 13

Enum: Variant.Operator

Power operator (**).

OP_SHIFT_LEFT = 14

Enum: Variant.Operator

Left shift operator (<<).

OP_SHIFT_RIGHT = 15

Enum: Variant.Operator

Right shift operator (>>).

OP_BIT_AND = 16

Enum: Variant.Operator

Bitwise AND operator (&).

OP_BIT_OR = 17

Enum: Variant.Operator

Bitwise OR operator (|).

OP_BIT_XOR = 18

Enum: Variant.Operator

Bitwise XOR operator (^).

OP_BIT_NEGATE = 19

Enum: Variant.Operator

Bitwise NOT operator (~).

OP_AND = 20

Enum: Variant.Operator

Logical AND operator (and or &&).

OP_OR = 21

Enum: Variant.Operator

Logical OR operator (or or ||).

OP_XOR = 22

Enum: Variant.Operator

Logical XOR operator (not implemented in GDScript).

OP_NOT = 23

Enum: Variant.Operator

Logical NOT operator (not or !).

OP_IN = 24

Enum: Variant.Operator

Logical IN operator (in).

OP_MAX = 25

Enum: Variant.Operator

Represents the size of the Variant.Operator enum.

Tutorials

Source revision 704b10a8e178
Connection interrupted. Reload×

Rejoining the server...

Rejoin failed... trying again in seconds.

Failed to rejoin.
Please retry or reload the page.

The session has been paused by the server.

Failed to resume the session.
Please retry or reload the page.