pyglet 2.1.13__py3-none-any.whl → 3.0.dev1__py3-none-any.whl

pyglet/graphics/api/gl/gl_info.py

@@ -0,0 +1,188 @@
+"""Information about version and extensions of current GL implementation.
+
+Usage::
+
+    if pyglet.graphics.api.have_extension('GL_NV_register_combiners'):
+        # ...
+
+"""
+from __future__ import annotations
+
+from ctypes import c_char_p, cast, c_int, c_float
+from pyglet.graphics.api.gl import gl
+from pyglet.graphics.api.gl.lib import GLException
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from pyglet.graphics.api.gl.win32.wgl_info import WGLInfo
+    from pyglet.graphics.api.gl.xlib.glx_info import GLXInfo
+
+
+class GLInfo:
+    """Information interface for a single GL context.
+
+    A default instance is created automatically when the first OpenGL context
+    is created.  You can use the module functions as a convenience for
+    this default instance's methods.
+
+    If you are using more than one context, you must call `set_active_context`
+    when the context is active for this `GLInfo` instance.
+    """
+    extensions: set[str]
+    vendor: str = ''
+    renderer: str = ''
+    version: str = '0.0'
+    major_version: int = 0
+    minor_version: int = 0
+    opengl_api: str = 'gl'
+
+    was_queried = False
+
+    platform_info: GLXInfo | WGLInfo | None
+
+    def __init__(self, platform_info: GLXInfo | WGLInfo | None) -> None:
+        """Store information for the currently active context.
+
+        Combines any information from the platform information.
+        """
+        super().__init__()
+        self.extensions = set()
+
+        # A subset of OpenGL that is platform specific. (WGL, GLX)
+        self.platform_info = platform_info
+
+    def query(self, context) -> None:
+        self.context = context
+        self.vendor = self.get_str(gl.GL_VENDOR)
+        """The vendor string. For example 'NVIDIA Corporation'"""
+
+        self.renderer = self.get_str(gl.GL_RENDERER)
+        """The graphics renderer. For example "NVIDIA GeForce RTX 2080 SUPER/PCIe/SSE2"""
+
+        self.version = self.get_str(gl.GL_VERSION)
+
+        self.MAX_ARRAY_TEXTURE_LAYERS = self.get_int(gl.GL_MAX_ARRAY_TEXTURE_LAYERS)
+        """Value indicates the maximum number of layers allowed in a texture array"""
+
+        self.MAX_TEXTURE_SIZE = self.get_int(gl.GL_MAX_TEXTURE_SIZE)
+        """The largest texture size available."""
+
+        self.MAX_COLOR_ATTACHMENTS = self.get_int(gl.GL_MAX_COLOR_ATTACHMENTS)
+        """Get the maximum allowable framebuffer color attachments."""
+
+        self.MAX_COLOR_TEXTURE_SAMPLES = self.get_int(gl.GL_MAX_COLOR_TEXTURE_SAMPLES)
+        """Maximum number of samples in a color multisample texture"""
+
+        self.MAX_TEXTURE_IMAGE_UNITS = self.get_int(gl.GL_MAX_TEXTURE_IMAGE_UNITS)
+        """Maximum number of texture units that can be used."""
+
+        self.MAX_UNIFORM_BUFFER_BINDINGS = self.get_int(gl.GL_MAX_UNIFORM_BUFFER_BINDINGS)
+
+        # NOTE: The version string requirements for gles is a lot stricter
+        #       so using this to rely on detecting the API is not too unreasonable
+        self.opengl_api = "gles" if "opengl es" in self.version.lower() else "gl"
+
+        try:
+            self.major_version = self.get_int(gl.GL_MAJOR_VERSION)
+            """Major version number of the OpenGL API supported by the current context."""
+
+            self.minor_version = self.get_int(gl.GL_MINOR_VERSION)
+            """Minor version number of the OpenGL API supported by the current context"""
+
+            num_ext = self.get_int(gl.GL_NUM_EXTENSIONS)
+            extensions = (self.get_str_index(gl.GL_EXTENSIONS, i) for i in range(num_ext))
+            self.extensions = set(extensions)
+        except GLException:
+            pass  # GL3 is likely not available
+
+        if self.platform_info:
+            self.extensions.update(set(self.platform_info.get_extensions(context)))
+
+        self.was_queried = True
+
+    def have_extension(self, extension: str) -> bool:
+        """Determine if an OpenGL extension is available.
+
+        Args:
+            extension:
+                The name of the extension to test for, including its ``GL_`` prefix.
+
+        Returns:
+            True if the extension is provided by the driver.
+        """
+        return extension in self.extensions
+
+    def get_extensions(self) -> set[str]:
+        """Get a set of available OpenGL extensions."""
+        return self.extensions
+
+    def get_version(self) -> tuple[int, int]:
+        """Get the current major and minor version of OpenGL."""
+        return self.major_version, self.minor_version
+
+    def get_version_string(self) -> str:
+        """Get the current OpenGL version string."""
+        return self.version
+
+    def have_version(self, major: int, minor: int = 0) -> bool:
+        """Determine if a version of OpenGL is supported.
+
+        Args:
+            major:
+                The major revision number (typically 1 or 2).
+            minor:
+                The minor revision number.
+
+        Returns:
+            ``True`` if the requested or a later version is supported.
+        """
+        if not self.major_version and not self.minor_version:
+            return False
+
+        return (self.major_version > major or
+                (self.major_version == major and self.minor_version >= minor) or
+                (self.major_version == major and self.minor_version == minor))
+
+    def get_renderer(self) -> str:
+        """Determine the renderer string of the OpenGL context."""
+        return self.renderer
+
+    def get_vendor(self) -> str:
+        """Determine the vendor string of the OpenGL context."""
+        return self.vendor
+
+    def get_opengl_api(self) -> str:
+        """Determine the OpenGL API version.
+
+        Usually ``gl`` or ``gles``.
+        """
+        return self.opengl_api
+
+    def get_int(self, enum: int, default: int=0) -> int | tuple[int]:
+        try:
+            value = c_int()
+            self.context.glGetIntegerv(enum, value)
+            return value.value
+        except GLException:
+            return default
+
+    def get_float(self, enum: int, default=0.0) -> float:
+        try:
+            value = c_float()
+            self.context.glGetFloatv(enum, value)
+            return value.value
+        except GLException:
+            return default
+
+    def get_str(self, enum: int) -> str:
+        try:
+            return cast(self.context.glGetString(enum), c_char_p).value.decode()
+        except GLException:
+            return "Unknown"
+
+    def get_str_index(self, enum: int, index: int) -> str:
+        try:
+            return cast(self.context.glGetStringi(enum, index), c_char_p).value.decode()
+        except GLException:
+            return "Unknown"

