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

pyglet/model/__init__.py

@@ -32,7 +32,7 @@ from math import pi, sin, cos
 from typing import TYPE_CHECKING
 
 import pyglet
-from pyglet import gl, graphics
+from pyglet import graphics
 from pyglet.math import Mat4
 
 from .codecs import add_default_codecs as _add_default_codecs
@@ -41,11 +41,10 @@ from .codecs.base import Material, Scene, SimpleMaterial
 
 if TYPE_CHECKING:
     from typing import BinaryIO, TextIO
-    from pyglet.image import Texture
+    from pyglet.graphics import Texture
     from pyglet.graphics import Batch, Group
-    from pyglet.graphics.shader import ShaderProgram
+    from pyglet.graphics import ShaderProgram
     from pyglet.graphics.vertexdomain import VertexList
-    from pyglet.image import Texture
     from pyglet.model.codecs import ModelDecoder
 
 
@@ -68,13 +67,19 @@ def load(filename: str, file: BinaryIO | TextIO | None = None, decoder: ModelDec
 
 
 def get_default_shader() -> ShaderProgram:
-    return pyglet.gl.current_context.create_program((MaterialGroup.default_vert_src, 'vertex'),
-                                                    (MaterialGroup.default_frag_src, 'fragment'))
+    return pyglet.graphics.api.get_cached_shader(
+        "default_model_material",
+        (MaterialGroup.default_vert_src, 'vertex'),
+        (MaterialGroup.default_frag_src, 'fragment'),
+    )
 
 
 def get_default_textured_shader() -> ShaderProgram:
-    return pyglet.gl.current_context.create_program((TexturedMaterialGroup.default_vert_src, 'vertex'),
-                                                    (TexturedMaterialGroup.default_frag_src, 'fragment'))
+    return pyglet.graphics.api.get_cached_shader(
+        "default_model_textured_material",
+        (TexturedMaterialGroup.default_vert_src, 'vertex'),
+        (TexturedMaterialGroup.default_frag_src, 'fragment'),
+    )
 
 
 class Model:
@@ -123,7 +128,7 @@ class Model:
             batch = graphics.Batch()
 
         for group, vlist in zip(self.groups, self.vertex_lists):
-            self._batch.migrate(vlist, gl.GL_TRIANGLES, group, batch)
+            self._batch.migrate(vlist, graphics.GeometryMode.TRIANGLES, group, batch)
 
         self._batch = batch
 
@@ -204,24 +209,29 @@ class TexturedMaterialGroup(BaseMaterialGroup):
                  texture: Texture, order: int = 0, parent: Group | None = None):
         super().__init__(material, program, order, parent)
         self.texture = texture
-
-    def set_state(self) -> None:
-        gl.glActiveTexture(gl.GL_TEXTURE0)
-        gl.glBindTexture(self.texture.target, self.texture.id)
-        self.program.use()
-        self.program['model'] = self.matrix
-
-    def __hash__(self) -> int:
-        return hash((self.texture.target, self.texture.id, self.program, self.order, self.parent))
-
-    def __eq__(self, other) -> bool:
-        return (self.__class__ is other.__class__ and
-                self.material == other.material and
-                self.texture.target == other.texture.target and
-                self.texture.id == other.texture.id and
-                self.program == other.program and
-                self.order == other.order and
-                self.parent == other.parent)
+        self.set_texture(self.texture)
+        self.set_shader_program(program)
+        self.uniforms = {"model": self.matrix}
+        self.set_shader_uniforms(program, self.uniforms)
+    #
+    # def set_state(self) -> None:
+    #     # gl.glActiveTexture(gl.GL_TEXTURE0)
+    #     # gl.glBindTexture(self.texture.target, self.texture.id)
+    #     # self.program.use()
+    #     # self.program['model'] = self.matrix
+    #     pass
+    #
+    # def __hash__(self) -> int:
+    #     return hash((self.texture.target, self.texture.id, self.program, self.order, self.parent))
+    #
+    # def __eq__(self, other) -> bool:
+    #     return (self.__class__ is other.__class__ and
+    #             self.material == other.material and
+    #             self.texture.target == other.texture.target and
+    #             self.texture.id == other.texture.id and
+    #             self.program == other.program and
+    #             self.order == other.order and
+    #             self.parent == other.parent)
 
 
 class MaterialGroup(BaseMaterialGroup):
@@ -354,7 +364,7 @@ class Cube(Model):
                    7, 6, 4, 6, 5, 4,        # back
                    3, 2, 0, 2, 1, 0]        # front
 
