textmode.js 0.8.1 → 0.9.0-beta.2

package/dist/types/exports/conversion.d.ts

@@ -0,0 +1 @@
+export * from '../textmode/conversion';

package/dist/types/exports/filters.d.ts

@@ -0,0 +1 @@
+export * from '../textmode/filters';

package/dist/types/exports/input.d.ts

@@ -0,0 +1 @@
+export * from '../textmode/managers';

package/dist/types/exports/layering.d.ts

@@ -0,0 +1 @@
+export * from '../textmode/layers';

package/dist/types/exports/loadables.d.ts

@@ -0,0 +1 @@
+export * from '../textmode/loadables';

package/dist/types/exports/loading.d.ts

@@ -0,0 +1 @@
+export * from '../textmode/loading';

package/dist/types/exports/plugins.d.ts

@@ -0,0 +1 @@
+export type { TextmodePlugin, TextmodePluginAPI, TextmodePluginHook, LayerLifecycleHook, LayerRenderHook, SetupLifecycleHook, } from '../textmode/managers/PluginManager';

package/dist/types/index.d.ts

@@ -16,7 +16,40 @@ export type { TextmodeFramebufferOptions } from './rendering/webgl';
  * but custom strategies can be registered via {@link TextmodeConversionManager.register}.
  */
 export * as conversion from './textmode/conversion';
-export type { TextmodePlugin, TextmodePluginAPI } from './textmode/managers/PluginManager';
+/**
+ * Plugin system types for extending textmode.js functionality.
+ *
+ * Plugins can:
+ * - Add methods to TextmodeLayer instances (e.g., `.synth()`)
+ * - Hook into the render lifecycle (pre/post draw, per-layer rendering)
+ * - React to layer creation and disposal events
+ * - Access the WebGL renderer, framebuffers, and other internals
+ *
+ * @example
+ * ```ts
+ * import type { TextmodePlugin, TextmodePluginAPI } from 'textmode.js/plugins';
+ *
+ * const MyPlugin: TextmodePlugin = {
+ *   name: 'my-plugin',
+ *   version: '1.0.0',
+ *   install(textmodifier, api) {
+ *     // Extend layers with a new method
+ *     api.extendLayer('myMethod', function(value) {
+ *       this.setPluginState('my-plugin', { value });
+ *     });
+ *
+ *     // Hook into layer rendering
+ *     api.registerLayerPreRenderHook((layer, ctx) => {
+ *       const state = layer.getPluginState('my-plugin');
+ *       if (state) {
+ *         // Render plugin content to layer.drawFramebuffer
+ *       }
+ *     });
+ *   }
+ * };
+ * ```
+ */
+export * as plugins from './textmode/managers/PluginManager';
 /**
  * All filter related modules and types.
  *
@@ -28,6 +61,7 @@ export type { TextmodePlugin, TextmodePluginAPI } from './textmode/managers/Plug
  */
 export * as filters from './textmode/filters';
 export { TextmodeErrorLevel } from './errors/ErrorHandler';
+export { GLShader as TextmodeShader } from './rendering/webgl/core/Shader';
 export { Textmode as textmode } from './Textmode';
 /** All loading screen related modules and types. */
 export * as loading from './textmode/loading';

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

