ncca-ngl 0.3.5__py3-none-any.whl → 0.5.1__py3-none-any.whl

ncca/ngl/vec2.py

@@ -1,360 +1,117 @@
 """
 Simple float only Vec2 class for 3D graphics, very similar to the pyngl ones
+NumPy-based implementation with VectorBase inheritance for code reuse.
 """
 
-import ctypes
 import math
+from typing import Union
 
 import numpy as np
 
-from .util import clamp, hash_combine
+from .util import clamp
+from .vector_base import VectorBase, _create_properties
 
 
-class Vec2:
+class Vec2(VectorBase["Vec2"]):
     """
-    A simple 3D vector class for 3D graphics, I use slots to fix the attributes to x,y,z
+    A simple 2D vector class for graphics, using numpy for efficient operations.
+
     Attributes:
         x (float): The x-coordinate of the vector.
         y (float): The y-coordinate of the vector.
     """
 
-    __slots__ = ["_x", "_y"]  # fix the attributes to x,y,z
-
-    def __init__(self, x=0.0, y=0.0):
-        """
-        Initializes a new instance of the Vec2 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.
-        """
-        self._x = x  # x component of vector : float
-        self._y = y  # y component of vector : float
+    DIMENSION = 2
+    COMPONENT_NAMES = ("x", "y")
+    DEFAULT_VALUES = (0.0, 0.0)
 
-    @classmethod
-    def sizeof(cls):
-        return 2 * ctypes.sizeof(ctypes.c_float)
+    __slots__ = ["_data"]
 
-    def __iter__(self):
-        """
-        Make the Vec2 class iterable.
-        Yields:
-            float: The x and y components of the vector.
-        """
-        yield self.x
-        yield self.y
-
-    def __hash__(self):
-        # Use 32-bit float element hashes, then combine
-        seed = 0
-        for v in (self.x, self.y):
-            # ensure 32-bit float semantics
-            h = hash(float(np.float32(v)))
-            seed = hash_combine(seed, h)
-        return seed
-
-    def copy(self) -> "Vec2":
-        """
-        Create a copy of the vector.
-        Returns:
-            Vec2: A new instance of Vec2 with the same x and y values.
-        """
-        return Vec2(self.x, self.y)
-
-    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.
+    def cross(self, rhs: "Vec2") -> float:
         """
-        components = [self.x, self.y]
-        try:
-            return components[index]
-        except IndexError:
-            raise IndexError("Index out of range. Valid indices are 0, 1,")
+        Cross product of two vectors a x b (2D version returns scalar).
 
-    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, np.float32)):
-            raise ValueError("need float or int")
-        else:
-            setattr(self, name, v)
-
-    def __add__(self, rhs):
-        """
-        vector addition a+b
+            rhs (Vec2): The right-hand side vector to cross product with.
 
-        Args:
-            rhs (Vec2): The right-hand side vector to add.
         Returns:
-            Vec2: A new vector that is the result of adding this vector and the rhs vector.
+            float: 2D cross product (perpendicular dot product).
         """
-        r = Vec2()
-        r.x = self.x + rhs.x
-        r.y = self.y + rhs.y
-        return r
+        return self._data[0] * rhs._data[1] - self._data[1] * rhs._data[0]
 
-    def __iadd__(self, rhs):
+    def reflect(self, n: "Vec2") -> "Vec2":
         """
-        vector addition a+=b
+        Reflect a vector about a normal.
 
         Args:
-            rhs (Vec2): The right-hand side vector to add.
-        Returns:
-            Vec2: returns this vector after adding the rhs vector.
-        """
-        self.x += rhs.x
-        self.y += rhs.y
-        return self
-
-    def __sub__(self, rhs):
-        """
-        vector subtraction a-b
+            n (Vec2): The normal to reflect about.
 
-        Args:
-            rhs (Vec2): The right-hand side vector to add.
         Returns:
-            Vec2: A new vector that is the result of subtracting this vector and the rhs vector.
+            Vec2: A new vector that is the result of reflecting this vector about the normal.
         """
-        r = Vec2()
-        r.x = self.x - rhs.x
-        r.y = self.y - rhs.y
-        return r
+        d = self.dot(n)
+        # I - 2.0 * dot(N, I) * N
+        return Vec2(
+            self._data[0] - 2.0 * d * n._data[0], self._data[1] - 2.0 * d * n._data[1]
+        )
 
-    def __isub__(self, rhs):
+    def outer(self, rhs: "Vec2"):
         """
