ncca-ngl 0.1.0__py3-none-any.whl

ncca/ngl/PrimData/pack_arrays.py

@@ -0,0 +1,20 @@
+#!/usr/bin/env python3
+
+import numpy as np
+import pathlib
+
+files = pathlib.Path(".").glob("*.npy")
+
+data = {}
+for f in files:
+    data[str(f.stem)] = np.load(f)
+    # arrays.append(np.load(f))
+    # names.append(str(f.stem))
+print(data.keys())
+
+
+np.savez_compressed("Primitives", **data)
+
+loaded = np.load("Primitives.npz")
+print(loaded)
+print(loaded["dragon"])

ncca/ngl/__init__.py

@@ -0,0 +1,100 @@
+from .abstract_vao import AbstractVAO, VertexData
+from .base_mesh import BaseMesh, Face
+from .bbox import BBox
+from .bezier_curve import BezierCurve
+from .first_person_camera import FirstPersonCamera
+from .image import Image, ImageModes
+from .log import logger
+from .mat2 import Mat2
+from .mat3 import Mat3, Mat3Error, Mat3NotSquare
+from .mat4 import Mat4, Mat4Error, Mat4NotSquare
+from .multi_buffer_vao import MultiBufferVAO
+from .obj import (
+    Obj,
+    ObjParseFaceError,
+    ObjParseNormalError,
+    ObjParseUVError,
+    ObjParseVertexError,
+)
+from .plane import Plane
+from .primitives import Primitives, Prims
+from .pyside_event_handling_mixin import PySideEventHandlingMixin
+from .quaternion import Quaternion
+from .random import Random
+from .shader import MatrixTranspose, Shader, ShaderType
+from .shader_lib import DefaultShader, ShaderLib
+from .shader_program import ShaderProgram
+from .simple_index_vao import IndexVertexData, SimpleIndexVAO
+from .simple_vao import SimpleVAO
+from .text import Text
+from .texture import Texture
+from .transform import Transform, TransformRotationOrder
+from .util import calc_normal, clamp, frustum, lerp, look_at, ortho, perspective
+from .vao_factory import VAOFactory, VAOType
+from .vec2 import Vec2
+from .vec2_array import Vec2Array
+from .vec3 import Vec3
+from .vec3_array import Vec3Array
+from .vec4 import Vec4
+from .vec4_array import Vec4Array
+
+all = [
+    AbstractVAO,
+    VertexData,
+    BaseMesh,
+    Face,
+    BBox,
+    BezierCurve,
+    Image,
+    ImageModes,
+    Mat2,
+    Mat3,
+    Mat4,
+    MultiBufferVAO,
+    Obj,
+    Plane,
+    Quaternion,
+    MatrixTranspose,
+    Shader,
+    ShaderProgram,
+    ShaderType,
+    ShaderLib,
+    IndexVertexData,
+    SimpleIndexVAO,
+    SimpleVAO,
+    Texture,
+    VAOFactory,
+    Vec2,
+    Vec3,
+    Vec4,
+    Vec3Array,
+    Vec2Array,
+    Vec4Array,
+    ObjParseVertexError,
+    ObjParseNormalError,
+    ObjParseUVError,
+    ObjParseFaceError,
+    clamp,
+    lerp,
+    look_at,
+    perspective,
+    ortho,
+    frustum,
+    Transform,
+    TransformRotationOrder,
+    Random,
+    Text,
+    calc_normal,
+    Mat3Error,
+    Mat4Error,
+    Mat3NotSquare,
+    Mat4NotSquare,
+    Mat4NotSquare,
+    VAOType,
+    DefaultShader,
+    logger,
+    Primitives,
+    Prims,
+    FirstPersonCamera,
+    PySideEventHandlingMixin,
+]

ncca/ngl/abstract_vao.py

