textmode.js 0.1.9 → 0.2.0-beta.2

package/dist/types/export/txt/types.d.ts

@@ -2,7 +2,6 @@
  * TXT-specific type definitions for the textmode.js library.
  */
 import type { TextmodeFont, TextmodeGrid } from '../..';
-import type { TextmodeConversionPipeline } from '../../textmode/ConversionPipeline';
 /**
  * Options for exporting the textmode content to TXT format.
  */
@@ -40,12 +39,13 @@ export interface TXTGenerationOptions {
     preserveTrailingSpaces: boolean;
     lineEnding: 'lf' | 'crlf';
     emptyCharacter: string;
+    filename: string;
 }
 /**
  * Data required for textmode rendering export
  */
 export interface TextmodeRenderingData {
-    pipeline: TextmodeConversionPipeline;
+    pipeline: any;
     grid: TextmodeGrid;
     font: TextmodeFont;
 }

package/dist/types/index.d.ts

@@ -3,18 +3,12 @@ export { Textmodifier } from './textmode/Textmodifier';
 export { TextmodeFont } from './textmode/font';
 export { TextmodeCanvas } from './textmode/Canvas';
 export { TextmodeGrid } from './textmode/Grid';
-export type { TextmodeOptions, TextmodeCaptureSource } from './textmode/Textmodifier';
+export type { TextmodeOptions } from './textmode/Textmodifier';
 export type { TextmodeCharacter } from './textmode/font';
 /** All types related to export options for different formats. */
 export * as export from './export';
-export { TextmodeConversionPipeline } from './textmode/ConversionPipeline';
-export { TextmodeColorPalette } from './ColorPalette';
 export { TextmodeErrorLevel } from './errors/ErrorHandler';
-/** Contains all converters that can be added to a rendering pipeline to shape the textmode output. */
-export * as converters from './textmode/converters';
 export { Textmode as textmode } from './Textmode';
-/** Contains all rendering-related utilities and components. */
-export * as rendering from './rendering/core';
 /**
  * Exports the create, setErrorLevel, and version functions from the Textmode class for UMD compatibility,
  * so calls like `textmode.create()` can be used.

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

@@ -1,4 +1,3 @@
-export * from './core';
 export { GLShader as Shader } from './webgl/Shader';
 export { GLRenderer } from './webgl/Renderer';
 export { GLFramebuffer } from './webgl/Framebuffer';

package/dist/types/rendering/webgl/DrawQueue.d.ts

@@ -0,0 +1,26 @@
+import type { DrawCommand } from './types/DrawCommand';
+/**
+ * Global draw queue preserving user-issued draw order across geometry types.
+ */
+export declare class DrawQueue implements Iterable<DrawCommand> {
+    private _commands;
+    private _nextId;
+    private _size;
+    /** Reserve or reuse a pooled slot */
+    private _acquireSlot;
+    /** Specialized enqueues (zero-alloc on steady state) */
+    $enqueueRectangle(x: number, y: number, width: number, height: number, renderState: any): number;
+    $enqueueLine(x1: number, y1: number, x2: number, y2: number, thickness: number | undefined, renderState: any): number;
+    $enqueueEllipse(x: number, y: number, width: number, height: number, renderState: any): number;
+    $enqueueArc(x: number, y: number, width: number, height: number, start: number, stop: number, renderState: any): number;
+    $enqueueTriangle(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, renderState: any): number;
+    $enqueueBezierCurve(x1: number, y1: number, cp1x: number, cp1y: number, cp2x: number, cp2y: number, x2: number, y2: number, thickness: number | undefined, renderState: any): number;
+    /** Number of queued commands */
+    get length(): number;
+    /** True if no commands queued */
+    get isEmpty(): boolean;
+    /** Clear all queued commands */
+    $clear(): void;
+    /** Iterate in the exact order of insertion */
+    [Symbol.iterator](): Iterator<DrawCommand>;
+}

package/dist/types/rendering/webgl/Framebuffer.d.ts

