textmode.js 0.4.0 → 0.6.0-beta.1

package/dist/types/rendering/webgl/{Shader.d.ts → core/Shader.d.ts}

@@ -2,7 +2,7 @@ import { GLFramebuffer } from './Framebuffer';
 /**
  * Supported uniform value types
  */
-type UniformValue = number | boolean | number[] | number[][] | Float32Array | Int32Array | GLFramebuffer | WebGLTexture;
+export type UniformValue = number | boolean | number[] | number[][] | Float32Array | Int32Array | GLFramebuffer | WebGLTexture;
 /**
  * WebGL implementation of the shader abstraction.
  * Provides GPU shader program management with automatic uniform handling and minification support.
@@ -32,31 +32,11 @@ export declare class GLShader {
      * Reset texture unit counter and other state
      */
     private _resetState;
-    $setUniforms(uniforms: Record<string, UniformValue>): void;
-    /**
-     * Check if a uniform exists in this shader
-     */
-    $hasUniform(name: string): boolean;
-    /**
-     * Get debug information about a uniform
-     */
-    $getUniformInfo(name: string): {
-        type: number;
-        size: number;
-    } | null;
-    /**
-     * List all available uniforms for debugging
-     */
-    $listUniforms(): Array<{
-        name: string;
-        type: number;
-        size: number;
-    }>;
+    $setUniforms(uniforms: Record<string, any>): void;
     /**
      * Set a single uniform value with automatic texture unit management and proper type detection
      */
     $setUniform(name: string, value: UniformValue): void;
-    private _getNextTextureUnit;
     /**
      * Get the WebGL program
      */
@@ -67,4 +47,3 @@ export declare class GLShader {
      */
     $dispose(): void;
 }
-export {};

package/dist/types/rendering/webgl/core/interfaces/IFramebuffer.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Interface for managing offscreen rendering targets (framebuffers).
+ *
+ * Framebuffers are used to render content offscreen, enabling effects like:
+ * - Post-processing filters
+ * - Multi-pass rendering
+ * - Render-to-texture operations
+ * - Double buffering
+ *
+ * Framebuffers in this system support Multiple Render Targets (MRT), allowing
+ * multiple textures to be written simultaneously in a single render pass.
+ */
+export interface IFramebuffer {
+    /**
+     * Get the current framebuffer width in pixels/cells.
+     */
+    readonly width: number;
+    /**
+     * Get the current framebuffer height in pixels/cells.
+     */
+    readonly height: number;
+    /**
+     * Get all textures associated with this framebuffer.
+     *
+     * Useful for binding textures for reading in shaders.
+     *
+    * Textmode framebuffers allocate 4 attachments by default:
+    * - 0: Character data encoded in red and green channels
+    * - 1: Character colors
+    * - 2: Cell background colors
+    * - 3: Inversion, horizontal/flip flags, and rotation encoded in red, green, blue, alpha channels
+     */
+    readonly textures: WebGLTexture[];
+    /**
+     * Update the framebuffer texture with canvas or video content.
+     * Note: Only updates the first attachment in multi-attachment mode.
+     *
+     * @param source - The HTML canvas or video element to copy from
+     * @ignore
+     */
+    $update(source: HTMLCanvasElement | HTMLVideoElement): void;
+    /**
+     * Resize the framebuffer to new dimensions.
+     * This recreates the internal textures with the new size and invalidates any cached pixel data.
+     *
+     * @param width - New width in pixels/cells
+     * @param height - New height in pixels/cells
+     */
+    resize(width: number, height: number): void;
+    /**
+     * Read pixels from a specific color attachment into an RGBA Uint8Array.
+     *
+     * The returned pixel data:
+     * - Is in RGBA format (4 bytes per pixel)
+     * - Has top-left origin (first pixel is top-left corner)
+     * - Is cached until the next render pass to this framebuffer
+     *
+     * @param attachmentIndex - The index of the color attachment to read (0-based)<br/>
+     *                          0. Character data and transform info<br/>
+     *                          1. Character colors<br/>
+     *                          2. Cell background colors<br/>
+    * @returns A Uint8Array containing the pixel data in RGBA format
+     */
+    readPixels(attachmentIndex: number): Uint8Array;
+    /**
+     * Begin drawing to this framebuffer.
+     *
+     * This method:
+     * - Flushes any pending draw calls to maintain proper render order
+     * - Saves the current framebuffer and viewport state
+     * - Binds this framebuffer as the render target
+     * - Clears all color attachments to transparent black
+     * - Sets the viewport to match the framebuffer dimensions
+     *
+     * All subsequent drawing operations will target this framebuffer until {@link end} is called.
+     */
+    begin(): void;
+    /**
+     * End rendering to this framebuffer and restore previous state.
+     *
+     * This method:
+     * - Flushes any pending draw calls into this framebuffer
+     * - Restores the previously bound framebuffer
+     * - Restores the previous viewport settings
+     *
+     * After calling this method, rendering operations will target the previously active framebuffer.
+     */
+    end(): void;
+    /**
+     * Dispose of WebGL resources used by this framebuffer.
+     *
+     * This releases:
+     * - The WebGL framebuffer object
+     * - All associated texture objects
+     * - Any cached pixel data
+     *
+     * This method is idempotent and safe to call multiple times.
+     * After disposal, the framebuffer should not be used for rendering.
+     *
+     * @ignore
+     */
+    $dispose(): void;
+}

