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

e2D/__init__.py

@@ -6,9 +6,9 @@ Copyright (c) 2025 Riccardo Mariani
 MIT License
 """
 
-__version__ = "2.0.0"
+__version__ = "2.0.2"
 __author__ = "Riccardo Mariani"
-__email__ = "ricomari2006@gmail.com"
+__email__ = "riccardo.mariani@emptyhead.dev"
 
 import numpy as np
 import moderngl
@@ -16,6 +16,12 @@ import glfw
 import time
 import os
 
+# Import type definitions
+from .types import (
+    ComputeShaderType, ProgramAttrType, UniformType, VectorType, ColorType, Number,
+    ContextType, ProgramType, BufferType, WindowType, pArray
+)
+
 # Import original e2D modules
 from .text_renderer import DEFAULT_TEXT_STYLE, Pivots, TextRenderer, TextLabel, TextStyle
 from .shapes import ShapeRenderer, ShapeLabel, InstancedShapeBatch, FillMode
@@ -24,48 +30,43 @@ from .commons import get_pattr, get_pattr_value, set_pattr_value, get_uniform
 
 from typing import Optional
 
-# Import optimized Vector2D
+# Import color utilities
+from .colors import Color, normalize_color, lerp_colors, gradient, batch_colors_to_array
+from .color_defs import (
+    # Basic colors
+    TRANSPARENT, WHITE, BLACK, RED, GREEN, BLUE, CYAN, MAGENTA, YELLOW,
+    # Extended colors (most common)
+    ORANGE, PURPLE, PINK, GRAY50,
+    # Lookup functions
+    COLOR_NAMES, get_color, has_color,
+)
+
+# Try to import Cython-optimized color operations (optional batch utilities)
 try:
-    from .cvectors import (
-        Vector2D,
-        batch_add_inplace,
-        batch_scale_inplace,
-        batch_normalize_inplace,
-        vectors_to_array,
-        array_to_vectors,
-    )
-    _VECTOR_COMPILED = True
+    from . import ccolors  # type: ignore[import-not-found]
+    _COLOR_COMPILED = True
 except ImportError:
-    # Fallback to pure Python implementation
-    import warnings
-    warnings.warn(
-        "Vector2D compiled extension not available. "
-        "Install Cython and rebuild for optimal performance.",
-        RuntimeWarning
-    )
-    from .vectors import (
-        Vector2D,
-        batch_add_inplace,
-        batch_scale_inplace,
-        batch_normalize_inplace,
-        vectors_to_array,
-        array_to_vectors,
-    )
-    _VECTOR_COMPILED = False
+    _COLOR_COMPILED = False
 
-# Import vector utilities
+# Import Vector2D - vectors.py handles Cython/Python fallback internally
 from .vectors import (
+    Vector2D,
     V2,
-    Vec2,
     CommonVectors,
+    batch_add_inplace,
+    batch_scale_inplace,
+    batch_normalize_inplace,
+    vectors_to_array,
+    array_to_vectors,
     lerp,
     create_grid,
     create_circle,
+    _COMPILED as _VECTOR_COMPILED,
 )
 
 
 class DefEnv:
-    ctx: moderngl.Context
+    ctx: ContextType
     def __init__(self) -> None: ...
 
     def draw(self) -> None: ...
@@ -75,13 +76,29 @@ class DefEnv:
     def on_resize(self, width: int, height: int) -> None: ...
 
 class RootEnv:
+    window_size: VectorType
+    target_fps: int
+    window: WindowType
+    ctx: ContextType
+    programs: dict[str, ProgramType]
+    compute_shaders: dict[str, ComputeShaderType]
+    buffers: dict[str, BufferType]
+    keyboard: Keyboard
+    mouse: Mouse
+    text_renderer: TextRenderer
+    shape_renderer: ShapeRenderer
+    delta: float
+    last_frame_time: float
+    start_time: float
+    env: DefEnv
+    
     def __init__(
             self,
-            window_size:tuple[int, int]=(1920, 1080),
-            target_fps:int=60,
-            vsync:bool=True,
-            version:tuple[int, int]=(4,3),
-            monitor:Optional[int]=None
+            window_size: tuple[int, int] = (1920, 1080),
+            target_fps: int = 60,
+            vsync: bool = True,
+            version: tuple[int, int] = (4, 3),
+            monitor: Optional[int] = None
         ) -> None:
 
         if not glfw.init():
@@ -96,7 +113,7 @@ class RootEnv:
         self.window_size = window_size
         self.target_fps = target_fps
 
-        self.window : glfw._GLFWwindow = glfw.create_window(window_size[0], window_size[1], "e2D", monitor, None)
+        self.window = glfw.create_window(window_size[0], window_size[1], "e2D", monitor, None)
         if not self.window:
             glfw.terminate()
             raise RuntimeError("Failed to create GLFW window")
@@ -127,9 +144,9 @@ class RootEnv:
         
         glfw.set_window_size_callback(self.window, self._on_resize)
 
-        self.programs :dict[str, moderngl.Program]= {}
-        self.compute_shaders :dict[str, moderngl.ComputeShader]= {}
-        self.buffers :dict[str, moderngl.Buffer]= {}
+        self.programs :dict[str, ProgramType]= {}
+        self.compute_shaders = {}
+        self.buffers :dict[str, BufferType]= {}
         
         self.keyboard = Keyboard()
         self.mouse = Mouse()
@@ -138,25 +155,53 @@ class RootEnv:
         
         # Delta time tracking
         self.delta = 0.0
-        self.last_frame_time = time.time()
+        self.last_frame_time = time.perf_counter()
+        
+        # Runtime tracking (elapsed time from initialization)
+        self.start_time = time.perf_counter()
     
     @property
     def window_size_f(self) -> tuple[float, float]:
         """Get window size as floats for shader uniforms."""
         return (float(self.window_size[0]), float(self.window_size[1]))
     
-    def _on_resize(self, window, width, height) -> None:
+    @property
+    def runtime(self) -> float:
+        """Get total elapsed time since program initialization in seconds."""
+        return time.perf_counter() - self.start_time
+    
+    def _on_resize(self, window: WindowType, width: int, height: int) -> None:
         self.window_size = (width, height)
         fb_size = glfw.get_framebuffer_size(window)
         self.ctx.viewport = (0, 0, fb_size[0], fb_size[1])
         if hasattr(self, 'env') and hasattr(self.env, 'on_resize'):
             self.env.on_resize(fb_size[0], fb_size[1])
 
-    def init(self, env:DefEnv) -> "RootEnv":
+    def init(self, env: DefEnv) -> "RootEnv":
         self.env = env
         return self
     
-    def load_shader_file(self, path:str) -> str:
+    def init_rec(self, fps: int = 30, draw_on_screen: bool = True, path: str = 'output.mp4') -> 'RootEnv':
+        """Initialize screen recording.
+        
+        Args:
+            fps: Recording framerate (independent of application FPS)
+            draw_on_screen: Show recording stats overlay
+            path: Output video file path
+        
+        Returns:
+            Self for method chaining
+        
+        Controls:
+            F9: Pause/Resume recording
+            F10: Restart recording (clear buffer)
+            F12: Take screenshot
+        """
+        from .winrec import WinRec
+        self.__winrecorder__ = WinRec(self, fps=fps, draw_on_screen=draw_on_screen, path=path)
+        return self
+    
+    def load_shader_file(self, path: str) -> str:
         """Load shader source code from a file.
         
         Args:
