Fixing reference return

Author: BastiaanOlij

include/godot_cpp/classes/ref.hpp

@@ -112,7 +112,15 @@ class Ref {
 	}
 
 	operator Variant() const {
-		return Variant(reference);
+		if (reference != nullptr) {
+			// When assigning a variant this way it's not increasing the refcount like it should
+			// not sure if this is a workaround or a proper solution...
+			reference->reference();
+			return Variant(reference);
+		} else {
+			// no object? return NIL variant
+			return Variant();
+		}
 	}
 
 	void operator=(const Ref &p_from) {
@@ -186,6 +194,20 @@ class Ref {
 		r.reference = nullptr;
 	}
 
+	template <class T_Other>
+	Ref(const Ref<T_Other> &&p_other) {
+		RefCounted *refb = const_cast<RefCounted *>(static_cast<const RefCounted *>(p_other.ptr()));
+		if (!refb) {
+			unref();
+			return;
+		}
+
+		Ref r;
+		r.reference = Object::cast_to<T>(refb);
+		ref(r);
+		r.reference = nullptr;
+	}
+
 	Ref(T *p_reference) {
 		if (p_reference) {
 			ref_pointer(p_reference);
@@ -246,7 +268,7 @@ struct PtrToArg<Ref<T>> {
 	typedef Ref<T> EncodeT;
 
 	_FORCE_INLINE_ static void encode(Ref<T> p_val, const void *p_ptr) {
-		*(void **)p_ptr = p_val->_owner;
+		godot::internal::gdn_interface->reference_assign((GDNativeObjectPtr)p_ptr, (GDNativeObjectPtr)p_val->_owner);
 	}
 };
 

test/demo/main.gd

@@ -9,9 +9,12 @@ func _ready():
 	($Example as Example).simple_const_func() # Force use of ptrcall
 	prints("returned", $Example.return_something("some string"))
 	prints("returned const", $Example.return_something_const())
-	prints("returned ref", $Example.return_extended_ref())
+
+	prints("returned example ref object: ", $Example.return_extended_ref())
+
 	var ref = ExampleRef.new()
 	prints("sending ref: ", ref.get_instance_id(), "returned ref: ", $Example.extended_ref_checks(ref).get_instance_id())
+
 	prints("vararg args", $Example.varargs_func("some", "arguments", "to", "test"))
 
 	prints("test array", $Example.test_array())

test/src/example.cpp

@@ -38,22 +38,26 @@
 
 using namespace godot;
 
+uint64_t ExampleRef::instance_count = 0;
+
 ExampleRef::ExampleRef() {
-	UtilityFunctions::print("ExampleRef created.");
+	instance_count++;
+	UtilityFunctions::print("ExampleRef created. Our total instance count is now: ", instance_count);
 }
 
 ExampleRef::~ExampleRef() {
-	UtilityFunctions::print("ExampleRef destroyed.");
+	instance_count--;
+	UtilityFunctions::print("ExampleRef destroyed. Our total instance count is now: ", instance_count);
 }
 
 void Example::_bind_methods() {
 	// Methods.
 	ClassDB::bind_method(D_METHOD("simple_func"), &Example::simple_func);
 	ClassDB::bind_method(D_METHOD("simple_const_func"), &Example::simple_const_func);
-	ClassDB::bind_method(D_METHOD("return_something"), &Example::return_something);
+	ClassDB::bind_method(D_METHOD("return_something", "base"), &Example::return_something);
 	ClassDB::bind_method(D_METHOD("return_something_const"), &Example::return_something_const);
 	ClassDB::bind_method(D_METHOD("return_extended_ref"), &Example::return_extended_ref);
-	ClassDB::bind_method(D_METHOD("extended_ref_checks"), &Example::extended_ref_checks);
+	ClassDB::bind_method(D_METHOD("extended_ref_checks", "ref"), &Example::extended_ref_checks);
 
 	ClassDB::bind_method(D_METHOD("test_array"), &Example::test_array);
 	ClassDB::bind_method(D_METHOD("test_dictionary"), &Example::test_dictionary);
@@ -73,6 +77,10 @@ void Example::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("set_custom_position", "position"), &Example::set_custom_position);
 	ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "group_subgroup_custom_position"), "set_custom_position", "get_custom_position");
 
+	// ClassDB::bind_method(D_METHOD("get_ref_obj"), &Example::get_ref_obj);
+	// ClassDB::bind_method(D_METHOD("set_ref_obj", "ref_obj"), &Example::set_ref_obj);
+	// ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "ref_obj", PROPERTY_HINT_RESOURCE_TYPE, "ExampleRef"), "set_ref_obj", "get_ref_obj");
+
 	// Signals.
 	ADD_SIGNAL(MethodInfo("custom_signal", PropertyInfo(Variant::STRING, "name"), PropertyInfo(Variant::INT, "value")));
 	ClassDB::bind_method(D_METHOD("emit_custom_signal", "name", "value"), &Example::emit_custom_signal);
@@ -115,15 +123,19 @@ Viewport *Example::return_something_const() const {
 	return nullptr;
 }
 
-ExampleRef *Example::return_extended_ref() const {
-	return memnew(ExampleRef());
+Ref<ExampleRef> Example::return_extended_ref() const {
+	// When subclassing RefCounted we should ALWAYS use Ref<..> or Godot will start doing confusing things as it will start using reference counting to manage the object.
+	// We should never instantiate the object directly such as this:
+	// return memnew(ExampleRef());
+
+	Ref<ExampleRef> ref;
+	ref.instantiate();
+	return ref;
 }
 
 Ref<ExampleRef> Example::extended_ref_checks(Ref<ExampleRef> p_ref) const {
 	Ref<ExampleRef> ref;
 	ref.instantiate();
-	// TODO the returned value gets dereferenced too early and return a null object otherwise.
-	ref->reference();
 	UtilityFunctions::print("Example ref checks called with value: ", p_ref->get_instance_id(), ", returning value: ", ref->get_instance_id());
 	return ref;
 }
@@ -165,6 +177,16 @@ Vector2 Example::get_custom_position() const {
 	return custom_position;
 }
 
+/*
+void Example::set_ref_obj(const Ref<ExampleRef> p_ref) {
+	ref_obj = p_ref;
+}
+
+Ref<ExampleRef> Example::get_ref_obj() const {
+	return ref_obj;
+}
+*/
+
 // Virtual function override.
 bool Example::_has_point(const Vector2 &point) const {
 	Label *label = get_node<Label>("Label");

test/src/example.h

@@ -39,14 +39,18 @@
 
 #include <godot_cpp/classes/control.hpp>
 #include <godot_cpp/classes/global_constants.hpp>
+#include <godot_cpp/classes/resource.hpp>
 #include <godot_cpp/classes/viewport.hpp>
 
 #include <godot_cpp/core/binder_common.hpp>
 
 using namespace godot;
 
-class ExampleRef : public RefCounted {
-	GDCLASS(ExampleRef, RefCounted);
+class ExampleRef : public Resource {
+	GDCLASS(ExampleRef, Resource);
+
+private:
+	static uint64_t instance_count;
 
 protected:
 	static void _bind_methods() {}
@@ -64,6 +68,7 @@ class Example : public Control {
 
 private:
 	Vector2 custom_position;
+	// Ref<ExampleRef> ref_obj;
 
 public:
 	// Constants.
@@ -84,7 +89,7 @@ class Example : public Control {
 	void simple_const_func() const;
 	String return_something(const String &base);
 	Viewport *return_something_const() const;
-	ExampleRef *return_extended_ref() const;
+	Ref<ExampleRef> return_extended_ref() const;
 	Ref<ExampleRef> extended_ref_checks(Ref<ExampleRef> p_ref) const;
 	Variant varargs_func(const Variant **args, GDNativeInt arg_count, GDNativeCallError &error);
 	void emit_custom_signal(const String &name, int value);
@@ -96,6 +101,9 @@ class Example : public Control {
 	void set_custom_position(const Vector2 &pos);
 	Vector2 get_custom_position() const;
 
+	// void set_ref_obj(const Ref<ExampleRef> p_ref);
+	// Ref<ExampleRef> get_ref_obj() const;
+
 	// Virtual function override (no need to bind manually).
 	virtual bool _has_point(const Vector2 &point) const override;
 };