Very crude (and half broken ^^) support for script class instance

Author: touilleMan

src/godot/__init__.py

@@ -38,6 +38,8 @@
 # )
 from .builtins import *  # noqa: E402, F403
 
+from ._lang import exposed  # noqa: E402, F401
+
 # from .classes import _load_singleton, _load_class
 
 

src/godot/_lang.pyx

@@ -11,10 +11,12 @@ from .classes cimport _load_class, _load_singleton, _cleanup_loaded_classes_and_
 # Extensions definition
 #
 
-include "_lang_script_language.pxi"
-include "_lang_script.pxi"
 include "_lang_resource_format_loader.pxi"
 include "_lang_resource_format_saver.pxi"
+include "_lang_script_language.pxi"
+include "_lang_script.pxi"
+include "_lang_script_instance.pxi"
+include "_lang_tags.pxi"
 
 
 #

src/godot/_lang_resource_format_loader.pxi

@@ -1,3 +1,7 @@
+import importlib
+import traceback
+
+
 cdef object RESOURCE_TYPE_NAME = "Python"
 cdef object RESOURCE_EXTENSIONS = ("py", "pyc", "pyo", "pyd")
 
@@ -85,37 +89,81 @@ cdef class PythonResourceFormatLoader:
     # godot_extension: method(virtual=True, const=True)
     cdef gd_variant_t _load(self, gd_string_t path, gd_string_t original_path, gd_bool_t use_sub_threads, gd_int_t cache_mode):
         cdef gd_variant_t ret = gd_variant_new()
-        cdef object py_path = gdapi.gd_string_to_pystr(&path)
-        cdef object py_original_path = gdapi.gd_string_to_pystr(&original_path)
+        cdef str py_path = gdapi.gd_string_to_pystr(&path)
+        cdef str py_original_path = gdapi.gd_string_to_pystr(&original_path)
         gd_string_del(&path)
         gd_string_del(&original_path)
         spy_log(f"CALLED PythonResourceFormatLoader::_load(path={py_path!r}, original_path={py_original_path!r}, use_sub_threads={use_sub_threads}, cache_mode={cache_mode})")
 
+        # 1) Check path and convert it to Python format (e.g. `res://foo/bar.py` -> `foo.bar`)
+
+        if not (
+            py_path.startswith("res://") and
+            (
+                py_path.endswith(".py") or
+                py_path.endswith(".pyc") or
+                py_path.endswith(".pyo") or
+                py_path.endswith(".pyd")
+            )
+        ):
+            print(
+                f"Bad python script path `{py_path}`, must starts by `res://` and ends with `.py/pyc/pyo/pyd`", flush=True
+            )
+            return gdapi.gd_int_into_variant(Error.ERR_FILE_BAD_PATH)
+
+        # TODO: possible bug if res:// is not part of PYTHONPATH
+        # Remove `res://`, `.py` and replace / by .
+        modname = py_path[len("res://"):].rsplit(".", 1)[0].replace("/", ".")
+
+        try:
+            importlib.import_module(modname)  # Force lazy loading of the module
+            klass = _get_exposed_class(modname)  # `_get_exposed_class` defined in `_lang_tags.pxi`
+            print('=========> new Godot-Python class', klass)
+
+        except BaseException:
+            # If we are here it could be because the file doesn't exists
+            # or (more possibly) the file content is not valid python (or
+            # doesn't provide an exposed class)
+            print(
+                f"Got exception loading `{py_path}` (aka `{modname}`): {traceback.format_exc()}", flush=True
+            )
+            return gdapi.gd_int_into_variant(Error.ERR_PARSE_ERROR)
+
+        if klass is None:
+            print(
+                f"Cannot load `{py_path}` (aka `{modname}`) because it doesn't expose any class to Godot", flush=True
+            )
+            return gdapi.gd_int_into_variant(Error.ERR_PARSE_ERROR)
+
+
+
         cdef PythonScript script
-        cdef gd_string_t gd_source
-        cdef gd_string_t gd_script_path
-        cdef GDString source_code
-
-        # Load the source code from file
-
-        from godot.classes import FileAccess
-        # TODO: use `path` directly !
-        cdef object file = FileAccess.open(GDString(py_path), FileAccess.ModeFlags.READ.value)
-        if file is None:
-            spy_log(f"Failed to load Python script {py_original_path}: cannot open file {path}")
-            # If file loading fails, return the nil variant (already initialized)
-            return ret
-        # TODO: what happen if the text is not UTF8 ?
-        source_code = file.get_as_text()
+        # cdef gd_string_t gd_source
+        # cdef gd_string_t gd_script_path
+        # cdef GDString source_code
+
+        # # Load the source code from file
+
+        # from godot.classes import FileAccess
+        # # TODO: use `path` directly !
+        # cdef object file = FileAccess.open(GDString(py_path), FileAccess.ModeFlags.READ.value)
+        # if file is None:
+        #     spy_log(f"Failed to load Python script {py_original_path}: cannot open file {path}")
+        #     # If file loading fails, return the nil variant (already initialized)
+        #     return ret
+        # # TODO: what happen if the text is not UTF8 ?
+        # source_code = file.get_as_text()
 
         # Create a new script instance from the source code
 
