ncca-ngl 0.1.1__py3-none-any.whl → 0.1.2__py3-none-any.whl

ncca/ngl/vec2_array.py

@@ -0,0 +1,106 @@
+"""
+A container for ngl.Vec2 objects that mimics some of the behavior of a std::vector
+"""
+
+import numpy as np
+
+from .vec2 import Vec2
+
+
+class Vec2Array:
+    """
+    A class to hold a list of Vec2 objects and perform operations on them.
+    """
+
+    def __init__(self, values=None):
+        """
+        Initializes the Vec2Array.
+
+        Args:
+            values (iterable, optional): An iterable of Vec2 objects. Defaults to None.
+        """
+        self._data = []
+        if values is not None:
+            for v in values:
+                if not isinstance(v, Vec2):
+                    raise TypeError("All elements must be of type Vec2")
+                self._data.append(v)
+
+    def __getitem__(self, index):
+        """
+        Get the Vec2 at the specified index.
+
+        Args:
+            index (int): The index of the element.
+
+        Returns:
+            Vec2: The Vec2 object at the given index.
+        """
+        return self._data[index]
+
+    def __len__(self):
+        """
+        Return the number of elements in the array.
+        """
+        return len(self._data)
+
+    def __iter__(self):
+        """
+        Return an iterator for the array.
+        """
+        return iter(self._data)
+
+    def append(self, value):
+        """
+        Append a Vec2 object to the array.
+
+        Args:
+            value (Vec2): The Vec2 object to append.
+        """
+        if not isinstance(value, Vec2):
+            raise TypeError("Only Vec2 objects can be appended")
+        self._data.append(value)
+
+    def extend(self, values):
+        """
+        Extend the array with a list of Vec2 objects.
+
+        Args:
+            values (list): A list of Vec2 objects to extend.
+        """
+        if not all(isinstance(v, Vec2) for v in values):
+            raise TypeError("All elements must be of type Vec2")
+        self._data.extend(values)
+
+    def to_list(self):
+        """
+        Convert the array of Vec2 objects to a single flat list of floats.
+
+        Returns:
+            list: A list of x, y components concatenated.
+        """
+        return [comp for vec in self._data for comp in vec]
+
+    def to_numpy(self):
+        """
+        Convert the array of Vec2 objects to a numpy array.
+
+        Returns:
+            numpy.ndarray: A numpy array of the vector data.
+        """
+        return np.array(self.to_list(), dtype=np.float32)
+
+    def __repr__(self):
+        return f"Vec2Array({self._data!r})"
+
+    def __str__(self):
+        return str(self._data)
+
+    def sizeof(self):
+        """
+        Return the size of the array in bytes.
+
+        Returns:
+            int: The size of the array in bytes.
+        """
+        return len(self._data) * Vec2.sizeof()

ncca/ngl/vec3.py

