ncca-ngl 0.3.4__py3-none-any.whl → 0.5.0__py3-none-any.whl

ncca/ngl/prim_data.py

@@ -1,13 +1,15 @@
-import enum
+from enum import Enum
 from pathlib import Path
-from typing import Union
 
 import numpy as np
 
 from .vec3 import Vec3
 
+RAD_POS = "Radius must be positive"
+NON_NEG = "Height must be non-negative"
 
-class Prims(enum.Enum):
+
+class Prims(Enum):
     """Enum for the default primitives that can be loaded."""
 
     BUDDHA = "buddah"
@@ -346,64 +348,43 @@ class PrimData:
         return np.array(data, dtype=np.float32)
 
     @staticmethod
-    def capsule(radius: float, height: float, precision: int) -> np.ndarray:
-        """
-        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
-        """
-        if radius <= 0.0:
-            raise ValueError("Radius must be positive")
-        if height < 0.0:
-            raise ValueError("Height must be non-negative")
-        if precision < 4:
-            precision = 4
-
-        data = []
-        h = height / 2.0
-        ang = np.pi / precision
-
-        # Cylinder sides
+    def _add_cylinder_sides(data: list, radius: float, h: float, ang: float, precision: int):
+        """Generates cylinder side geometry."""
         for i in range(2 * precision):
             c = radius * np.cos(ang * i)
             c1 = radius * np.cos(ang * (i + 1))
             s = radius * np.sin(ang * i)
             s1 = radius * np.sin(ang * (i + 1))
-
             # normals for cylinder sides
             nc = np.cos(ang * i)
             ns = np.sin(ang * i)
             nc1 = np.cos(ang * (i + 1))
             ns1 = np.sin(ang * (i + 1))
-
             # side top
             data.extend([c1, h, s1, nc1, 0.0, ns1, 0.0, 0.0])
             data.extend([c, h, s, nc, 0.0, ns, 0.0, 0.0])
             data.extend([c, -h, s, nc, 0.0, ns, 0.0, 0.0])
-
             # side bot
             data.extend([c, -h, s, nc, 0.0, ns, 0.0, 0.0])
             data.extend([c1, -h, s1, nc1, 0.0, ns1, 0.0, 0.0])
             data.extend([c1, h, s1, nc1, 0.0, ns1, 0.0, 0.0])
-        # Hemispherical caps
+
+    @staticmethod
+    def _add_hemispherical_caps(data: list, radius: float, h: float, ang: float, precision: int):
+        """Generates hemispherical cap geometry."""
         for i in range(2 * precision):
             # longitude
             s = -np.sin(ang * i)
             s1 = -np.sin(ang * (i + 1))
             c = np.cos(ang * i)
             c1 = np.cos(ang * (i + 1))
-
             for j in range(precision + 1):
                 o = h if j < precision / 2 else -h
-
                 # latitude
                 sb = radius * np.sin(ang * j)
                 sb1 = radius * np.sin(ang * (j + 1))
                 cb = radius * np.cos(ang * j)
                 cb1 = radius * np.cos(ang * (j + 1))
-
                 if j != precision - 1:
                     nx, ny, nz = sb * c, cb, sb * s
                     data.extend([nx, ny + o, nz, nx, ny, nz, 0.0, 0.0])
@@ -411,7 +392,6 @@ class PrimData:
                     data.extend([nx, ny + o, nz, nx, ny, nz, 0.0, 0.0])
                     nx, ny, nz = sb1 * c1, cb1, sb1 * s1
                     data.extend([nx, ny + o, nz, nx, ny, nz, 0.0, 0.0])
-
                 if j != 0:
                     nx, ny, nz = sb * c, cb, sb * s
                     data.extend([nx, ny + o, nz, nx, ny, nz, 0.0, 0.0])
@@ -420,6 +400,32 @@ class PrimData:
                     nx, ny, nz = sb * c1, cb, sb * s1
                     data.extend([nx, ny + o, nz, nx, ny, nz, 0.0, 0.0])
 
