UCLASS()
class ATestCharacter: public ACharacter
{
 GENERATED_BODY()
 public:
 // Public member function to get health
 UFUNCTION(BlueprintPure, Category = "Health")
 float GetHealth() const;
 
 // Public member function to set health
 UFUNCTION(BlueprintCallable, Category = "Health")
 void SetHealth(float NewHealth);
 
 protected:
 // Protected member variable
 UPROPERTY(EditDefaultsOnly, Category = "Health")
 float Health;
};

// In this example there isn't much different in terms of line count, but it does remove calls to the 
// pre-processor and also removes the GENERATE_BODY macro which would be part of 
// the @UnrealClass metafunction
ATestCharacter: @UnrealClass<ACharacter> type = {
 public :
 GetHealth: @UFunction<BlueprintPure, Category = "Health">(this) const -> float;
 SetHealth: @UFunction<BlueprintPure, Category = "Health">(this, NewHealth: float);
 protected:
 health: @UProperty<EditDefaultsOnly, Category = "Health"> float;
}

class Component : public godot::Resource {
 GDCLASS(Component, godot::Resource)
public:
 auto get_position() const -> godot::Vector3 { return _position; }
 auto set_position(const godot::Vector3& p) -> void { _position = p; }
protected:
 static auto _bind_methods() -> void {
 using namespace godot;
 ClassDB::bind_method(D_METHOD("get_position"), &Component::get_position);
 ClassDB::bind_method(D_METHOD("set_position", "position"), &Component::set_position);
 ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "position"), "set_position", "get_position");
 }
private:
 godot::Vector3 _position;
};

// This example is a more drastic improvement, with a much lower line count, by making the GDCLASS
// macro call a type metafunction and in this example it assumes that the @Property metafunction
// would generate a _bind_methods function for you based on the parameters pass to the
// metafunction and the property type. For a more complete behaviour, multiple @Property functions
// would be able to combine into the single _bind_methods function that is needed by an exposed godot
// class. Could maybe be achieved by having the @GDClass metafunction keep track of all the @Property
// metafunction calls and then combining the outputs of all of them
Component: @GDClass<godot::Resource> type = {
public:
 get_position: (this) const -> godot::Vector3 = { return _position }
 set_position: (this, p: const godot::Vector3) = { this._position = p; }
private:
 _position: @Property<get_position, set_position> godot::Vector3;
}