-        vector subtraction a-=b
+        Outer product of two vectors a x b.
 
         Args:
-            rhs (Vec2): The right-hand side vector to add.
-        Returns:
-            Vec2: returns this vector after subtracting the rhs vector.
-        """
-        self.x -= rhs.x
-        self.y -= rhs.y
-        return self
+            rhs (Vec2): The right-hand side vector to outer product with.
 
-    def __eq__(self, rhs):
-        """
-        vector comparison a==b using math.isclose not we only compare to 6 decimal places
-        Args:
-            rhs (Vec2): 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 Vec2.
+            Mat2: A new 2x2 matrix that is the result of the outer product.
         """
+        from .mat2 import Mat2
 
-        if not isinstance(rhs, Vec2):
-            return NotImplemented
-        return math.isclose(self.x, rhs.x) and math.isclose(self.y, rhs.y)
-
-    def __neq__(self, rhs):
-        """
-        vector comparison a!=b using math.isclose not we only compare to 6 decimal places
-        Args:
-            rhs (Vec2): 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 Vec2.
-        """
+        result = Mat2()
+        result.m = np.outer(self._data, rhs._data).astype(np.float64)
+        return result
 
-        if not isinstance(rhs, Vec2):
-            return NotImplemented
-        return not (math.isclose(self.x, rhs.x) and math.isclose(self.y, rhs.y))
-
-    def __neg__(self):
-        """
-        negate a vector -a
-        """
-        self.x = -self.x
-        self.y = -self.y
-        return self
-
-    def set(self, x, y):
-        """
-        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.
-        Raises :
-            ValueError: if x,y are not float
+    def __matmul__(self, rhs):
         """
-        try:
-            self.x = float(x)
-            self.y = float(y)
-        except ValueError:
-            raise ValueError(f"Vec2.set {x=} {y=} all need to be float")
+        Vec2 @ Mat2 matrix multiplication.
 
-    def dot(self, rhs):
-        """
-        dot product of two vectors a.b
         Args:
-            rhs (Vec2): The right-hand side vector to dot product with.
-        """
-        return self.x * rhs.x + self.y * rhs.y
-
-    def length(self):
-        """
-        length of vector
-        Returns:
-            float: The length of the vector.
-        """
-        return math.sqrt(self.x**2 + self.y**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
+            rhs (Mat2): The matrix to multiply by.
 
-    def inner(self, rhs):
-        """
-        inner product of two vectors a.b
-        Args:
-            rhs (Vec2): The right-hand side vector to inner product with.
         Returns:
-            float: The inner product of the two vectors.
+            Vec2: A new vector that is the result of multiplying this vector by the matrix.
         """
-        return (self.x * rhs.x) + (self.y * rhs.y)
+        return Vec2(
+            self._data[0] * rhs.m[0, 0] + self._data[1] * rhs.m[1, 0],
+            self._data[0] * rhs.m[0, 1] + self._data[1] * rhs.m[1, 1],
+        )
 
-    def null(self):
-        """
-        set the vector to zero
+    def set(self, *args: float) -> None:
         """
-        self.x = 0.0
-        self.y = 0.0
+        Set the x,y values of the vector.
 
-    def cross(self, rhs):
-        """
-        cross product of two vectors a x b
         Args:
-            rhs (Vec2): The right-hand side vector to cross product with.
-        Returns:
-            float : 2D cross product or perpendicular dot product.
-        """
-        return self.x * rhs.y - self.y * rhs.x
+            *args: Component values (x, y).
 
-    def normalize(self):
-        """
-        normalize the vector to unit length
-        Returns:
-            Vec2: A new vector that is the result of normalizing this vector.
         Raises:
