ncca-ngl 0.2.2__py3-none-any.whl → 0.2.4__py3-none-any.whl

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
@@ -38,7 +41,7 @@ from .simple_vao import SimpleVAO
 from .text import Text
 from .texture import Texture
 from .transform import Transform, TransformRotationOrder
-from .util import calc_normal, clamp, frustum, lerp, look_at, ortho, perspective
+from .util import PerspMode, calc_normal, clamp, frustum, lerp, look_at, ortho, perspective
 from .vao_factory import VAOFactory, VAOType
 from .vec2 import Vec2
 from .vec2_array import Vec2Array
@@ -107,4 +110,5 @@ all = [
     PrimData,
     FirstPersonCamera,
     PySideEventHandlingMixin,
+    PerspMode,
 ]

ncca/ngl/abstract_vao.py

@@ -52,14 +52,10 @@ class AbstractVAO(abc.ABC):
     def remove_vao(self):
         raise NotImplementedError
 
-    def set_vertex_attribute_pointer(
-        self, id, size, type, stride, offset, normalize=False
-    ):
+    def set_vertex_attribute_pointer(self, id, size, type, stride, offset, normalize=False):
         if not self.bound:
             logger.error("VAO not bound in set_vertex_attribute_pointer")
-        gl.glVertexAttribPointer(
-            id, size, type, normalize, stride, ctypes.c_void_p(offset)
-        )
+        gl.glVertexAttribPointer(id, size, type, normalize, stride, ctypes.c_void_p(offset))
         gl.glEnableVertexAttribArray(id)
 
     def set_num_indices(self, count):

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/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/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/prim_data.py

@@ -10,7 +10,7 @@ from .vec3 import Vec3
 class Prims(enum.Enum):
     """Enum for the default primitives that can be loaded."""
 
-    BUDDAH = "buddah"
+    BUDDHA = "buddah"
     BUNNY = "bunny"
     CUBE = "cube"
     DODECAHEDRON = "dodecahedron"

ncca/ngl/quaternion.py

@@ -10,6 +10,7 @@ Attributes:
 import math
 
 from .mat4 import Mat4
+from .vec3 import Vec3
 
 
 class Quaternion:
@@ -75,9 +76,7 @@ class Quaternion:
         return Quaternion(s, x, y, z)
 
     def __add__(self, rhs):
-        return Quaternion(
-            self.s + rhs.s, self.x + rhs.x, self.y + rhs.y, self.z + rhs.z
-        )
+        return Quaternion(self.s + rhs.s, self.x + rhs.x, self.y + rhs.y, self.z + rhs.z)
 
     def __iadd__(self, rhs):
         self.s += rhs.s
@@ -87,20 +86,57 @@ class Quaternion:
         return self
 
     def __sub__(self, rhs):
-        return Quaternion(
-            self.s - rhs.s, self.x - rhs.x, self.y - rhs.y, self.z - rhs.z
-        )
+        return Quaternion(self.s - rhs.s, self.x - rhs.x, self.y - rhs.y, self.z - rhs.z)
 
     def __isub__(self, rhs):
         return self.__sub__(rhs)
 
+    # def __mul__(self, rhs):
+    #     return Quaternion(
+    #         self.s * rhs.s - self.x * rhs.x - self.y * rhs.y - self.z * rhs.z,
+    #         self.s * rhs.x + self.x * rhs.s + self.y * rhs.z - self.z * rhs.y,
+    #         self.s * rhs.y - self.x * rhs.z + self.y * rhs.s + self.z * rhs.x,
+    #         self.s * rhs.z + self.x * rhs.y - self.y * rhs.x + self.z * rhs.s,
+    #     )
+
     def __mul__(self, rhs):
