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

ncca/ngl/simple_index_vao.py

@@ -1,65 +0,0 @@
-import numpy as np
-import OpenGL.GL as gl
-
-from .abstract_vao import AbstractVAO, VertexData
-from .log import logger
-
-
-class IndexVertexData(VertexData):
-    def __init__(self, data, size, indices, index_type, mode=gl.GL_STATIC_DRAW):
-        super().__init__(data, size, mode)
-        gl.GL_to_numpy_type = {
-            gl.GL_UNSIGNED_INT: np.uint32,
-            gl.GL_UNSIGNED_SHORT: np.uint16,
-            gl.GL_UNSIGNED_BYTE: np.uint8,
-        }
-        numpy_dtype = gl.GL_to_numpy_type.get(index_type)
-        if numpy_dtype is None:
-            logger.error("SimpleIndexVAO: Unsupported index type")
-            raise TypeError(f"Unsupported index type: {index_type}")
-
-        self.indices = np.array(indices, dtype=numpy_dtype)
-        self.index_type = index_type
-
-
-class SimpleIndexVAO(AbstractVAO):
-    def __init__(self, mode=gl.GL_TRIANGLES):
-        super().__init__(mode)
-        self.buffer = gl.glGenBuffers(1)
-        self.idx_buffer = gl.glGenBuffers(1)
-        self.index_type = gl.GL_UNSIGNED_INT
-
-    def draw(self):
-        if self.bound and self.allocated:
-            gl.glDrawElements(self.mode, self.indices_count, self.index_type, None)
-        else:
-            logger.error("SimpleIndexVAO not bound or not allocated")
-
-    def set_data(self, data):
-        if not isinstance(data, IndexVertexData):
-            logger.error("SimpleIndexVAO: Unsupported index type")
-            raise TypeError("data must be of type IndexVertexData")
-
-        gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self.buffer)
-        gl.glBufferData(gl.GL_ARRAY_BUFFER, data.data.nbytes, data.data, data.mode)
-
-        gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, self.idx_buffer)
-        gl.glBufferData(
-            gl.GL_ELEMENT_ARRAY_BUFFER, data.indices.nbytes, data.indices, data.mode
-        )
-
-        self.allocated = True
-        self.indices_count = len(data.indices)
-        self.index_type = data.index_type
-
-    def remove_vao(self):
-        gl.glDeleteBuffers(1, [self.buffer])
-        gl.glDeleteBuffers(1, [self.idx_buffer])
-        gl.glDeleteVertexArrays(1, [self.id])
-
-    def get_buffer_id(self, index=0):
-        return self.buffer
-
-    def map_buffer(self, index=0, access_mode=gl.GL_READ_WRITE):
-        gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self.buffer)
-        return gl.glMapBuffer(gl.GL_ARRAY_BUFFER, access_mode)

ncca/ngl/simple_vao.py

@@ -1,42 +0,0 @@
-import OpenGL.GL as gl
-
-from .abstract_vao import AbstractVAO, VertexData
-from .log import logger
-
-
-class SimpleVAO(AbstractVAO):
-    def __init__(self, mode=gl.GL_TRIANGLES):
-        super().__init__(mode)
-        self.buffer = gl.glGenBuffers(1)
-
-    def draw(self):
-        if self.bound and self.allocated:
-            gl.glDrawArrays(self.mode, 0, self.indices_count)
-        else:
-            logger.error("SimpleVAO not bound or not allocated")
-
-    def set_data(self, data):
-        if not isinstance(data, VertexData):
-            logger.error("SimpleVAO: Invalid data type")
-            raise TypeError("data must be of type VertexData")
-        if not self.bound:
-            logger.error("SimpleVAO not bound")
-            raise RuntimeError("SimpleVAO not bound")
-        gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self.buffer)
-        gl.glBufferData(gl.GL_ARRAY_BUFFER, data.data.nbytes, data.data, data.mode)
-        self.allocated = True
-        self.indices_count = data.size
-
-    def num_indices(self):
-        return self.indices_count
-
-    def remove_vao(self):
-        gl.glDeleteBuffers(1, [self.buffer])
-        gl.glDeleteVertexArrays(1, [self.id])
-
-    def get_buffer_id(self, index=0):
-        return self.buffer
-
-    def map_buffer(self, index=0, access_mode=gl.GL_READ_WRITE):
-        gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self.buffer)
-        return gl.glMapBuffer(gl.GL_ARRAY_BUFFER, access_mode)

ncca/ngl/text.py

