e2D 2.0.0__cp313-cp313-win_amd64.whl → 2.0.2__cp313-cp313-win_amd64.whl

e2D/shapes.pyi

@@ -0,0 +1,272 @@
+"""
+Type stubs for shapes module
+High-performance 2D shape rendering using SDF and GPU shaders
+"""
+
+import moderngl
+import numpy as np
+import numpy.typing as npt
+from typing import Optional, Sequence
+from enum import Enum
+from .types import ContextType, ProgramType, VAOType, VectorType, ColorType, BufferType
+from .color_defs import WHITE, TRANSPARENT
+
+class FillMode(Enum):
+    """Shape fill mode"""
+    FILL: int
+    STROKE: int
+    FILL_STROKE: int
+
+class ShapeLabel:
+    """A pre-rendered shape for efficient repeated drawing."""
+    ctx: ContextType
+    prog: ProgramType
+    vbo: BufferType
+    vertex_count: int
+    shape_type: str
+    vao: VAOType
+    
+    def __init__(
+        self, 
+        ctx: ContextType, 
+        prog: ProgramType, 
+        vbo: BufferType, 
+        vertex_count: int, 
+        shape_type: str = 'line'
+    ) -> None: ...
+    
+    def draw(self) -> None:
+        """Draw the cached shape."""
+        ...
+
+class InstancedShapeBatch:
+    """High-performance instanced batch for drawing thousands of shapes with minimal CPU overhead."""
+    ctx: ContextType
+    prog: ProgramType
+    shape_type: str
+    max_instances: int
+    instance_count: int
+    floats_per_instance: int
+    instance_buffer: BufferType
+    quad_vbo: BufferType
+    vao: VAOType
+    instance_data: list[float]
+    
+    def __init__(
+        self, 
+        ctx: ContextType, 
+        prog: ProgramType, 
+        shape_type: str = 'circle', 
+        max_instances: int = 100000
+    ) -> None: ...
+    
+    def add_circle(
+        self, 
+        center: VectorType, 
+        radius: float,
+        color: ColorType = (1.0, 1.0, 1.0, 1.0),
+        border_color: ColorType = (0.0, 0.0, 0.0, 0.0),
+        border_width: float = 0.0,
+        antialiasing: float = 1.0
+    ) -> None:
+        """Add a circle instance to the batch."""
+        ...
+    
+    def add_circles_numpy(
+        self, 
+        centers: npt.NDArray[np.float32], 
+        radii: npt.NDArray[np.float32], 
+        colors: npt.NDArray[np.float32],
+        border_colors: Optional[npt.NDArray[np.float32]] = None,
+        border_widths: Optional[npt.NDArray[np.float32]] = None,
+        antialiasing: float = 1.0
+    ) -> None:
+        """Add multiple circles efficiently using numpy arrays (10-50x faster than loop)."""
+        ...
+    
+    def add_rect(
+        self, 
+        center: VectorType, 
+        size: VectorType,
+        color: ColorType = (1.0, 1.0, 1.0, 1.0),
+        corner_radius: float = 0.0,
+        border_color: ColorType = (0.0, 0.0, 0.0, 0.0),
+        border_width: float = 0.0,
+        antialiasing: float = 1.0,
+        rotation: float = 0.0
+    ) -> None:
+        """Add a rectangle instance to the batch."""
+        ...
+    
+    def add_rects_numpy(
+        self, 
+        centers: npt.NDArray[np.float32], 
+        sizes: npt.NDArray[np.float32],
+        colors: npt.NDArray[np.float32],
+        corner_radii: Optional[npt.NDArray[np.float32]] = None,
+        border_colors: Optional[npt.NDArray[np.float32]] = None,
+        border_widths: Optional[npt.NDArray[np.float32]] = None,
+        antialiasing: float = 1.0,
+        rotations: Optional[npt.NDArray[np.float32]] = None
+    ) -> None:
+        """Add multiple rectangles efficiently using numpy arrays."""
+        ...
+    
+    def add_line(
+        self, 
+        start: VectorType, 
+        end: VectorType,
+        width: float = 1.0,
+        color: ColorType = (1.0, 1.0, 1.0, 1.0)
+    ) -> None:
+        """Add a line instance to the batch."""
+        ...
+    
+    def add_lines_numpy(
+        self, 
+        starts: npt.NDArray[np.float32], 
+        ends: npt.NDArray[np.float32],
+        widths: npt.NDArray[np.float32], 
+        colors: npt.NDArray[np.float32]
+    ) -> None:
+        """Add multiple lines efficiently using numpy arrays."""
+        ...
+    
+    def flush(self) -> None:
+        """Draw all instances in a single draw call."""
+        ...
+    
+    def clear(self) -> None:
+        """Clear the batch without drawing."""
+        ...
+
+class ShapeRenderer:
+    """
+    High-performance 2D shape renderer using SDF (Signed Distance Functions) and GPU shaders.
+    Supports immediate mode, cached drawing, and batched rendering.
+    """
+    ctx: ContextType
+    circle_instanced_prog: ProgramType
+    rect_instanced_prog: ProgramType
+    line_instanced_prog: ProgramType
+    circle_prog: ProgramType
+    rect_prog: ProgramType
+    line_prog: ProgramType
+    circle_vbo: BufferType
+    rect_vbo: BufferType
+    line_vbo: BufferType
+    circle_vao: VAOType
+    rect_vao: VAOType
+    line_vao: VAOType
+    
+    def __init__(self, ctx: ContextType) -> None: ...
+    
+    def draw_circle(
+        self, 
+        center: VectorType, 
+        radius: float,
+        color: ColorType = (1.0, 1.0, 1.0, 1.0),
+        rotation: float = 0.0,
+        border_color: ColorType = (0.0, 0.0, 0.0, 0.0),
+        border_width: float = 0.0,
+        antialiasing: float = 1.0
+    ) -> None:
+        """Draw a circle immediately."""
+        ...
+    
+    def create_circle(
+        self, 
+        center: VectorType, 
+        radius: float,
+        color: ColorType = (1.0, 1.0, 1.0, 1.0),
+        rotation: float = 0.0,
+        border_color: ColorType = (0.0, 0.0, 0.0, 0.0),
+        border_width: float = 0.0,
+        antialiasing: float = 1.0
+    ) -> ShapeLabel:
+        """Create a cached circle for repeated drawing."""
+        ...
+    
+    def draw_rect(
+        self, 
+        position: VectorType, 
+        size: VectorType,
+        color: ColorType = (1.0, 1.0, 1.0, 1.0),
+        rotation: float = 0.0,
+        corner_radius: float = 0.0,
+        border_color: ColorType = (0.0, 0.0, 0.0, 0.0),
+        border_width: float = 0.0,
+        antialiasing: float = 1.0
+    ) -> None:
+        """Draw a rectangle immediately."""
+        ...
+    
+    def create_rect(
+        self, 
+        position: VectorType, 
+        size: VectorType,
+        color: ColorType = (1.0, 1.0, 1.0, 1.0),
+        rotation: float = 0.0,
+        corner_radius: float = 0.0,
+        border_color: ColorType = (0.0, 0.0, 0.0, 0.0),
+        border_width: float = 0.0,
+        antialiasing: float = 1.0
+    ) -> ShapeLabel:
+        """Create a cached rectangle for repeated drawing."""
+        ...
+    
+    def draw_line(
+        self, 
+        start: VectorType, 
+        end: VectorType,
+        width: float = 1.0,
+        color: ColorType = (1.0, 1.0, 1.0, 1.0),
+        antialiasing: float = 1.0
+    ) -> None:
+        """Draw a single line segment."""
+        ...
+    
+    def draw_lines(
+        self, 
+        points: npt.NDArray[np.float32] | Sequence[VectorType],
+        width: float = 1.0,
+        color: ColorType | npt.NDArray[np.float32] = (1.0, 1.0, 1.0, 1.0),
+        antialiasing: float = 1.0,
+        closed: bool = False
+    ) -> None:
+        """Draw a polyline (connected line segments)."""
+        ...
+    
+    def create_line(
+        self, 
+        start: VectorType, 
+        end: VectorType,
+        width: float = 1.0,
+        color: ColorType = (1.0, 1.0, 1.0, 1.0),
+        antialiasing: float = 1.0
+    ) -> ShapeLabel:
+        """Create a cached line for repeated drawing."""
+        ...
+    
+    def create_lines(
+        self, 
+        points: npt.NDArray[np.float32] | Sequence[VectorType],
+        width: float = 1.0,
+        color: ColorType | npt.NDArray[np.float32] = (1.0, 1.0, 1.0, 1.0),
+        antialiasing: float = 1.0,
+        closed: bool = False
+    ) -> ShapeLabel:
+        """Create a cached polyline for repeated drawing."""
+        ...
+    
+    def create_circle_batch(self, max_shapes: int = 10000) -> InstancedShapeBatch:
+        """Create a batch for drawing multiple circles efficiently using GPU instancing."""
+        ...
+    
+    def create_rect_batch(self, max_shapes: int = 10000) -> InstancedShapeBatch:
+        """Create a batch for drawing multiple rectangles efficiently using GPU instancing."""
+        ...
+    
+    def create_line_batch(self, max_shapes: int = 10000) -> InstancedShapeBatch:
+        """Create a batch for drawing multiple lines efficiently using GPU instancing."""
+        ...

