ncca-ngl 0.1.0__tar.gz

ncca_ngl-0.1.0/LICENSE.txt

@@ -0,0 +1,7 @@
+Copyright 2024 Jon Macey
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

ncca_ngl-0.1.0/PKG-INFO

@@ -0,0 +1,23 @@
+Metadata-Version: 2.4
+Name: ncca-ngl
+Version: 0.1.0
+Summary: A Python version of the NGL graphics library.
+Author-email: Jon Macey <jmacey@bournemouth.ac.uk>
+License: Copyright 2024 Jon Macey
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+Project-URL: Homepage, https://github.com/NCCA/PyNGL
+Project-URL: Issues, https://github.com/NCCA/PyNGL/issues
+Requires-Python: >=3.13
+License-File: LICENSE.txt
+Requires-Dist: numpy>=2.3.3
+Requires-Dist: PyOpenGL
+Requires-Dist: Pillow
+Requires-Dist: glfw>=2.9.0
+Requires-Dist: freetype-py>=2.5.1
+Requires-Dist: pyside6>=6.9.2
+Dynamic: license-file

ncca_ngl-0.1.0/README.md

@@ -0,0 +1,22 @@
+# PyNGL
+
+This is the code for the full python version of [NGL](https://github.com/NCCA/NGL) the ncca graphics library.
+
+More details soon as this is work in progress.
+
+
+## Test
+
+use
+
+```
+uv run pytest
+```
+
+To run tests,
+
+```
+uv run pytest --cov=src --cov-report=term-missing
+```
+
+For coverage reports.

ncca_ngl-0.1.0/pyproject.toml

@@ -0,0 +1,47 @@
+[project]
+name = "ncca-ngl"
+version = "0.1.0"
+description = "A Python version of the NGL graphics library."
+authors = [{ name = "Jon Macey", email = "jmacey@bournemouth.ac.uk" }]
+requires-python = ">=3.13"
+license = { file = "LICENSE.txt" }
+
+dependencies = [
+    "numpy>=2.3.3",
+    "PyOpenGL",
+    "Pillow",
+    "glfw>=2.9.0",
+    "freetype-py>=2.5.1",
+    "pyside6>=6.9.2",
+]
+
+[project.urls]
+Homepage = "https://github.com/NCCA/PyNGL"
+Issues = "https://github.com/NCCA/PyNGL/issues"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+include = ["ncca.*"]
+
+[tool.pytest.ini_options]
+pythonpath = ["src","tests"]
+
+# [build-system]
+# requires = ["uv_build>=0.8.14,<0.9.0"]
+# build-backend = "uv_build"
+# module-name = ["ncca.ngl"]
+# module-root = "src/ncca/"
+
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[dependency-groups]
+dev = [
+    "coverage>=7.10.6",
+    "pytest>=8.4.2",
+    "pytest-cov>=7.0.0",
+    "ruff>=0.13.0",
+    "pre-commit>=4.3.0",
+
+]

ncca_ngl-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

ncca_ngl-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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: ...