+    @staticmethod
+    def capsule(radius: float, height: float, precision: int) -> np.ndarray:
+        """
+        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
+        """
+        if radius <= 0.0:
+            raise ValueError(RAD_POS)
+        if height < 0.0:
+            raise ValueError(NON_NEG)
+        if precision < 4:
+            precision = 4
+
+        data = []
+        h = height / 2.0
+        ang = np.pi / precision
+
+        # Cylinder sides
+        PrimData._add_cylinder_sides(data, radius, h, ang, precision)
+
+        # Hemispherical caps
+        PrimData._add_hemispherical_caps(data, radius, h, ang, precision)
+
         return np.array(data, dtype=np.float32)
 
     @staticmethod
@@ -430,9 +436,9 @@ class PrimData:
         This method generates the cylinder walls, but not the top and bottom caps.
         """
         if radius <= 0.0:
-            raise ValueError("Radius must be positive")
+            raise ValueError(RAD_POS)
         if height < 0.0:
-            raise ValueError("Height must be non-negative")
+            raise ValueError(NON_NEG)
         if slices < 3:
             slices = 3
         if stacks < 1:
@@ -486,7 +492,7 @@ class PrimData:
             slices: The number of slices to divide the disk into.
         """
         if radius <= 0.0:
-            raise ValueError("Radius must be positive")
+            raise ValueError(RAD_POS)
         if slices < 3:
             slices = 3
 
@@ -540,7 +546,7 @@ class PrimData:
             rings: The number of rings for the torus.
         """
         if minor_radius <= 0 or major_radius <= 0:
-            raise ValueError("Radii must be positive")
+            raise ValueError(RAD_POS)
         if sides < 3 or rings < 3:
             raise ValueError("Sides and rings must be at least 3")
 
@@ -602,7 +608,7 @@ class PrimData:
         return np.array(data, dtype=np.float32)
 
     @staticmethod
-    def primitive(name: Union[str, enum]) -> np.ndarray:
+    def primitive(name: str | Enum) -> np.ndarray:
         prim_folder = Path(__file__).parent / "PrimData"
         prims = np.load(prim_folder / "Primitives.npz")
         if isinstance(name, Prims):

ncca/ngl/primitives.py

@@ -6,7 +6,7 @@ We need to create the data first which is stored in a map as part of the class,
 which will generate a pipeline for this object and draw into the current context.
 """
 
-from typing import Dict, Union
+from typing import Dict
 
 import numpy as np
 import OpenGL.GL as gl
@@ -104,7 +104,7 @@ class Primitives:
             cls._loaded = True
 
     @classmethod
-    def draw(cls, name: Union[str, Prims]) -> None:
+    def draw(cls, name: str | Prims) -> None:
         """
         Draws the specified primitive.
 

ncca/ngl/pyside_event_handling_mixin.py

@@ -22,22 +22,6 @@ from PySide6.QtCore import Qt
 from .vec3 import Vec3
 
 
-class EventHandlingTarget(Protocol):
-    """
-    Protocol defining the interface that classes using EventHandlingMixin must implement.
-
-    This ensures that the mixin has access to the necessary methods and attributes.
-    """
-
-    def update(self) -> None:
-        """Trigger a redraw of the window."""
-        ...
-
-    def close(self) -> None:
-        """Close the window."""
-        ...
-
-
 class PySideEventHandlingMixin:
     """
     Mixin class providing standard event handling for PyNGL applications.
@@ -96,32 +80,12 @@ class PySideEventHandlingMixin:
         self.INCREMENT = self.translation_sensitivity
         self.ZOOM = self.zoom_sensitivity
 