-        return self._program.vertex_list_indexed(len(vertices) // 3, pyglet.gl.GL_TRIANGLES, indices,
+        return self._program.vertex_list_indexed(len(vertices) // 3, graphics.GeometryMode.TRIANGLES, indices,
                                                  batch=self._batch, group=self._group,
                                                  POSITION=('f', vertices),
                                                  NORMAL=('f', normals),
@@ -412,7 +422,7 @@ class Sphere(Model):
                 indices.extend([first, second, second + 1])
                 indices.extend([first, second + 1, first + 1])
 
-        return self._program.vertex_list_indexed(len(vertices) // 3, pyglet.gl.GL_TRIANGLES, indices,
+        return self._program.vertex_list_indexed(len(vertices) // 3, graphics.GeometryMode.TRIANGLES, indices,
                                                  batch=self._batch, group=self._group,
                                                  POSITION=('f', vertices),
                                                  NORMAL=('f', normals),

pyglet/model/codecs/base.py

@@ -1,12 +1,12 @@
 from __future__ import annotations
 
-from abc import ABC, abstractmethod
+from abc import ABC
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     from typing import Sequence
     from pyglet.model import Model
-    from pyglet.graphics import Batch, Group
+    from pyglet.graphics import Batch, Group, GeometryMode
 
 
 class Scene(ABC):
@@ -75,7 +75,7 @@ class Attribute:
 class Primitive:
     """Geometry to be rendered, with optional material."""
     def __init__(self, attributes: list[Attribute], indices: Sequence[int] | None,
-                 mode: int, material: Material | None = None) -> None:
+                 mode: GeometryMode, material: Material | None = None) -> None:
         self.attributes = attributes
         self.indices = indices
         self.mode = mode
@@ -107,7 +107,7 @@ class SimpleMaterial(Material):
         self.texture_name = texture_name
 
     def __repr__(self):
-        return f"Material(name='{self.name}', texture='{self.texture_name}'"
+        return f"Material(name='{self.name}', texture='{self.texture_name}')"
 
 
 class PBRMaterial(Material):

pyglet/model/codecs/gltf.py

@@ -8,9 +8,9 @@ from urllib.request import urlopen
 
 import pyglet
 
-from pyglet.gl import GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT, GL_UNSIGNED_SHORT, GL_FLOAT, GL_DOUBLE
-from pyglet.gl import GL_INT, GL_UNSIGNED_INT, GL_ELEMENT_ARRAY_BUFFER, GL_ARRAY_BUFFER
-from pyglet.gl import GL_REPEAT
+from pyglet.graphics.api.gl import GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT, GL_UNSIGNED_SHORT, GL_FLOAT, GL_DOUBLE
+from pyglet.graphics.api.gl import GL_INT, GL_UNSIGNED_INT, GL_ELEMENT_ARRAY_BUFFER, GL_ARRAY_BUFFER
+from pyglet.graphics.api.gl import GL_REPEAT
 
 from . import ModelDecodeException, ModelDecoder
 from .base import Scene

pyglet/model/codecs/obj.py

@@ -4,27 +4,29 @@ import os
 
 import pyglet
 
-from pyglet.gl import GL_TRIANGLES
 from pyglet.util import asstr
 
 from . import ModelDecodeException, ModelDecoder
 from .base import SimpleMaterial, Mesh, Primitive, Attribute, Node, Scene
-from .. import Model, MaterialGroup, TexturedMaterialGroup
-from ...graphics import Batch, Group
+from pyglet.model import Model, MaterialGroup, TexturedMaterialGroup
+from pyglet.graphics import Batch, Group, GeometryMode
 
 
 def _new_mesh(name, material):
     # The three primitive types used in .obj files:
-    attributes = [Attribute('POSITION', 'f', 'VEC3', 0, []),
-                  Attribute('NORMAL', 'f', 'VEC3', 0, []),
-                  Attribute('TEXCOORD_0', 'f', 'VEC3', 0, [])]
-    primitive = Primitive(attributes=attributes, indices=None, material=material, mode=GL_TRIANGLES)
+    attributes = [
+        Attribute('POSITION', 'f', 'VEC3', 0, []),
+        Attribute('NORMAL', 'f', 'VEC3', 0, []),
+        Attribute('TEXCOORD_0', 'f', 'VEC3', 0, []),
+    ]
+
+    primitive = Primitive(attributes=attributes, indices=None, material=material, mode=GeometryMode.TRIANGLES)
     mesh = Mesh(primitives=[primitive], name=name)
     return mesh
 
 
 def load_material_library(filename):
-    file = open(filename, 'r')
+    file = open(filename)
 
     name = None
     diffuse = [1.0, 1.0, 1.0]
@@ -73,7 +75,7 @@ def load_material_library(filename):
                 texture_name = values[1]
 
         except BaseException as ex:
-            raise ModelDecodeException('Parsing error in {0}.'.format((filename, ex)))
+            raise ModelDecodeException(f'Parsing error in {(filename, ex)}.')
 
     file.close()
 
@@ -93,7 +95,7 @@ def parse_obj_file(filename, file=None) -> list[Mesh]:
 
     try:
         if file is None:
-            with open(filename, 'r') as f:
+            with open(filename) as f:
                 file_contents = f.read()
         else:
             file_contents = asstr(file.read())
@@ -132,7 +134,7 @@ def parse_obj_file(filename, file=None) -> list[Mesh]:
 
         elif values[0] == 'mtllib':
             material_abspath = os.path.join(location, values[1])
-            materials = load_material_library(filename=material_abspath)            
+            materials = load_material_library(filename=material_abspath)
 
         elif values[0] in ('usemtl', 'usemat'):
             material = materials.get(values[1])
@@ -140,49 +142,75 @@ def parse_obj_file(filename, file=None) -> list[Mesh]:
                 mesh.primitives[0].material = material
 
         elif values[0] == 'o':
-            mesh = _new_mesh(name=values[1], material=default_material)
+            mesh = _new_mesh(values[1], material=default_material)
             meshes.append(mesh)
 
         elif values[0] == 'f':
+            # --- FACES
+
             if material is None:
                 material = SimpleMaterial()
             if mesh is None:
                 mesh = _new_mesh(name='unknown', material=material)
                 meshes.append(mesh)
 
-            # For fan triangulation, remember first and latest vertices
-            n1 = None
-            nlast = None
-            t1 = None
-            tlast = None
-            v1 = None
-            vlast = None
-
-            for i, v in enumerate(values[1:]):
-                v_i, t_i, n_i = (list(map(int, [j or 0 for j in v.split('/')])) + [0, 0])[:3]
+            primitive = mesh.primitives[0]
+
+            pos_attr = primitive.attributes[0]
+
+            # optional normals and teture uvs
+            normal_attr = primitive.attributes[1] if len(primitive.attributes) > 1 else None
+            tex_uv_attr = primitive.attributes[2] if len(primitive.attributes) > 2 else None
+
+            face_vertices = []
+            for v in values[1:]:
+                parts = v.split('/')
+
+                # vertex index (should not be empty, raise error instead?)
+                v_i = int(parts[0]) if parts[0] else 0
+
+                # texcoord index (optional)
+                t_i = 0
+                if len(parts) >= 2 and parts[1]:
+                    t_i = int(parts[1])
+
+                # normal index (optional)
+                n_i = 0
+                if len(parts) == 3 and parts[2]:
+                    n_i = int(parts[2])
+
+                # handle negative indices
                 if v_i < 0:
-                    v_i += len(vertices) - 1
+                    v_i = len(vertices) + v_i
                 if t_i < 0:
-                    t_i += len(tex_coords) - 1
+                    t_i = len(tex_coords) + t_i
                 if n_i < 0:
-                    n_i += len(normals) - 1
-
-                mesh.primitives[0].attributes[0].array += vertices[v_i]
-                mesh.primitives[0].attributes[1].array += normals[n_i]
-                mesh.primitives[0].attributes[2].array += tex_coords[t_i]
+                    n_i = len(normals) + n_i
 
-                if i >= 3:
-                    mesh.primitives[0].attributes[0].array += v1 + vlast
-                    mesh.primitives[0].attributes[1].array += n1 + nlast
-                    mesh.primitives[0].attributes[2].array += t1 + tlast
+                face_vertices.append((v_i, t_i, n_i))
 
-                if i == 0:
-                    n1 = normals[n_i]
-                    t1 = tex_coords[t_i]
-                    v1 = vertices[v_i]
-                nlast = normals[n_i]
-                tlast = tex_coords[t_i]
-                vlast = vertices[v_i]
+            # For fan triangulation, remember first and latest vertices
+            for i in range(2, len(face_vertices)):
+                for idx in (0, i - 1, i):
+                    v_i, t_i, n_i = face_vertices[idx]
+
+                    pos_attr.array += vertices[v_i]
+
+                    # normals (optional)
+                    if normal_attr is not None:
+                        if n_i != 0:
+                            primitive.has_normals = True
+                            normal_attr.array += normals[n_i]
+                        else:
+                            normal_attr.array += [0.0, 0.0, 1.0]
+
+                    # texcoords (optional)
+                    if tex_uv_attr is not None:
+                        if t_i != 0:
+                            primitive.has_tex_coords = True
+                            tex_uv_attr.array += tex_coords[t_i]
+                        else:
+                            tex_uv_attr.array += [0.0, 0.0]
 
         for mesh in meshes:
             for primitive in mesh.primitives:
@@ -204,17 +232,17 @@ class OBJScene(Scene):
 
                 if material.texture_name:
                     program = pyglet.model.get_default_textured_shader()
-                    texture = pyglet.resource.texture(material.texture_name)
+                    texture = pyglet.resource.texture(material.texture_name, atlas=False)
                     matgroup = TexturedMaterialGroup(material, program, texture, parent=group)
                 else:
                     program = pyglet.model.get_default_shader()
                     matgroup = MaterialGroup(material, program, parent=group)
 
-                data = {a.name: (a.fmt, a.array) for a in mesh.primitives[0].attributes}
+                data = {a.name: (a.fmt, a.array) for a in mesh.primitives[0].attributes if a.name in program.attributes}
                 # Add additional material data:
                 data['COLOR_0'] = 'f', material.diffuse * count
 
-                vertex_lists.append(program.vertex_list(count, GL_TRIANGLES, batch, matgroup, **data))
+                vertex_lists.append(program.vertex_list(count, GeometryMode.TRIANGLES, batch, matgroup, **data))
                 groups.append(matgroup)
 
         return [Model(vertex_lists=vertex_lists, groups=groups, batch=batch)]