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

ncca/ngl/texture.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+import OpenGL.GL as gl
+
+from .image import Image
+
+
+class Texture:
+    """A texture class to load and create OpenGL textures."""
+
+    def __init__(self, filename: str = None) -> None:
+        self._image = Image(filename)
+        self._texture_id = 0
+        self._multi_texture_id = 0
+
+    @property
+    def width(self) -> int:
+        return self._image.width
+
+    @property
+    def height(self) -> int:
+        return self._image.height
+
+    @property
+    def format(self) -> int:
+        if self._image.mode:
+            if self._image.mode.value == "RGB":
+                return gl.GL_RGB
+            elif self._image.mode.value == "RGBA":
+                return gl.GL_RGBA
+            elif self._image.mode.value == "L":
+                return gl.GL_RED
+        return 0
+
+    @property
+    def internal_format(self) -> int:
+        if self._image.mode:
+            if self._image.mode.value == "RGB":
+                return gl.GL_RGB8
+            elif self._image.mode.value == "RGBA":
+                return gl.GL_RGBA8
+            elif self._image.mode.value == "L":
+                return gl.GL_R8
+        return 0
+
+    def load_image(self, filename: str) -> bool:
+        return self._image.load(filename)
+
+    def get_pixels(self) -> bytes:
+        return self._image.get_pixels().tobytes()
+
+    def set_texture_gl(self) -> int:
+        if self._image.width > 0 and self._image.height > 0:
+            self._texture_id = gl.glGenTextures(1)
+            gl.glActiveTexture(gl.GL_TEXTURE0 + self._multi_texture_id)
+            gl.glBindTexture(gl.GL_TEXTURE_2D, self._texture_id)
+            gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_LINEAR)
+            gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_LINEAR)
+            gl.glTexImage2D(
+                gl.GL_TEXTURE_2D,
+                0,
+                self.internal_format,
+                self.width,
+                self.height,
+                0,
+                self.format,
+                gl.GL_UNSIGNED_BYTE,
+                self.get_pixels(),
+            )
+            gl.glGenerateMipmap(gl.GL_TEXTURE_2D)
+            return self._texture_id
+        return 0
+
+    def set_multi_texture(self, id: int) -> None:
+        self._multi_texture_id = id

ncca/ngl/transform.py