-    # def sync_legacy_attributes(self) -> None:
-    #     """
-    #     Synchronize legacy attribute names with new ones.
-    #     Call this if you modify the legacy attributes directly.
-    #     """
-    #     self.spin_x_face = self.spinXFace
-    #     self.spin_y_face = self.spinYFace
-    #     self.model_position = self.modelPos
-    #     self.original_x_rotation = self.origX
-    #     self.original_y_rotation = self.origY
-    #     self.original_x_pos = self.origXPos
-    #     self.original_y_pos = self.origYPos
-    #     self.translation_sensitivity = self.INCREMENT
-    #     self.zoom_sensitivity = self.ZOOM
-
     def reset_camera(self) -> None:
         """Reset camera rotation and model position to defaults."""
         self.spin_x_face = 0
         self.spin_y_face = 0
         self.model_position.set(0, 0, 0)
 
-        # # Sync legacy attributes
-        # self.spinXFace = 0
-        # self.spinYFace = 0
-        # self.modelPos.set(0, 0, 0)
-
     def keyPressEvent(self, event) -> None:
         """
         Handle keyboard press events with common shortcuts.
@@ -175,12 +139,6 @@ class PySideEventHandlingMixin:
             self.original_x_rotation = position.x()
             self.original_y_rotation = position.y()
 
-            # # Sync legacy attributes
-            # self.spinXFace = self.spin_x_face
-            # self.spinYFace = self.spin_y_face
-            # self.origX = self.original_x_rotation
-            # self.origY = self.original_y_rotation
-
             self.update()
 
         # Handle translation with right mouse button
@@ -194,11 +152,6 @@ class PySideEventHandlingMixin:
             self.model_position.x += self.translation_sensitivity * diff_x
             self.model_position.y -= self.translation_sensitivity * diff_y
 
-            # # Sync legacy attributes
-            # self.origXPos = self.original_x_pos
-            # self.origYPos = self.original_y_pos
-            # self.modelPos = self.model_position
-
             self.update()
 
     def mousePressEvent(self, event) -> None:
@@ -218,19 +171,11 @@ class PySideEventHandlingMixin:
             self.original_y_rotation = position.y()
             self.rotate = True
 
-            # # Sync legacy attributes
-            # self.origX = self.original_x_rotation
-            # self.origY = self.original_y_rotation
-
         elif event.button() == Qt.RightButton:
             self.original_x_pos = position.x()
             self.original_y_pos = position.y()
             self.translate = True
 
-            # # Sync legacy attributes
-            # self.origXPos = self.original_x_pos
-            # self.origYPos = self.original_y_pos
-
     def mouseReleaseEvent(self, event) -> None:
         """
         Handle mouse button release events to stop rotation or translation.
@@ -262,57 +207,4 @@ class PySideEventHandlingMixin:
         elif delta < 0:
             self.model_position.z -= self.zoom_sensitivity
 
-        # # Sync legacy attributes
-        # self.modelPos = self.model_position
-
         self.update()
-
-    def get_camera_state(self) -> dict:
-        """
-        Get the current camera state for serialization or debugging.
-
-        Returns:
-            Dictionary containing current camera state
-        """
-        return {
-            "spin_x_face": self.spin_x_face,
-            "spin_y_face": self.spin_y_face,
-            "model_position": [
-                self.model_position.x,
-                self.model_position.y,
-                self.model_position.z,
-            ],
-            "rotation_sensitivity": self.rotation_sensitivity,
-            "translation_sensitivity": self.translation_sensitivity,
-            "zoom_sensitivity": self.zoom_sensitivity,
-        }
-
-    def set_camera_state(self, state: dict) -> None:
-        """
-        Restore camera state from a dictionary.
-
-        Args:
-            state: Dictionary containing camera state (from get_camera_state())
-        """
-        self.spin_x_face = state.get("spin_x_face", 0)
-        self.spin_y_face = state.get("spin_y_face", 0)
-
-        pos = state.get("model_position", [0, 0, 0])
-        # Handle cases where pos might have fewer than 3 elements
-        x = pos[0] if len(pos) > 0 else 0
-        y = pos[1] if len(pos) > 1 else 0
-        z = pos[2] if len(pos) > 2 else 0
-        self.model_position.set(x, y, z)
-
-        self.rotation_sensitivity = state.get(
-            "rotation_sensitivity", self.DEFAULT_ROTATION_SENSITIVITY
-        )
-        self.translation_sensitivity = state.get(
-            "translation_sensitivity", self.DEFAULT_TRANSLATION_SENSITIVITY
-        )
-        self.zoom_sensitivity = state.get(
-            "zoom_sensitivity", self.DEFAULT_ZOOM_SENSITIVITY
-        )
-
-        # # Sync legacy attributes
-        # self.sync_legacy_attributes()

