ProcessThreadMessages
Node.swift:100struct ProcessThreadMessagesstruct ProcessThreadMessagesimport SwiftGodotFramework to write Godot Game Extensions using the Swift Programming Language.
class NodeBase class for all scene objects.
static let notificationApplicationFocusIn: IntNotification 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: IntNotification 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: IntNotification received from the OS when the application is paused.
static let notificationApplicationResumed: IntNotification received from the OS when the application is resumed.
static let notificationChildOrderChanged: IntNotification received when the list of children is changed. This happens when child nodes are added, moved or removed.
static let notificationCrash: IntNotification received from Godot’s crash handler when the engine is about to crash.
static let notificationDisabled: IntNotification received when the node is disabled. See .disabled.
static let notificationDragBegin: IntNotification received when a drag operation begins. All nodes receive this notification, not only the dragged one.
static let notificationDragEnd: IntNotification received when a drag operation ends.
static let notificationEditorPostSave: IntNotification 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: IntNotification 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: IntNotification received when the node is enabled again after being disabled. See .disabled.
static let notificationEnterTree: IntNotification received when the node enters a SceneTree. See _enterTree.
static let notificationExitTree: IntNotification received when the node is about to exit a SceneTree. See _exitTree.
static let notificationInternalPhysicsProcess: IntNotification received from the tree every physics frame when isPhysicsProcessingInternal returns true.
static let notificationInternalProcess: IntNotification received from the tree every rendered frame when isProcessingInternal returns true.
static let notificationMovedInParent: Intstatic let notificationOsImeUpdate: IntNotification 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: IntNotification received from the OS when the application is exceeding its allocated memory.
static let notificationParented: IntNotification received when the node is set as a child of another node (see addChild(node:forceReadableName:`internal`:) and addSibling(_:forceReadableName:)).
static let notificationPathRenamed: IntNotification 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: IntNotification received when the node is paused. See processMode.
static let notificationPhysicsProcess: IntNotification received from the tree every physics frame when isPhysicsProcessing returns true. See _physicsProcess(delta:).
static let notificationPostEnterTree: IntNotification 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: IntNotification received from the tree every rendered frame when isProcessing returns true. See _process(delta:).
static let notificationReady: IntNotification received when the node is ready. See _ready.
static let notificationResetPhysicsInterpolation: IntNotification received when resetPhysicsInterpolation is called on the node or its ancestors.
static let notificationSceneInstantiated: IntNotification received only by the newly instantiated scene root node, when instantiate(editState:) is completed.
static let notificationTextServerChanged: IntNotification received when the TextServer is changed.
static let notificationTranslationChanged: IntNotification 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: IntNotification received when the parent node calls removeChild(node:) on this node.
static let notificationUnpaused: IntNotification received when the node is unpaused. See processMode.
static let notificationVpMouseEnter: IntNotification 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: IntNotification 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: IntNotification received from the OS when a request for “About” information is sent.
static let notificationWmCloseRequest: IntNotification 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: IntNotification received from the OS when the screen’s dots per inch (DPI) scale is changed. Only implemented on macOS.
static let notificationWmGoBackRequest: IntNotification received from the OS when a go back request is sent (e.g. pressing the “Back” button on Android).
static let notificationWmMouseEnter: IntNotification received when the mouse enters the window.
static let notificationWmMouseExit: IntNotification received when the mouse leaves the window.
static let notificationWmSizeChanged: IntNotification received when the window is resized.
static let notificationWmWindowFocusIn: IntNotification 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: IntNotification 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.
override class var godotClassName: StringName { get }final var autoTranslateMode: Node.AutoTranslateMode { get set }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 { get }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 { get }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 { get }Emitted when the list of children is changed. This happens when child nodes are added, moved or removed.
final var editorDescription: String { get set }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 { get }Emitted when the node’s editor description field changed.
final var multiplayer: MultiplayerAPI? { get }The MultiplayerAPI instance associated with this node. See getMultiplayer(forPath:).
final var name: StringName { get set }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.
final var owner: Node? { get set }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.
final var physicsInterpolationMode: Node.PhysicsInterpolationMode { get set }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.
final var processMode: Node.ProcessMode { get set }The node’s processing behavior (see ProcessMode). To check if the node can process in its current mode, use canProcess.
final var processPhysicsPriority: Int32 { get set }Similar to processPriority but for notificationPhysicsProcess, _physicsProcess(delta:) or the internal version.
final var processPriority: Int32 { get set }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.
final var processThreadGroup: Node.ProcessThreadGroup { get set }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.
final var processThreadGroupOrder: Int32 { get set }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.
final var processThreadMessages: Node.ProcessThreadMessages { get set }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 { get }Emitted when the node is considered ready, after _ready is called.
var renamed: SimpleSignal { get }Emitted when the node’s name is changed, if the node is inside the tree.
var replacingBy: Signal3 { get }Emitted when this node is being replaced by the node, see replaceBy(node:keepGroups:).
final var sceneFilePath: String { get set }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 { get }Emitted when the node enters the tree.
var treeExited: SimpleSignal { get }Emitted after the node exits the tree and is no longer active.
var treeExiting: SimpleSignal { get }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).
final var uniqueNameInOwner: Bool { get set }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 _enterTree() Called when the node enters the SceneTree (e.g. upon instantiating, scene changing, or after calling addChild(node:forceReadableName:`internal`:) in a script). If the node has children, its _enterTree callback will be called first, and then that of the children.
func _exitTree() Called when the node is about to leave the SceneTree (e.g. upon freeing, scene changing, or after calling removeChild(node:) in a script). If the node has children, its _exitTree callback will be called last, after all its children have left the tree.
func _getConfigurationWarnings() -> PackedStringArray The elements in the array returned from this method are displayed as warnings in the Scene dock if the script that overrides it is a tool script.
func _input(event: InputEvent) Called when there is an input event. The input event propagates up through the node tree until a node consumes it.
func _physicsProcess(delta: Double) Called during the physics processing step of the main loop. Physics processing means that the frame rate is synced to the physics, i.e. the delta variable should be constant. delta is in seconds.
func _process(delta: Double) Called during the processing step of the main loop. Processing happens at every frame and as fast as possible, so the delta time since the previous frame is not constant. delta is in seconds.
func _ready() Called when the node is “ready”, i.e. when both the node and its children have entered the scene tree. If the node has children, their _ready callbacks get triggered first, and the parent node will receive the ready notification afterwards.
func _shortcutInput(event: InputEvent?) Called when an InputEventKey, InputEventShortcut, or InputEventJoypadButton hasn’t been consumed by _input(event:) or any GUI Control item. It is called before _unhandledKeyInput(event:) and _unhandledInput(event:). The input event propagates up through the node tree until a node consumes it.
func _unhandledInput(event: InputEvent?) Called when an InputEvent hasn’t been consumed by _input(event:) or any GUI Control item. It is called after _shortcutInput(event:) and after _unhandledKeyInput(event:). The input event propagates up through the node tree until a node consumes it.
func _unhandledKeyInput(event: InputEvent?) Called when an InputEventKey hasn’t been consumed by _input(event:) or any GUI Control item. It is called after _shortcutInput(event:) but before _unhandledInput(event:). The input event propagates up through the node tree until a node consumes it.
final func addChild(node: Node?, forceReadableName: Bool = false, internal: Node.InternalMode = .disabled) 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.
final func addSibling(_ sibling: Node?, forceReadableName: Bool = false) Adds a sibling node to this node’s parent, and moves the added sibling right below this node.
final func addToGroup(_ group: StringName, persistent: Bool = false) 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.
final func atr(message: String, context: StringName = 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.
final func atrN(message: String, pluralMessage: StringName, n: Int32, context: StringName = 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.
final func callDeferredThreadGroup(method: StringName, _ arguments: 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.
final func callThreadSafe(method: StringName, _ arguments: 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.
final 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:
final func createTween() -> Tween? Creates a new Tween and binds it to this node.
final func duplicate(flags: Int32 = 15) -> 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).
final func findChild(pattern: String, recursive: Bool = true, owned: Bool = true) -> 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.
final func findChildren(pattern: String, type: String = "", recursive: Bool = true, owned: Bool = true) -> 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.
final 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:).
final func getChild(idx: Int32, includeInternal: Bool = false) -> 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.
final func getChildCount(includeInternal: Bool = false) -> Int32 Returns the number of children of this node.
final func getChildren(includeInternal: Bool = false) -> ObjectCollection<Node> Returns all children of this node inside an GArray.
final func getGroups() -> VariantCollection<StringName> Returns an GArray of group names that the node has been added to.
final func getIndex(includeInternal: Bool = false) -> Int32 Returns this node’s order among its siblings. The first node’s index is 0. See also getChild(idx:includeInternal:).
final 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.
final func getMultiplayerAuthority() -> Int32 Returns the peer ID of the multiplayer authority for this node. See setMultiplayerAuthority(id:recursive:).
final 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
final 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:
final 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.
final func getParent() -> Node? Returns this node’s parent node, or null if the node doesn’t have a parent.
final 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.
final func getPathTo(node: Node?, useUniquePath: Bool = false) -> 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.
final 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.
final 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.
final func getSceneInstanceLoadPlaceholder() -> Bool Returns true if this node is an instance load placeholder. See InstancePlaceholder and setSceneInstanceLoadPlaceholder(_:).
final 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.
final 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.
final 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.
final func getViewport() -> Viewport? Returns the node’s closest Viewport ancestor, if the node is inside the tree. Otherwise, returns null.
final 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()).
final func hasNode(path: NodePath) -> Bool Returns true if the path points to a valid node. See also getNode(path:).
final 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:).
final func isAncestorOf(node: Node?) -> Bool Returns true if the given node is a direct or indirect child of this node.
final 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:).
final 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:).
final 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.
final func isInGroup(_ group: 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.
final func isInsideTree() -> Bool Returns true if this node is currently inside a SceneTree. See also getTree.
final func isMultiplayerAuthority() -> Bool Returns true if the local system is the multiplayer authority of this node.
final func isNodeReady() -> Bool Returns true if the node is ready, i.e. it’s inside scene tree and all its children are initialized.
final func isPartOfEditedScene() -> Bool Returns true if the node is part of the scene currently opened in the editor.
final func isPhysicsInterpolated() -> Bool Returns true if physics interpolation is enabled for this node (see physicsInterpolationMode).
final func isPhysicsInterpolatedAndEnabled() -> Bool Returns true if physics interpolation is enabled (see physicsInterpolationMode) and enabled in the SceneTree.
final func isPhysicsProcessing() -> Bool Returns true if physics processing is enabled (see setPhysicsProcess(enable:)).
final func isPhysicsProcessingInternal() -> Bool Returns true if internal physics processing is enabled (see setPhysicsProcessInternal(enable:)).
final func isProcessing() -> Bool Returns true if processing is enabled (see setProcess(enable:)).
final func isProcessingInput() -> Bool Returns true if the node is processing input (see setProcessInput(enable:)).
final func isProcessingInternal() -> Bool Returns true if internal processing is enabled (see setProcessInternal(enable:)).
final func isProcessingShortcutInput() -> Bool Returns true if the node is processing shortcuts (see setProcessShortcutInput(enable:)).
final func isProcessingUnhandledInput() -> Bool Returns true if the node is processing unhandled input (see setProcessUnhandledInput(enable:)).
final func isProcessingUnhandledKeyInput() -> Bool Returns true if the node is processing unhandled key input (see setProcessUnhandledKeyInput(enable:)).
final 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:).
final func notifyDeferredThreadGroup(what: Int32) Similar to callDeferredThreadGroup(method:), but for notifications.
final func notifyThreadSafe(what: Int32) Similar to callThreadSafe(method:), but for notifications.
final 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.
final 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.
final func propagateCall(method: StringName, args: GArray = GArray (), parentFirst: Bool = false) Calls the given method name, passing args as arguments, on this node and all of its children, recursively.
final func propagateNotification(what: Int32) Calls notification(what:reversed:) with what on this node and all of its children, recursively.
final 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.
final func removeChild(node: Node?) Removes a child node. The node, along with its children, are not deleted. To delete a node, see queueFree.
final func removeFromGroup(_ group: 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.
final func reparent(newParent: Node?, keepGlobalTransform: Bool = true) 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).
final func replaceBy(node: Node?, keepGroups: Bool = false) Replaces this node by the given node. All children of this node are moved to node.
final func requestReady() Requests _ready to be called again the next time the node enters the tree. Does not immediately call _ready.
final 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.
final func rpc(method: StringName, _ arguments: 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.
final 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:
final func rpcId(peerId: Int64, method: StringName, _ arguments: Variant...) -> GodotError Sends a rpc(method:) to a specific peer identified by peerId (see setTargetPeer(id:)).
final func setDeferredThreadGroup(property: StringName, value: Variant) Similar to callDeferredThreadGroup(method:), but for setting properties.
final 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.
final 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:).
final func setMultiplayerAuthority(id: Int32, recursive: Bool = true) 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.
final 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).
final 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:)).
final 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).
final func setProcessInput(enable: Bool) If set to true, enables input processing.
final 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:)).
final func setProcessShortcutInput(enable: Bool) If set to true, enables shortcut processing for this node.
final 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).
final func setProcessUnhandledKeyInput(enable: Bool) If set to true, enables unhandled key input processing.
final func setSceneInstanceLoadPlaceholder(_ loadPlaceholder: Bool) If set to true, the node becomes a InstancePlaceholder when packed and instantiated from a PackedScene. See also getSceneInstanceLoadPlaceholder.
final func setThreadSafe(property: StringName, value: Variant) Similar to callThreadSafe(method:), but for setting properties.
final func updateConfigurationWarnings() Refreshes the warnings displayed for this node in the Scene dock. Use _getConfigurationWarnings to customize the warning messages to display.
enum AutoTranslateModeenum DuplicateFlagsenum InternalModeenum PhysicsInterpolationModeenum ProcessModeenum ProcessThreadGroupclass Signal1Signal support.
class Signal2Signal support.
class Signal3Signal support.
class Signal4Signal support.
class ViewportAbstract base class for viewports. Encapsulates drawing and interaction with a game world.
class InstancePlaceholderPlaceholder for the root Node of a PackedScene.
protocol CustomDebugStringConvertibleA type with a customized textual representation suitable for debugging purposes.
protocol EquatableA type that can be compared for value equality.
protocol ExpressibleByArrayLiteralA type that can be initialized using an array literal.
protocol OptionSet : RawRepresentable, SetAlgebraA type that presents a mathematical set interface to a bit set.
protocol RawRepresentable<RawValue>A type that can be converted to and from an associated raw value.
protocol SetAlgebra<Element> : Equatable, ExpressibleByArrayLiteralA type that provides mathematical set operations.
init(rawValue: Int) static let messages: Node.ProcessThreadMessagesAllows this node to process threaded messages created with callDeferredThreadGroup(method:) right before _process(delta:) is called.
static let messagesAll: Node.ProcessThreadMessagesAllows this node to process threaded messages created with callDeferredThreadGroup(method:) right before either _process(delta:) or _physicsProcess(delta:) are called.
static let messagesPhysics: Node.ProcessThreadMessagesAllows this node to process threaded messages created with callDeferredThreadGroup(method:) right before _physicsProcess(delta:) is called.
var debugDescription: String { get }A textual representation of this instance, suitable for debugging
let rawValue: Intinit() Creates an empty option set.
init<S>(_ sequence: S) where S : Sequence, Self.Element == S.Element Creates a new set from a finite sequence of items.
init(arrayLiteral: Self.Element...) Creates a set containing the elements of the given array literal.
var isEmpty: Bool { get }A Boolean value that indicates whether the set has no elements.
static func != (lhs: Self, rhs: Self) -> Bool Returns a Boolean value indicating whether two values are not equal.
func contains(_ member: Self) -> Bool Returns a Boolean value that indicates whether a given element is a member of the option set.
mutating func formIntersection(_ other: Self) Removes all elements of this option set that are not also present in the given set.
mutating func formSymmetricDifference(_ other: Self) Replaces this set with a new set containing all elements contained in either this set or the given set, but not in both.
mutating func formUnion(_ other: Self) Inserts the elements of another set into this option set.
@discardableResult mutating func insert(_ newMember: Self.Element) -> (inserted: Bool, memberAfterInsert: Self.Element) Adds the given element to the option set if it is not already a member.
func intersection(_ other: Self) -> Self Returns a new option set with only the elements contained in both this set and the given set.
func isDisjoint(with other: Self) -> Bool Returns a Boolean value that indicates whether the set has no members in common with the given set.
func isStrictSubset(of other: Self) -> Bool Returns a Boolean value that indicates whether this set is a strict subset of the given set.
func isStrictSuperset(of other: Self) -> Bool Returns a Boolean value that indicates whether this set is a strict superset of the given set.
func isSubset(of other: Self) -> Bool Returns a Boolean value that indicates whether the set is a subset of another set.
func isSuperset(of other: Self) -> Bool Returns a Boolean value that indicates whether the set is a superset of the given set.
@discardableResult mutating func remove(_ member: Self.Element) -> Self.Element? Removes the given element and all elements subsumed by it.
mutating func subtract(_ other: Self) Removes the elements of the given set from this set.
func subtracting(_ other: Self) -> Self Returns a new set containing the elements of this set that do not occur in the given set.
func symmetricDifference(_ other: Self) -> Self Returns a new option set with the elements contained in this set or in the given set, but not in both.
func union(_ other: Self) -> Self Returns a new option set of the elements contained in this set, in the given set, or in both.
@discardableResult mutating func update(with newMember: Self.Element) -> Self.Element? Inserts the given element into the set.