@@ -0,0 +1,95 @@
+"""
+Class to represent a transform using translate, rotate and scale,
+"""
+
+from .mat4 import Mat4
+from .vec3 import Vec3
+
+
+class TransformRotationOrder(Exception):
+    pass
+
+
+class Transform:
+    rot_order = {
+        "xyz": "rz@ry@rx",
+        "yzx": "rx@rz@ry",
+        "zxy": "ry@rx@rz",
+        "xzy": "ry@rz@rx",
+        "yxz": "rz@rx@ry",
+        "zyx": "rx@ry@rz",
+    }
+
+    def __init__(self):
+        self.position = Vec3(0.0, 0.0, 0.0)
+        self.rotation = Vec3(0.0, 0.0, 0.0)
+        self.scale = Vec3(1.0, 1.0, 1.0)
+        self.matrix = Mat4()
+        self.need_recalc = True
+        self.order = "xyz"
+
+    def _set_value(self, args):
+        v = Vec3()
+        self.need_recalc = True
+        if len(args) == 1:  # one argument
+            if isinstance(args[0], (list, tuple)):
+                v.x = args[0][0]
+                v.y = args[0][1]
+                v.z = args[0][2]
+            else:  # try vec types
+                v.x = args[0].x
+                v.y = args[0].y
+                v.z = args[0].z
+            return v
+        elif len(args) == 3:  # 3 as x,y,z
+            v.x = float(args[0])
+            v.y = float(args[1])
+            v.z = float(args[2])
+            return v
+        else:
+            raise ValueError
+
+    def reset(self):
+        self.position = Vec3()
+        self.rotation = Vec3()
+        self.scale = Vec3(1, 1, 1)
+        self.order = "xyz"
+        self.need_recalc = True
+
+    def set_position(self, *args):
+        "set position attrib using either x,y,z or vec types"
+        self.position = self._set_value(args)
+
+    def set_rotation(self, *args):
+        "set rotation attrib using either x,y,z or vec types"
+        self.rotation = self._set_value(args)
+
+    def set_scale(self, *args):
+        "set scale attrib using either x,y,z or vec types"
+        self.scale = self._set_value(args)
+
+    def set_order(self, order):
+        "set rotation order from string e.g xyz or zyx"
+        if order not in self.rot_order:
+            raise TransformRotationOrder
+        self.order = order
+        self.need_recalc = True
+
+    def get_matrix(self):
+        "return a transform matrix based on rotation order"
+        if self.need_recalc is True:
+            scale = Mat4.scale(self.scale.x, self.scale.y, self.scale.z)
+            rx = Mat4.rotate_x(self.rotation.x)  # noqa: F841
+            ry = Mat4.rotate_y(self.rotation.y)  # noqa: F841
+            rz = Mat4.rotate_z(self.rotation.z)  # noqa: F841
+            rotation_scale = eval(self.rot_order.get(self.order)) @ scale
+            self.matrix = rotation_scale
+            self.matrix.m[3][0] = self.position.x
+            self.matrix.m[3][1] = self.position.y
+            self.matrix.m[3][2] = self.position.z
+            self.matrix.m[3][3] = 1.0
+            self.need_recalc = False
+        return self.matrix
+
+    def __str__(self):
+        return f"pos {self.position}\nrot {self.rotation}\nscale {self.scale}"

ncca/ngl/util.py

@@ -0,0 +1,128 @@
+"""Utility math module, contains various useful functions for 3D.
+
+Most of these functions are based on functions found in other libraries such as GLM, NGL or GLU
+"""
+
+import math
+
+from .mat4 import Mat4
+
+
+def clamp(num, low, high):
+    "clamp to range min and max will throw ValueError is low>=high"
+    if low > high or low == high:
+        raise ValueError
+    return max(min(num, high), low)
+
+
+def look_at(eye, look, up):
+    """
+    Calculate 4x4 matrix for camera lookAt
+    """
+
+    n = look - eye
+    u = up
+    v = n.cross(u)
+    u = v.cross(n)
+    n.normalize()
+    v.normalize()
+    u.normalize()
+
+    result = Mat4.identity()
+    result.m[0][0] = v.x
+    result.m[1][0] = v.y
+    result.m[2][0] = v.z
+    result.m[0][1] = u.x
+    result.m[1][1] = u.y
+    result.m[2][1] = u.z
+    result.m[0][2] = -n.x
+    result.m[1][2] = -n.y
+    result.m[2][2] = -n.z
+    result.m[3][0] = -eye.dot(v)
+    result.m[3][1] = -eye.dot(u)
+    result.m[3][2] = eye.dot(n)
+    return result
+
+
+def perspective(fov, aspect, near, far):
+    m = Mat4.zero()  # as per glm
+    _range = math.tan(math.radians(fov / 2.0)) * near
+    left = -_range * aspect
+    right = _range * aspect
+    bottom = -_range
+    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)
+    return m
+
+
+def ortho(left, right, bottom, top, near, far):
+    """Create an orthographic projection matrix."""
+    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)
+    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()
+    m.m[0][0] = (2.0 * near) / (right - left)
+    m.m[1][1] = (2.0 * near) / (top - bottom)
+    m.m[2][0] = (right + left) / (right - left)
+    m.m[2][1] = (top + bottom) / (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)
+    return m
+
+
+def lerp(a, b, t):
+    return a + (b - a) * t
+
+
+def calc_normal(p1, p2, p3):
+    """
+    Calculates the normal of a triangle defined by three points.
+
+    This is a Python implementation of the NGL C++ Util::calcNormal function.
+    It uses the vector cross product method for clarity and leverages the py-ngl library.
+    The order of the cross product is chosen to match the output of the C++ version.
+
+    Args:
+        p1: The first vertex of the triangle.
+        p2: The second vertex of the triangle.
+        p3: The third vertex of the triangle.
+
+    Returns:
+        The normalized normal vector of the triangle.
+    """
+    # Two vectors on the plane of the triangle
+    v1 = p3 - p1
+    v2 = p2 - p1
+
+    # The cross product gives the normal vector.
+    # The order (v1 x v2) is used to match the C++ implementation's result.
+    normal = v1.cross(v2)
+
+    # Normalize the result to get a unit length normal
+    normal.normalize()
+
+    return normal