-        script = PythonScript()
-        script._set_source_code(source_code.into_gd_data())
-        # `into_gd_data()` steal the underlying Godot string, so `source_code`
-        # ends up containing nothing and we'd rather destroy it early to avoid
-        # confusions.
-        del source_code
+        script = PythonScript()  # `__cinit__()` initializes `script._gd_ptr`
+        script._py_cls = klass
+        script._script_instance_info = generate_instance_info()
+        # script._set_source_code(source_code.into_gd_data())
+        # # `into_gd_data()` steal the underlying Godot string, so `source_code`
+        # # ends up containing nothing and we'd rather destroy it early to avoid
+        # # confusions.
+        # del source_code
 
         # Return the script as a variant
 

src/godot/_lang_script.pxi

@@ -4,16 +4,23 @@
 # create an instance of this script)
 
 
+from godot.hazmat cimport gdptrs
+
+
 # godot_extension: class(parent="ScriptExtension")
 @cython.final
 cdef class PythonScript:
     # Godot "sees" us through this object
     cdef gd_object_t _gd_ptr
+    # The Python class that *is* the script
+    cdef object _py_cls
+    cdef GDExtensionScriptInstanceInfo3 _script_instance_info
 
     # godot_extension: method(virtual=True, const=True)
     cdef gd_bool_t _can_instantiate(self):
         spy_log("CALLED PythonScript::_can_instantiate()")
-        return self._is_valid()
+        return True
+        # return self._is_valid()
 
     # godot_extension: method(virtual=True)
     cdef gd_bool_t _editor_can_reload_from_file(self):
@@ -193,11 +200,18 @@ cdef class PythonScript:
     # godot_extension: method(virtual=True, const=True)
     cdef void* _instance_create(self, gd_object_t for_object):
         spy_log(f"CALLED PythonScript::_instance_create(for_object=<object 0x{<size_t>for_object:x}>)")
-        # For now, return NULL as we don't have full instance support yet
-        # This would need to create a Python script instance that can
-        # execute the script code and handle Godot callbacks
-        # `gd_object_t` doesn't need to be be deleted (is it just a raw pointer)
-        return NULL
+
+        # Call to __new__ bypasses __init__ constructor
+        cdef BaseGDObject py_instance = self._py_cls.__new__(self._py_cls)
+        py_instance._gd_ptr = for_object
+        # TODO: call `__init__` ? or a init hook ?
+        Py_INCREF(py_instance)
+        cdef GDExtensionScriptInstancePtr script_instance = gdptrs.gdptr_script_instance_create3(
+            &self._script_instance_info,
+            <void*>py_instance,
+        )
+        spy_log(f"CALLED PythonScript::_instance_create(for_object=<object 0x{<size_t>for_object:x}>) -> <object 0x{<size_t>script_instance:x}>")
+        return script_instance
 
     # godot_extension: method(virtual=True, const=True)
     cdef gd_bool_t _instance_has(self, gd_object_t object):
@@ -216,29 +230,23 @@ cdef class PythonScript:
     # godot_extension: method(virtual=True, const=True)
     cdef gd_bool_t _is_tool(self):
         spy_log("CALLED PythonScript::_is_tool()")
-        # Check if the script contains @tool decorator or similar
-        if not self._source_code:
+        if self._py_cls is not None:
+            return self._py_cls._tool
+        else:
             return False
-        try:
-            lines = self._source_code.split('\n')
-            for line in lines:
-                if line.strip().startswith('@tool') or '# tool' in line.lower():
-                    return True
-        except:
-            pass
-        return False
 
     # godot_extension: method(virtual=True, const=True)
     cdef gd_bool_t _is_valid(self):
         spy_log("CALLED PythonScript::_is_valid()")
-        # A script is valid if it has source code and can be compiled
-        if not self._source_code:
-            return False
-        try:
-            compile(self._source_code, '<string>', 'exec')
-            return True
-        except:
-            return False
+        return True
+        # # A script is valid if it has source code and can be compiled
+        # if not self._source_code:
+        #     return False
+        # try:
+        #     compile(self._source_code, '<string>', 'exec')
+        #     return True
+        # except:
+        #     return False
 
     # godot_extension: method(virtual=True)
     cdef void _placeholder_erased(self, void* placeholder):