package/dist/types/rendering/webgl/core/interfaces/IRenderer.d.ts

@@ -0,0 +1,210 @@
+import type { GLFramebuffer, FramebufferOptions } from "../Framebuffer";
+import type { GLShader } from "../Shader";
+import type { RenderState } from "../../state/RenderState";
+/**
+ * Interface for the core WebGL renderer that manages the WebGL context and provides high-level rendering operations.
+ *
+ * This interface defines the contract for all rendering operations including:
+ * - Shader management and creation
+ * - Framebuffer operations
+ * - Primitive rendering (rectangles, lines, ellipses, triangles, arcs, bezier curves)
+ * - Image and texture rendering
+ * - State management
+ * - Viewport and clearing operations
+ */
+export interface IRenderer {
+    /**
+     * Get the WebGL rendering context.
+     * Provides direct access to the underlying WebGL2 context for advanced operations.
+     */
+    readonly context: WebGLRenderingContext;
+    /**
+     * Get the current render state.
+     * The render state tracks the current rendering configuration including blend modes,
+     * colors, and other state that affects how primitives are drawn.
+     */
+    readonly state: RenderState;
+    /**
+     * Set the current shader for subsequent rendering operations.
+     * This binds the shader program and makes it active for all following draw calls
+     * until a different shader is set.
+     *
+     * @param shader - The shader to activate
+     */
+    $shader(shader: GLShader): void;
+    /**
+     * Create a new shader from vertex and fragment source code.
+     * The shader is compiled, linked, and cached by the shader manager.
+     *
+     * @param vertexSource - GLSL source code for the vertex shader
+     * @param fragmentSource - GLSL source code for the fragment shader
+     * @returns A compiled and linked shader program
+     */
+    $createShader(vertexSource: string, fragmentSource: string): GLShader;
+    /**
+     * Set a custom user shader for subsequent rendering operations.
+     * This shader will be used for primitive rendering instead of the default shader.
+     * Pass null to reset to the default shader.
+     *
+     * @param shader - The custom shader to use, or null to reset to default
+     */
+    $setUserShader(shader: GLShader | null): void;
+    /**
+     * Set a uniform value for the current user shader.
+     * The uniform must exist in the shader for this to have any effect.
+     *
+     * @param name - The name of the uniform variable in the shader
+     * @param value - The value to set (type must match the uniform type in the shader)
+     */
+    $setUniform(name: string, value: any): void;
+    /**
+     * Set multiple uniform values for the current user shader.
+     * This is a convenience method for setting multiple uniforms at once.
+     *
+     * @param uniforms - A record mapping uniform names to their values
+     */
+    $setUserUniforms(uniforms: Record<string, any>): void;
+    /**
+     * Create a filter shader using the standard instanced vertex shader.
+     * Filter shaders are commonly used for post-processing effects and only require
+     * a custom fragment shader since they use a standard quad-rendering vertex shader.
+     *
+     * @param fragmentSource - GLSL source code for the fragment shader
+     * @returns A shader configured for filter operations
+     */
+    $createFilterShader(fragmentSource: string): GLShader;
+    /**
+     * Draw a quad covering the pixel rectangle (x, y, width, height) on the canvas.
+     * The quad is converted to NDC (Normalized Device Coordinates) and rendered with the
+     * current shader using only the a_position attribute.
+     * Origin: top-left (canvas space).
+     *
+     * @param x - X coordinate of the top-left corner in pixels
+     * @param y - Y coordinate of the top-left corner in pixels
+     * @param width - Width of the quad in pixels
+     * @param height - Height of the quad in pixels
+     */
+    $quad(x: number, y: number, width: number, height: number): void;
+    /**
+     * Draw a rectangle.
+     * The rectangle is rendered using the current shader and render state.
+     *
+     * @param x - X coordinate of the top-left corner
+     * @param y - Y coordinate of the top-left corner
+     * @param width - Width of the rectangle
+     * @param height - Height of the rectangle
+     */
+    $rect(x: number, y: number, width: number, height: number): void;
+    /**
+     * Draw a line from one point to another.
+     * The line is rendered with the current stroke settings from the render state.
+     *
+     * @param x1 - X coordinate of the line start point
+     * @param y1 - Y coordinate of the line start point
+     * @param x2 - X coordinate of the line end point
+     * @param y2 - Y coordinate of the line end point
+     */
+    $line(x1: number, y1: number, x2: number, y2: number): void;
+    /**
+     * Draw an ellipse.
+     * The ellipse is centered at (x, y) with the specified width and height.
+     *
+     * @param x - X coordinate of the center
+     * @param y - Y coordinate of the center
+     * @param width - Width of the ellipse
+     * @param height - Height of the ellipse
+     */
+    $ellipse(x: number, y: number, width: number, height: number): void;
+    /**
+     * Draw a triangle.
+     * The triangle is defined by three vertices and rendered with the current render state.
+     *
+     * @param x1 - First vertex X coordinate
+     * @param y1 - First vertex Y coordinate
+     * @param x2 - Second vertex X coordinate
+     * @param y2 - Second vertex Y coordinate
+     * @param x3 - Third vertex X coordinate
+     * @param y3 - Third vertex Y coordinate
+     */
+    $triangle(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number): void;
+    /**
+     * Draw a cubic Bezier curve.
+     * The curve is defined by a start point, two control points, and an end point.
+     *
+     * @param x1 - Start point X coordinate
+     * @param y1 - Start point Y coordinate
+     * @param cp1x - First control point X coordinate
+     * @param cp1y - First control point Y coordinate
+     * @param cp2x - Second control point X coordinate
+     * @param cp2y - Second control point Y coordinate
+     * @param x2 - End point X coordinate
+     * @param y2 - End point Y coordinate
+     */
+    $bezierCurve(x1: number, y1: number, cp1x: number, cp1y: number, cp2x: number, cp2y: number, x2: number, y2: number): void;
+    /**
+     * Draw an arc (a portion of an ellipse).
+     * The arc is part of an ellipse centered at (x, y) with the specified dimensions,
+     * drawn from the start angle to the stop angle.
+     *
+     * @param x - X coordinate of the center
+     * @param y - Y coordinate of the center
+     * @param width - Width of the ellipse
+     * @param height - Height of the ellipse
+     * @param start - Start angle in radians
+     * @param stop - Stop angle in radians
+     */
+    $arc(x: number, y: number, width: number, height: number, start: number, stop: number): void;
+    /**
+     * Create a new framebuffer for off-screen rendering.
+     * Framebuffers can be used for render-to-texture operations, post-processing,
+     * and other advanced rendering techniques.
+     *
+     * @param width - Width of the framebuffer in pixels
+     * @param height - Height of the framebuffer in pixels
+     * @param attachmentCount - Number of color attachments (default: 1, supports MRT)
+     * @param options - Additional framebuffer configuration options
+     * @returns A new framebuffer instance
+     */
+    $createFramebuffer(width: number, height: number, attachmentCount?: number, options?: FramebufferOptions): GLFramebuffer;
+    /**
+     * Fill the current framebuffer with a solid color.
+     * This sets the canvas background color in the render state and clears the framebuffer.
+     * If only one value is provided, it's used for all RGB components.
+     *
+     * @param r - Red component (0-255)
+     * @param g - Green component (0-255), defaults to r if not provided
+     * @param b - Blue component (0-255), defaults to r if not provided
+     * @param a - Alpha component (0-255), defaults to 255 if not provided
+     */
+    $background(r: number, g?: number, b?: number, a?: number): void;
+    /**
+     * Clear the current framebuffer to a specified color.
+     * Color components should be in the range [0, 1].
+     *
+     * @param r - Red component (0-1), defaults to 0
+     * @param g - Green component (0-1), defaults to 0
+     * @param b - Blue component (0-1), defaults to 0
+     * @param a - Alpha component (0-1), defaults to 0
+     */
+    $clear(r?: number, g?: number, b?: number, a?: number): void;
+    /**
+     * Reset the viewport to match the canvas dimensions.
+     * This ensures the viewport is synchronized with the canvas size, which is
+     * important after canvas resize operations.
+     */
+    $resetViewport(): void;
+    /**
+     * Flush all batched instances for instanced rendering.
+     * This must be called at the end of each frame to actually render all batched geometry.
+     * The method processes the entire draw queue and renders all primitives that were
+     * queued during the frame.
+     */
+    $flushInstances(): void;
+    /**
+     * Dispose of all WebGL resources managed by this renderer.
+     * This releases buffers, shaders, geometries, and other GPU resources.
+     * This method is idempotent and safe to call multiple times.
+     * After disposal, the renderer should not be used.
+     */
+    $dispose(): void;
+}