@@ -0,0 +1,89 @@
+import abc
+import ctypes
+
+import numpy as np
+import OpenGL.GL as gl
+
+from .log import logger
+
+
+class VertexData:
+    def __init__(self, data, size, mode=gl.GL_STATIC_DRAW):
+        if isinstance(data, np.ndarray):
+            self.data = data
+        else:
+            self.data = np.array(data, dtype=np.float32)
+        self.size = size
+        self.mode = mode
+
+
+class AbstractVAO(abc.ABC):
+    def __init__(self, mode=gl.GL_TRIANGLES):
+        self.id = gl.glGenVertexArrays(1)
+        self.mode = mode
+        self.bound = False
+        self.allocated = False
+        self.indices_count = 0
+
+    def bind(self):
+        gl.glBindVertexArray(self.id)
+        self.bound = True
+
+    def unbind(self):
+        gl.glBindVertexArray(0)
+        self.bound = False
+
+    def __enter__(self):
+        self.bind()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.unbind()
+
+    @abc.abstractmethod
+    def draw(self):
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def set_data(self, data):
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def remove_vao(self):
+        raise NotImplementedError
+
+    def set_vertex_attribute_pointer(
+        self, id, size, type, stride, offset, normalize=False
+    ):
+        if not self.bound:
+            logger.error("VAO not bound in set_vertex_attribute_pointer")
+        gl.glVertexAttribPointer(
+            id, size, type, normalize, stride, ctypes.c_void_p(offset)
+        )
+        gl.glEnableVertexAttribArray(id)
+
+    def set_num_indices(self, count):
+        self.indices_count = count
+
+    def num_indices(self):
+        return self.indices_count
+
+    def get_mode(self):
+        return self.mode
+
+    def set_mode(self, mode):
+        self.mode = mode
+
+    @abc.abstractmethod
+    def get_buffer_id(self, index=0):
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def map_buffer(self, index=0, access_mode=gl.GL_READ_WRITE):
+        raise NotImplementedError
+
+    def unmap_buffer(self):
+        gl.glUnmapBuffer(gl.GL_ARRAY_BUFFER)
+
+    def get_id(self):
+        return self.id

ncca/ngl/base_mesh.py

