textmode.js 0.4.1-beta.1 → 0.6.0-beta.2

package/dist/types/textmode/loadables/TextmodeVideo.d.ts

@@ -0,0 +1,265 @@
+import type { GLRenderer } from '../../rendering/webgl/core/Renderer';
+import type { Material } from '../../rendering/webgl/materials/Material';
+import { TextmodeSource } from './TextmodeSource';
+type TextmodeVideoPreloadStrategy = 'captureStream' | 'seeking';
+export interface TextmodeVideoPreloadProgress {
+    percent: number;
+    loadedFrames: number;
+    totalFrames: number;
+    strategy: TextmodeVideoPreloadStrategy;
+}
+export interface TextmodeVideoPreloadComplete {
+    totalFrames: number;
+    strategy: TextmodeVideoPreloadStrategy;
+}
+/**
+ * Options for preloading video frames in {@link TextmodeVideo}.
+ *
+ * When providing this options object as a second argument to {@link Textmodifier.loadVideo},
+ * you can choose to preload all video frames at a specified frame rate before using the video.
+ *
+ * When preloading, the video will not play live asynchronously. Instead, all frames will be captured
+ * upfront, allowing for frame-accurate seeking and rendering.
+ *
+ * This is especially useful for scenarios where precise frame control is needed,
+ * like capturing GIFs/videos from textmode.js canvas using the `textmode.export.js` add-on library without
+ * missing frames due to asynchronous video playback.
+ *
+ * Preloading takes time proportional to the video length and frame rate, which introduces significant delays
+ * before the sketch can start rendering. Therefore, it is recommended to use this feature only when intending
+ * to capture or export frames, rather than for real-time playback.
+ */
+export interface TextmodeVideoOptions {
+    /** Frame rate to use when preloading video frames. If not specified, video will not be preloaded. */
+    frameRate?: number;
+    /** Callback invoked periodically during preloading to report progress. */
+    onProgress?: (progress: TextmodeVideoPreloadProgress) => void;
+    /** Callback invoked once preloading is complete. */
+    onComplete?: (summary: TextmodeVideoPreloadComplete) => void;
+    /** Callback invoked if an error occurs during preloading. */
+    onError?: (error: Error) => void;
+}
+/**
+ * Represents a video element for textmode rendering via {@link Textmodifier.loadVideo}.
+ *
+ * It can be drawn to the canvas via {@link Textmodifier.image}.
+ *
+ * A video uploaded currently runs through an adjustable brightness-converter that converts
+ * the video frames into a textmode representation using characters.
+ * Those adjustable options are available via chainable methods on this class.
+ * ```javascript
+ * const t = textmode.create({
+ *     width: 800,
+ *     height: 600,
+ * });
+ *
+ * let video;
+ *
+ * t.setup(async () => {
+ *     video = await t.loadVideo('https://interactive-examples.mdn.mozilla.net/media/cc0-videos/flower.mp4');
+ *     // Start playback and enable looping so the video keeps playing
+ *     video.play();
+ *     video.loop();
+ *
+ *     video.characters(" .:-=+*#%@");
+ *     // ... other adjustments like video.flipX(boolean), video.cellColorMode('sampled' | 'fixed'), etc.
+ *     // (can also be chained or updated during runtime)
+ * });
+ *
+ * t.draw(() => {
+ *     t.background(0);
+ *
+ *     if (video) {
+ *         // Draw the loaded video
+ *         t.image(video);
+ *     }
+ * });
+ * ```
+ */
+export declare class TextmodeVideo extends TextmodeSource {
+    private _videoElement;
+    private _isPreloaded;
+    private _preloadedFrames;
+    private _frameRate;
+    private _totalFrames;
+    private _currentFrameIndex;
+    private _lastProgressBucket;
+    /**
+     * Create a new TextmodeVideo instance.
+     * @param gl WebGL2 rendering context
+     * @param renderer GLRenderer instance
+     * @param texture WebGL texture for video frames
+     * @param videoElement The HTML video element
+     * @param originalWidth Original video width in pixels
+     * @param originalHeight Original video height in pixels
+     * @param gridCols Number of columns in the grid (for auto-sizing)
+     * @param gridRows Number of rows in the grid (for auto-sizing)
+     *
+     * @ignore
+     */
+    constructor(gl: WebGL2RenderingContext, renderer: GLRenderer, texture: WebGLTexture, videoElement: HTMLVideoElement, originalWidth: number, originalHeight: number, gridCols: number, gridRows: number);
+    /**
+     * Dispose of GPU resources and cleanup video element.
+     * @ignore
+     */
+    $dispose(): void;
+    /**
+     * Update the texture with the current video frame if needed.
+     * For preloaded videos, this returns the appropriate frame texture.
+     * For live videos, this updates the texture with current video data.
+     * @ignore
+     */
+    $updateTexture(): void;
+    /**
+     * Get the active texture for the current frame.
+     * For preloaded videos, returns the texture at the current frame index.
+     * For live videos, returns the live texture.
+     * @ignore
+     */
+    protected $getActiveTexture(): WebGLTexture;
+    /**
+     * Get or create the material for rendering this video.
+     * Always updates the material to ensure the latest video frame is used.
+     * @ignore
+     */
+    $getMaterial(): Material;
+    protected $beforeMaterialUpdate(): void;
+    /**
+     * Preload all frames of the video at the specified frame rate.
+     * Chooses the most optimal strategy based on browser capabilities.
+     * @param frameRate Frame rate to use for capturing frames
+     * @ignore
+     */
+    private _preloadFrames;
+    private _initializePreloadState;
+    private _finalizePreloadSuccess;
+    private _captureSourceToTexture;
+    private _reportPreloadProgress;
+    private _tryPreloadWithTrackProcessor;
+    private _preloadWithLegacySeeking;
+    private _waitForSeek;
+    /**
+     * For preloaded videos, set or get the current frame index.
+     * When called without arguments, returns this video instance for use with t.image().
+     * When called with an index, sets the frame and returns this instance.
+     *
+     * The frame index automatically wraps using modulo, so you can pass t.frameCount directly
+     * and it will loop through the video frames seamlessly.
+     *
+     * For non-preloaded videos, this method does nothing and returns the instance.
+     *
+     * @param index Optional frame index to set (0-based, automatically wraps)
+     * @returns This instance for chaining.
+     *
+     * @example
+     * ```javascript
+     * // Draw specific frame
+     * t.image(video.frame(0), x, y);
+     *
+     * // Draw frame based on frameCount (automatically wraps)
+     * t.image(video.frame(t.frameCount), x, y);
+     *
+     * video.frame(t.frameCount);
+     * t.image(video, x, y);
+     * ```
+     */
+    frame(index?: number): this;
+    /**
+     * Create a TextmodeVideo instance from a video source (URL or HTMLVideoElement).
+     * @param renderer GLRenderer instance
+     * @param source Video URL string or HTMLVideoElement
+     * @param gridCols Number of columns in the grid
+     * @param gridRows Number of rows in the grid
+     * @param glyphResolver Function to resolve character strings to glyph colors
+     * @param options Optional preload configuration (frameRate, onProgress, onComplete, onError).
+     * @returns Promise resolving to TextmodeVideo instance
+     * @ignore
+     */
+    static $fromSource(renderer: GLRenderer, source: string | HTMLVideoElement, gridCols: number, gridRows: number, glyphResolver: (s: string) => ([number, number, number])[], options?: TextmodeVideoOptions): Promise<TextmodeVideo>;
+    /**
+     * Play the video.
+     * @returns Promise that resolves when playback starts
+     */
+    play(): Promise<void>;
+    /**
+     * Pause the video.
+     */
+    pause(): void;
+    /**
+     * Stop the video and reset to beginning.
+     */
+    stop(): void;
+    /**
+     * Set the playback speed.
+     * @param rate Playback rate (1.0 = normal speed)
+     */
+    speed(rate: number): this;
+    /**
+     * Set whether the video should loop.
+     * @param shouldLoop Whether to loop (defaults to true)
+     */
+    loop(shouldLoop?: boolean): this;
+    /**
+     * Set the current time position in the video.
+     * @param seconds Time in seconds
+     */
+    time(seconds: number): this;
+    /**
+     * Set the volume.
+     * @param level Volume level (0.0-1.0)
+     */
+    volume(level: number): this;
+    /**
+     * WebGL texture handle containing the current video frame.
+     */
+    get texture(): WebGLTexture;
+    /**
+     * Ideal width to draw the video at (in grid cells), calculated to fit the grid while preserving aspect ratio.
+     */
+    get width(): number;
+    /**
+     * Ideal height to draw the video at (in grid cells), calculated to fit the grid while preserving aspect ratio.
+     */
+    get height(): number;
+    /**
+     * Original pixel width of the video.
+     */
+    get originalWidth(): number;
+    /**
+     * Original pixel height of the video.
+     */
+    get originalHeight(): number;
+    /**
+     * The underlying HTML video element.
+     */
+    get videoElement(): HTMLVideoElement;
+    /**
+     * Current playback time in seconds.
+     */
+    get currentTime(): number;
+    /**
+     * Total duration of the video in seconds.
+     */
+    get duration(): number;
+    /**
+     * Whether the video is currently playing.
+     */
+    get isPlaying(): boolean;
+    /**
+     * Whether this video has been preloaded with frames.
+     */
+    get isPreloaded(): boolean;
+    /**
+     * Total number of preloaded frames. Returns 0 for non-preloaded videos.
+     */
+    get totalFrames(): number;
+    /**
+     * The frame rate used for preloading. Returns null for non-preloaded videos.
+     */
+    get preloadFrameRate(): number | null;
+    /**
+     * Current frame index for preloaded videos. Returns 0 for non-preloaded videos.
+     */
+    get currentFrameIndex(): number;
+}
+export {};