package/dist/types/rendering/webgl/geometries/{Arc.d.ts → 2d/Arc.d.ts}

@@ -1,9 +1,10 @@
 /**
  * Instanced arc (pie segment) geometry implementation
  */
-import type { InstanceBatch } from '../InstanceBatch';
-import { type ArcParams } from '../types/GeometryTypes';
-import { BaseGeometry } from './BaseGeometry';
+import type { InstanceBatch } from '../../batching/InstanceBatch';
+import { type ArcParams } from '../../types/GeometryTypes';
+import { BaseGeometry } from '../BaseGeometry';
+import type { IRenderState } from '../../state/RenderState';
 /**
  * Instanced arc geometry renderer.
  * Batches arc draw calls using a unit triangle fan scaled to width/height.
@@ -12,5 +13,5 @@ import { BaseGeometry } from './BaseGeometry';
 export declare class Arc extends BaseGeometry {
     constructor(gl: WebGL2RenderingContext, batch: InstanceBatch);
     /** Add an arc instance (filled pie segment) */
-    $addInstance(params: ArcParams, renderState: any): number;
+    $addInstance(params: ArcParams, renderState: IRenderState): number;
 }

package/dist/types/rendering/webgl/geometries/{BezierCurve.d.ts → 2d/BezierCurve.d.ts}

