Virtual method for non-node instantiation?

[hmrrrrr]

I'm trying to implement a basic custom object - registering the following doesn't run Init() on creating an instance of the object:

type TestObj struct {
	classdb.Extension[TestObj, Object.Instance]
}

func (fs *TestObj) Init() {
	fmt.Println("hello!")
}

I tried this naming the method OnCreate as well, neither were run automatically and they are instead registered as regular methods on the object.

Would be nice to have some sort of 'virtual method' reference because if this functionality is already present I'm not sure how I would find out without diving into the source (which I tried)

[Splizard]

@hmrrrrr thanks for bringing this up, this is an interesting one. So technically speaking, with GDExtension the virtual methods documented for base object instances work differently than with other engine classes.

So if you want to override virtual methods on a node, there is an Interface type defined that documents what can be overridden.

As for the base Object.Instance GDextension supports implementing extension objects with their own get_property_list, notification etc. These should be working but there isn't an interface example in the Object package - so I'll add one.

For _init / Init, this isn't something that is specifically available to override through GDExtension, instead, I believe it's intended for object-oriented languages to use their own constructor pattern as the equivalent.

Go doesn't have constructors, instead a common pattern would be to define a NewX function (where X is the name of the type). This works well in the case that you are constructing the value entirely within Go but not for GDScript integration which will instantiating an empty Go struct when you call MyClass.new.

Are you hoping to initialise things on the Go side when you call .new in GDScript on an extension class that you've defined?

[hmrrrrr]

I think it would be helpful to have an initialization function on the Go side, that could be through an Init function with certain parameters (as it is working within GDScript), or maybe a way to define custom static methods that act like the NewX example you mentioned (this would probably be the preferred way?)

[hmrrrrr]

I'm not sure how feasible this is, but maybe methods defined like so could be considered 'static' by Godot:

func (TestObj) Static() {
	fmt.Println("hello!")
}

The main issue seems to be that there isn't a good way to export functions to GDScript without instantiating an object.

[Splizard]

@hmrrrrr thanks for your feedback, I've added the following to classdb.Register:

All exported fields and methods will be exposed to The Engine, so
take caution when embedding types, as their fields and methods
will be promoted. They will be exported as snake_case by default,
for fields, the exported name can be adjusted with the 'gd' tag.

This function accepts a variable number of additional arguments,
they may either be func, map[string]any (where each any is a func), 
or map[string]int, these arguments can be used to register static 
methods, rename existing methods, or to define constants respectively. 
As a special case, if a function is passed which name begins with 'New', 
accepts no arguments and returns T, then it will be registered as the 
constructor for the class when it is instantiated from within The Engine.

You can now register a constructor, add static functions, and rename methods.

type HelloWorld struct {
	classdb.Extension[HelloWorld, Object.Instance]
}

func NewHelloWorld() *HelloWorld {
	fmt.Println("NewHelloWorld!")
	return &HelloWorld{}
}

func Static() string {
	return "static method call"
}

// Arch returns the current GOARCH value.
func (h *HelloWorld) Arch() string { return runtime.GOARCH }

func main() {
	classdb.Register[HelloWorld](NewHelloWorld, Static, map[string]any{
		"get_arch": (*HelloWorld).Arch,
	})
	startup.Scene()
}