ProcessThreadGroup

Types

• enum AutoTranslateMode
• enum DuplicateFlags
• enum InternalMode
• enum PhysicsInterpolationMode
• enum ProcessMode
• struct ProcessThreadMessages
• class Signal1

  Signal support.

• class Signal2

  Signal support.

• class Signal3

  Signal support.

• class Signal4

  Signal support.

Type members

• static let notificationApplicationFocusIn: Int

  Notification received from the OS when the application is focused, i.e. when changing the focus from the OS desktop or a thirdparty application to any open window of the Godot instance.

• static let notificationApplicationFocusOut: Int

  Notification received from the OS when the application is defocused, i.e. when changing the focus from any open window of the Godot instance to the OS desktop or a thirdparty application.

• static let notificationApplicationPaused: Int

  Notification received from the OS when the application is paused.

• static let notificationApplicationResumed: Int

  Notification received from the OS when the application is resumed.

• static let notificationChildOrderChanged: Int

  Notification received when the list of children is changed. This happens when child nodes are added, moved or removed.

• static let notificationCrash: Int

  Notification received from Godot’s crash handler when the engine is about to crash.

• static let notificationDisabled: Int

  Notification received when the node is disabled. See .disabled.

• static let notificationDragBegin: Int

  Notification received when a drag operation begins. All nodes receive this notification, not only the dragged one.

• static let notificationDragEnd: Int

  Notification received when a drag operation ends.

• static let notificationEditorPostSave: Int

  Notification received right after the scene with the node is saved in the editor. This notification is only sent in the Godot editor and will not occur in exported projects.

• static let notificationEditorPreSave: Int

  Notification received right before the scene with the node is saved in the editor. This notification is only sent in the Godot editor and will not occur in exported projects.

• static let notificationEnabled: Int

  Notification received when the node is enabled again after being disabled. See .disabled.

• static let notificationEnterTree: Int

  Notification received when the node enters a SceneTree. See _enterTree.

• static let notificationExitTree: Int

  Notification received when the node is about to exit a SceneTree. See _exitTree.

• static let notificationInternalPhysicsProcess: Int

  Notification received from the tree every physics frame when isPhysicsProcessingInternal returns true.

• static let notificationInternalProcess: Int

  Notification received from the tree every rendered frame when isProcessingInternal returns true.

• static let notificationMovedInParent: Int
• static let notificationOsImeUpdate: Int

  Notification received from the OS when an update of the Input Method Engine occurs (e.g. change of IME cursor position or composition string).

• static let notificationOsMemoryWarning: Int

  Notification received from the OS when the application is exceeding its allocated memory.

• static let notificationParented: Int

  Notification received when the node is set as a child of another node (see addChild(node:forceReadableName:`internal`:) and addSibling(_:forceReadableName:)).

• static let notificationPathRenamed: Int

  Notification received when the node’s name or one of its ancestors’ name is changed. This notification is not received when the node is removed from the SceneTree.

• static let notificationPaused: Int

  Notification received when the node is paused. See processMode.

• static let notificationPhysicsProcess: Int

  Notification received from the tree every physics frame when isPhysicsProcessing returns true. See _physicsProcess(delta:).

• static let notificationPostEnterTree: Int

  Notification received when the node enters the tree, just before notificationReady may be received. Unlike the latter, it is sent every time the node enters tree, not just once.

• static let notificationProcess: Int

  Notification received from the tree every rendered frame when isProcessing returns true. See _process(delta:).

• static let notificationReady: Int

  Notification received when the node is ready. See _ready.

• static let notificationResetPhysicsInterpolation: Int

  Notification received when resetPhysicsInterpolation is called on the node or its ancestors.

• static let notificationSceneInstantiated: Int

  Notification received only by the newly instantiated scene root node, when instantiate(editState:) is completed.

• static let notificationTextServerChanged: Int

  Notification received when the TextServer is changed.

• static let notificationTranslationChanged: Int

  Notification received when translations may have changed. Can be triggered by the user changing the locale, changing autoTranslateMode or when the node enters the scene tree. Can be used to respond to language changes, for example to change the UI strings on the fly. Useful when working with the built-in translation support, like tr(message:context:).

• static let notificationUnparented: Int

  Notification received when the parent node calls removeChild(node:) on this node.

