Node

func (Expanded) AddChild ¶

func (self Expanded) AddChild(node Instance, force_readable_name bool, internal_ InternalMode)

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 'force_readable_name' is true, improves the readability of the added 'node'. If not named, the 'node' is renamed to its type, and if it shares Instance.Name with a sibling, a number is suffixed more appropriately. This operation is very slow. As such, it is recommended leaving this to false, which assigns a dummy name featuring @ in both situations.

If 'internal' is different than InternalModeDisabled, the child will be added as internal node. These nodes are ignored by methods like Instance.GetChildren, unless their parameter include_internal is true. It also prevents these nodes being duplicated with their parent. The intended usage is to hide the internal nodes from the user, so the user won't accidentally delete or modify them. Used by some GUI nodes, e.g. graphics.gd/classdb/ColorPicker.

Note: If 'node' already has a parent, this method will fail. Use Instance.RemoveChild first to remove 'node' from its current parent. For example:

If you need the child node to be added below a specific node in the list of children, use Instance.AddSibling instead of this method.

Note: If you want a child to be persisted to a graphics.gd/classdb/PackedScene, you must set Instance.Owner in addition to calling Instance.AddChild. This is typically relevant for tool scripts and editor plugins. If Instance.AddChild is called without setting Instance.Owner, the newly added graphics.gd/classdb/Node will not be visible in the scene tree, though it will be visible in the 2D/3D view.

func (Expanded) AddSibling ¶

func (self Expanded) AddSibling(sibling Instance, force_readable_name bool)

Adds a 'sibling' node to this node's parent, and moves the added sibling right below this node.

If 'force_readable_name' is true, improves the readability of the added 'sibling'. If not named, the 'sibling' is renamed to its type, and if it shares Instance.Name with a sibling, a number is suffixed more appropriately. This operation is very slow. As such, it is recommended leaving this to false, which assigns a dummy name featuring @ in both situations.

Use Instance.AddChild instead of this method if you don't need the child node to be added below a specific node in the list of children.