@@ -0,0 +1,170 @@
+from dataclasses import dataclass
+
+import numpy as np
+import OpenGL.GL as gl
+
+from . import vao_factory
+from .abstract_vao import VertexData
+from .bbox import BBox
+from .log import logger
+
+
+class Face:
+    """
+    Simple face structure for mesh geometry.
+    Holds indices for vertices, UVs, and normals.
+    """
+
+    slots = ("vertex", "uv", "normal")
+
+    def __init__(self):
+        self.vertex: list[int] = []
+        self.uv: list[int] = []
+        self.normal: list[int] = []
+
+
+class BaseMesh:
+    """
+    Base class for mesh geometry.
+    Provides storage for vertices, normals, UVs, faces, and VAO management.
+    """
+
+    def __init__(self):
+        self.vertex: list = []
+        self.normals: list = []
+        self.uv: list = []
+        self.faces: list[Face] = []
+        self.vao = None
+        self.bbox = None
+        self.min_x: float = 0.0
+        self.max_x: float = 0.0
+        self.min_y: float = 0.0
+        self.max_y: float = 0.0
+        self.min_z: float = 0.0
+        self.max_z: float = 0.0
+        self.texture_id: int = 0
+        self.texture: bool = False
+
+    def is_triangular(self) -> bool:
+        """
+        Check if all faces in the mesh are triangles.
+
+        Returns:
+            bool: True if all faces are triangles, False otherwise.
+        """
+        return all(len(f.vertex) == 3 for f in self.faces)
+
+    def create_vao(self, reset_vao: bool = False) -> None:
+        """
+        Create a Vertex Array Object (VAO) for the mesh.
+        Only supports triangular meshes.
+
+        Args:
+            reset_vao: If True, will not create a new VAO if one already exists.
+        Raises:
+            RuntimeError: If the mesh is not composed entirely of triangles.
+        """
+        if reset_vao:
+            if self.vao is not None:
+                logger.warning("VAO exist so returning")
+                return
+        else:
+            if self.vao is not None:
+                logger.warning("Creating new VAO")
+
+        data_pack_type = 0
+        if self.is_triangular():
+            data_pack_type = gl.GL_TRIANGLES
+        if data_pack_type == 0:
+            logger.error("Can only create VBO from all Triangle data at present")
+            raise RuntimeError("Can only create VBO from all Triangle data at present")
+
+        @dataclass
+        class VertData:
+            """
+            Structure for a single vertex's data, including position, normal, and UV.
+            """
+
+            x: float = 0.0
+            y: float = 0.0
+            z: float = 0.0
+            nx: float = 0.0
+            ny: float = 0.0
+            nz: float = 0.0
+            u: float = 0.0
+            v: float = 0.0
+
+            def as_array(self) -> np.ndarray:
+                return np.array(
+                    [self.x, self.y, self.z, self.nx, self.ny, self.nz, self.u, self.v],
+                    dtype=np.float32,
+                )
+
+        vbo_mesh: list[VertData] = []
+        for face in self.faces:
+            for i in range(3):
+                d = VertData()
+                d.x = self.vertex[face.vertex[i]].x
+                d.y = self.vertex[face.vertex[i]].y
+                d.z = self.vertex[face.vertex[i]].z
+                if self.normals and self.uv:
+                    d.nx = self.normals[face.normal[i]].x
+                    d.ny = self.normals[face.normal[i]].y
+                    d.nz = self.normals[face.normal[i]].z
+                    d.u = self.uv[face.uv[i]].x
+                    d.v = 1 - self.uv[face.uv[i]].y  # Flip V for OpenGL
+                elif self.normals and not self.uv:
+                    d.nx = self.normals[face.normal[i]].x
+                    d.ny = self.normals[face.normal[i]].y
+                    d.nz = self.normals[face.normal[i]].z
+                elif not self.normals and self.uv:
+                    d.u = self.uv[face.uv[i]].x
+                    d.v = 1 - self.uv[face.uv[i]].y
+                vbo_mesh.append(d)
+
+        mesh_data = np.concatenate([v.as_array() for v in vbo_mesh]).astype(np.float32)
+        self.vao = vao_factory.VAOFactory.create_vao(
+            vao_factory.VAOType.SIMPLE, data_pack_type
+        )
+        with self.vao as vao:
+            mesh_size = len(mesh_data) // 8
+            vao.set_data(VertexData(mesh_data, mesh_size))
+            # vertex
+            vao.set_vertex_attribute_pointer(0, 3, gl.GL_FLOAT, 8 * 4, 0)
+            # normals
+            vao.set_vertex_attribute_pointer(1, 3, gl.GL_FLOAT, 8 * 4, 3 * 4)
+            # uvs
+            vao.set_vertex_attribute_pointer(2, 2, gl.GL_FLOAT, 8 * 4, 6 * 4)
+            vao.set_num_indices(mesh_size)
+        self.calc_dimensions()
+        self.bbox = BBox.from_extents(
+            self.min_x, self.max_x, self.min_y, self.max_y, self.min_z, self.max_z
+        )
+
+    def calc_dimensions(self) -> None:
+        """
+        Calculate the bounding box extents for the mesh.
+        Updates min_x, max_x, min_y, max_y, min_z, max_z.
+        """
+        if not self.vertex:
+            return
+        self.min_x = self.max_x = self.vertex[0].x
+        self.min_y = self.max_y = self.vertex[0].y
+        self.min_z = self.max_z = self.vertex[0].z
+        for v in self.vertex:
+            self.min_x = min(self.min_x, v.x)
+            self.max_x = max(self.max_x, v.x)
+            self.min_y = min(self.min_y, v.y)
+            self.max_y = max(self.max_y, v.y)
+            self.min_z = min(self.min_z, v.z)
+            self.max_z = max(self.max_z, v.z)
+
+    def draw(self) -> None:
+        """
+        Draw the mesh using its VAO and bound texture (if any).
+        """
+        if self.vao:
+            if self.texture_id:
+                gl.glBindTexture(gl.GL_TEXTURE_2D, self.texture_id)
+            with self.vao as vao:
+                vao.draw()

ncca/ngl/base_mesh.pyi

@@ -0,0 +1,11 @@
+class Face:
+    vert: list
+    uv: list
+    normal: list
+
+class BaseMesh:
+    verts: list
+    normals: list
+    uv: list
+    faces: list
+    def __init__(self) -> None: ...

ncca/ngl/bbox.py