@@ -171,7 +216,7 @@ class RootEnv:
         with open(path, 'r', encoding='utf-8') as f:
             return f.read()
     
-    def create_program(self, vertex_shader:str, fragment_shader:str, id:str) -> moderngl.Program:
+    def create_program(self, vertex_shader: str, fragment_shader: str, id: str) -> ProgramType:
         new_program = self.ctx.program(
             vertex_shader=vertex_shader,
             fragment_shader=fragment_shader
@@ -181,7 +226,7 @@ class RootEnv:
         self.programs[id] = new_program
         return new_program
     
-    def create_program_from_files(self, vertex_path:str, fragment_path:str, id:str) -> moderngl.Program:
+    def create_program_from_files(self, vertex_path: str, fragment_path: str, id: str) -> ProgramType:
         """Create a shader program from shader files.
         
         Args:
@@ -196,14 +241,19 @@ class RootEnv:
         fragment_shader = self.load_shader_file(fragment_path)
         return self.create_program(vertex_shader, fragment_shader, id)
 
-    def get_program(self, id:str) -> moderngl.Program | None:
+    def get_program(self, id:str) -> ProgramType | None:
         return self.programs.get(id, None)
     
     def __draw__(self) -> None:
         self.ctx.clear(0.0, 0.0, 0.0, 1.0)
         self.env.draw()
+        
+        # Screen recording: capture frame before overlay, draw stats after
+        if hasattr(self, '__winrecorder__'):
+            self.__winrecorder__.update()  # Captures clean frame
+            self.__winrecorder__.draw()     # Draws stats overlay (not recorded)
     
-    def create_compute_shader(self, compute_shader:str, id:str) -> moderngl.ComputeShader:
+    def create_compute_shader(self, compute_shader:str, id:str) -> ComputeShaderType:
         """Create and store a compute shader program."""
         new_compute = self.ctx.compute_shader(compute_shader)
         if id in self.compute_shaders:
@@ -211,7 +261,7 @@ class RootEnv:
         self.compute_shaders[id] = new_compute
         return new_compute
     
-    def create_compute_shader_from_file(self, compute_path:str, id:str) -> moderngl.ComputeShader:
+    def create_compute_shader_from_file(self, compute_path:str, id:str) -> ComputeShaderType:
         """Create a compute shader from a file.
         
         Args:
@@ -224,11 +274,11 @@ class RootEnv:
         compute_shader = self.load_shader_file(compute_path)
         return self.create_compute_shader(compute_shader, id)
     
-    def get_compute_shader(self, id:str) -> moderngl.ComputeShader | None:
+    def get_compute_shader(self, id:str) -> ComputeShaderType | None:
         """Retrieve a compute shader by id."""
         return self.compute_shaders.get(id, None)
     
-    def create_buffer(self, data=None, reserve:int=0, id:Optional[str]=None, dynamic:bool=True) -> moderngl.Buffer:
+    def create_buffer(self, data=None, reserve:int=0, id:Optional[str]=None, dynamic:bool=True) -> BufferType:
         """Create and optionally store a buffer.
         
         Args:
@@ -252,11 +302,11 @@ class RootEnv:
         
         return buffer
     
-    def get_buffer(self, id:str) -> moderngl.Buffer | None:
+    def get_buffer(self, id:str) -> BufferType | None:
         """Retrieve a buffer by id."""
         return self.buffers.get(id, None)
     
-    def bind_buffer_to_storage(self, buffer:moderngl.Buffer|str, binding:int) -> None:
+    def bind_buffer_to_storage(self, buffer:BufferType|str, binding:int) -> None:
         """Bind a buffer to a shader storage binding point.
         
         Args:
@@ -272,9 +322,9 @@ class RootEnv:
         buffer.bind_to_storage_buffer(binding)
     
     def dispatch_compute(self, 
-            compute_id:str|moderngl.ComputeShader, 
+            compute_id:str|ComputeShaderType, 
             groups_x:int=1, groups_y:int=1, groups_z:int=1,
-            buffers:Optional[dict[int, moderngl.Buffer|str]]=None,
+            buffers:Optional[dict[int, BufferType|str]]=None,
             wait:bool=True
         ) -> None:
         """Dispatch a compute shader with automatic buffer binding.
@@ -304,7 +354,7 @@ class RootEnv:
         if wait:
             self.ctx.memory_barrier()
     
-    def read_buffer(self, buffer:moderngl.Buffer|str, dtype='f4') -> np.ndarray:
+    def read_buffer(self, buffer:BufferType|str, dtype='f4') -> np.ndarray:
         """Read data from a buffer into a numpy array.
         
         Args:
@@ -320,7 +370,7 @@ class RootEnv:
         data = np.frombuffer(buffer.read(), dtype=dtype)
         return data
     
-    def write_buffer(self, buffer:moderngl.Buffer|str, data, offset:int=0) -> None:
+    def write_buffer(self, buffer:BufferType|str, data, offset:int=0) -> None:
         """Write data to a buffer.
         
         Args:
@@ -342,16 +392,16 @@ class RootEnv:
     def __update__(self) -> None:
         self.env.update()
 
-    def get_pattr(self, prog_id:str|moderngl.Program, name:str) -> moderngl.Uniform | moderngl.UniformBlock | moderngl.Attribute | moderngl.Varying:
+    def get_pattr(self, prog_id:str|ProgramType, name:str) -> ProgramAttrType:
         return get_pattr(prog_id, name, programs=self.programs)
     
-    def get_uniform(self, prog_id:str|moderngl.Program|moderngl.ComputeShader, name:str) -> moderngl.Uniform:
+    def get_uniform(self, prog_id:str|ProgramType|ComputeShaderType, name:str) -> UniformType:
         return get_uniform(prog_id, name, compute_shaders=self.compute_shaders, programs=self.programs)
 
-    def get_pattr_value(self, prog_id:str|moderngl.Program, name:str) -> int|float|tuple|list:
+    def get_pattr_value(self, prog_id:str|ProgramType, name:str) -> Number|pArray:
         return get_pattr_value(prog_id, name, programs=self.programs)
     
-    def set_pattr_value(self, prog_id:str|moderngl.Program, name: str, value, *, force_write: bool= False) -> None:
+    def set_pattr_value(self, prog_id:str|ProgramType, name: str, value, *, force_write: bool= False) -> None:
         return set_pattr_value(prog_id, name, value, force_write=force_write, programs=self.programs)
 
     def loop(self) -> None:
@@ -364,7 +414,7 @@ class RootEnv:
         target_frame_time = 1.0 / self.target_fps if (self.target_fps and self.target_fps > 0) else 0.0
             
         while not glfw.window_should_close(self.window):
-            start_time = time.time()
+            start_time = time.perf_counter()
             
             # Calculate delta time
             self.delta = start_time - self.last_frame_time
@@ -389,20 +439,24 @@ class RootEnv:
             
             # FPS Limiting
             if target_frame_time > 0:
-                elapsed = time.time() - start_time
+                elapsed = time.perf_counter() - start_time
                 wait = target_frame_time - elapsed
                 if wait > 0:
                     time.sleep(wait)
         
+        # Cleanup recording before terminating
+        if hasattr(self, '__winrecorder__'):
+            self.__winrecorder__.quit()
+        
         glfw.terminate()
 
     def print(
         self,
         text_or_label: str|TextLabel,
-        position: tuple[float, float],
+        position: VectorType,
         scale: float = 1.0,
         style: TextStyle = DEFAULT_TEXT_STYLE,
-        pivot: Pivots = Pivots.TOP_LEFT,
+        pivot: Pivots|int = Pivots.TOP_LEFT,
         save_cache: bool = False
     ) -> Optional[TextLabel]:
 
@@ -416,15 +470,15 @@ class RootEnv:
     
     # ========== Shape Drawing Methods ==========
     
-    def draw_circle(self, center: tuple[float, float], radius: float, **kwargs) -> None:
+    def draw_circle(self, center: VectorType, radius: float, **kwargs) -> None:
         """Draw a circle. See ShapeRenderer.draw_circle for parameters."""
         self.shape_renderer.draw_circle(center, radius, **kwargs)
     
-    def draw_rect(self, position: tuple[float, float], size: tuple[float, float], **kwargs) -> None:
+    def draw_rect(self, position: VectorType, size: VectorType, **kwargs) -> None:
         """Draw a rectangle. See ShapeRenderer.draw_rect for parameters."""
         self.shape_renderer.draw_rect(position, size, **kwargs)
     
-    def draw_line(self, start: tuple[float, float], end: tuple[float, float], **kwargs) -> None:
+    def draw_line(self, start: VectorType, end: VectorType, **kwargs) -> None:
         """Draw a line. See ShapeRenderer.draw_line for parameters."""
         self.shape_renderer.draw_line(start, end, **kwargs)
     
@@ -432,15 +486,15 @@ class RootEnv:
         """Draw a polyline. See ShapeRenderer.draw_lines for parameters."""
         self.shape_renderer.draw_lines(points, **kwargs)
     
-    def create_circle(self, center: tuple[float, float], radius: float, **kwargs) -> ShapeLabel:
+    def create_circle(self, center: VectorType, radius: float, **kwargs) -> ShapeLabel:
         """Create a cached circle. See ShapeRenderer.create_circle for parameters."""
         return self.shape_renderer.create_circle(center, radius, **kwargs)
     
-    def create_rect(self, position: tuple[float, float], size: tuple[float, float], **kwargs) -> ShapeLabel:
+    def create_rect(self, position: VectorType, size: VectorType, **kwargs) -> ShapeLabel:
         """Create a cached rectangle. See ShapeRenderer.create_rect for parameters."""
         return self.shape_renderer.create_rect(position, size, **kwargs)
     
-    def create_line(self, start: tuple[float, float], end: tuple[float, float], **kwargs) -> ShapeLabel:
+    def create_line(self, start: VectorType, end: VectorType, **kwargs) -> ShapeLabel:
         """Create a cached line. See ShapeRenderer.create_line for parameters."""
         return self.shape_renderer.create_line(start, end, **kwargs)
     
@@ -458,4 +512,77 @@ class RootEnv:
     
     def create_line_batch(self, max_shapes: int = 10000) -> InstancedShapeBatch:
         """Create a batch for drawing multiple lines using GPU instancing."""
-        return self.shape_renderer.create_line_batch(max_shapes)
+        return self.shape_renderer.create_line_batch(max_shapes)
+
+
+# Export all public symbols for easy access
+__all__ = [
+    # Version info
+    '__version__',
+    '__author__',
+    '__email__',
+    # Core classes
+    'RootEnv',
+    'DefEnv',
+    # Vector classes and utilities
+    'Vector2D',
+    'V2',
+    'CommonVectors',
+    'batch_add_inplace',
+    'batch_scale_inplace',
+    'batch_normalize_inplace',
+    'vectors_to_array',
+    'array_to_vectors',
+    'lerp',
+    'create_grid',
+    'create_circle',
+    # Type aliases
+    'VectorType',
+    'ColorType',
+    # Color utilities
+    'Color',
+    'normalize_color',
+    'lerp_colors',
+    'gradient',
+    'batch_colors_to_array',
+    # Pre-defined colors
+    'TRANSPARENT',
+    'WHITE',
+    'BLACK',
+    'RED',
+    'GREEN',
+    'BLUE',
+    'CYAN',
+    'MAGENTA',
+    'YELLOW',
+    'ORANGE',
+    'PURPLE',
+    'PINK',
+    'GRAY50',
+    'COLOR_NAMES',
+    'get_color',
+    'has_color',
+    # Text rendering
+    'TextRenderer',
+    'TextLabel',
+    'TextStyle',
+    'Pivots',
+    'DEFAULT_TEXT_STYLE',
+    # Shape rendering
+    'ShapeRenderer',
+    'ShapeLabel',
+    'InstancedShapeBatch',
+    'FillMode',
+    # Input devices
+    'Keyboard',
+    'Mouse',
+    'KeyState',
+    # ModernGL utilities
+    'get_pattr',
+    'get_pattr_value',
+    'set_pattr_value',
+    'get_uniform',
+    # Compilation flags
+    '_VECTOR_COMPILED',
+    '_COLOR_COMPILED',
+]

e2D/__init__.pyi

@@ -0,0 +1,145 @@
+"""
+Type stubs for e2D package
+High-Performance 2D Graphics and Math Library
+"""
+
+import numpy as np
+from typing import Optional, Any
+from .types import BufferType, ComputeShaderType, ContextType, Number, ProgramAttrType, ProgramType, ProgramType, UniformType, VectorType, pArray
+from .text_renderer import DEFAULT_TEXT_STYLE, Pivots, TextRenderer, TextLabel, TextStyle
+from .shapes import ShapeRenderer, ShapeLabel, InstancedShapeBatch
+from .devices import Keyboard, Mouse
+
+__version__: str
+__author__: str
+__email__: str
+
+_VECTOR_COMPILED: bool
+
+class DefEnv:
+    """Base environment class for user environments"""
+    ctx: ContextType
+    
+    def __init__(self) -> None: ...
+    def draw(self) -> None: ...
+    def update(self) -> None: ...
+    def on_resize(self, width: int, height: int) -> None: ...
+
+class RootEnv:
+    """Root environment managing the window, context, and main loop"""
+    window: Any  # glfw._GLFWwindow
+    window_size: tuple[int, int]
+    target_fps: int
+    ctx: ContextType
+    programs: dict[str, ProgramType]
+    compute_shaders: dict[str, ComputeShaderType]
+    buffers: dict[str, BufferType]
+    keyboard: Keyboard
+    mouse: Mouse
+    text_renderer: TextRenderer
+    shape_renderer: ShapeRenderer
+    delta: float
+    last_frame_time: float
+    start_time: float
+    env: DefEnv
+    
+    def __init__(
+        self,
+        window_size: tuple[int, int] = (1920, 1080),
+        target_fps: int = 60,
+        vsync: bool = True,
+        version: tuple[int, int] = (4, 3),
+        monitor: Optional[int] = None
+    ) -> None: ...
+    
+    @property
+    def window_size_f(self) -> tuple[float, float]:
+        """Get window size as floats for shader uniforms."""
+        ...
+    
+    @property
+    def runtime(self) -> float:
+        """Get total elapsed time since program initialization in seconds."""
+        ...
+    
+    def init(self, env: DefEnv) -> "RootEnv": ...
+    
+    def load_shader_file(self, path: str) -> str:
+        """Load shader source code from a file."""
+        ...
+    
+    def create_program(self, vertex_shader: str, fragment_shader: str, id: str) -> ProgramType: ...
+    def create_program_from_files(self, vertex_path: str, fragment_path: str, id: str) -> ProgramType: ...
+    def get_program(self, id: str) -> Optional[ProgramType]: ...
+    
+    def create_compute_shader(self, compute_shader: str, id: str) -> ComputeShaderType: ...
+    def create_compute_shader_from_file(self, compute_path: str, id: str) -> ComputeShaderType: ...
+    def get_compute_shader(self, id: str) -> Optional[ComputeShaderType]: ...
+    
+    def create_buffer(
+        self, 
+        data: Any = None, 
+        reserve: int = 0, 
+        id: Optional[str] = None, 
+        dynamic: bool = True
+    ) -> BufferType: ...
+    
+    def get_buffer(self, id: str) -> Optional[BufferType]: ...
+    def bind_buffer_to_storage(self, buffer: BufferType | str, binding: int) -> None: ...
+    
+    def dispatch_compute(
+        self,
+        compute_id: str | ComputeShaderType,
+        groups_x: int = 1,
+        groups_y: int = 1,
+        groups_z: int = 1,
+        buffers: Optional[dict[int, BufferType | str]] = None,
+        wait: bool = True
+    ) -> None: ...
+    
+    def read_buffer(self, buffer: BufferType | str, dtype: str = 'f4') -> np.ndarray: ...
+    def write_buffer(self, buffer: BufferType | str, data: Any, offset: int = 0) -> None: ...
+    
+    def get_pattr(
+        self, 
+        prog_id: str | ProgramType, 
+        name: str
+    ) -> ProgramAttrType: ...
+    
+    def get_uniform(
+        self, 
+        prog_id: str | ProgramType | ComputeShaderType, 
+        name: str
+    ) -> UniformType: ...
+    
+    def get_pattr_value(self, prog_id: str | ProgramType, name: str) -> Number | pArray: ...
+    def set_pattr_value(self, prog_id: str | ProgramType, name: str, value: Any, *, force_write: bool = False) -> None: ...
+    
+    def loop(self) -> None:
+        """Main rendering loop"""
+        ...
+    
+    def print(
+        self,
+        text_or_label: str | TextLabel,
+        position: VectorType,
+        scale: float = 1.0,
+        style: TextStyle = DEFAULT_TEXT_STYLE,
+        pivot: Pivots|int = Pivots.TOP_LEFT,
+        save_cache: bool = False
+    ) -> Optional[TextLabel]: ...
+    
+    # Shape drawing methods
+    def draw_circle(self, center: VectorType, radius: float, **kwargs: Any) -> None: ...
+    def draw_rect(self, position: VectorType, size: VectorType, **kwargs: Any) -> None: ...
+    def draw_line(self, start: VectorType, end: VectorType, **kwargs: Any) -> None: ...
+    def draw_lines(self, points: Any, **kwargs: Any) -> None: ...
+    
+    def create_circle(self, center: VectorType, radius: float, **kwargs: Any) -> ShapeLabel: ...
+    def create_rect(self, position: VectorType, size: VectorType, **kwargs: Any) -> ShapeLabel: ...
+    def create_line(self, start: VectorType, end: VectorType, **kwargs: Any) -> ShapeLabel: ...
+    def create_lines(self, points: Any, **kwargs: Any) -> ShapeLabel: ...
+    
+    def create_circle_batch(self, max_shapes: int = 10000) -> InstancedShapeBatch: ...
+    def create_rect_batch(self, max_shapes: int = 10000) -> InstancedShapeBatch: ...
+    def create_line_batch(self, max_shapes: int = 10000) -> InstancedShapeBatch: ...