e2D/test_colors.py

@@ -0,0 +1,122 @@
+"""
+Test script for new e2D color system
+Demonstrates usage and verifies functionality
+"""
+
+# Test basic imports - use direct imports to avoid types.py conflict
+import sys
+import os
+sys.path.insert(0, os.path.dirname(__file__))
+
+from colors import Color, normalize_color, lerp_colors, gradient
+from color_defs import RED, BLUE, GREEN, ORANGE, get_color, MD_BLUE
+
+print("=" * 60)
+print("e2D Color System Test")
+print("=" * 60)
+
+# Test 1: Creating colors
+print("\n1. Creating Colors:")
+c1 = Color(1.0, 0.0, 0.0, 1.0)  # Red
+print(f"   Color(1, 0, 0, 1) = {c1}")
+
+c2 = Color.from_rgb255(255, 128, 0)  # Orange
+print(f"   from_rgb255(255, 128, 0) = {c2}")
+
+c3 = Color.from_hex("#00FF00")  # Green
+print(f"   from_hex('#00FF00') = {c3}")
+
+c4 = Color.from_hsv(0.5, 1.0, 1.0)  # Cyan
+print(f"   from_hsv(0.5, 1, 1) = {c4}")
+
+# Test 2: Color operations
+print("\n2. Color Operations:")
+red = Color.red()
+blue = Color.blue()
+print(f"   red.lerp(blue, 0.5) = {red.lerp(blue, 0.5)}")
+print(f"   red.lighten(0.2) = {red.lighten(0.2)}")
+print(f"   blue.darken(0.3) = {blue.darken(0.3)}")
+print(f"   red.invert() = {red.invert()}")
+
+# Test 3: Color space conversions
+print("\n3. Color Space Conversions:")
+orange = Color.orange()
+print(f"   Orange RGB: {orange.to_rgb()}")
+print(f"   Orange RGB255: {orange.to_rgb255()}")
+print(f"   Orange HSV: {orange.to_hsv()}")
+print(f"   Orange HEX: {orange.to_hex()}")
+
+# Test 4: Pre-defined colors
+print("\n4. Pre-defined Colors:")
+print(f"   RED = {RED}")
+print(f"   BLUE = {BLUE}")
+print(f"   MD_BLUE = {MD_BLUE}")
+print(f"   get_color('orange') = {get_color('orange')}")
+
+# Test 5: Utility functions
+print("\n5. Utility Functions:")
+normalized = normalize_color("#FF0000")
+print(f"   normalize_color('#FF0000') = {normalized}")
+
+lerped = lerp_colors(RED, BLUE, 0.5)
+print(f"   lerp_colors(RED, BLUE, 0.5) = {lerped}")
+
+grad = gradient([RED, GREEN, BLUE], 5)
+print(f"   gradient([RED, GREEN, BLUE], 5):")
+for i, color in enumerate(grad):
+    print(f"      [{i}] = {color}")
+
+# Test 6: Immutability and tuple unpacking
+print("\n6. Immutability & Unpacking:")
+c = Color.red()
+r, g, b, a = c
+print(f"   Unpacked red: r={r}, g={g}, b={b}, a={a}")
+print(f"   Indexing: c[0]={c[0]}, c[1]={c[1]}, c[2]={c[2]}, c[3]={c[3]}")
+
+# Test 7: Operators
+print("\n7. Operators:")
+c1 = Color(0.5, 0.3, 0.2, 1.0)
+c2 = Color(0.2, 0.4, 0.5, 1.0)
+print(f"   c1 = {c1}")
+print(f"   c2 = {c2}")
+print(f"   c1 + c2 = {c1 + c2}")
+print(f"   c1 - c2 = {c1 - c2}")
+print(f"   c1 * 2.0 = {c1 * 2.0}")
+print(f"   c1 / 2.0 = {c1 / 2.0}")
+
+# Test 8: GPU compatibility
+print("\n8. GPU Compatibility:")
+c = Color.from_rgba(0.8, 0.4, 0.2, 1.0)
+arr = c.to_array()
+print(f"   Color as numpy array: {arr}")
+print(f"   Array dtype: {arr.dtype}")
+print(f"   Array shape: {arr.shape}")
+
+# Test 9: Color manipulation
+print("\n9. Color Manipulation:")
+green = Color.green()
+print(f"   Green: {green}")
+print(f"   Rotate hue +60°: {green.rotate_hue(60)}")
+print(f"   Rotate hue +120°: {green.rotate_hue(120)}")
+print(f"   Saturate +0.3: {green.saturate(0.3)}")
+print(f"   Desaturate -0.5: {green.desaturate(0.5)}")
+print(f"   Grayscale: {green.grayscale()}")
+
+# Test 10: with_alpha
+print("\n10. Alpha Manipulation:")
+c = Color.red()
+print(f"   Red (full opacity): {c}")
+print(f"   Red with 50% alpha: {c.with_alpha(0.5)}")
+print(f"   Red transparent: {c.with_alpha(0.0)}")
+
+print("\n" + "=" * 60)
+print("All tests completed successfully!")
+print("=" * 60)
+
+# Summary
+print("\n✓ Color class is immutable and GPU-optimized")
+print("✓ Default format: RGBA floats (0.0-1.0)")
+print("✓ Full ModernGL/GLTF compatibility")
+print("✓ Rich color operations and conversions")
+print("✓ 80+ pre-defined colors available")
+print("✓ Type-safe with proper type hints")