@@ -0,0 +1,224 @@
+from .vec3 import Vec3
+
+
+class BBox:
+    """
+    A bounding box class for 3D geometry.
+
+    Stores center, dimensions, extents, vertices, and normals for a box.
+    Provides methods to recalculate from center/dimensions or from extents.
+    """
+
+    def __init__(
+        self,
+        center: Vec3 = Vec3(),
+        width: float = 2.0,
+        height: float = 2.0,
+        depth: float = 2.0,
+    ) -> None:
+        """
+        Initialize a bounding box from center and dimensions.
+
+        Args:
+            center: Center of the bounding box (Vec3)
+            width: Width of the box
+            height: Height of the box
+            depth: Depth of the box
+        """
+        self._center: Vec3 = center
+        self._width: float = width
+        self._height: float = height
+        self._depth: float = depth
+        self._min_x: float = 0.0
+        self._max_x: float = 0.0
+        self._min_y: float = 0.0
+        self._max_y: float = 0.0
+        self._min_z: float = 0.0
+        self._max_z: float = 0.0
+        self._verts: list[Vec3] = [Vec3() for _ in range(8)]
+        self._normals: list[Vec3] = [Vec3() for _ in range(6)]
+        self.recalculate_from_center_dims()
+
+    @classmethod
+    def from_extents(
+        cls,
+        min_x: float,
+        max_x: float,
+        min_y: float,
+        max_y: float,
+        min_z: float,
+        max_z: float,
+    ) -> "BBox":
+        """
+        Create a bounding box from min/max extents.
+
+        Args:
+            min_x, max_x, min_y, max_y, min_z, max_z: Box extents
+
+        Returns:
+            BBox: The constructed bounding box
+        """
+        bbox = cls()
+        bbox.set_extents(min_x, max_x, min_y, max_y, min_z, max_z)
+        return bbox
+
+    @property
+    def center(self) -> Vec3:
+        """Get or set the center of the bounding box."""
+        return self._center
+
+    @center.setter
+    def center(self, value: Vec3) -> None:
+        self._center = value
+        self.recalculate_from_center_dims()
+
+    @property
+    def width(self) -> float:
+        """Get or set the width of the bounding box."""
+        return self._width
+
+    @width.setter
+    def width(self, value: float) -> None:
+        self._width = value
+        self.recalculate_from_center_dims()
+
+    @property
+    def height(self) -> float:
+        """Get or set the height of the bounding box."""
+        return self._height
+
+    @height.setter
+    def height(self, value: float) -> None:
+        self._height = value
+        self.recalculate_from_center_dims()
+
+    @property
+    def depth(self) -> float:
+        """Get or set the depth of the bounding box."""
+        return self._depth
+
+    @depth.setter
+    def depth(self, value: float) -> None:
+        self._depth = value
+        self.recalculate_from_center_dims()
+
+    @property
+    def min_x(self) -> float:
+        """Get the minimum x extent."""
+        return self._min_x
+
+    @property
+    def max_x(self) -> float:
+        """Get the maximum x extent."""
+        return self._max_x
+
+    @property
+    def min_y(self) -> float:
+        """Get the minimum y extent."""
+        return self._min_y
+
+    @property
+    def max_y(self) -> float:
+        """Get the maximum y extent."""
+        return self._max_y
+
+    @property
+    def min_z(self) -> float:
+        """Get the minimum z extent."""
+        return self._min_z
+
+    @property
+    def max_z(self) -> float:
+        """Get the maximum z extent."""
+        return self._max_z
+
+    def get_vertex_array(self) -> list[Vec3]:
+        """
+        Get the list of 8 vertices for the bounding box.
+
+        Returns:
+            list[Vec3]: The 8 vertices of the box.
+        """
+        return self._verts
+
+    def get_normal_array(self) -> list[Vec3]:
+        """
+        Get the list of 6 normals for the bounding box faces.
+
+        Returns:
+            list[Vec3]: The 6 normals of the box.
+        """
+        return self._normals
+
+    def set_extents(
+        self,
+        min_x: float,
+        max_x: float,
+        min_y: float,
+        max_y: float,
+        min_z: float,
+        max_z: float,
+    ) -> None:
+        """
+        Set the extents of the bounding box and recalculate center/dimensions.
+
+        Args:
+            min_x, max_x, min_y, max_y, min_z, max_z: Box extents
+        """
+        self._min_x = min_x
+        self._max_x = max_x
+        self._min_y = min_y
+        self._max_y = max_y
+        self._min_z = min_z
+        self._max_z = max_z
+        self.recalculate_from_extents()
+
+    def recalculate_from_center_dims(self) -> None:
+        """
+        Recalculate extents and update vertices/normals from center and dimensions.
+        """
+        half_width = self._width / 2.0
+        half_height = self._height / 2.0
+        half_depth = self._depth / 2.0
+
+        self._min_x = self._center.x - half_width
+        self._max_x = self._center.x + half_width
+        self._min_y = self._center.y - half_height
+        self._max_y = self._center.y + half_height
+        self._min_z = self._center.z - half_depth
+        self._max_z = self._center.z + half_depth
+        self._update_verts_and_normals()
+
+    def recalculate_from_extents(self) -> None:
+        """
+        Recalculate center and dimensions from extents, then update vertices/normals.
+        """
+        self._width = self._max_x - self._min_x
+        self._height = self._max_y - self._min_y
+        self._depth = self._max_z - self._min_z
+        self._center = Vec3(
+            self._min_x + self._width / 2.0,
+            self._min_y + self._height / 2.0,
+            self._min_z + self._depth / 2.0,
+        )
+        self._update_verts_and_normals()
+
+    def _update_verts_and_normals(self) -> None:
+        """
+        Update the 8 vertices and 6 normals of the bounding box based on current extents.
+        """
+        self._verts[0].set(self._min_x, self._max_y, self._min_z)
+        self._verts[1].set(self._max_x, self._max_y, self._min_z)
+        self._verts[2].set(self._max_x, self._max_y, self._max_z)
+        self._verts[3].set(self._min_x, self._max_y, self._max_z)
+        self._verts[4].set(self._min_x, self._min_y, self._min_z)
+        self._verts[5].set(self._max_x, self._min_y, self._min_z)
+        self._verts[6].set(self._max_x, self._min_y, self._max_z)
+        self._verts[7].set(self._min_x, self._min_y, self._max_z)
+
+        self._normals[0].set(0.0, 1.0, 0.0)
+        self._normals[1].set(0.0, -1.0, 0.0)
+        self._normals[2].set(1.0, 0.0, 0.0)
+        self._normals[3].set(-1.0, 0.0, 0.0)
+        self._normals[4].set(0.0, 0.0, 1.0)
+        self._normals[5].set(0.0, 0.0, -1.0)

