PyOpenGL-accelerate 3.1.10__tar.gz → 4.0.0a4__tar.gz

{pyopengl_accelerate-3.1.10 → pyopengl_accelerate-4.0.0a4}/OpenGL_accelerate/__init__.py

@@ -7,5 +7,5 @@ PyOpenGL package and is built via the setupaccel.py
 script in the top level of the PyOpenGL source package.
 """
 
-__version__ = "3.1.10"
-__version_tuple__ = (3, 1, 10)
+__version__ = "4.0.0a4"
+__version_tuple__ = (4, 0, 0)

pyopengl_accelerate-4.0.0a4/PKG-INFO

@@ -0,0 +1,46 @@
+Metadata-Version: 2.4
+Name: PyOpenGL-accelerate
+Version: 4.0.0a4
+Summary: Cython-coded accelerators for PyOpenGL
+Home-page: http://pyopengl.sourceforge.net
+Download-URL: http://sourceforge.net/project/showfiles.php?group_id=5988
+Author: Mike C. Fletcher
+Author-email: "Mike C. Fletcher" <mcfletch@vrplumber.com>
+License-Expression: BSD-3-Clause
+Project-URL: Homepage, https://mcfletch.github.io/pyopengl/
+Project-URL: Download, https://pypi.org/project/PyOpenGL-accelerate/
+Project-URL: Source, https://github.com/mcfletch/pyopengl
+Project-URL: Documentation, https://mcfletch.github.io/pyopengl/documentation/index.html
+Keywords: Graphics,3D,OpenGL,GLU,GLUT,GLE,GLX,EXT,ARB,Mesa,PyOpenGL
+Platform: Win32
+Platform: Linux
+Platform: OS-X
+Platform: Posix
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Multimedia :: Graphics :: 3D Rendering
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Intended Audience :: Developers
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: license.txt
+Requires-Dist: PyOpenGL==4.0.0a4
+Dynamic: download-url
+Dynamic: license-file
+Dynamic: requires-dist
+
+# Acceleration code for PyOpenGL
+
+This set of C (Cython) extensions provides acceleration of common operations
+for slow points in PyOpenGL 3.x. It is not a requirement for using PyOpenGL
+but performance without it will be poor.
+
+## Build Process
+
+Cython is updated frequently to support newer versions of Python. As of
+release 3.1.9 we no longer check in the Cython generated code for the
+wrapper modules, relying on the build machines to generate the wrappers.
+
+The Github CI Pipeline should generate and release binary builds for most
+major platforms (Windows, Linux, Mac), but if you need to build from source,
+a `pip install .` **should** work from the PyOpenGL repository.

pyopengl_accelerate-4.0.0a4/PyOpenGL_accelerate.egg-info/PKG-INFO

@@ -0,0 +1,46 @@
+Metadata-Version: 2.4
+Name: PyOpenGL-accelerate
+Version: 4.0.0a4
+Summary: Cython-coded accelerators for PyOpenGL
+Home-page: http://pyopengl.sourceforge.net
+Download-URL: http://sourceforge.net/project/showfiles.php?group_id=5988
+Author: Mike C. Fletcher
+Author-email: "Mike C. Fletcher" <mcfletch@vrplumber.com>
+License-Expression: BSD-3-Clause
+Project-URL: Homepage, https://mcfletch.github.io/pyopengl/
+Project-URL: Download, https://pypi.org/project/PyOpenGL-accelerate/
+Project-URL: Source, https://github.com/mcfletch/pyopengl
+Project-URL: Documentation, https://mcfletch.github.io/pyopengl/documentation/index.html
+Keywords: Graphics,3D,OpenGL,GLU,GLUT,GLE,GLX,EXT,ARB,Mesa,PyOpenGL
+Platform: Win32
+Platform: Linux
+Platform: OS-X
+Platform: Posix
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Multimedia :: Graphics :: 3D Rendering
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Intended Audience :: Developers
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: license.txt
+Requires-Dist: PyOpenGL==4.0.0a4
+Dynamic: download-url
+Dynamic: license-file
+Dynamic: requires-dist
+
+# Acceleration code for PyOpenGL
+
+This set of C (Cython) extensions provides acceleration of common operations
+for slow points in PyOpenGL 3.x. It is not a requirement for using PyOpenGL
+but performance without it will be poor.
+
+## Build Process
+
+Cython is updated frequently to support newer versions of Python. As of
+release 3.1.9 we no longer check in the Cython generated code for the
+wrapper modules, relying on the build machines to generate the wrappers.
+
+The Github CI Pipeline should generate and release binary builds for most
+major platforms (Windows, Linux, Mac), but if you need to build from source,
+a `pip install .` **should** work from the PyOpenGL repository.

{pyopengl_accelerate-3.1.10 → pyopengl_accelerate-4.0.0a4}/PyOpenGL_accelerate.egg-info/SOURCES.txt

@@ -10,6 +10,7 @@ OpenGL_accelerate/wrapper.pxd
 PyOpenGL_accelerate.egg-info/PKG-INFO
 PyOpenGL_accelerate.egg-info/SOURCES.txt
 PyOpenGL_accelerate.egg-info/dependency_links.txt
+PyOpenGL_accelerate.egg-info/requires.txt
 PyOpenGL_accelerate.egg-info/top_level.txt
 src/arraydatatype.pyx
 src/buffers_formathandler.pyx
@@ -20,5 +21,17 @@ src/nones_formathandler.pyx
 src/numpy_formathandler.pyx
 src/vbo.pyx
 src/wrapper.pyx
+src/c/pygl_handwritten.c
+src/c/pygl_runtime.c
+src/c/generated/pygl_EGL.c
+src/c/generated/pygl_GL.c
+src/c/generated/pygl_GLES1.c
+src/c/generated/pygl_GLES2.c
+src/c/generated/pygl_GLES3.c
+src/c/generated/pygl_GLSC2.c
+src/c/generated/pygl_GLX.c
+src/c/generated/pygl_WGL.c
+src/c/generated/pygl_generated.c
+src/c/generated/pygl_modules.c
 tests/test_arraydatatypeaccel.py
 tests/test_numpyaccel.py

pyopengl_accelerate-4.0.0a4/PyOpenGL_accelerate.egg-info/requires.txt

@@ -0,0 +1 @@
+PyOpenGL==4.0.0a4

pyopengl_accelerate-4.0.0a4/pyproject.toml

@@ -0,0 +1,72 @@
+[project]
+name="PyOpenGL-accelerate"
+dynamic=["version", "dependencies"]
+description = "Cython-coded accelerators for PyOpenGL"
+authors = [
+    {name="Mike C. Fletcher",email="mcfletch@vrplumber.com"},
+]
+readme = {file="README.md", content-type = "text/markdown"}
+license = "BSD-3-Clause"
+license-files = ["license.txt"]
+requires-python = ">=3.9"
+keywords = [
+    "Graphics",
+    "3D",
+    "OpenGL",
+    "GLU",
+    "GLUT",
+    "GLE",
+    "GLX",
+    "EXT",
+    "ARB",
+    "Mesa",
+    "PyOpenGL",
+]
+classifiers = [
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3",
+    "Topic :: Multimedia :: Graphics :: 3D Rendering",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Intended Audience :: Developers",
+]
+[project.urls]
+Homepage = "https://mcfletch.github.io/pyopengl/"
+Download = "https://pypi.org/project/PyOpenGL-accelerate/"
+Source = "https://github.com/mcfletch/pyopengl"
+Documentation = "https://mcfletch.github.io/pyopengl/documentation/index.html"
+
+[build-system]
+# numpy 2.0+ produces wheels that are ABI-compatible with numpy >= 1.26 at runtime
+# via the PyDataType_* accessor backports. Mostly hit by cibuildwheel.
+requires = [
+    "setuptools >= 77.0",
+    "Cython >= 0.28",
+    "numpy >= 2.0",
+]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.dynamic]
+version = {attr = "OpenGL_accelerate.__version__"}
+# The dependency on PyOpenGL is an exact pin on this package's own version, so
+# setup.py builds it from the one number rather than a second copy living here
+# to drift -- see pyopengl_requirement().
+
+[tool.setuptools.packages.find]
+namespaces=false
+include=["OpenGL_accelerate"]
+exclude=["tests","src"]
+
+# uv decides whether its cached metadata for a source tree is still current
+# from pyproject.toml, setup.py and setup.cfg alone. This project's version
+# lives in OpenGL_accelerate/__init__.py, so name that file too: without it a
+# version bump leaves uv answering with the previous number, and a dependent
+# requiring the new one resolves against PyPI rather than this checkout.
+[tool.uv]
+# setup.py too: the dependency on PyOpenGL is built there, from the version
+# in OpenGL_accelerate/__init__.py, so both files decide this package's
+# metadata and a change to either has to invalidate the cached answer.
+cache-keys = [
+    { file = "pyproject.toml" },
+    { file = "setup.py" },
+    { file = "OpenGL_accelerate/__init__.py" },
+]

pyopengl_accelerate-4.0.0a4/setup.py

@@ -0,0 +1,224 @@
+#!/usr/bin/env python
+"""Builds accelleration functions for PyOpenGL
+"""
+import sys
+from setuptools import setup, Extension
+
+try:
+    from Cython.Distutils import build_ext
+except ImportError:
+    have_cython = False
+    build_ext = False
+else:
+    have_cython = True
+
+import sys, os
+
+HERE = os.path.normpath(os.path.abspath(os.path.dirname(__file__)))
+
+extensions = []
+
+
+def _our_version():
+    """This package's version, read without importing it.
+
+    Importing ``OpenGL_accelerate`` during its own build would need the
+    extensions that are not built yet, so the assignment is read out of the
+    source the way the build backend reads it.
+    """
+    import re
+
+    with open(
+        os.path.join(HERE, 'OpenGL_accelerate', '__init__.py'), encoding='utf-8'
+    ) as handle:
+        source = handle.read()
+    found = re.search(r'^__version__\s*=\s*["\']([^"\']+)["\']', source, re.M)
+    if not found:
+        raise RuntimeError('OpenGL_accelerate/__init__.py states no __version__')
+    return found.group(1)
+
+
+def pyopengl_requirement():
+    """The PyOpenGL this accelerate pairs with, as a requirement string.
+
+    Exact, because the two are released together from one repository and the
+    dispatch extension's tables are generated from that PyOpenGL: a mismatched
+    pair does not degrade, it dispatches through the wrong slot indices.
+    ``OpenGL._dispatch`` refuses one at import; this stops pip assembling one
+    in the first place, which is a better place to learn it than the first
+    entry point a program calls.
+
+    Read from this package's own version so there is one number to bump.
+    """
+    return 'PyOpenGL==%s' % (_our_version(),)
+
+
+def dispatch_extension():
+    """The registry-generated C implementation of the OpenGL entry points.
+
+    It lives here rather than in ``pyopengl`` so that ``pyopengl`` stays a
+    single universal wheel: the C is what needs a compiler and a wheel per
+    platform, and this package is already the optional compiled companion.
+    "Is the fast path available?" is then the question it has always been --
+    is accelerate installed?
+
+    Both packages are released together from one repository, and the two
+    share generated tables, so the versions must match exactly; the module
+    checks that at import.
+    """
+    import glob
+
+    if os.environ.get('PYOPENGL_NO_C_DISPATCH'):
+        return []
+    if sys.implementation.name != 'cpython':
+        # The extension reaches CPython's vectorcall protocol directly.  On
+        # PyPy it would compile, import, and route every call through an
+        # emulated vectorcall across the cpyext boundary -- the slowest path
+        # available, chosen by default, on the interpreter the ctypes
+        # implementation exists to serve.
+        return []
+    generated = os.path.join(HERE, 'src', 'c', 'generated')
+    sources = sorted(
+        os.path.relpath(path, HERE).replace(os.sep, '/')
+        for path in glob.glob(os.path.join(generated, '*.c'))
+    )
+    if not sources:
+        return []
+    sources.insert(0, 'src/c/pygl_handwritten.c')
+    sources.insert(0, 'src/c/pygl_runtime.c')
+    # setuptools does not work out header dependencies, so a change to pygl.h
+    # would otherwise leave the generated objects stale and the build mixed:
+    # objects compiled against one version of a macro linked with a runtime
+    # compiled against another.
+    headers = [
+        'src/c/pygl.h',
+        'src/c/generated/pygl_elements.h',
+        'src/c/generated/pygl_glgets.h',
+    ]
+    return [
+        Extension(
+            'OpenGL_accelerate.dispatch',
+            sources=sources,
+            include_dirs=['src/c', 'src/c/generated'],
+            # The extension states which PyOpenGL its tables were generated
+            # from, so that a mismatched pair is refused with a sentence rather
+            # than dispatching through the wrong slot indices.  The two are
+            # released together and carry the same number, so this is the
+            # accelerate version.
+            define_macros=[('PYOPENGL_VERSION', '"%s"' % (_our_version(),))],
+            depends=[
+                path for path in headers if os.path.exists(os.path.join(HERE, path))
+            ],
+            # Optional so a source install without a compiler still yields a
+            # working accelerate; PyOpenGL falls back to ctypes on its own.
+            # Set PYOPENGL_REQUIRE_C_DISPATCH=1 while working on it, or a
+            # compile error is a warning and the stale object is kept.
+            optional=not os.environ.get('PYOPENGL_REQUIRE_C_DISPATCH'),
+        )
+    ]
+
+
+extensions.extend(dispatch_extension())
+
+
+def cython_extension(
+    name,
+    include_dirs=(),
+):
+    """Create a cython extension object"""
+    filenames = "%(name)s.c" % locals(), "%(name)s.pyx" % locals()
+    filename = filenames[bool(have_cython)]
+    return Extension(
+        "OpenGL_accelerate.%(name)s" % locals(),
+        [
+            os.path.join("src", filename),
+        ],
+        include_dirs=[
+            os.path.join(HERE, "src"),
+            HERE,
+        ]
+        + list(include_dirs),
+        define_macros=[
+            ('NPY_NO_DEPRECATED_API', 'NPY_1_7_API_VERSION'),
+        ],
+        compiler_directives={'language_level': "3"} if have_cython else {},
+    )
+
+
+extensions.extend(
+    [
+        cython_extension("wrapper"),
+        cython_extension("formathandler"),
+        cython_extension("arraydatatype"),
+        cython_extension("errorchecker"),
+        cython_extension("vbo"),
+        cython_extension("nones_formathandler"),
+        cython_extension("latebind"),
+    ]
+)
+if sys.version_info[:2] >= (2, 7):
+    extensions.extend(
+        [
+            cython_extension("buffers_formathandler"),
+        ]
+    )
+
+try:
+    import numpy
+except ImportError:
+    sys.stderr.write("""Unable to import numpy, skipping numpy extension building\n""")
+else:
+    if hasattr(numpy, "get_include"):
+        includeDirectories = [
+            numpy.get_include(),
+        ]
+    else:
+        includeDirectories = [
+            os.path.join(
+                os.path.dirname(numpy.__file__),
+                "core",
+                "include",
+            ),
+        ]
+    extensions.append(
+        cython_extension(
+            "numpy_formathandler",
+            includeDirectories,
+        )
+    )
+
+if (  # Prevents running of setup during code introspection imports
+    __name__ == "__main__"
+):
+    # Workaround for Broken apple Python build params echoed in distutils
+    # Approach taken from the PyMongo driver. OS-X Python builds were created with
+    # non-existent flag, and distutils passes those flags to the extension
+    # build, newer clangs now treat those flags as errors rather than warnings.
+    import platform, sys
+
+    if sys.platform == "darwin" and "clang" in platform.python_compiler().lower():
+        from distutils.sysconfig import get_config_vars
+
+        res = get_config_vars()
+        for key in ("CFLAGS", "PY_CFLAGS"):
+            if key in res:
+                res[key] = res[key].replace("-mno-fused-madd", "")
+
+    extraArguments = {}
+    ### Now the actual set up call
+    if have_cython:
+        extraArguments["cmdclass"] = {
+            "build_ext": build_ext,
+        }
+    setup(
+        build_requires=['cython'],
+        install_requires=[pyopengl_requirement()],
+        options={
+            "sdist": {
+                "formats": ["gztar"],
+                "force_manifest": True,
+            },
+        },
+        ext_modules=extensions,
+        **extraArguments
+    )

{pyopengl_accelerate-3.1.10 → pyopengl_accelerate-4.0.0a4}/src/arraydatatype.pyx

@@ -292,7 +292,99 @@ cdef class Output(cArgConverter):
     cdef object c_call( self, tuple pyArgs, int index, object baseOperation ):
         """Return pyArgs[ self.index ]"""
         return self.arrayType.c_zeros( self.c_getSize(pyArgs), self.arrayType.typeConstant )
-    
+
+    cdef object c_orInput( self, tuple pyArgs, int index ):
+        """Coerce a passed-in output array, refusing a lossy copy.
+
+        When the caller's array is already an acceptable buffer, asArray returns
+        it unchanged and the GL result is written straight back into it. When it
+        is the wrong type, asArray must *copy* it to match; if that copy is
+        smaller than the caller's buffer, the read is truncated into the copy and
+        never reaches the caller's array -- the silent "returns zeroes" bug.
+        Detect the shrinking copy and raise. Correctly-typed arrays are not
+        copied, so they never trip this.
+
+        Then the other question, which the count answers: an array shorter than
+        the call will write into is a heap overrun rather than an exception, so
+        it is refused. See ``Output.checkOutputSize`` in OpenGL/converters.py,
+        which is the same check for the pure-Python converter -- this one is
+        what runs where accelerate is installed, whichever dispatch layer the
+        entry points come from.
+        """
+        value = pyArgs[index]
+        result = self.arrayType.asArray( value )
+        if result is not value:
+            try:
+                rbytes = self.arrayType.arrayByteCount( result )
+                vbytes = self.arrayType.arrayByteCount( value )
+            except Exception:
+                # Not measurable -- a list has no byte count of its own -- so
+                # there is no shrinking coercion to detect. The size the call
+                # will write is still checked below.
+                rbytes = vbytes = 0
+            if rbytes < vbytes:
+                raise TypeError(
+                    '%s: pass-in output array was coerced to a smaller buffer '
+                    '(%d < %d bytes), so the GL result cannot be written back '
+                    'into your array. Pass a correctly-typed array, or None to '
+                    'have one allocated.' % ( self.name, rbytes, vbytes )
+                )
+        self.c_checkOutputSize( result, pyArgs )
+        return result
+
+    cdef int c_checkOutputSize( self, object array, tuple pyArgs ) except -1:
+        """Nothing to check: a fixed declared size is a maximum.
+
+        Which of it a call fills depends on the pname -- glGetVertexAttribiv
+        declares four and writes one for most of them -- so a shorter array is
+        legitimate here.  :class:`SizedOutput` overrides this, because its size
+        is a count the caller passed and so says what will be written.
+        """
+        return 0
+
+    cdef int c_checkPromisedSize( self, object array, tuple pyArgs ) except -1:
+        """Refuse an output array smaller than the call will write into it.
+
+        Only a shortfall: a larger array is a caller deliberately reusing one
+        buffer for several calls, which is ordinary and safe.
+        """
+        cdef long wanted = 1
+        try:
+            shape = self.c_getSize( pyArgs )
+        except Exception:
+            return 0
+        if shape is None:
+            return 0
+        for dimension in shape:
+            try:
+                wanted = wanted * int(dimension)
+            except (TypeError, ValueError):
+                return 0
+        if wanted <= 0:
+            return 0
+        # Compared in bytes, not elements.  The count is in units of the type
+        # the *declaration* names -- glGetBufferSubData's `size` is a byte
+        # count, glGenTextures' `n` is a count of GLuint -- and the caller may
+        # pass an array of some other type holding the same bytes.
+        # Only what carries its own length.  A bare ctypes pointer does not --
+        # the hand-written wrappers in OpenGL/GL/exceptional.py pass
+        # `typedPointer` results straight down -- and arrayByteCount answers
+        # for one anyway, with the size of a single element.
+        if not hasattr( array, '__len__' ):
+            return 0
+        try:
+            wanted_bytes = wanted * ctypes.sizeof( self.arrayType.baseType )
+            held_bytes = self.arrayType.arrayByteCount( array )
+        except Exception:
+            return 0
+        if held_bytes < wanted_bytes:
+            raise ValueError(
+                '%s: output array holds %d byte(s), but the call will '
+                'write %d. Pass a larger array, or None to have one '
+                'allocated.' % ( self.name, held_bytes, wanted_bytes )
+            )
+        return 0
+
     def oldStyleReturn( self, object result, object baseOperation, tuple pyArgs, tuple cArgs ):
         """Retrieve cArgs[ self.index ]"""
         #TODO: make this a c_api-bearing value, not a Python function call
@@ -313,7 +405,7 @@ cdef class OutputOrInput( Output ):
     cdef object c_call( self, tuple pyArgs, int index, object baseOperation ):
         """Return pyArgs[ self.index ]"""
         if pyArgs[index] is not DO_OUTPUT[0] and pyArgs[index] is not DO_OUTPUT[1]:
-            return self.arrayType.asArray( pyArgs[index] )
+            return self.c_orInput( pyArgs, index )
         return self.arrayType.c_zeros( self.c_getSize(pyArgs), self.arrayType.typeConstant )
 
 cdef class SizedOutput( Output ):
@@ -334,6 +426,24 @@ cdef class SizedOutput( Output ):
     def finalise( self, wrapper ):
         super( SizedOutput,self).finalise( wrapper )
         self.index = wrapper.pyArgIndex( self.specifier )
+    cdef int c_checkOutputSize( self, object array, tuple pyArgs ) except -1:
+        """Check the size only where it says what this call will write.
+
+        It does when it comes from a *count* the caller passed --
+        glGenTextures(n, names) writes n, glGetBufferSubData writes `size`
+        bytes -- which the declaration spells `size=lambda x: (x,)`.
+
+        It does not when it comes from a table keyed on a *pname*, which says
+        how large that piece of state is in total; how much of it a call fills
+        is the call's business, and glGetIntegeri_v writes one element of a
+        three-element pname at a time.  The declaration spells that
+        `size=<a dict>`, handed on as its `__getitem__` -- so the dict it is
+        bound to is what tells the two apart.
+        """
+        if isinstance( getattr( self.lookup, '__self__', None ), dict ):
+            return 0
+        return self.c_checkPromisedSize( array, pyArgs )
+
     cdef tuple c_getSize( self, tuple pyArgs ):
         """Retrieve the array size for this argument"""
         try:
@@ -353,7 +463,7 @@ cdef class SizedOutputOrInput( SizedOutput ):
     cdef object c_call( self, tuple pyArgs, int index, object baseOperation ):
         """Return pyArgs[ self.index ]"""
         if pyArgs[index] is not DO_OUTPUT[0] and pyArgs[index] is not DO_OUTPUT[1]:
-            return self.arrayType.asArray( pyArgs[index] )
+            return self.c_orInput( pyArgs, index )
         return self.arrayType.c_zeros( self.c_getSize(pyArgs), self.arrayType.typeConstant )