Fix int/float vs builtins containing int/float size issues

Author: touilleMan

meson.build

@@ -26,6 +26,23 @@ if (
 endif
 
 
+# Godot can be build in two mode: real number in builtins (e.g. Vector2) as
+# 32bits (float, the default) or 64bits (double).
+# On top of that pointer size is of course different between 32 and 64 bits platforms.
+if get_option('real_is_double')
+    if host_machine.cpu_family() == 'x86_64'
+        godot_build_config = 'double_64'
+    else
+        godot_build_config = 'double_32'
+    endif
+else
+    if host_machine.cpu_family() == 'x86_64'
+        godot_build_config = 'float_64'
+    else
+        godot_build_config = 'float_32'
+    endif
+endif
+
 # We stick with Godot's platform naming
 # Note darwin may refere to iOS and macOS (because it's sooo clever to designate
 # two totally diferent things with the same name...) but we only support macOS

meson_options.txt

@@ -1,2 +1,3 @@
 option('cpython_distrib_version', type: 'string', value: '3.9.7', description: 'Version of CPython to ship')
 option('godot_headers', type: 'string', value: 'godot_headers', description: 'Path to Godot extension headers directory')
+option('real_is_double', type: 'boolean', value: false, description: 'Built for Godot with 64bits floating point numbers (i.e. double) in builtins instead of 32bits (i.e. float)')

scripts/extension_api_parser/api.py

@@ -7,7 +7,9 @@
 from .builtins import BuiltinSpec
 from .classes import ClassSpec
 from .type import (
+    TYPES_DB,
     TypeInUse,
+    TypeSpec,
     register_builtins_in_types_db,
     register_classes_in_types_db,
     register_global_enums_in_types_db,
@@ -118,6 +120,8 @@ class ExtensionApi:
     version_build: str  # e.g. "official"
     version_full_name: str  # e.g. "Godot Engine v4.0.alpha13.official"
 
+    variant_size: int
+
     classes: List[ClassSpec]
     builtins: List[BuiltinSpec]
     global_constants: List[GlobalConstantSpec]
@@ -126,6 +130,23 @@ class ExtensionApi:
     singletons: List[SingletonSpec]
     native_structures: List[NativeStructureSpec]
 
+    # Expose scalars
+
+    @property
+    def bool_spec(self):
+        return TYPES_DB["bool"]
+        # return next(builtin for builtin in self.builtins if builtin.name == "int")
+
+    @property
+    def int_spec(self):
+        return TYPES_DB["int"]
+        # return next(builtin for builtin in self.builtins if builtin.name == "int")
+
+    @property
+    def float_spec(self):
+        return TYPES_DB["float"]
+        # return next(builtin for builtin in self.builtins if builtin.name == "int")
+
 
 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
@@ -153,6 +174,18 @@ def merge_builtins_size_info(api_json: dict, build_config: BuildConfig) -> None:
             for item_member in item["members"]:
                 if item_member["name"] == member["member"]:
                     item_member["offset"] = member["offset"]
+                    # Float builtin in extension_api.json is always 64bits long,
+                    # however builtins made of floating point number can be made of
+                    # 32bits (C float) or 64bits (C double)
+                    if item_member["type"] == "float":
+                        if build_config in (BuildConfig.FLOAT_32, BuildConfig.FLOAT_64):
+                            item_member["type"] = "meta:float"
+                        else:
+                            assert build_config in (BuildConfig.DOUBLE_32, BuildConfig.DOUBLE_64)
+                            item_member["type"] = "meta:double"
+                    elif item_member["type"] == "int":
+                        # Builtins containing int is always made of int32
+                        item_member["type"] = "meta:int32"
                     break
             else:
                 raise RuntimeError(f"Don't member {member} doesn't seem to be part of {name} !")
@@ -166,7 +199,7 @@ def parse_extension_api_json(path: Path, build_config: BuildConfig) -> Extension
     api_json = json.loads(path.read_text(encoding="utf8"))
     assert isinstance(api_json, dict)
 
-    variant_size = merge_builtins_size_info(api_json, build_config)
+    merge_builtins_size_info(api_json, build_config)
 
     api = ExtensionApi(
         version_major=api_json["header"]["version_major"],
@@ -175,6 +208,7 @@ def parse_extension_api_json(path: Path, build_config: BuildConfig) -> Extension
         version_status=api_json["header"]["version_status"],
         version_build=api_json["header"]["version_build"],
         version_full_name=api_json["header"]["version_full_name"],
+        variant_size=api_json["variant_size"],
         classes=[ClassSpec.parse(x) for x in api_json["classes"]],
         builtins=[BuiltinSpec.parse(x) for x in api_json["builtin_classes"]],
         global_constants=[GlobalConstantSpec.parse(x) for x in api_json["global_constants"]],

scripts/extension_api_parser/type.py

@@ -18,13 +18,13 @@
 class TypeSpec:
     # Type used within Godot `extension_api.json`
     gdapi_type: str
-    # Type used when calling C api functions
-    c_type: str
     # Type used for PEP 484 Python typing
     py_type: str
+    # Type used when calling C api functions
+    c_type: str
     # Type used in Cython, basically similar to c_type for scalars&enums
     # and to py_type for Godot objects&builtins
-    cy_type: str = None
+    cy_type: str
     # Type is a Godot object (i.e. defined in api.json)
     is_object: bool = False
     # Type is a Godot builtin (e.g. Vector2)
@@ -40,7 +40,6 @@ class TypeSpec:
     variant_type_name: str = "<n/a>"
 
     def __post_init__(self):
-        self.cy_type = self.cy_type or self.py_type
         if self.is_scalar:
             assert not self.is_object
             assert not self.is_builtin
@@ -59,27 +58,32 @@ def __post_init__(self):
 
 
 TYPES_DB: Dict[str, TypeSpec] = {
-    "Variant": TypeSpec(gdapi_type="Variant", c_type="CVariant", py_type="GDAny", is_builtin=True),
+    "Variant": TypeSpec(
+        gdapi_type="Variant", c_type="CVariant", cy_type="object", py_type="GDAny", is_builtin=True
+    ),
     # Types marked as `meta` are used in the classes method args/return types
     "meta:int8": TypeSpec(
         gdapi_type="int8",
         c_type="int8_t",
+        cy_type="int8_t",
         py_type="int",
         variant_type_name="GDNATIVE_VARIANT_TYPE_INT",
         is_scalar=True,
         is_stack_only=True,
     ),
-    "meta:int32": TypeSpec(
-        gdapi_type="int32",
-        c_type="int32_t",
+    "meta:int16": TypeSpec(
+        gdapi_type="int16",
+        c_type="int16_t",
+        cy_type="int16_t",
         py_type="int",
         variant_type_name="GDNATIVE_VARIANT_TYPE_INT",
         is_scalar=True,
         is_stack_only=True,
     ),
-    "meta:int16": TypeSpec(
-        gdapi_type="int16",
-        c_type="int16_t",
+    "meta:int32": TypeSpec(
+        gdapi_type="int32",
+        c_type="int32_t",
+        cy_type="int32_t",
         py_type="int",
         variant_type_name="GDNATIVE_VARIANT_TYPE_INT",
         is_scalar=True,
@@ -88,6 +92,7 @@ def __post_init__(self):
     "meta:int64": TypeSpec(
         gdapi_type="int64",
         c_type="int64_t",
+        cy_type="int64_t",
         py_type="int",
         variant_type_name="GDNATIVE_VARIANT_TYPE_INT",
         is_scalar=True,
@@ -96,6 +101,7 @@ def __post_init__(self):
     "meta:uint8": TypeSpec(
         gdapi_type="uint8",
         c_type="uint8_t",
+        cy_type="uint8_t",
         py_type="int",
         variant_type_name="GDNATIVE_VARIANT_TYPE_INT",
         is_scalar=True,
@@ -104,6 +110,7 @@ def __post_init__(self):
     "meta:uint16": TypeSpec(
         gdapi_type="uint16",
         c_type="uint16_t",
+        cy_type="uint16_t",
         py_type="int",
         variant_type_name="GDNATIVE_VARIANT_TYPE_INT",
         is_scalar=True,
@@ -112,6 +119,7 @@ def __post_init__(self):
     "meta:uint32": TypeSpec(
         gdapi_type="uint32",
         c_type="uint32_t",
+        cy_type="uint32_t",
         py_type="int",
         variant_type_name="GDNATIVE_VARIANT_TYPE_INT",
         is_scalar=True,
@@ -120,6 +128,17 @@ def __post_init__(self):
     "meta:uint64": TypeSpec(
         gdapi_type="uint64",
         c_type="uint64_t",
+        cy_type="uint64_t",
+        py_type="int",
+        variant_type_name="GDNATIVE_VARIANT_TYPE_INT",
+        is_scalar=True,
+        is_stack_only=True,
+    ),
+    # int is always 8bytes long
+    "int": TypeSpec(
+        gdapi_type="int",
+        c_type="uint64_t",
+        cy_type="uint64_t",
         py_type="int",
         variant_type_name="GDNATIVE_VARIANT_TYPE_INT",
         is_scalar=True,
@@ -128,6 +147,7 @@ def __post_init__(self):
     "meta:float": TypeSpec(
         gdapi_type="float",
         c_type="float",
+        cy_type="float",
         py_type="float",
         variant_type_name="GDNATIVE_VARIANT_TYPE_FLOAT",
         is_scalar=True,
@@ -136,6 +156,7 @@ def __post_init__(self):
     "meta:double": TypeSpec(
         gdapi_type="double",
         c_type="double",
+        cy_type="double",
         py_type="float",
         variant_type_name="GDNATIVE_VARIANT_TYPE_FLOAT",
         is_scalar=True,
@@ -159,6 +180,7 @@ def register_builtins_in_types_db(builtins: Iterable["BuiltinSpec"]) -> None:
                 # Cython provide a `bint` type for boolean, however it is defined in C as
                 # a `int` (so 32bits), so I guess it won't work for Godot's 8bits bool
                 c_type=f"uint{spec.size*8}_t",
+                cy_type=f"uint{spec.size*8}_t",
                 is_stack_only=True,
                 is_scalar=True,
                 variant_type_name=spec.variant_type_name,
@@ -194,6 +216,7 @@ def register_classes_in_types_db(classes: Iterable["ClassSpec"]) -> None:
             gdapi_type=spec.original_name,
             py_type=spec.name,
             c_type="Object",
+            cy_type="Object",
             variant_type_name="GDNATIVE_VARIANT_TYPE_OBJECT",
         )
         TYPES_DB[ts.gdapi_type] = ts
@@ -202,6 +225,7 @@ def register_classes_in_types_db(classes: Iterable["ClassSpec"]) -> None:
                 gdapi_type=f"enum::{spec.original_name}.{e.original_name}",
                 py_type=f"{spec.name}.{e.name}",
                 c_type="int",
+                cy_type=f"{spec.name}.{e.name}",
                 is_scalar=True,
                 is_stack_only=True,
                 is_enum=True,
@@ -216,6 +240,7 @@ def register_global_enums_in_types_db(enums: Iterable["GlobalEnumSpec"]) -> None
             gdapi_type=f"enum::{spec.original_name}",
             py_type=spec.name,
             c_type="int",
+            cy_type=spec.name,
             is_scalar=True,
             is_stack_only=True,
             is_enum=True,
@@ -230,7 +255,6 @@ class TypeInUse:
 
     def __repr__(self) -> str:
         try:
-            raise KeyError
             resolved = self.resolve()
         except KeyError:
             resolved = "<not resolved yet>"
@@ -242,7 +266,6 @@ def resolve(self) -> TypeSpec:
         try:
             return TYPES_DB[self.type_name]
         except KeyError:
-            breakpoint()
             return
 
     def __getattr__(self, name: str):

scripts/generate_tmpl.py

@@ -74,15 +74,13 @@ def generate_builtins_pyi(api: ExtensionApi) -> str:
     parser.add_argument(
         "--build-config",
         required=True,
-        type=BuildConfig,
-        choices=BuildConfig,
-        help=f"choices: {', '.join([x.value for x in BuildConfig])}",
+        choices=[x.value for x in BuildConfig],
         metavar="CONFIG",
     )
 
     args = parser.parse_args()
 
-    api = parse_extension_api_json(path=args.input, build_config=args.build_config)
+    api = parse_extension_api_json(path=args.input, build_config=BuildConfig(args.build_config))
 
     # We use # in the name to simulate folder hierarchy in the meson build
     *_, name = args.output.name.rsplit("#", 1)

src/_pythonscript.pyx

@@ -43,9 +43,10 @@ cdef api void _pythonscript_initialize() with gil:
     cooked_sys_version = '.'.join(map(str, sys.version_info))
     print(f"Pythonscript {pythonscript_version} (CPython {cooked_sys_version})")
     print(f"PYTHONPATH: {sys.path}")
-    v = Vector2(3., 2.)
-    v2 = Vector2(v)
+    v = Vector2(66.8, 77.99)
+    v.x = 42
     print("===========>", v.x, v.y)
+    v2 = Vector2(v)
     print("+++++++++++>", v2.x, v2.y)
 
 

src/godot/_builtins.pyx.j2

@@ -1,4 +1,4 @@
-{%- from '_builtins_pyx/class.j2' import render_spec -%}
+{%- from '_builtins_pyx/class.j2' import render_spec with context -%}
 # /!\ Autogenerated code, modifications will be lost /!\
 # see `scripts/generate_tmpl.py`
 

src/godot/_builtins_pyx/class.j2

@@ -1,5 +1,5 @@
-{%- from '_builtins_pyx/constructor.j2' import render_constructor -%}
-{%- from '_builtins_pyx/gdapi.j2' import render_gdapi -%}
+{%- from '_builtins_pyx/constructor.j2' import render_constructor with context -%}
+{%- from '_builtins_pyx/gdapi.j2' import render_gdapi with context -%}
 
 {% macro render_spec(spec) -%}
 
@@ -52,7 +52,7 @@ cdef class {{ spec.name }}:
     def {{ m.name }}(self) -> {{ m.type.py_type }}:
 {%   if m.offset is not none %}
 {%     if m.type.is_scalar %}
-        return (<{{ m.type.c_type }}*>self._gd_data)[{{ m.offset }}]
+        return (<{{ m.type.c_type }}*>(&self._gd_data[{{ m.offset }}]))[0]
 {#   TODO: ensure m.type doesn't need a destructor #}
 {%     else %}
 {#      TODO: Find a way to avoid this copy ? #}
@@ -63,7 +63,7 @@ cdef class {{ spec.name }}:
     @{{ m.name }}.setter
     def {{ m.name }}(self, {{ m.type.py_type }} value) -> None:
 {%     if m.type.is_scalar %}
-        (<{{ m.type.c_type }}*>self._gd_data)[{{ m.offset }}] = value
+        (<{{ m.type.c_type }}*>(&self._gd_data[{{ m.offset }}]))[0] = value
 {#   TODO: ensure m.type doesn't need a destructor #}
 {%     else %}
         self._gd_data = value._gd_data

src/godot/_builtins_pyx/constructor.j2

@@ -8,8 +8,8 @@
 
 def __cinit__({{ spec.name }} self, x=None, y=None):
     cdef GDNativeTypePtr args[2]
-    cdef float args_x
-    cdef float args_y
+    cdef {{ api.float_spec.cy_type }} args_x
+    cdef {{ api.float_spec.cy_type }} args_y
     if y is None:
         if x is None:
             __{{ spec.name }}_constructor_0(self._gd_data, NULL)

src/meson.build

@@ -17,22 +17,13 @@ generate_tmpl_base_input = [
 ]
 
 
-if host_machine.cpu_family() == 'x86_64'
-    generate_tmpl_build_config = 'double_64'
-elif host_machine.cpu_family() == 'x86'
-    generate_tmpl_build_config = 'double_32'
-else
-    error('Unsupported CPU familly' + host_machine.cpu_family())
-endif
-
-
 generate_tmpl_cmd = [
     python,
     '@INPUT0@',  # generate_tmpl.py
     '--input',
     '@INPUT1@',  # extension_api.json
     '--build-config',
-    generate_tmpl_build_config,
+    godot_build_config,
     '--output',
     '@OUTPUT0@',
 ]