package/dist/types/textmode/{font → loadables/font}/CharacterColorMapper.d.ts

@@ -17,7 +17,7 @@ export declare class CharacterColorMapper {
     /**
      * Generates a unique RGB color for a character based on its index.
      * @param index The index of the character
-     * @returns RGB color as a tuple [r, g, b] with values from 0-1 for shader use
+     * @returns RGB color as a tuple [r, g, 0] with values from 0-1 for shader use
      */
     private _generateCharacterColor;
     /**

package/dist/types/textmode/{font → loadables/font}/CharacterExtractor.d.ts

@@ -10,12 +10,6 @@ export declare class CharacterExtraction {
      * @returns Array of unique character strings
      */
     $extractCharacters(font: TyprFont): string[];
-    /**
-     * Filters out problematic characters that might cause rendering issues.
-     * @param characters Array of character strings to filter
-     * @returns Filtered array of character strings
-     */
-    $filterProblematicCharacters(characters: string[]): string[];
     /**
      * Extracts characters from a Format 4 cmap table (Basic Multilingual Plane).
      */
@@ -28,8 +22,4 @@ export declare class CharacterExtraction {
      * Calculates the glyph index for a character in a Format 4 cmap table.
      */
     private _calculateGlyphIndexFormat4;
-    /**
-     * Checks if a character is valid for rendering.
-     */
-    private _isValidCharacter;
 }

package/dist/types/textmode/{font → loadables/font}/TextmodeFont.d.ts

@@ -1,12 +1,15 @@
-import type { GLRenderer } from '../../rendering/webgl/Renderer.ts';
-import type { GLFramebuffer } from '../../rendering/webgl/Framebuffer.ts';
+import type { GLRenderer } from '../../../rendering/webgl/core/Renderer.ts';
+import type { GLFramebuffer } from '../../../rendering/webgl/core/Framebuffer.ts';
 import type { TextmodeCharacter } from './types.ts';
 import type { TyprFont, GlyphData } from './typr/types.ts';
 /**
- * Manages the font used for rendering characters.
+ * Manages the font used for rendering characters via {@link Textmodifier.loadFont}.
  *
  * This class coordinates font loading, character extraction, texture atlas creation,
  * and provides character information.
+ *
+ * The font used by your {@link Textmodifier} instance is accessible via
+ * the {@link Textmodifier.font} property.
  */
 export declare class TextmodeFont {
     private _font;
@@ -75,9 +78,12 @@ export declare class TextmodeFont {
     $getCharacterColors(characters: string): [number, number, number][];
     /**
      * Lazily retrieves glyph data for the given Unicode code point.
+     *
      * Glyph data is cached after the first access to avoid repeated Typr parsing.
+     *
      * @param codePoint Unicode code point
      * @returns Parsed glyph data or null if unavailable
+     * @ignore
      */
     getGlyphData(codePoint: number): GlyphData | null;
     private _getGlyphIndex;

package/dist/types/textmode/{font → loadables/font}/TextureAtlas.d.ts

@@ -1,6 +1,6 @@
 import type { TextmodeCharacter, GlyphDimensions } from './types.ts';
-import type { GLRenderer } from '../../rendering/webgl/Renderer.ts';
-import type { GLFramebuffer } from '../../rendering/webgl/Framebuffer.ts';
+import type { GLRenderer } from '../../../rendering/webgl/core/Renderer.ts';
+import type { GLFramebuffer } from '../../../rendering/webgl/core/Framebuffer.ts';
 import type { TyprFont } from './typr/types.ts';
 /**
  * Handles creation of texture atlases for font rendering.
@@ -23,10 +23,10 @@ export declare class TextureAtlasCreation {
      * @param characters Array of TextmodeCharacter objects
      * @param maxGlyphDimensions Maximum dimensions of glyphs
      * @param fontSize Font size for rendering
-     * @param fontDataOrFamilyName Either Typr.js font data object for path rendering, or font family name string for fillText rendering
+     * @param font Either Typr.js font data object for path rendering, or font family name string for fillText rendering
      * @returns Object containing framebuffer, columns, and rows
      */
-    createTextureAtlas(characters: TextmodeCharacter[], maxGlyphDimensions: GlyphDimensions, fontSize: number, fontDataOrFamilyName: TyprFont | string): {
+    $createTextureAtlas(characters: TextmodeCharacter[], maxGlyphDimensions: GlyphDimensions, fontSize: number, font: TyprFont): {
         framebuffer: GLFramebuffer;
         columns: number;
         rows: number;
@@ -53,13 +53,6 @@ export declare class TextureAtlasCreation {
      * @returns Parsed glyph data or null if not found
      */
     private _getGlyphData;
-    /**
-     * Gets the advance width for a glyph
-     * @param fontData The Typr.js font data
-     * @param glyphIndex The glyph index
-     * @returns The advance width in font units
-     */
-    private _getGlyphAdvanceWidth;
     /**
      * Renders a glyph to the canvas using direct path rendering from glyph outline data.
      * @param glyphData Glyph data from Typr.js

package/dist/types/textmode/{font → loadables/font}/typr/types.d.ts

@@ -18,12 +18,6 @@ export interface TyprBinary {
     readUint: (buff: Uint8Array, p: number) => number;
     /** Read ASCII string */
     readASCII: (buff: Uint8Array, p: number, l: number) => string;
-    /** Write unsigned 16-bit integer (big-endian) */
-    writeUshort: (buff: Uint8Array, p: number, n: number) => void;
-    /** Write unsigned 32-bit integer (big-endian) */
-    writeUint: (buff: Uint8Array, p: number, n: number) => void;
-    /** Write ASCII string */
-    writeASCII: (buff: Uint8Array, p: number, s: string) => void;
     /** Shared typed array buffers for efficient reading */
     t: {
         uint8: Uint8Array;

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

@@ -0,0 +1,5 @@
+export { TextmodeImage } from './TextmodeImage';
+export { TextmodeVideo } from './TextmodeVideo';
+export { TextmodeFont } from './font/TextmodeFont';
+export type { TextmodeCharacter } from './font/types';
+export type { TextmodeVideoOptions } from './TextmodeVideo';

package/dist/types/textmode/loading/LoadingPhaseTracker.d.ts

@@ -0,0 +1,20 @@
+import type { LoadingPhaseSnapshot } from './types';
+/**
+ * Tracks loading phases and their progress.
+ * @ignore
+ */
+export declare class LoadingPhaseTracker {
+    private _phases;
+    private _phaseOrder;
+    private _totalWeight;
+    private _lastReportedProgress;
+    private _onProgressChange?;
+    get $totalWeight(): number;
+    get $progress(): number;
+    $setProgressChangeCallback(callback: (progress: number) => void): void;
+    $createPhase(label: string, weight?: number): string;
+    $updatePhaseProgress(id: string, progress: number): void;
+    $completePhase(id: string): void;
+    $failPhase(id: string): void;
+    $snapshotPhases(): LoadingPhaseSnapshot[];
+}

package/dist/types/textmode/loading/LoadingScreenManager.d.ts

@@ -0,0 +1,211 @@
+import type { Textmodifier } from '../Textmodifier';
+import type { RGBA } from '../utils/cssColor';
+import type { LoadingPhaseHandle, LoadingScreenOptions } from './types';
+/**
+ * Manages the loading screen display and state. Can be accessed via {@link Textmodifier.loading}.
+ */
+export declare class LoadingScreenManager {
+    private readonly _textmodifier;
+    private readonly _options;
+    private readonly _stateMachine;
+    private readonly _phaseTracker;
+    private readonly _transition;
+    private readonly _loadingAnimationController;
+    private _loadingFont;
+    private _loadingGrid;
+    private _loadingDrawFramebuffer;
+    private _loadingFramebuffer;
+    private _renderer;
+    private _palette;
+    private _theme;
+    private _startTime;
+    private _loadingFrameCount;
+    private _isRendering;
+    private _isInitialized;
+    /**
+     * Initializes a new LoadingScreenManager.
+     * @param textmodifier Textmodifier instance to render on.
+     * @param opts Loading screen options.
+     * @param canvasBackground Background color of the canvas.
+     * @ignore
+     */
+    constructor(textmodifier: Textmodifier, opts: LoadingScreenOptions | undefined, canvasBackground: RGBA | null);
+    /**
+     * Initialize loading screen resources (font, grid, framebuffers).
+     * Must be called after the renderer is ready.
+     * @param fontSource Optional font source for the loading screen
+     * @ignore
+     */
+    $initialize(fontSource?: string): Promise<void>;
+    /**
+     * Indicates whether the loading screen should render this frame.
+     * @ignore
+     */
+    get $shouldRender(): boolean;
+    /**
+     * Start the independent loading screen animation loop.
+     * This runs independently of the user's animation loop.
+     * @ignore
+     */
+    $start(): void;
+    /**
+     * Stop the independent loading screen animation loop.
+     * @ignore
+     */
+    $stop(): void;
+    /**
+     * Handle canvas resize during loading.
+     * Updates grid and framebuffers to match new canvas dimensions.
+     * @ignore
+     */
+    $resize(): void;
+    /**
+     * Dispose of the loading screen manager and clean up resources.
+     * @ignore
+     */
+    $dispose(): void;
+    /**
+     * Get the current overall loading progress (0-1).
+    *
+    * @example
+    * ```ts
+    * const t = textmode.create({
+    *   width: 800,
+    *   height: 600,
+    *   loadingScreen: { message: 'starting...' }
+    * });
+    *
+    * // In setup we can start a phase and read the overall progress
+    * t.setup(async () => {
+    *   const phase = t.loading.beginPhase('assets', 1);
+    *   phase.report(0.5); // half complete for the phase
+    *
+    *   // The `progress` accessor reports the global progress across all phases
+    *   console.log(`Loading: ${Math.round(t.loading.progress * 100)}%`);
+    * });
+    * ```
+     */
+    get progress(): number;
+    /**
+     * Get or set the loading screen message.
+     * @param next Optional new message to set.
+     * @returns The current loading screen message.
+    *
+    * @example
+    * ```ts
+    * const t = textmode.create({
+    *   width: 800,
+    *   height: 600,
+    *   loadingScreen: { message: 'loading...' }
+    * });
+    *
+    * t.setup(() => {
+    *   // Update the message visible on the loading screen
+    *   t.loading.message('preloading video...');
+    *
+    *   // Read the current message (useful in custom renderers)
+    *   const msg = t.loading.message();
+    *   console.log(msg);
+    * });
+    * ```
+     */
+    message(next?: string): string | undefined;
+    /**
+     * Begin a new loading phase.
+     *
+     * With the returned {@link LoadingPhaseHandle} you can report progress,
+     * track asynchronous work, and manage the phase lifecycle.
+     *
+     * @param label Label for the loading phase.
+     * @param weight Weight of the loading phase (default is 1).
+     * @returns A handle to the created loading phase.
+    *
+    * @example
+    * ```ts
+    * const t = textmode.create({
+    *   width: 800,
+    *   height: 600,
+    *   loadingScreen: { message: 'preparing...' }
+    * });
+    *
+    * // In setup we start a phase and then track work in that phase
+    * t.setup(async () => {
+    *   const phase = t.loading.beginPhase('video preload', 2);
+    *
+    *   // Example: report progress from a loader callback
+    *   await phase.track(async () => {
+    *     // Simulated work
+    *     for (let i = 0; i <= 10; i++) {
+    *       phase.report(i / 10);
+    *       await new Promise((r) => setTimeout(r, 30));
+    *     }
+    *   });
+    * });
+    * ```
+     */
+    addPhase(label: string, weight?: number): LoadingPhaseHandle;
+    /**
+     * Finish the loading process.
+     * @ignore
+     */
+    $finish(): void;
+    private _notifyComplete;
+    private _onCompleteCallback?;
+    /**
+     * Set a callback to be invoked when loading is complete.
+     * @param callback The callback function to invoke.
+     * @ignore
+     */
+    $setOnComplete(callback: () => void): void;
+    /**
+     * Report an error that occurred during loading.
+     * @param error The error message or `Error` object.
+    *
+    * @example
+    * ```ts
+    * const t = textmode.create({
+    *   width: 800,
+    *   height: 600,
+    *   loadingScreen: { message: 'starting...' }
+    * });
+    *
+    * t.setup(async () => {
+    *   const phase = t.loading.beginPhase('remote fetch', 1);
+    *   try {
+    *     await phase.track(async () => {
+    *       // Failing call
+    *       throw new Error('server down');
+    *     });
+    *   } catch (err) {
+    *     // This will put the loading manager into an error state
+    *     t.loading.error(err instanceof Error ? err : String(err));
+    *   }
+    * });
+    * ```
+     */
+    error(error: Error | string): void;
+    /**
+     * Independent render loop for the loading screen.
+     * This runs on its own animation controller, separate from user animation.
+     * @ignore
+     */
+    private _renderLoadingFrame;
+    /**
+     * Performs the actual rendering of the loading screen.
+     * @ignore
+     */
+    private _performRender;
+    /**
+     * Update the background color used in the loading screen theme.
+     * @param color The new background color.
+     * @ignore
+     */
+    $updateBackgroundColor(color: RGBA | null): void;
+    private _resolveRenderer;
+    /**
+     * Renders the library branding tag at the bottom left of the loading screen.
+     * Uses obfuscation techniques to make removal more difficult.
+     * @ignore
+     */
+    private _renderBrandingTag;
+}

package/dist/types/textmode/loading/LoadingScreenState.d.ts

@@ -0,0 +1,22 @@
+import type { LoadingScreenState } from './types';
+/**
+ * Manages the state of the loading screen.
+ * @ignore
+ */
+export declare class LoadingScreenStateMachine {
+    private _state;
+    private _errorMessage;
+    private _errorDetails;
+    constructor(initialState?: LoadingScreenState);
+    get $state(): LoadingScreenState;
+    get $isEnabled(): boolean;
+    get $shouldRender(): boolean;
+    get $errorMessage(): string;
+    get $errorDetails(): string;
+    $activate(): void;
+    $finish(): void;
+    $startTransition(): void;
+    $completeTransition(): void;
+    $setError(error: Error | string): void;
+    $disable(): void;
+}

package/dist/types/textmode/loading/LoadingScreenTheme.d.ts

@@ -0,0 +1,26 @@
+import type { LoadingScreenTheme, LoadingScreenOptions } from './types';
+import type { Textmodifier } from '../Textmodifier';
+import type { TextmodeColor } from '../TextmodeColor';
+/**
+ * Resolves the loading screen theme based on options and background color.
+ * @param options Loading screen options.
+ * @param background Background color as RGBA or null.
+ * @returns The resolved loading screen theme.
+ * @ignore
+ */
+export declare function $resolveTheme(options: LoadingScreenOptions, background: [number, number, number, number] | null): LoadingScreenTheme;
+/**
+ * Resolves the default color palette based on the theme mode.
+ * @param theme The loading screen theme.
+ * @returns An array of color strings representing the default palette.
+ * @ignore
+ */
+export declare function $resolveDefaultPalette(theme: LoadingScreenTheme): string[];
+/**
+ * Resolves an array of color inputs into TextmodeColor instances.
+ * @param inputs Input colors as numbers, strings, or TextmodeColor instances.
+ * @param textmodifier The Textmodifier instance used to create TextmodeColor objects.
+ * @returns An array of TextmodeColor instances.
+ * @ignore
+ */
+export declare function $resolveColorInputs(inputs: (number | string | TextmodeColor)[], textmodifier: Textmodifier): TextmodeColor[];

package/dist/types/textmode/loading/LoadingScreenTransition.d.ts

@@ -0,0 +1,17 @@
+export type TransitionType = 'none' | 'fade';
+/**
+ * Handles loading screen transitions.
+ * @ignore
+ */
+export declare class LoadingScreenTransition {
+    private _transitionStartTime;
+    private _transitionOpacity;
+    private _transitionType;
+    private _transitionDuration;
+    constructor(transitionType: TransitionType, transitionDuration: number);
+    get $opacity(): number;
+    get $isTransitioning(): boolean;
+    $start(): void;
+    $update(): boolean;
+    $reset(): void;
+}