Struct Node

Source

pub struct Node { /* private fields */ }

Expand description

Godot class Node.

Inherits Object.

Related symbols:

node: sidecar module with related enum/flag types
INode: virtual methods
SignalsOfNode: signal collection
NodeNotification: notification type

§Construction

This class is manually managed. You can create a new instance using Node::new_alloc().

Do not forget to call free() or hand over ownership to Godot.

§Godot docs

Nodes are Godot’s building blocks. They can be assigned as the child of another node, resulting in a tree arrangement. A given node can contain any number of nodes as children with the requirement that all siblings (direct children of a node) should have unique names.

A tree of nodes is called a scene. Scenes can be saved to the disk and then instantiated into other scenes. This allows for very high flexibility in the architecture and data model of Godot projects.

Scene tree: The SceneTree contains the active tree of nodes. When a node is added to the scene tree, it receives the [constant NOTIFICATION_ENTER_TREE] notification and its enter_tree callback is triggered. Child nodes are always added after their parent node, i.e. the enter_tree callback of a parent node will be triggered before its child’s.

Once all nodes have been added in the scene tree, they receive the [constant NOTIFICATION_READY] notification and their respective ready callbacks are triggered. For groups of nodes, the ready callback is called in reverse order, starting with the children and moving up to the parent nodes.

This means that when adding a node to the scene tree, the following order will be used for the callbacks: enter_tree of the parent, enter_tree of the children, ready of the children and finally ready of the parent (recursively for the entire scene tree).

Processing: Nodes can override the “process” state, so that they receive a callback on each frame requesting them to process (do something). Normal processing (callback process, toggled with set_process) happens as fast as possible and is dependent on the frame rate, so the processing time delta (in seconds) is passed as an argument. Physics processing (callback physics_process, toggled with set_physics_process) happens a fixed number of times per second (60 by default) and is useful for code related to the physics engine.

Nodes can also process input events. When present, the input function will be called for each input that the program receives. In many cases, this can be overkill (unless used for simple projects), and the unhandled_input function might be preferred; it is called when the input event was not handled by anyone else (typically, GUI Control nodes), ensuring that the node only receives the events that were meant for it.

To keep track of the scene hierarchy (especially when instantiating scenes into other scenes), an “owner” can be set for the node with the [member owner] property. This keeps track of who instantiated what. This is mostly useful when writing editors and tools, though.

Finally, when a node is freed with free or queue_free, it will also free all its children.

Groups: Nodes can be added to as many groups as you want to be easy to manage, you could create groups like “enemies” or “collectables” for example, depending on your game. See add_to_group, is_in_group and remove_from_group. You can then retrieve all nodes in these groups, iterate them and even call methods on groups via the methods on SceneTree.

Networking with nodes: After connecting to a server (or making one, see ENetMultiplayerPeer), it is possible to use the built-in RPC (remote procedure call) system to communicate over the network. By calling rpc with a method name, it will be called locally and in all connected peers (peers = clients and the server that accepts connections). To identify which node receives the RPC call, Godot will use its NodePath (make sure node names are the same on all peers). Also, take a look at the high-level networking tutorial and corresponding demos.

Note: The script property is part of the Object class, not Node. It isn’t exposed like most properties but does have a setter and getter (see [method Object.set_script] and [method Object.get_script]).

Struct Node Copy item path

§Construction

§Godot docs

Implementations§

impl Node

pub fn get_node_as<T>(&self, path: impl AsArg<NodePath>) -> Gd<T>where T: Inherits<Node>,

§Panics

pub fn try_get_node_as<T>(&self, path: impl AsArg<NodePath>) -> Option<Gd<T>>where T: Inherits<Node>,

impl Node

pub fn get_tree(&self) -> Gd<SceneTree>

§Panics

pub fn get_tree_or_null(&self) -> Option<Gd<SceneTree>>

impl Node

pub fn print_orphan_nodes()

pub fn get_orphan_node_ids() -> Array<i64>

pub fn add_sibling(&mut self, sibling: impl AsArg<Gd<Node>>)

pub fn add_sibling_ex<'ex>( &'ex mut self, sibling: impl AsArg<Gd<Node>> + 'ex, ) -> ExAddSibling<'ex>

pub fn set_name(&mut self, name: impl AsArg<StringName>)

pub fn get_name(&self) -> StringName

pub fn add_child(&mut self, node: impl AsArg<Gd<Node>>)

pub fn add_child_ex<'ex>( &'ex mut self, node: impl AsArg<Gd<Node>> + 'ex, ) -> ExAddChild<'ex>

pub fn remove_child(&mut self, node: impl AsArg<Gd<Node>>)

pub fn reparent(&mut self, new_parent: impl AsArg<Gd<Node>>)