@@ -0,0 +1,401 @@
+"""
+Simple float only Vec3 class for 3D graphics, very similar to the pyngl ones
+"""
+
+import ctypes
+import math
+
+import numpy as np
+
+from .util import clamp
+
+
+class Vec3:
+    """
+    A simple 3D vector class for 3D graphics, I use slots to fix the attributes to x,y,z
+    Attributes:
+        x (float): The x-coordinate of the vector.
+        y (float): The y-coordinate of the vector.
+        z (float): The z-coordinate of the vector.
+
+    """
+
+    __slots__ = ["_x", "_y", "_z"]  # fix the attributes to x,y,z
+
+    def __init__(self, x=0.0, y=0.0, z=0.0):
+        """
+        Initializes a new instance of the Vec3 class.
+
+        Args:
+            x (float, optional): The x-coordinate of the vector. Defaults to 0.0.
+            y (float, optional): The y-coordinate of the vector. Defaults to 0.0.
+            z (float, optional): The z-coordinate of the vector. Defaults to 0.0.
+        """
+        self._x = x  # x component of vector : float
+        self._y = y  # y component of vector : float
+        self._z = z  # z component of vector : float
+
+    @classmethod
+    def sizeof(cls):
+        return 3 * ctypes.sizeof(ctypes.c_float)
+
+    def __iter__(self):
+        """
+        Make the Vec3 class iterable.
+        Yields:
+            float: The x, y, and z components of the vector.
+        """
+        yield self.x
+        yield self.y
+        yield self.z
+
+    def __getitem__(self, index):
+        """
+        Get the component of the vector at the given index.
+        Args:
+            index (int): The index of the component (0 for x, 1 for y, 2 for z).
+        Returns:
+            float: The value of the component at the given index.
+        Raises:
+            IndexError: If the index is out of range.
+        """
+        components = [self.x, self.y, self.z]
+        try:
+            return components[index]
+        except IndexError:
+            raise IndexError("Index out of range. Valid indices are 0, 1, and 2.")
+
+    def _validate_and_set(self, v, name):
+        """
+        check if v is a float or int
+        Args:
+            v (number): The value to check.
+        Raises:
+            ValueError: If v is not a float or int.
+        """
+        if not isinstance(v, (int, float)):
+            raise ValueError("need float or int")
+        else:
+            setattr(self, name, v)
+
+    def clone(self) -> "Vec3":
+        """
+        Create a clone of the current vector.
+        Returns:
+            Vec3: A new instance of Vec3 with the same x, y, and z values.
+        """
+        return Vec3(self.x, self.y, self.z)
+
+    def __add__(self, rhs):
+        """
+        vector addition a+b
+
+        Args:
+            rhs (Vec3): The right-hand side vector to add.
+        Returns:
+            Vec3: A new vector that is the result of adding this vector and the rhs vector.
+        """
+        r = Vec3()
+        r.x = self.x + rhs.x
+        r.y = self.y + rhs.y
+        r.z = self.z + rhs.z
+        return r
+
+    def __iadd__(self, rhs):
+        """
+        vector addition a+=b
+
+        Args:
+            rhs (Vec3): The right-hand side vector to add.
+        Returns:
+            Vec3: returns this vector after adding the rhs vector.
+        """
+        self.x += rhs.x
+        self.y += rhs.y
+        self.z += rhs.z
+        return self
+
+    def __sub__(self, rhs):
+        """
+        vector subtraction a-b
+
+        Args:
+            rhs (Vec3): The right-hand side vector to subtract.
+        Returns:
+            Vec3: A new vector that is the result of subtracting this vector and the rhs vector.
+        """
+        r = Vec3()
+        r.x = self.x - rhs.x
+        r.y = self.y - rhs.y
+        r.z = self.z - rhs.z
+        return r
+
+    def __isub__(self, rhs):
+        """
+        vector subtraction a-=b
+
+        Args:
+            rhs (Vec3): The right-hand side vector to add.
+        Returns:
+            Vec3: returns this vector after subtracting the rhs vector.
+        """
+        self.x -= rhs.x
+        self.y -= rhs.y
+        self.z -= rhs.z
+        return self
+
+    def __eq__(self, rhs):
+        """
+        vector comparison a==b using math.isclose not we only compare to 6 decimal places
+        Args:
+            rhs (Vec3): The right-hand side vector to compare.
+        Returns:
+            bool: True if the vectors are close, False otherwise.
+            NotImplemented: If the right-hand side is not a 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)
+
+    def __neq__(self, rhs):
+        """
+        vector comparison a!=b using math.isclose not we only compare to 6 decimal places
+        Args:
+            rhs (Vec3): The right-hand side vector to compare.
+        Returns:
+            bool: True if the vectors are not close, False otherwise.
+            NotImplemented: If the right-hand side is not a 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))
+
+    def __neg__(self):
+        """
+        negate a vector -a
+        """
+        self.x = -self.x
+        self.y = -self.y
+        self.z = -self.z
+        return self
+
+    def set(self, x, y, z):
+        """
+        set the x,y,z values of the vector
+        Args:
+            x (float): The x-coordinate of the vector.
+            y (float): The y-coordinate of the vector.
+            z (float): The z-coordinate of the vector.
+        Raises :
+            ValueError: if x,y,z are not float
+        """
+        try:
+            self.x = float(x)
+            self.y = float(y)
+            self.z = float(z)
+        except ValueError:
+            raise ValueError(f"Vec3.set {x=} {y=} {z=} all need to be float")
+
+    def dot(self, rhs):
+        """
+        dot product of two vectors a.b
+        Args:
+            rhs (Vec3): The right-hand side vector to dot product with.
+        """
+        return self.x * rhs.x + self.y * rhs.y + self.z * rhs.z
+
+    def length(self):
+        """
+        length of vector
+        Returns:
+            float: The length of the vector.
+        """
+        return math.sqrt(self.x**2 + self.y**2 + self.z**2)
+
+    def length_squared(self):
+        """
+        length of vector squared sometimes used to avoid the sqrt for performance
+        Returns:
+            float: The length of the vector squared
+        """
+        return self.x**2 + self.y**2 + self.z**2
+
+    def inner(self, rhs):
+        """
+        inner product of two vectors a.b
+        Args:
+            rhs (Vec3): The right-hand side vector to inner product with.
+        Returns:
+            float: The inner product of the two vectors.
+        """
+        return (self.x * rhs.x) + (self.y * rhs.y) + (self.z * rhs.z)
+
+    def null(self):
+        """
+        set the vector to zero
+        """
+        self.x = 0.0
+        self.y = 0.0
+        self.z = 0.0
+
+    def cross(self, rhs):
+        """
+        cross product of two vectors a x b
+        Args:
+            rhs (Vec3): The right-hand side vector to cross product with.
+        Returns:
+            Vec3: A new vector that is the result of the cross product.
+        """
+        return Vec3(
+            self.y * rhs.z - self.z * rhs.y,
+            self.z * rhs.x - self.x * rhs.z,
+            self.x * rhs.y - self.y * rhs.x,
+        )
+
+    def normalize(self):
+        """
+        normalize the vector to unit length
+        Returns:
+            Vec3: A new vector that is the result of normalizing this vector.
+        Raises:
+            ZeroDivisionError: If the length of the vector is zero.
+        """
+        vector_length = self.length()
+        try:
+            self.x /= vector_length
+            self.y /= vector_length
+            self.z /= vector_length
+        except ZeroDivisionError:
+            raise ZeroDivisionError(
+                f"Vec3.normalize {vector_length} length is zero most likely calling normalize on a zero vector"
+            )
+        return self
+
+    def reflect(self, n):
+        """
+        reflect a vector about a normal
+        Args:
+            n (Vec3): The normal to reflect about.
+        Returns:
+            Vec3: A new vector that is the result of reflecting this vector about the normal.
+        """
+        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)
+
+    def clamp(self, low, high):
+        """
+        clamp the vector to a range
+        Args:
+            low (float): The low end of the range.
+            high (float): The high end of the range.
+
+        """
+        self.x = clamp(self.x, low, high)
+        self.y = clamp(self.y, low, high)
+        self.z = clamp(self.z, low, high)
+
+    def __repr__(self):
+        "object representation for debugging"
+        return f"Vec3 [{self.x},{self.y},{self.z}]"
+
+    def __str__(self):
+        "object representation for debugging"
+        return f"[{self.x},{self.y},{self.z}]"
+
+    def outer(self, rhs):
+        """
+        outer product of two vectors a x b
+        Args:
+            rhs (Vec3): The right-hand side vector to outer product with.
+        Returns:
+            Mat3: A new 3x3 matrix that is the result of the outer product.
+        """
+        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],
+        ])
+
+    def __mul__(self, rhs):
+        """
+        piecewise scalar multiplication
+        Args:
+            rhs (float): The scalar to multiply by.
+        Returns:
+            Vec3: A new vector that is the result of multiplying this vector by the scalar.
+        Raises:
+            ValueError: If the right-hand side is not a float.
+        """
+        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=}")
+
+    def __rmul__(self, rhs):
+        """
+        piecewise scalar multiplication
+        Args:
+            rhs (float): The scalar to multiply by.
+        Returns:
+            Vec3: A new vector that is the result of multiplying this vector by the scalar.
+        Raises:
+            ValueError: If the right-hand side is not a float.
+        """
+        return self * rhs
+
+    def __truediv__(self, rhs):
+        """
+        piecewise scalar division
+        Args:
+            rhs (float): The scalar to divide by.
+        Returns:
+            Vec3: A new vector that is the result of dividing this vector by the scalar.
+        Raises:
+            ValueError: If the right-hand side is not a float.
+        """
+        if isinstance(rhs, (float, int)):
+            return Vec3(self.x / rhs, self.y / rhs, self.z / rhs)
+        elif isinstance(rhs, Vec3):
+            return Vec3(self.x / rhs.x, self.y / rhs.y, self.z / rhs.z)
+        else:
+            raise ValueError(f"can only do piecewise division with a scalar {rhs=}")
+
+    def __matmul__(self, rhs):
+        """
+        "Vec3 @ Mat3 matrix multiplication"
+        Args:
+            rhs (Mat3): The matrix to multiply by.
+        Returns:
+            Vec3: A new vector that is the result of multiplying this vector by the matrix.
+        """
+        return Vec3(
+            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],
+        )
+
+    def to_list(self):
+        return [self.x, self.y, self.z]
+
+    def to_numpy(self):
+        return np.array([self.x, self.y, self.z])
+
+
+# Helper function to create properties
+def _create_property(attr_name):
+    def getter(self):
+        return getattr(self, f"_{attr_name}")
+
+    def setter(self, value):
+        self._validate_and_set(value, f"_{attr_name}")
+
+    return property(getter, setter)
+
+
+# Dynamically add properties for x, y, z
+for attr in ["x", "y", "z"]:
+    setattr(Vec3, attr, _create_property(attr))