ncca/ngl/quaternion.py

@@ -1,5 +1,6 @@
 """
 A simple Quaternion class for use in NCCA Python
+NumPy-based implementation for efficient operations
 Attributes:
     s (float): The scalar part of the quaternion.
     x (float): The x-coordinate of the vector part of the quaternion.
@@ -9,12 +10,14 @@ Attributes:
 
 import math
 
+import numpy as np
+
 from .mat4 import Mat4
 from .vec3 import Vec3
 
 
 class Quaternion:
-    __slots__ = ["s", "x", "y", "z"]  # fix the attributes to s x,y,z
+    __slots__ = ["_data"]  # Store as [s, x, y, z]
 
     def __init__(self, s: float = 1.0, x: float = 0, y: float = 0, z: float = 0):
         """
@@ -25,12 +28,8 @@ class Quaternion:
             x (float): The x-coordinate of the vector part of the quaternion.
             y (float): The y-coordinate of the vector part of the quaternion.
             z (float): The z-coordinate of the vector part of the quaternion.
-
         """
-        self.s = float(s)
-        self.x = float(x)
-        self.y = float(y)
-        self.z = float(z)
+        self._data = np.array([float(s), float(x), float(y), float(z)], dtype=np.float64)
 
     @staticmethod
     def from_mat4(mat: "Mat4") -> "Quaternion":
@@ -42,7 +41,6 @@ class Quaternion:
 
         Returns:
             Quaternion: A new Quaternion representing the rotation matrix.
-
         """
         matrix = mat.get_matrix()
         T = 1.0 + matrix[0] + matrix[5] + matrix[10]
@@ -58,14 +56,12 @@ class Quaternion:
             y = (matrix[4] + matrix[1]) / scale
             z = (matrix[2] + matrix[8]) / scale
             s = (matrix[6] - matrix[9]) / scale
-
         elif matrix[5] > matrix[10]:
             scale = math.sqrt(1.0 + matrix[5] - matrix[0] - matrix[10]) * 2.0
             x = (matrix[4] + matrix[1]) / scale
             y = 0.25 * scale
             z = (matrix[9] + matrix[6]) / scale
             s = (matrix[8] - matrix[2]) / scale
-
         else:
             scale = math.sqrt(1.0 + matrix[10] - matrix[0] - matrix[5]) * 2.0
             x = (matrix[8] + matrix[2]) / scale
@@ -97,38 +93,37 @@ 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)
+        result = Quaternion()
+        result._data = self._data + rhs._data
+        return result
 
     def __iadd__(self, rhs):
-        self.s += rhs.s
-        self.x += rhs.x
-        self.y += rhs.y
-        self.z += rhs.z
+        self._data += rhs._data
         return self
 
     def __sub__(self, rhs):
-        return Quaternion(self.s - rhs.s, self.x - rhs.x, self.y - rhs.y, self.z - rhs.z)
+        result = Quaternion()
+        result._data = self._data - rhs._data
+        return result
 
     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,
-    #     )
+        self._data -= rhs._data
+        return self
 
     def __mul__(self, rhs):
         if isinstance(rhs, Quaternion):
+            # Quaternion multiplication
+            s1, x1, y1, z1 = self._data
+            s2, x2, y2, z2 = rhs._data
+
             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,
