classes/class_object

[giscus[bot]]

classes/class_object

Inherited By: AudioServer, CameraServer, ClassDB, DisplayServer, EditorFileSystemDirectory, EditorInterface, EditorPaths, EditorSelection, EditorUndoRedoManager, EditorVCSInterface, Engine, EngineD...

https://docs.godotengine.org/en/stable/classes/class_object.html

[MartinNr5]

There is as far as I can tell no example that shows how to use Connect() with my own parameters and flags. In fact, I don't think there's an example that shows how to use flags at all.

[willnationsdev]

@MartinNr5
Put this together to help: here's an advanced, working example (see the _reset method) using Godot 4.3 stable.

# log.gd, an autoload singleton named "Log".
extends Node
## An example logging singleton. Very verbose considering warnings/errors
## already include this info, but it illustrates the point.

## This creates a "global" contact point for any 3rd-party API that wants to
## know when a log has occurred (e.g. to also log elsewhere w/o editing this code).
signal log_requested(message: String, level: int, category: String)

enum Level {
	NONE,
	VERBOSE,
	DEBUG,
	INFORMATION,
	WARNING,
	ERROR,
	FATAL
}

var targets: Array[String] = ["godot", "file"]:
	get: return targets
	set(value):
		targets = value
		_reset()

var default_level := Level.INFORMATION

## Set to non-empty string if you want a console log any time this class
## attempts to print something.
var meta_msg := ""


func _ready() -> void:
	_reset()


## Enqueues multiple async one-off logging jobs for end of frame, one for each target.
##
## - We need CONNECT_DEFERRED to wait till end of frame.
## - We need CONNECT_REFERENCE_COUNTED because we bind the same function on the same
##     object to the same signal, even if we buffer different extra arguments via `bind()`.
##
## Note: because we bind `meta_msg` using a Callable, you can call `defer_log`, immediately
##     change the `meta_msg` property, and see the updated value when the deferred log triggers.
func _reset() -> void:
	for conn in log_requested.get_connections():
		(conn.signal as Signal).disconnect(conn.callable)
	var flags = CONNECT_DEFERRED | CONNECT_REFERENCE_COUNTED
	var get_meta_msg := func(): return meta_msg
	for target in targets:
		log_requested.connect(_log_target.bind(get_meta_msg).bind(target), flags)


## More user-friendly abstracted API for using the signal.
func defer_log(message: String, level: int, category: String) -> void:
	log_requested.emit(message, level, category)


## Logs a message to a specific target immediately.
## Note: if you add type hints to `target` or `meta`, then the `.bind(...)` calls we make
##     in `_reset()` will produce an error, even if the type matches. I think it's because
##     the Godot API loses the type information in the binding process & so thinks
##     that we are passing an untyped value into a typed parameter.
func _log_target(message: String, level: int, category: String, target, meta) -> void:
	# For fun, I included this to also demonstrate `bind` arguments for Callables.
	if meta:
		var meta_val := ""
		match typeof(meta):
			TYPE_STRING: meta_val = meta
			TYPE_CALLABLE when meta.is_valid(): meta_val = meta.call()
		if meta_val:
			print("Log._log_target[meta]: %s" % meta_val)

	# WARNING: Actual logging should use a more precise method than this.
	var datetime_utc := Time.get_datetime_string_from_system(true)

	var actual := "%s [%s] %s: %s" % [datetime_utc, level2str(level), category, message]
	if target == "godot":
		match level:
			Level.FATAL, Level.ERROR:
				push_error(actual)
			Level.WARNING:
				push_warning(actual)
			_:
				print(actual)
	elif target == "file":
		pass # logs to a rolling file or something.


func level2str(level: int) -> String:
	match level:
		Level.NONE: return level2str(default_level)
		Level.VERBOSE: return "VRB"
		Level.DEBUG: return "DBG"
		Level.INFORMATION: return "INF"
		Level.WARNING: return "WRN"
		Level.ERROR: return "ERR"
		Level.FATAL: return "FTL"
		_: return "???"

Example Usage:

# my_node.gd
extends Node


func _ready() -> void:
	var category = get_script().resource_path.get_file().get_basename()
	
	Log.defer_log("A deferred message with formatting that prints at end of frame", \
		Log.Level.INFORMATION, \
		category)

	Log.defer_log("Another deferred message!", \
		Logs.Level.INFORMATION, \
		category)

	print("This should print first, without formatting")

Prints (when I tested it):

This should print first, without formatting
2024-12-30T22:24:10 [INF] my_node: A deferred message with formatting that prints at end of frame
2024-12-30T22:24:10 [INF] my_node: Another deferred message!

[RobynTheDevil]

Requesting documentation and examples for overloading/shadowing new() on Object.

Observations:
Currently cannot call super() in overridden new

extends Node

class Foo extends Object:
    static func new():
    	var this = super()
    	return this

func _ready():
	var __ = Foo.new()


> Function "new()" not found in base Object.

Workaround is to reference Object directly

...
        var this = Object.new()

Casting up appears implicit

...
func _ready():
	var __ = Foo.new()
    print(str(__ is Foo))

> true

[RobynTheDevil]

The previous is incorrect, new is not called on the extending class at all.

[willnationsdev]

If I recall correctly, GDScript uses an _init() function that the engine will call during a constructor, if it is defined. Any parameters you add to that method will become required parameters when instantiating the class. And I think the Godot Editor itself will use empty constructors when making instances of your script, so you will also often want it to have default values for whatever parameters are there (though, maybe that is only needed for tool scripts?).

[Calinou]

• See Make it possible to pass arguments to PackedScene.instance() godot-proposals#1513.

[manuq]

I notice that set_process(true) has to be called always after setting the object script. This is regardless of the process mode of the object. Should this be documented in set_script()? Here is an example (isolated from the BlockCoding plugin).

extends Node2D

@onready var icon: Sprite2D = %Icon

var source_code_a: String = """
extends Sprite2D

func _process(delta: float) -> void:
	rotation_degrees -= 1
"""

var source_code_b: String = """
extends Sprite2D

func _process(delta: float) -> void:
	rotation_degrees += 3
"""

# Called when the node enters the scene tree for the first time.
func _ready() -> void:
	_override_icon_script(source_code_a)


func _override_icon_script(source_code: String):
	var script := GDScript.new()
	script.set_source_code(source_code)
	script.reload()
	icon.set_script(script)
	icon.set_process(true)


func _process(delta: float) -> void:
	if Input.is_action_just_released("ui_left"):
		_override_icon_script(source_code_a)
	elif Input.is_action_just_released("ui_right"):
		_override_icon_script(source_code_b)

[Wilker-uwu]

what is *_meta about? is this in any way related to get_property_list?

[willnationsdev]

The get_meta, set_meta, and has_meta methods are for editing/querying metadata on Godot objects. It is like a hidden Dictionary<string, Variant> that stores transient, dynamic, and ad-hoc data. Unlike properties, this data is not formally defined (it is not in the ClassDB nor any Script), and, because it is both stored and defined directly on an individual instance, there is no hierarchical/inheritance key lookup mechanism like there is with the virtual _get and _set methods for properties.

I've most often observed it being used to add boolean flags for caching or compatibility-related checks for some algorithm; also for adding group/tag like functionality to non-Node objects. And lastly, when a script needed to create a static singleton and chose to put an object instance inside a meta value on the script itself.

If you're familiar with any web programming, it's like the HttpContext.Items property. Or kind of like environment variables for systems programming. Just a shared, low-level API for key-value data that can be used as the need arises.