raylib 5.0.0.0__pp38-pypy38_pp73-win_amd64.whl → 5.0.0.2__pp38-pypy38_pp73-win_amd64.whl

pyray/__init__.py

@@ -11,6 +11,9 @@
 #  available at https://www.gnu.org/software/classpath/license.html.
 #
 #  SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+import re
+import weakref
+from array import array
 
 from raylib import rl, ffi
 from raylib.colors import *
@@ -21,12 +24,21 @@ except AttributeError:
     print("sorry deprecated enums dont work on dynamic version")
 
 from inspect import getmembers, isbuiltin
-import inflection
 
 current_module = __import__(__name__)
 
 
-def pointer(self, struct):
+def _underscore(word: str) -> str:
+    """
+    from inflection
+    """
+    word = re.sub(r"([A-Z]+)([A-Z][a-z])", r'\1_\2', word)
+    word = re.sub(r"([a-z\d])([A-Z])", r'\1_\2', word)
+    word = word.replace("-", "_")
+    return word.lower()
+
+
+def pointer(struct):
     return ffi.addressof(struct)
 
 
@@ -38,70 +50,93 @@ def pointer(self, struct):
 # Another possibility is ffi.typeof() but that will throw an exception if you give it a type that isn't a ctype
 # Another way to improve performance might be to special-case simple types before doing the string comparisons
 
-def makefunc(a):
+def _wrap_function(original_func):
     # print("makefunc ",a, ffi.typeof(a).args)
-    def func(*args):
+    def wrapped_func(*args):
         modified_args = []
-        for (c_arg, arg) in zip(ffi.typeof(a).args, args):
-            #print("arg:",str(arg), "c_arg.kind:", c_arg.kind, "c_arg:", c_arg, "type(arg):",str(type(arg)))
+        for (c_arg, arg) in zip(ffi.typeof(original_func).args, args):
+            # print("arg:",str(arg), "c_arg.kind:", c_arg.kind, "c_arg:", c_arg, "type(arg):",str(type(arg)))
             if c_arg.kind == 'pointer':
-                if type(arg) == str:
+                if type(arg) is str:
                     arg = arg.encode('utf-8')
-                elif type(arg) is bool:
-                    arg = ffi.new("bool *", arg)
-                elif type(arg) is int:
-                    arg = ffi.new("int *", arg)
-                elif type(arg) is float:
-                    arg = ffi.new("float *", arg)
-                elif type(arg) is list  and str(c_arg) == "<ctype 'char * *'>":
+                # if c_arg is a 'char *' not a 'const char *' then we ought to raise here because its an out
+                # parameter and user should supply a ctype pointer, but cffi cant detect const
+                # so we would have to get the info from raylib.json
+                elif type(arg) is list and str(c_arg) == "<ctype 'char * *'>":
                     arg = [ffi.new("char[]", x.encode('utf-8')) for x in arg]
-                elif str(type(arg)) == "<class '_cffi_backend.__CDataOwn'>" and "*" not in str(arg):  # CPython
-                    arg = ffi.addressof(arg)
-                elif str(type(arg)) == "<class '_cffi_backend._CDataBase'>" and "*" not in str(arg):  # Pypy
+                elif is_cdata(arg) and "*" not in str(arg):
                     arg = ffi.addressof(arg)
                 elif arg is None:
                     arg = ffi.NULL
+                elif not is_cdata(arg):
+                    if str(c_arg) == "<ctype '_Bool *'>":
+                        raise TypeError(
+                            "Argument must be a ctype bool, please create one with: pyray.ffi.new('bool *', True)")
+                    elif str(c_arg) == "<ctype 'int *'>":
+                        raise TypeError(
+                            "Argument must be a ctype int, please create one with: pyray.ffi.new('int *', 1)")
+                    elif str(c_arg) == "<ctype 'float *'>":
+                        raise TypeError(
+                            "Argument must be a ctype float, please create one with: pyray.ffi.new('float *', 1.0)")
             modified_args.append(arg)
-        result = a(*modified_args)
+        result = original_func(*modified_args)
         if result is None:
             return
-        if str(type(result)) == "<class '_cffi_backend._CDataBase'>" and str(result).startswith("<cdata 'char *'"):
+        elif is_cdata(result) and str(result).startswith("<cdata 'char *'"):
             if str(result) == "<cdata 'char *' NULL>":
-                result = ""
+                return ""
             else:
-                result = ffi.string(result).decode('utf-8')
-        return result
+                return ffi.string(result).decode('utf-8')
+        else:
+            return result
 
-    return func
+    # apparently pypy and cpython produce different types so check for both
+    def is_cdata(arg):
+        return str(type(arg)) == "<class '_cffi_backend.__CDataOwn'>" or str(
+            type(arg)) == "<class '_cffi_backend._CDataBase'>"
 
+    return wrapped_func
 
-def makeStructHelper(struct):
+
+global_weakkeydict = weakref.WeakKeyDictionary()
+
+
+def _make_struct_constructor_function(struct):
     def func(*args):
-        return ffi.new(f"struct {struct} *", args)[0]
+        # print(struct, args)
+        modified_args = []
+        for (field, arg) in zip(ffi.typeof(struct).fields, args):
+            # print("arg:", str(arg), "field:", field[1], "field type:", field[1].type, "type(arg):", str(type(arg)))
+            if arg is None:
+                arg = ffi.NULL
+            elif (field[1].type.kind == 'pointer'
+                  and (str(type(arg)) == "<class 'numpy.ndarray'>"
+                       or isinstance(arg, (array, bytes, bytearray, memoryview)))):
+                arg = ffi.from_buffer(field[1].type, arg)
+            modified_args.append(arg)
+        s = ffi.new(f"struct {struct} *", modified_args)[0]
+        global_weakkeydict[s] = modified_args
+        return s
 
     return func
 
 
 for name, attr in getmembers(rl):
     # print(name, attr)
-    uname = inflection.underscore(name).replace('3_d', '_3d').replace('2_d', '_2d')
+    uname = _underscore(name).replace('3_d', '_3d').replace('2_d', '_2d')
     if isbuiltin(attr) or str(type(attr)) == "<class '_cffi_backend.__FFIFunctionWrapper'>" or str(
             type(attr)) == "<class '_cffi_backend._CDataBase'>":
         # print(attr.__call__)
         # print(attr.__doc__)
-        # print(attr.__text_signature__)
         # print(dir(attr))
         # print(dir(attr.__repr__))
-        f = makefunc(attr)
+        f = _wrap_function(attr)
         setattr(current_module, uname, f)
-        # def wrap(*args):
-        #    print("call to ",attr)
-        # setattr(PyRay, uname, lambda *args: print("call to ",attr))
     else:
         setattr(current_module, name, attr)
 
 for struct in ffi.list_types()[0]:
-    f = makeStructHelper(struct)
+    f = _make_struct_constructor_function(struct)
     setattr(current_module, struct, f)
 
 # overwrite ffi enums with our own