ncca-ngl 0.1.0__py3-none-any.whl

ncca/ngl/vec4.py

@@ -0,0 +1,229 @@
+"""
+Simple Float only Vec3 class for 3D graphics, very similar to the pyngl ones
+"""
+
+import ctypes
+import math
+
+import numpy as np
+
+from .log import logger
+
+
+class Vec4:
+    __slots__ = ["_x", "_y", "_z", "_w"]
+    "by using slots we fix our class attributes to x,y,z,w"
+
+    def __init__(self, x=0.0, y=0.0, z=0.0, w=1.0):
+        """simple ctor"""
+        self._x = x  # x component of vector : float
+        self._y = y  # y component of vector : float
+        self._z = z  # z component of vector : float
+        self._w = w  # w component of vector : float
+
+    @classmethod
+    def sizeof(cls):
+        return 4 * ctypes.sizeof(ctypes.c_float)
+
+    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 __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
+        yield self.w
+
+    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, self.w]
+        try:
+            return components[index]
+        except IndexError:
+            raise IndexError("Index out of range. Valid indices are 0, 1, 2, and 3.")
+
+    def clone(self) -> "Vec4":
+        """
+        Create a copy of the vector.
+        Returns:
+            Vec4: A new Vec4 instance with the same values.
+        """
+        return Vec4(self.x, self.y, self.z, self.w)
+
+    def __add__(self, rhs):
+        "return a+b vector addition"
+        r = Vec4()
+        r.x = self.x + rhs.x
+        r.y = self.y + rhs.y
+        r.z = self.z + rhs.z
+        r.w = self.w + rhs.w
+        return r
+
+    def __iadd__(self, rhs):
+        "return a+=b vector addition"
+        self.x += rhs.x
+        self.y += rhs.y
+        self.z += rhs.z
+        self.w += rhs.w
+
+        return self
+
+    def __sub__(self, rhs):
+        "return a+b vector addition"
+        r = Vec4()
+        r.x = self.x - rhs.x
+        r.y = self.y - rhs.y
+        r.z = self.z - rhs.z
+        r.w = self.w - rhs.w
+        return r
+
+    def __isub__(self, rhs):
+        "return a+=b vector addition"
+        self.x -= rhs.x
+        self.y -= rhs.y
+        self.z -= rhs.z
+        self.w -= rhs.w
+        return self
+
+    def set(self, x, y, z, w=1.0):
+        "set from x,y,z,w will convert to float an raise value error if problem"
+        try:
+            self.x = float(x)
+            self.y = float(y)
+            self.z = float(z)
+            self.w = float(w)
+        except ValueError:
+            logger.warning("need float values")
+            raise
+
+    def dot(self, rhs):
+        return (self.x * rhs.x) + (self.y * rhs.y) + (self.z * rhs.z) + (self.w * rhs.w)
+
+    def length(self):
+        "length of vector"
+        return math.sqrt(self.x**2 + self.y**2 + self.z**2 + self.w**2)
+
+    def length_squared(self):
+        "square length of vector"
+        return self.x**2 + self.y**2 + self.z**2 + self.w**2
+
+    def normalize(self):
+        "normalize this vector"
+        length = self.length()
+        try:
+            self.x /= length
+            self.y /= length
+            self.z /= length
+            self.w /= length
+        except ZeroDivisionError:
+            raise ZeroDivisionError("cannot normalize the zero vector")
+        return self
+
+    def __eq__(self, rhs):
+        "test a==b using math.isclose"
+        if not isinstance(rhs, Vec4):
+            return NotImplemented
+        return (
+            math.isclose(self.x, rhs.x)
+            and math.isclose(self.y, rhs.y)
+            and math.isclose(self.z, rhs.z)
+            and math.isclose(self.w, rhs.w)
+        )
+
+    def __neq__(self, rhs):
+        "test a!=b using math.isclose"
+        if not isinstance(rhs, Vec4):
+            return NotImplemented
+        return not (
+            math.isclose(self.x, rhs.x)
+            and math.isclose(self.y, rhs.y)
+            and math.isclose(self.z, rhs.z)
+            and math.isclose(self.w, rhs.w)
+        )
+
+    def __neg__(self):
+        self.x = -self.x
+        self.y = -self.y
+        self.z = -self.z
+        self.w = -self.w
+        return self
+
+    def __mul__(self, rhs):
+        if isinstance(rhs, (float, int)):
+            "Vec4 * scalar multiplication"
+            return Vec4(self.x * rhs, self.y * rhs, self.z * rhs, self.w * rhs)
+        else:
+            raise ValueError
+
+    def __rmul__(self, rhs):
+        return self * rhs
+
+    def __truediv__(self, rhs):
+        if isinstance(rhs, (float, int)):
+            return Vec4(self.x / rhs, self.y / rhs, self.z / rhs, self.w / rhs)
+        elif isinstance(rhs, Vec4):
+            return Vec4(self.x / rhs.x, self.y / rhs.y, self.z / rhs.z, self.w / rhs.w)
+        else:
+            raise ValueError(f"can only do piecewise division with a scalar {rhs=}")
+
+    def __matmul__(self, rhs):
+        "Vec4 @ Mat4 matrix multiplication"
+        return Vec4(
+            self.x * rhs.m[0][0] + self.y * rhs.m[1][0] + self.z * rhs.m[2][0] + self.w * rhs.m[3][0],
+            self.x * rhs.m[0][1] + self.y * rhs.m[1][1] + self.z * rhs.m[2][1] + self.w * rhs.m[3][1],
+            self.x * rhs.m[0][2] + self.y * rhs.m[1][2] + self.z * rhs.m[2][2] + self.w * rhs.m[3][2],
+            self.x * rhs.m[0][3] + self.y * rhs.m[1][3] + self.z * rhs.m[2][3] + self.w * rhs.m[3][3],
+        )
+
+    def __repr__(self):
+        "repr for debugging purposes"
+        return f"Vec4 [{self.x},{self.y},{self.z},{self.w}]"
+
+    def __str__(self):
+        "print out the vector as a string"
+        return f"[{self.x},{self.y},{self.z},{self.w}]"
+
+    def to_list(self):
+        return [self.x, self.y, self.z, self.w]
+
+    def to_numpy(self):
+        return np.array([self.x, self.y, self.z, self.w])
+
+
+# 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,w
+for attr in ["x", "y", "z", "w"]:
+    setattr(Vec4, attr, _create_property(attr))

