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

e2D/plots.pyi

@@ -0,0 +1,238 @@
+"""
+Type stubs for plots module
+2D plotting with GPU-accelerated rendering
+"""
+
+from typing import Optional, Callable
+from enum import Enum
+import numpy as np
+import numpy.typing as npt
+from .types import BufferType, ColorType, ComputeShaderType, ContextType, ProgramType, VAOType, VectorType
+from .color_defs import GRAY10, GRAY50, WHITE, RED, CYAN, TRANSPARENT
+
+class ShaderManager:
+    """Cache and manage shader files for the plots module."""
+    _cache: dict[str, str]
+    
+    @staticmethod
+    def load_shader(path: str) -> str:
+        """Load a shader file with caching."""
+        ...
+    
+    @staticmethod
+    def create_program(ctx: ContextType, vertex_path: str, fragment_path: str) -> ProgramType:
+        """Create a program from shader files."""
+        ...
+    
+    @staticmethod
+    def create_compute(ctx: ContextType, compute_path: str) -> ComputeShaderType:
+        """Create a compute shader from file."""
+        ...
+
+class View2D:
+    """
+    Manages coordinate space (World <-> Clip) via UBO.
+    """
+    ctx: ContextType
+    binding: int
+    center: npt.NDArray[np.float32]
+    zoom: float
+    aspect: float
+    resolution: npt.NDArray[np.float32]
+    buffer: BufferType
+    
+    def __init__(self, ctx: ContextType, binding: int = 0) -> None: ...
+    
+    def update_win_size(self, width: int, height: int) -> None: ...
+    def pan(self, dx: float, dy: float) -> None: ...
+    def zoom_step(self, factor: float) -> None: ...
+    def zoom_at(self, factor: float, ndc_x: float, ndc_y: float) -> None: ...
+    def update_buffer(self) -> None: ...
+
+class PlotSettings:
+    bg_color: ColorType
+    show_axis: bool
+    axis_color: ColorType
+    axis_width: float
+    show_grid: bool
+    grid_color: ColorType
+    grid_spacing: float
+    
+    def __init__(
+        self,
+        bg_color: ColorType = (0.1, 0.1, 0.1, 1.0),
+        show_axis: bool = True,
+        axis_color: ColorType = (0.5, 0.5, 0.5, 1.0),
+        axis_width: float = 2.0,
+        show_grid: bool = True,
+        grid_color: ColorType = (0.2, 0.2, 0.2, 1.0),
+        grid_spacing: float = 1.0
+    ) -> None: ...
+
+class CurveSettings:
+    color: ColorType
+    width: float
+    count: int
+    
+    def __init__(
+        self,
+        color: ColorType = (1.0, 1.0, 1.0, 1.0),
+        width: float = 2.0,
+        count: int = 1024
+    ) -> None:
+        self.color = color
+        self.width = width
+        self.count = count
+
+class ImplicitSettings:
+    color: ColorType
+    thickness: float
+    
+    def __init__(
+        self,
+        color: ColorType = (0.4, 0.6, 1.0, 1.0),
+        thickness: float = 2.0
+    ) -> None: ... 
+
+class LineType(Enum):
+    NONE: int
+    DIRECT: int
+    BEZIER_QUADRATIC: int
+    BEZIER_CUBIC: int
+    SMOOTH: int
+
+class StreamSettings:
+    point_color: ColorType
+    point_radius: float
+    show_points: bool
+    round_points: bool
+    line_type: LineType
+    line_color: ColorType
+    line_width: float
+    curve_segments: int
+
+    def __init__(
+        self,
+        point_color: ColorType = (1.0, 0.0, 0.0, 1.0),
+        point_radius: float = 5.0,
+        show_points: bool = True,
+        round_points: bool = True,
+        line_type: LineType|int = LineType.DIRECT,
+        line_color: ColorType = (1.0, 0.0, 0.0, 1.0),
+        line_width: float = 2.0,
+        curve_segments: int = 10
+    ) -> None: ...
+
+class Plot2D:
+    """A specific rectangular area on the screen for plotting."""
+    ctx: ContextType
+    top_left: VectorType
+    bottom_right: VectorType
+    settings: PlotSettings
+    width: int
+    height: int
+    view: View2D
+    viewport: tuple[int, int, int, int]
+    grid_prog: ProgramType
+    grid_quad: BufferType
+    grid_vao: VAOType
+    is_dragging: bool
+    last_mouse_pos: VectorType
+    
+    def __init__(
+        self, 
+        ctx: ContextType,
+        top_left: VectorType, 
+        bottom_right: VectorType, 
+        settings: Optional[PlotSettings] = None
+    ) -> None: ...
+    
+    def set_rect(self, top_left: VectorType, bottom_right: VectorType) -> None: ...
+    def update_window_size(self, win_width: int, win_height: int) -> None: ...
+    def render(self, draw_callback: Callable[[], None]) -> None: ...
+    def contains(self, x: float, y: float) -> bool: ...
+    def on_mouse_drag(self, dx: float, dy: float) -> None: ...
+    def on_scroll(self, yoffset: float, mouse_x: float, mouse_y: float) -> None: ...
+
+class GpuStream:
+    """Ring-buffer on GPU for high-performance point streaming."""
+    ctx: ContextType
+    capacity: int
+    settings: StreamSettings
+    head: int
+    size: int
+    buffer: BufferType
+    prog: ProgramType
+    vao: VAOType
+    smooth_prog: ProgramType
+    smooth_vao: VAOType
+    
+    def __init__(
+        self, 
+        ctx: ContextType, 
+        capacity: int = 100000, 
+        settings: Optional[StreamSettings] = None
+    ) -> None: ...
+    
+    def push(self, points: npt.NDArray[np.float32]) -> None: ...
+    def draw(self) -> None: ...
+    def shift_points(self, offset: VectorType) -> None: ...
+
+class ComputeCurve:
+    """Parametric curve p(t) evaluated entirely on GPU."""
+    ctx: ContextType
+    count: int
+    t_range: tuple[float, float]
+    settings: CurveSettings
+    vbo: BufferType
+    compute_prog: ComputeShaderType
+    render_prog: ProgramType
+    vao: VAOType
+    
+    def __init__(
+        self, 
+        ctx: ContextType, 
+        func_body: str, 
+        t_range: tuple[float, float], 
+        count: int = 1024, 
+        settings: Optional[CurveSettings] = None
+    ) -> None: ...
+    
+    def update(self) -> None: ...
+    def draw(self) -> None: ...
+
+class ImplicitPlot:
+    """Rendering of f(x,y)=0 via Fragment Shader and SDF."""
+    ctx: ContextType
+    settings: ImplicitSettings
+    quad: BufferType
+    prog: ProgramType
+    vao: VAOType
+    
+    def __init__(
+        self, 
+        ctx: ContextType, 
+        func_body: str, 
+        settings: Optional[ImplicitSettings] = None
+    ) -> None: ...
+    
+    def draw(self) -> None: ...
+
+class SegmentDisplay:
+    """Simple 7-segment display renderer for numbers."""
+    ctx: ContextType
+    prog: ProgramType
+    vbo: BufferType
+    vao: VAOType
+    digits: dict[str, list[int]]
+    
+    def __init__(self, ctx: ContextType) -> None: ...
+    
+    def draw_number(
+        self, 
+        text: str, 
+        x: float, 
+        y: float, 
+        size: float = 20.0, 
+        color: ColorType = (1.0, 1.0, 1.0, 1.0)
+    ) -> None: ...

