Struct gdnative_bindings::RoomManager
source · pub struct RoomManager { /* private fields */ }
Expand description
core class RoomManager
inherits Spatial
(manually managed).
This class has related types in the room_manager
module.
Official documentation
See the documentation of this class in the Godot engine’s official documentation. The method descriptions are generated from it and typically contain code samples in GDScript, not Rust.
Memory management
Non-reference-counted objects, such as the ones of this type, are usually owned by the engine.
RoomManager
is a reference-only type. Persistent references can
only exist in the unsafe Ref<RoomManager>
form.
In the cases where Rust code owns an object of this type, for example if the object was just
created on the Rust side and not passed to the engine yet, ownership should be either given
to the engine or the object must be manually destroyed using Ref::free
, or Ref::queue_free
if it is a Node
.
Class hierarchy
RoomManager inherits methods from:
Safety
All types in the Godot API have interior mutability in Rust parlance.
To enforce that the official thread-safety guidelines are
followed, the typestate pattern is used in the Ref
and TRef
smart pointers,
and the Instance
API. The typestate Ownership
in these types tracks whether
ownership is unique, shared, or exclusive to the current thread. For more information,
see the type-level documentation on Ref
.
Implementations§
source§impl RoomManager
impl RoomManager
Constants
pub const PVS_MODE_DISABLED: i64 = 0i64
pub const PVS_MODE_PARTIAL: i64 = 1i64
pub const PVS_MODE_FULL: i64 = 2i64
source§impl RoomManager
impl RoomManager
sourcepub fn new() -> Ref<Self, Unique>
pub fn new() -> Ref<Self, Unique>
Creates a new instance of this object.
Because this type is not reference counted, the lifetime of the returned object is not automatically managed.
Immediately after creation, the object is owned by the caller, and can be
passed to the engine (in which case the engine will be responsible for
destroying the object) or destroyed manually using Ref::free
, or preferably
Ref::queue_free
if it is a Node
.
sourcepub fn debug_sprawl(&self) -> bool
pub fn debug_sprawl(&self) -> bool
Large objects can ‘sprawl’ over (be present in) more than one room. It can be useful to visualize which objects are sprawling outside the current room. Toggling this setting turns this debug view on and off.
sourcepub fn default_portal_margin(&self) -> f64
pub fn default_portal_margin(&self) -> f64
Usually we don’t want objects that only just cross a boundary into an adjacent Room
to sprawl into that room. To prevent this, each Portal
has an extra margin, or tolerance zone where objects can enter without sprawling to a neighbouring room.
In most cases you can set this here for all portals. It is possible to override the margin for each portal.
sourcepub fn gameplay_monitor_enabled(&self) -> bool
pub fn gameplay_monitor_enabled(&self) -> bool
When using a partial or full PVS, the gameplay monitor allows you to receive callbacks when roaming objects or rooms enter or exit the gameplay area. The gameplay area is defined as either the primary, or secondary PVS.
These callbacks allow you to, for example, reduce processing for objects that are far from the player, or turn on and off AI.
You can either choose to receive callbacks as notifications through the _notification
function, or as signals.
NOTIFICATION_ENTER_GAMEPLAY
NOTIFICATION_EXIT_GAMEPLAY
Signals: "gameplay_entered"
, "gameplay_exited"
sourcepub fn merge_meshes(&self) -> bool
pub fn merge_meshes(&self) -> bool
If enabled, the system will attempt to merge similar meshes (particularly in terms of materials) within Room
s during conversion. This can significantly reduce the number of drawcalls and state changes required during rendering, albeit at a cost of reduced culling granularity.
Note: This operates at runtime during the conversion process, and will only operate on exported or running projects, in order to prevent accidental alteration to the scene and loss of data.
sourcepub fn overlap_warning_threshold(&self) -> i64
pub fn overlap_warning_threshold(&self) -> i64
When converting rooms, the editor will warn you if overlap is detected between rooms. Overlap can interfere with determining the room that cameras and objects are within. A small amount can be acceptable, depending on your level. Here you can alter the threshold at which the editor warning appears. There are no other side effects.
sourcepub fn portal_depth_limit(&self) -> i64
pub fn portal_depth_limit(&self) -> i64
Portal rendering is recursive - each time a portal is seen through an earlier portal there is some cost. For this reason, and to prevent the possibility of infinite loops, this setting provides a hard limit on the recursion depth.
Note: This value is unused when using Full
PVS mode.
sourcepub fn preview_camera_path(&self) -> NodePath
pub fn preview_camera_path(&self) -> NodePath
sourcepub fn pvs_mode(&self) -> PvsMode
pub fn pvs_mode(&self) -> PvsMode
Optionally during conversion the potentially visible set (PVS) of rooms that are potentially visible from each room can be calculated. This can be used either to aid in dynamic portal culling, or to totally replace portal culling.
In Full
PVS Mode, all objects within the potentially visible rooms will be frustum culled, and rendered if they are within the view frustum.
sourcepub fn roaming_expansion_margin(&self) -> f64
pub fn roaming_expansion_margin(&self) -> f64
In order to reduce processing for roaming objects, an expansion is applied to their AABB as they move. This expanded volume is used to calculate which rooms the roaming object is within. If the object’s exact AABB is still within this expanded volume on the next move, there is no need to reprocess the object, which can save considerable CPU. The downside is that if the expansion is too much, the object may end up unexpectedly sprawling into neighbouring rooms and showing up where it might otherwise be culled. In order to balance roaming performance against culling accuracy, this expansion margin can be customized by the user. It will typically depend on your room and object sizes, and movement speeds. The default value should work reasonably in most circumstances.
sourcepub fn room_simplify(&self) -> f64
pub fn room_simplify(&self) -> f64
During the conversion process, the geometry of objects within Room
s, or a custom specified manual bound, are used to generate a convex hull bound.
This convex hull is required in the visibility system, and is used for many purposes. Most importantly, it is used to decide whether the Camera
(or an object) is within a Room
. The convex hull generating algorithm is good, but occasionally it can create too many (or too few) planes to give a good representation of the room volume.
The room_simplify
value can be used to gain fine control over this process. It determines how similar planes can be for them to be considered the same (and duplicates removed). The value can be set between 0 (no simplification) and 1 (maximum simplification).
The value set here is the default for all rooms, but individual rooms can override this value if desired.
The room convex hulls are shown as a wireframe in the editor.
sourcepub fn roomlist_path(&self) -> NodePath
pub fn roomlist_path(&self) -> NodePath
sourcepub fn show_margins(&self) -> bool
pub fn show_margins(&self) -> bool
Shows the Portal
margins when the portal gizmo is used in the editor.
sourcepub fn use_secondary_pvs(&self) -> bool
pub fn use_secondary_pvs(&self) -> bool
When receiving gameplay callbacks when objects enter and exit gameplay, the gameplay area can be defined by either the primary PVS (potentially visible set) of Room
s, or the secondary PVS (the primary PVS and their neighbouring Room
s).
Sometimes using the larger gameplay area of the secondary PVS may be preferable.
sourcepub fn rooms_clear(&self)
pub fn rooms_clear(&self)
This function clears all converted data from the room graph. Use this before unloading a level, when transitioning from level to level, or returning to a main menu.
sourcepub fn rooms_convert(&self)
pub fn rooms_convert(&self)
This is the most important function in the whole portal culling system. Without it, the system cannot function.
First it goes through every Room
that is a child of the room list
node (and RoomGroup
s within) and converts and adds it to the room graph
.
This works for both Room
nodes, and Spatial
nodes that follow a special naming convention. They should begin with the prefix ‘Room’, followed by the name you wish to give the room, e.g. ‘Room_lounge’. This will automatically convert such Spatial
s to Room
nodes for you. This is useful if you want to build you entire room system in e.g. Blender, and reimport multiple times as you work on the level.
The conversion will try to assign VisualInstance
s that are children and grandchildren of the Room
to the room. These should be given a suitable portal mode
(see the CullInstance
documentation). The default portal mode
is STATIC
- objects which are not expected to move while the level is played, which will typically be most objects.
The conversion will usually use the geometry of these VisualInstance
s (and the Portal
s) to calculate a convex hull bound for the room. These bounds will be shown in the editor with a wireframe. Alternatively you can specify a manual custom bound for any room, see the Room
documentation.
By definition, Camera
s within a room can see everything else within the room (that is one advantage to using convex hulls). However, in order to see from one room into adjacent rooms, you must place Portal
s, which represent openings that the camera can see through, like windows and doors.
Portal
s are really just specialized MeshInstance
s. In fact you will usually first create a portal by creating a MeshInstance
, especially a plane
mesh instance. You would move the plane in the editor to cover a window or doorway, with the front face pointing outward from the room. To let the conversion process know you want this mesh to be a portal, again we use a special naming convention. MeshInstance
s to be converted to a Portal
should start with the prefix ‘Portal’.
You now have a choice - you can leave the name as ‘Portal’_ and allow the system to automatically detect the nearest Room
to link. In most cases this will work fine.
An alternative method is to specify the Room
to link to manually, appending a suffix to the portal name, which should be the name of the room you intend to link to. For example ‘Portal_lounge’ will attempt to link to the room named ‘Room_lounge’.
There is a special case here - Godot does not allow two nodes to share the same name. What if you want to manually have more than one portal leading into the same room? Surely they will need to both be called, e.g. ‘Portal_lounge’?
The solution is a wildcard character. After the room name, if you use the character ‘*’, this character and anything following it will be ignored. So you can use for example ‘Portal_lounge*0’, ‘Portal_lounge*1’ etc.
Note that Portal
s that have already been converted to Portal
nodes (rather than MeshInstance
s) still need to follow the same naming convention, as they will be relinked each time during conversion.
It is recommended that you only place objects in rooms that are desired to stay within those rooms - i.e. portal mode
s STATIC
or DYNAMIC
(not crossing portals). GLOBAL
and ROAMING
objects are best placed in another part of the scene tree, to avoid confusion. See CullInstance
for a full description of portal modes.
sourcepub fn rooms_get_active(&self) -> bool
pub fn rooms_get_active(&self) -> bool
Switches the portal culling system on and off.
It is important to note that when portal culling is active, it is responsible for all the 3d culling. Some editor visual debugging helpers may not be available when active, so switching the active flag is intended to be used to ensure your Room
/ Portal
layout works within the editor.
Switching to active
will have no effect when the room graph
is unloaded (the rooms have not yet been converted).
Note: For efficiency, the portal system is designed to work with only the core visual object types. In particular, only nodes derived from VisualInstance
are expected to show when the system is active.
sourcepub fn rooms_set_active(&self, active: bool)
pub fn rooms_set_active(&self, active: bool)
Switches the portal culling system on and off.
It is important to note that when portal culling is active, it is responsible for all the 3d culling. Some editor visual debugging helpers may not be available when active, so switching the active flag is intended to be used to ensure your Room
/ Portal
layout works within the editor.
Switching to active
will have no effect when the room graph
is unloaded (the rooms have not yet been converted).
Note: For efficiency, the portal system is designed to work with only the core visual object types. In particular, only nodes derived from VisualInstance
are expected to show when the system is active.
sourcepub fn set_debug_sprawl(&self, debug_sprawl: bool)
pub fn set_debug_sprawl(&self, debug_sprawl: bool)
Large objects can ‘sprawl’ over (be present in) more than one room. It can be useful to visualize which objects are sprawling outside the current room. Toggling this setting turns this debug view on and off.
sourcepub fn set_default_portal_margin(&self, default_portal_margin: f64)
pub fn set_default_portal_margin(&self, default_portal_margin: f64)
Usually we don’t want objects that only just cross a boundary into an adjacent Room
to sprawl into that room. To prevent this, each Portal
has an extra margin, or tolerance zone where objects can enter without sprawling to a neighbouring room.
In most cases you can set this here for all portals. It is possible to override the margin for each portal.
sourcepub fn set_gameplay_monitor_enabled(&self, gameplay_monitor: bool)
pub fn set_gameplay_monitor_enabled(&self, gameplay_monitor: bool)
When using a partial or full PVS, the gameplay monitor allows you to receive callbacks when roaming objects or rooms enter or exit the gameplay area. The gameplay area is defined as either the primary, or secondary PVS.
These callbacks allow you to, for example, reduce processing for objects that are far from the player, or turn on and off AI.
You can either choose to receive callbacks as notifications through the _notification
function, or as signals.
NOTIFICATION_ENTER_GAMEPLAY
NOTIFICATION_EXIT_GAMEPLAY
Signals: "gameplay_entered"
, "gameplay_exited"
sourcepub fn set_merge_meshes(&self, merge_meshes: bool)
pub fn set_merge_meshes(&self, merge_meshes: bool)
If enabled, the system will attempt to merge similar meshes (particularly in terms of materials) within Room
s during conversion. This can significantly reduce the number of drawcalls and state changes required during rendering, albeit at a cost of reduced culling granularity.
Note: This operates at runtime during the conversion process, and will only operate on exported or running projects, in order to prevent accidental alteration to the scene and loss of data.
sourcepub fn set_overlap_warning_threshold(&self, overlap_warning_threshold: i64)
pub fn set_overlap_warning_threshold(&self, overlap_warning_threshold: i64)
When converting rooms, the editor will warn you if overlap is detected between rooms. Overlap can interfere with determining the room that cameras and objects are within. A small amount can be acceptable, depending on your level. Here you can alter the threshold at which the editor warning appears. There are no other side effects.
sourcepub fn set_portal_depth_limit(&self, portal_depth_limit: i64)
pub fn set_portal_depth_limit(&self, portal_depth_limit: i64)
Portal rendering is recursive - each time a portal is seen through an earlier portal there is some cost. For this reason, and to prevent the possibility of infinite loops, this setting provides a hard limit on the recursion depth.
Note: This value is unused when using Full
PVS mode.
sourcepub fn set_preview_camera_path(&self, preview_camera: impl Into<NodePath>)
pub fn set_preview_camera_path(&self, preview_camera: impl Into<NodePath>)
sourcepub fn set_pvs_mode(&self, pvs_mode: i64)
pub fn set_pvs_mode(&self, pvs_mode: i64)
Optionally during conversion the potentially visible set (PVS) of rooms that are potentially visible from each room can be calculated. This can be used either to aid in dynamic portal culling, or to totally replace portal culling.
In Full
PVS Mode, all objects within the potentially visible rooms will be frustum culled, and rendered if they are within the view frustum.
sourcepub fn set_roaming_expansion_margin(&self, roaming_expansion_margin: f64)
pub fn set_roaming_expansion_margin(&self, roaming_expansion_margin: f64)
In order to reduce processing for roaming objects, an expansion is applied to their AABB as they move. This expanded volume is used to calculate which rooms the roaming object is within. If the object’s exact AABB is still within this expanded volume on the next move, there is no need to reprocess the object, which can save considerable CPU. The downside is that if the expansion is too much, the object may end up unexpectedly sprawling into neighbouring rooms and showing up where it might otherwise be culled. In order to balance roaming performance against culling accuracy, this expansion margin can be customized by the user. It will typically depend on your room and object sizes, and movement speeds. The default value should work reasonably in most circumstances.
sourcepub fn set_room_simplify(&self, room_simplify: f64)
pub fn set_room_simplify(&self, room_simplify: f64)
During the conversion process, the geometry of objects within Room
s, or a custom specified manual bound, are used to generate a convex hull bound.
This convex hull is required in the visibility system, and is used for many purposes. Most importantly, it is used to decide whether the Camera
(or an object) is within a Room
. The convex hull generating algorithm is good, but occasionally it can create too many (or too few) planes to give a good representation of the room volume.
The room_simplify
value can be used to gain fine control over this process. It determines how similar planes can be for them to be considered the same (and duplicates removed). The value can be set between 0 (no simplification) and 1 (maximum simplification).
The value set here is the default for all rooms, but individual rooms can override this value if desired.
The room convex hulls are shown as a wireframe in the editor.
sourcepub fn set_roomlist_path(&self, p_path: impl Into<NodePath>)
pub fn set_roomlist_path(&self, p_path: impl Into<NodePath>)
sourcepub fn set_show_margins(&self, show_margins: bool)
pub fn set_show_margins(&self, show_margins: bool)
Shows the Portal
margins when the portal gizmo is used in the editor.
sourcepub fn set_use_secondary_pvs(&self, use_secondary_pvs: bool)
pub fn set_use_secondary_pvs(&self, use_secondary_pvs: bool)
When receiving gameplay callbacks when objects enter and exit gameplay, the gameplay area can be defined by either the primary PVS (potentially visible set) of Room
s, or the secondary PVS (the primary PVS and their neighbouring Room
s).
Sometimes using the larger gameplay area of the secondary PVS may be preferable.
Methods from Deref<Target = Spatial>§
pub const NOTIFICATION_ENTER_WORLD: i64 = 41i64
pub const NOTIFICATION_EXIT_WORLD: i64 = 42i64
pub const NOTIFICATION_VISIBILITY_CHANGED: i64 = 43i64
pub const NOTIFICATION_ENTER_GAMEPLAY: i64 = 45i64
pub const NOTIFICATION_EXIT_GAMEPLAY: i64 = 46i64
pub const NOTIFICATION_TRANSFORM_CHANGED: i64 = 2_000i64
sourcepub fn force_update_transform(&self)
pub fn force_update_transform(&self)
Forces the transform to update. Transform changes in physics are not instant for performance reasons. Transforms are accumulated and then set. Use this if you need an up-to-date transform when doing physics operations.
sourcepub fn gizmo(&self) -> Option<Ref<SpatialGizmo, Shared>>
pub fn gizmo(&self) -> Option<Ref<SpatialGizmo, Shared>>
The SpatialGizmo
for this node. Used for example in EditorSpatialGizmo
as custom visualization and editing handles in Editor.
sourcepub fn global_rotation(&self) -> Vector3
pub fn global_rotation(&self) -> Vector3
Rotation part of the global transformation in radians, specified in terms of YXZ-Euler angles in the format (X angle, Y angle, Z angle).
Note: In the mathematical sense, rotation is a matrix and not a vector. The three Euler angles, which are the three independent parameters of the Euler-angle parametrization of the rotation matrix, are stored in a Vector3
data structure not because the rotation is a vector, but only because Vector3
exists as a convenient data-structure to store 3 floating-point numbers. Therefore, applying affine operations on the rotation “vector” is not meaningful.
sourcepub fn global_transform(&self) -> Transform
pub fn global_transform(&self) -> Transform
World space (global) Transform
of this node.
sourcepub fn get_global_transform_interpolated(&self) -> Transform
pub fn get_global_transform_interpolated(&self) -> Transform
When using physics interpolation, there will be circumstances in which you want to know the interpolated (displayed) transform of a node rather than the standard transform (which may only be accurate to the most recent physics tick).
This is particularly important for frame-based operations that take place in [Node._process
][Node::_process], rather than [Node._physics_process
][Node::_physics_process]. Examples include Camera
s focusing on a node, or finding where to fire lasers from on a frame rather than physics tick.
sourcepub fn global_translation(&self) -> Vector3
pub fn global_translation(&self) -> Vector3
Global position of this node. This is equivalent to global_transform.origin
.
sourcepub fn rotation(&self) -> Vector3
pub fn rotation(&self) -> Vector3
Rotation part of the local transformation in radians, specified in terms of YXZ-Euler angles in the format (X angle, Y angle, Z angle).
Note: In the mathematical sense, rotation is a matrix and not a vector. The three Euler angles, which are the three independent parameters of the Euler-angle parametrization of the rotation matrix, are stored in a Vector3
data structure not because the rotation is a vector, but only because Vector3
exists as a convenient data-structure to store 3 floating-point numbers. Therefore, applying affine operations on the rotation “vector” is not meaningful.
sourcepub fn rotation_degrees(&self) -> Vector3
pub fn rotation_degrees(&self) -> Vector3
Rotation part of the local transformation in degrees, specified in terms of YXZ-Euler angles in the format (X angle, Y angle, Z angle).
sourcepub fn scale(&self) -> Vector3
pub fn scale(&self) -> Vector3
Scale part of the local transformation. Note: Mixed negative scales in 3D are not decomposable from the transformation matrix. Due to the way scale is represented with transformation matrices in Godot, the scale values will either be all positive or all negative.
sourcepub fn transform(&self) -> Transform
pub fn transform(&self) -> Transform
Local space Transform
of this node, with respect to the parent node.
sourcepub fn translation(&self) -> Vector3
pub fn translation(&self) -> Vector3
Local translation of this node.
sourcepub fn global_rotate(&self, axis: Vector3, angle: f64)
pub fn global_rotate(&self, axis: Vector3, angle: f64)
Rotates the global (world) transformation around axis, a unit Vector3
, by specified angle in radians. The rotation axis is in global coordinate system.
sourcepub fn global_scale(&self, scale: Vector3)
pub fn global_scale(&self, scale: Vector3)
Scales the global (world) transformation by the given Vector3
scale factors.
sourcepub fn global_translate(&self, offset: Vector3)
pub fn global_translate(&self, offset: Vector3)
Moves the global (world) transformation by Vector3
offset. The offset is in global coordinate system.
sourcepub fn is_local_transform_notification_enabled(&self) -> bool
pub fn is_local_transform_notification_enabled(&self) -> bool
Returns whether node notifies about its local transformation changes. Spatial
will not propagate this by default.
sourcepub fn is_scale_disabled(&self) -> bool
pub fn is_scale_disabled(&self) -> bool
Returns whether this node uses a scale of (1, 1, 1)
or its local transformation scale.
sourcepub fn is_set_as_toplevel(&self) -> bool
pub fn is_set_as_toplevel(&self) -> bool
Returns whether this node is set as Toplevel, that is whether it ignores its parent nodes transformations.
sourcepub fn is_transform_notification_enabled(&self) -> bool
pub fn is_transform_notification_enabled(&self) -> bool
Returns whether the node notifies about its global and local transformation changes. Spatial
will not propagate this by default.
sourcepub fn is_visible(&self) -> bool
pub fn is_visible(&self) -> bool
If true
, this node is drawn. The node is only visible if all of its antecedents are visible as well (in other words, is_visible_in_tree
must return true
).
sourcepub fn is_visible_in_tree(&self) -> bool
pub fn is_visible_in_tree(&self) -> bool
Returns true
if the node is present in the SceneTree
, its [visible
][Self::visible] property is true
and all its antecedents are also visible. If any antecedent is hidden, this node will not be visible in the scene tree.
sourcepub fn look_at(&self, target: Vector3, up: Vector3)
pub fn look_at(&self, target: Vector3, up: Vector3)
Rotates the node so that the local forward axis (-Z) points toward the target
position.
The local up axis (+Y) points as close to the up
vector as possible while staying perpendicular to the local forward axis. The resulting transform is orthogonal, and the scale is preserved. Non-uniform scaling may not work correctly.
The target
position cannot be the same as the node’s position, the up
vector cannot be zero, and the direction from the node’s position to the target
vector cannot be parallel to the up
vector.
Operations take place in global space.
sourcepub fn look_at_from_position(
&self,
position: Vector3,
target: Vector3,
up: Vector3
)
pub fn look_at_from_position(
&self,
position: Vector3,
target: Vector3,
up: Vector3
)
Moves the node to the specified position
, and then rotates itself to point toward the target
as per look_at
. Operations take place in global space.
sourcepub fn orthonormalize(&self)
pub fn orthonormalize(&self)
Resets this node’s transformations (like scale, skew and taper) preserving its rotation and translation by performing Gram-Schmidt orthonormalization on this node’s Transform
.
sourcepub fn rotate(&self, axis: Vector3, angle: f64)
pub fn rotate(&self, axis: Vector3, angle: f64)
Rotates the local transformation around axis, a unit Vector3
, by specified angle in radians.
sourcepub fn rotate_object_local(&self, axis: Vector3, angle: f64)
pub fn rotate_object_local(&self, axis: Vector3, angle: f64)
Rotates the local transformation around axis, a unit Vector3
, by specified angle in radians. The rotation axis is in object-local coordinate system.
sourcepub fn rotate_x(&self, angle: f64)
pub fn rotate_x(&self, angle: f64)
Rotates the local transformation around the X axis by angle in radians.
sourcepub fn rotate_y(&self, angle: f64)
pub fn rotate_y(&self, angle: f64)
Rotates the local transformation around the Y axis by angle in radians.
sourcepub fn rotate_z(&self, angle: f64)
pub fn rotate_z(&self, angle: f64)
Rotates the local transformation around the Z axis by angle in radians.
sourcepub fn scale_object_local(&self, scale: Vector3)
pub fn scale_object_local(&self, scale: Vector3)
Scales the local transformation by given 3D scale factors in object-local coordinate system.
sourcepub fn set_as_toplevel(&self, enable: bool)
pub fn set_as_toplevel(&self, enable: bool)
Makes the node ignore its parents transformations. Node transformations are only in global space.
sourcepub fn set_disable_scale(&self, disable: bool)
pub fn set_disable_scale(&self, disable: bool)
Sets whether the node uses a scale of (1, 1, 1)
or its local transformation scale. Changes to the local transformation scale are preserved.
sourcepub fn set_gizmo(&self, gizmo: impl AsArg<SpatialGizmo>)
pub fn set_gizmo(&self, gizmo: impl AsArg<SpatialGizmo>)
The SpatialGizmo
for this node. Used for example in EditorSpatialGizmo
as custom visualization and editing handles in Editor.
sourcepub fn set_global_rotation(&self, radians: Vector3)
pub fn set_global_rotation(&self, radians: Vector3)
Rotation part of the global transformation in radians, specified in terms of YXZ-Euler angles in the format (X angle, Y angle, Z angle).
Note: In the mathematical sense, rotation is a matrix and not a vector. The three Euler angles, which are the three independent parameters of the Euler-angle parametrization of the rotation matrix, are stored in a Vector3
data structure not because the rotation is a vector, but only because Vector3
exists as a convenient data-structure to store 3 floating-point numbers. Therefore, applying affine operations on the rotation “vector” is not meaningful.
sourcepub fn set_global_transform(&self, global: Transform)
pub fn set_global_transform(&self, global: Transform)
World space (global) Transform
of this node.
sourcepub fn set_global_translation(&self, translation: Vector3)
pub fn set_global_translation(&self, translation: Vector3)
Global position of this node. This is equivalent to global_transform.origin
.
sourcepub fn set_identity(&self)
pub fn set_identity(&self)
Reset all transformations for this node (sets its Transform
to the identity matrix).
sourcepub fn set_ignore_transform_notification(&self, enabled: bool)
pub fn set_ignore_transform_notification(&self, enabled: bool)
Sets whether the node ignores notification that its transformation (global or local) changed.
sourcepub fn set_notify_local_transform(&self, enable: bool)
pub fn set_notify_local_transform(&self, enable: bool)
Sets whether the node notifies about its local transformation changes. Spatial
will not propagate this by default.
sourcepub fn set_notify_transform(&self, enable: bool)
pub fn set_notify_transform(&self, enable: bool)
Sets whether the node notifies about its global and local transformation changes. Spatial
will not propagate this by default, unless it is in the editor context and it has a valid gizmo.
sourcepub fn set_rotation(&self, euler: Vector3)
pub fn set_rotation(&self, euler: Vector3)
Rotation part of the local transformation in radians, specified in terms of YXZ-Euler angles in the format (X angle, Y angle, Z angle).
Note: In the mathematical sense, rotation is a matrix and not a vector. The three Euler angles, which are the three independent parameters of the Euler-angle parametrization of the rotation matrix, are stored in a Vector3
data structure not because the rotation is a vector, but only because Vector3
exists as a convenient data-structure to store 3 floating-point numbers. Therefore, applying affine operations on the rotation “vector” is not meaningful.
sourcepub fn set_rotation_degrees(&self, euler_degrees: Vector3)
pub fn set_rotation_degrees(&self, euler_degrees: Vector3)
Rotation part of the local transformation in degrees, specified in terms of YXZ-Euler angles in the format (X angle, Y angle, Z angle).
sourcepub fn set_scale(&self, scale: Vector3)
pub fn set_scale(&self, scale: Vector3)
Scale part of the local transformation. Note: Mixed negative scales in 3D are not decomposable from the transformation matrix. Due to the way scale is represented with transformation matrices in Godot, the scale values will either be all positive or all negative.
sourcepub fn set_transform(&self, local: Transform)
pub fn set_transform(&self, local: Transform)
Local space Transform
of this node, with respect to the parent node.
sourcepub fn set_translation(&self, translation: Vector3)
pub fn set_translation(&self, translation: Vector3)
Local translation of this node.
sourcepub fn set_visible(&self, visible: bool)
pub fn set_visible(&self, visible: bool)
If true
, this node is drawn. The node is only visible if all of its antecedents are visible as well (in other words, is_visible_in_tree
must return true
).
sourcepub fn to_global(&self, local_point: Vector3) -> Vector3
pub fn to_global(&self, local_point: Vector3) -> Vector3
Transforms local_point
from this node’s local space to world space.
sourcepub fn to_local(&self, global_point: Vector3) -> Vector3
pub fn to_local(&self, global_point: Vector3) -> Vector3
Transforms global_point
from world space to this node’s local space.
sourcepub fn translate(&self, offset: Vector3)
pub fn translate(&self, offset: Vector3)
Changes the node’s position by the given offset Vector3
.
Note that the translation offset
is affected by the node’s scale, so if scaled by e.g. (10, 1, 1)
, a translation by an offset of (2, 0, 0)
would actually add 20 (2 * 10
) to the X coordinate.
sourcepub fn translate_object_local(&self, offset: Vector3)
pub fn translate_object_local(&self, offset: Vector3)
Changes the node’s position by the given offset Vector3
in local space.
sourcepub fn update_gizmo(&self)
pub fn update_gizmo(&self)
Updates the SpatialGizmo
of this node.
Methods from Deref<Target = Node>§
pub const PAUSE_MODE_INHERIT: i64 = 0i64
pub const PHYSICS_INTERPOLATION_MODE_INHERIT: i64 = 0i64
pub const DUPLICATE_SIGNALS: i64 = 1i64
pub const PAUSE_MODE_STOP: i64 = 1i64
pub const PHYSICS_INTERPOLATION_MODE_OFF: i64 = 1i64
pub const DUPLICATE_GROUPS: i64 = 2i64
pub const PAUSE_MODE_PROCESS: i64 = 2i64
pub const PHYSICS_INTERPOLATION_MODE_ON: i64 = 2i64
pub const DUPLICATE_SCRIPTS: i64 = 4i64
pub const DUPLICATE_USE_INSTANCING: i64 = 8i64
pub const NOTIFICATION_ENTER_TREE: i64 = 10i64
pub const NOTIFICATION_EXIT_TREE: i64 = 11i64
pub const NOTIFICATION_MOVED_IN_PARENT: i64 = 12i64
pub const NOTIFICATION_READY: i64 = 13i64
pub const NOTIFICATION_PAUSED: i64 = 14i64
pub const NOTIFICATION_UNPAUSED: i64 = 15i64
pub const NOTIFICATION_PHYSICS_PROCESS: i64 = 16i64
pub const NOTIFICATION_PROCESS: i64 = 17i64
pub const NOTIFICATION_PARENTED: i64 = 18i64
pub const NOTIFICATION_UNPARENTED: i64 = 19i64
pub const NOTIFICATION_INSTANCED: i64 = 20i64
pub const NOTIFICATION_DRAG_BEGIN: i64 = 21i64
pub const NOTIFICATION_DRAG_END: i64 = 22i64
pub const NOTIFICATION_PATH_CHANGED: i64 = 23i64
pub const NOTIFICATION_INTERNAL_PROCESS: i64 = 25i64
pub const NOTIFICATION_INTERNAL_PHYSICS_PROCESS: i64 = 26i64
pub const NOTIFICATION_POST_ENTER_TREE: i64 = 27i64
pub const NOTIFICATION_RESET_PHYSICS_INTERPOLATION: i64 = 28i64
pub const NOTIFICATION_WM_MOUSE_ENTER: i64 = 1_002i64
pub const NOTIFICATION_WM_MOUSE_EXIT: i64 = 1_003i64
pub const NOTIFICATION_WM_FOCUS_IN: i64 = 1_004i64
pub const NOTIFICATION_WM_FOCUS_OUT: i64 = 1_005i64
pub const NOTIFICATION_WM_QUIT_REQUEST: i64 = 1_006i64
pub const NOTIFICATION_WM_GO_BACK_REQUEST: i64 = 1_007i64
pub const NOTIFICATION_WM_UNFOCUS_REQUEST: i64 = 1_008i64
pub const NOTIFICATION_OS_MEMORY_WARNING: i64 = 1_009i64
pub const NOTIFICATION_TRANSLATION_CHANGED: i64 = 1_010i64
pub const NOTIFICATION_WM_ABOUT: i64 = 1_011i64
pub const NOTIFICATION_CRASH: i64 = 1_012i64
pub const NOTIFICATION_OS_IME_UPDATE: i64 = 1_013i64
pub const NOTIFICATION_APP_RESUMED: i64 = 1_014i64
pub const NOTIFICATION_APP_PAUSED: i64 = 1_015i64
sourcepub fn add_child(&self, node: impl AsArg<Node>, legible_unique_name: bool)
pub fn add_child(&self, node: impl AsArg<Node>, legible_unique_name: bool)
Sample code is GDScript unless otherwise noted.
Adds a child node. Nodes can have any number of children, but every child must have a unique name. Child nodes are automatically deleted when the parent node is deleted, so an entire scene can be removed by deleting its topmost node.
If legible_unique_name
is true
, the child node will have a human-readable name based on the name of the node being instanced instead of its type.
Note: If the child node already has a parent, the function will fail. Use remove_child
first to remove the node from its current parent. For example:
if child_node.get_parent():
child_node.get_parent().remove_child(child_node)
add_child(child_node)
Note: If you want a child to be persisted to a PackedScene
, you must set owner
in addition to calling add_child
. This is typically relevant for tool scripts and editor plugins. If add_child
is called without setting owner
, the newly added Node
will not be visible in the scene tree, though it will be visible in the 2D/3D view.
Default Arguments
legible_unique_name
-false
sourcepub fn add_child_below_node(
&self,
node: impl AsArg<Node>,
child_node: impl AsArg<Node>,
legible_unique_name: bool
)
pub fn add_child_below_node(
&self,
node: impl AsArg<Node>,
child_node: impl AsArg<Node>,
legible_unique_name: bool
)
Adds child_node
as a child. The child is placed below the given node
in the list of children.
If legible_unique_name
is true
, the child node will have a human-readable name based on the name of the node being instanced instead of its type.
Default Arguments
legible_unique_name
-false
sourcepub fn add_to_group(&self, group: impl Into<GodotString>, persistent: bool)
pub fn add_to_group(&self, group: impl Into<GodotString>, persistent: bool)
Adds the node to a group. Groups are helpers to name and organize a subset of nodes, for example “enemies” or “collectables”. A node can be in any number of groups. Nodes can be assigned a group at any time, but will not be added until they are inside the scene tree (see is_inside_tree
). See notes in the description, and the group methods in SceneTree
.
The persistent
option is used when packing node to PackedScene
and saving to file. Non-persistent groups aren’t stored.
Note: For performance reasons, the order of node groups is not guaranteed. The order of node groups should not be relied upon as it can vary across project runs.
Default Arguments
persistent
-false
sourcepub fn can_process(&self) -> bool
pub fn can_process(&self) -> bool
Returns true
if the node can process while the scene tree is paused (see pause_mode
). Always returns true
if the scene tree is not paused, and false
if the node is not in the tree.
sourcepub fn create_tween(&self) -> Option<Ref<SceneTreeTween, Shared>>
pub fn create_tween(&self) -> Option<Ref<SceneTreeTween, Shared>>
Sample code is GDScript unless otherwise noted.
Creates a new SceneTreeTween
and binds it to this node. This is equivalent of doing:
get_tree().create_tween().bind_node(self)
sourcepub fn duplicate(&self, flags: i64) -> Option<Ref<Node, Shared>>
pub fn duplicate(&self, flags: i64) -> Option<Ref<Node, Shared>>
Duplicates the node, returning a new node.
You can fine-tune the behavior using the flags
(see DuplicateFlags
).
Note: It will not work properly if the node contains a script with constructor arguments (i.e. needs to supply arguments to [Object._init
][Object::_init] method). In that case, the node will be duplicated without a script.
Default Arguments
flags
-15
sourcepub fn find_node(
&self,
mask: impl Into<GodotString>,
recursive: bool,
owned: bool
) -> Option<Ref<Node, Shared>>
pub fn find_node(
&self,
mask: impl Into<GodotString>,
recursive: bool,
owned: bool
) -> Option<Ref<Node, Shared>>
Finds a descendant of this node whose name matches mask
as in [String.match
][GodotString::match] (i.e. case-sensitive, but "*"
matches zero or more characters and "?"
matches any single character except "."
). Returns null
if no matching Node
is found.
Note: It does not match against the full path, just against individual node names.
If owned
is true
, this method only finds nodes whose owner is this node. This is especially important for scenes instantiated through a script, because those scenes don’t have an owner.
Note: As this method walks through all the descendants of the node, it is the slowest way to get a reference to another node. Whenever possible, consider using get_node
instead. To avoid using find_node
too often, consider caching the node reference into a variable.
Default Arguments
recursive
-true
owned
-true
sourcepub fn find_parent(
&self,
mask: impl Into<GodotString>
) -> Option<Ref<Node, Shared>>
pub fn find_parent(
&self,
mask: impl Into<GodotString>
) -> Option<Ref<Node, Shared>>
Finds the first parent of the current node whose name matches mask
as in [String.match
][GodotString::match] (i.e. case-sensitive, but "*"
matches zero or more characters and "?"
matches any single character except "."
).
Note: It does not match against the full path, just against individual node names.
Note: As this method walks upwards in the scene tree, it can be slow in large, deeply nested scene trees. Whenever possible, consider using get_node
instead. To avoid using find_parent
too often, consider caching the node reference into a variable.
sourcepub fn get_child(&self, idx: i64) -> Option<Ref<Node, Shared>>
pub fn get_child(&self, idx: i64) -> Option<Ref<Node, Shared>>
Returns a child node by its index (see get_child_count
). This method is often used for iterating all children of a node.
To access a child node via its name, use get_node
.
sourcepub fn get_child_count(&self) -> i64
pub fn get_child_count(&self) -> i64
Returns the number of child nodes.
sourcepub fn get_children(&self) -> VariantArray
pub fn get_children(&self) -> VariantArray
Returns an array of references to node’s children.
sourcepub fn custom_multiplayer(&self) -> Option<Ref<MultiplayerAPI, Shared>>
pub fn custom_multiplayer(&self) -> Option<Ref<MultiplayerAPI, Shared>>
The override to the default MultiplayerAPI
. Set to null
to use the default SceneTree
one.
sourcepub fn filename(&self) -> GodotString
pub fn filename(&self) -> GodotString
sourcepub fn get_groups(&self) -> VariantArray
pub fn get_groups(&self) -> VariantArray
Sample code is GDScript unless otherwise noted.
Returns an array listing the groups that the node is a member of.
Note: For performance reasons, the order of node groups is not guaranteed. The order of node groups should not be relied upon as it can vary across project runs.
Note: The engine uses some group names internally (all starting with an underscore). To avoid conflicts with internal groups, do not add custom groups whose name starts with an underscore. To exclude internal groups while looping over get_groups
, use the following snippet:
# Stores the node's non-internal groups only (as an array of Strings).
var non_internal_groups = []
for group in get_groups():
if not group.begins_with("_"):
non_internal_groups.push_back(group)
sourcepub fn get_index(&self) -> i64
pub fn get_index(&self) -> i64
Returns the node’s index, i.e. its position among the siblings of its parent.
sourcepub fn multiplayer(&self) -> Option<Ref<MultiplayerAPI, Shared>>
pub fn multiplayer(&self) -> Option<Ref<MultiplayerAPI, Shared>>
The MultiplayerAPI
instance associated with this node. Either the custom_multiplayer
, or the default SceneTree one (if inside tree).
sourcepub fn name(&self) -> GodotString
pub fn name(&self) -> GodotString
The name of the node. This name is unique among the siblings (other child nodes from the same parent). When set to an existing name, the node will be automatically renamed.
Note: Auto-generated names might include the @
character, which is reserved for unique names when using add_child
. When setting the name manually, any @
will be removed.
sourcepub fn get_network_master(&self) -> i64
pub fn get_network_master(&self) -> i64
Returns the peer ID of the network master for this node. See set_network_master
.
sourcepub fn get_node(&self, path: impl Into<NodePath>) -> Option<Ref<Node, Shared>>
pub fn get_node(&self, path: impl Into<NodePath>) -> Option<Ref<Node, Shared>>
Sample code is GDScript unless otherwise noted.
Fetches a node. The NodePath
can be either a relative path (from the current node) or an absolute path (in the scene tree) to a node. If the path does not exist, null
is returned and an error is logged. Attempts to access methods on the return value will result in an “Attempt to call is_inside_tree
).
Example: Assume your current node is Character and the following tree:
/root
/root/Character
/root/Character/Sword
/root/Character/Backpack/Dagger
/root/MyGame
/root/Swamp/Alligator
/root/Swamp/Mosquito
/root/Swamp/Goblin
Possible paths are:
get_node("Sword")
get_node("Backpack/Dagger")
get_node("../Swamp/Alligator")
get_node("/root/MyGame")
sourcepub fn get_node_and_resource(&self, path: impl Into<NodePath>) -> VariantArray
pub fn get_node_and_resource(&self, path: impl Into<NodePath>) -> VariantArray
Sample code is GDScript unless otherwise noted.
Fetches a node and one of its resources as specified by the NodePath
’s subname (e.g. Area2D/CollisionShape2D:shape
). If several nested resources are specified in the NodePath
, the last one will be fetched.
The return value is an array of size 3: the first index points to the Node
(or null
if not found), the second index points to the Resource
(or null
if not found), and the third index is the remaining NodePath
, if any.
For example, assuming that Area2D/CollisionShape2D
is a valid node and that its shape
property has been assigned a RectangleShape2D
resource, one could have this kind of output:
print(get_node_and_resource("Area2D/CollisionShape2D")) # [[CollisionShape2D:1161], Null, ]
print(get_node_and_resource("Area2D/CollisionShape2D:shape")) # [[CollisionShape2D:1161], [RectangleShape2D:1156], ]
print(get_node_and_resource("Area2D/CollisionShape2D:shape:extents")) # [[CollisionShape2D:1161], [RectangleShape2D:1156], :extents]
sourcepub fn owner(&self) -> Option<Ref<Node, Shared>>
pub fn owner(&self) -> Option<Ref<Node, Shared>>
The node owner. A node can have any other node as owner (as long as it is a valid parent, grandparent, etc. ascending in the tree). When saving a node (using PackedScene
), all the nodes it owns will be saved with it. This allows for the creation of complex SceneTree
s, with instancing and subinstancing.
Note: If you want a child to be persisted to a PackedScene
, you must set owner
in addition to calling add_child
. This is typically relevant for tool scripts and editor plugins. If add_child
is called without setting owner
, the newly added Node
will not be visible in the scene tree, though it will be visible in the 2D/3D view.
sourcepub fn get_parent(&self) -> Option<Ref<Node, Shared>>
pub fn get_parent(&self) -> Option<Ref<Node, Shared>>
Returns the parent node of the current node, or null
if the node lacks a parent.
sourcepub fn get_path(&self) -> NodePath
pub fn get_path(&self) -> NodePath
Returns the absolute path of the current node. This only works if the current node is inside the scene tree (see is_inside_tree
).
sourcepub fn get_path_to(&self, node: impl AsArg<Node>) -> NodePath
pub fn get_path_to(&self, node: impl AsArg<Node>) -> NodePath
Returns the relative NodePath
from this node to the specified node
. Both nodes must be in the same scene or the function will fail.
sourcepub fn pause_mode(&self) -> PauseMode
pub fn pause_mode(&self) -> PauseMode
Pause mode. How the node will behave if the SceneTree
is paused.
sourcepub fn physics_interpolation_mode(&self) -> PhysicsInterpolationMode
pub fn physics_interpolation_mode(&self) -> PhysicsInterpolationMode
Allows enabling or disabling physics interpolation per node, offering a finer grain of control than turning physics interpolation on and off globally.
Note: This can be especially useful for Camera
s, where custom interpolation can sometimes give superior results.
sourcepub fn get_physics_process_delta_time(&self) -> f64
pub fn get_physics_process_delta_time(&self) -> f64
Returns the time elapsed (in seconds) since the last physics-bound frame (see [_physics_process
][Self::_physics_process]). This is always a constant value in physics processing unless the frames per second is changed via Engine.iterations_per_second
.
sourcepub fn get_position_in_parent(&self) -> i64
pub fn get_position_in_parent(&self) -> i64
Returns the node’s order in the scene tree branch. For example, if called on the first child node the position is 0
.
sourcepub fn get_process_delta_time(&self) -> f64
pub fn get_process_delta_time(&self) -> f64
Returns the time elapsed (in seconds) since the last process callback. This value may vary from frame to frame.
sourcepub fn process_priority(&self) -> i64
pub fn process_priority(&self) -> i64
The node’s priority in the execution order of the enabled processing callbacks (i.e. NOTIFICATION_PROCESS
, NOTIFICATION_PHYSICS_PROCESS
and their internal counterparts). Nodes whose process priority value is lower will have their processing callbacks executed first.
sourcepub fn get_scene_instance_load_placeholder(&self) -> bool
pub fn get_scene_instance_load_placeholder(&self) -> bool
Returns true
if this is an instance load placeholder. See InstancePlaceholder
.
sourcepub fn get_tree(&self) -> Option<Ref<SceneTree, Shared>>
pub fn get_tree(&self) -> Option<Ref<SceneTree, Shared>>
Returns the SceneTree
that contains this node.
sourcepub fn has_node(&self, path: impl Into<NodePath>) -> bool
pub fn has_node(&self, path: impl Into<NodePath>) -> bool
Returns true
if the node that the NodePath
points to exists.
sourcepub fn has_node_and_resource(&self, path: impl Into<NodePath>) -> bool
pub fn has_node_and_resource(&self, path: impl Into<NodePath>) -> bool
sourcepub fn is_a_parent_of(&self, node: impl AsArg<Node>) -> bool
pub fn is_a_parent_of(&self, node: impl AsArg<Node>) -> bool
Returns true
if the given node is a direct or indirect child of the current node.
sourcepub fn is_displayed_folded(&self) -> bool
pub fn is_displayed_folded(&self) -> bool
Returns true
if the node is folded (collapsed) in the Scene dock.
sourcepub fn is_greater_than(&self, node: impl AsArg<Node>) -> bool
pub fn is_greater_than(&self, node: impl AsArg<Node>) -> bool
Returns true
if the given node occurs later in the scene hierarchy than the current node.
sourcepub fn is_in_group(&self, group: impl Into<GodotString>) -> bool
pub fn is_in_group(&self, group: impl Into<GodotString>) -> bool
Returns true
if this node is in the specified group. See notes in the description, and the group methods in SceneTree
.
sourcepub fn is_inside_tree(&self) -> bool
pub fn is_inside_tree(&self) -> bool
Returns true
if this node is currently inside a SceneTree
.
sourcepub fn is_network_master(&self) -> bool
pub fn is_network_master(&self) -> bool
Returns true
if the local system is the master of this node.
sourcepub fn is_physics_interpolated(&self) -> bool
pub fn is_physics_interpolated(&self) -> bool
Returns true
if the physics interpolated flag is set for this Node (see physics_interpolation_mode
).
Note: Interpolation will only be active if both the flag is set and physics interpolation is enabled within the SceneTree
. This can be tested using is_physics_interpolated_and_enabled
.
sourcepub fn is_physics_interpolated_and_enabled(&self) -> bool
pub fn is_physics_interpolated_and_enabled(&self) -> bool
Returns true
if physics interpolation is enabled (see physics_interpolation_mode
) and enabled in the SceneTree
.
This is a convenience version of is_physics_interpolated
that also checks whether physics interpolation is enabled globally.
See [SceneTree.physics_interpolation
][SceneTree::physics_interpolation] and [member ProjectSettings.physics/common/physics_interpolation].
sourcepub fn is_physics_processing(&self) -> bool
pub fn is_physics_processing(&self) -> bool
Returns true
if physics processing is enabled (see set_physics_process
).
sourcepub fn is_physics_processing_internal(&self) -> bool
pub fn is_physics_processing_internal(&self) -> bool
Returns true
if internal physics processing is enabled (see set_physics_process_internal
).
sourcepub fn is_processing(&self) -> bool
pub fn is_processing(&self) -> bool
Returns true
if processing is enabled (see set_process
).
sourcepub fn is_processing_input(&self) -> bool
pub fn is_processing_input(&self) -> bool
Returns true
if the node is processing input (see set_process_input
).
sourcepub fn is_processing_internal(&self) -> bool
pub fn is_processing_internal(&self) -> bool
Returns true
if internal processing is enabled (see set_process_internal
).
sourcepub fn is_processing_unhandled_input(&self) -> bool
pub fn is_processing_unhandled_input(&self) -> bool
Returns true
if the node is processing unhandled input (see set_process_unhandled_input
).
sourcepub fn is_processing_unhandled_key_input(&self) -> bool
pub fn is_processing_unhandled_key_input(&self) -> bool
Returns true
if the node is processing unhandled key input (see set_process_unhandled_key_input
).
sourcepub fn is_unique_name_in_owner(&self) -> bool
pub fn is_unique_name_in_owner(&self) -> bool
Sets this node’s name as a unique name in its owner
. This allows the node to be accessed as %Name
instead of the full path, from any node within that scene.
If another node with the same owner already had that name declared as unique, that other node’s name will no longer be set as having a unique name.
sourcepub fn move_child(&self, child_node: impl AsArg<Node>, to_position: i64)
pub fn move_child(&self, child_node: impl AsArg<Node>, to_position: i64)
Moves a child node to a different position (order) among the other children. Since calls, signals, etc are performed by tree order, changing the order of children nodes may be useful.
sourcepub fn print_stray_nodes(&self)
pub fn print_stray_nodes(&self)
Prints all stray nodes (nodes outside the SceneTree
). Used for debugging. Works only in debug builds.
sourcepub fn print_tree(&self)
pub fn print_tree(&self)
Sample code is GDScript unless otherwise noted.
Prints the tree to stdout. Used mainly for debugging purposes. This version displays the path relative to the current node, and is good for copy/pasting into the get_node
function.
Example output:
TheGame
TheGame/Menu
TheGame/Menu/Label
TheGame/Menu/Camera2D
TheGame/SplashScreen
TheGame/SplashScreen/Camera2D
sourcepub fn print_tree_pretty(&self)
pub fn print_tree_pretty(&self)
Sample code is GDScript unless otherwise noted.
Similar to print_tree
, this prints the tree to stdout. This version displays a more graphical representation similar to what is displayed in the scene inspector. It is useful for inspecting larger trees.
Example output:
┖╴TheGame
┠╴Menu
┃ ┠╴Label
┃ ┖╴Camera2D
┖╴SplashScreen
┖╴Camera2D
sourcepub fn propagate_call(
&self,
method: impl Into<GodotString>,
args: VariantArray,
parent_first: bool
)
pub fn propagate_call(
&self,
method: impl Into<GodotString>,
args: VariantArray,
parent_first: bool
)
Calls the given method (if present) with the arguments given in args
on this node and recursively on all its children. If the parent_first
argument is true
, the method will be called on the current node first, then on all its children. If parent_first
is false
, the children will be called first.
Default Arguments
args
-[ ]
parent_first
-false
sourcepub fn propagate_notification(&self, what: i64)
pub fn propagate_notification(&self, what: i64)
Notifies the current node and all its children recursively by calling Object.notification
on all of them.
sourcepub fn queue_free(&self)
pub fn queue_free(&self)
Queues a node for deletion at the end of the current frame. When deleted, all of its child nodes will be deleted as well. This method ensures it’s safe to delete the node, contrary to [Object.free
][Object::free]. Use Object.is_queued_for_deletion
to check whether a node will be deleted at the end of the frame.
Important: If you have a variable pointing to a node, it will not be assigned to null
once the node is freed. Instead, it will point to a previously freed instance and you should validate it with [method @GDScript.is_instance_valid] before attempting to call its methods or access its properties.
sourcepub fn raise(&self)
pub fn raise(&self)
Moves this node to the bottom of parent node’s children hierarchy. This is often useful in GUIs (Control
nodes), because their order of drawing depends on their order in the tree. The top Node is drawn first, then any siblings below the top Node in the hierarchy are successively drawn on top of it. After using raise
, a Control will be drawn on top of its siblings.
sourcepub fn remove_and_skip(&self)
pub fn remove_and_skip(&self)
Removes a node and sets all its children as children of the parent node (if it exists). All event subscriptions that pass by the removed node will be unsubscribed.
sourcepub fn remove_child(&self, node: impl AsArg<Node>)
pub fn remove_child(&self, node: impl AsArg<Node>)
sourcepub fn remove_from_group(&self, group: impl Into<GodotString>)
pub fn remove_from_group(&self, group: impl Into<GodotString>)
Removes a node from a group. See notes in the description, and the group methods in SceneTree
.
sourcepub fn replace_by(&self, node: impl AsArg<Node>, keep_data: bool)
pub fn replace_by(&self, node: impl AsArg<Node>, keep_data: bool)
Replaces a node in a scene by the given one. Subscriptions that pass through this node will be lost.
Note: The given node will become the new parent of any child nodes that the replaced node had.
Note: The replaced node is not automatically freed, so you either need to keep it in a variable for later use or free it using [Object.free
][Object::free].
Default Arguments
keep_data
-false
sourcepub fn request_ready(&self)
pub fn request_ready(&self)
Requests that _ready
be called again. Note that the method won’t be called immediately, but is scheduled for when the node is added to the scene tree again (see [_ready
][Self::_ready]). _ready
is called only for the node which requested it, which means that you need to request ready for each child if you want them to call _ready
too (in which case, _ready
will be called in the same order as it would normally).
sourcepub fn reset_physics_interpolation(&self)
pub fn reset_physics_interpolation(&self)
When physics interpolation is active, moving a node to a radically different transform (such as placement within a level) can result in a visible glitch as the object is rendered moving from the old to new position over the physics tick.
This glitch can be prevented by calling reset_physics_interpolation
, which temporarily turns off interpolation until the physics tick is complete.
NOTIFICATION_RESET_PHYSICS_INTERPOLATION
will be received by the node and all children recursively.
Note: This function should be called after moving the node, rather than before.
sourcepub fn rpc(&self, method: impl Into<GodotString>, varargs: &[Variant]) -> Variant
pub fn rpc(&self, method: impl Into<GodotString>, varargs: &[Variant]) -> Variant
Sends a remote procedure call request for the given method
to peers on the network (and locally), optionally sending all additional arguments as arguments to the method called by the RPC. The call request will only be received by nodes with the same NodePath
, including the exact same node name. Behaviour depends on the RPC configuration for the given method, see rpc_config
. Methods are not exposed to RPCs by default. See also rset
and rset_config
for properties. Returns null
.
Note: You can only safely use RPCs on clients after you received the connected_to_server
signal from the SceneTree
. You also need to keep track of the connection state, either by the SceneTree
signals like server_disconnected
or by checking SceneTree.network_peer.get_connection_status() == CONNECTION_CONNECTED
.
sourcepub fn rpc_config(&self, method: impl Into<GodotString>, mode: i64)
pub fn rpc_config(&self, method: impl Into<GodotString>, mode: i64)
Changes the RPC mode for the given method
to the given mode
. See [enum MultiplayerAPI.RPCMode]. An alternative is annotating methods and properties with the corresponding keywords (remote
, master
, puppet
, remotesync
, mastersync
, puppetsync
). By default, methods are not exposed to networking (and RPCs). See also rset
and rset_config
for properties.
sourcepub fn rpc_id(
&self,
peer_id: i64,
method: impl Into<GodotString>,
varargs: &[Variant]
) -> Variant
pub fn rpc_id(
&self,
peer_id: i64,
method: impl Into<GodotString>,
varargs: &[Variant]
) -> Variant
Sends a rpc
to a specific peer identified by peer_id
(see NetworkedMultiplayerPeer.set_target_peer
). Returns null
.
sourcepub fn rpc_unreliable(
&self,
method: impl Into<GodotString>,
varargs: &[Variant]
) -> Variant
pub fn rpc_unreliable(
&self,
method: impl Into<GodotString>,
varargs: &[Variant]
) -> Variant
Sends a rpc
using an unreliable protocol. Returns null
.
sourcepub fn rpc_unreliable_id(
&self,
peer_id: i64,
method: impl Into<GodotString>,
varargs: &[Variant]
) -> Variant
pub fn rpc_unreliable_id(
&self,
peer_id: i64,
method: impl Into<GodotString>,
varargs: &[Variant]
) -> Variant
Sends a rpc
to a specific peer identified by peer_id
using an unreliable protocol (see NetworkedMultiplayerPeer.set_target_peer
). Returns null
.
sourcepub fn rset(&self, property: impl Into<GodotString>, value: impl OwnedToVariant)
pub fn rset(&self, property: impl Into<GodotString>, value: impl OwnedToVariant)
Remotely changes a property’s value on other peers (and locally). Behaviour depends on the RPC configuration for the given property, see rset_config
. See also rpc
for RPCs for methods, most information applies to this method as well.
sourcepub fn rset_config(&self, property: impl Into<GodotString>, mode: i64)
pub fn rset_config(&self, property: impl Into<GodotString>, mode: i64)
Changes the RPC mode for the given property
to the given mode
. See [enum MultiplayerAPI.RPCMode]. An alternative is annotating methods and properties with the corresponding keywords (remote
, master
, puppet
, remotesync
, mastersync
, puppetsync
). By default, properties are not exposed to networking (and RPCs). See also rpc
and rpc_config
for methods.
sourcepub fn rset_id(
&self,
peer_id: i64,
property: impl Into<GodotString>,
value: impl OwnedToVariant
)
pub fn rset_id(
&self,
peer_id: i64,
property: impl Into<GodotString>,
value: impl OwnedToVariant
)
Remotely changes the property’s value on a specific peer identified by peer_id
(see NetworkedMultiplayerPeer.set_target_peer
).
sourcepub fn rset_unreliable(
&self,
property: impl Into<GodotString>,
value: impl OwnedToVariant
)
pub fn rset_unreliable(
&self,
property: impl Into<GodotString>,
value: impl OwnedToVariant
)
Remotely changes the property’s value on other peers (and locally) using an unreliable protocol.
sourcepub fn rset_unreliable_id(
&self,
peer_id: i64,
property: impl Into<GodotString>,
value: impl OwnedToVariant
)
pub fn rset_unreliable_id(
&self,
peer_id: i64,
property: impl Into<GodotString>,
value: impl OwnedToVariant
)
Remotely changes property’s value on a specific peer identified by peer_id
using an unreliable protocol (see NetworkedMultiplayerPeer.set_target_peer
).
sourcepub fn set_custom_multiplayer(&self, api: impl AsArg<MultiplayerAPI>)
pub fn set_custom_multiplayer(&self, api: impl AsArg<MultiplayerAPI>)
The override to the default MultiplayerAPI
. Set to null
to use the default SceneTree
one.
sourcepub fn set_display_folded(&self, fold: bool)
pub fn set_display_folded(&self, fold: bool)
Sets the folded state of the node in the Scene dock.
sourcepub fn set_filename(&self, filename: impl Into<GodotString>)
pub fn set_filename(&self, filename: impl Into<GodotString>)
sourcepub fn set_name(&self, name: impl Into<GodotString>)
pub fn set_name(&self, name: impl Into<GodotString>)
The name of the node. This name is unique among the siblings (other child nodes from the same parent). When set to an existing name, the node will be automatically renamed.
Note: Auto-generated names might include the @
character, which is reserved for unique names when using add_child
. When setting the name manually, any @
will be removed.
sourcepub fn set_network_master(&self, id: i64, recursive: bool)
pub fn set_network_master(&self, id: i64, recursive: bool)
Sets the node’s network master to the peer with the given peer ID. The network master is the peer that has authority over the node on the network. Useful in conjunction with the master
and puppet
keywords. Inherited from the parent node by default, which ultimately defaults to peer ID 1 (the server). If recursive
, the given peer is recursively set as the master for all children of this node.
Default Arguments
recursive
-true
sourcepub fn set_owner(&self, owner: impl AsArg<Node>)
pub fn set_owner(&self, owner: impl AsArg<Node>)
The node owner. A node can have any other node as owner (as long as it is a valid parent, grandparent, etc. ascending in the tree). When saving a node (using PackedScene
), all the nodes it owns will be saved with it. This allows for the creation of complex SceneTree
s, with instancing and subinstancing.
Note: If you want a child to be persisted to a PackedScene
, you must set owner
in addition to calling add_child
. This is typically relevant for tool scripts and editor plugins. If add_child
is called without setting owner
, the newly added Node
will not be visible in the scene tree, though it will be visible in the 2D/3D view.
sourcepub fn set_pause_mode(&self, mode: i64)
pub fn set_pause_mode(&self, mode: i64)
Pause mode. How the node will behave if the SceneTree
is paused.
sourcepub fn set_physics_interpolation_mode(&self, mode: i64)
pub fn set_physics_interpolation_mode(&self, mode: i64)
Allows enabling or disabling physics interpolation per node, offering a finer grain of control than turning physics interpolation on and off globally.
Note: This can be especially useful for Camera
s, where custom interpolation can sometimes give superior results.
sourcepub fn set_physics_process(&self, enable: bool)
pub fn set_physics_process(&self, enable: bool)
Enables or disables physics (i.e. fixed framerate) processing. When a node is being processed, it will receive a NOTIFICATION_PHYSICS_PROCESS
at a fixed (usually 60 FPS, see Engine.iterations_per_second
to change) interval (and the [_physics_process
][Self::_physics_process] callback will be called if exists). Enabled automatically if [_physics_process
][Self::_physics_process] is overridden. Any calls to this before [_ready
][Self::_ready] will be ignored.
sourcepub fn set_physics_process_internal(&self, enable: bool)
pub fn set_physics_process_internal(&self, enable: bool)
Enables or disables internal physics for this node. Internal physics processing happens in isolation from the normal [_physics_process
][Self::_physics_process] calls and is used by some nodes internally to guarantee proper functioning even if the node is paused or physics processing is disabled for scripting (set_physics_process
). Only useful for advanced uses to manipulate built-in nodes’ behavior.
Warning: Built-in Nodes rely on the internal processing for their own logic, so changing this value from your code may lead to unexpected behavior. Script access to this internal logic is provided for specific advanced uses, but is unsafe and not supported.
sourcepub fn set_process(&self, enable: bool)
pub fn set_process(&self, enable: bool)
Enables or disables processing. When a node is being processed, it will receive a NOTIFICATION_PROCESS
on every drawn frame (and the [_process
][Self::_process] callback will be called if exists). Enabled automatically if [_process
][Self::_process] is overridden. Any calls to this before [_ready
][Self::_ready] will be ignored.
sourcepub fn set_process_input(&self, enable: bool)
pub fn set_process_input(&self, enable: bool)
Enables or disables input processing. This is not required for GUI controls! Enabled automatically if [_input
][Self::_input] is overridden. Any calls to this before [_ready
][Self::_ready] will be ignored.
sourcepub fn set_process_internal(&self, enable: bool)
pub fn set_process_internal(&self, enable: bool)
Enables or disabled internal processing for this node. Internal processing happens in isolation from the normal [_process
][Self::_process] calls and is used by some nodes internally to guarantee proper functioning even if the node is paused or processing is disabled for scripting (set_process
). Only useful for advanced uses to manipulate built-in nodes’ behavior.
Warning: Built-in Nodes rely on the internal processing for their own logic, so changing this value from your code may lead to unexpected behavior. Script access to this internal logic is provided for specific advanced uses, but is unsafe and not supported.
sourcepub fn set_process_priority(&self, priority: i64)
pub fn set_process_priority(&self, priority: i64)
The node’s priority in the execution order of the enabled processing callbacks (i.e. NOTIFICATION_PROCESS
, NOTIFICATION_PHYSICS_PROCESS
and their internal counterparts). Nodes whose process priority value is lower will have their processing callbacks executed first.
sourcepub fn set_process_unhandled_input(&self, enable: bool)
pub fn set_process_unhandled_input(&self, enable: bool)
Enables unhandled input processing. This is not required for GUI controls! It enables the node to receive all input that was not previously handled (usually by a Control
). Enabled automatically if [_unhandled_input
][Self::_unhandled_input] is overridden. Any calls to this before [_ready
][Self::_ready] will be ignored.
sourcepub fn set_process_unhandled_key_input(&self, enable: bool)
pub fn set_process_unhandled_key_input(&self, enable: bool)
Enables unhandled key input processing. Enabled automatically if [_unhandled_key_input
][Self::_unhandled_key_input] is overridden. Any calls to this before [_ready
][Self::_ready] will be ignored.
sourcepub fn set_scene_instance_load_placeholder(&self, load_placeholder: bool)
pub fn set_scene_instance_load_placeholder(&self, load_placeholder: bool)
Sets whether this is an instance load placeholder. See InstancePlaceholder
.
sourcepub fn set_unique_name_in_owner(&self, enable: bool)
pub fn set_unique_name_in_owner(&self, enable: bool)
Sets this node’s name as a unique name in its owner
. This allows the node to be accessed as %Name
instead of the full path, from any node within that scene.
If another node with the same owner already had that name declared as unique, that other node’s name will no longer be set as having a unique name.
sourcepub fn update_configuration_warning(&self)
pub fn update_configuration_warning(&self)
Updates the warning displayed for this node in the Scene Dock.
Use [_get_configuration_warning
][Self::_get_configuration_warning] to setup the warning message to display.
Methods from Deref<Target = Object>§
pub const NOTIFICATION_POSTINITIALIZE: i64 = 0i64
pub const CONNECT_DEFERRED: i64 = 1i64
pub const NOTIFICATION_PREDELETE: i64 = 1i64
pub const CONNECT_PERSIST: i64 = 2i64
pub const CONNECT_ONESHOT: i64 = 4i64
pub const CONNECT_REFERENCE_COUNTED: i64 = 8i64
sourcepub fn add_user_signal(
&self,
signal: impl Into<GodotString>,
arguments: VariantArray
)
pub fn add_user_signal(
&self,
signal: impl Into<GodotString>,
arguments: VariantArray
)
Adds a user-defined signal
. Arguments are optional, but can be added as an Array
of dictionaries, each containing name: String
and type: int
(see [enum Variant.Type]) entries.
Default Arguments
arguments
-[ ]
sourcepub unsafe fn call(
&self,
method: impl Into<GodotString>,
varargs: &[Variant]
) -> Variant
pub unsafe fn call(
&self,
method: impl Into<GodotString>,
varargs: &[Variant]
) -> Variant
Sample code is GDScript unless otherwise noted.
Calls the method
on the object and returns the result. This method supports a variable number of arguments, so parameters are passed as a comma separated list. Example:
call("set", "position", Vector2(42.0, 0.0))
Note: In C#, the method name must be specified as snake_case if it is defined by a built-in Godot node. This doesn’t apply to user-defined methods where you should use the same convention as in the C# source (typically PascalCase).
Safety
This function bypasses Rust’s static type checks (aliasing, thread boundaries, calls to free(), …).
sourcepub unsafe fn call_deferred(
&self,
method: impl Into<GodotString>,
varargs: &[Variant]
) -> Variant
pub unsafe fn call_deferred(
&self,
method: impl Into<GodotString>,
varargs: &[Variant]
) -> Variant
Sample code is GDScript unless otherwise noted.
Calls the method
on the object during idle time. This method supports a variable number of arguments, so parameters are passed as a comma separated list. Example:
call_deferred("set", "position", Vector2(42.0, 0.0))
Note: In C#, the method name must be specified as snake_case if it is defined by a built-in Godot node. This doesn’t apply to user-defined methods where you should use the same convention as in the C# source (typically PascalCase).
Safety
This function bypasses Rust’s static type checks (aliasing, thread boundaries, calls to free(), …).
sourcepub unsafe fn callv(
&self,
method: impl Into<GodotString>,
arg_array: VariantArray
) -> Variant
pub unsafe fn callv(
&self,
method: impl Into<GodotString>,
arg_array: VariantArray
) -> Variant
Sample code is GDScript unless otherwise noted.
Calls the method
on the object and returns the result. Contrarily to call
, this method does not support a variable number of arguments but expects all parameters to be via a single Array
.
callv("set", [ "position", Vector2(42.0, 0.0) ])
Safety
This function bypasses Rust’s static type checks (aliasing, thread boundaries, calls to free(), …).
sourcepub fn can_translate_messages(&self) -> bool
pub fn can_translate_messages(&self) -> bool
Returns true
if the object can translate strings. See set_message_translation
and tr
.
sourcepub fn connect(
&self,
signal: impl Into<GodotString>,
target: impl AsArg<Object>,
method: impl Into<GodotString>,
binds: VariantArray,
flags: i64
) -> GodotResult
pub fn connect(
&self,
signal: impl Into<GodotString>,
target: impl AsArg<Object>,
method: impl Into<GodotString>,
binds: VariantArray,
flags: i64
) -> GodotResult
Sample code is GDScript unless otherwise noted.
Connects a signal
to a method
on a target
object. Pass optional binds
to the call as an Array
of parameters. These parameters will be passed to the method after any parameter used in the call to emit_signal
. Use flags
to set deferred or one-shot connections. See ConnectFlags
constants.
A signal
can only be connected once to a method
. It will print an error if already connected, unless the signal was connected with CONNECT_REFERENCE_COUNTED
. To avoid this, first, use is_connected
to check for existing connections.
If the target
is destroyed in the game’s lifecycle, the connection will be lost.
Examples:
connect("pressed", self, "_on_Button_pressed") # BaseButton signal
connect("text_entered", self, "_on_LineEdit_text_entered") # LineEdit signal
connect("hit", self, "_on_Player_hit", [ weapon_type, damage ]) # User-defined signal
An example of the relationship between binds
passed to connect
and parameters used when calling emit_signal
:
connect("hit", self, "_on_Player_hit", [ weapon_type, damage ]) # weapon_type and damage are passed last
emit_signal("hit", "Dark lord", 5) # "Dark lord" and 5 are passed first
func _on_Player_hit(hit_by, level, weapon_type, damage):
print("Hit by %s (lvl %d) with weapon %s for %d damage" % [hit_by, level, weapon_type, damage])
Default Arguments
binds
-[ ]
flags
-0
sourcepub fn disconnect(
&self,
signal: impl Into<GodotString>,
target: impl AsArg<Object>,
method: impl Into<GodotString>
)
pub fn disconnect(
&self,
signal: impl Into<GodotString>,
target: impl AsArg<Object>,
method: impl Into<GodotString>
)
Disconnects a signal
from a method
on the given target
.
If you try to disconnect a connection that does not exist, the method will print an error. Use is_connected
to ensure that the connection exists.
sourcepub fn emit_signal(
&self,
signal: impl Into<GodotString>,
varargs: &[Variant]
) -> Variant
pub fn emit_signal(
&self,
signal: impl Into<GodotString>,
varargs: &[Variant]
) -> Variant
Sample code is GDScript unless otherwise noted.
Emits the given signal
. The signal must exist, so it should be a built-in signal of this class or one of its parent classes, or a user-defined signal. This method supports a variable number of arguments, so parameters are passed as a comma separated list. Example:
emit_signal("hit", weapon_type, damage)
emit_signal("game_over")
sourcepub fn get(&self, property: impl Into<GodotString>) -> Variant
pub fn get(&self, property: impl Into<GodotString>) -> Variant
Returns the Variant
value of the given property
. If the property
doesn’t exist, this will return null
.
Note: In C#, the property name must be specified as snake_case if it is defined by a built-in Godot node. This doesn’t apply to user-defined properties where you should use the same convention as in the C# source (typically PascalCase).
sourcepub fn get_class(&self) -> GodotString
pub fn get_class(&self) -> GodotString
sourcepub fn get_incoming_connections(&self) -> VariantArray
pub fn get_incoming_connections(&self) -> VariantArray
Returns an Array
of dictionaries with information about signals that are connected to the object.
Each Dictionary
contains three String entries:
source
is a reference to the signal emitter.signal_name
is the name of the connected signal.method_name
is the name of the method to which the signal is connected.
sourcepub fn get_indexed(&self, property: impl Into<NodePath>) -> Variant
pub fn get_indexed(&self, property: impl Into<NodePath>) -> Variant
Gets the object’s property indexed by the given NodePath
. The node path should be relative to the current object and can use the colon character (:
) to access nested properties. Examples: "position:x"
or "material:next_pass:blend_mode"
.
Note: Even though the method takes NodePath
argument, it doesn’t support actual paths to Node
s in the scene tree, only colon-separated sub-property paths. For the purpose of nodes, use Node.get_node_and_resource
instead.
sourcepub fn get_instance_id(&self) -> i64
pub fn get_instance_id(&self) -> i64
Returns the object’s unique instance ID.
This ID can be saved in EncodedObjectAsID
, and can be used to retrieve the object instance with [method @GDScript.instance_from_id].
sourcepub fn get_meta(
&self,
name: impl Into<GodotString>,
default: impl OwnedToVariant
) -> Variant
pub fn get_meta(
&self,
name: impl Into<GodotString>,
default: impl OwnedToVariant
) -> Variant
Returns the object’s metadata entry for the given name
.
Throws error if the entry does not exist, unless default
is not null
(in which case the default value will be returned).
Default Arguments
default
-null
sourcepub fn get_meta_list(&self) -> PoolArray<GodotString>
pub fn get_meta_list(&self) -> PoolArray<GodotString>
Returns the object’s metadata as a PoolStringArray
.
sourcepub fn get_method_list(&self) -> VariantArray
pub fn get_method_list(&self) -> VariantArray
Returns the object’s methods and their signatures as an Array
.
sourcepub fn get_property_list(&self) -> VariantArray
pub fn get_property_list(&self) -> VariantArray
Returns the object’s property list as an Array
of dictionaries.
Each property’s Dictionary
contain at least name: String
and type: int
(see [enum Variant.Type]) entries. Optionally, it can also include hint: int
(see [PropertyHint
][PropertyHint]), hint_string: String
, and usage: int
(see [PropertyUsageFlags
][PropertyUsageFlags]).
sourcepub fn get_script(&self) -> Option<Ref<Reference, Shared>>
pub fn get_script(&self) -> Option<Ref<Reference, Shared>>
Returns the object’s Script
instance, or null
if none is assigned.
sourcepub fn get_signal_connection_list(
&self,
signal: impl Into<GodotString>
) -> VariantArray
pub fn get_signal_connection_list(
&self,
signal: impl Into<GodotString>
) -> VariantArray
Returns an Array
of connections for the given signal
.
sourcepub fn get_signal_list(&self) -> VariantArray
pub fn get_signal_list(&self) -> VariantArray
Returns the list of signals as an Array
of dictionaries.
sourcepub fn has_meta(&self, name: impl Into<GodotString>) -> bool
pub fn has_meta(&self, name: impl Into<GodotString>) -> bool
Returns true
if a metadata entry is found with the given name
.
sourcepub fn has_method(&self, method: impl Into<GodotString>) -> bool
pub fn has_method(&self, method: impl Into<GodotString>) -> bool
Returns true
if the object contains the given method
.
sourcepub fn has_signal(&self, signal: impl Into<GodotString>) -> bool
pub fn has_signal(&self, signal: impl Into<GodotString>) -> bool
Returns true
if the given signal
exists.
sourcepub fn has_user_signal(&self, signal: impl Into<GodotString>) -> bool
pub fn has_user_signal(&self, signal: impl Into<GodotString>) -> bool
Returns true
if the given user-defined signal
exists. Only signals added using add_user_signal
are taken into account.
sourcepub fn is_blocking_signals(&self) -> bool
pub fn is_blocking_signals(&self) -> bool
Returns true
if signal emission blocking is enabled.
sourcepub fn is_class(&self, class: impl Into<GodotString>) -> bool
pub fn is_class(&self, class: impl Into<GodotString>) -> bool
sourcepub fn is_connected(
&self,
signal: impl Into<GodotString>,
target: impl AsArg<Object>,
method: impl Into<GodotString>
) -> bool
pub fn is_connected(
&self,
signal: impl Into<GodotString>,
target: impl AsArg<Object>,
method: impl Into<GodotString>
) -> bool
Returns true
if a connection exists for a given signal
, target
, and method
.
sourcepub fn is_queued_for_deletion(&self) -> bool
pub fn is_queued_for_deletion(&self) -> bool
Returns true
if the Node.queue_free
method was called for the object.
sourcepub fn notification(&self, what: i64, reversed: bool)
pub fn notification(&self, what: i64, reversed: bool)
Send a given notification to the object, which will also trigger a call to the [_notification
][Self::_notification] method of all classes that the object inherits from.
If reversed
is true
, [_notification
][Self::_notification] is called first on the object’s own class, and then up to its successive parent classes. If reversed
is false
, [_notification
][Self::_notification] is called first on the highest ancestor (Object
itself), and then down to its successive inheriting classes.
Default Arguments
reversed
-false
sourcepub fn property_list_changed_notify(&self)
pub fn property_list_changed_notify(&self)
Notify the editor that the property list has changed, so that editor plugins can take the new values into account. Does nothing on export builds.
sourcepub fn remove_meta(&self, name: impl Into<GodotString>)
pub fn remove_meta(&self, name: impl Into<GodotString>)
Removes a given entry from the object’s metadata. See also set_meta
.
sourcepub fn set(&self, property: impl Into<GodotString>, value: impl OwnedToVariant)
pub fn set(&self, property: impl Into<GodotString>, value: impl OwnedToVariant)
Assigns a new value to the given property. If the property
does not exist or the given value’s type doesn’t match, nothing will happen.
Note: In C#, the property name must be specified as snake_case if it is defined by a built-in Godot node. This doesn’t apply to user-defined properties where you should use the same convention as in the C# source (typically PascalCase).
sourcepub fn set_block_signals(&self, enable: bool)
pub fn set_block_signals(&self, enable: bool)
If set to true
, signal emission is blocked.
sourcepub fn set_deferred(
&self,
property: impl Into<GodotString>,
value: impl OwnedToVariant
)
pub fn set_deferred(
&self,
property: impl Into<GodotString>,
value: impl OwnedToVariant
)
Assigns a new value to the given property, after the current frame’s physics step. This is equivalent to calling set
via call_deferred
, i.e. call_deferred("set", property, value)
.
Note: In C#, the property name must be specified as snake_case if it is defined by a built-in Godot node. This doesn’t apply to user-defined properties where you should use the same convention as in the C# source (typically PascalCase).
sourcepub fn set_indexed(
&self,
property: impl Into<NodePath>,
value: impl OwnedToVariant
)
pub fn set_indexed(
&self,
property: impl Into<NodePath>,
value: impl OwnedToVariant
)
Sample code is GDScript unless otherwise noted.
Assigns a new value to the property identified by the NodePath
. The node path should be relative to the current object and can use the colon character (:
) to access nested properties. Example:
set_indexed("position", Vector2(42, 0))
set_indexed("position:y", -10)
print(position) # (42, -10)
sourcepub fn set_message_translation(&self, enable: bool)
pub fn set_message_translation(&self, enable: bool)
Defines whether the object can translate strings (with calls to tr
). Enabled by default.
sourcepub fn set_meta(&self, name: impl Into<GodotString>, value: impl OwnedToVariant)
pub fn set_meta(&self, name: impl Into<GodotString>, value: impl OwnedToVariant)
Adds, changes or removes a given entry in the object’s metadata. Metadata are serialized and can take any Variant
value.
To remove a given entry from the object’s metadata, use remove_meta
. Metadata is also removed if its value is set to null
. This means you can also use set_meta("name", null)
to remove metadata for "name"
.
sourcepub fn set_script(&self, script: impl AsArg<Reference>)
pub fn set_script(&self, script: impl AsArg<Reference>)
Assigns a script to the object. Each object can have a single script assigned to it, which are used to extend its functionality.
If the object already had a script, the previous script instance will be freed and its variables and state will be lost. The new script’s [_init
][Self::_init] method will be called.
sourcepub fn to_string(&self) -> GodotString
pub fn to_string(&self) -> GodotString
sourcepub fn tr(&self, message: impl Into<GodotString>) -> GodotString
pub fn tr(&self, message: impl Into<GodotString>) -> GodotString
Translates a message using translation catalogs configured in the Project Settings.
Only works if message translation is enabled (which it is by default), otherwise it returns the message
unchanged. See set_message_translation
.
Trait Implementations§
source§impl Debug for RoomManager
impl Debug for RoomManager
source§impl Deref for RoomManager
impl Deref for RoomManager
source§impl DerefMut for RoomManager
impl DerefMut for RoomManager
source§impl GodotObject for RoomManager
impl GodotObject for RoomManager
§type Memory = ManuallyManaged
type Memory = ManuallyManaged
Ref
smart pointer. See its type-level documentation for more
information.fn class_name() -> &'static str
source§fn null() -> Null<Self>
fn null() -> Null<Self>
Self
as a method argument. This makes type
inference easier for the compiler compared to Option
.source§fn new() -> Ref<Self, Unique>where
Self: Instanciable,
fn new() -> Ref<Self, Unique>where
Self: Instanciable,
Self
using a zero-argument constructor, as a Unique
reference.source§fn cast<T>(&self) -> Option<&T>where
T: GodotObject + SubClass<Self>,
fn cast<T>(&self) -> Option<&T>where
T: GodotObject + SubClass<Self>,
source§fn upcast<T>(&self) -> &Twhere
T: GodotObject,
Self: SubClass<T>,
fn upcast<T>(&self) -> &Twhere
T: GodotObject,
Self: SubClass<T>,
source§unsafe fn assume_unique(&self) -> Ref<Self, Unique>where
Self: Sized,
unsafe fn assume_unique(&self) -> Ref<Self, Unique>where
Self: Sized,
source§impl Instanciable for RoomManager
impl Instanciable for RoomManager
impl QueueFree for RoomManager
impl Sealed for RoomManager
impl SubClass<Node> for RoomManager
impl SubClass<Object> for RoomManager
impl SubClass<Spatial> for RoomManager
Auto Trait Implementations§
impl RefUnwindSafe for RoomManager
impl !Send for RoomManager
impl !Sync for RoomManager
impl Unpin for RoomManager
impl UnwindSafe for RoomManager
Blanket Implementations§
source§impl<N, P> NodeResolveExt<P> for Nwhere
N: SubClass<Node>,
P: Into<NodePath>,
impl<N, P> NodeResolveExt<P> for Nwhere
N: SubClass<Node>,
P: Into<NodePath>,
source§unsafe fn get_node_as<'a, T>(&self, path: P) -> Option<TRef<'a, T, Shared>>where
T: SubClass<Node>,
unsafe fn get_node_as<'a, T>(&self, path: P) -> Option<TRef<'a, T, Shared>>where
T: SubClass<Node>,
path
relative to self
,
and cast it to the desired type. Returns None
if the node does not exist or is
not of the correct type. Read moresource§unsafe fn get_node_as_instance<'a, T>(&self, path: P) -> Option<TInstance<'a, T>>where
T: NativeClass,
T::Base: SubClass<Node>,
unsafe fn get_node_as_instance<'a, T>(&self, path: P) -> Option<TInstance<'a, T>>where
T: NativeClass,
T::Base: SubClass<Node>,
path
relative to self
,
and cast it to an instance of the desired NativeClass
type. Returns None
if
the node does not exist or is not of the correct type. Read more