Module godot::builtin

Built-in types like Vector2, GString and Variant.

Background on the design of vector algebra types

The basic vector algebra types like Vector2, Matrix4 and Quaternion are re-implemented here, with an API similar to that in the Godot engine itself. There are other approaches, but they all have their disadvantages:

• We could invoke API methods from the engine. The implementations could be generated, but it is slower and prevents inlining.

• We could re-export types from an existing vector algebra crate, like glam. This removes the duplication, but it would create a strong dependency on a volatile API outside our control. The gdnative crate started out this way, using types from euclid, but found it impractical. Moreover, the API would not match Godot’s own, which would make porting from GDScript (slightly) harder.

• We could opaquely wrap types from an existing vector algebra crate. This protects users of gdextension from changes in the wrapped crate. However, direct field access using .x, .y, .z is no longer possible. Instead of v.y += a; you would have to write v.set_y(v.get_y() + a);. (A union could be used to add these fields in the public API, but would make every field access unsafe, which is also not great.)

• We could re-export types from the mint crate, which was explicitly designed to solve this problem. However, it falls short because operator overloading would become impossible.

Modules

• array
  Specialized types related to arrays.
• dictionary
  Specialized types related to dictionaries.
• math
  Math-related functions and traits like ApproxEq.
• meta
  Meta-information about variant types, properties and class names.
• strings
  Specialized types related to Godot’s various string implementations.

Macros

• array
  Constructs Array literals, similar to Rust’s standard vec! macro.
• dict
  Constructs Dictionary literals, close to Godot’s own syntax.
• real
  A macro to coerce float-literals into the real type.
• reals
  Array of reals.
• swizzle
  Access vector components in different order.
• varray
  Constructs VariantArray literals, similar to Rust’s standard vec! macro.

Structs

• Aabb
  Axis-aligned bounding box in 3D space.
• Array
  Godot’s Array type.
• Basis
  A 3x3 matrix, typically used as an orthogonal basis for Transform3D.
• Callable
  A Callable represents a function in Godot.
• Color
  Color built-in type, in floating-point RGBA format.
• ColorHsv
  HSVA floating-number Color representation.
• Dictionary
  Godot’s Dictionary type.
• GString
  Godot’s reference counted string type.
• NodePath
  A pre-parsed scene tree path.
• PackedByteArray
  Implements Godot’s PackedByteArray type, which is an efficient array of u8s.
• PackedColorArray
  Implements Godot’s PackedColorArray type, which is an efficient array of Colors.
• PackedFloat32Array
  Implements Godot’s PackedFloat32Array type, which is an efficient array of f32s.
• PackedFloat64Array
  Implements Godot’s PackedFloat64Array type, which is an efficient array of f64s.
• PackedInt32Array
  Implements Godot’s PackedInt32Array type, which is an efficient array of i32s.
• PackedInt64Array
  Implements Godot’s PackedInt64Array type, which is an efficient array of i64s.
• PackedStringArray
  Implements Godot’s PackedStringArray type, which is an efficient array of GStrings.
• PackedVector2Array
  Implements Godot’s PackedVector2Array type, which is an efficient array of Vector2s.
• PackedVector3Array
  Implements Godot’s PackedVector3Array type, which is an efficient array of Vector3s.
• PackedVector4Array
  Implements Godot’s PackedVector4Array type, which is an efficient array of Vector4s.
• Plane
  3D plane in Hessian normal form.
• Projection
  A 4x4 matrix used for 3D projective transformations.
• Quaternion
• Rect2
  2D axis-aligned bounding box.
• Rect2i
  2D axis-aligned integer bounding box.
• Signal
  A Signal represents a signal of an Object instance in Godot.
• StringName
  A string optimized for unique names.
• Transform2D
  Affine 2D transform (2x3 matrix).
• Transform3D
  Affine 3D transform (3x4 matrix).
• Variant
  Godot variant type, able to store a variety of different types.
• Vector2
  Vector used for 2D math using floating point coordinates.
• Vector2i
  Vector used for 2D math using integer coordinates.
• Vector3
  Vector used for 3D math using floating point coordinates.
• Vector3i
  Vector used for 3D math using integer coordinates.
• Vector4
  Vector used for 4D math using floating point coordinates.
• Vector4i
  Vector used for 4D math using integer coordinates.

Enums

• ColorChannelOrder
• EulerOrder
  The ordering used to interpret a set of euler angles as extrinsic rotations.
• ProjectionEye
  The eye to create a projection for, when creating a projection adjusted for head-mounted displays.
• ProjectionPlane
  A projection’s clipping plane.
• RectSide
  The side of a Rect2 or Rect2i.
• Rid
  A RID (“resource ID”) is an opaque handle that refers to a Godot Resource.
• VariantOperator
• VariantType
• Vector2Axis
  Enumerates the axes in a Vector2.
• Vector3Axis
  Enumerates the axes in a Vector3.
• Vector4Axis
  Enumerates the axes in a Vector4.

Traits

• RealConv
  Convenience conversion between real and f32/f64.
• RustCallable
  Represents a custom callable object defined in Rust.
• ToVector
  Trait that allows conversion from tuples to vectors.

Type Aliases

• VariantArray
  A Godot Array without an assigned type.
• real
  Floating point type used for many structs and functions in Godot.