+                s1 * s2 - x1 * x2 - y1 * y2 - z1 * z2,
+                s1 * x2 + x1 * s2 + y1 * z2 - z1 * y2,
+                s1 * y2 - x1 * z2 + y1 * s2 + z1 * x2,
+                s1 * z2 + x1 * y2 - y1 * x2 + z1 * s2,
             )
         elif isinstance(rhs, Vec3):
+            # Quaternion-vector multiplication (rotate vector by quaternion)
             qw = self.s
             qx = self.x
             qy = self.y
@@ -138,13 +133,13 @@ class Quaternion:
             vy = rhs.y
             vz = rhs.z
 
-            # pq
+            # pq (quaternion * pure quaternion from vector)
             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*
+            # pqp* (result * conjugate of quaternion)
             return Vec3(
                 -pw * qx + px * qw - py * qz + pz * qy,
                 -pw * qy + px * qz + py * qw - pz * qx,
@@ -152,12 +147,25 @@ class Quaternion:
             )
 
     def normalize(self):
-        length = math.sqrt(self.s * self.s + self.x * self.x + self.y * self.y + self.z * self.z)
+        """Normalize the quaternion to unit length"""
+        length = np.linalg.norm(self._data)
         if length > 0:
-            self.s /= length
-            self.x /= length
-            self.y /= length
-            self.z /= length
+            self._data /= length
+
+    def length(self):
+        """Return the length/magnitude of the quaternion"""
+        return np.linalg.norm(self._data)
+
+    def conjugate(self):
+        """Return the conjugate of the quaternion (s, -x, -y, -z)"""
+        result = Quaternion()
+        result._data = self._data.copy()
+        result._data[1:] *= -1  # Negate x, y, z components
+        return result
+
+    def dot(self, rhs):
+        """Dot product of two quaternions"""
+        return np.dot(self._data, rhs._data)
 
     def __str__(self) -> str:
         """
@@ -165,9 +173,34 @@ class Quaternion:
 
         Returns:
             str: A string representation of the Quaternion.
-
         """
         return f"Quaternion({self.s}, [{self.x}, {self.y}, {self.z}])"
 
     def __repr__(self) -> str:
         return f"Quaternion({self.s}, [{self.x}, {self.y}, {self.z}])"
+
+    def to_numpy(self):
+        """Return the quaternion as a numpy array [s, x, y, z]"""
+        return self._data.copy()
+
+    def to_list(self):
+        """Return the quaternion as a list [s, x, y, z]"""
+        return self._data.tolist()
+
+
+# Helper function to create properties
+def _create_property(index):
+    def getter(self):
+        return self._data[index]
+
+    def setter(self, value):
+        if not isinstance(value, (int, float, np.float32)):
+            raise ValueError("need float or int")
+        self._data[index] = value
+
+    return property(getter, setter)
+
+
+# Dynamically add properties for s, x, y, z, w
+for i, attr in enumerate(["s", "x", "y", "z"]):
+    setattr(Quaternion, attr, _create_property(i))

ncca/ngl/shader.py