ncca/ngl/vao_factory.py

@@ -0,0 +1,34 @@
+import enum
+
+from .multi_buffer_vao import MultiBufferVAO
+from .simple_index_vao import SimpleIndexVAO
+from .simple_vao import SimpleVAO
+from .log import logger
+
+
+class VAOType(enum.Enum):
+    SIMPLE = "simpleVAO"
+    MULTI_BUFFER = "multiBufferVAO"
+    SIMPLE_INDEX = "simpleIndexVAO"
+
+
+class VAOFactory:
+    _creators = {}
+
+    @staticmethod
+    def register_vao_creator(name, creator_func):
+        VAOFactory._creators[name] = creator_func
+
+    @staticmethod
+    def create_vao(name, mode):
+        creator = VAOFactory._creators.get(name)
+        if not creator:
+            logger.warning(f"VAO type '{name}' not found.")
+            raise ValueError(name)
+        return creator(mode)
+
+
+# pre-register the default VAO types
+VAOFactory.register_vao_creator(VAOType.SIMPLE, SimpleVAO)
+VAOFactory.register_vao_creator(VAOType.MULTI_BUFFER, MultiBufferVAO)
+VAOFactory.register_vao_creator(VAOType.SIMPLE_INDEX, SimpleIndexVAO)

ncca/ngl/vec2.py

@@ -0,0 +1,350 @@
+"""
+Simple float only Vec2 class for 3D graphics, very similar to the pyngl ones
+"""
+
+import ctypes
+import math
+
+from .util import clamp
+
+
+class Vec2:
+    """
+    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.
+    """
+
+    __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
+
+    @classmethod
+    def sizeof(cls):
+        return 2 * ctypes.sizeof(ctypes.c_float)
+
+    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 clone(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.
+        """
+        components = [self.x, self.y]
+        try:
+            return components[index]
+        except IndexError:
+            raise IndexError("Index out of range. Valid indices are 0, 1,")
+
+    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 __add__(self, rhs):
+        """
+        vector addition a+b
+
+        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.
+        """
+        r = Vec2()
+        r.x = self.x + rhs.x
+        r.y = self.y + rhs.y
+        return r
+
+    def __iadd__(self, rhs):
+        """
+        vector addition a+=b
+
+        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
+
+        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.
+        """
+        r = Vec2()
+        r.x = self.x - rhs.x
+        r.y = self.y - rhs.y
+        return r
+
+    def __isub__(self, rhs):
+        """
+        vector subtraction a-=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
+
+    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.
+        """
+
+        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.
+        """
+
+        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
+        """
+        try:
+            self.x = float(x)
+            self.y = float(y)
+        except ValueError:
+            raise ValueError(f"Vec2.set {x=} {y=} all need to be float")
+
+    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
+
+    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.
+        """
+        return (self.x * rhs.x) + (self.y * rhs.y)
+
+    def null(self):
+        """
+        set the vector to zero
+        """
+        self.x = 0.0
+        self.y = 0.0
+
+    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
+
+    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.
+        """
+        vector_length = self.length()
+        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.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],
+        )
+
+
+# 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
+for attr in ["x", "y"]:
+    setattr(Vec2, attr, _create_property(attr))