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

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

@@ -3,6 +3,7 @@
 Most of these functions are based on functions found in other libraries such as GLM, NGL or GLU
 """
 
+import enum
 import math
 
 from .mat4 import Mat4
@@ -44,7 +45,32 @@ def look_at(eye, look, up):
     return result
 
 
-def perspective(fov, aspect, near, far):
+class PerspMode(enum.Enum):
+    OpenGL = "OpenGL"
+    WebGPU = "WebGPU"
+    Vulkan = "Vulkan"
+
+
+def perspective(
+    fov: float,
+    aspect: float,
+    near: float,
+    far: float,
+    mode: PerspMode = PerspMode.OpenGL,
+) -> Mat4:
+    """
+    Calculate a perspective matrix for various 3D graphics API's default mode is OpenGL but will covert for Vulkan and Web GPU if
+    required.
+
+    Args :
+        fov : float - Field of view angle in degrees.
+        aspect : float - Aspect ratio of the viewport.
+        near : float - Near clipping plane distance.
+        far : float - Far clipping plane distance.
+
+    Returns:
+        Mat4 - The perspective matrix.
+    """
     m = Mat4.zero()  # as per glm
     _range = math.tan(math.radians(fov / 2.0)) * near
     left = -_range * aspect
@@ -53,34 +79,36 @@ def perspective(fov, aspect, near, far):
     top = _range
     m.m[0][0] = (2.0 * near) / (right - left)
     m.m[1][1] = (2.0 * near) / (top - bottom)
-    m.m[2][2] = -(far + near) / (far - near)
-    m.m[2][3] = -1.0
-    m.m[3][2] = -(2.0 * far * near) / (far - near)
+    match mode:
+        case PerspMode.OpenGL:
+            m.m[2][2] = -(far + near) / (far - near)
+            m.m[2][3] = -1.0
+            m.m[3][2] = -(2.0 * far * near) / (far - near)
+
+        # This ensures the clip space Z range is [0, 1] as required by Vulkan and WebGPU.
+        case PerspMode.WebGPU | PerspMode.Vulkan:
+            m.m[2][2] = -far / (far - near)
+            m.m[2][3] = -1.0
+            m.m[3][2] = -(far * near) / (far - near)
     return m
 
 
-def ortho(left, right, bottom, top, near, far):
-    """Create an orthographic projection matrix."""
+def ortho(left, right, bottom, top, near, far, mode=PerspMode.OpenGL):
     m = Mat4.identity()
     m.m[0][0] = 2.0 / (right - left)
     m.m[1][1] = 2.0 / (top - bottom)
-    m.m[2][2] = -2.0 / (far - near)
+    match mode:
+        case PerspMode.OpenGL:
+            m.m[2][2] = -2.0 / (far - near)
+            m.m[3][2] = -(far + near) / (far - near)
+        case PerspMode.WebGPU | PerspMode.Vulkan:
+            m.m[2][2] = -1.0 / (far - near)
+            m.m[3][2] = -near / (far - near)
     m.m[3][0] = -(right + left) / (right - left)
     m.m[3][1] = -(top + bottom) / (top - bottom)
-    m.m[3][2] = -(far + near) / (far - near)
     return m
 
 
-# Mat4 result(1.0f);
-#   result.m_00= 2.0f / (_right - _left);
-#   result.m_11= 2.0f / (_top - _bottom);
-#   result.m_22= - 2.0f / (_zFar - _zNear);
-#   result.m_30= - (_right + _left) / (_right - _left);
-#   result.m_31= - (_top + _bottom) / (_top - _bottom);
-#   result.m_32= - (_zFar + _zNear) / (_zFar - _zNear);
-#   return result;
-
-
 def frustum(left, right, bottom, top, near, far):
     """Create a frustum projection matrix."""
     m = Mat4.zero()

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.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: ncca-ngl
-Version: 0.1.4
+Version: 0.2.1
 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.2.1.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=tyDe5m-1jd51kIOU-f2m1kU0XU10mebwrQ3td0Wdhko,2543
+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
@@ -30,13 +30,14 @@ ncca/ngl/mat4.py,sha256=eGvmLfw_wwKuuVh29wAKrvSZJB41jgmcYV5EufzyXbo,17273
 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/primitives.py,sha256=G4X5kPROgcO2hZf8YkYvviS5C2kPLXrlSerJUdD6Fog,22575
+ncca/ngl/prim_data.py,sha256=Y-Y748_3-VgimuUlbengPyJvZIJQAPBFmnlMbsLPCVU,18853
+ncca/ngl/primitives.py,sha256=YitjEsxDKo94mLeYclDOeG41ZVr9VM9TGhMCiKqGAgs,7651
 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 +49,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/util.py,sha256=8jp5vTVuGfVHMSktFEubtoaQ8SvLIQtM2UNbUeMTOFk,4372
 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.2.1.dist-info/WHEEL,sha256=eh7sammvW2TypMMMGKgsM83HyA_3qQ5Lgg3ynoecH3M,79
+ncca_ngl-0.2.1.dist-info/METADATA,sha256=DvVhD66ulcT-u9WQEmfkzZtGy2iaQstB_9dEM_xK_Xo,1596
+ncca_ngl-0.2.1.dist-info/RECORD,,

{ncca_ngl-0.1.4.dist-info → ncca_ngl-0.2.1.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: uv 0.8.14
+Generator: uv 0.8.24
 Root-Is-Purelib: true
 Tag: py3-none-any