@@ -1,69 +1,70 @@
-import { Framebuffer, type FramebufferOptions } from '../core/Framebuffer';
+export type FramebufferOptions = {
+    /** Texture filtering mode */
+    filter?: 'nearest' | 'linear';
+    /** Texture wrapping mode */
+    wrap?: 'clamp' | 'repeat';
+    /** Texture format */
+    format?: 'rgba' | 'rgb';
+    /** Data type for texture data */
+    type?: 'unsigned_byte' | 'float';
+};
 /**
- * WebGL implementation of the framebuffer abstraction.
+ * WebGL2 implementation of the framebuffer abstraction.
  * Provides GPU-accelerated render targets with automatic texture creation.
+ * Supports both single-texture and Multiple Render Targets (MRT) functionality.
  * Can also be used as a standalone texture (without render target functionality).
  */
-export declare class GLFramebuffer extends Framebuffer {
+export declare class GLFramebuffer {
+    protected _width: number;
+    protected _height: number;
+    protected _options: FramebufferOptions;
+    protected _pixels: Uint8Array | null;
     private _gl;
     private _framebuffer;
-    private _texture;
+    private _textures;
+    private _attachmentCount;
     private _previousState;
-    constructor(gl: WebGLRenderingContext, width: number, height?: number, options?: FramebufferOptions);
-    /**
-     * Execute a function with this framebuffer bound, then restore previous binding
-     */
-    private _withFramebufferBound;
-    private _createTexture;
-    private _updateTextureSize;
-    private _attachTexture;
+    private _attachmentPixels;
+    constructor(gl: WebGL2RenderingContext, width: number, height?: number, attachmentCount?: number, options?: FramebufferOptions);
+    private _createTextures;
+    private _attachTextures;
     /**
      * Update the framebuffer texture with canvas or video content
+     * Note: Only updates the first attachment in multi-attachment mode
      */
     $update(source: HTMLCanvasElement | HTMLVideoElement): void;
     /**
-     * Update the framebuffer texture with pixel data
+     * Resize the framebuffer
      */
-    updatePixels(pixelData: Uint8Array, width: number, height: number): void;
+    $resize(width: number, height: number): void;
     /**
-     * Resize the framebuffer
+     * Read pixels from a specific color attachment into an RGBA Uint8Array.
+     * Rows are flipped to top-left origin to match row-major iteration in exporters.
      */
-    resize(width: number, height: number): void;
+    $readAttachment(attachmentIndex: number): Uint8Array;
+    /** Read and cache all attachments. */
+    $readAll(): void;
     /**
      * Begin rendering to this framebuffer
      */
-    begin(): void;
+    $begin(): void;
     /**
      * End rendering to this framebuffer and restore previous state
      */
-    end(): void;
-    /**
-     * Load pixel data from the framebuffer into the pixels array
-     */
-    loadPixels(): void;
-    /**
-     * Gets a pixel or a region of pixels from the framebuffer.
-     *
-     * The version of `get()` with no parameters returns pixel data for the entire framebuffer.
-     * The version of `get()` with two parameters interprets them as coordinates and returns
-     * an array with the `[R, G, B, A]` values of the pixel at the given point.
-     * The version of `get()` with four parameters interprets them as coordinates and dimensions
-     * and returns pixel data for the specified region.
-     *
-     * @param x x-coordinate of the pixel (optional)
-     * @param y y-coordinate of the pixel (optional)
-     * @param w width of the region (optional)
-     * @param h height of the region (optional)
-     * @returns Uint8Array for regions or number array for single pixel
-     */
-    get(): Uint8Array;
-    get(x: number, y: number): [number, number, number, number];
-    get(x: number, y: number, w: number, h: number): Uint8Array;
+    $end(): void;
     /**
      * Dispose of WebGL resources used by this framebuffer.
      * This method is idempotent and safe to call multiple times.
      */
     $dispose(): void;
+    get width(): number;
+    get height(): number;
+    get pixels(): Uint8Array | null;
+    get options(): FramebufferOptions;
     get framebuffer(): WebGLFramebuffer | null;
     get texture(): WebGLTexture;
+    get textures(): WebGLTexture[];
+    get attachmentCount(): number;
+    /** Return a cached copy of pixels for an attachment if previously read, else null. */
+    getAttachmentPixels(attachmentIndex: number): Uint8Array | null;
 }

package/dist/types/rendering/webgl/InstanceBatch.d.ts

@@ -0,0 +1,91 @@
+import type { InstanceData } from './InstanceData';
+import { GLShader } from './Shader';
+/**
+ * High-performance instance batch manager for WebGL instanced rendering.
+ * Handles efficient buffer management, automatic capacity growth, and WebGL attribute setup.
+ *
+ * Features:
+ * - Automatic buffer growth with configurable growth factor
+ * - Double buffering for smooth updates
+ * - Efficient sub-buffer updates for animated content
+ * - Optimized WebGL attribute binding
+ * - Memory pooling to reduce garbage collection
+ */
+export declare class InstanceBatch {
+    private _gl;
+    private _instances;
+    private _capacity;
+    private _growthFactor;
+    private _instanceBuffer;
+    private _needsUpload;
+    private _lastUploadedCount;
+    private _attributeLocationCache;
+    private _packedDataCache;
+    /**
+     * Creates a new instance batch.
+     * @param gl WebGL2 rendering context
+     * @param initialCapacity Initial buffer capacity (number of instances)
+     * @param growthFactor Buffer growth factor when capacity is exceeded
+     */
+    constructor(gl: WebGL2RenderingContext, initialCapacity?: number, growthFactor?: number);
+    /**
+     * Add a new instance to the batch.
+     * @param instance Instance data to add
+     * @returns Index of the added instance
+     */
+    $addInstance(instance: InstanceData): number;
+    /**
+     * Get the current number of instances in the batch.
+     */
+    get count(): number;
+    /**
+     * Check if the batch is empty.
+     */
+    get isEmpty(): boolean;
+    /**
+     * Clear all instances from the batch.
+     */
+    clear(): void;
+    /**
+     * Ensure buffer capacity can handle the specified number of instances.
+     * Automatically grows buffer if needed.
+     * @param requiredInstances Number of instances that need to fit
+     */
+    private _ensureCapacity;
+    /**
+     * Create or recreate the WebGL instance buffer.
+     */
+    private _createBuffer;
+    /**
+     * Upload instance data to GPU buffer.
+     * Uses efficient sub-buffer updates when possible.
+     */
+    $upload(): void;
+    /**
+     * Get cached attribute locations for a shader program.
+     * @param program WebGL shader program
+     * @returns Map of attribute name to location
+     */
+    private _getAttributeLocations;
+    /**
+     * Bind instance buffer and configure vertex attributes for instanced rendering.
+     * @param shader The shader program to bind attributes for
+     */
+    $bindAttributes(shader: GLShader): void;
+    /**
+     * Unbind instance attributes to clean up WebGL state.
+     * @param shader The shader program to unbind attributes for
+     */
+    $unbindAttributes(shader: GLShader): void;
+    /**
+     * Execute instanced draw call for all instances in the batch.
+     * @param primitiveType WebGL primitive type (e.g., gl.TRIANGLES)
+     * @param vertexCount Number of vertices in the base geometry
+     */
+    $draw(primitiveType: number, vertexCount: number): void;
+    /**
+     * Dispose of WebGL resources.
+     * Call this when the batch is no longer needed.
+     */
+    $dispose(): void;
+}

package/dist/types/rendering/webgl/InstanceData.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Core data structure representing a single instance in batched rendering.
+ * Contains all necessary data for ASCII character rendering via MRT.
+ */
+export interface InstanceData {
+    position: [number, number];
+    size: [number, number];
+    character: [number, number, number];
+    primaryColor: [number, number, number, number];
+    secondaryColor: [number, number, number, number];
+    rotation: [number, number];
+    transform: [number, number, number];
+    globalRotation: number;
+    rotationCenter: [number, number];
+    arcAngles?: [number, number];
+    bezierControlPoint1?: [number, number];
+    bezierControlPoint2?: [number, number];
+    bezierStartPoint?: [number, number];
+    bezierEndPoint?: [number, number];
+}
+/**
+ * Optimized packed instance data layout for GPU upload.
+ * Designed for efficient WebGL attribute binding and minimal memory usage.
+ *
+ * Total size: 132 bytes per instance (with Arc + Bezier support)
+ * Layout designed to minimize GPU bandwidth and maximize cache efficiency.
+ */
+export declare class PackedInstanceData {
+    static readonly BYTES_PER_INSTANCE = 132;
+    static readonly FLOATS_PER_INSTANCE = 33;
+    /**
+     * Pack instance data into a Float32Array for efficient GPU upload.
+     * @param instance The instance data to pack
+     * @param target Optional target array to write into (for reuse)
+     * @param offset Offset in the target array to start writing
+     * @returns Float32Array containing packed instance data
+     */
+    static $pack(instance: InstanceData, target?: Float32Array, offset?: number): Float32Array;
+    /**
+     * Pack multiple instances into a single Float32Array for batch upload.
+     * @param instances Array of instance data to pack
+     * @returns Float32Array containing all packed instance data
+     */
+    static $packBatch(instances: InstanceData[]): Float32Array;
+}
+/**
+ * WebGL attribute configuration for instance data.
+ * Defines how packed instance data maps to vertex shader attributes.
+ */
+export interface InstanceAttributeConfig {
+    location: number;
+    size: number;
+    type: number;
+    normalized: boolean;
+    stride: number;
+    offset: number;
+    divisor: number;
+}
+/**
+ * Pre-configured attribute layouts for efficient WebGL setup.
+ */
+export declare class InstanceAttributeLayout {
+    static readonly STRIDE = 132;
+    static readonly ATTRIBUTES: Record<string, InstanceAttributeConfig>;
+}

package/dist/types/rendering/webgl/RenderPipeline.d.ts

@@ -0,0 +1,15 @@
+import type { IGeometry } from './types/GeometryTypes';
+import { GeometryType } from './types/GeometryTypes';
+import type { RenderContext } from './types/RenderTypes';
+import type { DrawCommand } from './types/DrawCommand';
+/**
+ * Execute draw commands exactly in the order they were enqueued while
+ * still batching consecutive commands of the same geometry type to minimize
+ * state changes and buffer uploads.
+ */
+export declare class RenderPipeline {
+    private readonly _vaoMgr;
+    private readonly _gl;
+    constructor(gl: WebGL2RenderingContext);
+    $execute(context: RenderContext, commands: Iterable<DrawCommand>, geometries: Map<GeometryType, IGeometry>): void;
+}

package/dist/types/rendering/webgl/RenderState.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Represents a snapshot of the current rendering state
+ */
+export interface IRenderState {
+    lineWeight: number;
+    rotation: number;
+    character: [number, number, number];
+    charColor: [number, number, number, number];
+    cellColor: [number, number, number, number];
+    flipHorizontally: boolean;
+    flipVertically: boolean;
+    invert: boolean;
+    charRotation: [number, number];
+}
+/**
+ * Manages rendering state and provides push/pop functionality for state management
+ */
+export declare class RenderState {
+    private _currentLineWeight;
+    private _currentRotation;
+    private _currentCharacter;
+    private _currentCharColor;
+    private _currentCellColor;
+    private _flipHorizontally;
+    private _flipVertically;
+    private _invert;
+    private _charRotation;
+    private _canvasBackgroundColor;
+    private _stateStack;
+    /**
+     * Save the current rendering state to the state stack
+     */
+    $push(): void;
+    /**
+     * Restore the most recently saved rendering state from the state stack
+     */
+    $pop(): void;
+    /**
+     * Reset frame-specific state - called automatically after each frame.
+     * Note: This does not reset fill/stroke state as that should persist
+     * across frames and be managed by push/pop or explicit calls.
+     */
+    $reset(): void;
+    /**
+     * Write current state into an existing target object/struct to avoid allocations.
+     * The target is expected to have the same shape as RenderStateSnapshot, with mutable arrays.
+     */
+    $writeSnapshotTo(target: {
+        lineWeight: number;
+        rotation: number;
+        character: number[];
+        charColor: number[];
+        bgColor: number[];
+        flipHorizontally: boolean;
+        flipVertically: boolean;
+        invert: boolean;
+        charRotation: number[];
+    }): void;
+    get lineWeight(): number;
+    get canvasBackgroundColor(): [number, number, number, number];
+    $setLineWeight(weight: number): void;
+    $setRotation(degrees: number): void;
+    $setCharacter(character: [number, number, number]): void;
+    $setCharColor(r: number, g?: number, b?: number, a?: number): void;
+    $setCellColor(r: number, g?: number, b?: number, a?: number): void;
+    $setFlipHorizontally(flip: boolean): void;
+    $setFlipVertically(flip: boolean): void;
+    $setInvert(invert: boolean): void;
+    $setCharRotation(rotation: number): void;
+    $setCanvasBackground(r: number, g: number, b: number, a: number): void;
+}

package/dist/types/rendering/webgl/Renderer.d.ts

@@ -1,96 +1,39 @@
 import { GLFramebuffer } from "./Framebuffer";
-import type { Framebuffer, FramebufferOptions } from '../core/Framebuffer';
+import type { FramebufferOptions } from '../webgl/Framebuffer';
 import { GLShader } from "./Shader";
-import type { UniformValue } from "../core";
+import { RenderState } from "./RenderState";
 /**
  * Core WebGL renderer that manages the WebGL context and provides high-level rendering operations
  */
 export declare class GLRenderer {
     private _gl;
-    private _imageShader;
-    private _solidColorShader;
     private _currentShader;
-    private _rectangleGeometry;
-    private _lineGeometry;
-    private _currentFillColor;
-    private _fillMode;
-    private _currentStrokeColor;
-    private _currentStrokeWeight;
-    private _strokeMode;
-    private _currentRotation;
-    private _stateStack;
-    constructor(gl: WebGLRenderingContext | WebGL2RenderingContext);
+    private _fullscreenQuadBuffer;
+    private _ndcQuadBuffer;
+    private readonly _geometries;
+    private readonly _renderPipeline;
+    private readonly _drawQueue;
+    private _renderState;
+    constructor(gl: WebGL2RenderingContext);
+    /** Get or create a geometry instance */
+    private _getGeometry;
     /**
      * Set the current shader
      */
     $shader(shader: GLShader): void;
-    /**
-     * Sets the fill color for subsequent rendering operations
-     * @param r Red component *(0-255)*
-     * @param g Green component *(0-255, optional)*
-     * @param b Blue component *(0-255, optional)*
-     * @param a Alpha component *(0-255, optional)*
-     */
-    $fill(r: number, g?: number, b?: number, a?: number): void;
-    /**
-     * Sets the stroke color for subsequent rendering operations
-     * @param r Red component *(0-255)*
-     * @param g Green component *(0-255, optional)*
-     * @param b Blue component *(0-255, optional)*
-     * @param a Alpha component *(0-255, optional)*
-     */
-    $stroke(r: number, g?: number, b?: number, a?: number): void;
-    /**
-     * Sets the stroke weight (thickness) for subsequent stroke operations
-     * @param weight The stroke thickness in pixels
-     */
-    $strokeWeight(weight: number): void;
-    /**
-     * Disables stroke rendering for subsequent operations
-     */
-    $noStroke(): void;
-    /**
-     * Disables fill rendering for subsequent operations
-     */
-    $noFill(): void;
-    /**
-     * Sets the rotation angle for subsequent rendering operations
-     * @param degrees The rotation angle in degrees
-     */
-    $rotate(degrees: number): void;
-    /**
-     * Save the current rendering state (fill, stroke, etc.) to the state stack
-     */
-    $push(): void;
-    /**
-     * Restore the most recently saved rendering state from the state stack
-     */
-    $pop(): void;
-    /**
-     * Reset frame-specific state - called automatically after each frame.
-     * Note: This does not reset fill/stroke state as that should persist
-     * across frames and be managed by push/pop or explicit calls.
-     */
-    $reset(): void;
-    /**
-     * Detect if a fragment shader is WebGL2 by checking for version directive
-     * @param fragmentSource The fragment shader source code
-     * @returns true if WebGL2, false if WebGL1
-     */
-    private _detectShaderVersion;
     $createShader(vertexSource: string, fragmentSource: string): GLShader;
-    $createFilterShader(fragmentSource: string): GLShader;
     /**
-     * Set a uniform value for the current shader
+     * Draw a quad covering the pixel rectangle (x, y, width, height) on the canvas.
+     * The quad is converted to NDC and rendered with the current shader using only a_position.
+     * Origin: top-left (canvas space)
      */
-    $setUniform(name: string, value: UniformValue): void;
+    $quadPixels(x: number, y: number, width: number, height: number): void;
     /**
-     * Draw a rectangle with the current fill and/or stroke settings
+     * Draw a rectangle.
      */
     $rect(x: number, y: number, width: number, height: number): void;
     /**
-     * Draw a line from (x1, y1) to (x2, y2) with the current stroke settings.
-     * Lines only support stroke rendering - fill properties are ignored.
+     * Draw a line from (x1, y1) to (x2, y2).
      * @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
@@ -98,13 +41,40 @@ export declare class GLRenderer {
      */
     $line(x1: number, y1: number, x2: number, y2: number): void;
     /**
-     * Calculate rotation parameters for built-in shaders (NDC coordinates)
+     * Draw an ellipse.
+     * @param x X coordinate (center)
+     * @param y Y coordinate (center)
+     * @param width Ellipse width
+     * @param height Ellipse height
+     */
+    $ellipse(x: number, y: number, width: number, height: number): void;
+    /**
+     * Draw a triangle.
+     * @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 bezier curve.
+     * @param x1 Start point X coordinate
+     * @param y1 Start point Y coordinate
+     * @param cp1x Control point 1 X coordinate
+     * @param cp1y Control point 1 Y coordinate
+     * @param cp2x Control point 2 X coordinate
+     * @param cp2y Control point 2 Y coordinate
+     * @param x2 End point X coordinate
+     * @param y2 End point Y coordinate
      */
-    private _calculateRotationParams;
+    $bezierCurve(x1: number, y1: number, cp1x: number, cp1y: number, cp2x: number, cp2y: number, x2: number, y2: number): void;
     /**
      * Create a new framebuffer
      */
-    $createFramebuffer(width: number, height: number, options?: FramebufferOptions): GLFramebuffer;
+    $createFramebuffer(width: number, height: number, attachmentCount?: number, options?: FramebufferOptions): GLFramebuffer;
+    $arc(x: number, y: number, width: number, height: number, start: number, stop: number): void;
     /**
      * Fill the current framebuffer with a solid color
      */
@@ -121,13 +91,16 @@ export declare class GLRenderer {
      * Get the WebGL context
      */
     get context(): WebGLRenderingContext;
+    get state(): RenderState;
+    /**
+     * Flush all batched instances for instanced rendering.
+     * This must be called at the end of each frame to actually render the batched geometry.
+     * @param shader The instanced shader to use for rendering
+     */
+    $flushInstances(shader: GLShader): void;
     /**
      * Dispose of all WebGL resources managed by this renderer.
      * This method is idempotent and safe to call multiple times.
      */
     $dispose(): void;
-    /**
-     * Render a framebuffer at a specific position with optional scaling
-     */
-    $image(source: Framebuffer, posX: number, posY: number, width?: number, height?: number): void;
 }

package/dist/types/rendering/webgl/Shader.d.ts

@@ -1,9 +1,13 @@
-import { Shader, type UniformValue } from '../core/Shader';
+import { GLFramebuffer } from './Framebuffer';
+/**
+ * Supported uniform value types
+ */
+type UniformValue = number | boolean | number[] | Float32Array | Int32Array | GLFramebuffer | WebGLTexture;
 /**
  * WebGL implementation of the shader abstraction.
  * Provides GPU shader program management with automatic uniform handling.
  */
-export declare class GLShader extends Shader {
+export declare class GLShader {
     private _gl;
     private _program;
     private _uniformLocations;
@@ -18,13 +22,6 @@ export declare class GLShader extends Shader {
      * @ignore
      */
     constructor(gl: WebGLRenderingContext, vertexSource: string, fragmentSource: string);
-    /**
-     * Factory method to create a shader from source object
-     */
-    static fromSource(gl: WebGLRenderingContext, source: {
-        vertex: string;
-        fragment: string;
-    }): GLShader;
     private _cacheLocations;
     private _createProgram;
     private _createShader;
@@ -35,23 +32,21 @@ export declare class GLShader extends Shader {
     /**
      * Reset texture unit counter and other state
      */
-    $resetState(): void;
+    private _resetState;
+    $setUniforms(uniforms: Record<string, UniformValue>): void;
     /**
      * Set a single uniform value with automatic texture unit management
      */
-    setUniform(name: string, value: UniformValue): void;
+    $setUniform(name: string, value: UniformValue): void;
     private _getNextTextureUnit;
-    /**
-     * Check if a uniform is an integer type
-     */
-    private _isUniformInteger;
     /**
      * Get the WebGL program
      */
-    get glProgram(): WebGLProgram;
+    get $glProgram(): WebGLProgram;
     /**
      * Dispose of WebGL resources used by this shader.
      * This method is idempotent and safe to call multiple times.
      */
     $dispose(): void;
 }
+export {};