pyglet/graphics/api/gl/global_opengl.py

@@ -0,0 +1,226 @@
+from __future__ import annotations
+
+import sys
+import warnings
+from typing import Sequence, TYPE_CHECKING, Literal
+
+import pyglet
+from pyglet.graphics.api.base import BackendGlobalObject, SurfaceContext, UBOMatrixTransformations
+from pyglet.math import Mat4
+from pyglet.graphics.api.gl.shader import Shader, ShaderProgram
+
+if TYPE_CHECKING:
+    from pyglet.graphics.api.gl.win32.wgl import WGLFunctions
+    from pyglet.graphics.shader import ShaderType
+    from pyglet.graphics.api.gl import OpenGLWindowConfig, ObjectSpace, OpenGLSurfaceContext
+    from pyglet.window import Window
+
+_is_pyglet_doc_run = hasattr(sys, "is_pyglet_doc_run") and sys.is_pyglet_doc_run
+
+
+class OpenGL3_Matrices(UBOMatrixTransformations):
+    # Create a default ShaderProgram, so the Window instance can
+    # update the `WindowBlock` UBO shared by all default shaders.
+    _default_vertex_source = """#version 150 core
+         in vec4 position;
+
+         uniform WindowBlock
+         {
+             mat4 projection;
+             mat4 view;
+         } window;
+
+         void main()
+         {
+             gl_Position = window.projection * window.view * position;
+         }
+     """
+    _default_fragment_source = """#version 150 core
+         out vec4 color;
+
+         void main()
+         {
+             color = vec4(1.0, 0.0, 0.0, 1.0);
+         }
+     """
+
+    def __init__(self, window: Window, backend: OpenGLBackend):
+
+        self._default_program = backend.create_shader_program(
+            backend.create_shader(self._default_vertex_source, 'vertex'),
+            backend.create_shader(self._default_fragment_source, 'fragment'))
+
+        window_block = self._default_program.uniform_blocks['WindowBlock']
+        self.ubo = window_block.create_ubo()
+        window_block.bind(self.ubo)
+
+        self._viewport = (0, 0, *window.get_framebuffer_size())
+
+        width, height = window.get_size()
+
+        super().__init__(window, Mat4.orthogonal_projection(0, width, 0, height, -255, 255), Mat4(), Mat4())
+
+        with self.ubo as window_block:
+            window_block.view[:] = self._view
+            window_block.projection[:] = self._projection
+            #window_block.model[:] = self._model
+
+    @property
+    def projection(self) -> Mat4:
+        return self._projection
+
+    @projection.setter
+    def projection(self, projection: Mat4):
+        with self.ubo as window_block:
+            window_block.projection[:] = projection
+
+        self._projection = projection
+
+    @property
+    def view(self) -> Mat4:
+        return self._view
+
+    @view.setter
+    def view(self, view: Mat4):
+        with self.ubo as window_block:
+            window_block.view[:] = view
+
+        self._view = view
+
+    @property
+    def model(self) -> Mat4:
+        return self._model
+
+    @model.setter
+    def model(self, model: Mat4):
+        with self.ubo as window_block:
+            window_block.model[:] = model
+
+        self._model = model
+
+class OpenGLBackend(BackendGlobalObject):
+    platform_func: WGLFunctions | None
+    gl_api: Literal["gl", "gles"]
+    current_context: OpenGLSurfaceContext | None
+    _have_context: bool = False
+
+    def __init__(self, gl_api: Literal["gl", "gles"] = "gl") -> None:
+        self.gl_api = gl_api
+        self.initialized = False
+        self.current_context = None
+
+        # When the shadow window is created, a context is made. This is used to help the "real" context to utilize
+        # its full capabilities; however, the two contexts have no relationship normally. This is used for the purpose
+        # of sharing basic information between contexts. However, in usage, the user or internals should use the
+        # "real" context's information to prevent any discrepencies.
+        self.platform_func = None
+        self.platform_exts = []
+        super().__init__()
+
+    @property
+    def object_space(self) -> ObjectSpace:
+        assert self.current_context is not None, "Context has not been created."
+        return self.current_context.object_space
+
+    def create_context(self, config: OpenGLWindowConfig, shared: OpenGLSurfaceContext | None) -> OpenGLSurfaceContext:
+        return config.create_context(self, shared)
+
+    def get_surface_context(self, window: Window, config: OpenGLWindowConfig) -> SurfaceContext:
+        context = self.windows[window] = self.create_context(config, shared=self.current_context)
+        self._have_context = True
+        return context
+
+    def get_default_configs(self) -> Sequence[pyglet.config.OpenGLConfig]:
+        """A sequence of configs to use if the user does not specify any.
+
+        These will be used during Window creation.
+        """
+        # On Windows if you specify GLES but set 3.3 as major/minor version, it will upgrade to a full context.
+        # Version 3.2 needs to be specified explicitly.
+        if self.gl_api == "gles":
+            configs = [
+                pyglet.config.OpenGLConfig(double_buffer=True, depth_size=24, major_version=3, minor_version=2,
+                                                    opengl_api=self.gl_api),
+                pyglet.config.OpenGLConfig(double_buffer=True, depth_size=16, major_version=3, minor_version=2,
+                                                    opengl_api=self.gl_api),
+            ]
+        else:
+            configs = [
+                pyglet.config.OpenGLConfig(double_buffer=True, depth_size=24, major_version=3, minor_version=3),
+                pyglet.config.OpenGLConfig(double_buffer=True, depth_size=16, major_version=3, minor_version=3),
+            ]
+
+        return configs
+
+    def get_config(self, **kwargs: float | str | None) -> pyglet.config.OpenGLConfig:
+        return pyglet.config.OpenGLConfig(**kwargs)
+
+    def get_info(self):
+        return self.current_context.get_info()
+
+    def have_extension(self, extension_name: str) -> bool:
+        if not self.current_context:
+            warnings.warn('No GL context created yet or current context not set.')
+            return False
+
+        return self.current_context.get_info().have_extension(extension_name)
+
+    def have_version(self, major: int, minor: int = 0) -> bool:
+        if not self.current_context:
+            warnings.warn('No GL context created yet or current context not set.')
+            return False
+
+        return self.current_context.get_info().have_version(major, minor)
+
+    def get_cached_shader(self, name: str, *sources: tuple[str, ShaderType]) -> ShaderProgram:
+        """Create a ShaderProgram from OpenGL GLSL source.
+
+        This is a convenience method that takes one or more tuples of
+        (source_string, shader_type), and returns a
+        :py:class:`~pyglet.graphics.ShaderProgram` instance.
+
+        ``source_string`` is OpenGL GLSL source code as a str, and ``shader_type``
+        is the OpenGL shader type, such as "vertex" or "fragment". See
+        :py:class:`~pyglet.graphics.Shader` for more information.
+
+        .. note:: This method is cached. Given the same shader sources, the
+                  same ShaderProgram instance will be returned. For more
+                  control over the ShaderProgram lifecycle, it is recommended
+                  to manually create Shaders and link ShaderPrograms.
+
+        .. versionadded:: 2.0.10
+        """
+        assert self.current_context
+        assert isinstance(name, str), "First argument must be a string name for the shader."
+        if program := self.current_context.cached_programs.get(name):
+            return program
+
+        shaders = (Shader(src, srctype) for (src, srctype) in sources)
+        program = ShaderProgram(*shaders)
+        self.current_context.cached_programs[name] = program
+        return program
+
+    def create_shader_program(self, *shaders: Shader) -> ShaderProgram:
+        return ShaderProgram(*shaders)
+
+    def create_shader(self, source_string: str, shader_type: ShaderType) -> Shader:
+        return Shader(source_string, shader_type)
+
+    def get_default_batch(self) -> pyglet.graphics.Batch:
+        assert self.current_context
+        if not hasattr(self.current_context, "default_batch"):
+            self.current_context.default_batch = pyglet.graphics.Batch()
+
+        return self.current_context.default_batch
+
+    @property
+    def have_context(self) -> bool:
+        return self._have_context
+
+    def initialize_matrices(self, window):
+        return OpenGL3_Matrices(window, self)
+
+    def set_viewport(self, window, x: int, y: int, width: int, height: int) -> None:
+        self.current_context.glViewport(x, y, width, height)
+
+

