Module meta

Meta-information about Godot types, their properties and conversions between them.

Conversions between types

Godot representation

The library provides two traits FromGodot and ToGodot, which are used at the Rust <-> Godot boundary, both in user-defined functions (#[func]) and engine APIs (godot::classes module). Their to_godot() and from_godot() methods convert types from/to their closest possible Godot type (e.g. GString instead of Rust String). You usually don’t need to call these methods yourself, they are automatically invoked when passing objects to/from Godot.

Most often, the two traits appear in pairs, however there are cases where only one of the two is implemented. For example, &str implements ToGodot but not FromGodot. Additionally, GodotConvert acts as a supertrait of both FromGodot and ToGodot. Its sole purpose is to define the “closest possible Godot type” GodotConvert::Via.

For fallible conversions, you can use FromGodot::try_from_godot().

Variants

ToGodot and FromGodot also implement a conversion to/from Variant, which is the most versatile Godot type. This conversion is available via to_variant() and from_variant() methods. These methods are also available directly on Variant itself, via to(), try_to() and from() functions.

Class conversions

Godot classes exist in a hierarchy. In OOP, it is usually possible to represent pointers to derived objects as pointer to their bases. For conversions between base and derived class objects, you can use Gd methods cast(), try_cast() and upcast(). Upcasts are infallible.

Argument conversions

Rust does not support implicit conversions, however it has something very close: the impl Into<T> idiom, which can be used to convert “T-compatible” arguments into T. This library specializes this idea with two traits:

• AsArg<T> allows argument conversions from arguments into T. This is most interesting in the context of strings (so you can pass &str to a function expecting GString), but is generic to support e.g. array insertion.
• AsObjectArg<T> is a more specialized version of AsArg that is used for object arguments, i.e. Gd<T>.

Modules

error

Errors in the gdext library.

Structs

ClassName

Name of a class registered with Godot.

MethodInfo

Describes a method in Godot.

PropertyHintInfo

Info needed by Godot, for how to export a type to the editor.

PropertyInfo

Describes a property in Godot.

RefArg

Simple reference wrapper, used when passing arguments by-ref to Godot APIs.

Enums

ByRef

ByValue

Traits

ArgPassing

ArrayElement

Marker trait to identify types that can be stored in Array<T>.

AsArg

Implicit conversions for arguments passed to Godot APIs.

AsObjectArg

Objects that can be passed as arguments to Godot engine functions.

FromGodot

Defines the canonical conversion from Godot for a type.

GodotConvert

Indicates that a type can be passed to/from Godot, either directly or through an intermediate “via” type.

GodotType

Type that is directly representable in the engine.

InParamTuple

Represents a parameter list that is received from some external location (usually Godot).

OutParamTuple

Represents a parameter list that is used to call some external code.

PackedArrayElement

Marker trait to identify types that can be stored in Packed*Array types.

ParamTuple

Represents a parameter list as Rust tuple where each tuple element is one parameter.

ParamType

Implemented for all parameter types T that are allowed to receive impl AsArg<T>.

ToGodot

Defines the canonical conversion to Godot for a type.

UniformObjectDeref

Unifies dereferencing of user and engine classes, as &T/&mut T and Gd<T>.