e2D/text_renderer.py

@@ -4,15 +4,18 @@ from PIL import Image, ImageFont
 from attr import dataclass
 import numpy as np
 import moderngl
+from .types import ColorType, VAOType, VectorType, ContextType, ProgramType, BufferType, TextureType
+from .colors import normalize_color
+from .color_defs import WHITE, BLACK
 
 @dataclass
 class TextStyle:
     font: str = "arial.ttf"
     font_size: int = 32
-    color: tuple[float, float, float, float] = (1.0, 1.0, 1.0, 1.0)
-    bg_color: tuple[float, float, float, float] = (0.0, 0.0, 0.0, 0.9)
-    bg_margin: float | tuple[float, float, float, float] = 15.0
-    bg_border_radius: float | tuple[float, float, float, float] = 15.0
+    color: ColorType = (1.0, 1.0, 1.0, 1.0)
+    bg_color: ColorType = (0.0, 0.0, 0.0, 0.9)
+    bg_margin: float | tuple[float, float, float, float] | tuple[float, float] | list[float] = 15.0
+    bg_border_radius: float | tuple[float, float, float, float] | tuple[float, float] | list[float] = 15.0
 
 class Pivots(Enum):
     TOP_LEFT = 0
@@ -28,8 +31,19 @@ class Pivots(Enum):
 DEFAULT_TEXT_STYLE = TextStyle()
 
 class TextLabel:
-    def __init__(self, ctx: moderngl.Context, prog: moderngl.Program, texture: moderngl.Texture, vertices: list,
-                 bg_prog: Optional[moderngl.Program] = None, bg_vertices: Optional[list] = None) -> None:
+    ctx: ContextType
+    prog: ProgramType
+    texture: TextureType
+    vertices: list[float]
+    vbo: BufferType
+    vao: VAOType
+    bg_prog: Optional[ProgramType]
+    bg_vertices: Optional[list[float]]
+    bg_vbo: Optional[BufferType]
+    bg_vao: Optional[VAOType]
+    
+    def __init__(self, ctx: ContextType, prog: ProgramType, texture: TextureType, vertices: list[float],
+                 bg_prog: Optional[ProgramType] = None, bg_vertices: Optional[list[float]] = None) -> None:
         """
         A pre-rendered text label for efficient drawing.
         To generate select a option below:
@@ -75,7 +89,13 @@ class TextRenderer:
     Renders text using a texture atlas generated from a TTF font via Pillow.
     Supports multiple fonts and sizes with caching for optimization.
     """
-    def __init__(self, ctx: moderngl.Context) -> None:
+    ctx: ContextType
+    font_cache: dict[tuple[str, int], dict]
+    chars: str
+    bg_prog: ProgramType
+    prog: ProgramType
+    
+    def __init__(self, ctx: ContextType) -> None:
         self.ctx = ctx
         
         # Cache for font atlases: (font_path, font_size) -> {font, char_data, texture}