@@ -111,119 +111,3 @@ class Shader:
         """
         self._source = shader_source
         gl.glShaderSource(self._id, self._source)
-
-
-# class ShaderProgram:
-#     def __init__(self, name: str, exit_on_error: bool = True):
-#         self._name = name
-#         self._exit_on_error = exit_on_error
-#         self._id = gl.glCreateProgram()
-#         self._shaders = []
-#         self._uniforms = {}
-
-#     def attach_shader(self, shader: Shader):
-#         gl.glAttachShader(self._id, shader._id)
-#         self._shaders.append(shader)
-
-#     def link(self) -> bool:
-#         gl.glLinkProgram(self._id)
-#         if gl.glGetProgramiv(self._id, gl.GL_LINK_STATUS) != gl.GL_TRUE:
-#             info = gl.glGetProgramInfoLog(self._id)
-#             print(f"Error linking program {self._name}: {info}")
-#             if self._exit_on_error:
-#                 exit()
-#             return False
-#         return True
-
-#     def use(self):
-#         gl.glUseProgram(self._id)
-
-#     def get_id(self) -> int:
-#         return self._id
-
-#     def get_uniform_location(self, name: str) -> int:
-#         if name not in self._uniforms:
-#             self._uniforms[name] = gl.glGetUniformLocation(self._id, name)
-#         return self._uniforms[name]
-
-#     def set_uniform(self, name: str, *value):
-#         loc = self.get_uniform_location(name)
-#         if loc != -1:
-#             if len(value) == 1:
-#                 if isinstance(value[0], int):
-#                     gl.glUniform1i(loc, value[0])
-#                 elif isinstance(value[0], float):
-#                     gl.glUniform1f(loc, value[0])
-#                 else:
-#                     try:
-#                         val = list(value[0])
-#                         if len(val) == 4:
-#                             gl.glUniformMatrix2fv(loc, 1, gl.GL_TRUE, (ctypes.c_float * 4)(*val))
-#                         elif len(val) == 9:
-#                             gl.glUniformMatrix3fv(loc, 1, gl.GL_TRUE, (ctypes.c_float * 9)(*val))
-#                         elif len(val) == 16:
-#                             gl.glUniformMatrix4fv(loc, 1, gl.GL_TRUE, (ctypes.c_float * 16)(*val))
-#                     except TypeError:
-#                         pass
-#             elif len(value) == 2:
-#                 gl.glUniform2f(loc, *value)
-#             elif len(value) == 3:
-#                 gl.glUniform3f(loc, *value)
-#             elif len(value) == 4:
-#                 gl.glUniform4f(loc, *value)
-
-#     def get_uniform_1f(self, name: str) -> float:
-#         loc = self.get_uniform_location(name)
-#         if loc != -1:
-#             result = (ctypes.c_float * 1)()
-#             gl.glGetUniformfv(self._id, loc, result)
-#             return result[0]
-#         return 0.0
-
-#     def get_uniform_2f(self, name: str) -> list[float]:
-#         loc = self.get_uniform_location(name)
-#         if loc != -1:
-#             result = (ctypes.c_float * 2)()
-#             gl.glGetUniformfv(self._id, loc, result)
-#             return list(result)
-#         return [0.0, 0.0]
-
-#     def get_uniform_3f(self, name: str) -> list[float]:
-#         loc = self.get_uniform_location(name)
-#         if loc != -1:
-#             result = (ctypes.c_float * 3)()
-#             gl.glGetUniformfv(self._id, loc, result)
-#             return list(result)
-#         return [0.0, 0.0, 0.0]
-
-#     def get_uniform_4f(self, name: str) -> list[float]:
-#         loc = self.get_uniform_location(name)
-#         if loc != -1:
-#             result = (ctypes.c_float * 4)()
-#             gl.glGetUniformfv(self._id, loc, result)
-#             return list(result)
-#         return [0.0, 0.0, 0.0, 0.0]
-
-#     def get_uniform_mat2(self, name: str) -> list[float]:
-#         loc = self.get_uniform_location(name)
-#         if loc != -1:
-#             result = (ctypes.c_float * 4)()
-#             gl.glGetUniformfv(self._id, loc, result)
-#             return list(result)
-#         return [0.0] * 4
-
-#     def get_uniform_mat3(self, name: str) -> list[float]:
-#         loc = self.get_uniform_location(name)
-#         if loc != -1:
-#             result = (ctypes.c_float * 9)()
-#             gl.glGetUniformfv(self._id, loc, result)
-#             return list(result)
-#         return [0.0] * 9
-
-#     def get_uniform_mat4(self, name: str) -> list[float]:
-#         loc = self.get_uniform_location(name)
-#         if loc != -1:
-#             result = (ctypes.c_float * 16)()
-#             gl.glGetUniformfv(self._id, loc, result)
-#             return list(result)
-#         return [0.0] * 16