ncca-ngl 0.1.4__py3-none-any.whl → 0.1.6__py3-none-any.whl

ncca/ngl/__init__.py

@@ -1,3 +1,11 @@
+# generate auto __version__
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("ncca-ngl")
+except PackageNotFoundError:
+    __version__ = "0.0.0"
+
 from .abstract_vao import AbstractVAO, VertexData
 from .base_mesh import BaseMesh, Face
 from .bbox import BBox

ncca/ngl/abstract_vao.py

@@ -52,10 +52,14 @@ 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/quaternion.py

@@ -75,7 +75,9 @@ 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
@@ -85,7 +87,9 @@ 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)

ncca/ngl/shader_program.py

@@ -105,7 +105,9 @@ class ShaderProgram:
             if is_array:
                 for element_idx in range(size):
                     element_name = f"{base_name}[{element_idx}]"
-                    element_location = gl.glGetUniformLocation(self._id, element_name.encode("utf-8"))
+                    element_location = gl.glGetUniformLocation(
+                        self._id, element_name.encode("utf-8")
+                    )
                     if element_location != -1:
                         # Store individual array element: (location, shader_type, 1, False)
                         self._uniforms[element_name] = (
@@ -120,7 +122,9 @@ class ShaderProgram:
                 logger.info(
                     f"Registered array uniform: {base_name}[{size}] (type: {self.get_gl_type_string(shader_type)}, location: {location})"
                 )
-                logger.info(f"  Also registered individual elements: {base_name}[0] to {base_name}[{size - 1}]")
+                logger.info(
+                    f"  Also registered individual elements: {base_name}[0] to {base_name}[{size - 1}]"
+                )
             else:
                 logger.info(
                     f"Registered uniform: {base_name} (type: {self.get_gl_type_string(shader_type)}, location: {location})"
@@ -143,8 +147,14 @@ class ShaderProgram:
             name_buffer = (ctypes.c_char * 256)()
             length = ctypes.c_int()
 
-            gl.glGetActiveUniformBlockName(self._id, i, 256, ctypes.byref(length), name_buffer)
-            name_str = name_buffer.value.decode("utf-8") if name_buffer.value else f"UniformBlock_{i}"
+            gl.glGetActiveUniformBlockName(
+                self._id, i, 256, ctypes.byref(length), name_buffer
+            )
+            name_str = (
+                name_buffer.value.decode("utf-8")
+                if name_buffer.value
+                else f"UniformBlock_{i}"
+            )
 
             # Create uniform block data structure
             data = {
@@ -242,7 +252,9 @@ class ShaderProgram:
             bool: True if successful, False otherwise
         """
         if uniform_block_name not in self._registered_uniform_blocks:
-            logger.error(f"Uniform block '{uniform_block_name}' not found in shader '{self._name}'")
+            logger.error(
+                f"Uniform block '{uniform_block_name}' not found in shader '{self._name}'"
+            )
             return False
 
         block = self._registered_uniform_blocks[uniform_block_name]
@@ -295,11 +307,17 @@ class ShaderProgram:
             elif isinstance(val, float):
                 gl.glUniform1f(loc, val)
             elif isinstance(val, Mat2):
-                gl.glUniformMatrix2fv(loc, 1, gl.GL_FALSE, (ctypes.c_float * 4)(*val.get_matrix()))
+                gl.glUniformMatrix2fv(
+                    loc, 1, gl.GL_FALSE, (ctypes.c_float * 4)(*val.get_matrix())
+                )
             elif isinstance(val, Mat3):
-                gl.glUniformMatrix3fv(loc, 1, gl.GL_FALSE, (ctypes.c_float * 9)(*val.get_matrix()))
+                gl.glUniformMatrix3fv(
+                    loc, 1, gl.GL_FALSE, (ctypes.c_float * 9)(*val.get_matrix())
+                )
             elif isinstance(val, Mat4):
-                gl.glUniformMatrix4fv(loc, 1, gl.GL_FALSE, (ctypes.c_float * 16)(*val.get_matrix()))
+                gl.glUniformMatrix4fv(
+                    loc, 1, gl.GL_FALSE, (ctypes.c_float * 16)(*val.get_matrix())
+                )
             elif isinstance(val, Vec2):
                 gl.glUniform2f(loc, *val)
             elif isinstance(val, Vec3):
@@ -310,13 +328,21 @@ class ShaderProgram:
                 try:
                     val = list(value[0])
                     if len(val) == 4:
-                        gl.glUniformMatrix2fv(loc, 1, gl.GL_FALSE, (ctypes.c_float * 4)(*val))
+                        gl.glUniformMatrix2fv(
+                            loc, 1, gl.GL_FALSE, (ctypes.c_float * 4)(*val)
+                        )
                     elif len(val) == 9:
-                        gl.glUniformMatrix3fv(loc, 1, gl.GL_FALSE, (ctypes.c_float * 9)(*val))
+                        gl.glUniformMatrix3fv(
+                            loc, 1, gl.GL_FALSE, (ctypes.c_float * 9)(*val)
+                        )
                     elif len(val) == 16:
-                        gl.glUniformMatrix4fv(loc, 1, gl.GL_FALSE, (ctypes.c_float * 16)(*val))
+                        gl.glUniformMatrix4fv(
+                            loc, 1, gl.GL_FALSE, (ctypes.c_float * 16)(*val)
+                        )
                 except TypeError:
-                    logger.warning(f"Warning: uniform '{name}' has unknown type: {type(val)}")
+                    logger.warning(
+                        f"Warning: uniform '{name}' has unknown type: {type(val)}"
+                    )
 
         elif len(value) == 2:
             if isinstance(value[0], int):
@@ -359,7 +385,9 @@ class ShaderProgram:
         loc = self.get_uniform_location(name)
         if loc != -1:
             flat_values = [item for vec in values for item in vec]
-            gl.glUniform2fv(loc, len(values), (ctypes.c_float * len(flat_values))(*flat_values))
+            gl.glUniform2fv(
+                loc, len(values), (ctypes.c_float * len(flat_values))(*flat_values)
+            )
 
     def set_uniform_3fv(self, name: str, values: List[List[float]]) -> None:
         """
@@ -373,7 +401,9 @@ class ShaderProgram:
         loc = self.get_uniform_location(name)
         if loc != -1:
             flat_values = [item for vec in values for item in vec]
-            gl.glUniform3fv(loc, len(values), (ctypes.c_float * len(flat_values))(*flat_values))
+            gl.glUniform3fv(
+                loc, len(values), (ctypes.c_float * len(flat_values))(*flat_values)
+            )
 
     def set_uniform_4fv(self, name: str, values: List[List[float]]) -> None:
         """
@@ -387,7 +417,9 @@ class ShaderProgram:
         loc = self.get_uniform_location(name)
         if loc != -1:
             flat_values = [item for vec in values for item in vec]
-            gl.glUniform4fv(loc, len(values), (ctypes.c_float * len(flat_values))(*flat_values))
+            gl.glUniform4fv(
+                loc, len(values), (ctypes.c_float * len(flat_values))(*flat_values)
+            )
 
     def set_uniform_1iv(self, name: str, values: List[int]) -> None:
         """
@@ -696,19 +728,121 @@ class ShaderProgram:
             str: Human-readable type string
         """
         type_map = {
+            # Scalars
             gl.GL_FLOAT: "float",
-            gl.GL_FLOAT_VEC2: "vec2",
-            gl.GL_FLOAT_VEC3: "vec3",
-            gl.GL_FLOAT_VEC4: "vec4",
             gl.GL_DOUBLE: "double",
             gl.GL_INT: "int",
-            gl.GL_UNSIGNED_INT: "unsigned int",
+            gl.GL_UNSIGNED_INT: "uint",
             gl.GL_BOOL: "bool",
+            # Float vectors
+            gl.GL_FLOAT_VEC2: "vec2",
+            gl.GL_FLOAT_VEC3: "vec3",
+            gl.GL_FLOAT_VEC4: "vec4",
+            # Double vectors
+            gl.GL_DOUBLE_VEC2: "dvec2",
+            gl.GL_DOUBLE_VEC3: "dvec3",
+            gl.GL_DOUBLE_VEC4: "dvec4",
+            # Integer vectors
+            gl.GL_INT_VEC2: "ivec2",
+            gl.GL_INT_VEC3: "ivec3",
+            gl.GL_INT_VEC4: "ivec4",
+            # Unsigned int vectors
+            gl.GL_UNSIGNED_INT_VEC2: "uvec2",
+            gl.GL_UNSIGNED_INT_VEC3: "uvec3",
+            gl.GL_UNSIGNED_INT_VEC4: "uvec4",
+            # Bool vectors
+            gl.GL_BOOL_VEC2: "bvec2",
+            gl.GL_BOOL_VEC3: "bvec3",
+            gl.GL_BOOL_VEC4: "bvec4",
+            # Float matrices
             gl.GL_FLOAT_MAT2: "mat2",
             gl.GL_FLOAT_MAT3: "mat3",
             gl.GL_FLOAT_MAT4: "mat4",
+            gl.GL_FLOAT_MAT2x3: "mat2x3",
+            gl.GL_FLOAT_MAT2x4: "mat2x4",
+            gl.GL_FLOAT_MAT3x2: "mat3x2",
+            gl.GL_FLOAT_MAT3x4: "mat3x4",
+            gl.GL_FLOAT_MAT4x2: "mat4x2",
+            gl.GL_FLOAT_MAT4x3: "mat4x3",
+            # Double matrices
+            gl.GL_DOUBLE_MAT2: "dmat2",
+            gl.GL_DOUBLE_MAT3: "dmat3",
+            gl.GL_DOUBLE_MAT4: "dmat4",
+            gl.GL_DOUBLE_MAT2x3: "dmat2x3",
+            gl.GL_DOUBLE_MAT2x4: "dmat2x4",
+            gl.GL_DOUBLE_MAT3x2: "dmat3x2",
+            gl.GL_DOUBLE_MAT3x4: "dmat3x4",
+            gl.GL_DOUBLE_MAT4x2: "dmat4x2",
+            gl.GL_DOUBLE_MAT4x3: "dmat4x3",
+            # Samplers (float)
+            gl.GL_SAMPLER_1D: "sampler1D",
             gl.GL_SAMPLER_2D: "sampler2D",
+            gl.GL_SAMPLER_3D: "sampler3D",
             gl.GL_SAMPLER_CUBE: "samplerCube",
+            gl.GL_SAMPLER_1D_SHADOW: "sampler1DShadow",
+            gl.GL_SAMPLER_2D_SHADOW: "sampler2DShadow",
+            gl.GL_SAMPLER_1D_ARRAY: "sampler1DArray",
+            gl.GL_SAMPLER_2D_ARRAY: "sampler2DArray",
+            gl.GL_SAMPLER_1D_ARRAY_SHADOW: "sampler1DArrayShadow",
+            gl.GL_SAMPLER_2D_ARRAY_SHADOW: "sampler2DArrayShadow",
+            gl.GL_SAMPLER_CUBE_SHADOW: "samplerCubeShadow",
+            gl.GL_SAMPLER_BUFFER: "samplerBuffer",
+            gl.GL_SAMPLER_2D_RECT: "sampler2DRect",
+            gl.GL_SAMPLER_2D_RECT_SHADOW: "sampler2DRectShadow",
+            # Samplers (int)
+            gl.GL_INT_SAMPLER_1D: "isampler1D",
+            gl.GL_INT_SAMPLER_2D: "isampler2D",
+            gl.GL_INT_SAMPLER_3D: "isampler3D",
+            gl.GL_INT_SAMPLER_CUBE: "isamplerCube",
+            gl.GL_INT_SAMPLER_1D_ARRAY: "isampler1DArray",
+            gl.GL_INT_SAMPLER_2D_ARRAY: "isampler2DArray",
+            gl.GL_INT_SAMPLER_BUFFER: "isamplerBuffer",
+            gl.GL_INT_SAMPLER_2D_RECT: "isampler2DRect",
+            # Samplers (unsigned int)
+            gl.GL_UNSIGNED_INT_SAMPLER_1D: "usampler1D",
+            gl.GL_UNSIGNED_INT_SAMPLER_2D: "usampler2D",
+            gl.GL_UNSIGNED_INT_SAMPLER_3D: "usampler3D",
+            gl.GL_UNSIGNED_INT_SAMPLER_CUBE: "usamplerCube",
+            gl.GL_UNSIGNED_INT_SAMPLER_1D_ARRAY: "usampler1DArray",
+            gl.GL_UNSIGNED_INT_SAMPLER_2D_ARRAY: "usampler2DArray",
+            gl.GL_UNSIGNED_INT_SAMPLER_BUFFER: "usamplerBuffer",
+            gl.GL_UNSIGNED_INT_SAMPLER_2D_RECT: "usampler2DRect",
+            # Images (float)
+            gl.GL_IMAGE_1D: "image1D",
+            gl.GL_IMAGE_2D: "image2D",
+            gl.GL_IMAGE_3D: "image3D",
+            gl.GL_IMAGE_2D_RECT: "image2DRect",
+            gl.GL_IMAGE_CUBE: "imageCube",
+            gl.GL_IMAGE_BUFFER: "imageBuffer",
+            gl.GL_IMAGE_1D_ARRAY: "image1DArray",
+            gl.GL_IMAGE_2D_ARRAY: "image2DArray",
+            gl.GL_IMAGE_CUBE_MAP_ARRAY: "imageCubeArray",
+            gl.GL_IMAGE_2D_MULTISAMPLE: "image2DMS",
+            gl.GL_IMAGE_2D_MULTISAMPLE_ARRAY: "image2DMSArray",
+            # Images (int)
+            gl.GL_INT_IMAGE_1D: "iimage1D",
+            gl.GL_INT_IMAGE_2D: "iimage2D",
+            gl.GL_INT_IMAGE_3D: "iimage3D",
+            gl.GL_INT_IMAGE_2D_RECT: "iimage2DRect",
+            gl.GL_INT_IMAGE_CUBE: "iimageCube",
+            gl.GL_INT_IMAGE_BUFFER: "iimageBuffer",
+            gl.GL_INT_IMAGE_1D_ARRAY: "iimage1DArray",
+            gl.GL_INT_IMAGE_2D_ARRAY: "iimage2DArray",
+            gl.GL_INT_IMAGE_CUBE_MAP_ARRAY: "iimageCubeArray",
+            gl.GL_INT_IMAGE_2D_MULTISAMPLE: "iimage2DMS",
+            gl.GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY: "iimage2DMSArray",
+            # Images (unsigned int)
+            gl.GL_UNSIGNED_INT_IMAGE_1D: "uimage1D",
+            gl.GL_UNSIGNED_INT_IMAGE_2D: "uimage2D",
+            gl.GL_UNSIGNED_INT_IMAGE_3D: "uimage3D",
+            gl.GL_UNSIGNED_INT_IMAGE_2D_RECT: "uimage2DRect",
+            gl.GL_UNSIGNED_INT_IMAGE_CUBE: "uimageCube",
+            gl.GL_UNSIGNED_INT_IMAGE_BUFFER: "uimageBuffer",
+            gl.GL_UNSIGNED_INT_IMAGE_1D_ARRAY: "uimage1DArray",
+            gl.GL_UNSIGNED_INT_IMAGE_2D_ARRAY: "uimage2DArray",
+            gl.GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY: "uimageCubeArray",
+            gl.GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE: "uimage2DMS",
+            gl.GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY: "uimage2DMSArray",
         }
         return type_map.get(gl_type, f"Unknown type {gl_type}")
 
@@ -727,7 +861,9 @@ class ShaderProgram:
                 base_name = name.split("[")[0]
                 if base_name not in array_elements:
                     array_elements[base_name] = []
-                array_elements[base_name].append((name, location, uniform_type, size, is_array))
+                array_elements[base_name].append(
+                    (name, location, uniform_type, size, is_array)
+                )
             else:
                 base_uniforms[name] = (location, uniform_type, size, is_array)
 
@@ -735,7 +871,9 @@ class ShaderProgram:
         for name, (location, uniform_type, size, is_array) in base_uniforms.items():
             type_str = self.get_gl_type_string(uniform_type)
             if is_array:
-                logger.info(f"  {name}[{size}] (type: {type_str}, location: {location})")
+                logger.info(
+                    f"  {name}[{size}] (type: {type_str}, location: {location})"
+                )
             else:
                 logger.info(f"  {name} (type: {type_str}, location: {location})")
 
@@ -744,7 +882,9 @@ class ShaderProgram:
             logger.info(f"  Array elements for {base_name}:")
             for element_name, location, uniform_type, size, is_array in elements:
                 type_str = self.get_gl_type_string(uniform_type)
-                logger.info(f"    {element_name} (type: {type_str}, location: {location})")
+                logger.info(
+                    f"    {element_name} (type: {type_str}, location: {location})"
+                )
 
     def print_registered_uniform_blocks(self) -> None:
         """
@@ -782,4 +922,6 @@ class ShaderProgram:
         if self._registered_uniform_blocks:
             logger.info("  Registered uniform blocks:")
             for name, data in self._registered_uniform_blocks.items():
-                logger.info(f"    {name} (index: {data['loc']}, buffer: {data['buffer']})")
+                logger.info(
+                    f"    {name} (index: {data['loc']}, buffer: {data['buffer']})"
+                )

ncca/ngl/text.py

@@ -227,7 +227,9 @@ class _Text:
         ShaderLib.set_uniform("fontSize", 1.0)
         ShaderLib.set_uniform("textColour", 1.0, 1.0, 1.0, 1.0)
 
-    def render_text(self, font: str, x: int, y: int, text: str, colour: Vec3 = Vec3(1.0, 1.0, 1.0)) -> None:
+    def render_text(
+        self, font: str, x: int, y: int, text: str, colour: Vec3 = Vec3(1.0, 1.0, 1.0)
+    ) -> None:
         """
         Renders a string of text to the screen.
 
@@ -274,7 +276,9 @@ class _Text:
             gl.glActiveTexture(gl.GL_TEXTURE0)
             gl.glBindTexture(gl.GL_TEXTURE_2D, atlas.texture)
             ShaderLib.use(DefaultShader.TEXT)
-            ShaderLib.set_uniform("textColour", float(colour.x), float(colour.y), float(colour.z), 1.0)
+            ShaderLib.set_uniform(
+                "textColour", float(colour.x), float(colour.y), float(colour.z), 1.0
+            )
             # We are drawing one point per character
             vao.set_num_indices(len(render_data) // 8)
             vao.draw()
@@ -286,7 +290,9 @@ class _Text:
         if polygon_mode != gl.GL_FILL:
             gl.glPolygonMode(gl.GL_FRONT_AND_BACK, polygon_mode)
 
-    def _build_instances(self, font: str, text: str, start_x: int, start_y: int) -> List[float]:
+    def _build_instances(
+        self, font: str, text: str, start_x: int, start_y: int
+    ) -> List[float]:
         """
         Generates vertex attribute data for each character in a string.
 

ncca/ngl/vec2.py

@@ -305,7 +305,9 @@ 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):
         """

ncca/ngl/vec3.py

@@ -156,7 +156,11 @@ 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):
         """
@@ -169,7 +173,11 @@ 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):
         """
@@ -282,7 +290,9 @@ 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):
         """
@@ -314,11 +324,13 @@ 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):
         """
@@ -333,7 +345,9 @@ 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

@@ -192,10 +192,22 @@ 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.1.4.dist-info → ncca_ngl-0.1.6.dist-info}/METADATA

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

{ncca_ngl-0.1.4.dist-info → ncca_ngl-0.1.6.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=i01MBdh814MrDmPDvG4dPI6azBWZWTq212cfVNnKkR8,2308
-ncca/ngl/abstract_vao.py,sha256=fi7-BIfw1jefcXe09Qj2gGmnqqA9kzJK-hAwfG14Hrc,2068
+ncca/ngl/__init__.py,sha256=vnvVyQjWGkGEF1mCIJRfa53GmkKdD4Dn3oQIOWmBeJc,2497
+ncca/ngl/abstract_vao.py,sha256=VLKp3pmPYK_dQgEImMOAQ0DufAswK_0H4DR4r8flp2U,2104
 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
@@ -32,11 +32,11 @@ ncca/ngl/obj.py,sha256=AGldNouHrkrDs2UhATClGkgo4dzr6lzArR4YeCxQKmo,13667
 ncca/ngl/plane.py,sha256=96WuGzexYKhoeRVevGP2pZcustt9fzyyAjuwJHT25tk,1299
 ncca/ngl/primitives.py,sha256=G4X5kPROgcO2hZf8YkYvviS5C2kPLXrlSerJUdD6Fog,22575
 ncca/ngl/pyside_event_handling_mixin.py,sha256=L8obXeTp-g2Va2eXyd1hnmSp-sY7p4GX6EcFYRnH1F4,10588
-ncca/ngl/quaternion.py,sha256=MeQ-oxufo96TJ1GusRdpaHJsjfD6hG1ADsqTiBbHxlM,3814
+ncca/ngl/quaternion.py,sha256=agmbW8i125FyLOV2Z9SpTY5yQwmnnm0rxQawwHqq1YI,3858
 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
-ncca/ngl/shader_program.py,sha256=Yuq7RMsa__MWWZWDFz1J7g9Z9Gi2CjTq9y2F0Qf9rhk,27959
+ncca/ngl/shader_program.py,sha256=WNEUOl4N4giC6caC0uMXm5ikDUtzCuZl7dqZl4M7p6k,33655
 ncca/ngl/shaders/checker_fragment.glsl,sha256=2hJH8yOJxLH5DdDdS15C3uom4o4YsiBle0fIYLkx9jI,640
 ncca/ngl/shaders/checker_vertex.glsl,sha256=G90GDAY5yEsdYMHhpZhWTmFFx_jfpDUexam-vpuVrXo,411
 ncca/ngl/shaders/colour_fragment.glsl,sha256=Y8CeWyDyQAK7u3-rQhURO6Ee3ibturZR3B75e5vcb2U,118
@@ -48,17 +48,17 @@ ncca/ngl/shaders/text_geometry.glsl,sha256=OTLdn4pdZj2BOMh33rE6JBfQ9SHQ1L1e8qn3H
 ncca/ngl/shaders/text_vertex.glsl,sha256=uPym1x87SJOd0E3zPN1Fx44warJ6IYfvhzPQEtLOO3w,289
 ncca/ngl/simple_index_vao.py,sha256=1IVy1WQH4V8_viZbRoIMbDRJsiH7iAhw0GEWUV9KpAU,2338
 ncca/ngl/simple_vao.py,sha256=jfU2O3yliaM6iWNvfcRbjQ6o2_IVSPrOR3GthDiul6Q,1419
-ncca/ngl/text.py,sha256=6vIfMKuP3WWSehR9RDK7YF_jgxKz_istVv8dSlPMjYo,13550
+ncca/ngl/text.py,sha256=yWNfKHnuWn0bxbwhW1H-EkRZ7bEM9DAyjES16cxTnME,13608
 ncca/ngl/texture.py,sha256=OgBBEItgUDohCsVWgmjEWcQWBJaXl9w070PTOOywPx4,2303
 ncca/ngl/transform.py,sha256=_PibgtFoU_exfvQUWucmts0WF5OreSTNbftvSa3zT8g,2938
 ncca/ngl/util.py,sha256=RLgGmxTq4gzlMKdAfLrO3gtV8VUSP5WtQK4hyLV6waQ,3558
 ncca/ngl/vao_factory.py,sha256=v87VfrUMaoqcsE-CS9kM7h5Fyk_e0LGl_iA6xqaomPg,930
-ncca/ngl/vec2.py,sha256=hJ0RWBxmeh-OOro_Y9lKocgiuu0f9vxp6L2_6vKfwUQ,10331
+ncca/ngl/vec2.py,sha256=3bhd03y5E3HRnBdXJZ4xMsTMMAte5IEr6u4qqWT_UL4,10361
 ncca/ngl/vec2_array.py,sha256=7QRgXh75fORsmNnSnNxNQWk6_rnDgfmRX3tmJZ4ES9E,3420
-ncca/ngl/vec3.py,sha256=q4HI4y4Xk3lTdlB8YdF4T2mCdwK2jXRattjDHlJi7vg,12265
+ncca/ngl/vec3.py,sha256=ntgqB3sc_jzcGO5vlHKgDqloOoMkykVcWPxpYdWFy5Q,12449
 ncca/ngl/vec3_array.py,sha256=fLRC8k0TwcaU7CnR2GmJ0prud4dcvvUX0JTbQH_2W3Y,3535
-ncca/ngl/vec4.py,sha256=zF0zw5EO4UE7EmqN30LPR3QQfaMcA1VcMID8CZALDiU,6740
+ncca/ngl/vec4.py,sha256=95b7yr82JtC3FqVDC8Hwn3wzPmVzSYTDCR1A6h_w9RM,6884
 ncca/ngl/vec4_array.py,sha256=PSJXfG0g2AT4oQCLHiVAP6EC5n7vMXRQy0N1rGvv1iw,3426
-ncca_ngl-0.1.4.dist-info/WHEEL,sha256=NHRAbdxxzyL9K3IO2LjmlNqKSyPZnKv2BD16YYVKo18,79
-ncca_ngl-0.1.4.dist-info/METADATA,sha256=KYfa9uhviMmF1MyM6yabGza0uQAuDpXm1N6BFSUKK1I,1596
-ncca_ngl-0.1.4.dist-info/RECORD,,
+ncca_ngl-0.1.6.dist-info/WHEEL,sha256=NHRAbdxxzyL9K3IO2LjmlNqKSyPZnKv2BD16YYVKo18,79
+ncca_ngl-0.1.6.dist-info/METADATA,sha256=Mu1XM1Y4C8JaSvpNJVa_ZYSEJHiecu7jWdSSk6uemPQ,1596
+ncca_ngl-0.1.6.dist-info/RECORD,,