A pre-parsed relative or absolute path in a scene tree,
for use with godot.Node.getNode and similar functions.
It can reference a node, a resource within a node, or a property
of a node or resource.
For instance, "Path2D/PathFollow2D/Sprite2D:texture:size"
would refer to the size property of the texture
resource on the node named "Sprite2D" which is a child of
the other named nodes in the path.
You will usually just pass a string to godot.Node.getNode
and it will be automatically converted, but you may occasionally
want to parse a path ahead of time with NodePath.
Exporting a NodePath variable will give you a node selection widget
in the properties panel of the editor, which can often be useful.
A NodePath is composed of a list of slash-separated node names
(like a filesystem path) and an optional colon-separated list of
"subnames" which can be resources or properties.
Note: In the editor, NodePath properties are automatically updated when moving, renaming or deleting a node in the scene tree, but they are never updated at runtime.
Some examples of NodePaths include the following:
// No leading slash means it is relative to the current node.
new NodePath("A"); // Immediate child A.
new NodePath("A/B"); // A's child B.
new NodePath("."); // The current node.
new NodePath(".."); // The parent node.
new NodePath("../C"); // A sibling node C.
// A leading slash means it is absolute from the SceneTree.
new NodePath("/root"); // Equivalent to GetTree().Root
new NodePath("/root/Main"); // If your main scene's root node were named "Main".
new NodePath("/root/MyAutoload"); // If you have an autoloaded node or scene.
Static methods
Constructor
Variables
Methods
getAsPropertyPath():NodePath
Returns a node path with a colon character (:) prepended,
transforming it to a pure property path with no node name (defaults
to resolving from the current node).
// This will be parsed as a node path to the "x" property in the "position" node.
var nodePath = new NodePath("position:x");
// This will be parsed as a node path to the "x" component of the "position" property in the current node.
NodePath propertyPath = nodePath.GetAsPropertyPath();
GD.Print(propertyPath); // :position:x
Returns:
The godot.NodePath as a pure property path.
getConcatenatedSubnames():String
Returns all subnames concatenated with a colon character (:)
as separator, i.e. the right side of the first colon in a node path.
var nodepath = new NodePath("Path2D/PathFollow2D/Sprite2D:texture:load_path");
GD.Print(nodepath.GetConcatenatedSubnames()); // texture:load_path
Returns:
The subnames concatenated with :.
getName(idx:Int):String
Gets the node name indicated by idx (0 to godot.NodePath.getNameCount).
var nodePath = new NodePath("Path2D/PathFollow2D/Sprite2D");
GD.Print(nodePath.GetName(0)); // Path2D
GD.Print(nodePath.GetName(1)); // PathFollow2D
GD.Print(nodePath.GetName(2)); // Sprite
Parameters:
idx | The name index. |
|---|
Returns:
The name at the given index idx.
getNameCount():Int
Gets the number of node names which make up the path.
Subnames (see godot.NodePath.getSubnameCount) are not included.
For example, "Path2D/PathFollow2D/Sprite2D" has 3 names.
Returns:
The number of node names which make up the path.
getSubname(idx:Int):String
Gets the resource or property name indicated by idx (0 to godot.NodePath.getSubnameCount).
Parameters:
idx | The subname index. |
|---|
Returns:
The subname at the given index idx.
getSubnameCount():Int
Gets the number of resource or property names ("subnames") in the path.
Each subname is listed after a colon character (:) in the node path.
For example, "Path2D/PathFollow2D/Sprite2D:texture:load_path" has 2 subnames.
Returns:
The number of subnames in the path.
isAbsolute():Bool
Returns true if the node path is absolute (as opposed to relative),
which means that it starts with a slash character (/). Absolute node paths can
be used to access the root node ("/root") or autoloads (e.g. "/global"
if a "global" autoload was registered).
Returns:
If the godot.NodePath is an absolute path.