GDExtension.cpp

#include "gdexample.h"
#include <godot_cpp/core/class_db.hpp>
#include <godot_cpp/variant/utility_functions.hpp>
#include <godot_cpp/classes/random_number_generator.hpp>
#include <stdio.h>

using namespace godot;

void GDExample::_bind_methods() {
	ClassDB::bind_method(D_METHOD("tick", "delta"), &GDExample::tick);
	ClassDB::bind_method(D_METHOD("click", "parent"), &GDExample::click);
}

GDExample::GDExample() {

}

GDExample::~GDExample() {
	// Add your cleanup here.
}
class sprite {
	public:
		Vector2 vel;
		Sprite2D* s;
		double average_dist=0.0f;
};
float speed = 1000.0;

std::vector<sprite*> nodes;
void GDExample::click(Variant parent)
{
	UtilityFunctions::print("click:", parent);
	RandomNumberGenerator rng;
	for (int i=0; i<10; i++) {		
		Node2D* p = Object::cast_to<Node2D>(parent);
		Texture2D* texture = Object::cast_to<Texture2D>(parent.get("image_texture"));
		Sprite2D* s = new Sprite2D();
		s->set_centered(false);
		s->set_texture(texture);
		p->add_child(s);
		sprite* spr = new sprite();
		spr->s = s;
		spr->vel = Vector2(rng.randf()*speed,rng.randf()*speed);
		nodes.push_back(spr);
	}
}

double time_elapsed = 0.0f;
void GDExample::tick(double delta)
{
	time_elapsed += delta;
	if (time_elapsed > 1.0) {
		time_elapsed = 0.0;
		UtilityFunctions::print (nodes.size(), " native sprites");
	}
			
	int tw=20, th=20, sw=1000, sh=1000;
	float time = 0.01;
	for (int i=0; i<nodes.size(); i++) {
		sprite* o = nodes[i];

		Node2D* n = o->s;
		//UtilityFunctions::print("pos:", n->get_position());
		Vector2 pos = n->get_position();
		Vector2 vel = o->vel;
		if (pos.x<0 || pos.x > sw)
			vel.x = -vel.x;
		if (pos.y<0 || pos.y > sh)
			vel.y = -vel.y;
		
		pos += (vel * time);
		o->vel = vel;
		n->set_position(pos);
		double avg = 0.0;
		for (int j=0; j<nodes.size(); j++) {
			double distance = nodes[j]->s->get_position().distance_to(pos);
			avg += distance;
		}
		avg /=  (double)nodes.size();
		o->average_dist = avg;
	}
}

void GDExample::_process(double delta) {

}

main.gd.py

extends Node3D
const Builder := preload("res://benchmark/Builder.gd")

class sprite:
	var node = null
	var vel = Vector2()
	var speed = 1000.0
	var screensize = null 
	var average_dist = 0.0
	func _init(node):
		self.node = node
		vel.x = randf() * speed
		vel.y = randf() * speed
		self.screensize = node.get_viewport().get_visible_rect().size

	func tick(time):
		var sw=1000; var sh=1000;
		var pos = self.node.get_position()

		if pos.x<0 || pos.x > sw:
			self.vel.x = -self.vel.x
		if pos.y<0 || pos.y > sh:
			self.vel.y = -self.vel.y
		pos += self.vel * time

		self.node.set_position(pos)

class rootNode extends Node2D:
	const b := preload("res://benchmark/Builder.gd")
	var time_elapsed = 0.0
	var image = null
	var image_texture = null
	var random = RandomNumberGenerator.new()
	var dotick = true
	var native = GDExample.new()

	func _init():
		image = Image.load_from_file("res://icon.svg")	
		image_texture = ImageTexture.create_from_image(image)
		random.randomize()
		set_process_input(true) 

	var sprites = []
	
	func click_gds():
		for i in range(10):
			sprites.append(sprite.new(b.gen(b.makeSprite(image_texture), self, self)))
	
	func tick_gds(delta): 
		for i in sprites:
			i.tick(delta)
			var avg = 0.0
			for j in sprites:
				avg += j.node.get_position().distance_to(i.node.get_position())
			avg /= sprites.size()
			i.average_dist = avg
		

	func _process(delta):
		time_elapsed += delta
		if time_elapsed > 1.0:
			time_elapsed = 0.0
			print ("FPS:", Engine.get_frames_per_second(), " for ", sprites.size(), " sprites. With tick ", self.dotick)
			
		if Input.is_key_pressed(KEY_T):
			self.dotick = !self.dotick
		
		if Input.get_mouse_button_mask():
			click_gds()
			#native.click(self)

		if self.dotick:
			tick_gds(delta)
			#native.tick(delta)

# Called when the node enters the scene tree for the first time.
func _ready():
	var p = Builder.setScene(Builder.node2d(Builder.ref(rootNode)), get_tree())

# Called every frame. 'delta' is the elapsed time since the previous frame.
func _process(delta):
	pass