Finally ! Calling class method the hard way is working !

Author: touilleMan

scripts/extension_api_parser/api.py

@@ -174,6 +174,11 @@ def float_spec(self):
         return TYPES_DB["float"]
         # return next(builtin for builtin in self.builtins if builtin.name == "int")
 
+    def get_class_meth_hash(self, classname: str, methname: str) -> int:
+        klass = next(c for c in self.classes if c.original_name == classname)
+        meth = next(m for m in klass.methods if m.original_name == methname)
+        return meth.hash
+
 
 def merge_builtins_size_info(api_json: dict, build_config: BuildConfig) -> None:
     # Builtins size depend of the build config, hence it is stored separatly from

src/_pythonscript.pyx

@@ -27,7 +27,7 @@ from godot.builtins cimport GDString, Vector2
 
 from godot.hazmat.gdnative_interface cimport *
 from godot.hazmat.gdapi cimport *
-
+from godot.classes cimport _load_class
 
 # include "_pythonscript_script.pxi"
 # include "_pythonscript_instance.pxi"
@@ -50,18 +50,32 @@ cdef api void _pythonscript_free_instance(
 # is the very first Python module that gets loaded.
 
 
-cdef api void _pythonscript_initialize() with gil:
+cdef api void _pythonscript_late_init() with gil:
+    pythonscript_gdapi.print_error("pythonscript late init", "<function>", "<file>", 0)
+    OS = _load_class("OS")
+    pythonscript_gdapi.print_error("OS class loaded", "<function>", "<file>", 0)
+
+    # from godot.classes import OS
+    cdef gd_variant_t gdvariant
+    if not pyobject_to_gdvariant(f"singletion is {OS!r}", &gdvariant):
+        pythonscript_gdapi.print_error("pyobject_to_gdvariant !!!!", "<function>", "<file>", 0)
+    gd_print(&gdvariant, 1)
+    pythonscript_gdapi.variant_destroy(&gdvariant)
+    pythonscript_gdapi.print_error("_pythonscript_late_init done", "<function>", "<file>", 0)
+
     import sys
     from godot._version import __version__ as pythonscript_version
-    cdef GDString r = GDString("foo")
-    if r.to_pystr() == "foo":
-        pythonscript_gdapi.print_error("ok", "<function>", "<file>", 0)
-    else:
-        pythonscript_gdapi.print_error("ko", "<function>", "<file>", 0)
 
     cooked_sys_version = '.'.join(map(str, sys.version_info))
     print(f"Pythonscript {pythonscript_version} (CPython {cooked_sys_version})")
     print(f"PYTHONPATH: {sys.path}")
+
+
+cdef api void _pythonscript_early_init() with gil:
+    pythonscript_gdapi.print_error("pythonscript early init", "<function>", "<file>", 0)
+    # pythonscript_gdapi.
+    # Engine get_singleton_list
+
     v = Vector2(66.8, -77.99)
     v.x = 42
     print("===========>", v.x, v.y)

src/godot/__init__.py

@@ -33,4 +33,18 @@
 #     exposed,
 # )
 from godot.builtins import *
-from godot.classes import *
+
+# from godot.classes import _load_singleton, _load_class
+
+
+# def __getattr__(name):
+#     # Look for singleton first given they have the same name than their class
+#     item = _load_singleton(name) or _load_class(name)
+
+#     if not item:
+#         raise AttributeError
+
+#     # Cache entry
+#     setattr(globals(), name, item)
+
+#     return item

src/godot/builtins_pyx/class.pyx.j2

@@ -8,7 +8,12 @@
 {%   else %}
 @property
 def {{ c.name }}(self):
-    return {{ c.value }}
+    cdef gd_variant_t gdvariant
+    pythonscript_gdapi.variant_get_constant_value({{ spec.variant_type_name }}, "{{ c.original_name }}", &gdvariant)
+    try:
+        return gdvariant_to_pyobject(&gdvariant)
+    finally:
+        gd_variant_del(&gdvariant)
 {%   endif %}
 {% endmacro %}
 
@@ -30,9 +35,12 @@ cdef class {{ spec.name }}:
 {% endif %}
 
     def __repr__(self):
-        # TODO: finish me...
-        # pythonscript_gdapi.variant_stringify(&self._gd_data)
-        return "<{{ spec.name }}>"
+        cdef gd_string_t gdstr
+        try:
+            pythonscript_gdapi.variant_stringify(&self._gd_data, &gdstr)
+            return gdstring_to_pystr(&gdstr)
+        finally:
+            gd_string_del(&gdstr)
 {% if spec.name == "GDString" %}
     def __str__(self):
         return self.to_pystr()

src/godot/classes.pxd.j2

@@ -39,3 +39,7 @@ cdef class {{spec.name}}({{ spec.inherits or "" }}):
     pass
 {%   endif %}
 {% endfor %}
+
+
+cdef object _load_class(str name)
+cdef object _object_call(GDNativeObjectPtr obj, str meth, args)

src/godot/classes.pyx.j2

@@ -3,15 +3,21 @@
 
 cimport cython
 
-from .hazmat.gdapi cimport pythonscript_gdapi
-from .hazmat.gdnative_interface cimport GDNativeObjectPtr
+from .hazmat.gdapi cimport *
+from .builtins cimport *
 {% for spec in api["classes"] %}
 
 
 cdef class {{ spec.name }}({{ spec.inherits or "" }}):
 {%   if spec.inherits is none %}
+
+    {# @staticmethod
+    cpdef inline {{ spec.name}} new():
+        raise NotImplementedError("TODO :'(") #}
+
     def free(self):
-        gdobject_free(self)
+        pythonscript_gdapi.object_destroy(self._gd_ptr)
+        self._gd_ptr = NULL
 
     def __init__(self):
         raise RuntimeError(
@@ -24,3 +30,68 @@ cdef class {{ spec.name }}({{ spec.inherits or "" }}):
     pass
 {% endif %}
 {% endfor %}
+
+
+cdef _load_singleton(name):
+    cdef GDObject gdobj = GDObject.__new__(GDObject)
+    gdobj._gd_ptr = pythonscript_gdapi.global_get_singleton(name)
+{% for spec in api["singletons"] %}
+    cdef {{ spec.type.py_type }} singleton_{{ spec.name }} = {{ spec.type.py_type }}.__new__({{ spec.type.py_type }})
+    singleton_{{ spec.name }}._gd_ptr = pythonscript_gdapi.global_get_singleton("{{ spec.original_name }}")
+    globals()["{{ spec.name }}"] = singleton_{{ spec.name }}
+{% endfor %}
+
+
+cdef object _load_class(str name):
+    # Load our good friend ClassDB
+    cdef GDNativeObjectPtr classdb = pythonscript_gdapi.global_get_singleton("ClassDB")
+    pythonscript_gdapi.print_error("AAAAAAAAAA", "_object_call", "", 0)
+    cdef gd_variant_t meths = _object_call(classdb, "class_get_method_list", [name])
+    pythonscript_gdapi.print_error("BBBB", "_object_call", "", 0)
+    pythonscript_gdapi.print_error("GOOOOOOOOOOOOOOOD", "_object_call", "", 0)
+
+
+cdef object _object_call(GDNativeObjectPtr obj, str meth, args):
+    cdef gd_variant_t ret
+    cdef GDNativeCallError call_error
+
+    cdef GDNativeObjectPtr classdb = pythonscript_gdapi.global_get_singleton("ClassDB")
+    cdef GDNativeMethodBindPtr Object_call = pythonscript_gdapi.classdb_get_method_bind("Object", "call", {{ api.get_class_meth_hash("Object", "call") }})
+
+    cdef GDNativeInt args_with_meth_len = len(args) + 1
+    if args_with_meth_len > 9:
+        # TODO: handle this
+        pythonscript_gdapi.print_error("more than 8 params is not supported !", "_object_call", "", 0)
+        return None
+    cdef gd_variant_t[9] variant_args
+    cdef (gd_variant_t*)[9] variant_args_ptrs
+    for i in range(args_with_meth_len):
+        variant_args_ptrs[i] = &variant_args[i]
+
+    cdef gd_string_t meth_gdstr = gdstring_from_unchecked_pystr(meth)
+    cdef gd_string_name_t meth_gdstrname = gd_string_name_new_from_string(&meth_gdstr)
+    gd_string_del(&meth_gdstr)
+    variant_args[0] = gd_string_name_into_variant(&meth_gdstrname)
+    # Into conversion steals the owneship, so no need to delete meth_gdstrname
+
+    for i, arg in enumerate(args, 1):
+        # TODO: check return value
+        pyobject_to_gdvariant(arg, &variant_args[i])
+
+    pythonscript_gdapi.object_method_bind_call(
+        Object_call,
+        classdb,
+        <GDNativeVariantPtr *>&variant_args_ptrs,
+        args_with_meth_len,
+        &ret,
+        &call_error,  # TODO: check call_error
+    )
+    pythonscript_gdapi.print_error("after call", "<function>", "<file>", 0)
+    for i in range(args_with_meth_len):
+        gd_variant_del(&variant_args[i])
+
+    try:
+        gd_print(&ret, 1)
+        return gdvariant_to_pyobject(&ret)
+    finally:
+        gd_variant_del(&ret)

src/godot/hazmat/gdapi.pxd.j2

@@ -3,6 +3,8 @@
     render_utility_function,
     render_builtin_type_cy_struct,
     render_builtin_type_c_extern,
+    render_builtin_into_variant_signature,
+    render_builtin_from_variant_signature,
     render_builtin_constructor_signature,
     render_builtin_destructor_signature,
     render_builtin_method_signature,
@@ -60,10 +62,15 @@ cdef extern from *:
 {% endfor %}
 
 
+# gd_variant_del(gd_variant_t *variant)
+# GDNativeObjectPtr gd_object_from_variant(gd_variant_t *val)
+# gd_variant_t gd_object_into_variant(GDNativeObjectPtr *val)
 {% for spec in api["builtins"] if not spec.is_scalar %}
 
 
 # {{spec.original_name }}: List of inlines functions defined in the jungle below
+# {{ render_builtin_into_variant_signature(spec) }}
+# {{ render_builtin_from_variant_signature(spec) }}
 {% for c in spec.constructors %}
 #     {{ render_builtin_constructor_signature(spec, c) }}
 {% endfor %}
@@ -129,6 +136,10 @@ DEF {{ key }} = {{ value }}
 #   and nicer inline function
 
 
+cdef inline gd_variant_del(gd_variant_t *variant):
+    pythonscript_gdapi.variant_destroy(variant)
+
+
 ##############################################################################
 #                    Inline defs: Utility functions                          #
 ##############################################################################
@@ -208,5 +219,5 @@ DEF {{ spec.c_name_prefix.upper() }}_{{ key }} = {{ value }}
 
 {% for spec in api["builtins"] if not spec.is_scalar %}
 cdef GDNativeTypeFromVariantConstructorFunc __{{ spec.name }}_from_variant
-cdef GDNativeVariantFromTypeConstructorFunc __{{ spec.name }}_to_variant
+cdef GDNativeVariantFromTypeConstructorFunc __{{ spec.name }}_into_variant
 {% endfor %}

src/godot/hazmat/gdapi_pxd/conversion.pxd.j2

@@ -1,5 +1,5 @@
-cdef object gdvariant_to_pyobj(const gd_variant_t *p_gdvar)
-cdef bint pyobj_to_gdvariant(object pyobj, gd_variant_t *p_var)
+cdef object gdvariant_to_pyobject(const gd_variant_t *p_gdvar)
+cdef bint pyobject_to_gdvariant(object pyobj, gd_variant_t *p_var)
 
 
 cdef bint is_pytype_compatible_with_gdvariant(object pytype)