e2D/shapes.py

@@ -1,6 +1,9 @@
 import moderngl
 import numpy as np
 from .commons import get_pattr, get_pattr_value, set_pattr_value
+from .types import VAOType, VectorType, ColorType, ContextType, ProgramType, BufferType
+from .colors import normalize_color
+from .color_defs import WHITE, BLACK, TRANSPARENT
 from typing import Optional, Sequence
 from enum import Enum
 
@@ -12,8 +15,15 @@ class FillMode(Enum):
 
 class ShapeLabel:
     """A pre-rendered shape for efficient repeated drawing."""
-    def __init__(self, ctx: moderngl.Context, prog: moderngl.Program, 
-                 vbo: moderngl.Buffer, vertex_count: int, shape_type: str = 'line') -> None:
+    ctx: ContextType
+    prog: ProgramType
+    vbo: BufferType
+    vao: VAOType
+    vertex_count: int
+    shape_type: str
+    
+    def __init__(self, ctx: ContextType, prog: ProgramType, 
+                 vbo: BufferType, vertex_count: int, shape_type: str = 'line') -> None:
         self.ctx = ctx
         self.prog = prog
         self.vbo = vbo
@@ -45,7 +55,18 @@ class ShapeLabel:
 
 class InstancedShapeBatch:
     """High-performance instanced batch for drawing thousands of shapes with minimal CPU overhead."""