pub fn reparent_ex<'ex>( &'ex mut self, new_parent: impl AsArg<Gd<Node>> + 'ex, ) -> ExReparent<'ex>

pub fn get_child_count(&self) -> i32

pub fn get_child_count_ex<'ex>(&'ex self) -> ExGetChildCount<'ex>

pub fn get_children(&self) -> Array<Gd<Node>>

pub fn get_children_ex<'ex>(&'ex self) -> ExGetChildren<'ex>

pub fn get_child(&self, idx: i32) -> Option<Gd<Node>>

pub fn get_child_ex<'ex>(&'ex self, idx: i32) -> ExGetChild<'ex>

pub fn has_node(&self, path: impl AsArg<NodePath>) -> bool

pub fn get_node_or_null(&self, path: impl AsArg<NodePath>) -> Option<Gd<Node>>

pub fn get_parent(&self) -> Option<Gd<Node>>

pub fn find_child(&self, pattern: impl AsArg<GString>) -> Option<Gd<Node>>

pub fn find_child_ex<'ex>( &'ex self, pattern: impl AsArg<GString> + 'ex, ) -> ExFindChild<'ex>

pub fn find_children(&self, pattern: impl AsArg<GString>) -> Array<Gd<Node>>

pub fn find_children_ex<'ex>( &'ex self, pattern: impl AsArg<GString> + 'ex, ) -> ExFindChildren<'ex>

pub fn find_parent(&self, pattern: impl AsArg<GString>) -> Option<Gd<Node>>

pub fn has_node_and_resource(&self, path: impl AsArg<NodePath>) -> bool

pub fn get_node_and_resource( &self, path: impl AsArg<NodePath>, ) -> Array<Variant>

pub fn is_inside_tree(&self) -> bool

pub fn is_part_of_edited_scene(&self) -> bool

pub fn is_ancestor_of(&self, node: impl AsArg<Gd<Node>>) -> bool

pub fn is_greater_than(&self, node: impl AsArg<Gd<Node>>) -> bool

pub fn get_path(&self) -> NodePath

pub fn get_path_to(&self, node: impl AsArg<Gd<Node>>) -> NodePath

pub fn get_path_to_ex<'ex>( &'ex self, node: impl AsArg<Gd<Node>> + 'ex, ) -> ExGetPathTo<'ex>

pub fn add_to_group(&mut self, group: impl AsArg<StringName>)

pub fn add_to_group_ex<'ex>( &'ex mut self, group: impl AsArg<StringName> + 'ex, ) -> ExAddToGroup<'ex>

pub fn remove_from_group(&mut self, group: impl AsArg<StringName>)

pub fn is_in_group(&self, group: impl AsArg<StringName>) -> bool

pub fn move_child(&mut self, child_node: impl AsArg<Gd<Node>>, to_index: i32)

pub fn get_groups(&self) -> Array<StringName>

pub fn set_owner(&mut self, owner: impl AsArg<Option<Gd<Node>>>)

pub fn get_owner(&self) -> Option<Gd<Node>>

pub fn get_index(&self) -> i32

pub fn get_index_ex<'ex>(&'ex self) -> ExGetIndex<'ex>

pub fn print_tree(&mut self)

pub fn print_tree_pretty(&mut self)

pub fn get_tree_string(&self) -> GString

pub fn get_tree_string_pretty(&self) -> GString

pub fn set_scene_file_path(&mut self, scene_file_path: impl AsArg<GString>)

pub fn get_scene_file_path(&self) -> GString

pub fn propagate_notification(&mut self, what: i32)

pub fn propagate_call(&mut self, method: impl AsArg<StringName>)

pub fn propagate_call_ex<'ex>( &'ex mut self, method: impl AsArg<StringName> + 'ex, ) -> ExPropagateCall<'ex>

pub fn set_physics_process(&mut self, enable: bool)

pub fn get_physics_process_delta_time(&self) -> f64

pub fn is_physics_processing(&self) -> bool

pub fn get_process_delta_time(&self) -> f64

pub fn set_process(&mut self, enable: bool)

pub fn set_process_priority(&mut self, priority: i32)

pub fn get_process_priority(&self) -> i32

pub fn set_physics_process_priority(&mut self, priority: i32)

pub fn get_physics_process_priority(&self) -> i32

pub fn is_processing(&self) -> bool

pub fn set_process_input(&mut self, enable: bool)

pub fn is_processing_input(&self) -> bool

pub fn set_process_shortcut_input(&mut self, enable: bool)

pub fn is_processing_shortcut_input(&self) -> bool

Struct Node

pub fn get_node_as<T>(&self, path: impl AsArg<NodePath>) -> Gd<T>
where T: Inherits<Node>,

pub fn try_get_node_as<T>(&self, path: impl AsArg<NodePath>) -> Option<Gd<T>>
where T: Inherits<Node>,