Note: If this node is internal, the added sibling will be internal too (see Instance.AddChild's internal parameter).

func (Expanded) AddToGroup ¶

func (self Expanded) AddToGroup(group string, persistent bool)

Adds the node to the 'group'. Groups can be helpful to organize a subset of nodes, for example "enemies" or "collectables". See notes in the description, and the group methods in graphics.gd/classdb/SceneTree.

If 'persistent' is true, the group will be stored when saved inside a graphics.gd/classdb/PackedScene. All groups created and displayed in the Node dock are persistent.

Note: To improve performance, the order of group names is not guaranteed and may vary between project runs. Therefore, do not rely on the group order.

Note: graphics.gd/classdb/SceneTree's group methods will not work on this node if not inside the tree (see Instance.IsInsideTree).

func (Expanded) Atr ¶

func (self Expanded) Atr(message string, context string) string

Translates a 'message', using the translation catalogs configured in the Project Settings. Further 'context' can be specified to help with the translation. Note that most graphics.gd/classdb/Control nodes automatically translate their strings, so this method is mostly useful for formatted strings or custom drawn text.

This method works the same as graphics.gd/classdb/Object.Instance.Tr, with the addition of respecting the Instance.AutoTranslateMode state.

If graphics.gd/classdb/Object.Instance.CanTranslateMessages is false, or no translation is available, this method returns the 'message' without changes. See graphics.gd/classdb/Object.Instance.SetMessageTranslation.

For detailed examples, see Internationalizing games.

func (Expanded) AtrN ¶

func (self Expanded) AtrN(message string, plural_message string, n int, context string) string

Translates a 'message' or 'plural_message', using the translation catalogs configured in the Project Settings. Further 'context' can be specified to help with the translation.

This method works the same as graphics.gd/classdb/Object.Instance.TrN, with the addition of respecting the Instance.AutoTranslateMode state.

If graphics.gd/classdb/Object.Instance.CanTranslateMessages is false, or no translation is available, this method returns 'message' or 'plural_message', without changes. See graphics.gd/classdb/Object.Instance.SetMessageTranslation.

The 'n' is the number, or amount, of the message's subject. It is used by the translation system to fetch the correct plural form for the current language.

For detailed examples, see Localization using gettext.

Note: Negative and [Float.X] numbers may not properly apply to some countable subjects. It's recommended to handle these cases with Instance.Atr.

func (Expanded) Duplicate ¶

func (self Expanded) Duplicate(flags int) Instance

Duplicates the node, returning a new node with all of its properties, signals, groups, and children copied from the original. The behavior can be tweaked through the 'flags' (see DuplicateFlags). Internal nodes are not duplicated.

Note: For nodes with a graphics.gd/classdb/Script attached, if graphics.gd/classdb/Object.Instance.Init has been defined with required parameters, the duplicated node will not have a graphics.gd/classdb/Script.

func (Expanded) FindChild ¶

func (self Expanded) FindChild(pattern string, recursive bool, owned bool) Instance

Finds the first descendant of this node whose Instance.Name matches 'pattern', returning null if no match is found. The matching is done against node names, not their paths, through graphics.gd/classdb/String.Instance.Match. As such, it is case-sensitive, "*" matches zero or more characters, and "?" matches any single character.

If 'recursive' is false, only this node's direct children are checked. Nodes are checked in tree order, so this node's first direct child is checked first, then its own direct children, etc., before moving to the second direct child, and so on. Internal children are also included in the search (see internal parameter in Instance.AddChild).

If 'owned' is true, only descendants with a valid Instance.Owner node are checked.

Note: This method can be very slow. Consider storing a reference to the found node in a variable. Alternatively, use Instance.GetNode with unique names (see Instance.UniqueNameInOwner).

Note: To find all descendant nodes matching a pattern or a class type, see Instance.FindChildren.

func (Expanded) FindChildren ¶

func (self Expanded) FindChildren(pattern string, atype string, recursive bool, owned bool) []Instance

Finds all descendants of this node whose names match 'pattern', returning an empty slice if no match is found. The matching is done against node names, not their paths, through graphics.gd/classdb/String.Instance.Match. As such, it is case-sensitive, "*" matches zero or more characters, and "?" matches any single character.

If 'type' is not empty, only ancestors inheriting from 'type' are included (see graphics.gd/classdb/Object.Instance.IsClass).

If 'recursive' is false, only this node's direct children are checked. Nodes are checked in tree order, so this node's first direct child is checked first, then its own direct children, etc., before moving to the second direct child, and so on. Internal children are also included in the search (see internal parameter in Instance.AddChild).

If 'owned' is true, only descendants with a valid Instance.Owner node are checked.

Note: This method can be very slow. Consider storing references to the found nodes in a variable.

Note: To find a single descendant node matching a pattern, see Instance.FindChild.

func (Expanded) GetChild ¶

func (self Expanded) GetChild(idx int, include_internal bool) Instance

Fetches a child node by its index. Each child node has an index relative to its siblings (see Instance.GetIndex). The first child is at index 0. Negative values can also be used to start from the end of the list. This method can be used in combination with Instance.GetChildCount to iterate over this node's children. If no child exists at the given index, this method returns null and an error is generated.

If 'include_internal' is false, internal children are ignored (see Instance.AddChild's internal parameter).

Note: To fetch a node by node path, use Instance.GetNode.

func (Expanded) GetChildCount ¶

func (self Expanded) GetChildCount(include_internal bool) int

Returns the number of children of this node.

If 'include_internal' is false, internal children are not counted (see Instance.AddChild's internal parameter).

func (Expanded) GetChildren ¶

func (self Expanded) GetChildren(include_internal bool) []Instance

Returns all children of this node inside an slice.

If 'include_internal' is false, excludes internal children from the returned array (see Instance.AddChild's internal parameter).

func (Expanded) GetIndex ¶

func (self Expanded) GetIndex(include_internal bool) int

Returns this node's order among its siblings. The first node's index is 0. See also Instance.GetChild.

If 'include_internal' is false, returns the index ignoring internal children. The first, non-internal child will have an index of 0 (see Instance.AddChild's internal parameter).

func (Expanded) GetPathTo ¶

func (self Expanded) GetPathTo(node Instance, use_unique_path bool) string

Returns the relative node path from this node to the specified 'node'. Both nodes must be in the same graphics.gd/classdb/SceneTree or scene hierarchy, otherwise this method fails and returns an empty node path.

If 'use_unique_path' is true, returns the shortest path accounting for this node's unique name (see Instance.UniqueNameInOwner).

Note: If you get a relative path which starts from a unique node, the path may be longer than a normal relative path, due to the addition of the unique node's name.

func (Expanded) PropagateCall ¶

func (self Expanded) PropagateCall(method string, args []any, parent_first bool)

Calls the given 'method' name, passing 'args' as arguments, on this node and all of its children, recursively.

If 'parent_first' is true, the method is called on this node first, then on all of its children. If false, the children's methods are called first.

func (Expanded) Reparent ¶

func (self Expanded) Reparent(new_parent Instance, keep_global_transform bool)

Changes the parent of this graphics.gd/classdb/Node to the 'new_parent'. The node needs to already have a parent. The node's Instance.Owner is preserved if its owner is still reachable from the new location (i.e., the node is still a descendant of the new parent after the operation).

If 'keep_global_transform' is true, the node's global transform will be preserved if supported. graphics.gd/classdb/Node2D, graphics.gd/classdb/Node3D and graphics.gd/classdb/Control support this argument (but graphics.gd/classdb/Control keeps only position).

func (Expanded) ReplaceBy ¶

func (self Expanded) ReplaceBy(node Instance, keep_groups bool)

Replaces this node by the given 'node'. All children of this node are moved to 'node'.

If 'keep_groups' is true, the 'node' is added to the same groups that the replaced node is in (see Instance.AddToGroup).

Warning: The replaced node is removed from the tree, but it is not deleted. To prevent memory leaks, store a reference to the node in a variable, or use graphics.gd/classdb/Object.Instance.Free.

func (Expanded) SetMultiplayerAuthority ¶

func (self Expanded) SetMultiplayerAuthority(id int, recursive bool)

Sets the node's multiplayer authority to the peer with the given peer 'id'. The multiplayer authority is the peer that has authority over the node on the network. Defaults to peer ID 1 (the server). Useful in conjunction with Instance.RpcConfig and the graphics.gd/classdb/MultiplayerAPI.

If 'recursive' is true, the given peer is recursively set as the authority for all children of this node.

Warning: This does not automatically replicate the new authority to other peers. It is the developer's responsibility to do so. You may replicate the new authority's information using graphics.gd/classdb/MultiplayerSpawner.Instance.SpawnFunction, an RPC, or a graphics.gd/classdb/MultiplayerSynchronizer. Furthermore, the parent's authority does not propagate to newly added children.

func (*Extension[T]) AsNode ¶

func (self *Extension[T]) AsNode() Instance

func (*Extension[T]) AsObject ¶

func (self *Extension[T]) AsObject() [1]gd.Object

func (ID) Instance ¶

func (id ID) Instance() (Instance, bool)

func (Instance) AddChild ¶

func (self Instance) AddChild(node Instance)

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 'force_readable_name' is true, improves the readability of the added 'node'. If not named, the 'node' is renamed to its type, and if it shares Instance.Name with a sibling, a number is suffixed more appropriately. This operation is very slow. As such, it is recommended leaving this to false, which assigns a dummy name featuring @ in both situations.

If 'internal' is different than InternalModeDisabled, the child will be added as internal node. These nodes are ignored by methods like Instance.GetChildren, unless their parameter include_internal is true. It also prevents these nodes being duplicated with their parent. The intended usage is to hide the internal nodes from the user, so the user won't accidentally delete or modify them. Used by some GUI nodes, e.g. graphics.gd/classdb/ColorPicker.

Note: If 'node' already has a parent, this method will fail. Use Instance.RemoveChild first to remove 'node' from its current parent. For example:

If you need the child node to be added below a specific node in the list of children, use Instance.AddSibling instead of this method.

Note: If you want a child to be persisted to a graphics.gd/classdb/PackedScene, you must set Instance.Owner in addition to calling Instance.AddChild. This is typically relevant for tool scripts and editor plugins. If Instance.AddChild is called without setting Instance.Owner, the newly added graphics.gd/classdb/Node will not be visible in the scene tree, though it will be visible in the 2D/3D view.

func (Instance) AddSibling ¶

func (self Instance) AddSibling(sibling Instance)

Adds a 'sibling' node to this node's parent, and moves the added sibling right below this node.

If 'force_readable_name' is true, improves the readability of the added 'sibling'. If not named, the 'sibling' is renamed to its type, and if it shares Instance.Name with a sibling, a number is suffixed more appropriately. This operation is very slow. As such, it is recommended leaving this to false, which assigns a dummy name featuring @ in both situations.

Use Instance.AddChild instead of this method if you don't need the child node to be added below a specific node in the list of children.

Note: If this node is internal, the added sibling will be internal too (see Instance.AddChild's internal parameter).

func (Instance) AddToGroup ¶

func (self Instance) AddToGroup(group string)

Adds the node to the 'group'. Groups can be helpful to organize a subset of nodes, for example "enemies" or "collectables". See notes in the description, and the group methods in graphics.gd/classdb/SceneTree.

If 'persistent' is true, the group will be stored when saved inside a graphics.gd/classdb/PackedScene. All groups created and displayed in the Node dock are persistent.

Note: To improve performance, the order of group names is not guaranteed and may vary between project runs. Therefore, do not rely on the group order.

Note: graphics.gd/classdb/SceneTree's group methods will not work on this node if not inside the tree (see Instance.IsInsideTree).

func (Instance) AsNode ¶

func (self Instance) AsNode() Instance

func (Instance) AsObject ¶

func (self Instance) AsObject() [1]gd.Object

func (Instance) Atr ¶

func (self Instance) Atr(message string) string

Translates a 'message', using the translation catalogs configured in the Project Settings. Further 'context' can be specified to help with the translation. Note that most graphics.gd/classdb/Control nodes automatically translate their strings, so this method is mostly useful for formatted strings or custom drawn text.

This method works the same as graphics.gd/classdb/Object.Instance.Tr, with the addition of respecting the Instance.AutoTranslateMode state.

If graphics.gd/classdb/Object.Instance.CanTranslateMessages is false, or no translation is available, this method returns the 'message' without changes. See graphics.gd/classdb/Object.Instance.SetMessageTranslation.

For detailed examples, see Internationalizing games.

func (Instance) AtrN ¶

func (self Instance) AtrN(message string, plural_message string, n int) string

Translates a 'message' or 'plural_message', using the translation catalogs configured in the Project Settings. Further 'context' can be specified to help with the translation.

This method works the same as graphics.gd/classdb/Object.Instance.TrN, with the addition of respecting the Instance.AutoTranslateMode state.

If graphics.gd/classdb/Object.Instance.CanTranslateMessages is false, or no translation is available, this method returns 'message' or 'plural_message', without changes. See graphics.gd/classdb/Object.Instance.SetMessageTranslation.

The 'n' is the number, or amount, of the message's subject. It is used by the translation system to fetch the correct plural form for the current language.

For detailed examples, see Localization using gettext.

Note: Negative and [Float.X] numbers may not properly apply to some countable subjects. It's recommended to handle these cases with Instance.Atr.

func (Instance) AutoTranslateMode ¶

func (self Instance) AutoTranslateMode() AutoTranslateMode

func (Instance) BindNode ¶

func (self Instance) BindNode(peer Tween.Instance) Tween.Instance

Binds this [Tween] with the given [param node]. [Tween]s are processed directly by the [SceneTree], so they run independently of the animated nodes. When you bind a [Node] with the [Tween], the [Tween] will halt the animation when the object is not inside tree and the [Tween] will be automatically killed when the bound object is freed. Also [constant TWEEN_PAUSE_BOUND] will make the pausing behavior dependent on the bound node. For a shorter way to create and bind a [Tween], you can use [method Node.create_tween].

func (Instance) CallDeferredThreadGroup ¶

func (self Instance) CallDeferredThreadGroup(method string, args ...any) any

This function is similar to graphics.gd/classdb/Object.Instance.CallDeferred except that the call will take place when the node thread group is processed. If the node thread group processes in sub-threads, then the call will be done on that thread, right before NotificationProcess or NotificationPhysicsProcess, the [Interface.Process] or [Interface.PhysicsProcess] or their internal versions are called.

func (Instance) CallThreadSafe ¶

func (self Instance) CallThreadSafe(method string, args ...any) any

This function ensures that the calling of this function will succeed, no matter whether it's being done from a thread or not. If called from a thread that is not allowed to call the function, the call will become deferred. Otherwise, the call will go through directly.

func (Instance) CanAutoTranslate ¶

func (self Instance) CanAutoTranslate() bool

Returns true if this node can automatically translate messages depending on the current locale. See Instance.AutoTranslateMode, Instance.Atr, and Instance.AtrN.

func (Instance) CanProcess ¶

func (self Instance) CanProcess() bool

Returns true if the node can receive processing notifications and input callbacks (NotificationProcess, [Interface.Input], etc.) from the graphics.gd/classdb/SceneTree and graphics.gd/classdb/Viewport. The returned value depends on Instance.ProcessMode:

- If set to ProcessModePausable, returns true when the game is processing, i.e. graphics.gd/classdb/SceneTree.Instance.Paused is false;

- If set to ProcessModeWhenPaused, returns true when the game is paused, i.e. graphics.gd/classdb/SceneTree.Instance.Paused is true;

- If set to ProcessModeAlways, always returns true;

- If set to ProcessModeDisabled, always returns false;

- If set to ProcessModeInherit, use the parent node's Instance.ProcessMode to determine the result.

If the node is not inside the tree, returns false no matter the value of Instance.ProcessMode.

func (Instance) CreateTween ¶

func (self Instance) CreateTween() Tween.Instance

Creates a new graphics.gd/classdb/Tween and binds it to this node.

This is the equivalent of doing:

The Tween will start automatically on the next process frame or physics frame (depending on [Tween.TweenProcessMode]). See graphics.gd/classdb/Tween.Instance.BindNode for more info on Tweens bound to nodes.

Note: The method can still be used when the node is not inside graphics.gd/classdb/SceneTree. It can fail in an unlikely case of using a custom graphics.gd/classdb/MainLoop.

func (Instance) Duplicate ¶

func (self Instance) Duplicate() Instance

Duplicates the node, returning a new node with all of its properties, signals, groups, and children copied from the original. The behavior can be tweaked through the 'flags' (see DuplicateFlags). Internal nodes are not duplicated.

Note: For nodes with a graphics.gd/classdb/Script attached, if graphics.gd/classdb/Object.Instance.Init has been defined with required parameters, the duplicated node will not have a graphics.gd/classdb/Script.

func (Instance) EditorDescription ¶

func (self Instance) EditorDescription() string

func (Instance) FindChild ¶

func (self Instance) FindChild(pattern string) Instance

Finds the first descendant of this node whose Instance.Name matches 'pattern', returning null if no match is found. The matching is done against node names, not their paths, through graphics.gd/classdb/String.Instance.Match. As such, it is case-sensitive, "*" matches zero or more characters, and "?" matches any single character.

If 'recursive' is false, only this node's direct children are checked. Nodes are checked in tree order, so this node's first direct child is checked first, then its own direct children, etc., before moving to the second direct child, and so on. Internal children are also included in the search (see internal parameter in Instance.AddChild).

If 'owned' is true, only descendants with a valid Instance.Owner node are checked.

Note: This method can be very slow. Consider storing a reference to the found node in a variable. Alternatively, use Instance.GetNode with unique names (see Instance.UniqueNameInOwner).

Note: To find all descendant nodes matching a pattern or a class type, see Instance.FindChildren.

func (Instance) FindChildren ¶

func (self Instance) FindChildren(pattern string) []Instance

Finds all descendants of this node whose names match 'pattern', returning an empty slice if no match is found. The matching is done against node names, not their paths, through graphics.gd/classdb/String.Instance.Match. As such, it is case-sensitive, "*" matches zero or more characters, and "?" matches any single character.

If 'type' is not empty, only ancestors inheriting from 'type' are included (see graphics.gd/classdb/Object.Instance.IsClass).

If 'recursive' is false, only this node's direct children are checked. Nodes are checked in tree order, so this node's first direct child is checked first, then its own direct children, etc., before moving to the second direct child, and so on. Internal children are also included in the search (see internal parameter in Instance.AddChild).

If 'owned' is true, only descendants with a valid Instance.Owner node are checked.

Note: This method can be very slow. Consider storing references to the found nodes in a variable.

Note: To find a single descendant node matching a pattern, see Instance.FindChild.

func (Instance) FindParent ¶

func (self Instance) FindParent(pattern string) Instance

Finds the first ancestor of this node whose Instance.Name matches 'pattern', returning null if no match is found. The matching is done through graphics.gd/classdb/String.Instance.Match. As such, it is case-sensitive, "*" matches zero or more characters, and "?" matches any single character. See also Instance.FindChild and Instance.FindChildren.

Note: As this method walks upwards in the scene tree, it can be slow in large, deeply nested nodes. Consider storing a reference to the found node in a variable. Alternatively, use Instance.GetNode with unique names (see Instance.UniqueNameInOwner).

func (Instance) GetAccessibilityElement ¶

func (self Instance) GetAccessibilityElement() RID.AccessibilityElement

Returns main accessibility element RID.

Note: This method should be called only during accessibility information updates (NotificationAccessibilityUpdate).

func (Instance) GetChild ¶

func (self Instance) GetChild(idx int) Instance

Fetches a child node by its index. Each child node has an index relative to its siblings (see Instance.GetIndex). The first child is at index 0. Negative values can also be used to start from the end of the list. This method can be used in combination with Instance.GetChildCount to iterate over this node's children. If no child exists at the given index, this method returns null and an error is generated.

If 'include_internal' is false, internal children are ignored (see Instance.AddChild's internal parameter).

Note: To fetch a node by node path, use Instance.GetNode.

func (Instance) GetChildCount ¶

func (self Instance) GetChildCount() int

Returns the number of children of this node.

If 'include_internal' is false, internal children are not counted (see Instance.AddChild's internal parameter).

func (Instance) GetChildren ¶

func (self Instance) GetChildren() []Instance

Returns all children of this node inside an slice.

If 'include_internal' is false, excludes internal children from the returned array (see Instance.AddChild's internal parameter).

func (Instance) GetGroups ¶

func (self Instance) GetGroups() []string

Returns an slice of group names that the node has been added to.

Note: To improve performance, the order of group names is not guaranteed and may vary between project runs. Therefore, do not rely on the group order.

Note: This method may also return some group names starting with an underscore (_). These are internally used by the engine. To avoid conflicts, do not use custom groups starting with underscores. To exclude internal groups, see the following code snippet:

func (Instance) GetIndex ¶

func (self Instance) GetIndex() int

Returns this node's order among its siblings. The first node's index is 0. See also Instance.GetChild.

If 'include_internal' is false, returns the index ignoring internal children. The first, non-internal child will have an index of 0 (see Instance.AddChild's internal parameter).

func (Instance) GetMultiplayerAuthority ¶

func (self Instance) GetMultiplayerAuthority() int

Returns the peer ID of the multiplayer authority for this node. See Instance.SetMultiplayerAuthority.

func (Instance) GetNode ¶

func (self Instance) GetNode(path string) Instance

Fetches a node. The node path can either be a relative path (from this node), or an absolute path (from the graphics.gd/classdb/SceneTree.Instance.Root) to a node. If 'path' does not point to a valid node, generates an error and returns null. Attempts to access methods on the return value will result in an "Attempt to call <method> on a null instance." error.

Note: Fetching by absolute path only works when the node is inside the scene tree (see Instance.IsInsideTree).

Example: Assume this method is called from the Character node, inside the following tree:

The following calls will return a valid node:

func (Instance) GetNodeAndResource ¶

func (self Instance) GetNodeAndResource(path string) (Instance, Resource.Instance, string)

Fetches a node and its most nested resource as specified by the node path's subname. Returns an slice of size 3 where:

- Element 0 is the graphics.gd/classdb/Node, or null if not found;

- Element 1 is the subname's last nested graphics.gd/classdb/Resource, or null if not found;

- Element 2 is the remaining node path, referring to an existing, non-graphics.gd/classdb/Resource property (see graphics.gd/classdb/Object.Instance.GetIndexed).

Example: Assume that the child's graphics.gd/classdb/Sprite2D.Instance.Texture has been assigned an graphics.gd/classdb/AtlasTexture:

func (Instance) GetNodeOrNull ¶

func (self Instance) GetNodeOrNull(path string) Instance

Fetches a node by node path. Similar to Instance.GetNode, but does not generate an error if 'path' does not point to a valid node.

func (Instance) GetNodeRpcConfig ¶

func (self Instance) GetNodeRpcConfig() any

Returns a data structure mapping method names to their RPC configuration defined for this node using Instance.RpcConfig.

Note: This method only returns the RPC configuration assigned via Instance.RpcConfig. See graphics.gd/classdb/Script.Instance.GetRpcConfig to retrieve the RPCs defined by the graphics.gd/classdb/Script.

func (Instance) GetParent ¶

func (self Instance) GetParent() Instance

Returns this node's parent node, or null if the node doesn't have a parent.

func (Instance) GetPath ¶

func (self Instance) GetPath() string

Returns the node's absolute path, relative to the graphics.gd/classdb/SceneTree.Instance.Root. If the node is not inside the scene tree, this method fails and returns an empty node path.

func (Instance) GetPathTo ¶

func (self Instance) GetPathTo(node Instance) string

Returns the relative node path from this node to the specified 'node'. Both nodes must be in the same graphics.gd/classdb/SceneTree or scene hierarchy, otherwise this method fails and returns an empty node path.

If 'use_unique_path' is true, returns the shortest path accounting for this node's unique name (see Instance.UniqueNameInOwner).

Note: If you get a relative path which starts from a unique node, the path may be longer than a normal relative path, due to the addition of the unique node's name.

func (Instance) GetPhysicsProcessDeltaTime ¶

func (self Instance) GetPhysicsProcessDeltaTime() Float.X

Returns the time elapsed (in seconds) since the last physics callback. This value is identical to [Interface.PhysicsProcess]'s delta parameter, and is often consistent at run-time, unless graphics.gd/classdb/Engine.PhysicsTicksPerSecond is changed. See also NotificationPhysicsProcess.

Note: The returned value will be larger than expected if running at a framerate lower than graphics.gd/classdb/Engine.PhysicsTicksPerSecond / graphics.gd/classdb/Engine.MaxPhysicsStepsPerFrame FPS. This is done to avoid "spiral of death" scenarios where performance would plummet due to an ever-increasing number of physics steps per frame. This behavior affects both [Interface.Process] and [Interface.PhysicsProcess]. As a result, avoid using delta for time measurements in real-world seconds. Use the graphics.gd/classdb/Time singleton's methods for this purpose instead, such as graphics.gd/classdb/Time.GetTicksUsec.

func (Instance) GetProcessDeltaTime ¶

func (self Instance) GetProcessDeltaTime() Float.X

Returns the time elapsed (in seconds) since the last process callback. This value is identical to [Interface.Process]'s delta parameter, and may vary from frame to frame. See also NotificationProcess.

Note: The returned value will be larger than expected if running at a framerate lower than graphics.gd/classdb/Engine.PhysicsTicksPerSecond / graphics.gd/classdb/Engine.MaxPhysicsStepsPerFrame FPS. This is done to avoid "spiral of death" scenarios where performance would plummet due to an ever-increasing number of physics steps per frame. This behavior affects both [Interface.Process] and [Interface.PhysicsProcess]. As a result, avoid using delta for time measurements in real-world seconds. Use the graphics.gd/classdb/Time singleton's methods for this purpose instead, such as graphics.gd/classdb/Time.GetTicksUsec.

func (Instance) GetSceneInstanceLoadPlaceholder ¶

func (self Instance) GetSceneInstanceLoadPlaceholder() bool

Returns true if this node is an instance load placeholder. See graphics.gd/classdb/InstancePlaceholder and Instance.SetSceneInstanceLoadPlaceholder.

func (Instance) GetTreeString ¶

func (self Instance) GetTreeString() string

Returns the tree as a string. Used mainly for debugging purposes. This version displays the path relative to the current node, and is good for copy/pasting into the Instance.GetNode function. It also can be used in game UI/UX.

May print, for example:

func (Instance) GetTreeStringPretty ¶

func (self Instance) GetTreeStringPretty() string

Similar to Instance.GetTreeString, this returns the tree as a string. This version displays a more graphical representation similar to what is displayed in the Scene Dock. It is useful for inspecting larger trees.

May print, for example:

func (Instance) HasNode ¶

func (self Instance) HasNode(path string) bool

Returns true if the 'path' points to a valid node. See also Instance.GetNode.

func (Instance) HasNodeAndResource ¶

func (self Instance) HasNodeAndResource(path string) bool

Returns true if 'path' points to a valid node and its subnames point to a valid graphics.gd/classdb/Resource, e.g. Area2D/CollisionShape2D:shape. Properties that are not graphics.gd/classdb/Resource types (such as nodes or other any types) are not considered. See also Instance.GetNodeAndResource.

func (Instance) ID ¶

func (self Instance) ID() ID

func (Instance) IsAncestorOf ¶

func (self Instance) IsAncestorOf(node Instance) bool

Returns true if the given 'node' is a direct or indirect child of this node.

func (Instance) IsDisplayedFolded ¶

func (self Instance) IsDisplayedFolded() bool

Returns true if the node is folded (collapsed) in the Scene dock. This method is intended to be used in editor plugins and tools. See also Instance.SetDisplayFolded.

func (Instance) IsEditableInstance ¶

func (self Instance) IsEditableInstance(node Instance) bool

Returns true if 'node' has editable children enabled relative to this node. This method is intended to be used in editor plugins and tools. See also Instance.SetEditableInstance.

func (Instance) IsGreaterThan ¶

func (self Instance) IsGreaterThan(node Instance) bool

Returns true if the given 'node' occurs later in the scene hierarchy than this node. A node occurring later is usually processed last.

func (Instance) IsInGroup ¶

func (self Instance) IsInGroup(group string) bool

Returns true if this node has been added to the given 'group'. See Instance.AddToGroup and Instance.RemoveFromGroup. See also notes in the description, and the graphics.gd/classdb/SceneTree's group methods.

func (Instance) IsInsideTree ¶

func (self Instance) IsInsideTree() bool

Returns true if this node is currently inside a graphics.gd/classdb/SceneTree. See also [Instance.GetTree].

func (Instance) IsMultiplayerAuthority ¶

func (self Instance) IsMultiplayerAuthority() bool

Returns true if the local system is the multiplayer authority of this node.

func (Instance) IsNodeReady ¶

func (self Instance) IsNodeReady() bool

Returns true if the node is ready, i.e. it's inside scene tree and all its children are initialized.

Instance.RequestReady resets it back to false.

func (Instance) IsPartOfEditedScene ¶

func (self Instance) IsPartOfEditedScene() bool

Returns true if the node is part of the scene currently opened in the editor.

func (Instance) IsPhysicsInterpolated ¶

func (self Instance) IsPhysicsInterpolated() bool

Returns true if physics interpolation is enabled for this node (see Instance.PhysicsInterpolationMode).

Note: Interpolation will only be active if both the flag is set and physics interpolation is enabled within the graphics.gd/classdb/SceneTree. This can be tested using Instance.IsPhysicsInterpolatedAndEnabled.

func (Instance) IsPhysicsInterpolatedAndEnabled ¶

func (self Instance) IsPhysicsInterpolatedAndEnabled() bool

Returns true if physics interpolation is enabled (see Instance.PhysicsInterpolationMode) and enabled in the graphics.gd/classdb/SceneTree.

This is a convenience version of Instance.IsPhysicsInterpolated that also checks whether physics interpolation is enabled globally.

See graphics.gd/classdb/SceneTree.Instance.PhysicsInterpolation and graphics.gd/classdb/ProjectSettings "physics/common/physics_interpolation".

func (Instance) IsPhysicsProcessing ¶

func (self Instance) IsPhysicsProcessing() bool

Returns true if physics processing is enabled (see Instance.SetPhysicsProcess).

func (Instance) IsPhysicsProcessingInternal ¶

func (self Instance) IsPhysicsProcessingInternal() bool

Returns true if internal physics processing is enabled (see Instance.SetPhysicsProcessInternal).

func (Instance) IsProcessing ¶

func (self Instance) IsProcessing() bool

Returns true if processing is enabled (see Instance.SetProcess).

func (Instance) IsProcessingInput ¶

func (self Instance) IsProcessingInput() bool

Returns true if the node is processing input (see Instance.SetProcessInput).

func (Instance) IsProcessingInternal ¶

func (self Instance) IsProcessingInternal() bool

Returns true if internal processing is enabled (see Instance.SetProcessInternal).

func (Instance) IsProcessingShortcutInput ¶

func (self Instance) IsProcessingShortcutInput() bool

Returns true if the node is processing shortcuts (see Instance.SetProcessShortcutInput).

func (Instance) IsProcessingUnhandledInput ¶

func (self Instance) IsProcessingUnhandledInput() bool

Returns true if the node is processing unhandled input (see Instance.SetProcessUnhandledInput).

func (Instance) IsProcessingUnhandledKeyInput ¶

func (self Instance) IsProcessingUnhandledKeyInput() bool

Returns true if the node is processing unhandled key input (see Instance.SetProcessUnhandledKeyInput).

func (Instance) IsQueuedForDeletion ¶

func (self Instance) IsQueuedForDeletion() bool

IsQueuedForDeletion returns true if the Instance.QueueFree method was called for the object.

func (Instance) MoveChild ¶

func (self Instance) MoveChild(child_node Instance, to_index int)

Moves 'child_node' to the given index. A node's index is the order among its siblings. If 'to_index' is negative, the index is counted from the end of the list. See also Instance.GetChild and Instance.GetIndex.

Note: The processing order of several engine callbacks ([Interface.Ready], [Interface.Process], etc.) and notifications sent through Instance.PropagateNotification is affected by tree order. graphics.gd/classdb/CanvasItem nodes are also rendered in tree order. See also Instance.ProcessPriority.

func (Instance) Multiplayer ¶

func (self Instance) Multiplayer() MultiplayerAPI.Instance

func (Instance) Name ¶

func (self Instance) Name() string

func (Instance) NotifyDeferredThreadGroup ¶

func (self Instance) NotifyDeferredThreadGroup(what int)

Similar to Instance.CallDeferredThreadGroup, but for notifications.

func (Instance) NotifyThreadSafe ¶

func (self Instance) NotifyThreadSafe(what int)

Similar to Instance.CallThreadSafe, but for notifications.

func (Instance) OnChildEnteredTree ¶

func (self Instance) OnChildEnteredTree(cb func(node Instance), flags ...Signal.Flags)

func (Instance) OnChildExitingTree ¶

func (self Instance) OnChildExitingTree(cb func(node Instance), flags ...Signal.Flags)

func (Instance) OnChildOrderChanged ¶

func (self Instance) OnChildOrderChanged(cb func(), flags ...Signal.Flags)

func (Instance) OnEditorDescriptionChanged ¶

func (self Instance) OnEditorDescriptionChanged(cb func(node Instance), flags ...Signal.Flags)

func (Instance) OnEditorStateChanged ¶

func (self Instance) OnEditorStateChanged(cb func(), flags ...Signal.Flags)

func (Instance) OnReady ¶

func (self Instance) OnReady(cb func(), flags ...Signal.Flags)

func (Instance) OnRenamed ¶

func (self Instance) OnRenamed(cb func(), flags ...Signal.Flags)

func (Instance) OnReplacingBy ¶

func (self Instance) OnReplacingBy(cb func(node Instance), flags ...Signal.Flags)

func (Instance) OnTreeEntered ¶

func (self Instance) OnTreeEntered(cb func(), flags ...Signal.Flags)

func (Instance) OnTreeExited ¶

func (self Instance) OnTreeExited(cb func(), flags ...Signal.Flags)

func (Instance) OnTreeExiting ¶

func (self Instance) OnTreeExiting(cb func(), flags ...Signal.Flags)

func (Instance) Owner ¶

func (self Instance) Owner() Instance

func (Instance) PhysicsInterpolationMode ¶

func (self Instance) PhysicsInterpolationMode() PhysicsInterpolationMode

func (Instance) PrintTree ¶

func (self Instance) PrintTree()

Prints the node and its children to the console, recursively. The node does not have to be inside the tree. This method outputs node paths relative to this node, and is good for copy/pasting into Instance.GetNode. See also Instance.PrintTreePretty.

May print, for example:

func (Instance) PrintTreePretty ¶

func (self Instance) PrintTreePretty()

Prints the node and its children to the console, recursively. The node does not have to be inside the tree. Similar to Instance.PrintTree, but the graphical representation looks like what is displayed in the editor's Scene dock. It is useful for inspecting larger trees.

May print, for example:

func (Instance) ProcessMode ¶

func (self Instance) ProcessMode() ProcessMode

func (Instance) ProcessPhysicsPriority ¶

func (self Instance) ProcessPhysicsPriority() int

func (Instance) ProcessPriority ¶

func (self Instance) ProcessPriority() int

func (Instance) ProcessThreadGroup ¶

func (self Instance) ProcessThreadGroup() ProcessThreadGroup

func (Instance) ProcessThreadGroupOrder ¶

func (self Instance) ProcessThreadGroupOrder() int

func (Instance) ProcessThreadMessages ¶

func (self Instance) ProcessThreadMessages() ProcessThreadMessages

func (Instance) PropagateCall ¶

func (self Instance) PropagateCall(method string)

Calls the given 'method' name, passing 'args' as arguments, on this node and all of its children, recursively.

If 'parent_first' is true, the method is called on this node first, then on all of its children. If false, the children's methods are called first.

func (Instance) PropagateNotification ¶

func (self Instance) PropagateNotification(what int)

Calls graphics.gd/classdb/Object.Instance.Notification with 'what' on this node and all of its children, recursively.

func (Instance) QueueAccessibilityUpdate ¶

func (self Instance) QueueAccessibilityUpdate()

Queues an accessibility information update for this node.

func (Instance) QueueFree ¶

func (self Instance) QueueFree()

Queues this node to be deleted at the end of the current frame. When deleted, all of its children are deleted as well, and all references to the node and its children become invalid.

Unlike with graphics.gd/classdb/Object.Instance.Free, the node is not deleted instantly, and it can still be accessed before deletion. It is also safe to call Instance.QueueFree multiple times. Use graphics.gd/classdb/Object.Instance.IsQueuedForDeletion to check if the node will be deleted at the end of the frame.

Note: The node will only be freed after all other deferred calls are finished. Using this method is not always the same as calling graphics.gd/classdb/Object.Instance.Free through graphics.gd/classdb/Object.Instance.CallDeferred.

func (Instance) RemoveChild ¶

func (self Instance) RemoveChild(node Instance)

Removes a child 'node'. The 'node', along with its children, are not deleted. To delete a node, see Instance.QueueFree.

Note: When this node is inside the tree, this method sets the Instance.Owner of the removed 'node' (or its descendants) to null, if their Instance.Owner is no longer an ancestor (see Instance.IsAncestorOf).

func (Instance) RemoveFromGroup ¶

func (self Instance) RemoveFromGroup(group string)

Removes the node from the given 'group'. Does nothing if the node is not in the 'group'. See also notes in the description, and the graphics.gd/classdb/SceneTree's group methods.

func (Instance) Reparent ¶

func (self Instance) Reparent(new_parent Instance)

Changes the parent of this graphics.gd/classdb/Node to the 'new_parent'. The node needs to already have a parent. The node's Instance.Owner is preserved if its owner is still reachable from the new location (i.e., the node is still a descendant of the new parent after the operation).

If 'keep_global_transform' is true, the node's global transform will be preserved if supported. graphics.gd/classdb/Node2D, graphics.gd/classdb/Node3D and graphics.gd/classdb/Control support this argument (but graphics.gd/classdb/Control keeps only position).

func (Instance) ReplaceBy ¶

func (self Instance) ReplaceBy(node Instance)

Replaces this node by the given 'node'. All children of this node are moved to 'node'.

If 'keep_groups' is true, the 'node' is added to the same groups that the replaced node is in (see Instance.AddToGroup).

Warning: The replaced node is removed from the tree, but it is not deleted. To prevent memory leaks, store a reference to the node in a variable, or use graphics.gd/classdb/Object.Instance.Free.

func (Instance) RequestReady ¶

func (self Instance) RequestReady()

Requests [Interface.Ready] to be called again the next time the node enters the tree. Does not immediately call [Interface.Ready].

Note: This method only affects the current node. If the node's children also need to request ready, this method needs to be called for each one of them. When the node and its children enter the tree again, the order of [Interface.Ready] callbacks will be the same as normal.

func (Instance) ResetPhysicsInterpolation ¶

func (self Instance) ResetPhysicsInterpolation()

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.

That glitch can be prevented by calling this method, which temporarily disables interpolation until the physics tick is complete.

The notification NotificationResetPhysicsInterpolation will be received by the node and all children recursively.

Note: This function should be called after moving the node, rather than before.

func (Instance) Rpc ¶

func (self Instance) Rpc(method string, args ...any) error

Sends a remote procedure call request for the given 'method' to peers on the network (and locally), sending additional arguments to the method called by the RPC. The call request will only be received by nodes with the same node path, including the exact same Instance.Name. Behavior depends on the RPC configuration for the given 'method' (see Instance.RpcConfig and ). By default, methods are not exposed to RPCs.

May return [constant OK] if the call is successful, [constant ERR_INVALID_PARAMETER] if the arguments passed in the [param method] do not match, [constant ERR_UNCONFIGURED] if the node's [member multiplayer] cannot be fetched (such as when the node is not inside the tree), [constant ERR_CONNECTION_ERROR] if [member multiplayer]'s connection is not available.

[b]Note:[/b] You can only safely use RPCs on clients after you received the [signal MultiplayerAPI.connected_to_server] signal from the [MultiplayerAPI]. You also need to keep track of the connection state, either by the [MultiplayerAPI] signals like [signal MultiplayerAPI.server_disconnected] or by checking ([code]get_multiplayer().peer.get_connection_status() == CONNECTION_CONNECTED[/code]).). By default, methods are not exposed to RPCs.

May return [Ok] if the call is successful, [ErrInvalidParameter] if the arguments passed in the 'method' do not match, [ErrUnconfigured] if the node's Instance.Multiplayer cannot be fetched (such as when the node is not inside the tree), [ErrConnectionError] if Instance.Multiplayer's connection is not available.

Note: You can only safely use RPCs on clients after you received the [Instance.OnMultiplayerapi.ConnectedToServer] signal from the graphics.gd/classdb/MultiplayerAPI. You also need to keep track of the connection state, either by the graphics.gd/classdb/MultiplayerAPI signals like [Instance.OnMultiplayerapi.ServerDisconnected] or by checking (get_multiplayer().peer.get_connection_status() == CONNECTION_CONNECTED).

func (Instance) RpcConfig ¶

func (self Instance) RpcConfig(method string, config any)

Changes the RPC configuration for the given 'method'. 'config' should either be null to disable the feature (as by default), or a data structure containing the following entries:

- rpc_mode: see [MultiplayerAPI.RPCMode];

- transfer_mode: see [MultiplayerPeer.TransferMode];

- call_local: if true, the method will also be called locally;

- channel: an int representing the channel to send the RPC on.

Note: In GDScript, this method corresponds to the annotation, with various parameters passed ([code]@rpc(any)[/code], [code]@rpc(authority)[/code]...). See also the [url=https://docs.godotengine.org/tutorials/networking/high_level_multiplayer.html]high-level multiplayer[/url] tutorial. annotation, with various parameters passed (@rpc(any), @rpc(authority)...). See also the high-level multiplayer tutorial.

func (Instance) RpcId ¶

func (self Instance) RpcId(peer_id int, method string, args ...any) error

Sends a Instance.Rpc to a specific peer identified by 'peer_id' (see graphics.gd/classdb/MultiplayerPeer.Instance.SetTargetPeer).

May return [Ok] if the call is successful, [ErrInvalidParameter] if the arguments passed in the 'method' do not match, [ErrUnconfigured] if the node's Instance.Multiplayer cannot be fetched (such as when the node is not inside the tree), [ErrConnectionError] if Instance.Multiplayer's connection is not available.

func (Instance) SceneFilePath ¶

func (self Instance) SceneFilePath() string

func (Instance) SetAutoTranslateMode ¶

func (self Instance) SetAutoTranslateMode(value AutoTranslateMode)

func (Instance) SetDeferredThreadGroup ¶

func (self Instance) SetDeferredThreadGroup(property string, value any)

Similar to Instance.CallDeferredThreadGroup, but for setting properties.

func (Instance) SetDisplayFolded ¶

func (self Instance) SetDisplayFolded(fold bool)

If set to true, the node appears folded in the Scene dock. As a result, all of its children are hidden. This method is intended to be used in editor plugins and tools, but it also works in release builds. See also Instance.IsDisplayedFolded.

func (Instance) SetEditableInstance ¶

func (self Instance) SetEditableInstance(node Instance, is_editable bool)

Set to true to allow all nodes owned by 'node' to be available, and editable, in the Scene dock, even if their Instance.Owner is not the scene root. This method is intended to be used in editor plugins and tools, but it also works in release builds. See also Instance.IsEditableInstance.

func (Instance) SetEditorDescription ¶

func (self Instance) SetEditorDescription(value string)

func (Instance) SetMultiplayerAuthority ¶

func (self Instance) SetMultiplayerAuthority(id int)

Sets the node's multiplayer authority to the peer with the given peer 'id'. The multiplayer authority is the peer that has authority over the node on the network. Defaults to peer ID 1 (the server). Useful in conjunction with Instance.RpcConfig and the graphics.gd/classdb/MultiplayerAPI.

If 'recursive' is true, the given peer is recursively set as the authority for all children of this node.

Warning: This does not automatically replicate the new authority to other peers. It is the developer's responsibility to do so. You may replicate the new authority's information using graphics.gd/classdb/MultiplayerSpawner.Instance.SpawnFunction, an RPC, or a graphics.gd/classdb/MultiplayerSynchronizer. Furthermore, the parent's authority does not propagate to newly added children.

func (Instance) SetName ¶

func (self Instance) SetName(value string)

func (*Instance) SetObject ¶

func (self *Instance) SetObject(obj [1]gd.Object) bool

func (Instance) SetOwner ¶

func (self Instance) SetOwner(value Instance)

func (Instance) SetPhysicsInterpolationMode ¶

func (self Instance) SetPhysicsInterpolationMode(value PhysicsInterpolationMode)

func (Instance) SetPhysicsProcess ¶

func (self Instance) SetPhysicsProcess(enable bool)

If set to true, enables physics (fixed framerate) processing. When a node is being processed, it will receive a NotificationPhysicsProcess at a fixed (usually 60 FPS, see graphics.gd/classdb/Engine.PhysicsTicksPerSecond to change) interval (and the [Interface.PhysicsProcess] callback will be called if it exists).

Note: If [Interface.PhysicsProcess] is overridden, this will be automatically enabled before [Interface.Ready] is called.

func (Instance) SetPhysicsProcessInternal ¶

func (self Instance) SetPhysicsProcessInternal(enable bool)

If set to true, enables internal physics for this node. Internal physics processing happens in isolation from the normal [Interface.PhysicsProcess] 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 (Instance.SetPhysicsProcess).

Warning: Built-in nodes rely on internal processing for their internal logic. Disabling it is unsafe and may lead to unexpected behavior. Use this method if you know what you are doing.

func (Instance) SetProcess ¶

func (self Instance) SetProcess(enable bool)

If set to true, enables processing. When a node is being processed, it will receive a NotificationProcess on every drawn frame (and the [Interface.Process] callback will be called if it exists).

Note: If [Interface.Process] is overridden, this will be automatically enabled before [Interface.Ready] is called.

Note: This method only affects the [Interface.Process] callback, i.e. it has no effect on other callbacks like [Interface.PhysicsProcess]. If you want to disable all processing for the node, set Instance.ProcessMode to ProcessModeDisabled.

func (Instance) SetProcessInput ¶

func (self Instance) SetProcessInput(enable bool)

If set to true, enables input processing.

Note: If [Interface.Input] is overridden, this will be automatically enabled before [Interface.Ready] is called. Input processing is also already enabled for GUI controls, such as graphics.gd/classdb/Button and graphics.gd/classdb/TextEdit.

func (Instance) SetProcessInternal ¶

func (self Instance) SetProcessInternal(enable bool)

If set to true, enables internal processing for this node. Internal processing happens in isolation from the normal [Interface.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 (Instance.SetProcess).

Warning: Built-in nodes rely on internal processing for their internal logic. Disabling it is unsafe and may lead to unexpected behavior. Use this method if you know what you are doing.

func (Instance) SetProcessMode ¶

func (self Instance) SetProcessMode(value ProcessMode)

func (Instance) SetProcessPhysicsPriority ¶

func (self Instance) SetProcessPhysicsPriority(value int)

func (Instance) SetProcessPriority ¶

func (self Instance) SetProcessPriority(value int)

func (Instance) SetProcessShortcutInput ¶

func (self Instance) SetProcessShortcutInput(enable bool)

If set to true, enables shortcut processing for this node.

Note: If [Interface.ShortcutInput] is overridden, this will be automatically enabled before [Interface.Ready] is called.

func (Instance) SetProcessThreadGroup ¶

func (self Instance) SetProcessThreadGroup(value ProcessThreadGroup)

func (Instance) SetProcessThreadGroupOrder ¶

func (self Instance) SetProcessThreadGroupOrder(value int)

func (Instance) SetProcessThreadMessages ¶

func (self Instance) SetProcessThreadMessages(value ProcessThreadMessages)

func (Instance) SetProcessUnhandledInput ¶

func (self Instance) SetProcessUnhandledInput(enable bool)

If set to true, enables unhandled input processing. It enables the node to receive all input that was not previously handled (usually by a graphics.gd/classdb/Control).

Note: If [Interface.UnhandledInput] is overridden, this will be automatically enabled before [Interface.Ready] is called. Unhandled input processing is also already enabled for GUI controls, such as graphics.gd/classdb/Button and graphics.gd/classdb/TextEdit.

func (Instance) SetProcessUnhandledKeyInput ¶

func (self Instance) SetProcessUnhandledKeyInput(enable bool)

If set to true, enables unhandled key input processing.

Note: If [Interface.UnhandledKeyInput] is overridden, this will be automatically enabled before [Interface.Ready] is called.

func (Instance) SetSceneFilePath ¶

func (self Instance) SetSceneFilePath(value string)

func (Instance) SetSceneInstanceLoadPlaceholder ¶

func (self Instance) SetSceneInstanceLoadPlaceholder(load_placeholder bool)

If set to true, the node becomes an graphics.gd/classdb/InstancePlaceholder when packed and instantiated from a graphics.gd/classdb/PackedScene. See also Instance.GetSceneInstanceLoadPlaceholder.

func (Instance) SetThreadSafe ¶

func (self Instance) SetThreadSafe(property string, value any)

Similar to Instance.CallThreadSafe, but for setting properties.

func (Instance) SetTranslationDomainInherited ¶

func (self Instance) SetTranslationDomainInherited()

Makes this node inherit the translation domain from its parent node. If this node has no parent, the main translation domain will be used.

This is the default behavior for all nodes. Calling graphics.gd/classdb/Object.Instance.SetTranslationDomain disables this behavior.

func (Instance) SetUniqueNameInOwner ¶

func (self Instance) SetUniqueNameInOwner(value bool)

func (Instance) UniqueNameInOwner ¶

func (self Instance) UniqueNameInOwner() bool

func (Instance) UpdateConfigurationWarnings ¶

func (self Instance) UpdateConfigurationWarnings()

Refreshes the warnings displayed for this node in the Scene dock. Use [Interface.GetConfigurationWarnings] to customize the warning messages to display.

func (Instance) Virtual ¶

func (self Instance) Virtual(name string) reflect.Value