@@ -1,9 +1,10 @@
 /**
  * Instanced bezier curve geometry implementation
  */
-import type { InstanceBatch } from '../InstanceBatch';
-import { type BezierCurveParams } from '../types/GeometryTypes';
-import { BaseGeometry } from './BaseGeometry';
+import type { InstanceBatch } from '../../batching/InstanceBatch';
+import { type BezierCurveParams } from '../../types/GeometryTypes';
+import { BaseGeometry } from '../BaseGeometry';
+import type { IRenderState } from '../../state/RenderState';
 /**
  * TRUE INSTANCED bezier curve geometry renderer.
  *
@@ -18,5 +19,5 @@ export declare class BezierCurve extends BaseGeometry {
     /**
      * Add a bezier curve instance to the batch - TRUE INSTANCED APPROACH
      */
-    $addInstance(params: BezierCurveParams, renderState: any): number;
+    $addInstance(params: BezierCurveParams, renderState: IRenderState): number;
 }

package/dist/types/rendering/webgl/geometries/{Ellipse.d.ts → 2d/Ellipse.d.ts}

@@ -1,9 +1,10 @@
 /**
  * Instanced ellipse geometry implementation
  */
-import type { InstanceBatch } from '../InstanceBatch';
-import { type EllipseParams } from '../types/GeometryTypes';
-import { BaseGeometry } from './BaseGeometry';
+import type { InstanceBatch } from '../../batching/InstanceBatch';
+import { type EllipseParams } from '../../types/GeometryTypes';
+import { BaseGeometry } from '../BaseGeometry';
+import type { IRenderState } from '../../state/RenderState';
 /**
  * Instanced ellipse geometry renderer.
  * Batches all ellipse draw calls for efficient GPU rendering.
@@ -12,9 +13,9 @@ export declare class Ellipse extends BaseGeometry {
     constructor(gl: WebGL2RenderingContext, batch: InstanceBatch);
     /**
      * Add an ellipse instance to the batch
-     * @param params Ellipse parameters (x,y as top-left corner, width/height as dimensions)
+     * @param params Ellipse parameters
      * @param renderState Current render state
      * @returns Index of the added instance
      */