ncca/ngl/vec4_array.py

@@ -0,0 +1,106 @@
+"""
+A container for ngl.Vec4 objects that mimics some of the behavior of a std::vector
+"""
+
+import numpy as np
+
+from .vec4 import Vec4
+
+
+class Vec4Array:
+    """
+    A class to hold a list of Vec4 objects and perform operations on them.
+    """
+
+    def __init__(self, values=None):
+        """
+        Initializes the Vec4Array.
+
+        Args:
+            values (iterable, optional): An iterable of Vec4 objects. Defaults to None.
+        """
+        self._data = []
+        if values is not None:
+            for v in values:
+                if not isinstance(v, Vec4):
+                    raise TypeError("All elements must be of type Vec4")
+                self._data.append(v)
+
+    def __getitem__(self, index):
+        """
+        Get the Vec4 at the specified index.
+
+        Args:
+            index (int): The index of the element.
+
+        Returns:
+            Vec4: The Vec4 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 Vec4 object to the array.
+
+        Args:
+            value (Vec4): The Vec4 object to append.
+        """
+        if not isinstance(value, Vec4):
+            raise TypeError("Only Vec4 objects can be appended")
+        self._data.append(value)
+
+    def extend(self, values):
+        """
+        Extend the array with a list of Vec4 objects.
+
+        Args:
+            values (list): A list of Vec4 objects to extend.
+        """
+        if not all(isinstance(v, Vec4) for v in values):
+            raise TypeError("All elements must be of type Vec4")
+        self._data.extend(values)
+
+    def to_list(self):
+        """
+        Convert the array of Vec4 objects to a single flat list of floats.
+
+        Returns:
+            list: A list of x, y, z, w components concatenated.
+        """
+        return [comp for vec in self._data for comp in vec]
+
+    def to_numpy(self):
+        """
+        Convert the array of Vec4 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"Vec4Array({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) * Vec4.sizeof()

ncca_ngl-0.1.0.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,41 @@
+ncca/ngl/__init__.py,sha256=i01MBdh814MrDmPDvG4dPI6azBWZWTq212cfVNnKkR8,2308
+ncca/ngl/abstract_vao.py,sha256=VLKp3pmPYK_dQgEImMOAQ0DufAswK_0H4DR4r8flp2U,2104
+ncca/ngl/base_mesh.py,sha256=2JmVT5_bvgLHra1VnwRld-mh-20IqqekgEu1dbGU1a4,5736
+ncca/ngl/base_mesh.pyi,sha256=kobLuNnCSZlRRobIgVopQaS7Bjg0tJ3m4M64WXt5I-M,173
+ncca/ngl/bbox.py,sha256=PylB6ju_bkdDUqQkzO1n2E-jsmxiviNkyBLY-sN59n8,6578
+ncca/ngl/bezier_curve.py,sha256=A0aidWJ7c8Bh2KGCgCJ7aH8c8MakP8xrFFEFvCjva38,2297
+ncca/ngl/first_person_camera.py,sha256=Rrt3ibMh72K8gPBu6B8neIbYk5lnNZcDnvBB8mq5pz0,5890
+ncca/ngl/image.py,sha256=zpG8egzXWkUJKQxpRhXndpRxJDKOKHZkDjQuKSRXN2E,2692
+ncca/ngl/log.py,sha256=b7l-XNJIpP36VqcCGXBV_0XT5Nkd5eyuC7043lWegcw,1282
+ncca/ngl/mat2.py,sha256=algDowqqP_pQ3Crl-xiqkQqRaYohfpymfaZYxvbH0qc,3437
+ncca/ngl/mat3.py,sha256=imWKkMuPPWLctIpU2lDqKTu014bWHSq5eEpIj4E7MzE,12404
+ncca/ngl/mat4.py,sha256=eGvmLfw_wwKuuVh29wAKrvSZJB41jgmcYV5EufzyXbo,17273
+ncca/ngl/multi_buffer_vao.py,sha256=cuNE6gSrqkNcYvfIOYOZp4MVnpCvChUgnzsf7b60pWg,1752
+ncca/ngl/obj.py,sha256=AGldNouHrkrDs2UhATClGkgo4dzr6lzArR4YeCxQKmo,13667
+ncca/ngl/plane.py,sha256=96WuGzexYKhoeRVevGP2pZcustt9fzyyAjuwJHT25tk,1299
+ncca/ngl/primitives.py,sha256=G4X5kPROgcO2hZf8YkYvviS5C2kPLXrlSerJUdD6Fog,22575
+ncca/ngl/pyside_event_handling_mixin.py,sha256=L8obXeTp-g2Va2eXyd1hnmSp-sY7p4GX6EcFYRnH1F4,10588
+ncca/ngl/quaternion.py,sha256=MeQ-oxufo96TJ1GusRdpaHJsjfD6hG1ADsqTiBbHxlM,3814
+ncca/ngl/random.py,sha256=wX1R2rMpb76TP4rk44NUp5XoVuMisH9d-eBG5kFBZsM,5579
+ncca/ngl/shader.py,sha256=fEz8R_itsQssIxQp1E8-PhY3aOaTdm7sXpyFYoARSic,7696
+ncca/ngl/shader_lib.py,sha256=YmF3EJM9roTEt5OI5sHonAVN_ydIseyiOUBFZTX4KdA,18627
+ncca/ngl/shader_program.py,sha256=GAOWSlixWn6IzN4mM6tIahKtQytsatUXQVsNhu2ynO4,28407
+ncca/ngl/simple_index_vao.py,sha256=1IVy1WQH4V8_viZbRoIMbDRJsiH7iAhw0GEWUV9KpAU,2338
+ncca/ngl/simple_vao.py,sha256=jfU2O3yliaM6iWNvfcRbjQ6o2_IVSPrOR3GthDiul6Q,1419
+ncca/ngl/text.py,sha256=dMakFdwCWNY4PWbOF8SPZsYa-qFUzwTBp1XfrGnY6l0,13535
+ncca/ngl/texture.py,sha256=OgBBEItgUDohCsVWgmjEWcQWBJaXl9w070PTOOywPx4,2303
+ncca/ngl/transform.py,sha256=_PibgtFoU_exfvQUWucmts0WF5OreSTNbftvSa3zT8g,2938
+ncca/ngl/util.py,sha256=RLgGmxTq4gzlMKdAfLrO3gtV8VUSP5WtQK4hyLV6waQ,3558
+ncca/ngl/vao_factory.py,sha256=v87VfrUMaoqcsE-CS9kM7h5Fyk_e0LGl_iA6xqaomPg,930
+ncca/ngl/vec2.py,sha256=hJ0RWBxmeh-OOro_Y9lKocgiuu0f9vxp6L2_6vKfwUQ,10331
+ncca/ngl/vec2_array.py,sha256=k3jYqUqsc_nXVxzpkipNw49-y6uFEQZBHiBkA5s4u0A,2693
+ncca/ngl/vec3.py,sha256=q4HI4y4Xk3lTdlB8YdF4T2mCdwK2jXRattjDHlJi7vg,12265
+ncca/ngl/vec3_array.py,sha256=okRU8rp-jGYg2AzEUWx-ErsBkH1fG4L16c8nGKu-v04,2808
+ncca/ngl/vec4.py,sha256=zF0zw5EO4UE7EmqN30LPR3QQfaMcA1VcMID8CZALDiU,6740
+ncca/ngl/vec4_array.py,sha256=CCyHM4nIHvlwWxa12jCrJp-j6qfIYvU_irbdcB7NO0g,2699
+ncca/ngl/PrimData/pack_arrays.py,sha256=aWShJX8QPHXKTj66C8yu1DskmD3VEzFXyaADcxw6YKs,362
+ncca_ngl-0.1.0.dist-info/licenses/LICENSE.txt,sha256=WY4-vI3NTjw6HGwshZcyvEYhvAKBX3rpY7x9wMF_FhA,1056
+ncca_ngl-0.1.0.dist-info/METADATA,sha256=K_RFj72JMSY1SwA0-7kBTMECJ-35KHRe0G029qb4WSM,1620
+ncca_ngl-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ncca_ngl-0.1.0.dist-info/top_level.txt,sha256=nCKLyKtzlEVkOyE2KwxaykU3UgPocbQqRoMUXcICm3s,5
+ncca_ngl-0.1.0.dist-info/RECORD,,

ncca_ngl-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

ncca_ngl-0.1.0.dist-info/licenses/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.dist-info/top_level.txt

@@ -0,0 +1 @@
+ncca