@@ -81,7 +81,7 @@ export declare class GLFramebuffer implements IFramebuffer {
      * @ignore
      */
     private _updateMaterial;
-    $dispose(): void;
+    dispose(): void;
     /** Get the width of the framebuffer */
     get width(): number;
     /** Get the height of the framebuffer */

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

@@ -4,8 +4,13 @@ import { GLFramebuffer } from './Framebuffer';
  */
 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.
+ *
+ * Shader class for managing WebGL shader programs initialized via {@link Textmodifier.createFilterShader} or {@link Textmodifier.createShader}.
+ *
+ * Use shaders and set uniforms via {@link Textmodifier.shader}, {@link Textmodifier.setUniform}, and {@link Textmodifier.setUniforms}.
+ *
+ * With a shader active, the next {@link Textmodifier.rect} call will use the shader for rendering,
+ * and automatically unuse it afterwards.
  */
 export declare class GLShader {
     private _gl;
@@ -28,22 +33,31 @@ export declare class GLShader {
     private _createShader;
     /**
      * Use this shader program
+     * @ignore
      */
     $use(): void;
     /**
      * Reset texture unit counter and other state
      */
     private _resetState;
+    /**
+     * Set multiple uniform values at once.
+     * @param uniforms An object mapping uniform names to their values.
+     * @ignore
+     */
     $setUniforms(uniforms: Record<string, any>): void;
     /**
      * Set a single uniform value with automatic texture unit management and proper type detection
+     * @param name The name of the uniform variable in the shader
+     * @param value The value to set for the uniform
+     * @ignore
      */
     $setUniform(name: string, value: UniformValue): void;
     private _acquireTextureUnit;
     /**
      * Get the WebGL program
      */
-    get $glProgram(): WebGLProgram;
+    get program(): WebGLProgram;
     /**
      * Dispose of WebGL resources used by this shader.
      */

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

@@ -89,15 +89,8 @@ export interface IFramebuffer {
     /**
      * 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;
+    dispose(): void;
 }

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

@@ -11,7 +11,9 @@ export declare class AnimationController {
     private _lastRenderTime;
     private _frameTimeHistory;
     private _frameTimeHistorySize;
+    private _deltaTime;
     private _frameCount;
+    private _millisStart;
     /**
      * Creates an AnimationController instance.
      * @param frameRateLimit Maximum frames per second. Defaults to 60.
@@ -68,4 +70,31 @@ export declare class AnimationController {
      * Should be called on each render to track total frames rendered.
      */
     $incrementFrame(): void;
+    /**
+     * Get the number of milliseconds since the animation started.
+     * Returns 0 if the animation has not started yet.
+     */
+    get $millis(): number;
+    /**
+     * Set the elapsed milliseconds by adjusting the start time.
+     * This allows seeking/scrubbing in animations.
+     * @param value The new elapsed time in milliseconds
+     */
+    set $millis(value: number);
+    /**
+     * Get the number of seconds since the animation started.
+     * Returns 0 if the animation has not started yet.
+     */
+    get $secs(): number;
+    /**
+     * Set the elapsed seconds by adjusting the start time.
+     * This allows seeking/scrubbing in animations.
+     * @param value The new elapsed time in seconds
+     */
+    set $secs(value: number);
+    /**
+     * Get the time in milliseconds between the current frame and the last frame.
+     * Useful for frame-rate-independent animations.
+     */
+    get $deltaTime(): number;
 }

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

@@ -80,6 +80,8 @@ export declare class TextmodeGrid {
     get offsetY(): number;
     /**
      * Restores responsive sizing so subsequent `t.resizeCanvas` calls recompute cols/rows.
+     *
+     * A grid becomes non-responsive when either `cols` or `rows` is manually set.
      */
     responsive(): void;
     /**

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

@@ -7,8 +7,8 @@ import { AnimationController } from './AnimationController';
 import { MouseManager } from './managers/MouseManager';
 import { KeyboardManager } from './managers/KeyboardManager';
 import { TouchManager } from './managers/TouchManager';
+import { TextmodePluginManager } from './managers/PluginManager';
 import type { ITextmodifier } from './interfaces';
-import type { GLShader } from '../rendering';
 import type { TextmodeOptions } from './types';
 import type { IAnimationMixin } from './mixins/interfaces/IAnimationMixin';
 import type { IRenderingMixin } from './mixins/interfaces/IRenderingMixin';
@@ -17,8 +17,8 @@ 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';
-import { TextmodeFilterManager } from './filters';
+import type { TextmodeLayer, TextmodeLayerManager } from './layers';
+import type { TextmodeFilterManager } from './filters';
 import type { FilterName, BuiltInFilterName, BuiltInFilterParams } from './filters';
 import { TextmodeConversionManager } from './conversion';
 declare const Textmodifier_base: {
@@ -40,23 +40,16 @@ export declare class Textmodifier extends Textmodifier_base implements ITextmodi
     _touchManager: TouchManager;
     _keyboardManager: KeyboardManager;
     _loading: LoadingScreenManager;
-    _textmodeConversionShader: GLShader;
-    _presentShader: GLShader;
     _layerManager: TextmodeLayerManager;
-    _activeFont?: TextmodeFont;
-    _activeGrid?: TextmodeGrid;
-    _filterManager: TextmodeFilterManager;
+    _activeLayer?: TextmodeLayer;
     _conversionManager: TextmodeConversionManager;
-    private _globalFilterQueue;
-    private _preFilterFramebuffer;
-    private _postFilterFramebuffer;
-    private _pluginManager;
+    /** @ignore */
+    _pluginManager: TextmodePluginManager;
     private _destroyRequested;
     private _isRenderingFrame;
     private _isDisposed;
     private _setupComplete;
     private _setupCallback;
-    private _drawCallback;
     private _resizedCallback;
     private _windowResizeListener;
     private _resizeObserver?;
@@ -81,17 +74,16 @@ export declare class Textmodifier extends Textmodifier_base implements ITextmodi
     private _performDestroy;
     filter<T extends BuiltInFilterName>(name: T, params?: BuiltInFilterParams[T]): void;
     filter(name: FilterName, params?: unknown): void;
+    draw(callback: () => void): void;
     loadFont(fontSource: string): Promise<TextmodeFont>;
     fontSize(size: number): void;
     inputGrid(target?: 'topmost' | TextmodeGrid): 'topmost' | TextmodeGrid | void;
     /**
      * Get the grid used for input coordinate mapping.
      * Returns the override grid/layer's grid if set, otherwise the topmost visible layer's grid.
-     * @ignore
      */
     private _getInputGrid;
     setup(callback: () => void | Promise<void>): Promise<void>;
-    draw(callback: () => void): void;
     windowResized(callback: () => void): void;
     get grid(): TextmodeGrid | undefined;
     get font(): TextmodeFont;
@@ -104,6 +96,7 @@ export declare class Textmodifier extends Textmodifier_base implements ITextmodi
     get layers(): LayerManager;
     get filters(): TextmodeFilterManager;
     get conversions(): TextmodeConversionManager;
+    get isRenderingFrame(): boolean;
 }
 export interface Textmodifier extends IRenderingMixin, IAnimationMixin, IMouseMixin, ITouchMixin, IKeyboardMixin {
 }

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

@@ -3,7 +3,6 @@ import type { TextmodeFont } from '../loadables/font';
 import type { TextmodeImage } from '../loadables/TextmodeImage';
 import type { TextmodeCanvas } from '../Canvas';
 import type { AnimationController } from '../AnimationController';
-import type { GLShader } from '../../rendering';
 import type { GLRenderer } from '../../rendering/webgl/core/Renderer';
 import type { MouseManager } from '../managers/MouseManager';
 import type { KeyboardManager } from '../managers/KeyboardManager';
@@ -15,6 +14,7 @@ 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';
+import type { TextmodeLayer } from '../layers/TextmodeLayer';
 import type { BuiltInFilterName, BuiltInFilterParams, TextmodeFilterManager, FilterName } from '../filters';
 import type { TextmodeConversionManager } from '../conversion';
 /**
@@ -38,22 +38,14 @@ export interface ITextmodifier extends IRenderingMixin, IAnimationMixin, IMouseM
     readonly _touchManager: TouchManager;
     /** Keyboard interaction manager @ignore */
     readonly _keyboardManager: KeyboardManager;
-    /** Shader used for converting pixels to textmode grid format @ignore */
-    readonly _textmodeConversionShader: GLShader;
-    /** Shader used for final presentation to the screen @ignore */
-    readonly _presentShader: GLShader;
     /** Loading screen manager for boot-time UX @ignore */
     readonly _loading: LoadingScreenManager;
     /** Conversion manager for image-to-ASCII conversion @ignore */
     readonly _conversionManager: TextmodeConversionManager;
-    /** Filter manager for applying post-processing effects @ignore */
-    readonly _filterManager: TextmodeFilterManager;
     /** Layer manager for handling multiple layers @ignore */
     readonly _layerManager: TextmodeLayerManager;
-    /** Active font based on layer, or loading screen font override @ignore */
-    _activeFont?: TextmodeFont;
-    /** Active grid based on layer currently being rendered @ignore */
-    _activeGrid?: TextmodeGrid;
+    /** Active layer currently being rendered @ignore */
+    _activeLayer?: TextmodeLayer;
     /** Main render method @ignore */
     $render(): void;
     /**

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

@@ -0,0 +1,205 @@
+/**
+ * A 3D camera/transform controller for the voxel raymarching system.
+ *
+ * This class encapsulates the 3D transformation state (rotation, translation, zoom)
+ * used when rendering layers in 3D mode. It provides a clean separation between
+ * camera/viewport concerns and layer management.
+ *
+ * The camera operates in a right-handed coordinate system where:
+ * - X axis points right
+ * - Y axis points up
+ * - Z axis points toward the viewer (out of the screen)
+ *
+ * @example
+ * ```ts
+ * const camera = new Camera3D();
+ *
+ * // Set rotation (degrees)
+ * camera.rotation(45, 30, 0);
+ *
+ * // Get current rotation
+ * const [rx, ry, rz] = camera.rotation();
+ *
+ * // Animate
+ * camera.rotateY(camera.rotation()[1] + 1);
+ *
+ * // Reset to defaults
+ * camera.reset();
+ * ```
+ */
+export declare class Camera3D {
+    private _rotation;
+    private _translation;
+    private _zoom;
+    private _rotationMatrixCache;
+    /**
+     * Create a new Camera3D with default values.
+     *
+     * @param options Initial camera configuration
+     */
+    constructor(options?: Camera3DOptions);
+    /**
+     * Set or get the rotation angles in degrees.
+     *
+     * When called with arguments, sets the rotation and returns void.
+     * When called without arguments, returns the current rotation.
+     *
+     * @param x Rotation around X axis in degrees
+     * @param y Rotation around Y axis in degrees (defaults to 0 if x provided)
+     * @param z Rotation around Z axis in degrees (defaults to 0 if x provided)
+     * @returns Current rotation as [x, y, z] tuple if no arguments provided
+     *
+     * @example
+     * ```ts
+     * camera.rotation(45, 30, 0);     // Set rotation
+     * const rot = camera.rotation();  // Get [45, 30, 0]
+     * ```
+     */
+    rotation(x?: number, y?: number, z?: number): [number, number, number] | void;
+    /**
+     * Set or get rotation around the X axis only.
+     *
+     * @param degrees Rotation in degrees, or undefined to get current value
+     * @returns Current X rotation if no argument provided
+     */
+    rotateX(degrees?: number): number | void;
+    /**
+     * Set or get rotation around the Y axis only.
+     *
+     * @param degrees Rotation in degrees, or undefined to get current value
+     * @returns Current Y rotation if no argument provided
+     */
+    rotateY(degrees?: number): number | void;
+    /**
+     * Set or get rotation around the Z axis only.
+     *
+     * @param degrees Rotation in degrees, or undefined to get current value
+     * @returns Current Z rotation if no argument provided
+     */
+    rotateZ(degrees?: number): number | void;
+    /**
+     * Set or get the translation offset in world units.
+     *
+     * @param x Translation along X axis
+     * @param y Translation along Y axis (defaults to 0 if x provided)
+     * @param z Translation along Z axis (defaults to 0 if x provided)
+     * @returns Current translation as [x, y, z] tuple if no arguments provided
+     *
+     * @example
+     * ```ts
+     * camera.translation(10, 5, 0);       // Set translation
+     * const pos = camera.translation();   // Get [10, 5, 0]
+     * ```
+     */
+    translation(x?: number, y?: number, z?: number): [number, number, number] | void;
+    /**
+     * Set or get translation along the X axis only.
+     *
+     * @param units Translation amount, or undefined to get current value
+     * @returns Current X translation if no argument provided
+     */
+    translateX(units?: number): number | void;
+    /**
+     * Set or get translation along the Y axis only.
+     *
+     * @param units Translation amount, or undefined to get current value
+     * @returns Current Y translation if no argument provided
+     */
+    translateY(units?: number): number | void;
+    /**
+     * Set or get translation along the Z axis only.
+     *
+     * @param units Translation amount, or undefined to get current value
+     * @returns Current Z translation if no argument provided
+     */
+    translateZ(units?: number): number | void;
+    /**
+     * Set or get the zoom level.
+     *
+     * Values greater than 1 zoom in, values less than 1 zoom out.
+     * The minimum zoom level is 0.001 to prevent division by zero.
+     *
+     * @param factor Zoom factor (1 = no zoom)
+     * @returns Current zoom if no argument provided
+     *
+     * @example
+     * ```ts
+     * camera.zoom(2);              // Zoom in 2x
+     * const z = camera.zoom();     // Get 2
+     * camera.zoom(0.5);            // Zoom out 50%
+     * ```
+     */
+    zoom(factor?: number): number | void;
+    /**
+     * Reset the camera to default values.
+     *
+     * - Rotation: [0, 0, 0]
+     * - Translation: [0, 0, 0]
+     * - Zoom: 1
+     */
+    reset(): void;
+    /**
+     * Copy values from another Camera3D instance.
+     *
+     * @param other The camera to copy from
+     */
+    copyFrom(other: Camera3D): void;
+    /**
+     * Create a clone of this camera.
+     *
+     * @returns A new Camera3D instance with the same values
+     */
+    clone(): Camera3D;
+    /**
+     * Get the rotation matrix as a Float32Array for GPU upload.
+     *
+     * The matrix is computed from the current Euler angles and transposed
+     * (inverted) for use in the shader. The result is cached and only
+     * recomputed when rotation values change.
+     *
+     * @returns Transposed 3x3 rotation matrix as Float32Array
+     */
+    getRotationMatrix(): Float32Array;
+    /**
+     * Get all transform parameters in a format ready for shader uniforms.
+     *
+     * @returns Object containing all transform data for GPU upload
+     */
+    getShaderUniforms(): Camera3DShaderUniforms;
+    /**
+     * Invalidate the cached rotation matrix.
+     * Called whenever rotation values change.
+     */
+    private _invalidateRotationCache;
+}
+/**
+ * Options for creating a new Camera3D instance.
+ */
+export interface Camera3DOptions {
+    /**
+     * Initial rotation in degrees around X, Y, Z axes.
+     * @default [0, 0, 0]
+     */
+    rotation?: [number, number, number];
+    /**
+     * Initial translation offset in world units.
+     * @default [0, 0, 0]
+     */
+    translation?: [number, number, number];
+    /**
+     * Initial zoom factor. Values > 1 zoom in, < 1 zoom out.
+     * @default 1
+     */
+    zoom?: number;
+}
+/**
+ * Shader uniforms generated by Camera3D for GPU upload.
+ */
+export interface Camera3DShaderUniforms {
+    /** Transposed 3x3 rotation matrix */
+    rotation: Float32Array;
+    /** Translation offset [x, y, z] */
+    translation: [number, number, number];
+    /** Zoom factor */
+    zoom: number;
+}

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

@@ -0,0 +1,152 @@
+import type { GLRenderer, GLFramebuffer } from '../../rendering';
+import type { TextmodeLayer } from './TextmodeLayer';
+import type { TextmodeFont } from '../loadables/font';
+import type { TextmodeGrid } from '../Grid';
+import type { Camera3D } from './Camera3D';
+/**
+ * 3D rendering options for the voxel raymarching system.
+ */
+export interface Layer3DOptions {
+    /**
+     * Camera containing rotation, translation, and zoom.
+     * If provided, rotation/translation/zoom properties below are ignored.
+     */
+    camera?: Camera3D;
+    /**
+     * Index of a specific layer to render in isolation.
+     * Set to -1 to render all layers.
+     * @default -1
+     */
+    isolatedLayer?: number;
+    /**
+     * Custom normal vectors for each voxel face (for lighting effects).
+     */
+    normals?: {
+        right?: [number, number, number];
+        left?: [number, number, number];
+        top?: [number, number, number];
+        bottom?: [number, number, number];
+        front?: [number, number, number];
+        back?: [number, number, number];
+    };
+}
+/**
+ * Parameters for the 3D composite operation.
+ */
+export interface Composite3DParams {
+    /** The base layer's draw framebuffer. */
+    baseDrawFramebuffer: GLFramebuffer;
+    /** 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. */
+    baseLayer: TextmodeLayer;
+    /** The array of user layers to stack. */
+    layers: readonly TextmodeLayer[];
+    /** The font used for character texture lookup (from base layer). */
+    font: TextmodeFont;
+    /** The grid with the largest dimensions (cols × rows) to use as reference. */
+    grid: TextmodeGrid;
+    /** Canvas width in pixels. */
+    canvasWidth: number;
+    /** Canvas height in pixels. */
+    canvasHeight: number;
+    /** 3D rendering options. */
+    options3D?: Layer3DOptions;
+}
+/**
+ * Handles the compositing of multiple layers using 3D voxel raymarching.
+ *
+ * This class is responsible for:
+ * - Combining all layer draw framebuffers into a single stacked atlas texture
+ * - Rendering the stacked layers as a 3D voxel grid using raymarching
+ * - Supporting rotation, zoom, and other 3D transformations
+ *
+ * @internal
+ *
+ * @remarks
+ * The compositor creates a stacked texture atlas where each layer's draw data
+ * is placed vertically in the texture. The 3D shader interprets this as a
+ * voxel grid with depth equal to the number of layers.
+ *
+ * Atlas layout:
+ * - Width: grid.cols
+ * - Height: grid.rows * (1 + numUserLayers)
+ * - Layer 0 (z=0, front): base layer at top
+ * - Layer N (z=N): user layers stacked below
+ */
+export declare class Layer3DCompositor {
+    private readonly _renderer;
+    private readonly _shaderGBuffer;
+    private readonly _shaderShade;
+    private _stackedAsciiBuffer;
+    private _stackedPrimaryBuffer;
+    private _stackedSecondaryBuffer;
+    private _gBuffer;
+    private _currentLayerCount;
+    private _canvasWidth;
+    private _canvasHeight;
+    private _maxCols;
+    private _maxRows;
+    /**
+     * Create a new Layer3DCompositor.
+     * @param renderer The WebGL renderer instance.
+     */
+    constructor(renderer: GLRenderer);
+    /**
+     * Initialize the compositor's framebuffers.
+     * @param maxCols Maximum columns across all layers.
+     * @param maxRows Maximum rows across all layers.
+     * @param totalLayers Total number of layers (1 base + N user layers).
+     * @ignore
+     */
+    $initialize(maxCols: number, maxRows: number, totalLayers?: number): void;
+    /**
+     * Resize the stacked atlas buffers to accommodate new dimensions.
+     * @param maxCols Maximum columns across all layers.
+     * @param maxRows Maximum rows across all layers.
+     * @param totalLayers Total number of layers.
+     * @ignore
+     */
+    $resize(maxCols: number, maxRows: number, totalLayers?: number): void;
+    /**
+     * Composite all layers into a 3D voxel render.
+     * @param params The composite parameters.
+     */
+    $composite(params: Composite3DParams): void;
+    /**
+     * Build the stacked atlas by copying each layer's draw data.
+     * Each layer is centered within the max dimensions.
+     */
+    private _buildStackedAtlas;
+    /**
+     * Copy a source texture into a region of the target atlas framebuffer.
+     * Uses blitFramebuffer for efficient GPU-side copies.
+     */
+    private _copyTextureToAtlas;
+    /**
+     * Render the 3D voxel scene using two-pass deferred rendering.
+     * Pass 1: G-Buffer generation (raymarching, outputs voxel coords + surface data)
+     * Pass 2: Shading (reads G-buffer, samples textures, applies character rendering)
+     */
+    private _render3D;
+    /**
+     * Ensure the G-buffer exists and is correctly sized.
+     * Uses RGBA8 textures with normalized encoding for maximum compatibility.
+     */
+    private _ensureGBuffer;
+    /**
+     * Dispose of all compositor resources.
+     * @ignore
+     */
+    $dispose(): void;
+    /**
+     * Get the current maximum columns in the stacked atlas.
+     */
+    get $maxCols(): number;
+    /**
+     * Get the current maximum rows per layer in the stacked atlas.
+     */
+    get $maxRows(): number;
+}