textmode.js 0.6.1 → 0.7.0-beta.2

package/dist/types/index.d.ts

@@ -9,6 +9,8 @@ export type { TextmodeFramebufferOptions } from './rendering/webgl';
 export { registerConversionStrategy, unregisterConversionStrategy, getConversionStrategy, } from './textmode/conversion';
 export type { TextmodeConversionStrategy, TextmodeConversionContext, TextmodeConversionMode, } from './textmode/conversion';
 export type { TextmodePlugin, TextmodePluginAPI, } from './textmode/managers/PluginManager';
+export { FilterRegistry } from './textmode/layers';
+export type { FilterName, BuiltInFilterName, BuiltInFilterParams, FilterContext, TextmodeFilterStrategy, } from './textmode/layers';
 export { TextmodeErrorLevel } from './errors/ErrorHandler';
 export { Textmode as textmode } from './Textmode';
 /** All loading screen related modules and types. */
@@ -17,6 +19,8 @@ export * as loading from './textmode/loading';
 export * as loadables from './textmode/loadables';
 /** All types and interfaces related to input event handling. */
 export * as input from './textmode/managers';
+/** All modules and types related to multi-layered textmode rendering. */
+export * as layering from './textmode/layers';
 /**
  * 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/webgl/core/Framebuffer.d.ts

@@ -21,6 +21,8 @@ export type TextmodeFramebufferOptions = {
     width?: number;
     /** Height of the framebuffer in grid cells */
     height?: number;
+    /** Number of color attachments (1-8) */
+    attachments?: number;
 };
 /**
  * Framebuffer class for managing offscreen rendering targets initialized via {@link Textmodifier.createFramebuffer}.

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

@@ -17,8 +17,10 @@ export declare class GLRenderer implements IRenderer {
     private _userUniforms;
     private _framebufferBindingStack;
     private _viewportStack;
+    private _attachmentCountStack;
     private _currentFramebuffer;
     private _currentViewport;
+    private _currentAttachmentCount;
     constructor(gl: WebGL2RenderingContext);
     /**
      * Push current framebuffer and viewport state onto the stack.
@@ -36,7 +38,7 @@ export declare class GLRenderer implements IRenderer {
      * Bind a framebuffer and update CPU-side tracking.
      * @internal
      */
-    $bindFramebuffer(framebuffer: WebGLFramebuffer | null, width: number, height: number): void;
+    $bindFramebuffer(framebuffer: WebGLFramebuffer | null, width: number, height: number, attachmentCount?: number): void;
     $shader(shader: GLShader): void;
     $createShader(vertexSource: string, fragmentSource: string): GLShader;
     $setUserShader(shader: GLShader | null): void;