pyglet/{gl → graphics/api/gl}/lib.py

@@ -5,12 +5,10 @@ from typing import Any, Callable, NoReturn, Sequence
 
 import pyglet
 
-__all__ = ['link_GL', 'link_AGL', 'link_GLX', 'link_WGL',
-           'GLException', 'missing_function', 'decorate_function']
 
-_debug_gl = pyglet.options['debug_gl']
-_debug_gl_trace = pyglet.options['debug_gl_trace']
-_debug_gl_trace_args = pyglet.options['debug_gl_trace_args']
+_debug_api = pyglet.options.debug_api
+_debug_api_trace = pyglet.options.debug_api_trace
+_debug_api_trace_args = pyglet.options.debug_api_trace_args
 
 
 class MissingFunctionException(Exception):  # noqa: N818
@@ -23,7 +21,7 @@ class MissingFunctionException(Exception):  # noqa: N818
         Exception.__init__(self, msg)
 
 
-def missing_function(name: str, requires: str | None =None, suggestions: Sequence[str] | None=None) -> Callable:  # noqa: D103
+def missing_function(name: str, requires: str | None =None, suggestions: Sequence[str] | None=None) -> Callable:
     def MissingFunction(*_args, **_kwargs) -> NoReturn:  # noqa: ANN002, ANN003, N802
         raise MissingFunctionException(name, requires, suggestions)
 