-    $addInstance(params: EllipseParams, renderState: any): number;
+    $addInstance(params: EllipseParams, renderState: IRenderState): number;
 }

package/dist/types/rendering/webgl/geometries/{Line.d.ts → 2d/Line.d.ts}

@@ -1,9 +1,10 @@
 /**
  * Instanced line geometry implementation
  */
-import type { InstanceBatch } from '../InstanceBatch';
-import { type LineParams } from '../types/GeometryTypes';
-import { BaseGeometry } from './BaseGeometry';
+import type { InstanceBatch } from '../../batching/InstanceBatch';
+import { type LineParams } from '../../types/GeometryTypes';
+import { BaseGeometry } from '../BaseGeometry';
+import type { IRenderState } from '../../state/RenderState';
 /**
  * Instanced line geometry renderer.
  * Batches all line draw calls for efficient GPU rendering.
@@ -16,5 +17,5 @@ export declare class Line extends BaseGeometry {
      * @param renderState Current render state
      * @returns Index of the added instance
      */
-    $addInstance(params: LineParams, renderState: any): number;
+    $addInstance(params: LineParams, renderState: IRenderState): number;
 }

package/dist/types/rendering/webgl/geometries/{Rectangle.d.ts → 2d/Rectangle.d.ts}

@@ -1,9 +1,10 @@
 /**
  * Instanced rectangle geometry implementation
  */
-import type { InstanceBatch } from '../InstanceBatch';
-import { type RectangleParams } from '../types/GeometryTypes';
-import { BaseGeometry } from './BaseGeometry';
+import type { InstanceBatch } from '../../batching/InstanceBatch';
+import { type RectangleParams } from '../../types/GeometryTypes';
+import { BaseGeometry } from '../BaseGeometry';
+import type { IRenderState } from '../../state/RenderState';
 /**
  * Instanced rectangle geometry renderer.
  * Batches all rectangle draw calls for efficient GPU rendering.
@@ -16,5 +17,5 @@ export declare class Rectangle extends BaseGeometry {
      * @param renderState Current render state
      * @returns Index of the added instance
      */