• static let notificationUnpaused: Int

  Notification received when the node is unpaused. See processMode.

• static let notificationVpMouseEnter: Int

  Notification received when the mouse cursor enters the Viewport‘s visible area, that is not occluded behind other Controls or Windows, provided its guiDisableInput is false and regardless if it’s currently focused or not.

• static let notificationVpMouseExit: Int

  Notification received when the mouse cursor leaves the Viewport‘s visible area, that is not occluded behind other Controls or Windows, provided its guiDisableInput is false and regardless if it’s currently focused or not.

• static let notificationWmAbout: Int

  Notification received from the OS when a request for “About” information is sent.

• static let notificationWmCloseRequest: Int

  Notification received from the OS when a close request is sent (e.g. closing the window with a “Close” button or [kbd]Alt + F4[/kbd]).

• static let notificationWmDpiChange: Int

  Notification received from the OS when the screen’s dots per inch (DPI) scale is changed. Only implemented on macOS.

• static let notificationWmGoBackRequest: Int

  Notification received from the OS when a go back request is sent (e.g. pressing the “Back” button on Android).

• static let notificationWmMouseEnter: Int

  Notification received when the mouse enters the window.

• static let notificationWmMouseExit: Int

  Notification received when the mouse leaves the window.

• static let notificationWmSizeChanged: Int

  Notification received when the window is resized.

• static let notificationWmWindowFocusIn: Int

  Notification received from the OS when the node’s Window ancestor is focused. This may be a change of focus between two windows of the same engine instance, or from the OS desktop or a third-party application to a window of the game (in which case notificationApplicationFocusIn is also received).

• static let notificationWmWindowFocusOut: Int

  Notification received from the OS when the node’s Window ancestor is defocused. This may be a change of focus between two windows of the same engine instance, or from a window of the game to the OS desktop or a third-party application (in which case notificationApplicationFocusOut is also received).

• static func printOrphanNodes()

  Prints all orphan nodes (nodes outside the SceneTree). Useful for debugging.

• class var godotClassName: StringName

Instance members

• var autoTranslateMode: Node.AutoTranslateMode

  Defines if any text should automatically change to its translated version depending on the current locale (for nodes such as Label, RichTextLabel, Window, etc.). Also decides if the node’s strings should be parsed for POT generation.

• var childEnteredTree: Signal1

  Emitted when the child node enters the SceneTree, usually because this node entered the tree (see [signal tree_entered]), or addChild(node:forceReadableName:`internal`:) has been called.

• var childExitingTree: Signal2

  Emitted when the child node is about to exit the SceneTree, usually because this node is exiting the tree (see [signal tree_exiting]), or because the child node is being removed or freed.

• var childOrderChanged: SimpleSignal

  Emitted when the list of children is changed. This happens when child nodes are added, moved or removed.

• var editorDescription: String

  An optional description to the node. It will be displayed as a tooltip when hovering over the node in the editor’s Scene dock.

• var editorDescriptionChanged: Signal4

  Emitted when the node’s editor description field changed.

• var multiplayer: MultiplayerAPI?

  The MultiplayerAPI instance associated with this node. See getMultiplayer(forPath:).

• var name: StringName

  The name of the node. This name must be unique among the siblings (other child nodes from the same parent). When set to an existing sibling’s name, the node is automatically renamed.

• var owner: Node?

  The owner of this node. The owner must be an ancestor of this node. When packing the owner node in a PackedScene, all the nodes it owns are also saved with it.

• var physicsInterpolationMode: Node.PhysicsInterpolationMode

  Allows enabling or disabling physics interpolation per node, offering a finer grain of control than turning physics interpolation on and off globally. See ProjectSettings/physics/common/physicsInterpolation and physicsInterpolation for the global setting.

• var processMode: Node.ProcessMode

  The node’s processing behavior (see ProcessMode). To check if the node can process in its current mode, use canProcess.

• var processPhysicsPriority: Int32

  Similar to processPriority but for notificationPhysicsProcess, _physicsProcess(delta:) or the internal version.

• var processPriority: Int32

  The node’s execution order of the process callbacks (_process(delta:), _physicsProcess(delta:), and internal processing). Nodes whose priority value is lower call their process callbacks first, regardless of tree order.