ncca/ngl/vec3_array.py

@@ -0,0 +1,110 @@
+"""
+A container for ngl.Vec3 objects that mimics some of the behavior of a std::vector
+"""
+
+import numpy as np
+
+from .vec3 import Vec3
+
+
+class Vec3Array:
+    """
+    A class to hold a list of Vec3 objects and perform operations on them.
+    """
+
+    def __init__(self, values=None):
+        """
+        Initializes the Vec3Array.
+
+        Args:
+            values (iterable, optional): An iterable of Vec3 objects. Defaults to None.
+        """
+        self._data = []
+        if values is not None:
+            for v in values:
+                if not isinstance(v, Vec3):
+                    raise TypeError("All elements must be of type Vec3")
+                self._data.append(v)
+
+    def __getitem__(self, index):
+        """
+        Get the Vec3 at the specified index.
+
+        Args:
+            index (int): The index of the element.
+
+        Returns:
+            Vec3: The Vec3 object at the given index.
+        """
+        return self._data[index]
+
+    def __len__(self):
+        """
+        Return the number of elements in the array.
+        """
+        return len(self._data)
+
+    def __iter__(self):
+        """
+        Return an iterator for the array.
+        """
+        return iter(self._data)
+
+    def append(self, value):
+        """
+        Append a Vec3 object to the array.
+
+        Args:
+            value (Vec3): The Vec3 object to append.
+        """
+        if not isinstance(value, Vec3):
+            raise TypeError("Only Vec3 objects can be appended")
+        self._data.append(value)
+
+    def extend(self, values):
+        """
+        Extend the array by appending elements from the iterable.
+
+        Args:
+            values (iterable): An iterable of Vec3 objects to append.
+
+        Raises:
+            TypeError: If any element in values is not a Vec3.
+        """
+        for v in values:
+            if not isinstance(v, Vec3):
+                raise TypeError("All elements must be of type Vec3")
+            self._data.append(v)
+
+    def to_list(self):
+        """
+        Convert the array of Vec3 objects to a single flat list of floats.
+
+        Returns:
+            list: A list of x, y, z components concatenated.
+        """
+        return [comp for vec in self._data for comp in vec]
+
+    def to_numpy(self):
+        """
+        Convert the array of Vec3 objects to a numpy array.
+
+        Returns:
+            numpy.ndarray: A numpy array of the vector data.
+        """
+        return np.array(self.to_list(), dtype=np.float32)
+
+    def __repr__(self):
+        return f"Vec3Array({self._data!r})"
+
+    def __str__(self):
+        return str(self._data)
+
+    def sizeof(self):
+        """
+        Return the size of the array in bytes.
+
+        Returns:
+            int: The size of the array in bytes.
+        """
+        return len(self._data) * Vec3.sizeof()