-            ZeroDivisionError: If the length of the vector is zero.
+            ValueError: If wrong number of arguments or they are not floats.
         """
-        vector_length = self.length()
+        if len(args) != 2:
+            raise ValueError(f"Vec2.set requires 2 arguments, got {len(args)}")
         try:
-            self.x /= vector_length
-            self.y /= vector_length
-        except ZeroDivisionError:
-            raise ZeroDivisionError(
-                f"Vec2.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 (Vec2): The normal to reflect about.
-        Returns:
-            Vec2: 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 Vec2(self.x - 2.0 * d * n.x, self.y - 2.0 * d * n.y)
-
-    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)
-
-    def __repr__(self):
-        "object representation for debugging"
-        return f"Vec2 [{self.x},{self.y}]"
-
-    def __truediv__(self, rhs):
-        if isinstance(rhs, (float, int)):
-            return Vec2(self.x / rhs, self.y / rhs)
-        elif isinstance(rhs, Vec2):
-            return Vec2(self.x / rhs.x, self.y / rhs.y)
-        else:
-            raise ValueError(f"can only do piecewise division with a scalar {rhs=}")
-
-    def __str__(self):
-        "object representation for debugging"
-        return f"[{self.x},{self.y}]"
-
-    def __mul__(self, rhs):
-        """
-        piecewise scalar multiplication
-        Args:
-            rhs (float): The scalar to multiply by.
-        Returns:
-            Vec2: 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 Vec2(self.x * rhs, self.y * 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:
-            Vec2: 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 __matmul__(self, rhs):
-        """
-        "Vec2 @ Mat2 matrix multiplication"
-        Args:
-            rhs (Mat2): The matrix to multiply by.
-        Returns:
-            Vec2: A new vector that is the result of multiplying this vector by the matrix.
-        """
-        return Vec2(
-            self.x * rhs.m[0][0] + self.y * rhs.m[1][0],
-            self.x * rhs.m[0][1] + self.y * rhs.m[1][1],
-        )
-
-
-# Helper function to create properties
-def _create_property(attr_name):
-    def getter(self):
-        return getattr(self, f"_{attr_name}")
+            self._data[0] = float(args[0])
+            self._data[1] = float(args[1])
+        except ValueError:
+            raise ValueError(f"Vec2.set {args=} all need to be float")
 
-    def setter(self, value):
-        self._validate_and_set(value, f"_{attr_name}")
+    def __repr__(self) -> str:
+        """Object representation for debugging."""
+        return f"Vec2 [{self._data[0]},{self._data[1]}]"
 
-    return property(getter, setter)
+    def __str__(self) -> str:
+        """String representation of the vector."""
+        return f"[{self._data[0]},{self._data[1]}]"
 
 
-# Dynamically add properties for x, y
-for attr in ["x", "y"]:
-    setattr(Vec2, attr, _create_property(attr))
+# Add properties for x, y components
+_create_properties(Vec2)

ncca/ngl/vec2_array.py

@@ -1,5 +1,6 @@
 """
 A container for ngl.Vec2 objects that mimics some of the behavior of a std::vector
+Optimized for graphics APIs with contiguous numpy storage
 """
 
 import numpy as np
@@ -9,40 +10,55 @@ from .vec2 import Vec2
 
 class Vec2Array:
     """
-    A class to hold a list of Vec2 objects and perform operations on them.
+    A class to hold Vec2 data in contiguous memory for efficient GPU transfer.
+    Internally uses a numpy array of shape (N, 2) for optimal performance.
     """
 
     def __init__(self, values=None):
         """
-        Initializes the Vec3Array.
+        Initializes the Vec2Array.
 
         Args:
-            values (iterable | int, optional): An iterable of Vec3 objects or an integer.
-                If an integer, the array is initialized with that many default Vec3s.
-                If an iterable, it's initialized with the Vec3s from the iterable.
+            values (iterable | int, optional): An iterable of Vec2 objects or an integer.
+                If an integer, the array is initialized with that many default Vec2s.
+                If an iterable, it's initialized with the Vec2s from the iterable.
                 Defaults to None (an empty array).
         """
-        self._data = []
-        if values is not None:
-            if isinstance(values, int):
-                self._data = [Vec2() for _ in range(values)]
-            else:
-                for v in values:
-                    if not isinstance(v, Vec2):
-                        raise TypeError("All elements must be of type Vec2")
-                    self._data.append(v)
+        if values is None:
+            # Empty array - start with shape (0, 2)
+            self._data = np.zeros((0, 2), dtype=np.float64)
+        elif isinstance(values, int):
+            # Initialize N default Vec2s (0, 0)
+            self._data = np.zeros((values, 2), dtype=np.float64)
+        else:
+            # Initialize from iterable of Vec2 objects
+            vec_list = []
+            for v in values:
+                if not isinstance(v, Vec2):
+                    raise TypeError("All elements must be of type Vec2")
+                vec_list.append([v.x, v.y])
+            self._data = np.array(vec_list, dtype=np.float64)
 
     def __getitem__(self, index):
         """
         Get the Vec2 at the specified index.
 
         Args:
-            index (int): The index of the element.
+            index (int | slice): The index or slice of the element(s).
 
         Returns:
             Vec2: The Vec2 object at the given index.
-        """
-        return self._data[index]
+            Vec2Array: A new Vec2Array if slicing.
+        """
+        if isinstance(index, slice):
+            # Return a new Vec2Array with sliced data
+            result = Vec2Array()
+            result._data = self._data[index].copy()
+            return result
+        else:
+            # Return a single Vec2
+            row = self._data[index]
+            return Vec2(row[0], row[1])
 
     def __setitem__(self, index, value):
         """
@@ -50,11 +66,11 @@ class Vec2Array:
 
         Args:
             index (int): The index of the element to set.
-            value (Vec3): The new Vec3 object.
+            value (Vec2): The new Vec2 object.
         """
         if not isinstance(value, Vec2):
             raise TypeError("Only Vec2 objects can be assigned")
-        self._data[index] = value
+        self._data[index] = [value.x, value.y]
 
     def __len__(self):
         """
@@ -64,9 +80,25 @@ class Vec2Array:
 
     def __iter__(self):
         """
-        Return an iterator for the array.
+        Return an iterator that yields Vec2 objects.
+        """
+        for i in range(len(self._data)):
+            row = self._data[i]
+            yield Vec2(row[0], row[1])
+
+    def __eq__(self, other):
+        """
+        Compare two Vec2Array instances for equality.
+
+        Args:
+            other: Another Vec2Array instance to compare with.
+
+        Returns:
+            bool: True if the arrays contain the same data, False otherwise.
         """
-        return iter(self._data)
+        if not isinstance(other, Vec2Array):
+            return NotImplemented
+        return np.array_equal(self._data, other._data)
 
     def append(self, value):
         """
@@ -77,7 +109,8 @@ class Vec2Array:
         """
         if not isinstance(value, Vec2):
             raise TypeError("Only Vec2 objects can be appended")
-        self._data.append(value)
+        new_row = np.array([[value.x, value.y]], dtype=np.float64)
+        self._data = np.vstack([self._data, new_row])
 
     def extend(self, values):
         """
@@ -88,7 +121,12 @@ class Vec2Array:
         """
         if not all(isinstance(v, Vec2) for v in values):
             raise TypeError("All elements must be of type Vec2")
-        self._data.extend(values)
+
+        new_rows = np.array([[v.x, v.y] for v in values], dtype=np.float64)
+        if len(self._data) == 0:
+            self._data = new_rows
+        else:
+            self._data = np.vstack([self._data, new_rows])
 
     def to_list(self):
         """
@@ -97,22 +135,35 @@ class Vec2Array:
         Returns:
             list: A list of x, y components concatenated.
         """
-        return [comp for vec in self._data for comp in vec]
+        return self._data.flatten().tolist()
 
     def to_numpy(self):
         """
         Convert the array of Vec2 objects to a numpy array.
+        This is the primary method for GPU data transfer.
+
+        Returns:
+            numpy.ndarray: A float32 numpy array of shape (N*2,) for GPU transfer.
+        """
+        return self._data.astype(np.float32).flatten()
+
+    def get_array(self):
+        """
+        Get the underlying numpy array in shape (N, 2).
+        Useful for vectorized operations.
 
         Returns:
-            numpy.ndarray: A numpy array of the vector data.
+            numpy.ndarray: The internal float64 array of shape (N, 2).
         """
-        return np.array(self.to_list(), dtype=np.float32)
+        return self._data
 
     def __repr__(self):
-        return f"Vec2Array({self._data!r})"
+        vec_list = [Vec2(row[0], row[1]) for row in self._data]
+        return f"Vec2Array({vec_list!r})"
 
     def __str__(self):
-        return str(self._data)
+        vec_list = [Vec2(row[0], row[1]) for row in self._data]
+        return str(vec_list)
 
     def sizeof(self):
         """