-    $addInstance(params: RectangleParams, renderState: any): number;
+    $addInstance(params: RectangleParams, renderState: IRenderState): number;
 }

package/dist/types/rendering/webgl/geometries/{Triangle.d.ts → 2d/Triangle.d.ts}

@@ -1,9 +1,10 @@
 /**
  * Instanced triangle geometry implementation
  */
-import type { InstanceBatch } from '../InstanceBatch';
-import { type TriangleParams } from '../types/GeometryTypes';
-import { BaseGeometry } from './BaseGeometry';
+import type { InstanceBatch } from '../../batching/InstanceBatch';
+import { type TriangleParams } from '../../types/GeometryTypes';
+import { BaseGeometry } from '../BaseGeometry';
+import type { IRenderState } from '../../state/RenderState';
 /**
  * Instanced triangle geometry renderer.
  * Batches all triangle draw calls for efficient GPU rendering.
@@ -16,5 +17,5 @@ export declare class Triangle extends BaseGeometry {
      * @param renderState Current render state
      * @returns Index of the added instance
      */
-    $addInstance(params: TriangleParams, renderState: any): number;
+    $addInstance(params: TriangleParams, renderState: IRenderState): number;
 }

package/dist/types/rendering/webgl/geometries/BaseGeometry.d.ts

@@ -1,10 +1,7 @@
-/**
- * Base class for instanced geometry implementations
- */
-import type { InstanceBatch } from '../InstanceBatch';
-import type { InstanceData } from '../InstanceData';
+import type { InstanceBatch } from '../batching/InstanceBatch';
+import type { InstanceData } from '../batching/InstanceData';
 import type { IGeometry, GeometryType, UnitGeometryData } from '../types/GeometryTypes';
-import type { IRenderState } from '../RenderState';
+import type { IRenderState } from '../state/RenderState';
 /**
  * Abstract base class for all instanced geometries.
  * Provides common functionality for instance data creation and batch management.
@@ -24,26 +21,33 @@ export declare abstract class BaseGeometry implements IGeometry {
     $hasInstances(): boolean;
     $dispose(): void;
     abstract $addInstance(params: any, renderState: any): number;
+    protected _addInstance(instanceData: InstanceData, _rotationCenterX: number, _rotationCenterY: number): number;
     /**
-     * Create base instance data from render state.
-     * This method handles the common instance data creation logic.
-     * Subclasses can override this to add geometry-specific data.
-     */
-    protected _createBaseInstanceData(x: number, y: number, width: number, height: number, renderState: IRenderState): InstanceData;
-    /**
-     * Convert screen coordinates to NDC for compatibility with existing code
+     * Write instance data directly to batch buffer (zero-allocation helper).
+     * Handles all common instance data setup to eliminate code duplication.
+     *
+     * @param x - X position
+     * @param y - Y position
+     * @param width - Width
+     * @param height - Height
+     * @param centerX - Rotation center X (in pixels)
+     * @param centerY - Rotation center Y (in pixels)
+     * @param renderState - Current render state
+     * @param geometryData - Optional geometry-specific data (arc angles, bezier points, depth)
+     * @returns Index of the written instance
      */
-    protected _toNDC(x: number, y: number): {
-        nx: number;
-        ny: number;
-    };
-    protected _setRotationCenter(instanceData: InstanceData, centerX: number, centerY: number): void;
-    protected _calculateRotationParams(x: number, y: number, width: number, height: number, rotationXDegrees: number, rotationYDegrees: number, rotationZDegrees: number): {
-        centerX: number;
-        centerY: number;
-        radiansX: number;
-        radiansY: number;
-        radiansZ: number;
-        aspectRatio: number;
-    };
+    protected _writeInstance(x: number, y: number, width: number, height: number, renderState: IRenderState, geometryData?: {
+        arcStart?: number;
+        arcStop?: number;
+        cp1x?: number;
+        cp1y?: number;
+        cp2x?: number;
+        cp2y?: number;
+        bezStartX?: number;
+        bezStartY?: number;
+        bezEndX?: number;
+        bezEndY?: number;
+        depth?: number;
+        baseZ?: number;
+    }): number;
 }