@@ -281,20 +301,30 @@ class TextRenderer:
         
         return total_w, line_height
     
-    def _normalize_margin(self, margin: float | tuple[float, float, float, float]) -> tuple[float, float, float, float]:
+    def _normalize_margin(self, margin: float | tuple[float, float, float, float] | tuple[float, float] | list[float]) -> tuple[float, float, float, float]:
         """Normalize margin to (top, right, bottom, left)."""
         if isinstance(margin, (int, float)):
             return (margin, margin, margin, margin)
-        return margin
+        elif isinstance(margin, (list, tuple)):
+            if len(margin) == 2:
+                return (margin[0], margin[1], margin[0], margin[1])
+            elif len(margin) == 4:
+                return (margin[0], margin[1], margin[2], margin[3])
+        return margin[0], margin[1], margin[2], margin[3]
     
-    def _normalize_radius(self, radius: float | tuple[float, float, float, float]) -> tuple[float, float, float, float]:
+    def _normalize_radius(self, radius: float | tuple[float, float, float, float] | tuple[float, float] | list[float]) -> tuple[float, float, float, float]:
         """Normalize border radius to (top-left, top-right, bottom-right, bottom-left)."""
         if isinstance(radius, (int, float)):
             return (radius, radius, radius, radius)
-        return radius
+        elif isinstance(radius, (list, tuple)):
+            if len(radius) == 2:
+                return (radius[0], radius[1], radius[0], radius[1])
+            elif len(radius) == 4:
+                return (radius[0], radius[1], radius[2], radius[3])
+        return radius[0], radius[1], radius[2], radius[3]
     
     def _generate_background_vertices(self, x: float, y: float, width: float, height: float, 
-                                     bg_color: tuple, margin: tuple[float, float, float, float],
+                                     bg_color: ColorType, margin: tuple[float, float, float, float],
                                      radius: tuple[float, float, float, float]) -> list[float]:
         """Generate vertices for a rounded rectangle background."""
         # Apply margin
