pyglet 2.1.dev7__tar.gz → 2.1rc1__tar.gz

{pyglet-2.1.dev7 → pyglet-2.1rc1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyglet
-Version: 2.1.dev7
+Version: 2.1rc1
 Summary: pyglet is a cross-platform games and multimedia package.
 Author-email: Alex Holkner & contributors <Alex.Holkner@gmail.com>
 Requires-Python: >=3.8

{pyglet-2.1.dev7 → pyglet-2.1rc1}/doc/index.rst

@@ -50,10 +50,11 @@ If you are migrating from an older version of pyglet, please read through
    programming_guide/keyboard
    programming_guide/mouse
    programming_guide/input
-   programming_guide/shapes
    programming_guide/image
-   programming_guide/media
    programming_guide/text
+   programming_guide/media
+   programming_guide/shapes
+   programming_guide/models
    programming_guide/resources
    programming_guide/rendering
    programming_guide/events

pyglet-2.1rc1/doc/modules/models.rst

@@ -0,0 +1,6 @@
+pyglet.model
+============
+
+.. automodule:: pyglet.model
+  :members:
+  :undoc-members:

{pyglet-2.1.dev7 → pyglet-2.1rc1}/doc/programming_guide/migration.rst

@@ -12,7 +12,10 @@ are having an issue that is not covered here, please open up an issue ticket on
 
 Window "HiDPI" support
 ----------------------
-TBD
+The v2.1 release now provides a lot more control over how modern 'HiDPI' displays
+are treated. This includes "retina" displays, or any display that has a non-0% zoom
+or scale (such as 4K displays). This is exposed as new pyglet options. See
+``pyglet.options.dpi_scaling`` for more information.
 
 Labels & Text Layouts
 ---------------------
@@ -84,7 +87,7 @@ as booleans for a quick workaround when migrating, you can do something like thi
 
 
 Vectors can also be useful for analog sticks, because it gives an easy way to
-calculate dead-zones using `.length()`. For example::
+calculate dead-zones using ``.length()``. For example::
 
     @controller.event
     def on_stick_motion(controller, name, vector):
@@ -102,8 +105,8 @@ that the maximum value stays within range. For example::
 
             vector = min(vector, vector.normalize())
 
-You can also of course directly access the individual `Vec2.x` & `Vec2.y`
-attributes. See :py:class:`~pyglet.math.Vec2` for more details on vector types.
+You can also of course directly access the individual ``Vec2.x`` & ``Vec2.y`` attributes,
+if you want to . See :py:class:`~pyglet.math.Vec2` for more details on vector types.
 
 Gui
 ---
@@ -116,8 +119,8 @@ The :py:class:`~pyglet.gui.widget.ToggleButton` and :py:class:`~pyglet.gui.widge
 widgets have a small change. Instead of the image arguments being named "pressed"
 and "depressed", they has been renamed to the correct "pressed" and "unpressed".
 
-Math module
------------
+Math
+----
 In the :py:mod:`~pyglet.math` module, vector types (:py:class:`~pyglet.math.Vec2`,
 :py:class:`~pyglet.math.Vec3`, :py:class:`~pyglet.math.Vec4`) are now
 immutable; all operations will return a new object. In addition, all vector objects
@@ -139,12 +142,23 @@ way as vectors). For example:
 Matrix objects are generally created via their helper methods, so this change should
 hopefully not require any code updates for most users.
 
+Models
+------
+The :py:mod:`~pyglet.model` module has seen some changes. This is an undocumented
+WIP module for pyglet 2.0, and it remains so pyglet 2.1. That said, it's in a more
+usable state now. The first change is that :py:meth:`~pyglet.model.load` now returns
+a ``Scene`` object instead of a ``Model`` object. The Scene is a new, "pure data"
+intermediate representation of a 3D scene, that closely mimics the layout of the glTF
+format. The :py:meth:`~pyglet.model.Scene.create_models` method can be used to create
+``Model`` instances from the Scene, but the Scene data can also be manually iterated
+over for more advanced use cases.
+
 Canvas module
 -------------
-The `pyglet.canvas` module has been renamed to `pyglet.display`. The "canvas"
+The ``pyglet.canvas`` module has been renamed to ``pyglet.display``. The "canvas"
 concept was a work-in-progress in legacy pyglet, and was never fully fleshed out.
 It appears to have been meant to allow arbitrary renderable areas, but this type
-of functionality can now be easily accomplished with Framebuffers. The name `display`
+of functionality can now be easily accomplished with Framebuffers. The name ``display``
 is a more accurate representation of what the code in the module actually relates to.
 The usage is the same, with just the name change::
 

pyglet-2.1rc1/doc/programming_guide/models.rst

@@ -0,0 +1,10 @@
+.. _guide_models:
+
+3D Models and Scenes
+====================
+
+The :py:mod:`~pyglet.model` module is still a work in progress, and is
+not yet documented.
+
+TBD
+---

{pyglet-2.1.dev7 → pyglet-2.1rc1}/examples/dpi_scaled_window.py

@@ -71,10 +71,25 @@ def on_resize(width, height):
     hello_label.position = (window.width // 2, window.height // 2, 0)
 
 
+screens = pyglet.display.get_display().get_screens()
+selected_screen = screens[0]
+
 @window.event
 def on_key_press(symbol, modifiers):
+    global selected_screen
+    if len(screens) > 1:
+        if symbol == pyglet.window.key._1:
+            selected_screen = screens[1]
+        elif symbol == pyglet.window.key._0:
+            selected_screen = screens[0]
+    
     if symbol == pyglet.window.key.SPACE:
         window.set_size(500, 300)
+    elif symbol == pyglet.window.key.F:
+        window.set_fullscreen(False, screen=selected_screen)
+    elif symbol == pyglet.window.key.G:
+        window.set_fullscreen(True, screen=selected_screen)
+        
 
 
 @window.event

{pyglet-2.1.dev7 → pyglet-2.1rc1}/examples/model/fpscamera.py

@@ -10,17 +10,16 @@ to your needs for first person games.
 """
 
 from __future__ import annotations
+
 import weakref
-from pathlib import Path
+
 from math import radians, degrees
 
 import pyglet
-from pyglet.window import key as _key
 
 from pyglet.gl import glEnable, GL_DEPTH_TEST, GL_CULL_FACE
 from pyglet.math import Vec2, Vec3, Mat4, clamp
-
-MODULE_PATH = Path(__file__).parent
+from pyglet.window import key as _key
 
 
 class FPSCamera:
@@ -346,8 +345,8 @@ if __name__ == "__main__":
     glEnable(GL_DEPTH_TEST)
     glEnable(GL_CULL_FACE)
 
-    model_logo = pyglet.model.load(MODULE_PATH / "logo3d.obj", batch=batch)
-    model_box = pyglet.model.load(MODULE_PATH / "box.obj", batch=batch)
+    model_logo = pyglet.resource.model("logo3d.obj", batch=batch)
+    model_box = pyglet.resource.model("box.obj", batch=batch)
 
     # Camera controls the global projection & view matrixes:
     camera = FPSCamera(window, position=Vec3(0.0, 0.0, 5.0))

{pyglet-2.1.dev7 → pyglet-2.1rc1}/examples/model/model.py

@@ -44,8 +44,10 @@ if __name__ == "__main__":
     glEnable(GL_DEPTH_TEST)
     glEnable(GL_CULL_FACE)
 
-    model_logo = pyglet.resource.model("logo3d.obj", batch=batch)
-    model_box = pyglet.resource.model("box.obj", batch=batch)
+    logo_scene = pyglet.resource.scene('logo3d.obj')
+    box_scene = pyglet.resource.scene('box.obj')
+    model_logo = logo_scene.create_models(batch=batch)[0]   # only one model in this scene
+    model_box = box_scene.create_models(batch=batch)[0]     # only one model in this scene
 
     # Set the application wide view matrix (camera):
     window.view = Mat4.look_at(position=Vec3(0, 0, 5), target=Vec3(0, 0, 0), up=Vec3(0, 1, 0))

{pyglet-2.1.dev7 → pyglet-2.1rc1}/pyglet/__init__.py

@@ -15,7 +15,7 @@ if TYPE_CHECKING:
     from typing import Any, Callable, ItemsView, Sized
 
 #: The release version
-version = '2.1.dev7'
+version = '2.1.rc1'
 __version__ = version
 
 MIN_PYTHON_VERSION = 3, 8
@@ -247,7 +247,7 @@ class Options:
 
     .. versionadded:: 2.0.5"""
 
-    dpi_scaling: Literal["real", "scaled", "stretch"] = "real"
+    dpi_scaling: Literal["real", "scaled", "stretch", "platform"] = "real"
     """For 'HiDPI' displays, Window behavior can differ between operating systems. Defaults to `'real'`.
 
     The current options are an attempt to create consistent behavior across all of the operating systems.
@@ -270,6 +270,13 @@ class Options:
     rescaling and repositioning of content will be necessary, but at the cost of blurry content depending on the extent
     of the stretch. For example, 800x600 at 150% DPI will be 800x600 for `window.get_size()` and 1200x900 for
     `window.get_framebuffer_size()`.
+    
+    `'platform'`: A DPI aware window is created, however window sizing and framebuffer sizing is not interfered with
+    by Pyglet. Final sizes are dictated by the platform the window was created on. It is up to the user to make any
+    platform adjustments themselves such as sizing on a platform, mouse coordinate adjustments, or framebuffer size
+    handling. On Windows and X11, the framebuffer and the requested window size will always match in pixels 1:1. On
+    MacOS, depending on a Hi-DPI display, you may get a different sized framebuffer than the window size. This option
+    does allow `window.dpi` and `window.scale` to return their respective values.
     """
 
     shader_bind_management: bool = True

{pyglet-2.1.dev7 → pyglet-2.1rc1}/pyglet/__init__.pyi

@@ -63,7 +63,6 @@ class Options:
     com_mta: bool
     osx_alt_loop: bool
     dpi_scaling: Literal["real", "scaled", "stretch"]
-    scale_with_dpi: bool
     shader_bind_management: bool
 
     def get(self, item: str, default: Any = None) -> Any:

{pyglet-2.1.dev7 → pyglet-2.1rc1}/pyglet/experimental/jobs.py

@@ -25,16 +25,17 @@ if TYPE_CHECKING:
 
 class _Worker(Thread):
     """A worker thread to pop and run jobs."""
-    def __init__(self, workqueue: Queue, exitevent: Event, name: str) -> None:
-        super().__init__(name=name, daemon=True)
-        self.queue = workqueue
-        self.exit = exitevent
+    def __init__(self, workqueue: Queue, exitevent: Event, index: int) -> None:
+        super().__init__(daemon=True)
+        self._queue = workqueue
+        self._exit = exitevent
+        self._index = index
         self.start()
 
     def run(self) -> None:
         """Parallel thread of execution."""
-        _exit = self.exit
-        _queue = self.queue
+        _exit = self._exit
+        _queue = self._queue
         while not _exit.is_set():
             func, args = _queue.get()
             func(*args)
@@ -51,8 +52,9 @@ class JobExecutor:
     `concurrent.futures` module, but does not share any code with those classes.
     Instead, it is a more light-weight implementation intended for execution of
     highly parallizable functions (jobs). A key difference is that JobExecutor
-    does not return `Futures`, and instead depends on the submitted jobs to
-    self-contained.
+    does not return `Futures`. Submitted jobs must be self-contained, or handle
+    returning values by other mechanisms. The :py:meth:`~sync` method can be
+    used to wait for all currently submitted jobs to complete.
     """
 
     def __init__(self, max_workers: int | None = None) -> None:
@@ -65,7 +67,7 @@ class JobExecutor:
         self._max_workers = max_workers or os.cpu_count() // 2
         self._exitevent = Event()
         self._queue = Queue()
-        self._threads = [_Worker(self._queue, self._exitevent, f"Thread{i+1}") for i in range(self._max_workers)]
+        self._threads = [_Worker(self._queue, self._exitevent, i) for i in range(self._max_workers)]
 
     def submit(self, func: Callable, *args: Any) -> None:
         """Submit a job to be executed on .

{pyglet-2.1.dev7 → pyglet-2.1rc1}/pyglet/gl/base.py

@@ -12,7 +12,7 @@ from pyglet.gl import gl_info
 
 if TYPE_CHECKING:
     from _ctypes import Array
-    from pyglet.display import Canvas
+    from pyglet.display.base import Canvas
     from pyglet.gl.gl_info import GLInfo
     from pyglet.graphics.shader import ShaderProgram
 
@@ -142,7 +142,7 @@ class Config:
         """
         msg = (
             'This config cannot be used to create contexts. '
-            'Use Config.match to created a CanvasConfig'
+            'Use Config.match to created a DisplayConfig'
         )
         raise gl.ConfigException(msg)
 
@@ -154,7 +154,7 @@ class Config:
         For example, `pyglet.window.Screen.get_matching_configs` returns
         complete configs.
 
-        :deprecated: Use ``isinstance(config, CanvasConfig)``.
+        :deprecated: Use ``isinstance(config, DisplayConfig)``.
         """
         return isinstance(self, DisplayConfig)
 
@@ -162,7 +162,7 @@ class Config:
         return f"{self.__class__.__name__}({self.get_gl_attributes()})"
 
 
-class DisplayConfig(Config):
+class DisplayConfig(Config, abc.ABC):
     """An OpenGL configuration for a particular display.
 
     Use ``Config.match`` to obtain an instance of this class.
@@ -214,20 +214,20 @@ class ObjectSpace:
 class Context:
     """A base OpenGL context for drawing.
 
-    Use ``CanvasConfig.create_context`` to create a context.
+    Use ``DisplayConfig.create_context`` to create a context.
     """
     #: gl_info.GLInfo instance, filled in on first set_current
     _info: GLInfo | None = None
 
     #: A container which is shared between all contexts that share GL objects.
     object_space: ObjectSpace
-    config: CanvasConfig
+    config: DisplayConfig
     context_share: Context | None
 
-    def __init__(self, config: CanvasConfig, context_share: Context | None = None) -> None:
+    def __init__(self, config: DisplayConfig, context_share: Context | None = None) -> None:
         """Initialize a context.
 
-        This should only be created through the ``CanvasConfig.create_context`` method.
+        This should only be created through the ``DisplayConfig.create_context`` method.
 
         Args:
             config:

{pyglet-2.1.dev7 → pyglet-2.1rc1}/pyglet/gl/headless.py

@@ -53,8 +53,7 @@ class HeadlessConfig(Config):  # noqa: D101
         egl.eglChooseConfig(display_connection, attrs_list, configs,
                             num_config.value, byref(num_config))
 
-        result = [HeadlessDisplayConfig(canvas, c, self) for c in configs]
-        return result
+        return [HeadlessDisplayConfig(canvas, c, self) for c in configs]
 
 
 class HeadlessDisplayConfig(DisplayConfig):  # noqa: D101
@@ -92,6 +91,9 @@ class HeadlessDisplayConfig(DisplayConfig):  # noqa: D101
         for name, value in _fake_gl_attributes.items():
             setattr(self, name, value)
 
+    def compatible(self, canvas: HeadlessCanvas) -> bool:
+        return isinstance(canvas, HeadlessCanvas)
+
     def create_context(self, share: HeadlessContext | None) -> HeadlessContext:
         return HeadlessContext(self, share)
 

{pyglet-2.1.dev7 → pyglet-2.1rc1}/pyglet/graphics/shader.py

@@ -1425,8 +1425,7 @@ class ShaderProgram:
         # Create vertex list and initialize
         if indexed:
             vlist = domain.create(count, len(indices))
-            start = vlist.start
-            vlist.indices = [i + start for i in indices]
+            vlist.indices = indices
         else:
             vlist = domain.create(count)
 

{pyglet-2.1.dev7 → pyglet-2.1rc1}/pyglet/graphics/vertexdomain.py

@@ -329,11 +329,15 @@ class IndexedVertexList(VertexList):
     @property
     def indices(self) -> list[int]:
         """Array of index data."""
-        return self.domain.index_buffer.get_region(self.index_start, self.index_count)
+        start = self.start
+        return [i - start for i in self.domain.index_buffer.get_region(self.index_start, self.index_count)]
 
     @indices.setter
     def indices(self, data: Sequence[int]) -> None:
-        self.domain.index_buffer.set_region(self.index_start, self.index_count, data)
+        start = self.start
+        # The vertex data is offset in the buffer, so offset the index values to match. Ex:
+        # vertex_buffer: [_, _, _, _, 1, 2, 3, 4]
+        self.domain.index_buffer.set_region(self.index_start, self.index_count, tuple(i + start for i in data))
 
 
 class VertexInstance:

{pyglet-2.1.dev7 → pyglet-2.1rc1}/pyglet/model/__init__.py

@@ -1,41 +1,20 @@
-"""Loading of 3D models.
+"""Loading of 3D scenes and models.
 
-A :py:class:`~pyglet.model.Model` is an instance of a 3D object.
+The :py:mod:`~pyglet.model` module provides an interface for loading 3D "scenes"
+and models. A :py:class:`~pyglet.model.Scene` is a logical container that can
+contain the data of one or more models, and is closely based on the design
+of the glTF format.
 
-The following example loads a ``"teapot.obj"`` model::
-
-    import pyglet
-
-    window = pyglet.window.Window()
-
-    teapot = pyglet.model.load('teapot.obj')
-
-    @window.event
-    def on_draw():
-        teapot.draw()
-
-    pyglet.app.run()
-
-
-You can also load models with :py:meth:`~pyglet.resource.model`.
-See :py:mod:`~pyglet.resource` for more information.
-
-
-Efficient Drawing
-=================
-
-As with Sprites or Text, Models can be added to a
-:py:class:`~pyglet.graphics.Batch` for efficient drawing. This is
-preferred to calling their ``draw`` methods individually.  To do this,
-simply pass in a reference to the :py:class:`~pyglet.graphics.Batch`
-instance when loading the Model::
+The following example loads a ``"teapot.obj"`` file. The wavefront format
+only contains a single model (mesh)::
 
     import pyglet
 
     window = pyglet.window.Window()
     batch = pyglet.graphics.Batch()
 
-    teapot = pyglet.model.load('teapot.obj', batch=batch)
+    scene = pyglet.model.load('teapot.obj')
+    models = scene.create_models(batch=batch)
 
     @window.event
     def on_draw():
@@ -44,6 +23,8 @@ instance when loading the Model::
     pyglet.app.run()
 
 
+You can also load scenes with :py:meth:`~pyglet.resource.scene`.
+See :py:mod:`~pyglet.resource` for more information.
 """
 from __future__ import annotations
 
@@ -59,7 +40,7 @@ from .codecs import registry as _codec_registry
 from .codecs.base import Material, Scene
 
 if TYPE_CHECKING:
-    from typing import BinaryIO
+    from typing import BinaryIO, TextIO
     from pyglet.image import Texture
     from pyglet.graphics import Batch, Group
     from pyglet.graphics.shader import ShaderProgram
@@ -68,46 +49,22 @@ if TYPE_CHECKING:
     from pyglet.model.codecs import ModelDecoder
 
 
-def load(filename: str, file: BinaryIO | None = None, decoder: ModelDecoder | None = None,
-         batch: Batch | None = None, group: Group | None = None) -> Model:
-    """Load a 3D model from a file.
-
-    Args:
-        filename:
-            Used to guess the model format, and to load the file if ``file`` is
-            unspecified.
-        file:
-            An open file containing the source of model data in any supported format.
-        decoder:
-            If unspecified, all decoders that are registered for the filename
-            extension are tried. An exception is raised if no codecs are
-            registered for the file extension, or if decoding fails.
-        batch:
-            An optional Batch instance to add this model to.
-        group:
-            An optional top level Group.
-    """
-    if decoder:
-        return decoder.decode(filename, file, batch=batch, group=group)
-    else:
-        return _codec_registry.decode(filename, file, batch=batch, group=group)
-
-
-def load_scene(filename: str, file: BinaryIO | None = None, decoder: ModelDecoder | None = None) -> Scene:
+def load(filename: str, file: BinaryIO | TextIO | None = None, decoder: ModelDecoder | None = None) -> Scene:
     """Load a 3D scene from a file.
 
     Args:
         filename:
-            Used to guess the scene format, and to load the file if ``file`` is
-            unspecified.
+            Used to guess the scene format, or to load the file if ``file`` is unspecified.
         file:
             An open file containing the source of the scene data in any supported format.
         decoder:
-            If unspecified, all decoders that are registered for the filename
-            extension are tried in order. An exception is raised if no codecs are
-            registered for the file extension, or if decoding fails.
+            The specific decoder to use to load the Scene. If None, use default decoders
+            that match the filename extension.
     """
-    pass
+    if decoder:
+        return decoder.decode(filename, file)
+
+    return _codec_registry.decode(filename, file)
 
 
 def get_default_shader() -> ShaderProgram:
@@ -203,15 +160,15 @@ class BaseMaterialGroup(graphics.Group):
 
 class TexturedMaterialGroup(BaseMaterialGroup):
     default_vert_src = """#version 330 core
-    in vec3 position;
-    in vec3 normals;
-    in vec2 tex_coords;
-    in vec4 colors;
+    in vec3 POSITION;
+    in vec3 NORMAL;
+    in vec2 TEXCOORD_0;
+    in vec4 COLOR_0;
 
-    out vec4 vertex_colors;
-    out vec3 vertex_normals;
-    out vec2 texture_coords;
-    out vec3 vertex_position;
+    out vec3 position;
+    out vec3 normal;
+    out vec2 texcoord_0;
+    out vec4 color_0;    
 
     uniform WindowBlock
     {
@@ -224,29 +181,29 @@ class TexturedMaterialGroup(BaseMaterialGroup):
     void main()
     {
         mat4 mv = window.view * model;
-        vec4 pos = mv * vec4(position, 1.0);
+        vec4 pos = mv * vec4(POSITION, 1.0);
         gl_Position = window.projection * pos;
         mat3 normal_matrix = transpose(inverse(mat3(mv)));
 
-        vertex_position = pos.xyz;
-        vertex_colors = colors;
-        texture_coords = tex_coords;
-        vertex_normals = normal_matrix * normals;
+        position = pos.xyz;
+        normal = normal_matrix * NORMAL;
+        texcoord_0 = TEXCOORD_0;
+        color_0 = COLOR_0;
     }
     """
     default_frag_src = """#version 330 core
-    in vec4 vertex_colors;
-    in vec3 vertex_normals;
-    in vec2 texture_coords;
-    in vec3 vertex_position;
+    in vec4 color_0;
+    in vec3 normal;
+    in vec2 texcoord_0;
+    in vec3 position;
     out vec4 final_colors;
 
     uniform sampler2D our_texture;
 
     void main()
     {
-        float l = dot(normalize(-vertex_position), normalize(vertex_normals));
-        vec4 tex_color = texture(our_texture, texture_coords) * vertex_colors;
+        float l = dot(normalize(-position), normalize(normal));
+        vec4 tex_color = texture(our_texture, texcoord_0) * color_0;
         // 75/25 light ambient
         final_colors = tex_color * l * 0.75 + tex_color * vec4(0.25);
     }
@@ -278,13 +235,13 @@ class TexturedMaterialGroup(BaseMaterialGroup):
 
 class MaterialGroup(BaseMaterialGroup):
     default_vert_src = """#version 330 core
-    in vec3 position;
-    in vec3 normals;
-    in vec4 colors;
+    in vec3 POSITION;
+    in vec3 NORMAL;
+    in vec4 COLOR_0;
 
-    out vec4 vertex_colors;
-    out vec3 vertex_normals;
-    out vec3 vertex_position;
+    out vec4 color_0;
+    out vec3 normal;
+    out vec3 position;
 
     uniform WindowBlock
     {
@@ -297,26 +254,26 @@ class MaterialGroup(BaseMaterialGroup):
     void main()
     {
         mat4 mv = window.view * model;
-        vec4 pos = mv * vec4(position, 1.0);
+        vec4 pos = mv * vec4(POSITION, 1.0);
         gl_Position = window.projection * pos;
         mat3 normal_matrix = transpose(inverse(mat3(mv)));
 
-        vertex_position = pos.xyz;
-        vertex_colors = colors;
-        vertex_normals = normal_matrix * normals;
+        position = pos.xyz;
+        color_0 = COLOR_0;
+        normal = normal_matrix * NORMAL;
     }
     """
     default_frag_src = """#version 330 core
-    in vec4 vertex_colors;
-    in vec3 vertex_normals;
-    in vec3 vertex_position;
+    in vec4 color_0;
+    in vec3 normal;
+    in vec3 position;
     out vec4 final_colors;
 
     void main()
     {
-        float l = dot(normalize(-vertex_position), normalize(vertex_normals));
+        float l = dot(normalize(-position), normalize(normal));
         // 75/25 light ambient
-        final_colors = vertex_colors * l * 0.75 + vertex_colors * vec4(0.25);
+        final_colors = color_0 * l * 0.75 + color_0 * vec4(0.25);
     }
     """
 
@@ -387,9 +344,9 @@ class Cube(Model):
 
         return self._program.vertex_list_indexed(len(vertices) // 3, pyglet.gl.GL_TRIANGLES, indices,
                                                  batch=self._batch, group=self._group,
-                                                 position=('f', vertices),
-                                                 normals=('f', normals),
-                                                 colors=('f', self._color * (len(vertices) // 3)))
+                                                 POSITION=('f', vertices),
+                                                 NORMAL=('f', normals),
+                                                 COLOR_0=('f', self._color * (len(vertices) // 3)))
 
 
 class Sphere(Model):
@@ -436,9 +393,9 @@ class Sphere(Model):
 
         return self._program.vertex_list_indexed(len(vertices) // 3, pyglet.gl.GL_TRIANGLES, indices,
                                                  batch=self._batch, group=self._group,
-                                                 position=('f', vertices),
-                                                 normals=('f', normals),
-                                                 colors=('f', self._color * (len(vertices) // 3)))
+                                                 POSITION=('f', vertices),
+                                                 NORMAL=('f', normals),
+                                                 COLOR_0=('f', self._color * (len(vertices) // 3)))
 
 
 _add_default_codecs()