package/dist/types/rendering/webgl/geometries/immediate/ImmediateQuad.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Immediate-mode quad renderer for full-screen passes and framebuffer presentation.
+ *
+ * This is NOT an instanced geometry - it's a simple, stateless utility for drawing
+ * a single textured quad immediately. Used primarily for presenting final framebuffer
+ * results to the screen or for filter passes.
+ */
+/**
+ * Simple immediate-mode quad renderer.
+ * No instancing, no batching, just a single quad drawn with vertex positions in NDC.
+ */
+export declare class ImmediateQuad {
+    private _gl;
+    private _vbo;
+    private _vertexData;
+    constructor(gl: WebGL2RenderingContext);
+    /**
+     * Draw a quad immediately with the given pixel coordinates.
+     * Converts pixel coordinates to NDC and renders a textured quad.
+     *
+     * The current shader must be bound before calling this method.
+     *
+     * @param x X position in pixels
+     * @param y Y position in pixels
+     * @param width Width in pixels
+     * @param height Height in pixels
+     */
+    $draw(x: number, y: number, width: number, height: number): void;
+    /**
+     * Dispose of WebGL resources.
+     */
+    $dispose(): void;
+}

package/dist/types/rendering/webgl/geometries/index.d.ts

@@ -1,6 +1,6 @@
-export { Rectangle } from './Rectangle';
-export { Line } from './Line';
-export { Ellipse } from './Ellipse';
-export { Arc } from './Arc';
-export { Triangle } from './Triangle';
-export { BezierCurve } from './BezierCurve';
+export { Rectangle } from './2d/Rectangle';
+export { Line } from './2d/Line';
+export { Ellipse } from './2d/Ellipse';
+export { Arc } from './2d/Arc';
+export { Triangle } from './2d/Triangle';
+export { BezierCurve } from './2d/BezierCurve';

package/dist/types/rendering/webgl/geometries/utils/GeometryDescriptors.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Shared geometry attribute descriptors to eliminate redundant definitions.
+ * All geometries of the same dimensionality (2D/3D) share identical stride and attribute layouts.
+ */
+/**
+ * Unit quad vertex data used by both instanced and immediate quad rendering.
+ * Format: [x, y, u, v] for each vertex (position + texCoord interleaved)
+ * Layout: Two triangles forming a unit square centered at origin from (-0.5,-0.5) to (0.5,0.5)
+ */
+export declare const UNIT_QUAD: Float32Array<ArrayBuffer>;
+/**
+ * Standard 2D geometry attribute descriptor.
+ * Used by: Rectangle, Line, Ellipse, Triangle, Arc, BezierCurve
+ *
+ * Layout: [position.xy, texCoord.uv]
+ * Stride: 16 bytes (4 floats)
+ */
+export declare const GEOMETRY_2D_DESCRIPTOR: {
+    readonly _stride: 16;
+    readonly _primitiveType: 4;
+    readonly _attributes: {
+        readonly _position: {
+            readonly size: 2;
+            readonly offset: 0;
+        };
+        readonly _texCoord: {
+            readonly size: 2;
+            readonly offset: 8;
+        };
+    };
+};

package/dist/types/rendering/webgl/geometries/utils/GeometryGenerator.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Geometry generation utilities for 2D shapes.
+ * 2D geometries use 4 floats per vertex: position.xy + texCoord.uv
+ */
+/**
+ * Generate 2D circle/ellipse vertices.
+ */
+export declare function generateCircleVertices(segments?: number): Float32Array;
+/**
+ * Generate unit arc vertices for 2D arc rendering.
+ */
+export declare function generateArcVertices(segments: number): Float32Array;
+/**
+ * Generate bezier curve geometry (multi-segment for GPU evaluation).
+ */
+export declare function generateBezierVertices(segments?: number): Float32Array;