@@ -321,8 +351,8 @@ class TextRenderer:
         
         return vertices
 
-    def _generate_vertices(self, text: str, pos: tuple[float, float], scale: float = 1.0, 
-            color: tuple = (1.0, 1.0, 1.0, 1.0), pivot: Pivots = Pivots.TOP_LEFT, char_data: dict = {} ) -> list[float]:
+    def _generate_vertices(self, text: str, pos: VectorType, scale: float = 1.0, 
+            color: ColorType = WHITE, pivot: Pivots | int = Pivots.TOP_LEFT, char_data: dict = {} ) -> list[float]:
 
         if not char_data:
             raise ValueError("char_data is required for _generate_vertices")
@@ -396,7 +426,7 @@ class TextRenderer:
             
         return vertices
 
-    def draw_text(self, text: str, pos: tuple[float, float], scale: float = 1.0, style: TextStyle = DEFAULT_TEXT_STYLE, pivot: Pivots = Pivots.TOP_LEFT) -> None:
+    def draw_text(self, text: str, pos: VectorType, scale: float = 1.0, style: TextStyle = DEFAULT_TEXT_STYLE, pivot: Pivots | int = Pivots.TOP_LEFT) -> None:
         if not text:
             return
         
@@ -451,7 +481,7 @@ class TextRenderer:
         self.ctx.enable(moderngl.BLEND)
         self.vao.render(moderngl.TRIANGLES, vertices=len(vertices)//8)
 
-    def create_label(self, text: str, x: float, y: float, scale: float = 1.0, style: TextStyle = DEFAULT_TEXT_STYLE, pivot: Pivots = Pivots.TOP_LEFT) -> TextLabel:
+    def create_label(self, text: str, x: float, y: float, scale: float = 1.0, style: TextStyle = DEFAULT_TEXT_STYLE, pivot: Pivots | int = Pivots.TOP_LEFT) -> TextLabel:
         if not text:
             # Return empty label with default texture
             font_atlas = self._get_or_create_font_atlas(style.font, style.font_size)

e2D/text_renderer.pyi

@@ -0,0 +1,118 @@
+"""
+Type stubs for text_renderer module
+Text rendering using texture atlases and TTF fonts
+"""
+
+from enum import Enum
+from typing import Optional
+from .types import ColorType, ContextType, ProgramType, TextureType, VAOType, VectorType, BufferType
+from .color_defs import WHITE
+
+class TextStyle:
+    """Text styling options"""
+    font: str
+    font_size: int
+    color: ColorType
+    bg_color: ColorType
+    bg_margin: float | tuple[float, float, float, float]
+    bg_border_radius: float | tuple[float, float, float, float]
+    
+    def __init__(
+        self,
+        font: str = "arial.ttf",
+        font_size: int = 32,
+        color: ColorType = (1.0, 1.0, 1.0, 1.0),
+        bg_color: ColorType = (0.0, 0.0, 0.0, 0.9),
+        bg_margin: float | tuple[float, float, float, float] = 15.0,
+        bg_border_radius: float | tuple[float, float, float, float] = 15.0
+    ) -> None: ...
+
+class Pivots(Enum):
+    """Text anchor/pivot points"""
+    TOP_LEFT: int
+    TOP_MIDDLE: int
+    TOP_RIGHT: int
+    LEFT: int
+    CENTER: int
+    RIGHT: int
+    BOTTOM_LEFT: int
+    BOTTOM_MIDDLE: int
+    BOTTOM_RIGHT: int
+
+DEFAULT_TEXT_STYLE: TextStyle
+
+class TextLabel:
+    """A pre-rendered text label for efficient drawing."""
+    ctx: ContextType
+    prog: ProgramType
+    texture: TextureType
+    vertices: list[float]
+    vbo: BufferType
+    vao: VAOType
+    bg_prog: Optional[ProgramType]
+    bg_vertices: Optional[list[float]]
+    bg_vbo: Optional[BufferType]
+    bg_vao: Optional[VAOType]
+    
+    def __init__(
+        self, 
+        ctx: ContextType, 
+        prog: ProgramType, 
+        texture: TextureType, 
+        vertices: list[float],
+        bg_prog: Optional[ProgramType] = None, 
+        bg_vertices: Optional[list[float]] = None
+    ) -> None: ...
+    
+    def draw(self) -> None:
+        """Draw the text label"""
+        ...
+
+class TextRenderer:
+    """
+    Renders text using a texture atlas generated from a TTF font via Pillow.
+    Supports multiple fonts and sizes with caching for optimization.
+    """
+    ctx: ContextType
+    font_cache: dict[tuple[str, int], dict]
+    chars: str
+    bg_prog: ProgramType
+    bg_vbo: BufferType
+    bg_vao: VAOType
+    prog: ProgramType
+    vbo: BufferType
+    vao: VAOType
+    
+    def __init__(self, ctx: ContextType) -> None: ...
+    
+    def get_text_width(
+        self, 
+        text: str, 
+        scale: float = 1.0, 
+        style: TextStyle = DEFAULT_TEXT_STYLE
+    ) -> float:
+        """Calculate the width of the text."""
+        ...
+    
+    def draw_text(
+        self,
+        text: str,
+        pos: VectorType,
+        scale: float = 1.0,
+        style: TextStyle = DEFAULT_TEXT_STYLE,
+        pivot: Pivots | int = Pivots.TOP_LEFT
+    ) -> None:
+        """Draw text immediately."""
+        ...
+    
+    def create_label(
+        self,
+        text: str,
+        x: float,
+        y: float,
+        scale: float = 1.0,
+        style: TextStyle = DEFAULT_TEXT_STYLE,
+        pivot: Pivots | int = Pivots.TOP_LEFT
+    ) -> TextLabel:
+        """Create a cached text label for repeated drawing."""
+        ...

e2D/types.py

@@ -0,0 +1,58 @@
+"""
+Type definitions for e2D library
+Provides common type aliases and type hints used throughout the library
+"""
+
+from __future__ import annotations
+
+# Simple type aliases without imports to avoid circular dependencies
+# These are used for type hints only
+
+# Type alias for vector-like objects
+# At runtime, accepts: Vector2D instances, tuples of 2 numbers, or sequences of 2 numbers
+# Use this for ALL vector/position/size parameters for maximum flexibility
+VectorType = object  # Union at type-check time via .pyi file
+
+# Color type (RGBA values between 0.0 and 1.0)
+ColorType = tuple[float, float, float, float]
+
+# Numeric types
+Number = int | float
+IntVec2 = tuple[int, int]
+FloatVec2 = tuple[float, float]
+NumVec2 = tuple[Number, Number]
+
+# Array-like types for numpy and buffers
+pArray = object  # list | tuple at runtime
+ArrayLike = object  # numpy array or similar at runtime
+
+# Shader and GPU resource types (forward declarations at runtime)
+ContextType = object  # moderngl.Context
+ProgramType = object  # moderngl.Program
+ComputeShaderType = object  # moderngl.ComputeShader
+BufferType = object  # moderngl.Buffer
+VAOType = object  # moderngl.VertexArray
+TextureType = object  # moderngl.Texture
+
+ProgramAttrType = object  # moderngl.Uniform | moderngl.UniformBlock | moderngl.Attribute | moderngl.Varying
+UniformType = object  # moderngl.Uniform
+UniformBlockType = object  # moderngl.UniformBlock
+
+# Window and input types
+WindowType = object  # glfw window
+
+__all__ = [
+    'VectorType',
+    'ColorType',
+    'Number',
+    'IntVec2',
+    'FloatVec2',
+    'NumVec2',
+    'ArrayLike',
+    'ContextType',
+    'ProgramType',
+    'BufferType',
+    'VAOType',
+    'TextureType',
+    'WindowType',
+]