ncca-ngl 0.2.1__tar.gz → 0.2.3__tar.gz

{ncca_ngl-0.2.1 → ncca_ngl-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: ncca-ngl
-Version: 0.2.1
+Version: 0.2.3
 Summary: A Python version of the NGL graphics library.
 Author: Jon Macey
 Author-email: Jon Macey <jmacey@bournemouth.ac.uk>

{ncca_ngl-0.2.1 → ncca_ngl-0.2.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ncca-ngl"
-version = "0.2.1"
+version = "0.2.3"
 description = "A Python version of the NGL graphics library."
 authors = [{ name = "Jon Macey", email = "jmacey@bournemouth.ac.uk" }]
 requires-python = ">=3.13"

{ncca_ngl-0.2.1 → ncca_ngl-0.2.3}/src/ncca/ngl/__init__.py

@@ -6,6 +6,9 @@ try:
 except PackageNotFoundError:
     __version__ = "0.0.0"
 
+__author__ = "Jon Macey jmacey@bournemouth.ac.uk"
+__license__ = "MIT"
+
 from .abstract_vao import AbstractVAO, VertexData
 from .base_mesh import BaseMesh, Face
 from .bbox import BBox

{ncca_ngl-0.2.1 → ncca_ngl-0.2.3}/src/ncca/ngl/mat2.py

@@ -45,7 +45,7 @@ class Mat2:
         Returns:
             list[float]: A flat list of floats.
         """
-        return [item for sublist in zip(*self.m) for item in sublist]
+        return [item for sublist in zip(*self.m, strict=False) for item in sublist]
 
     def to_numpy(self):
         """
@@ -125,4 +125,14 @@ class Mat2:
     def to_list(self):
         "convert matrix to list in column-major order"
         # flatten to single array
-        return [item for sublist in zip(*self.m) for item in sublist]
+        return [item for sublist in zip(*self.m, strict=False) for item in sublist]
+
+    def copy(self) -> "Mat2":
+        """Create a copy of the matrix.
+
+        Returns:
+            A new Mat2 instance with the same values.
+        """
+        new_mat = Mat2()
+        new_mat.m = copy.deepcopy(self.m)
+        return new_mat

{ncca_ngl-0.2.1 → ncca_ngl-0.2.3}/src/ncca/ngl/mat3.py

@@ -132,7 +132,7 @@ class Mat3:
 
     def transpose(self):
         """transpose this matrix"""
-        self.m = [list(item) for item in zip(*self.m)]
+        self.m = [list(item) for item in zip(*self.m, strict=False)]
 
     def get_transpose(self):
         """return a new matrix as the transpose of ourself
@@ -143,7 +143,7 @@ class Mat3:
                 The transpose of the current matrix
         """
         m = Mat3()
-        m.m = [list(item) for item in zip(*self.m)]
+        m.m = [list(item) for item in zip(*self.m, strict=False)]
         return m
 
     @classmethod
@@ -360,7 +360,7 @@ class Mat3:
         "internal add function"
         temp = Mat3()
         for i in range(0, len(temp.m)):
-            temp.m[i] = [a + b for a, b in zip(self.m[i], rhs.m[i])]
+            temp.m[i] = [a + b for a, b in zip(self.m[i], rhs.m[i], strict=False)]
         return temp
 
     def __add__(self, rhs):
@@ -375,7 +375,7 @@ class Mat3:
         "internal subtract function"
         temp = Mat3()
         for i in range(0, len(temp.m)):
-            temp.m[i] = [a - b for a, b in zip(self.m[i], rhs.m[i])]
+            temp.m[i] = [a - b for a, b in zip(self.m[i], rhs.m[i], strict=False)]
         return temp
 
     def __sub__(self, rhs):
@@ -399,6 +399,16 @@ class Mat3:
         # flatten to single array
         return functools.reduce(operator.concat, self.m)
 
+    def copy(self) -> "Mat3":
+        """Create a copy of the matrix.
+
+        Returns:
+            A new Mat3 instance with the same values.
+        """
+        new_mat = Mat3()
+        new_mat.m = copy.deepcopy(self.m)
+        return new_mat
+
     def inverse(self):
         "Inverse of matrix raise MatrixError if not calculable"
         det = self.determinant()
@@ -406,35 +416,17 @@ class Mat3:
             invdet = 1 / det
             tmp = Mat3()
             # minor matrix + co-factor
-            tmp.m[0][0] = (
-                +(self.m[1][1] * self.m[2][2] - self.m[1][2] * self.m[2][1]) * invdet
-            )
-            tmp.m[1][0] = (
-                -(self.m[1][0] * self.m[2][2] - self.m[1][2] * self.m[2][0]) * invdet
-            )
-            tmp.m[2][0] = (
-                +(self.m[1][0] * self.m[2][1] - self.m[1][1] * self.m[2][0]) * invdet
-            )
+            tmp.m[0][0] = +(self.m[1][1] * self.m[2][2] - self.m[1][2] * self.m[2][1]) * invdet
+            tmp.m[1][0] = -(self.m[1][0] * self.m[2][2] - self.m[1][2] * self.m[2][0]) * invdet
+            tmp.m[2][0] = +(self.m[1][0] * self.m[2][1] - self.m[1][1] * self.m[2][0]) * invdet
 
-            tmp.m[0][1] = (
-                -(self.m[0][1] * self.m[2][2] - self.m[0][2] * self.m[2][1]) * invdet
-            )
-            tmp.m[1][1] = (
-                +(self.m[0][0] * self.m[2][2] - self.m[0][2] * self.m[2][0]) * invdet
-            )
-            tmp.m[2][1] = (
-                -(self.m[0][0] * self.m[2][1] - self.m[0][1] * self.m[2][0]) * invdet
-            )
+            tmp.m[0][1] = -(self.m[0][1] * self.m[2][2] - self.m[0][2] * self.m[2][1]) * invdet
+            tmp.m[1][1] = +(self.m[0][0] * self.m[2][2] - self.m[0][2] * self.m[2][0]) * invdet
+            tmp.m[2][1] = -(self.m[0][0] * self.m[2][1] - self.m[0][1] * self.m[2][0]) * invdet
 
-            tmp.m[0][2] = (
-                +(self.m[0][1] * self.m[1][2] - self.m[0][2] * self.m[1][1]) * invdet
-            )
-            tmp.m[1][2] = (
-                -(self.m[0][0] * self.m[1][2] - self.m[0][2] * self.m[1][0]) * invdet
-            )
-            tmp.m[2][2] = (
-                +(self.m[0][0] * self.m[1][1] - self.m[0][1] * self.m[1][0]) * invdet
-            )
+            tmp.m[0][2] = +(self.m[0][1] * self.m[1][2] - self.m[0][2] * self.m[1][1]) * invdet
+            tmp.m[1][2] = -(self.m[0][0] * self.m[1][2] - self.m[0][2] * self.m[1][0]) * invdet
+            tmp.m[2][2] = +(self.m[0][0] * self.m[1][1] - self.m[0][1] * self.m[1][0]) * invdet
 
             return tmp
         except ZeroDivisionError:
@@ -451,16 +443,14 @@ class Mat3:
     @classmethod
     def from_mat4(cls, mat4):
         """Create a Mat3 from a Mat4"""
-        return Mat3.from_list(
-            [
-                mat4.m[0][0],
-                mat4.m[0][1],
-                mat4.m[0][2],
-                mat4.m[1][0],
-                mat4.m[1][1],
-                mat4.m[1][2],
-                mat4.m[2][0],
-                mat4.m[2][1],
-                mat4.m[2][2],
-            ]
-        )
+        return Mat3.from_list([
+            mat4.m[0][0],
+            mat4.m[0][1],
+            mat4.m[0][2],
+            mat4.m[1][0],
+            mat4.m[1][1],
+            mat4.m[1][2],
+            mat4.m[2][0],
+            mat4.m[2][1],
+            mat4.m[2][2],
+        ])

{ncca_ngl-0.2.1 → ncca_ngl-0.2.3}/src/ncca/ngl/mat4.py

@@ -86,14 +86,24 @@ class Mat4:
         # flatten to single array
         return functools.reduce(operator.concat, self.m)
 
+    def copy(self) -> "Mat4":
+        """Create a copy of the matrix.
+
+        Returns:
+            A new Mat4 instance with the same values.
+        """
+        new_mat = Mat4()
+        new_mat.m = copy.deepcopy(self.m)
+        return new_mat
+
     def transpose(self):
         "transpose this matrix"
-        self.m = [list(item) for item in zip(*self.m)]
+        self.m = [list(item) for item in zip(*self.m, strict=False)]
 
     def get_transpose(self):
         "return a new matrix as the transpose of ourself"
         m = Mat4()
-        m.m = [list(item) for item in zip(*self.m)]
+        m.m = [list(item) for item in zip(*self.m, strict=False)]
         return m
 
     @classmethod
@@ -258,7 +268,7 @@ class Mat4:
         "internal add function"
         temp = Mat4()
         for i in range(0, len(temp.m)):
-            temp.m[i] = [a + b for a, b in zip(self.m[i], rhs.m[i])]
+            temp.m[i] = [a + b for a, b in zip(self.m[i], rhs.m[i], strict=False)]
         return temp
 
     def __add__(self, rhs):
@@ -273,7 +283,7 @@ class Mat4:
         "internal sub function"
         temp = Mat4()
         for i in range(0, len(temp.m)):
-            temp.m[i] = [a - b for a, b in zip(self.m[i], rhs.m[i])]
+            temp.m[i] = [a - b for a, b in zip(self.m[i], rhs.m[i], strict=False)]
         return temp
 
     def __sub__(self, rhs):

{ncca_ngl-0.2.1 → ncca_ngl-0.2.3}/src/ncca/ngl/prim_data.py

@@ -21,6 +21,14 @@ class Prims(enum.Enum):
     TEAPOT = "teapot"
     TETRAHEDRON = "tetrahedron"
     TROLL = "troll"
+    SPHERE = "sphere"
+    TORUS = "torus"
+    LINE_GRID = "line_grid"
+    TRIANGLE_PLANE = "triangle_plane"
+    CONE = "cone"
+    CAPSULE = "capsule"
+    CYLINDER = "cylinder"
+    DISK = "disk"
 
 
 def _circle_table(n: int) -> np.ndarray:

ncca_ngl-0.2.3/src/ncca/ngl/primitives.py

@@ -0,0 +1,121 @@
+"""
+OpenGL primitive generation and drawing functions
+In this class we can generate a pipeline for drawing our data for the most part it will be
+x,y,z nx,ny,nz and u,v data in a flat numpy array.
+We need to create the data first which is stored in a map as part of the class, we can then call draw
+which will generate a pipeline for this object and draw into the current context.
+"""
+
+from typing import Dict, Union
+
+import numpy as np
+import OpenGL.GL as gl
+
+from .log import logger
+from .prim_data import PrimData, Prims
+from .simple_vao import VertexData
+from .vao_factory import VAOFactory, VAOType  # noqa
+from .vec3 import Vec3
+
+
+class _primitive:
+    """A private class to hold VAO data for a primitive."""
+
+    def __init__(self, prim_data: np.ndarray):
+        """
+        Initializes the primitive with the given data.
+
+        Args:
+            prim_data: A numpy array containing the vertex data (x,y,z,nx,ny,nz,u,v).
+        """
+        self.vao = VAOFactory.create_vao(VAOType.SIMPLE, gl.GL_TRIANGLES)
+        with self.vao:
+            data = VertexData(data=prim_data.data, size=prim_data.size)
+            self.vao.set_data(data)
+            vert_data_size = 8 * 4  # 4 is sizeof float and 8 is x,y,z,nx,ny,nz,uv
+            self.vao.set_vertex_attribute_pointer(0, 3, gl.GL_FLOAT, vert_data_size, 0)
+            self.vao.set_vertex_attribute_pointer(1, 3, gl.GL_FLOAT, vert_data_size, Vec3.sizeof())
+            self.vao.set_vertex_attribute_pointer(2, 2, gl.GL_FLOAT, vert_data_size, 2 * Vec3.sizeof())
+            self.vao.set_num_indices(prim_data.size // 8)
+
+
+class Primitives:
+    """A static class for creating and drawing primitives."""
+
+    # this is effectively a static class so we can use it to store data
+    # and generate pipelines for drawing
+    _primitives: Dict[str, _primitive] = {}
+    _loaded: bool = False
+
+    @classmethod
+    def create(cls, type: str, name: str, *args: object, **kwargs: object) -> None:
+        """
+        Creates and stores a primitive object of the specified type from :-
+        Prims.SPHERE : (radius: float, precision: int).
+        Prims.TORUS : (radius: float, tube_radius: float, precision: int).
+        Prims.LINE_GRID : (width: float, depth: float, steps: int).
+        Prims.TRIANGLE_PLANE : ( width: float, depth: float, w_p: int, d_p: int, v_n: Vec3).
+        Prims.CYLINDER : (radius: float, height: float, slices: int, stacks: int).
+        Prims.CAPSULE : (radius: float, height: float, slices: int, stacks: int).
+        Prims.CONE : (radius: float, height: float, slices: int, stacks: int).
+
+        Args:
+            type (str): The primitive type, typically from the Prims enum (e.g., Prims.SPHERE).
+            name (str): The name to associate with the created primitive.
+            *args: Positional arguments to pass to the primitive creation function (e.g., radius, precision).
+            **kwargs: Keyword arguments to pass to the primitive creation function.
+
+        Raises:
+            ValueError: If the primitive type is not recognized.
+
+        Example:
+            Primitives.create(Prims.SPHERE, "sphere", 0.3, 32)
+            Primitives.create(Prims.SPHERE, "sphere", radius=0.3, precision=32)
+        """
+        prim_methods = {
+            Prims.SPHERE: PrimData.sphere,
+            Prims.TORUS: PrimData.torus,
+            Prims.LINE_GRID: PrimData.line_grid,
+            Prims.TRIANGLE_PLANE: PrimData.triangle_plane,
+            Prims.CYLINDER: PrimData.cylinder,
+            Prims.DISK: PrimData.disk,
+            Prims.CAPSULE: PrimData.capsule,
+            Prims.CONE: PrimData.cone,
+        }
+        try:
+            method = prim_methods[type]
+        except KeyError:
+            raise ValueError(f"Unknown primitive: {name}")
+
+        cls._primitives[name] = _primitive(method(*args, **kwargs))
+
+    @classmethod
+    def load_default_primitives(cls) -> None:
+        """Loads the default primitives from the PrimData directory."""
+        logger.info("Loading default primitives...")
+        if not cls._loaded:
+            for p in Prims:
+                try:
+                    prim_data = PrimData.primitive(p.value)
+                    prim = _primitive(prim_data)
+                    cls._primitives[p.value] = prim
+                except Exception:
+                    pass
+            cls._loaded = True
+
+    @classmethod
+    def draw(cls, name: Union[str, Prims]) -> None:
+        """
+        Draws the specified primitive.
+
+        Args:
+            name: The name of the primitive to draw, either as a string or a Prims enum.
+        """
+        key = name.value if isinstance(name, Prims) else name
+        try:
+            prim = cls._primitives[key]
+            with prim.vao:
+                prim.vao.draw()
+        except KeyError:
+            logger.error(f"Failed to draw primitive {key}")
+            return

{ncca_ngl-0.2.1 → ncca_ngl-0.2.3}/src/ncca/ngl/vec2.py

@@ -42,7 +42,7 @@ class Vec2:
         yield self.x
         yield self.y
 
-    def clone(self) -> "Vec2":
+    def copy(self) -> "Vec2":
         """
         Create a copy of the vector.
         Returns:
@@ -305,9 +305,7 @@ class Vec2:
         if isinstance(rhs, (float, int)):
             return Vec2(self.x * rhs, self.y * rhs)
         else:
-            raise ValueError(
-                f"can only do piecewise multiplication with a scalar {rhs=}"
-            )
+            raise ValueError(f"can only do piecewise multiplication with a scalar {rhs=}")
 
     def __rmul__(self, rhs):
         """
@@ -330,9 +328,8 @@ class Vec2:
             Vec2: A new vector that is the result of multiplying this vector by the matrix.
         """
         return Vec2(
-            self.x * rhs.m[0][0] + self.y * rhs.m[1][0] + self.z * rhs.m[2][0],
-            self.x * rhs.m[0][1] + self.y * rhs.m[1][1] + self.z * rhs.m[2][1],
-            self.x * rhs.m[0][2] + self.y * rhs.m[1][2] + self.z * rhs.m[2][2],
+            self.x * rhs.m[0][0] + self.y * rhs.m[1][0],
+            self.x * rhs.m[0][1] + self.y * rhs.m[1][1],
         )
 
 

{ncca_ngl-0.2.1 → ncca_ngl-0.2.3}/src/ncca/ngl/vec3.py

@@ -78,9 +78,9 @@ class Vec3:
         else:
             setattr(self, name, v)
 
-    def clone(self) -> "Vec3":
+    def copy(self) -> "Vec3":
         """
-        Create a clone of the current vector.
+        Create a copy of the current vector.
         Returns:
             Vec3: A new instance of Vec3 with the same x, y, and z values.
         """
@@ -156,11 +156,7 @@ class Vec3:
 
         if not isinstance(rhs, Vec3):
             return NotImplemented
-        return (
-            math.isclose(self.x, rhs.x)
-            and math.isclose(self.y, rhs.y)
-            and math.isclose(self.z, rhs.z)
-        )
+        return math.isclose(self.x, rhs.x) and math.isclose(self.y, rhs.y) and math.isclose(self.z, rhs.z)
 
     def __neq__(self, rhs):
         """
@@ -173,11 +169,7 @@ class Vec3:
         """
         if not isinstance(rhs, Vec3):
             return NotImplemented
-        return not (
-            math.isclose(self.x, rhs.x)
-            and math.isclose(self.y, rhs.y)
-            and math.isclose(self.z, rhs.z)
-        )
+        return not (math.isclose(self.x, rhs.x) and math.isclose(self.y, rhs.y) and math.isclose(self.z, rhs.z))
 
     def __neg__(self):
         """
@@ -290,9 +282,7 @@ class Vec3:
         """
         d = self.dot(n)
         #  I - 2.0 * dot(N, I) * N
-        return Vec3(
-            self.x - 2.0 * d * n.x, self.y - 2.0 * d * n.y, self.z - 2.0 * d * n.z
-        )
+        return Vec3(self.x - 2.0 * d * n.x, self.y - 2.0 * d * n.y, self.z - 2.0 * d * n.z)
 
     def clamp(self, low, high):
         """
@@ -324,13 +314,11 @@ class Vec3:
         """
         from .mat3 import Mat3
 
-        return Mat3.from_list(
-            [
-                [self.x * rhs.x, self.x * rhs.y, self.x * rhs.z],
-                [self.y * rhs.x, self.y * rhs.y, self.y * rhs.z],
-                [self.z * rhs.x, self.z * rhs.y, self.z * rhs.z],
-            ]
-        )
+        return Mat3.from_list([
+            [self.x * rhs.x, self.x * rhs.y, self.x * rhs.z],
+            [self.y * rhs.x, self.y * rhs.y, self.y * rhs.z],
+            [self.z * rhs.x, self.z * rhs.y, self.z * rhs.z],
+        ])
 
     def __mul__(self, rhs):
         """
@@ -345,9 +333,7 @@ class Vec3:
         if isinstance(rhs, (float, int)):
             return Vec3(self.x * rhs, self.y * rhs, self.z * rhs)
         else:
-            raise ValueError(
-                f"can only do piecewise multiplication with a scalar {rhs=}"
-            )
+            raise ValueError(f"can only do piecewise multiplication with a scalar {rhs=}")
 
     def __rmul__(self, rhs):
         """

{ncca_ngl-0.2.1 → ncca_ngl-0.2.3}/src/ncca/ngl/vec4.py

@@ -65,7 +65,7 @@ class Vec4:
         except IndexError:
             raise IndexError("Index out of range. Valid indices are 0, 1, 2, and 3.")
 
-    def clone(self) -> "Vec4":
+    def copy(self) -> "Vec4":
         """
         Create a copy of the vector.
         Returns:
@@ -192,22 +192,10 @@ class Vec4:
     def __matmul__(self, rhs):
         "Vec4 @ Mat4 matrix multiplication"
         return Vec4(
-            self.x * rhs.m[0][0]
-            + self.y * rhs.m[1][0]
-            + self.z * rhs.m[2][0]
-            + self.w * rhs.m[3][0],
-            self.x * rhs.m[0][1]
-            + self.y * rhs.m[1][1]
-            + self.z * rhs.m[2][1]
-            + self.w * rhs.m[3][1],
-            self.x * rhs.m[0][2]
-            + self.y * rhs.m[1][2]
-            + self.z * rhs.m[2][2]
-            + self.w * rhs.m[3][2],
-            self.x * rhs.m[0][3]
-            + self.y * rhs.m[1][3]
-            + self.z * rhs.m[2][3]
-            + self.w * rhs.m[3][3],
+            self.x * rhs.m[0][0] + self.y * rhs.m[1][0] + self.z * rhs.m[2][0] + self.w * rhs.m[3][0],
+            self.x * rhs.m[0][1] + self.y * rhs.m[1][1] + self.z * rhs.m[2][1] + self.w * rhs.m[3][1],
+            self.x * rhs.m[0][2] + self.y * rhs.m[1][2] + self.z * rhs.m[2][2] + self.w * rhs.m[3][2],
+            self.x * rhs.m[0][3] + self.y * rhs.m[1][3] + self.z * rhs.m[2][3] + self.w * rhs.m[3][3],
         )
 
     def __repr__(self):

ncca_ngl-0.2.1/src/ncca/ngl/primitives.py

@@ -1,219 +0,0 @@
-"""
-OpenGL primitive generation and drawing functions
-In this class we can generate a pipeline for drawing our data for the most part it will be
-x,y,z nx,ny,nz and u,v data in a flat numpy array.
-We need to create the data first which is stored in a map as part of the class, we can then call draw
-which will generate a pipeline for this object and draw into the current context.
-"""
-
-from typing import Dict, Union
-
-import numpy as np
-import OpenGL.GL as gl
-
-from .log import logger
-from .prim_data import PrimData, Prims
-from .simple_vao import VertexData
-from .vao_factory import VAOFactory, VAOType  # noqa
-from .vec3 import Vec3
-
-
-class _primitive:
-    """A private class to hold VAO data for a primitive."""
-
-    def __init__(self, prim_data: np.ndarray):
-        """
-        Initializes the primitive with the given data.
-
-        Args:
-            prim_data: A numpy array containing the vertex data (x,y,z,nx,ny,nz,u,v).
-        """
-        self.vao = VAOFactory.create_vao(VAOType.SIMPLE, gl.GL_TRIANGLES)
-        with self.vao:
-            data = VertexData(data=prim_data.data, size=prim_data.size)
-            self.vao.set_data(data)
-            vert_data_size = 8 * 4  # 4 is sizeof float and 8 is x,y,z,nx,ny,nz,uv
-            self.vao.set_vertex_attribute_pointer(0, 3, gl.GL_FLOAT, vert_data_size, 0)
-            self.vao.set_vertex_attribute_pointer(1, 3, gl.GL_FLOAT, vert_data_size, Vec3.sizeof())
-            self.vao.set_vertex_attribute_pointer(2, 2, gl.GL_FLOAT, vert_data_size, 2 * Vec3.sizeof())
-            self.vao.set_num_indices(prim_data.size // 8)
-
-
-class Primitives:
-    """A static class for creating and drawing primitives."""
-
-    # this is effectively a static class so we can use it to store data
-    # and generate pipelines for drawing
-    _primitives: Dict[str, _primitive] = {}
-    _loaded: bool = False
-
-    @classmethod
-    def load_default_primitives(cls) -> None:
-        """Loads the default primitives from the PrimData directory."""
-        logger.info("Loading default primitives...")
-        if not cls._loaded:
-            for p in Prims:
-                prim_data = PrimData.primitive(p.value)
-                prim = _primitive(prim_data)
-                cls._primitives[p.value] = prim
-            cls._loaded = True
-
-    @classmethod
-    def create_line_grid(cls, name: str, width: float, depth: float, steps: int) -> None:
-        """
-        Creates a line grid primitive.
-
-        Args:
-            name: The name of the primitive to create.
-            width: The width of the grid.
-            depth: The depth of the grid.
-            steps: The number of steps in the grid.
-        """
-        # Convert the list to a NumPy array
-        data_array = PrimData.line_grid(width, depth, steps)
-        prim = _primitive(data_array)
-        cls._primitives[name] = prim
-
-    @classmethod
-    def create_triangle_plane(cls, name: str, width: float, depth: float, w_p: int, d_p: int, v_n: Vec3) -> None:
-        """
-        Creates a triangle plane primitive.
-
-        Args:
-            name: The name of the primitive.
-            width: The width of the plane.
-            depth: The depth of the plane.
-            w_p: The number of width partitions.
-            d_p: The number of depth partitions.
-            v_n: The normal vector for the plane.
-        """
-
-        data_array = PrimData.triangle_plane(width, depth, w_p, d_p, v_n)
-        prim = _primitive(data_array)
-        cls._primitives[name] = prim
-
-    @classmethod
-    def draw(cls, name: Union[str, Prims]) -> None:
-        """
-        Draws the specified primitive.
-
-        Args:
-            name: The name of the primitive to draw, either as a string or a Prims enum.
-        """
-        key = name.value if isinstance(name, Prims) else name
-        try:
-            prim = cls._primitives[key]
-            with prim.vao:
-                prim.vao.draw()
-        except KeyError:
-            logger.error(f"Failed to draw primitive {key}")
-            return
-
-    @classmethod
-    def create_sphere(cls, name: str, radius: float, precision: int) -> None:
-        """
-        Creates a sphere primitive.
-
-        Args:
-            name: The name of the primitive.
-            radius: The radius of the sphere.
-            precision: The precision of the sphere (number of slices).
-        """
-
-        data_array = PrimData.sphere(radius, precision)
-        prim = _primitive(data_array)
-        cls._primitives[name] = prim
-
-    @classmethod
-    def create_cone(cls, name: str, base: float, height: float, slices: int, stacks: int) -> None:
-        """
-        Creates a cone primitive.
-
-        Args:
-            name: The name of the primitive.
-            base: The radius of the cone's base.
-            height: The height of the cone.
-            slices: The number of divisions around the cone.
-            stacks: The number of divisions along the cone's height.
-        """
-        data_array = PrimData.cone(base, height, slices, stacks)
-        prim = _primitive(data_array)
-        cls._primitives[name] = prim
-
-    @classmethod
-    def create_capsule(cls, name: str, radius: float, height: float, precision: int) -> None:
-        """
-        Creates a capsule primitive.
-        The capsule is aligned along the y-axis.
-        It is composed of a cylinder and two hemispherical caps.
-        based on code from here https://code.google.com/p/rgine/source/browse/trunk/RGine/opengl/src/RGLShapes.cpp
-        and adapted
-
-        Args:
-            name: The name of the primitive.
-            radius: The radius of the capsule.
-            height: The height of the capsule.
-            precision: The precision of the capsule.
-        """
-
-        data_array = PrimData.capsule(radius, height, precision)
-        prim = _primitive(data_array)
-        cls._primitives[name] = prim
-
-    @classmethod
-    def create_cylinder(cls, name: str, radius: float, height: float, slices: int, stacks: int) -> None:
-        """
-        Creates a cylinder primitive.
-        The cylinder is aligned along the y-axis.
-        This method generates the cylinder walls, but not the top and bottom caps.
-
-        Args:
-            name: The name of the primitive.
-            radius: The radius of the cylinder.
-            height: The height of the cylinder.
-            slices: The number of slices.
-            stacks: The number of stacks.
-        """
-
-        data_array = PrimData.cylinder(radius, height, slices, stacks)
-        prim = _primitive(data_array)
-        cls._primitives[name] = prim
-
-    @classmethod
-    def create_disk(cls, name: str, radius: float, slices: int) -> None:
-        """
-        Creates a disk primitive.
-
-        Args:
-            name: The name of the primitive.
-            radius: The radius of the disk.
-            slices: The number of slices to divide the disk into.
-        """
-
-        data_array = PrimData.disk(radius, slices)
-        prim = _primitive(data_array)
-        cls._primitives[name] = prim
-
-    @classmethod
-    def create_torus(
-        cls,
-        name: str,
-        minor_radius: float,
-        major_radius: float,
-        sides: int,
-        rings: int,
-    ) -> None:
-        """
-        Creates a torus primitive.
-
-        Args:
-            name: The name of the primitive.
-            minor_radius: The minor radius of the torus.
-            major_radius: The major radius of the torus.
-            sides: The number of sides for each ring.
-            rings: The number of rings for the torus.
-        """
-
-        data_array = PrimData.torus(minor_radius, major_radius, sides, rings)
-        prim = _primitive(data_array)
-        cls._primitives[name] = prim