ncca/ngl/bezier_curve.py

@@ -0,0 +1,75 @@
+from .vec3 import Vec3
+
+
+class BezierCurve:
+    """A Bezier curve class."""
+
+    def __init__(
+        self, control_points: list[Vec3] = None, knots: list[float] = None
+    ) -> None:
+        self._cp = control_points if control_points is not None else []
+        self._knots = knots if knots is not None else []
+        self._degree = 0
+        self._order = 0
+        self._num_cp = 0
+        self._num_knots = 0
+        if self._cp:
+            self._num_cp = len(self._cp)
+            self._degree = self._num_cp
+            self._order = self._degree + 1
+            if not self._knots:
+                self.create_knots()
+            self._num_knots = len(self._knots)
+
+    @property
+    def control_points(self) -> list[Vec3]:
+        return self._cp
+
+    @property
+    def knots(self) -> list[float]:
+        return self._knots
+
+    def add_point(self, x: float | Vec3, y: float = None, z: float = None) -> None:
+        if isinstance(x, Vec3):
+            self._cp.append(x)
+        else:
+            self._cp.append(Vec3(x, y, z))
+        self._num_cp += 1
+        self._degree = self._num_cp
+        self._order = self._degree + 1
+        self.create_knots()
+
+    def add_knot(self, k: float) -> None:
+        self._knots.append(k)
+        self._num_knots = len(self._knots)
+
+    def create_knots(self) -> None:
+        self._num_knots = self._num_cp + self._order
+        self._knots = [0.0] * (self._num_knots // 2) + [1.0] * (
+            self._num_knots - (self._num_knots // 2)
+        )
+
+    def get_point_on_curve(self, u: float) -> Vec3:
+        p = Vec3()
+        for i in range(self._num_cp):
+            val = self.cox_de_boor(u, i, self._degree, self._knots)
+            if val > 0.001:
+                p += self._cp[i] * val
+        return p
+
+    def cox_de_boor(self, u: float, i: int, k: int, knots: list[float]) -> float:
+        if k == 1:
+            return 1.0 if knots[i] <= u <= knots[i + 1] else 0.0
+
+        den1 = knots[i + k - 1] - knots[i]
+        den2 = knots[i + k] - knots[i + 1]
+
+        eq1 = 0.0
+        if den1 > 0:
+            eq1 = ((u - knots[i]) / den1) * self.cox_de_boor(u, i, k - 1, knots)
+
+        eq2 = 0.0
+        if den2 > 0:
+            eq2 = ((knots[i + k] - u) / den2) * self.cox_de_boor(u, i + 1, k - 1, knots)
+
+        return eq1 + eq2