class JavaScriptObject
package godot
extends Reference › Object
@:nativeGen@:build(godot.Godot.buildUserClass())@:autoBuild(godot.Godot.buildUserClass())@:build(godot.Godot.buildUserClass())@:autoBuild(godot.Godot.buildUserClass())@:libType@:csNative@:native("Godot.JavaScriptObject")@:autoBuild(godot.Godot.buildUserClass())JavaScriptObject is used to interact with JavaScript objects retrieved or created via godot.JavaScript.getInterface, godot.JavaScript.createObject, or godot.JavaScript.createCallback.
Example:
extends Node
var _my_js_callback = JavaScript.create_callback(self, "myCallback") # This reference must be kept
var console = JavaScript.get_interface("console")
func _init():
var buf = JavaScript.create_object("ArrayBuffer", 10) # new ArrayBuffer(10)
print(buf) # prints [JavaScriptObject:OBJECT_ID]
var uint8arr = JavaScript.create_object("Uint8Array", buf) # new Uint8Array(buf)
uint8arr[1] = 255
prints(uint8arr[1], uint8arr.byteLength) # prints 255 10
console.log(uint8arr) # prints in browser console "Uint8Array(10) [ 0, 255, 0, 0, 0, 0, 0, 0, 0, 0 ]"
# Equivalent of JavaScript: Array.from(uint8arr).forEach(myCallback)
JavaScript.get_interface("Array").from(uint8arr).forEach(_my_js_callback)
func myCallback(args):
# Will be called with the parameters passed to the "forEach" callback
# [0, 0, [JavaScriptObject:1173]]
# [255, 1, [JavaScriptObject:1173]]
# ...
# [0, 9, [JavaScriptObject:1180]]
print(args)
Note: Only available in the HTML5 platform.
Inherited Variables
Defined by Object
@:native("DynamicObject")read onlydynamicObject:Dynamic
Gets a new godot.DynamicGodotObject associated with this instance.
@:native("NativeInstance")read onlynativeInstance:IntPtr
The pointer to the native instance of this godot.Object.
Inherited Methods
Defined by Reference
@:native("InitRef")initRef():Bool
Initializes the internal reference counter. Use this only if you really know what you are doing.
Returns whether the initialization was successful.
@:native("Reference_")reference_():Bool
Increments the internal reference counter. Use this only if you really know what you are doing.
Returns true if the increment was successful, false otherwise.
@:native("Unreference")unreference():Bool
Decrements the internal reference counter. Use this only if you really know what you are doing.
Returns true if the decrement was successful, false otherwise.
Defined by Object
@:native("_Get")_Get(property:String):Dynamic
Virtual method which can be overridden to customize the return value of godot.Object.get.
Returns the given property. Returns null if the property does not exist.
@:native("_GetPropertyList")_GetPropertyList():Array
Virtual method which can be overridden to customize the return value of godot.Object.getPropertyList.
Returns the object's property list as an godot.Collections_Array of dictionaries.
Each property's godot.Collections_Dictionary must contain at least name: String and type: int (see godot.Variant_Type) entries. Optionally, it can also include hint: int (see godot.PropertyHint), hint_string: String, and usage: int (see godot.PropertyUsageFlags).
@:native("_Notification")_Notification(what:Int):Void
Called whenever the object receives a notification, which is identified in what by a constant. The base godot.Object has two constants godot.Object.notificationPostinitialize and godot.Object.notificationPredelete, but subclasses such as godot.Node define a lot more notifications which are also received by this method.
@:native("_Set")_Set(property:String, value:Dynamic):Bool
Virtual method which can be overridden to customize the return value of godot.Object.set.
Sets a property. Returns true if the property exists.
@:native("AddUserSignal")addUserSignal(signal:String, ?arguments:Array):Void
Adds a user-defined signal. Arguments are optional, but can be added as an godot.Collections_Array of dictionaries, each containing name: String and type: int (see godot.Variant_Type) entries.
Parameters:
arguments | If the parameter is null, then the default value is new Godot.Collections.Array { } |
|---|
@:native("Call")call(method:String, args:HaxeArray<Dynamic>):Dynamic
Calls the method on the object and returns the result. This method supports a variable number of arguments, so parameters are passed as a comma separated list. Example:
call("set", "position", Vector2(42.0, 0.0))
Note: In C#, the method name must be specified as snake_case if it is defined by a built-in Godot node. This doesn't apply to user-defined methods where you should use the same convention as in the C# source (typically PascalCase).
@:native("CallDeferred")callDeferred(method:String, args:HaxeArray<Dynamic>):Void
Calls the method on the object during idle time. This method supports a variable number of arguments, so parameters are passed as a comma separated list. Example:
call_deferred("set", "position", Vector2(42.0, 0.0))
Note: In C#, the method name must be specified as snake_case if it is defined by a built-in Godot node. This doesn't apply to user-defined methods where you should use the same convention as in the C# source (typically PascalCase).
@:native("Callv")callv(method:String, argArray:Array):Dynamic
Calls the method on the object and returns the result. Contrarily to godot.Object.call, this method does not support a variable number of arguments but expects all parameters to be via a single godot.Collections_Array.
callv("set", [ "position", Vector2(42.0, 0.0) ])
@:native("CanTranslateMessages")canTranslateMessages():Bool
Returns true if the object can translate strings. See godot.Object.setMessageTranslation and godot.Object.tr.
@:native("Connect")connect(signal:String, target:Object, method:String, ?binds:Array, ?flags:UInt):Error
Connects a signal to a method on a target object. Pass optional binds to the call as an godot.Collections_Array of parameters. These parameters will be passed to the method after any parameter used in the call to godot.Object.emitSignal. Use flags to set deferred or one-shot connections. See godot.Object_ConnectFlags constants.
A signal can only be connected once to a method. It will print an error if already connected, unless the signal was connected with godot.Object_ConnectFlags.referenceCounted. To avoid this, first, use godot.Object.isConnected to check for existing connections.
If the target is destroyed in the game's lifecycle, the connection will be lost.
Examples:
connect("pressed", self, "_on_Button_pressed") # BaseButton signal
connect("text_entered", self, "_on_LineEdit_text_entered") # LineEdit signal
connect("hit", self, "_on_Player_hit", [ weapon_type, damage ]) # User-defined signal
An example of the relationship between binds passed to godot.Object.connect and parameters used when calling godot.Object.emitSignal:
connect("hit", self, "_on_Player_hit", [ weapon_type, damage ]) # weapon_type and damage are passed last
emit_signal("hit", "Dark lord", 5) # "Dark lord" and 5 are passed first
func _on_Player_hit(hit_by, level, weapon_type, damage):
print("Hit by %s (lvl %d) with weapon %s for %d damage" % [hit_by, level, weapon_type, damage])
Parameters:
binds | If the parameter is null, then the default value is new Godot.Collections.Array { } |
|---|
@:native("Disconnect")disconnect(signal:String, target:Object, method:String):Void
Disconnects a signal from a method on the given target.
If you try to disconnect a connection that does not exist, the method will print an error. Use godot.Object.isConnected to ensure that the connection exists.
@:native("Dispose")dispose():Void
@:native("Dispose")@:protectedDispose(disposing:Bool):Void
Disposes of this godot.Object.
@:native("EmitSignal")emitSignal(signal:String, args:HaxeArray<Dynamic>):Void
Emits the given signal. The signal must exist, so it should be a built-in signal of this class or one of its parent classes, or a user-defined signal. This method supports a variable number of arguments, so parameters are passed as a comma separated list. Example:
emit_signal("hit", weapon_type, damage)
emit_signal("game_over")
@:native("Free")free():Void
Deletes the object from memory immediately. For godot.Nodes, you may want to use godot.Node.queueFree to queue the node for safe deletion at the end of the current frame.
Important: If you have a variable pointing to an object, it will not be assigned to null once the object is freed. Instead, it will point to a previously freed instance and you should validate it with @GDScript.is_instance_valid before attempting to call its methods or access its properties.
@:native("Get")get(property:String):Dynamic
Returns the Variant value of the given property. If the property doesn't exist, this will return null.
Note: In C#, the property name must be specified as snake_case if it is defined by a built-in Godot node. This doesn't apply to user-defined properties where you should use the same convention as in the C# source (typically PascalCase).
@:native("GetClass")getClass():String
Returns the object's class as a String. See also godot.Object.isClass.
Note: godot.Object.getClass does not take class_name declarations into account. If the object has a class_name defined, the base class name will be returned instead.
@:native("GetIncomingConnections")getIncomingConnections():Array
Returns an godot.Collections_Array of dictionaries with information about signals that are connected to the object.
Each godot.Collections_Dictionary contains three String entries:
-
sourceis a reference to the signal emitter. -
signal_nameis the name of the connected signal. -
method_nameis the name of the method to which the signal is connected.
@:native("GetIndexed")getIndexed(property:NodePath):Dynamic
Gets the object's property indexed by the given godot.NodePath. The node path should be relative to the current object and can use the colon character (:) to access nested properties. Examples: "position:x" or "material:next_pass:blend_mode".
Note: Even though the method takes godot.NodePath argument, it doesn't support actual paths to godot.Nodes in the scene tree, only colon-separated sub-property paths. For the purpose of nodes, use godot.Node.getNodeAndResource instead.
@:native("GetInstanceId")getInstanceId():UInt64
Returns the object's unique instance ID.
This ID can be saved in godot.EncodedObjectAsID, and can be used to retrieve the object instance with @GDScript.instance_from_id.
@:native("GetMeta")getMeta(name:String):Dynamic
Returns the object's metadata entry for the given name.
@:native("GetMethodList")getMethodList():Array
Returns the object's methods and their signatures as an godot.Collections_Array.
@:native("GetPropertyList")getPropertyList():Array
Returns the object's property list as an godot.Collections_Array of dictionaries.
Each property's godot.Collections_Dictionary contain at least name: String and type: int (see godot.Variant_Type) entries. Optionally, it can also include hint: int (see godot.PropertyHint), hint_string: String, and usage: int (see godot.PropertyUsageFlags).
@:native("GetScript")getScript():Reference
Returns the object's godot.Script instance, or null if none is assigned.
@:native("GetSignalConnectionList")getSignalConnectionList(signal:String):Array
Returns an godot.Collections_Array of connections for the given signal.
@:native("GetSignalList")getSignalList():Array
Returns the list of signals as an godot.Collections_Array of dictionaries.
@:native("HasMeta")hasMeta(name:String):Bool
Returns true if a metadata entry is found with the given name.
@:native("HasMethod")hasMethod(method:String):Bool
Returns true if the object contains the given method.
@:native("HasUserSignal")hasUserSignal(signal:String):Bool
Returns true if the given user-defined signal exists. Only signals added using godot.Object.addUserSignal are taken into account.
@:native("IsBlockingSignals")isBlockingSignals():Bool
Returns true if signal emission blocking is enabled.
@:native("IsClass")isClass(class_:String):Bool
Returns true if the object inherits from the given class. See also godot.Object.getClass.
Note: godot.Object.isClass does not take class_name declarations into account. If the object has a class_name defined, godot.Object.isClass will return false for that name.
@:native("IsConnected")isConnected(signal:String, target:Object, method:String):Bool
Returns true if a connection exists for a given signal, target, and method.
@:native("IsQueuedForDeletion")isQueuedForDeletion():Bool
Returns true if the godot.Node.queueFree method was called for the object.
@:native("Notification")notification(what:Int, ?reversed:Bool):Void
Send a given notification to the object, which will also trigger a call to the godot.Object._Notification method of all classes that the object inherits from.
If reversed is true, godot.Object._Notification is called first on the object's own class, and then up to its successive parent classes. If reversed is false, godot.Object._Notification is called first on the highest ancestor (godot.Object itself), and then down to its successive inheriting classes.
@:native("PropertyListChangedNotify")propertyListChangedNotify():Void
Notify the editor that the property list has changed, so that editor plugins can take the new values into account. Does nothing on export builds.
@:native("RemoveMeta")removeMeta(name:String):Void
Removes a given entry from the object's metadata. See also godot.Object.setMeta.
@:native("Set")set(property:String, value:Dynamic):Void
Assigns a new value to the given property. If the property does not exist or the given value's type doesn't match, nothing will happen.
Note: In C#, the property name must be specified as snake_case if it is defined by a built-in Godot node. This doesn't apply to user-defined properties where you should use the same convention as in the C# source (typically PascalCase).
@:native("SetBlockSignals")setBlockSignals(enable:Bool):Void
If set to true, signal emission is blocked.
@:native("SetDeferred")setDeferred(property:String, value:Dynamic):Void
Assigns a new value to the given property, after the current frame's physics step. This is equivalent to calling godot.Object.set via godot.Object.callDeferred, i.e. call_deferred("set", property, value).
Note: In C#, the property name must be specified as snake_case if it is defined by a built-in Godot node. This doesn't apply to user-defined properties where you should use the same convention as in the C# source (typically PascalCase).
@:native("SetIndexed")setIndexed(property:NodePath, value:Dynamic):Void
Assigns a new value to the property identified by the godot.NodePath. The node path should be relative to the current object and can use the colon character (:) to access nested properties. Example:
set_indexed("position", Vector2(42, 0))
set_indexed("position:y", -10)
print(position) # (42, -10)
@:native("SetMessageTranslation")setMessageTranslation(enable:Bool):Void
Defines whether the object can translate strings (with calls to godot.Object.tr). Enabled by default.
@:native("SetMeta")setMeta(name:String, value:Dynamic):Void
Adds, changes or removes a given entry in the object's metadata. Metadata are serialized and can take any Variant value.
To remove a given entry from the object's metadata, use godot.Object.removeMeta. Metadata is also removed if its value is set to null. This means you can also use set_meta("name", null) to remove metadata for "name".
@:native("SetScript")setScript(script:Reference):Void
Assigns a script to the object. Each object can have a single script assigned to it, which are used to extend its functionality.
If the object already had a script, the previous script instance will be freed and its variables and state will be lost. The new script's method will be called.
@:native("ToSignal")toSignal(source:Object, signal:String):SignalAwaiter
Returns a new godot.SignalAwaiter awaiter configured to complete when the instance
source emits the signal specified by the signal parameter.
Parameters:
source | The instance the awaiter will be listening to. |
|---|---|
signal | The signal the awaiter will be waiting for. This sample prints a message once every frame up to 100 times. |
Returns:
A godot.SignalAwaiter that completes when
source emits the signal.
@:native("ToString")toString():String
@:native("Tr")tr(message:String):String
Translates a message using translation catalogs configured in the Project Settings.
Only works if message translation is enabled (which it is by default), otherwise it returns the message unchanged. See godot.Object.setMessageTranslation.