textmode.js 0.7.0-beta.1 → 0.7.0-beta.2

package/dist/types/index.d.ts

@@ -9,7 +9,7 @@ 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 { registerFilterStrategy, unregisterFilterStrategy, isFilterRegistered, getRegisteredFilters, } from './textmode/layers';
+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';

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

@@ -1,6 +1,7 @@
 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';
 /**
@@ -69,6 +70,29 @@ export declare class LayerManager implements ILayerManager {
     $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.
      */

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

@@ -1,87 +1,83 @@
+import type { GLRenderer, GLShader } from '../../../rendering';
 import type { TextmodeFilterStrategy, FilterName } from './types';
 /**
- * Register a custom filter strategy.
+ * Instance-based registry for filter strategies.
  *
- * Once registered, the filter can be used with `layer.filter('filterId', params)`.
+ * Each {@link Textmodifier} instance has its own FilterRegistry, allowing
+ * filters to be scoped to a specific instance rather than registered globally.
  *
- * @param strategy The filter strategy to register
- * @throws Error if a filter with the same ID is already registered
+ * Access via `t.layers.filters`.
  *
  * @example
  * ```typescript
- * import { registerFilterStrategy } from 'textmode.js';
+ * // Define a simple filter with the declarative API
+ * t.layers.filters.define('blur', blurShader, { radius: 5.0 });
  *
- * registerFilterStrategy({
- *     id: 'customGlow',
- *     createShader(context) {
- *         return context.renderer.$createShader(vertexSrc, fragmentSrc);
- *     },
- *     createUniforms(params, context) {
- *         return {
- *             u_intensity: params?.intensity ?? 1.0,
- *             u_color: params?.color ?? [1, 1, 1],
- *             u_resolution: [context.width, context.height]
- *         };
- *     }
+ * // Register a custom filter strategy
+ * t.layers.filters.register({
+ *     id: 'custom',
+ *     createShader(ctx) { ... },
+ *     createUniforms(params, ctx) { ... }
  * });
  *
- * // Then in your sketch:
- * layer.draw(() => {
- *     // ... drawing code
- *     this.filter('customGlow', { intensity: 0.8, color: [1, 0.5, 0] });
- * });
- * ```
- */
-export declare function registerFilterStrategy(strategy: TextmodeFilterStrategy): void;
-/**
- * Unregister a previously registered filter strategy.
- *
- * @param id The ID of the filter to unregister
- * @returns true if the filter was unregistered, false if it wasn't registered
- *
- * @example
- * ```typescript
- * import { unregisterFilterStrategy } from 'textmode.js';
- *
- * unregisterFilterStrategy('customGlow');
- * ```
- */
-export declare function unregisterFilterStrategy(id: FilterName): boolean;
-/**
- * Get a registered filter strategy by its ID.
- *
- * @param id The ID of the filter
- * @returns The filter strategy, or undefined if not found
- * @internal
- */
-export declare function getFilterStrategy(id: FilterName): TextmodeFilterStrategy | undefined;
-/**
- * Check if a filter is registered.
- *
- * @param id The ID of the filter to check
- * @returns true if the filter is registered
- *
- * @example
- * ```typescript
- * import { isFilterRegistered } from 'textmode.js';
- *
- * if (isFilterRegistered('myFilter')) {
- *     layer.filter('myFilter');
- * }
- * ```
- */
-export declare function isFilterRegistered(id: FilterName): boolean;
-/**
- * Get a list of all registered filter IDs.
- *
- * @returns An array of all registered filter IDs
- *
- * @example
- * ```typescript
- * import { getRegisteredFilters } from 'textmode.js';
- *
- * console.log('Available filters:', getRegisteredFilters());
- * // ['invert', 'grayscale', 'sepia', 'hueRotate', ...]
+ * // Use the filter
+ * t.layers.base.filter('blur', { radius: 10 });
  * ```
  */
-export declare function getRegisteredFilters(): FilterName[];
+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;
+}

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

@@ -1,5 +1,5 @@
-import type { GLRenderer, GLFramebuffer } from '../../../rendering';
-import type { QueuedFilter } from './types';
+import type { GLRenderer, GLShader, GLFramebuffer } from '../../../rendering';
+import type { QueuedFilter, FilterName } from './types';
 /**
  * Manages filter shader compilation and application for layers.
  *
@@ -17,11 +17,14 @@ export declare class LayerFilterManager {
     private _pingPongBuffers;
     private _currentBufferIndex;
     private _isInitialized;
+    private _filterRegistry;
     /**
      * Create a new LayerFilterManager.
      * @param renderer The WebGL renderer instance
      */
     constructor(renderer: GLRenderer);
+    register(id: FilterName, shader: GLShader | string, uniformDefs?: Record<string, [paramName: string, defaultValue: unknown]>): Promise<void>;
+    unregister(id: FilterName): boolean;
     /**
      * Initialize ping-pong buffers for filter chain processing.
      * @param width Buffer width in pixels

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

@@ -1,4 +1,3 @@
 export type { FilterName, BuiltInFilterName, BuiltInFilterParams, QueuedFilter, FilterContext, TextmodeFilterStrategy } from './types';
-export { registerFilterStrategy, unregisterFilterStrategy, isFilterRegistered, getRegisteredFilters } from './FilterRegistry';
-export { getFilterStrategy } from './FilterRegistry';
+export { FilterRegistry } from './FilterRegistry';
 export { LayerFilterManager } from './LayerFilterManager';

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

@@ -2,5 +2,5 @@ export { TextmodeLayer } from './TextmodeLayer';
 export { LayerManager as TextmodeLayerManager } from './LayerManager';
 export { Layer2DCompositor as LayerCompositor } from './Layer2DCompositor';
 export type { TextmodeLayerOptions, TextmodeLayerBlendMode } from './types';
-export { registerFilterStrategy, unregisterFilterStrategy, isFilterRegistered, getRegisteredFilters } from './filters';
+export { FilterRegistry } from './filters';
 export type { FilterName, BuiltInFilterName, BuiltInFilterParams, FilterContext, TextmodeFilterStrategy } from './filters';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "textmode.js",
-  "version": "0.7.0-beta.1",
+  "version": "0.7.0-beta.2",
   "description": "textmode.js is a lightweight creative coding library for creating real-time ASCII art on the web.",
   "type": "module",
   "types": "./dist/types/index.d.ts",