How can I act on an instance reference ?

[jugglingjsons]

Is it possible to directly call native methods on instances of Objects I created via gd ?

Sample:

func (m *Main) createBoid(id int) {
	mob, ok := classdb.As[gd.RigidBody2D](m.MobScene.Instantiate())
	if !ok {
		fmt.Println("failed to cast!")
		return
	}

I would Ideally want to have a reference to the mob, that I could call .setVelocity / .setPosition on.
Would that be possible ?

For context when I later use:

	b.gdObj.AsNode2D().SetPosition(position)
	b.gdObj.SetLinearVelocity(velocity)

it ends up exploding with: panic: runtime.link/mmm error: use after free

I may need to provide a reproducible example, I am using rwMutex on the boids, likely I screw up access in there, and it's not about the method linking at all. Will report back :)

[Splizard]

I imagine you are storing the mob somewhere, in order to do this with a Godot reference, you will need to pin the lifetime of the mob to the class it is contained in. I am exploring a design on how to make this more intuiative.
(See #25 (comment))

Note that since the instance inherits gd.Node adding the node as a child to another node will transfer ownership over to Godot (hence use-after 'free'), you may find it easier to add the 'mob' to the scene tree and then keep a gd.NodePath to it so that you can retrieve it at a later point.

A good heuristic to keep things simpler when working with Godot references in Go, always try to use references temporarily (within your method call) before you return back to Godot, if you need to hold onto the reference for a longer time, store the reference somewhere inside a Godot managed class (or use a Godot reference like gd.NodePath or gd.ObjectID), so that you can retrieve it later. This will help avoid issues with grow.graphics/gd semi-automatic memory management.

[jugglingjsons]

I don't seem to understand how to get it working.
I've prepared a sample below.

package main

import (
	"fmt"
	"math/rand"

	"graphics.gd/classdb"
	"graphics.gd/classdb/Node"
	"graphics.gd/classdb/PackedScene"
	"graphics.gd/classdb/RigidBody2D"
	"graphics.gd/startup"
	"graphics.gd/variant/Angle"
	"graphics.gd/variant/Float"
	"graphics.gd/variant/NodePath"
	"graphics.gd/variant/Vector2"
	"grow.graphics/gd"
)

type Main struct {
	classdb.Extension[Main, Node.Instance] `gd:"Boids"`
	MobScene                               PackedScene.Instance
	boidsGD                                []NodePath.String
}

const (
	boidCount  = 10
	viewRadius = 25
	adjRate    = 0.015
)

const (
	screenHeight = 320 * 4
	screenWidth  = 640 * 4
)

var boidMap [screenWidth + 1][screenHeight*4 + 1]int

func (m *Main) Ready() {
	for i := 0; i < boidCount; i++ {

		instance := Node.Instance(m.MobScene.Instantiate())
		mob, ok := classdb.As[RigidBody2D.Instance](instance)
		if !ok {
			fmt.Println("failed to cast!")
			return
		}

		positionGD := Vector2.XY{}
		positionGD.X = Float.Random() * screenWidth
		positionGD.Y = Float.Random() * screenHeight
		velocityGD := Vector2.New((Float.Random()*2)-1, (Float.Random()*2)-1)

		// Add some randomness to the direction.
		direction := Angle.Radians(Float.RandomBetween(Float.X(-Angle.Pi/4), Float.X(Angle.Pi/4)))

		mob.AsNode2D().SetPosition(positionGD)
		mob.AsNode2D().SetRotation(Float.X(direction))

		mob.SetLinearVelocity(Vector2.Rotated(velocityGD, direction))

		m.Super().AddChild(instance)
		fmt.Println(instance.GetPath())
		m.boidsGD = append(m.boidsGD, instance.GetPath())
	}
	fmt.Println("boids created", m.boidsGD)
}

var velocity = gd.Vector2{}

func (m *Main) Process(godot gd.Context, delta gd.Float) {
	for i, boidPath := range m.boidsGD {

		node := m.Super().GetNode(boidPath)

		idx := i
		velocity.SetX(velocity.X() + rand.Float64() - 0.5)
		velocity.SetY(velocity.Y() + rand.Float64() - 0.5)

		mob, ok := gd.As[gd.RigidBody2D](godot, node)
		if !ok {
			fmt.Println("failed to cast!")
			return
		}

		fmt.Print("casted ", idx, " ", mob)
		// mob.SetPosition(postion)
		mob.SetLinearVelocity(velocity)
	}
}

func main() {
	classdb.Register[Main]()
	classdb.Register[Mob]()
	startup.Engine()
}

It also explodes with the same error.

[Splizard]

Thanks, looks like you have found a bit of an issue here, as you need the node to be alive in Go in order to get the nodepath, I've added a function to gd (gd.AddChild) that will workaround this, it will add the child and return the resulting NodePath (I've tested this and it looks like the rigid bodies are moving now).

You can replace

m.Super().AddChild(instance)
fmt.Println(instance.GetPath())
m.boidsGD = append(m.boidsGD,instance.GetPath())

with

m.boidsGD = append(m.boidsGD, m.Super().AsNode().AddChild(mob.AsNode()))

Big thanks for reporting your experience here, it really helps us to identify the pain points and areas to improve our Go integration with Godot!

[jugglingjsons]

Thanks, this approach indeed works.

However, I think it's suboptimal.
I would ideally aim for a way to manage and keep nodes in go memory (or expose an explicit possibility of doing that).
This may come in handy when creating groupControllers or objectPooling.

I am not sure what the overhead of the node := m.Super().GetNode(ctx, boidPath) is, but I assume it would be faster if I could store and access the refs throughout the lifetime of the go process.

Context Scenario:

• simulations with thousands of actors

Would that be possible currenlty ? (I believe not)
Does it sound like a direction / approach the lib may take in the future?

Thanks for taking the time and very quick adjustment!

[Splizard]

I've thought about this, essentially it would be nice to have a safe set of Node methods, unfortunately node types are one of the least safe references to hold, as they aren't reference counted and may be freed unexpectedly when interacting with the scene tree.

If you are looking for better performance, you may have better luck working with the Server (ie gd.RenderingServer) singletons directly? Keep in mind, this project doesn't have any rendering/extensive benchmarks yet to measure overall performance compared to other languages working with Godot. Would love to see a contribution for this!

[jugglingjsons]

I've actually benchmarked it (the current implementation with casting and godot handling the drawing through nodes), half the CPU of the simulation was eaten by passing casting the nodes back and forth and passing the results of the calculation. I stand corrected :)

Your suggestions is great, using servers directly is also what I've been hearing about when it came to spawning large numbers of entities with GDScript itself. Will give it a go and hopefully report back with a comparative example :)

[jugglingjsons]

Got it running relatively smooth.
I've played around with adjusting the pointer and casting in the lib itself to call draws in batches, but I don't know enough about it to be helpful.

If you are open to that I can clean up the code, and pr it as an example.

Screen.Recording.2024-06-17.at.19.40.56.mp4

Depending on the radius & boid size the frames flactuate between 40-90 for 10k boids.

I wanted a proper example with multithreading. It's using a simple spacial partitioning as well.