@@ -1,346 +0,0 @@
-"""
-A module for rendering text in OpenGL using pre-rendered font atlases.
-
-This implementation uses the 'freetype-py' library to rasterize characters
-from a given font file into a single texture atlas. This atlas is then
-used by a set of shaders (vertex, geometry, and fragment) to render
-text efficiently.
-
-The process is as follows:
-1.  FontAtlas class:
-    -   Loads a font file.
-    -   Renders glyphs for a range of characters (ASCII ' ' to '~').
-    -   Packs these glyphs into a single large texture atlas in memory.
-    -   Calculates and stores metadata for each glyph (size, bearing,
-        advance, and UV coordinates within the atlas).
-    -   Generates a single OpenGL texture for the atlas.
-
-2.  _Text class (exported as Text):
-    -   Manages multiple fonts by creating and storing FontAtlas objects.
-    -   Provides a `render_dynamic_text` method to draw text strings.
-    -   `_build_instances`: For a given string, this method generates a
-        list of vertex attributes for each character. Each character is
-        represented as a single point with attributes for position, UVs,
-        and size.
-    -   `render_dynamic_text`: This method sends the generated instance
-        data to the GPU and draws it using GL_POINTS.
-
-3.  Shaders:
-    -   Vertex Shader: A simple pass-through shader that sends point
-        data to the geometry shader.
-    -   Geometry Shader: Receives points and generates a textured quad
-        for each character on the fly.
-    -   Fragment Shader: Samples the font atlas texture to color the
-        quad, effectively drawing the character.
-"""
-
-from typing import Any, Dict, List
-
-import freetype
-import numpy as np
-import OpenGL.GL as gl
-
-from .log import logger
-from .shader_lib import DefaultShader, ShaderLib
-from .simple_vao import VertexData
-from .vao_factory import VAOFactory, VAOType
-from .vec3 import Vec3
-
-
-class FontAtlas:
-    """
-    Manages the creation of a font texture atlas for efficient text rendering.
-
-    This class uses FreeType to render glyphs for a specified font and packs them
-    into a single texture. It also stores metadata for each glyph.
-    """
-
-    def __init__(self, font_path: str, font_size: int = 48, debug: bool = False):
-        """
-        Initializes the FontAtlas.
-
-        Args:
-            font_path: The file path to the font (e.g., a .ttf file).
-            font_size: The font size in pixels to be used for rendering the atlas.
-            debug: If True, saves the generated atlas as a PNG for debugging.
-        """
-        try:
-            self.face = freetype.Face(font_path)
-            self.face.set_pixel_sizes(0, font_size)
-            self.font_size: int = font_size
-            self.glyphs: Dict[str, Dict[str, Any]] = {}
-            self.texture: int = 0
-            self.atlas_w: int = 0
-            self.atlas_h: int = 0
-            self.atlas: np.ndarray | None = None
-            self.build_atlas(debug)
-
-        except freetype.FT_Exception as e:
-            logger.error(f"{font_path} could not be loaded {e}")
-
-    def __str__(self) -> str:
-        """Returns a string representation of the FontAtlas."""
-        return f"TextureID: {self.texture}, FontSize: {self.font_size}"
-
-    def build_atlas(self, debug: bool = False) -> None:
-        """
-        Renders characters and packs them into a texture atlas.
-
-        This method iterates through ASCII characters 32-126, renders each one
-        using FreeType, and arranges them in a single large numpy array which
-        will later be used to create an OpenGL texture.
-
-        Args:
-            debug: If True, saves the generated atlas as 'debug_atlas.png'.
-        """
-        padding = 2  # Padding between glyphs in the atlas
-        atlas_w = 1024  # Fixed width for the atlas texture
-        x, y, row_h = 0, 0, 0
-        bitmaps_data = []
-
-        # Iterate through printable ASCII characters
-        for charcode in range(ord(" "), ord("~")):
-            self.face.load_char(chr(charcode), freetype.FT_LOAD_RENDER)
-            bmp = self.face.glyph.bitmap
-            w, h = bmp.width, bmp.rows
-
-            # Move to the next row if the current glyph doesn't fit
-            if x + w + padding > atlas_w:
-                x = 0
-                y += row_h + padding
-                row_h = 0
-
-            # Copy bitmap data as the buffer is overwritten for each glyph
-            if w > 0 and h > 0:
-                buffer_copy = np.array(bmp.buffer, dtype=np.ubyte).reshape(h, w)
-                bitmaps_data.append((buffer_copy, x, y))
-
-            # Store glyph metadata
-            self.glyphs[chr(charcode)] = {
-                "size": (w, h),
-                "bearing": (self.face.glyph.bitmap_left, self.face.glyph.bitmap_top),
-                "advance": self.face.glyph.advance.x >> 6,  # Advance is in 1/64 pixels
-                "uv": (x, y, x + w, y + h),  # UVs in pixel coordinates
-            }
-            x += w + padding
-            row_h = max(row_h, h)
-
-        atlas_h = y + row_h + padding
-        self.atlas_w, self.atlas_h = atlas_w, atlas_h
-        atlas = np.zeros((atlas_h, atlas_w), dtype=np.ubyte)
-
-        # Blit all the individual glyph bitmaps onto the atlas
-        for arr, dest_x, dest_y in bitmaps_data:
-            h, w = arr.shape
-            atlas[dest_y : dest_y + h, dest_x : dest_x + w] = arr
-
-        self.atlas = atlas
-        if debug:
-            from PIL import Image
-
-            img = Image.fromarray(self.atlas, mode="L")
-            img.save("debug_atlas.png")
-            print(f"Saved debug_atlas.png, size: {self.atlas.shape}")
-
-    def generate_texture(self) -> None:
-        """Generates and configures the OpenGL texture for the font atlas."""
-        if self.atlas is None:
-            return
-        tex = gl.glGenTextures(1)
-        gl.glPixelStorei(gl.GL_UNPACK_ALIGNMENT, 1)
-
-        gl.glBindTexture(gl.GL_TEXTURE_2D, tex)
-        # Create a single-channel RED texture from our numpy atlas
-        gl.glTexImage2D(
-            gl.GL_TEXTURE_2D,
-            0,
-            gl.GL_RED,
-            self.atlas_w,
-            self.atlas_h,
-            0,
-            gl.GL_RED,
-            gl.GL_UNSIGNED_BYTE,
-            self.atlas,
-        )
-
-        gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_LINEAR)
-        gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_LINEAR)
-        gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_S, gl.GL_CLAMP_TO_EDGE)
-        gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_T, gl.GL_CLAMP_TO_EDGE)
-
-        # Use texture swizzling to use the RED channel as ALPHA.
-        # This allows us to color the font using a uniform in the shader,
-        # while using the glyph's intensity for transparency.
-        # We set the texture's RGB channels to 1.0, and the A channel to the
-        # value from the RED channel of the source.
-        gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_SWIZZLE_R, gl.GL_ONE)
-        gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_SWIZZLE_G, gl.GL_ONE)
-        gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_SWIZZLE_B, gl.GL_ONE)
-        gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_SWIZZLE_A, gl.GL_RED)
-
-        self.texture = tex
-
-
-class _Text:
-    """
-    Main class for managing and rendering text.
-
-    This class acts as a controller, loading fonts and providing methods
-    to render text strings to the screen. It is designed to be used as a
-    singleton instance.
-    """
-
-    def __init__(self) -> None:
-        """Initializes the Text renderer."""
-        self._fonts: Dict[str, FontAtlas] = {}
-        self._static_text: List[Any] = []  # Reserved for future use
-
-    def add_font(self, name: str, font_file: str, size: int) -> None:
-        """
-        Loads a font and makes it available for rendering.
-
-        Args:
-            name: A unique name to identify this font (e.g., "main_font").
-            font_file: The path to the font file.
-            size: The font size in pixels.
-        """
-        if not hasattr(self, "vao"):
-            self.vao = VAOFactory.create_vao(VAOType.SIMPLE, gl.GL_POINTS)
-        font = FontAtlas(font_file, size)
-        font.generate_texture()
-        print(f"Font '{name}' added with texture ID: {font.texture}")
-        self._fonts[name] = font
-
-    def set_screen_size(self, w: int, h: int) -> None:
-        """
-        Sets the screen dimensions for the text shader.
-
-        This should be called whenever the window is resized.
-
-        Args:
-            w: The width of the screen in pixels.
-            h: The height of the screen in pixels.
-        """
-        ShaderLib.use(DefaultShader.TEXT)
-        ShaderLib.set_uniform("textureID", 0)
-        ShaderLib.set_uniform("screenSize", w, h)
-        ShaderLib.set_uniform("fontSize", 1.0)
-        ShaderLib.set_uniform("textColor", 1.0, 1.0, 1.0, 1.0)
-
-    def render_text(
-        self, font: str, x: int, y: int, text: str, colour: Vec3 = Vec3(1, 1, 1)
-    ) -> None:
-        """
-        Renders a string of text to the screen.
-
-        Args:
-            font: The name of the font to use (previously added with add_font).
-            x: The x-coordinate of the starting position (baseline).
-            y: The y-coordinate of the starting position (baseline).
-            text: The string of text to render.
-            colour: The color of the text as a Vec4.
-        """
-        render_data = self._build_instances(font, text, x, y)
-        if not render_data:
-            return
-
-        buffer_data = np.array(render_data, dtype=np.float32)
-        atlas = self._fonts[font]
-
-        # Enable blending for transparency
-        gl.glEnable(gl.GL_BLEND)
-        gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
-
-        # Ensure text is rendered filled and restore state afterwards.
-        polygon_mode = gl.glGetIntegerv(gl.GL_POLYGON_MODE)[0]
-        if polygon_mode != gl.GL_FILL:
-            gl.glPolygonMode(gl.GL_FRONT_AND_BACK, gl.GL_FILL)
-
-        # Disable depth testing to ensure text is always drawn on top
-        depth_test_enabled = gl.glIsEnabled(gl.GL_DEPTH_TEST)
-        if depth_test_enabled:
-            gl.glDisable(gl.GL_DEPTH_TEST)
-
-        with self.vao as vao:
-            data = VertexData(data=buffer_data, size=buffer_data.nbytes)
-            stride = 32  # 8 floats * 4 bytes
-            vao.set_data(data)
-            # Vertex Attributes:
-            # 0: vec2 a_position (screen position of the glyph)
-            # 1: vec4 a_uvRect (u0, v0, u1, v1)
-            # 2: vec2 a_size (width, height of the glyph quad)
-            vao.set_vertex_attribute_pointer(0, 2, gl.GL_FLOAT, stride, 0)
-            vao.set_vertex_attribute_pointer(1, 4, gl.GL_FLOAT, stride, 8)
-            vao.set_vertex_attribute_pointer(2, 2, gl.GL_FLOAT, stride, 24)
-
-            gl.glActiveTexture(gl.GL_TEXTURE0)
-            gl.glBindTexture(gl.GL_TEXTURE_2D, atlas.texture)
-            ShaderLib.use(DefaultShader.TEXT)
-            ShaderLib.set_uniform("textColor", colour.x, colour.y, colour.z, 1.0)
-            # We are drawing one point per character
-            vao.set_num_indices(len(render_data) // 8)
-            vao.draw()
-
-        # Restore OpenGL state
-        gl.glDisable(gl.GL_BLEND)
-        if depth_test_enabled:
-            gl.glEnable(gl.GL_DEPTH_TEST)
-        if polygon_mode != gl.GL_FILL:
-            gl.glPolygonMode(gl.GL_FRONT_AND_BACK, polygon_mode)
-
-    def _build_instances(
-        self, font: str, text: str, start_x: int, start_y: int
-    ) -> List[float]:
-        """
-        Generates vertex attribute data for each character in a string.
-
-        This data is sent to the GPU as a single buffer. The geometry shader
-        then uses this data to construct a quad for each character.
-
-        Args:
-            font: The name of the font to use.
-            text: The string to process.
-            start_x: The initial x-coordinate for the text baseline.
-            start_y: The initial y-coordinate for the text baseline.
-
-        Returns:
-            A list of floats representing the packed vertex data for all characters.
-        """
-        inst = []
-        atlas = self._fonts.get(font)
-        if atlas:
-            x, y = float(start_x), float(start_y)  # Use floats for positioning
-
-            for ch in text:
-                if ch not in atlas.glyphs:
-                    continue
-                g = atlas.glyphs[ch]
-                w, h = g["size"]
-                adv = g["advance"]
-                bearing_x, bearing_y = g["bearing"]
-
-                # UV coordinates from atlas (in pixels)
-                u0_px, v0_px, u1_px, v1_px = g["uv"]
-
-                # Normalize UVs to the range [0, 1]
-                u0 = u0_px / atlas.atlas_w
-                v0 = v0_px / atlas.atlas_h
-                u1 = u1_px / atlas.atlas_w
-                v1 = v1_px / atlas.atlas_h
-
-                # Calculate the screen position for the top-left corner of the quad.
-                # FreeType's origin is at the baseline, with +y going up.
-                # Screen coordinates usually have +y going down, so we adjust.
-                pos_x = x + bearing_x
-                pos_y = y - bearing_y
-
-                # Each character is defined by 8 floats:
-                # pos_x, pos_y, u0, v0, u1, v1, w, h
-                inst.extend([pos_x, pos_y, u0, v0, u1, v1, float(w), float(h)])
-                # Advance the cursor for the next character
-                x += adv
-        return inst
-
-
-# Create a singleton instance of the Text class for global use.
-Text = _Text()

ncca/ngl/texture.py

@@ -1,75 +0,0 @@
-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

@@ -1,95 +0,0 @@
-"""
-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}"