@@ -53,21 +51,22 @@ class GLException(Exception):
 
 
 def errcheck(result: Any, func: Callable, arguments: Sequence) -> Any:
-    if _debug_gl_trace:
+    if _debug_api_trace:
         try:
             name = func.__name__
         except AttributeError:
             name = repr(func)
-        if _debug_gl_trace_args:
-            trace_args = ', '.join([repr(arg)[:20] for arg in arguments])
-            print(f'{name}({trace_args})')
+        if _debug_api_trace_args:
+            trace_args = ', '.join([repr(arg) for arg in arguments])
+            print(f'{name}({trace_args[:255]})')
         else:
             print(name)
 
-    from pyglet import gl
-    if not gl.current_context:
+    from pyglet.graphics.api import core, gl
+    ctx = core.current_context
+    if not ctx:
         raise GLException('No GL context; create a Window first')
-    error = gl.glGetError()
+    error = ctx.glGetError()
     if error:
         # These are the 6 possible error codes we can get in opengl core 3.3+
         error_types = {
@@ -84,8 +83,8 @@ def errcheck(result: Any, func: Callable, arguments: Sequence) -> Any:
     return result
 
 
-def decorate_function(func: Callable, name: str) -> None:  # noqa: D103
-    if _debug_gl and name not in ('glGetError',) and name[:3] not in ('glX', 'agl', 'wgl'):
+def decorate_function(func: Callable, name: str) -> None:
+    if _debug_api and name not in ('glGetError',) and name[:3] not in ('glX', 'agl', 'wgl'):
         func.errcheck = errcheck
         func.__name__ = name
 
@@ -93,10 +92,27 @@ def decorate_function(func: Callable, name: str) -> None:  # noqa: D103
 link_AGL = None
 link_GLX = None
 link_WGL = None
+link_WGL_proxy = None
+link_GL_proxy = None
 
 if pyglet.compat_platform in ('win32', 'cygwin'):
-    from pyglet.gl.lib_wgl import link_GL, link_WGL
+    from pyglet.libs.win32.lib_wgl import link_GL, link_GL_proxy, link_WGL
 elif pyglet.compat_platform == 'darwin':
-    from pyglet.gl.lib_agl import link_AGL, link_GL
+    from pyglet.libs.darwin.lib_agl import link_GL, link_GL_proxy, link_AGL
+elif pyglet.compat_platform.startswith('linux'):
+    from pyglet.libs.linux.glx.lib_glx import link_GL, link_GL_proxy, link_GLX  # noqa: F401
 else:
-    from pyglet.gl.lib_glx import link_GL, link_GLX
+    raise Exception("Platform not available.")
+
+
+__all__ = [
+    'GLException',
+    'MissingFunctionException',
+    'decorate_function',
+    'link_AGL',
+    'link_GL',
+    'link_GLX',
+    'link_WGL',
+    'link_WGL_proxy',
+    'missing_function',
+]