-        return Quaternion(
-            self.s * rhs.s - self.x * rhs.x - self.y * rhs.y - self.z * rhs.z,
-            self.s * rhs.x + self.x * rhs.s + self.y * rhs.z - self.z * rhs.y,
-            self.s * rhs.y - self.x * rhs.z + self.y * rhs.s + self.z * rhs.x,
-            self.s * rhs.z + self.x * rhs.y - self.y * rhs.x + self.z * rhs.s,
-        )
+        if isinstance(rhs, Quaternion):
+            return Quaternion(
+                self.s * rhs.s - self.x * rhs.x - self.y * rhs.y - self.z * rhs.z,
+                self.s * rhs.x + self.x * rhs.s + self.y * rhs.z - self.z * rhs.y,
+                self.s * rhs.y - self.x * rhs.z + self.y * rhs.s + self.z * rhs.x,
+                self.s * rhs.z + self.x * rhs.y - self.y * rhs.x + self.z * rhs.s,
+            )
+        elif isinstance(rhs, Vec3):
+            qw = self.s
+            qx = self.x
+            qy = self.y
+            qz = self.z
+
+            vx = rhs.x
+            vy = rhs.y
+            vz = rhs.z
+
+            # pq
+            pw = -qx * vx - qy * vy - qz * vz
+            px = qw * vx + qy * vz - qz * vy
+            py = qw * vy - qx * vz + qz * vx
+            pz = qw * vz + qx * vy - qy * vx
+
+            # pqp*
+            return Vec3(
+                -pw * qx + px * qw - py * qz + pz * qy,
+                -pw * qy + px * qz + py * qw - pz * qx,
+                -pw * qz - px * qy + py * qx + pz * qw,
+            )
+
+    def normalize(self):
+        length = math.sqrt(self.s * self.s + self.x * self.x + self.y * self.y + self.z * self.z)
+        if length > 0:
+            self.s /= length
+            self.x /= length
+            self.y /= length
+            self.z /= length
 
     def __str__(self) -> str:
         """

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/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/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.2.dist-info → ncca_ngl-0.2.4.dist-info}/METADATA

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

{ncca_ngl-0.2.2.dist-info → ncca_ngl-0.2.4.dist-info}/RECORD

@@ -15,8 +15,8 @@ ncca/ngl/PrimData/pack_arrays.py,sha256=aWShJX8QPHXKTj66C8yu1DskmD3VEzFXyaADcxw6
 ncca/ngl/PrimData/teapot.npy,sha256=fiOfYtB5SkegO7uTSitpjl_HmnS_iIy0sXAGfxCXXjY,1350560
 ncca/ngl/PrimData/tetrahedron.npy,sha256=_KCSpflFXhYB4gGVxFmF5Cv6pQyPHuUlCj9xfL2oyEM,512
 ncca/ngl/PrimData/troll.npy,sha256=ohgGgxLCJrmsFdNrlfRY2Rg9eJgcmvArf6IAspO2BKA,3505280
-ncca/ngl/__init__.py,sha256=tyDe5m-1jd51kIOU-f2m1kU0XU10mebwrQ3td0Wdhko,2543
-ncca/ngl/abstract_vao.py,sha256=VLKp3pmPYK_dQgEImMOAQ0DufAswK_0H4DR4r8flp2U,2104
+ncca/ngl/__init__.py,sha256=2zCMEMQLSZNeWUTY1i7GnRZqhmerPy1F220NoFPfJB0,2640
+ncca/ngl/abstract_vao.py,sha256=fi7-BIfw1jefcXe09Qj2gGmnqqA9kzJK-hAwfG14Hrc,2068
 ncca/ngl/base_mesh.py,sha256=2JmVT5_bvgLHra1VnwRld-mh-20IqqekgEu1dbGU1a4,5736
 ncca/ngl/base_mesh.pyi,sha256=kobLuNnCSZlRRobIgVopQaS7Bjg0tJ3m4M64WXt5I-M,173
 ncca/ngl/bbox.py,sha256=PylB6ju_bkdDUqQkzO1n2E-jsmxiviNkyBLY-sN59n8,6578
@@ -24,16 +24,16 @@ ncca/ngl/bezier_curve.py,sha256=A0aidWJ7c8Bh2KGCgCJ7aH8c8MakP8xrFFEFvCjva38,2297
 ncca/ngl/first_person_camera.py,sha256=Rrt3ibMh72K8gPBu6B8neIbYk5lnNZcDnvBB8mq5pz0,5890
 ncca/ngl/image.py,sha256=zpG8egzXWkUJKQxpRhXndpRxJDKOKHZkDjQuKSRXN2E,2692
 ncca/ngl/log.py,sha256=b7l-XNJIpP36VqcCGXBV_0XT5Nkd5eyuC7043lWegcw,1282
-ncca/ngl/mat2.py,sha256=algDowqqP_pQ3Crl-xiqkQqRaYohfpymfaZYxvbH0qc,3437
-ncca/ngl/mat3.py,sha256=imWKkMuPPWLctIpU2lDqKTu014bWHSq5eEpIj4E7MzE,12404
-ncca/ngl/mat4.py,sha256=eGvmLfw_wwKuuVh29wAKrvSZJB41jgmcYV5EufzyXbo,17273
+ncca/ngl/mat2.py,sha256=kHyrxLWQ_zGBf5t6huKL6BDrjF5a1skU_9PpcyMFi0I,3710
+ncca/ngl/mat3.py,sha256=k4kD9a5QqamxZZbnSECe4p0kQdVM6bEj5VaUBAf5AOs,12355
+ncca/ngl/mat4.py,sha256=i6ZKnMpwJdh8ULTjcnWKPo9UK39ulU4WeUdoet4yZAE,17574
 ncca/ngl/multi_buffer_vao.py,sha256=cuNE6gSrqkNcYvfIOYOZp4MVnpCvChUgnzsf7b60pWg,1752
 ncca/ngl/obj.py,sha256=AGldNouHrkrDs2UhATClGkgo4dzr6lzArR4YeCxQKmo,13667
 ncca/ngl/plane.py,sha256=96WuGzexYKhoeRVevGP2pZcustt9fzyyAjuwJHT25tk,1299
-ncca/ngl/prim_data.py,sha256=sBynXeAfVtYXK7dkdLYELo0VIbN1lK1KZ8KMmCWzjBA,19047
+ncca/ngl/prim_data.py,sha256=SmHoN1wpQlu3HSfZuLBqsR8jEnVGAqdXcwSq62Lepgg,19047
 ncca/ngl/primitives.py,sha256=pThdSWLv7jJa9weBVOXhRgTfVVH54AWCbsDFCEI1YLg,4841
 ncca/ngl/pyside_event_handling_mixin.py,sha256=L8obXeTp-g2Va2eXyd1hnmSp-sY7p4GX6EcFYRnH1F4,10588
-ncca/ngl/quaternion.py,sha256=agmbW8i125FyLOV2Z9SpTY5yQwmnnm0rxQawwHqq1YI,3858
+ncca/ngl/quaternion.py,sha256=hvMoaV7uxx60boPg4cTqLJDyTpFZrEpUhikNqmNVTrU,5188
 ncca/ngl/random.py,sha256=wX1R2rMpb76TP4rk44NUp5XoVuMisH9d-eBG5kFBZsM,5579
 ncca/ngl/shader.py,sha256=fEz8R_itsQssIxQp1E8-PhY3aOaTdm7sXpyFYoARSic,7696
 ncca/ngl/shader_lib.py,sha256=YmF3EJM9roTEt5OI5sHonAVN_ydIseyiOUBFZTX4KdA,18627
@@ -54,12 +54,12 @@ ncca/ngl/texture.py,sha256=OgBBEItgUDohCsVWgmjEWcQWBJaXl9w070PTOOywPx4,2303
 ncca/ngl/transform.py,sha256=_PibgtFoU_exfvQUWucmts0WF5OreSTNbftvSa3zT8g,2938
 ncca/ngl/util.py,sha256=8jp5vTVuGfVHMSktFEubtoaQ8SvLIQtM2UNbUeMTOFk,4372
 ncca/ngl/vao_factory.py,sha256=v87VfrUMaoqcsE-CS9kM7h5Fyk_e0LGl_iA6xqaomPg,930
-ncca/ngl/vec2.py,sha256=3bhd03y5E3HRnBdXJZ4xMsTMMAte5IEr6u4qqWT_UL4,10361
+ncca/ngl/vec2.py,sha256=XLDBdSS2uqJbDG4gl1bL2YR79fl77bQeu98OEMQMVCQ,10204
 ncca/ngl/vec2_array.py,sha256=7QRgXh75fORsmNnSnNxNQWk6_rnDgfmRX3tmJZ4ES9E,3420
-ncca/ngl/vec3.py,sha256=ntgqB3sc_jzcGO5vlHKgDqloOoMkykVcWPxpYdWFy5Q,12449
+ncca/ngl/vec3.py,sha256=NAiwdosG5ONcdGBBQGCfnskMdj7MH3eGagavjaU1SyI,12263
 ncca/ngl/vec3_array.py,sha256=fLRC8k0TwcaU7CnR2GmJ0prud4dcvvUX0JTbQH_2W3Y,3535
-ncca/ngl/vec4.py,sha256=95b7yr82JtC3FqVDC8Hwn3wzPmVzSYTDCR1A6h_w9RM,6884
+ncca/ngl/vec4.py,sha256=rkowZkxacU9l0piLnsEYdgMn94gdkYUzipcn4i8lES0,6739
 ncca/ngl/vec4_array.py,sha256=PSJXfG0g2AT4oQCLHiVAP6EC5n7vMXRQy0N1rGvv1iw,3426
-ncca_ngl-0.2.2.dist-info/WHEEL,sha256=eh7sammvW2TypMMMGKgsM83HyA_3qQ5Lgg3ynoecH3M,79
-ncca_ngl-0.2.2.dist-info/METADATA,sha256=7mdnns3adaYNydJ1fvfPeSO_alBW080SZQfnx6wGhGY,1596
-ncca_ngl-0.2.2.dist-info/RECORD,,
+ncca_ngl-0.2.4.dist-info/WHEEL,sha256=eh7sammvW2TypMMMGKgsM83HyA_3qQ5Lgg3ynoecH3M,79
+ncca_ngl-0.2.4.dist-info/METADATA,sha256=fl3kZoMULNeTS--RhNPD-hM6v3uWQ76LpLHm9fcO_9U,1596
+ncca_ngl-0.2.4.dist-info/RECORD,,