-    def __init__(self, ctx: moderngl.Context, prog: moderngl.Program, shape_type: str = 'circle', max_instances: int = 100000) -> None:
+    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:
         self.ctx = ctx
         self.prog = prog
         self.shape_type = shape_type
@@ -128,9 +149,9 @@ class InstancedShapeBatch:
         
         self.instance_data = []
     
-    def add_circle(self, center: tuple[float, float], radius: float,
-                   color: tuple[float, float, float, float] = (1.0, 1.0, 1.0, 1.0),
-                   border_color: tuple[float, float, float, float] = (0.0, 0.0, 0.0, 0.0),
+    def add_circle(self, center: VectorType, radius: float,
+                   color: ColorType = WHITE,
+                   border_color: ColorType = TRANSPARENT,
                    border_width: float = 0.0,
                    antialiasing: float = 1.0) -> None:
         """Add a circle instance to the batch."""
@@ -171,10 +192,10 @@ class InstancedShapeBatch:
         self.instance_data.extend(data.ravel())
         self.instance_count += n
     
-    def add_rect(self, center: tuple[float, float], size: tuple[float, float],
-                color: tuple[float, float, float, float] = (1.0, 1.0, 1.0, 1.0),
+    def add_rect(self, center: VectorType, size: VectorType,
+                color: ColorType = WHITE,
                 corner_radius: float = 0.0,
-                border_color: tuple[float, float, float, float] = (0.0, 0.0, 0.0, 0.0),
+                border_color: ColorType = TRANSPARENT,
                 border_width: float = 0.0,
                 antialiasing: float = 1.0,
                 rotation: float = 0.0) -> None:
@@ -225,9 +246,9 @@ class InstancedShapeBatch:
         self.instance_data.extend(data.ravel())
         self.instance_count += n
     
-    def add_line(self, start: tuple[float, float], end: tuple[float, float],
+    def add_line(self, start: VectorType, end: VectorType,
                 width: float = 1.0,
-                color: tuple[float, float, float, float] = (1.0, 1.0, 1.0, 1.0)) -> None:
+                color: ColorType = WHITE) -> None:
         """Add a line instance to the batch."""
         self.instance_data.extend([*start, *end, width, *color])
         self.instance_count += 1
@@ -282,8 +303,21 @@ 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: moderngl.Context) -> None:
+    def __init__(self, ctx: ContextType) -> None:
         self.ctx = ctx
         
         # ===== INSTANCED Circle Shader (for high-performance batching) =====
@@ -697,16 +731,17 @@ class ShapeRenderer:
     
     # ========== CIRCLE ==========
     
-    def _generate_circle_vertices(self, center: tuple[float, float], radius: float, 
-                                  color: tuple[float, float, float, float] = (1.0, 1.0, 1.0, 1.0),
+    def _generate_circle_vertices(self, center: VectorType, radius: float, 
+                                  color: ColorType = (1.0, 1.0, 1.0, 1.0),
                                   rotation: float = 0.0,
-                                  border_color: tuple[float, float, float, float] = (0.0, 0.0, 0.0, 0.0),
+                                  border_color: ColorType = (0.0, 0.0, 0.0, 0.0),
                                   border_width: float = 0.0,
                                   antialiasing: float = 1.0) -> list[float]:
         """Generate vertices for a circle (as a quad).
         Format: pos(2f), color(4f), radius(1f), border_color(4f), border_width(1f), aa(1f), center(2f)
         """
-        cx, cy = center
+        # Handle VectorType input - convert to tuple if needed
+        cx, cy = center[0], center[1]
         
         # Expand for border and antialiasing
         expand = radius + border_width + antialiasing * 2
@@ -735,10 +770,10 @@ class ShapeRenderer:
         
         return vertices
     
-    def draw_circle(self, center: tuple[float, float], radius: float,
-                   color: tuple[float, float, float, float] = (1.0, 1.0, 1.0, 1.0),
+    def draw_circle(self, center: VectorType, radius: float,
+                   color: ColorType = (1.0, 1.0, 1.0, 1.0),
                    rotation: float = 0.0,
-                   border_color: tuple[float, float, float, float] = (0.0, 0.0, 0.0, 0.0),
+                   border_color: ColorType = (0.0, 0.0, 0.0, 0.0),
                    border_width: float = 0.0,
                    antialiasing: float = 1.0) -> None:
         """
@@ -763,10 +798,10 @@ class ShapeRenderer:
         set_pattr_value(self.circle_prog, 'resolution', self.ctx.viewport[2:])
         self.circle_vao.render(moderngl.TRIANGLES, vertices=6)
     
-    def create_circle(self, center: tuple[float, float], radius: float,
-                     color: tuple[float, float, float, float] = (1.0, 1.0, 1.0, 1.0),
+    def create_circle(self, center: VectorType, radius: float,
+                     color: ColorType = (1.0, 1.0, 1.0, 1.0),
                      rotation: float = 0.0,
-                     border_color: tuple[float, float, float, float] = (0.0, 0.0, 0.0, 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."""
@@ -780,17 +815,18 @@ class ShapeRenderer:
     
     # ========== RECTANGLE ==========
     
-    def _generate_rect_vertices(self, position: tuple[float, float], size: tuple[float, float],
-                                color: tuple[float, float, float, float] = (1.0, 1.0, 1.0, 1.0),
+    def _generate_rect_vertices(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: tuple[float, float, float, float] = (0.0, 0.0, 0.0, 0.0),
+                                border_color: ColorType = (0.0, 0.0, 0.0, 0.0),
                                 border_width: float = 0.0,
                                 antialiasing: float = 1.0) -> list[float]:
         """Generate vertices for a rectangle.
         Format: pos(2f), color(4f), radius(1f), border_color(4f), border_width(1f), aa(1f), size(2f), local_pos(2f)
         """
-        x, y = position
+        # Handle VectorType input - convert to tuple if needed
+        x, y = position[0], position[1]
         w, h = size
         
         # Center of rectangle
@@ -832,11 +868,11 @@ class ShapeRenderer:
         
         return vertices
     
-    def draw_rect(self, position: tuple[float, float], size: tuple[float, float],
-                 color: tuple[float, float, float, float] = (1.0, 1.0, 1.0, 1.0),
+    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: tuple[float, float, float, float] = (0.0, 0.0, 0.0, 0.0),
+                 border_color: ColorType = (0.0, 0.0, 0.0, 0.0),
                  border_width: float = 0.0,
                  antialiasing: float = 1.0) -> None:
         """
@@ -862,11 +898,11 @@ class ShapeRenderer:
         set_pattr_value(self.rect_prog, 'resolution', self.ctx.viewport[2:])
         self.rect_vao.render(moderngl.TRIANGLES, vertices=6)
     
-    def create_rect(self, position: tuple[float, float], size: tuple[float, float],
-                   color: tuple[float, float, float, float] = (1.0, 1.0, 1.0, 1.0),
+    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: tuple[float, float, float, float] = (0.0, 0.0, 0.0, 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."""
@@ -880,12 +916,13 @@ class ShapeRenderer:
     
     # ========== LINES ==========
     
-    def _generate_line_segment_vertices(self, start: tuple[float, float], end: tuple[float, float],
-                                        width: float, color: tuple[float, float, float, float],
+    def _generate_line_segment_vertices(self, start: VectorType, end: VectorType,
+                                        width: float, color: ColorType,
                                         antialias: float = 1.0) -> list[float]:
         """Generate vertices for a line segment as a quad."""
-        x1, y1 = start
-        x2, y2 = end
+        # Handle VectorType input - convert to tuple if needed
+        x1, y1 = start[0], start[1]
+        x2, y2 = end[0], end[1]
         
         # Calculate perpendicular direction
         dx = x2 - x1
@@ -918,9 +955,9 @@ class ShapeRenderer:
         
         return vertices
     
-    def draw_line(self, start: tuple[float, float], end: tuple[float, float],
+    def draw_line(self, start: VectorType, end: VectorType,
                  width: float = 1.0,
-                 color: tuple[float, float, float, float] = (1.0, 1.0, 1.0, 1.0),
+                 color: ColorType = (1.0, 1.0, 1.0, 1.0),
                  antialiasing: float = 1.0) -> None:
         """
         Draw a single line segment.
@@ -944,9 +981,9 @@ class ShapeRenderer:
         set_pattr_value(self.line_prog, 'resolution', self.ctx.viewport[2:])
         self.line_vao.render(moderngl.TRIANGLES, vertices=6)
     
-    def draw_lines(self, points: np.ndarray | Sequence[tuple[float, float]],
+    def draw_lines(self, points: np.ndarray | Sequence[VectorType],
                   width: float = 1.0,
-                  color: tuple[float, float, float, float] | np.ndarray = (1.0, 1.0, 1.0, 1.0),
+                  color: ColorType | np.ndarray = (1.0, 1.0, 1.0, 1.0),
                   antialiasing: float = 1.0,
                   closed: bool = False) -> None:
         """
@@ -1003,9 +1040,9 @@ class ShapeRenderer:
         num_segments = (len(points_array) - 1) + (1 if closed else 0)
         self.line_vao.render(moderngl.TRIANGLES, vertices=num_segments * 6)
     
-    def create_line(self, start: tuple[float, float], end: tuple[float, float],
+    def create_line(self, start: VectorType, end: VectorType,
                    width: float = 1.0,
-                   color: tuple[float, float, float, float] = (1.0, 1.0, 1.0, 1.0),
+                   color: ColorType = (1.0, 1.0, 1.0, 1.0),
                    antialiasing: float = 1.0) -> ShapeLabel:
         """Create a cached line for repeated drawing."""
         vertices = self._generate_line_segment_vertices(start, end, width, color, antialiasing)
@@ -1015,9 +1052,9 @@ class ShapeRenderer:
         
         return ShapeLabel(self.ctx, self.line_prog, vbo, 6, 'line')
     
-    def create_lines(self, points: np.ndarray | Sequence[tuple[float, float]],
+    def create_lines(self, points: np.ndarray | Sequence[VectorType],
                     width: float = 1.0,
-                    color: tuple[float, float, float, float] | np.ndarray = (1.0, 1.0, 1.0, 1.0),
+                    color: ColorType | np.ndarray = (1.0, 1.0, 1.0, 1.0),
                     antialiasing: float = 1.0,
                     closed: bool = False) -> ShapeLabel:
         """Create a cached polyline for repeated drawing."""