• var processThreadGroup: Node.ProcessThreadGroup

  Set the process thread group for this node (basically, whether it receives notificationProcess, notificationPhysicsProcess, _process(delta:) or _physicsProcess(delta:) (and the internal versions) on the main thread or in a sub-thread.

• var processThreadGroupOrder: Int32

  Change the process thread group order. Groups with a lesser order will process before groups with a greater order. This is useful when a large amount of nodes process in sub thread and, afterwards, another group wants to collect their result in the main thread, as an example.

• var processThreadMessages: Node.ProcessThreadMessages

  Set whether the current thread group will process messages (calls to callDeferredThreadGroup(method:) on threads), and whether it wants to receive them during regular process or physics process callbacks.

• var ready: SimpleSignal

  Emitted when the node is considered ready, after _ready is called.

• var renamed: SimpleSignal

  Emitted when the node’s name is changed, if the node is inside the tree.

• var replacingBy: Signal3

  Emitted when this node is being replaced by the node, see replaceBy(node:keepGroups:).

• var sceneFilePath: String

  The original scene’s file path, if the node has been instantiated from a PackedScene file. Only scene root nodes contains this.

• var treeEntered: SimpleSignal

  Emitted when the node enters the tree.

• var treeExited: SimpleSignal

  Emitted after the node exits the tree and is no longer active.

• var treeExiting: SimpleSignal

  Emitted when the node is just about to exit the tree. The node is still valid. As such, this is the right place for de-initialization (or a “destructor”, if you will).

• var uniqueNameInOwner: Bool

  If true, the node can be accessed from any node sharing the same owner or from the owner itself, with special %Name syntax in getNode(path:).

• func addChild(node: Node?, forceReadableName: Bool, internal: Node.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.

• func addSibling(Node?, forceReadableName: Bool)

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

• func addToGroup(StringName, 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 SceneTree.

• func atr(message: String, context: StringName) -> 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 Control nodes automatically translate their strings, so this method is mostly useful for formatted strings or custom drawn text.

• func atrN(message: String, pluralMessage: StringName, n: Int32, context: StringName) -> String

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

• func callDeferredThreadGroup(method: StringName, Variant...) -> Variant

  This function is similar to Object/callDeferred(method:) 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 _process(delta:) or _physicsProcess(delta:) or their internal versions are called.

• func callThreadSafe(method: StringName, Variant...) -> Variant

  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 canProcess() -> Bool

  Returns true if the node can receive processing notifications and input callbacks (notificationProcess, _input(event:), etc.) from the SceneTree and Viewport. The returned value depends on processMode:

• func createTween() -> Tween?

  Creates a new Tween and binds it to this node.

• func duplicate(flags: Int32) -> Node?

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

• func findChild(pattern: String, recursive: Bool, owned: Bool) -> Node?

  Finds the first descendant of this node whose name matches pattern, returning null if no match is found. The matching is done against node names, not their paths, through String/match(expr:). As such, it is case-sensitive, "*" matches zero or more characters, and "?" matches any single character.

• func findChildren(pattern: String, type: String, recursive: Bool, owned: Bool) -> ObjectCollection<Node>

  Finds all descendants of this node whose names match pattern, returning an empty GArray if no match is found. The matching is done against node names, not their paths, through String/match(expr:). As such, it is case-sensitive, "*" matches zero or more characters, and "?" matches any single character.

• func findParent(pattern: String) -> Node?

  Finds the first ancestor of this node whose name matches pattern, returning null if no match is found. The matching is done through String/match(expr:). As such, it is case-sensitive, "*" matches zero or more characters, and "?" matches any single character. See also findChild(pattern:recursive:owned:) and findChildren(pattern:type:recursive:owned:).

• func getChild(idx: Int32, includeInternal: Bool) -> Node?

  Fetches a child node by its index. Each child node has an index relative its siblings (see getIndex(includeInternal:)). 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 getChildCount(includeInternal:) to iterate over this node’s children. If no child exists at the given index, this method returns null and an error is generated.

• func getChildCount(includeInternal: Bool) -> Int32

  Returns the number of children of this node.

• func getChildren(includeInternal: Bool) -> ObjectCollection<Node>

  Returns all children of this node inside an GArray.

• func getGroups() -> VariantCollection<StringName>

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

• func getIndex(includeInternal: Bool) -> Int32

  Returns this node’s order among its siblings. The first node’s index is 0. See also getChild(idx:includeInternal:).

• func getLastExclusiveWindow() -> Window?

  Returns the Window that contains this node, or the last exclusive child in a chain of windows starting with the one that contains this node.

• func getMultiplayerAuthority() -> Int32

  Returns the peer ID of the multiplayer authority for this node. See setMultiplayerAuthority(id:recursive:).

• func getNode(path: NodePath) -> Node?

  Fetches a node. The NodePath can either be a relative path (from this node), or an absolute path (from the 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 on a null instance.” error.

• func getNodeAndResource(path: NodePath) -> GArray

  Fetches a node and its most nested resource as specified by the NodePath’s subname. Returns an GArray of size 3 where:

• func getNodeOrNull(path: NodePath) -> Node?

  Fetches a node by NodePath. Similar to getNode(path:), but does not generate an error if path does not point to a valid node.

• func getParent() -> Node?

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

• func getPath() -> NodePath

  Returns the node’s absolute path, relative to the root. If the node is not inside the scene tree, this method fails and returns an empty NodePath.

• func getPathTo(node: Node?, useUniquePath: Bool) -> NodePath

  Returns the relative NodePath from this node to the specified node. Both nodes must be in the same SceneTree or scene hierarchy, otherwise this method fails and returns an empty NodePath.

• func getPhysicsProcessDeltaTime() -> Double

  Returns the time elapsed (in seconds) since the last physics callback. This value is identical to _physicsProcess(delta:)’s delta parameter, and is often consistent at run-time, unless physicsTicksPerSecond is changed. See also notificationPhysicsProcess.

• func getProcessDeltaTime() -> Double

  Returns the time elapsed (in seconds) since the last process callback. This value is identical to _process(delta:)’s delta parameter, and may vary from frame to frame. See also notificationProcess.

• func getSceneInstanceLoadPlaceholder() -> Bool

  Returns true if this node is an instance load placeholder. See InstancePlaceholder and setSceneInstanceLoadPlaceholder(_:).

• func getTree() -> SceneTree?

  Returns the SceneTree that contains this node. If this node is not inside the tree, generates an error and returns null. See also isInsideTree.

• func 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 getNode(path:) function. It also can be used in game UI/UX.

• func getTreeStringPretty() -> String

  Similar to 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.

• func getViewport() -> Viewport?

  Returns the node’s closest Viewport ancestor, if the node is inside the tree. Otherwise, returns null.

• func getWindow() -> Window?

  Returns the Window that contains this node. If the node is in the main window, this is equivalent to getting the root node (get_tree().get_root()).

• func hasNode(path: NodePath) -> Bool

  Returns true if the path points to a valid node. See also getNode(path:).

• func hasNodeAndResource(path: NodePath) -> Bool

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

• func isAncestorOf(node: Node?) -> Bool

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

• func 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 setDisplayFolded(fold:).

• func isEditableInstance(node: Node?) -> 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 setEditableInstance(node:isEditable:).

• func isGreaterThan(node: Node?) -> 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 isInGroup(StringName) -> Bool

  Returns true if this node has been added to the given group. See addToGroup(_:persistent:) and removeFromGroup(_:). See also notes in the description, and the SceneTree’s group methods.

• func isInsideTree() -> Bool

  Returns true if this node is currently inside a SceneTree. See also getTree.

• func isMultiplayerAuthority() -> Bool

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

• func isNodeReady() -> Bool

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

• func isPartOfEditedScene() -> Bool

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

• func isPhysicsInterpolated() -> Bool

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

• func isPhysicsInterpolatedAndEnabled() -> Bool

  Returns true if physics interpolation is enabled (see physicsInterpolationMode) and enabled in the SceneTree.

• func isPhysicsProcessing() -> Bool

  Returns true if physics processing is enabled (see setPhysicsProcess(enable:)).

• func isPhysicsProcessingInternal() -> Bool

  Returns true if internal physics processing is enabled (see setPhysicsProcessInternal(enable:)).

• func isProcessing() -> Bool

  Returns true if processing is enabled (see setProcess(enable:)).

• func isProcessingInput() -> Bool

  Returns true if the node is processing input (see setProcessInput(enable:)).

• func isProcessingInternal() -> Bool

  Returns true if internal processing is enabled (see setProcessInternal(enable:)).

• func isProcessingShortcutInput() -> Bool

  Returns true if the node is processing shortcuts (see setProcessShortcutInput(enable:)).

• func isProcessingUnhandledInput() -> Bool

  Returns true if the node is processing unhandled input (see setProcessUnhandledInput(enable:)).

• func isProcessingUnhandledKeyInput() -> Bool

  Returns true if the node is processing unhandled key input (see setProcessUnhandledKeyInput(enable:)).

• func moveChild(childNode: Node?, toIndex: Int32)

  Moves childNode to the given index. A node’s index is the order among its siblings. If toIndex is negative, the index is counted from the end of the list. See also getChild(idx:includeInternal:) and getIndex(includeInternal:).

• func notifyDeferredThreadGroup(what: Int32)

  Similar to callDeferredThreadGroup(method:), but for notifications.

• func notifyThreadSafe(what: Int32)

  Similar to callThreadSafe(method:), but for notifications.

• func printTree()

  Prints the node and its children to the console, recursively. The node does not have to be inside the tree. This method outputs NodePaths relative to this node, and is good for copy/pasting into getNode(path:). See also printTreePretty.

• func printTreePretty()

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

• func propagateCall(method: StringName, args: GArray, parentFirst: Bool)

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

• func propagateNotification(what: Int32)

  Calls notification(what:reversed:) with what on this node and all of its children, recursively.

• func 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.

• func removeChild(node: Node?)

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

• func removeFromGroup(StringName)

  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 SceneTree’s group methods.

• func reparent(newParent: Node?, keepGlobalTransform: Bool)

  Changes the parent of this Node to the newParent. The node needs to already have a parent. The node’s 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).

• func replaceBy(node: Node?, keepGroups: Bool)

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

• func requestReady()

  Requests _ready to be called again the next time the node enters the tree. Does not immediately call _ready.

• func 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.

• func rpc(method: StringName, Variant...) -> GodotError

  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 NodePath, including the exact same name. Behavior depends on the RPC configuration for the given method (see rpcConfig(method:config:) and [annotation @GDScript.@rpc]). By default, methods are not exposed to RPCs.

• func rpcConfig(method: StringName, config: Variant)

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

• func rpcId(peerId: Int64, method: StringName, Variant...) -> GodotError

  Sends a rpc(method:) to a specific peer identified by peerId (see setTargetPeer(id:)).

• func setDeferredThreadGroup(property: StringName, value: Variant)

  Similar to callDeferredThreadGroup(method:), but for setting properties.

• func 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 isDisplayedFolded.

• func setEditableInstance(node: Node?, isEditable: Bool)

  Set to true to allow all nodes owned by node to be available, and editable, in the Scene dock, even if their 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 isEditableInstance(node:).

• func setMultiplayerAuthority(id: Int32, 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 rpcConfig(method:config:) and the MultiplayerAPI.

• func 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 physicsTicksPerSecond to change) interval (and the _physicsProcess(delta:) callback will be called if it exists).

• func setPhysicsProcessInternal(enable: Bool)

  If set to true, enables internal physics for this node. Internal physics processing happens in isolation from the normal _physicsProcess(delta:) 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 (setPhysicsProcess(enable:)).

• func 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 _process(delta:) callback will be called if it exists).

• func setProcessInput(enable: Bool)

  If set to true, enables input processing.

• func setProcessInternal(enable: Bool)

  If set to true, enables internal processing for this node. Internal processing happens in isolation from the normal _process(delta:) calls and is used by some nodes internally to guarantee proper functioning even if the node is paused or processing is disabled for scripting (setProcess(enable:)).

• func setProcessShortcutInput(enable: Bool)

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

• func 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 Control).

• func setProcessUnhandledKeyInput(enable: Bool)

  If set to true, enables unhandled key input processing.

• func setSceneInstanceLoadPlaceholder(Bool)

  If set to true, the node becomes a InstancePlaceholder when packed and instantiated from a PackedScene. See also getSceneInstanceLoadPlaceholder.

• func setThreadSafe(property: StringName, value: Variant)

  Similar to callThreadSafe(method:), but for setting properties.

• func updateConfigurationWarnings()

  Refreshes the warnings displayed for this node in the Scene dock. Use _getConfigurationWarnings to customize the warning messages to display.