@@ -54,6 +56,15 @@ export declare class GLRenderer implements IRenderer {
     $createFramebuffer(width: number, height: number, attachmentCount?: number, options?: FramebufferOptions): GLFramebuffer;
     $background(r: number, g?: number, b?: number, a?: number): void;
     $clear(r?: number, g?: number, b?: number, a?: number): void;
+    /**
+     * Internal MRT-aware clear implementation.
+     * @param r Red component (0-1)
+     * @param g Green component (0-1)
+     * @param b Blue component (0-1)
+     * @param a Alpha component (0-1)
+     * @param preserveCharData If true, clears attachment 0 to (1, 1, 0, 0); if false, clears to (0, 0, 0, 0)
+     */
+    private _clearMRT;
     $resetViewport(): void;
     $flushInstances(): void;
     $dispose(): void;

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

@@ -13,6 +13,8 @@ export declare class GLShader {
     private _uniformLocations;
     private _uniformTypes;
     private _textureUnitCounter;
+    private _textureUnitAssignments;
+    private _maxTextureUnits;
     /**
      * Creates a new GLShader instance.
      * @param gl The WebGL rendering context.
@@ -37,6 +39,7 @@ export declare class GLShader {
      * Set a single uniform value with automatic texture unit management and proper type detection
      */
     $setUniform(name: string, value: UniformValue): void;
+    private _acquireTextureUnit;
     /**
      * Get the WebGL program
      */

package/dist/types/rendering/webgl/utils/hash.d.ts

@@ -67,22 +67,6 @@ export declare function hashArray(arr: number[] | number[][]): number;
  * ```
  */
 export declare function hashTypedArray(arr: Float32Array | Int32Array): number;
-/**
- * Hash an object by converting it to a string representation.
- * Uses the object's memory address (toString) as the hash basis.
- *
- * This is useful for WebGL objects like textures, buffers, etc.
- * where identity is more important than value equality.
- *
- * @param obj - Object to hash
- * @returns Hash based on object identity
- *
- * @example
- * ```typescript
- * const texture = gl.createTexture();
- * hashObject(texture) // → hash based on texture identity
- * ```
- */
 export declare function hashObject(obj: any): number;
 /**
  * Combine two hash values into a single hash.

package/dist/types/textmode/Textmodifier.d.ts

@@ -18,6 +18,8 @@ import type { IKeyboardMixin } from './mixins/interfaces/IKeyboardMixin';
 import type { ITouchMixin } from './mixins/interfaces/ITouchMixin';
 import type { IMouseMixin } from './mixins/interfaces/IMouseMixin';
 import { LoadingScreenManager } from './loading/LoadingScreenManager';
+import { LayerManager } from './layers/LayerManager';
+import type { TextmodeLayerManager } from './layers';
 declare const Textmodifier_base: {
     new (): {};
 };
@@ -43,6 +45,7 @@ export declare class Textmodifier extends Textmodifier_base implements ITextmodi
     _textmodeConversionShader: GLShader;
     _textmodeFramebuffer: GLFramebuffer;
     _presentShader: GLShader;
+    _layerManager: TextmodeLayerManager;
     private _pluginManager;
     private _destroyRequested;
     private _isRenderingFrame;
@@ -84,6 +87,7 @@ export declare class Textmodifier extends Textmodifier_base implements ITextmodi
     get isDisposed(): boolean;
     get overlay(): TextmodeImage | undefined;
     get loading(): LoadingScreenManager;
+    get layers(): LayerManager;
     $registerSource(source: TextmodeSource): void;
 }
 export interface Textmodifier extends IRenderingMixin, IFontMixin, IAnimationMixin, IMouseMixin, ITouchMixin, IKeyboardMixin {

package/dist/types/textmode/interfaces/ITextmodifier.d.ts

@@ -16,6 +16,7 @@ import type { ITouchMixin } from '../mixins/interfaces/ITouchMixin';
 import type { IMouseMixin } from '../mixins/interfaces/IMouseMixin';
 import type { IAnimationMixin } from '../mixins/interfaces/IAnimationMixin';
 import type { LoadingScreenManager } from '../loading/LoadingScreenManager';
+import type { TextmodeLayerManager } from '../layers';
 /**
  * Manages textmode rendering on a [`HTMLCanvasElement`](https://developer.mozilla.org/en-US/docs/Web/API/HTMLCanvasElement) and provides methods for drawing,
  * exporting, font management, event handling, and animation control.
@@ -53,6 +54,8 @@ export interface ITextmodifier extends IRenderingMixin, IFontMixin, IAnimationMi
     readonly _loading: LoadingScreenManager;
     /** Sources registered for rendering @ignore */
     readonly _sources: Set<TextmodeSource>;
+    /** Layer manager for handling multiple layers @ignore */
+    readonly _layerManager: TextmodeLayerManager;
     /** @ignore */
     $registerSource(source: TextmodeSource): void;
     /** Main render method @ignore */
@@ -95,9 +98,12 @@ export interface ITextmodifier extends IRenderingMixin, IFontMixin, IAnimationMi
      */
     setup(callback: () => void): void;
     /**
-     * Set a draw callback function that will be executed before each render.
+     * Set a draw callback function for the base layer.
      *
-     * This callback function is where all drawing commands should be placed for textmode rendering.
+     * This callback function is where all drawing commands should be placed for textmode rendering on the main layer.
+     *
+     * If multiple layers are added via {@link Textmodifier.layers}, each layer can have its own draw callback set via {@link TextmodeLayer.draw}.
+     * This allows for complex multi-layered compositions with independent rendering logic per layer.
      *
      * @param callback The function to call before each render
      *

package/dist/types/textmode/layers/ILayerManager.d.ts

@@ -0,0 +1,36 @@
+import type { TextmodeLayer } from './TextmodeLayer';
+import type { TextmodeLayerOptions } from './types';
+export interface ILayerManager {
+    /**
+     * Get all user layers as a readonly array.
+     */
+    readonly all: readonly TextmodeLayer[];
+    /**
+     * The base layer that is always rendered at the bottom of the layer stack.
+     * This layer represents the main drawing content before any user layers are composited.
+     */
+    readonly base: TextmodeLayer;
+    /**
+     * Add a new layer to the manager.
+     * @param options Layer configuration options.
+     * @returns The newly added layer.
+     */
+    add(options?: TextmodeLayerOptions): TextmodeLayer;
+    /**
+     * Remove a layer from the manager.
+     * @param layer The layer to remove.
+     */
+    remove(layer: TextmodeLayer): void;
+    /**
+     * Move a layer to a new index in the layer stack.
+     * @param layer The layer to move.
+     * @param newIndex The new index for the layer.
+     */
+    move(layer: TextmodeLayer, newIndex: number): void;
+    /**
+     * Swap the order of two layers if they exist in the same collection.
+     * @param layerA The first layer to swap.
+     * @param layerB The second layer to swap.
+     */
+    swap(layerA: TextmodeLayer, layerB: TextmodeLayer): void;
+}

package/dist/types/textmode/layers/Layer2DCompositor.d.ts

@@ -0,0 +1,74 @@
+import type { GLRenderer, GLFramebuffer } from '../../rendering';
+import type { TextmodeGrid } from '../Grid';
+import type { TextmodeLayer } from './TextmodeLayer';
+/**
+ * Parameters for the composite operation.
+ */
+export interface CompositeParams {
+    /** The base texture to composite onto. */
+    baseTexture: WebGLTexture;
+    /** The target framebuffer to render the final result into. */
+    targetFramebuffer: GLFramebuffer;
+    /** The background color as RGBA values (0-1 range). */
+    backgroundColor: [number, number, number, number];
+    /** The base layer configuration (visibility, opacity, offset). */
+    baseLayer: TextmodeLayer;
+    /** The array of user layers to composite on top of the base. */
+    layers: readonly TextmodeLayer[];
+}
+/**
+ * Handles the compositing of multiple layers using shader-based blending.
+ *
+ * This class is responsible for:
+ * - Managing ping-pong framebuffers for layer compositing
+ * - Applying blend modes via the composite shader
+ * - Rendering the final composited result to a target framebuffer
+ *
+ * @ignore
+ *
+ * @remarks
+ * The compositor uses a ping-pong buffer technique to avoid WebGL feedback loops
+ * when reading from and writing to textures during blend operations.
+ */
+export declare class Layer2DCompositor {
+    private readonly _renderer;
+    private readonly _blendShader;
+    private _pingPongBuffers;
+    private _currentPingPongIndex;
+    /**
+     * Create a new LayerCompositor.
+     * @param renderer The WebGL renderer instance.
+     */
+    constructor(renderer: GLRenderer);
+    /**
+     * Initialize the compositor's framebuffers.
+     * @param grid The grid defining the render dimensions.
+     * @ignore
+     */
+    $initialize(grid: TextmodeGrid): void;
+    /**
+     * Composite all layers onto the target framebuffer.
+     * @param params The composite parameters.
+     * @param grid The grid defining render dimensions.
+     */
+    $composite(params: CompositeParams, grid: TextmodeGrid): void;
+    /**
+     * Blend a single layer onto the current composite.
+     */
+    private _blendLayer;
+    /**
+     * Copy the final composite result to the target framebuffer.
+     */
+    private _copyToTarget;
+    /**
+     * Resize the compositor's framebuffers.
+     * @param grid The grid defining the new dimensions.
+     * @ignore
+     */
+    $resize(grid: TextmodeGrid): void;
+    /**
+     * Dispose of all compositor resources.
+     * @ignore
+     */
+    $dispose(): void;
+}

package/dist/types/textmode/layers/LayerManager.d.ts

@@ -0,0 +1,118 @@
+import type { GLFramebuffer } from '../../rendering';
+import type { Textmodifier } from '../Textmodifier';
+import { TextmodeLayer } from './TextmodeLayer';
+import { LayerFilterManager } from './filters';
+import type { TextmodeLayerOptions } from './types';
+import type { ILayerManager } from './ILayerManager';
+/**
+ * Manages all user-defined layers within a Textmodifier instance.
+ *
+ * This manager is responsible for:
+ * - Managing the collection of user layers (add, remove, move, swap)
+ * - Coordinating layer rendering and compositing
+ *
+ * The instance of this class can be accessed via {@link Textmodifier.layers}.
+ *
+ * The base layer at {@link Textmodifier.baseLayer} is not part of this manager's
+ * public layer stack, but is instead managed internally.
+ */
+export declare class LayerManager implements ILayerManager {
+    private readonly _textmodifier;
+    private readonly _renderer;
+    private readonly _conversionShader;
+    private readonly _compositor2D;
+    private readonly _filterManager;
+    private readonly _pendingLayers;
+    private readonly _layers;
+    private readonly _baseLayer;
+    private _baseFramebuffer;
+    private _baseRawFramebuffer;
+    private _isReady;
+    /**
+     * Create a new LayerManager.
+     * @param textmodifier The Textmodifier instance this manager belongs to.
+     * @ignore
+     */
+    constructor(textmodifier: Textmodifier);
+    add(options?: TextmodeLayerOptions): TextmodeLayer;
+    remove(layer: TextmodeLayer): void;
+    move(layer: TextmodeLayer, newIndex: number): void;
+    swap(layerA: TextmodeLayer, layerB: TextmodeLayer): void;
+    /**
+     * Initialize all pending layers and the compositor.
+     * @ignore
+     */
+    $initialize(): void;
+    /**
+     * Render all layers (base and user) and composite them to the target framebuffer.
+     * @param targetFramebuffer The framebuffer to render the final composited result to.
+     * @param backgroundColor The background color as RGBA values (0-1 range).
+     * @ignore
+     */
+    $renderAndComposite(targetFramebuffer: GLFramebuffer, backgroundColor: [number, number, number, number]): void;
+    /**
+     * Render all user layers to their respective framebuffers.
+     */
+    private _renderUserLayers;
+    /**
+     * Composite all layers onto the target framebuffer.
+     */
+    private _compositeLayers;
+    /**
+     * Resize all layers and the compositor to match the current grid dimensions.
+     * @ignore
+     */
+    $resize(): void;
+    /**
+     * Dispose of the layer manager, all layers, and the compositor.
+     * @ignore
+     */
+    $dispose(): void;
+    get all(): readonly TextmodeLayer[];
+    get base(): TextmodeLayer;
+    /**
+     * Access the filter registry for this Textmodifier instance.
+     *
+     * Use this to define or register custom filters scoped to this instance.
+     *
+     * @example
+     * ```typescript
+     * // Define a filter using the simplified API
+     * const shader = await t.createShader(vertSrc, fragSrc);
+     * t.layers.filters.define('brightness', shader, { amount: 1.0 });
+     *
+     * // Register a custom filter strategy
+     * t.layers.filters.register({
+     *     id: 'custom',
+     *     createShader() { return shader; },
+     *     createUniforms(params, ctx) { return { ... }; }
+     * });
+     *
+     * // Use the filter
+     * t.layers.base.filter('brightness', 1.5);
+     * ```
+     */
+    get filters(): LayerFilterManager;
+    /**
+     * Initialize a single layer with required dependencies.
+     */
+    private _initializeLayer;
+    /**
+     * Initialize the base layer with external (shared) framebuffers.
+     * The base layer shares the main textmode draw framebuffer and uses
+     * the manager's base framebuffer for ASCII output.
+     */
+    private _initializeBaseLayer;
+    /**
+     * Remove a layer from a collection and dispose it.
+     */
+    private _removeFromCollection;
+    /**
+     * Move a layer to a new index within a collection.
+     */
+    private _moveInCollection;
+    /**
+     * Swap two layers within a collection.
+     */
+    private _swapInCollection;
+}

package/dist/types/textmode/layers/TextmodeLayer.d.ts

@@ -0,0 +1,193 @@
+import type { GLFramebuffer, GLShader } from '../../rendering';
+import type { TextmodeGrid } from '../Grid';
+import type { Textmodifier } from '../Textmodifier';
+import type { TextmodeLayerBlendMode, TextmodeLayerOptions, LayerDependencies } from './types';
+import type { FilterName, BuiltInFilterName, BuiltInFilterParams, QueuedFilter } from './filters';
+/**
+ * A single layer within a multi-layered textmode rendering context.
+ *
+ * Layers are composited together using various blend modes
+ * to create complex visual effects. Each layer can be independently
+ * manipulated in terms of visibility, opacity, blend mode, and position.
+ *
+ * You can draw on each layer by providing a draw callback function,
+ * like you would with the base layer's {@link Textmodifier.draw} method.
+ *
+ * The base layer, which is always present at the bottom of the layer stack,
+ * can be accessed via {@link Textmodifier.baseLayer}.
+ */
+export declare class TextmodeLayer {
+    /** @ignore */
+    $visible: boolean;
+    /** @ignore */
+    $opacity: number;
+    /** @ignore */
+    $blendMode: TextmodeLayerBlendMode;
+    /** @ignore */
+    $offsetX: number;
+    /** @ignore */
+    $offsetY: number;
+    private _deps?;
+    private _drawFramebuffer?;
+    private _asciiFramebuffer?;
+    private _rawAsciiFramebuffer?;
+    private _drawCallback;
+    private _hasRenderableContent;
+    private _ownsFramebuffers;
+    private _filterQueue;
+    /**
+     * Create a new TextmodeLayer with the given options.
+     * @param options Layer configuration options.
+     * @ignore
+     */
+    constructor(options?: TextmodeLayerOptions);
+    /**
+     * Return true when this layer has a user-provided draw callback.
+     * @ignore
+     */
+    $hasDraw(): boolean;
+    /**
+     * Get and clear the filter queue. Used by LayerManager for base layer filter processing.
+     * @returns The current filter queue, which is then cleared.
+     * @ignore
+     */
+    $consumeFilterQueue(): QueuedFilter[];
+    /**
+     * Run the layer's draw callback in the calling context. This does NOT
+     * manage framebuffer binding; the caller must ensure the correct
+     * framebuffer is bound before invoking this.
+     * @ignore
+     */
+    $runDraw(textmodifier: Textmodifier): void;
+    /**
+     * Define this layers draw callback.
+     * @param callback The function to call when drawing this layer.
+     */
+    draw(callback: () => void): void;
+    /**
+     * Show this layer for rendering.
+     */
+    show(): void;
+    /**
+     * Hide this layer from rendering.
+     */
+    hide(): void;
+    /**
+     * Define or retrieve the layer's opacity.
+     * @param opacity The opacity value to set (between 0 and 1).
+     * @returns The current opacity if no parameter is provided.
+     */
+    opacity(opacity?: number): number | void;
+    /**
+     * Set or get the layer's blend mode.
+     * @param mode The blend mode to set.
+     * @returns The current blend mode if no parameter is provided.
+     */
+    blendMode(mode: TextmodeLayerBlendMode): TextmodeLayerBlendMode | void;
+    /**
+     * Set or get the layer's offset in pixels.
+     * @param x The x offset in pixels.
+     * @param y The y offset in pixels.
+     * @returns The current offset if no parameters are provided.
+     */
+    offset(x?: number, y?: number): {
+        x: number;
+        y: number;
+    } | void;
+    /**
+     * Apply a post-processing filter to this layer's rendered output.
+     *
+     * Filters are applied after ASCII conversion in the order they are called.
+     * Call this method within your layer's draw callback to apply effects.
+     *
+     * @param name The name of the filter to apply (built-in or custom registered filter)
+     * @param params Optional parameters for the filter
+     *
+     * @example
+     * ```typescript
+     * layer.draw(function() {
+     *     // Drawing commands...
+     *     this.rect(10, 10);
+     *
+     *     // Apply filters in sequence
+     *     layer.filter('invert');
+     *     layer.filter('hueRotate', 45);
+     *     layer.filter('glow', { intensity: 0.8, radius: 10 });
+     *     layer.filter('crt');
+     * });
+     * ```
+     *
+     * **Color Adjustment Filters:**
+     * - `'invert'` - Inverts all colors
+     * - `'grayscale'` - Converts to grayscale (param: amount 0-1, default 1)
+     * - `'sepia'` - Applies sepia tone (param: amount 0-1, default 1)
+     * - `'hueRotate'` - Rotates hue (param: angle in degrees)
+     * - `'saturate'` - Adjusts saturation (param: amount, 1 = normal)
+     * - `'brightness'` - Adjusts brightness (param: amount, 1 = normal)
+     * - `'contrast'` - Adjusts contrast (param: amount, 1 = normal)
+     * - `'threshold'` - Black/white threshold (param: threshold 0-1)
+     *
+     * **Post-Processing Effects:**
+     * - `'blur'` - Gaussian blur (param: radius in pixels)
+     * - `'glow'` - Bloom/glow effect (params: intensity, radius, threshold)
+     * - `'chromaticAberration'` - RGB color fringing (param: amount, direction)
+     * - `'scanlines'` - Horizontal scanlines (params: spacing, intensity, offset)
+     * - `'crt'` - Full CRT monitor effect (params: curvature, scanlineIntensity, vignetteIntensity, brightness)
+     * - `'vignette'` - Darkened edges (params: intensity, softness)
+     * - `'pixelate'` - Pixelation effect (param: pixelSize)
+     * - `'noise'` - Random noise overlay (params: intensity, seed)
+     *
+     * Custom filters can be registered using {@link registerFilterStrategy}.
+     */
+    filter<T extends BuiltInFilterName>(name: T, params?: BuiltInFilterParams[T]): void;
+    filter(name: FilterName, params?: unknown): void;
+    /**
+     * Attach necessary dependencies for this layer to function.
+     * @param deps Dependencies required by the layer.
+     * @ignore
+     */
+    $attachDependencies(deps: LayerDependencies): void;
+    /**
+     * Render the layer's content into its ASCII framebuffer.
+     * @param textmodifier The Textmodifier instance.
+     * @param conversionShader The shader used for conversion.
+     * @ignore
+     */
+    $render(textmodifier: Textmodifier, conversionShader: GLShader): void;
+    /**
+     * Resize the layer's framebuffers to match the given grid dimensions.
+     * @param grid The TextmodeGrid instance.
+     * @ignore
+     */
+    $resize(grid: TextmodeGrid): void;
+    /**
+     * Dispose of the layer's resources.
+     * @ignore
+     */
+    $dispose(): void;
+    /**
+     * Returns the WebGL texture of the final ASCII framebuffer.
+     * If the layer is not yet initialized, returns undefined.
+     */
+    get texture(): WebGLTexture | undefined;
+    /**
+     * Returns the width of the final ASCII framebuffer in pixels.
+     * If the layer is not yet initialized, returns 0.
+     */
+    get width(): number;
+    /**
+     * Returns the height of the final ASCII framebuffer in pixels.
+     * If the layer is not yet initialized, returns 0.
+     */
+    get height(): number;
+    /**
+     * Return true when this layer has renderable content.
+     * @ignore
+     */
+    get $hasRenderableContent(): boolean;
+    /**
+     * Returns the draw framebuffer for this layer. If the layer is not yet initialized, returns undefined.
+     */
+    get drawFramebuffer(): GLFramebuffer | undefined;
+    private _initializeFramebuffers;
+}

package/dist/types/textmode/layers/filters/FilterRegistry.d.ts

@@ -0,0 +1,83 @@
+import type { GLRenderer, GLShader } from '../../../rendering';
+import type { TextmodeFilterStrategy, FilterName } from './types';
+/**
+ * Instance-based registry for filter strategies.
+ *
+ * Each {@link Textmodifier} instance has its own FilterRegistry, allowing
+ * filters to be scoped to a specific instance rather than registered globally.
+ *
+ * Access via `t.layers.filters`.
+ *
+ * @example
+ * ```typescript
+ * // Define a simple filter with the declarative API
+ * t.layers.filters.define('blur', blurShader, { radius: 5.0 });
+ *
+ * // Register a custom filter strategy
+ * t.layers.filters.register({
+ *     id: 'custom',
+ *     createShader(ctx) { ... },
+ *     createUniforms(params, ctx) { ... }
+ * });
+ *
+ * // Use the filter
+ * t.layers.base.filter('blur', { radius: 10 });
+ * ```
+ */
+export declare class FilterRegistry {
+    private readonly _renderer;
+    private readonly _filters;
+    private readonly _shaderCache;
+    /**
+     * Create a new FilterRegistry.
+     * @param renderer The WebGL renderer instance
+     * @internal
+     */
+    constructor(renderer: GLRenderer);
+    /**
+     * Define a filter using a simplified declarative syntax.
+     *
+     * This is the easiest way to create filters for add-on libraries.
+     * The shader is compiled immediately and cached.
+     *
+     * @param id Unique filter identifier
+     * @param shader Pre-compiled GLShader, fragment shader source string, or path to a fragment shader file (.frag or .glsl)
+     * @param uniforms Default uniform values. Keys map uniform names to [paramName, defaultValue] tuples.
+     *
+     * @example
+     * ```typescript
+     * // With pre-compiled shader (recommended for add-ons)
+     * const shader = await t.createShader(vertSrc, fragSrc);
+     * t.layers.filters.define('brightness', shader, { u_amount: ['amount', 1.0] });
+     *
+     * // With a path to a fragment shader file
+     * await t.layers.filters.define('brightness', './brightness.frag', { u_amount: ['amount', 1.0] });
+     *
+     * // Usage:
+     * t.layers.base.filter('brightness', 1.5);
+     * t.layers.base.filter('brightness', { amount: 1.5 });
+     * ```
+     */
+    $register(id: FilterName, shader: GLShader | string, defs?: Record<string, [paramName: string, defaultValue: unknown]>): Promise<void>;
+    /**
+     * Unregister a filter by its ID.
+     *
+     * @param id The filter ID to unregister
+     * @returns true if the filter was unregistered, false if it wasn't found
+     */
+    $unregister(id: FilterName): boolean;
+    /**
+     * Get a filter strategy by ID.
+     * @internal
+     */
+    $get(id: FilterName): TextmodeFilterStrategy | undefined;
+    /**
+     * Dispose all resources.
+     * @internal
+     */
+    $dispose(): void;
+    /**
+     * Register all built-in filters.
+     */
+    private _registerBuiltInFilters;
+}