C++ GDNative properties aren't updated in `_ready` only `_process`

:information_source: Attention Topic was automatically imported from the old Question2Answer platform.
:bust_in_silhouette: Asked By humbletang

I’m a little bit confused because it seems like the property changes to a node made in the editor seem to not appear until the process step, instead of ready. Am I missing something?

It seems like this is related to Inconsistent behaviour of setup methods between GDScript and GDNative (C++) - values and default values of properties · Issue #26237 · godotengine/godot · GitHub and Undocumented unexpected properties behavior · Issue #301 · godotengine/godot-cpp · GitHub. The difference is that I’m just trying to make use of the updated property once it’s changed from the default. I don’t mind having to specify the default multiple places. It just seems like the property changes it’s value somewhere between my _ready and the subsequent _process calls…

Imgur: The magic of the Internet <— the initial property
https://i.imgur.com/juwYZjI.png ← screenshot showing modified property in editor



#include <Godot.hpp>
#include <File.hpp>
#include <vector>
#include <chrono>
#include <iostream>
#include <ResourceLoader.hpp>
#include <Material.hpp>
#include <fstream>
#include <String.hpp>
#include <OS.hpp>
#include <Spatial.hpp>
#include <ArrayMesh.hpp>
#include <MeshInstance.hpp>

namespace godot {

class GDExample : public Spatial {
    GODOT_CLASS(GDExample, Spatial)

    float speed;
    float amplitude;
    float time_passed;
    float time_emit;
    String file_pth;

    static void _register_methods();


    void _init(); // our initializer called by Godot
    void _ready();
    void _process(float delta);
void set_speed(float p_speed);
float get_speed();




    #include "gdexample.h"

using namespace godot;
using namespace std;

void GDExample::_register_methods() {
	register_method("_process", &GDExample::_process);
	register_property<GDExample, float>("amplitude", &GDExample::amplitude, 10.0);
	register_property<GDExample, float>("speed", &GDExample::set_speed, &GDExample::get_speed, 1.0);
	register_property<GDExample, String>("file_pth", &GDExample::file_pth, "./plant.ply");

	register_signal<GDExample>((char *)"position_changed", "node", GODOT_VARIANT_TYPE_OBJECT, "new_pos", GODOT_VARIANT_TYPE_VECTOR2);

GDExample::GDExample() {

GDExample::~GDExample() {
	// add your cleanup here

void GDExample::_init() {

	// for some reason the tutorial initializes values here, which seems like it overrides the values set in the property window of the editor.
	time_passed = 0.0;
	amplitude = 10.0;
	speed = 10.0;
	file_pth = "./plant.ply";
	// but if I don't set them here then they remain un initialized. How do I get the values typed into the property window to get used for my class members?


struct point {
	double x;
	double z;
	double y;
	unsigned char r;
	unsigned char g;
	unsigned char b;

void GDExample::_ready() {
	auto mat = ResourceLoader::get_singleton()->load("res://mat.tres");
	// Simple test code adapted from GDscript docs to native C++
	// Might leak if called repeatedly (not sure how that's handled),
	// but it gets a triangle on the screen.
	PoolVector3Array vertices;

	std::chrono::steady_clock::time_point beg = std::chrono::steady_clock::now();
	auto mySimpleMesh = ArrayMesh::_new();
	godot::Array arrays; // kind of a struct-of-arrays approach to vertex attributes (or array of arrays with enumerated keys)

	// Vertex colors don't show correctly, probably because there's no material/skin yet.
	PoolColorArray colors;  // optional...
	// read file, and populate the verts and colors	
	// see if using the gd FILe type is faster than some c++ method 

	//auto f = File::_new();
	ifstream f (file_pth.alloc_c_string(),ios::binary);
	cout << amplitude << endl;
	Godot::print("loading file");
   // **** this prints the default ./plant.ply ***
	string s;
	for (int i = 0;i< 11;i++ ) {
	int fbeg = int(f.tellg());
	int fend = int(f.tellg());
	//vector<char> buf(fend-fbeg);
	// figure out from the size of the data how many points we can have and print that
	int correct_size = 27;
	int buf_size = fend-fbeg;
	int size = (buf_size)/correct_size;
	cout << buf_size << endl;
	cout <<  size << endl;
	// convert the entire thing into a vector of structs that we can iterate over

	vector<point *> points;
	std::chrono::steady_clock::time_point begin = std::chrono::steady_clock::now();
	vector<char> buf(fend-fbeg);
	for (int i =0; i < size;i++) {

		//cout << i << endl;
		// read 27 bytes and assign them to the parts of a point that matter
		point * p = reinterpret_cast<point *>(buf.data()+i*27);
		//cout << p->x << endl;
		//cout << p->y << endl;
		//cout << p->z << endl;
		//cout << int(p->r) << endl;
		//cout << int(p->g) << endl;
		//cout << int(p->b) << endl;
		vertices.append(Vector3(p->x  - 409001,p->y- 0.957346,p->z- 3660087.5));
		//vertices.append(Vector3(p->x  ,p->y,p->z));

	cout << vertices.size()<< endl;

	arrays[ArrayMesh::ARRAY_VERTEX] = vertices; // required
	arrays[ArrayMesh::ARRAY_COLOR] = colors;
	mySimpleMesh->add_surface_from_arrays(Mesh::PRIMITIVE_POINTS, arrays);
	// pMeshInstance = new MeshInstance; // NO! BAD! Will crash the game!
	auto mySimpleMeshInstance = MeshInstance::_new(); // This is how we do things here.
	auto bb = mySimpleMeshInstance->get_aabb();
	//auto cam = get_node("../Camera");
	//cam->translate( q
	std::chrono::steady_clock::time_point end = std::chrono::steady_clock::now();
	std::cout << "Time difference = " << std::chrono::duration_cast<std::chrono::milliseconds>(end - begin).count() << "[ms]" << std::endl;


void GDExample::_process(float delta) {
   // ***** this prints the modified file_pth property  of ./plants2.ply
	// Godot::print("_process");
	//	time_passed += speed * delta;
	//	Vector3 new_position = Vector3(
	//		amplitude + (amplitude * sin(time_passed * 20.0)),
	//		0,
	//		amplitude + (amplitude * cos(time_passed * 15.0))
	//	);
	//	set_global_translation(new_position);
	//	time_emit += delta;
	//	if (time_emit > 1.0) {
	//		emit_signal("position_changed", this, new_position);
	//		time_emit = 0.0;
	//	}

void GDExample::set_speed(float p_speed) {
	speed = p_speed;

float GDExample::get_speed() {
	return speed;

Still love to know about how to do this, but I have a work around. Take the existing _ready function and make that something called makecloud and then add a getter and setter to the property for file_pth. Then inside the setter for the file_pth I can invoke the makecloud and that will mean I don’t have to add logic for loading the cloud to process.

humbletang | 2023-01-06 23:36