vtf-js/dist/core/image.d.ts

A javascript IO library for the Valve Texture Format.

import { VFormats } from './enums.js';
import { VFilter } from './resize.js';
/** An array of decoded RGBA pixels. */
export type VPixelArray = Uint8Array | Uint16Array | Uint32Array | Float32Array | Float64Array | Float16Array;
/** A generic constructor for VPixelArray types. */
export interface VPixelArrayConstructor<T extends VPixelArray = VPixelArray> {
    new (length?: number): T;
    new (array: ArrayLike<number> | Iterable<number>): T;
    new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): T;
    readonly BYTES_PER_ELEMENT: number;
}
/** An object that defines an image encoder/decoder for a given format. */
export interface VCodec {
    length(width: number, height: number): number;
    encode(data: VImageData): VEncodedImageData;
    decode(data: VEncodedImageData): VImageData;
}
/** Does the current environment support sec-float16array? */
export declare const HAS_FLOAT16: boolean;
/** All currently-registered image codecs. */
export declare const VCodecs: {
    [key in VFormats]?: VCodec;
};
/** Register an image encoder/decoder for the specified format. */
export declare function registerCodec(format: VFormats, codec: VCodec): void;
export declare function getCodec(format: VFormats): VCodec;
export declare function getCodec(format: VFormats, strict: boolean): VCodec | undefined;
/** Decoded RGBA image data. */
export declare class VImageData<D extends VPixelArray = VPixelArray> {
    readonly isEncoded: false;
    width: number;
    height: number;
    data: D;
    constructor(data: D, width: number, height: number);
    /**
     * Returns a remapped copy of this image with the specified data format, normalizing floating-point formats to 0-1.
     * If this image is already of the specified format, this method returns self.
     * If `do_clamp` is set to true, the data will be clamped between 0 and the array's maximum value.
     * @example const converted: VImageData<Float32Array> = image.convert(Float32Array);
     */
    convert<T extends VPixelArray = VPixelArray>(type: VPixelArrayConstructor<T>, do_clamp?: boolean): VImageData<T>;
    /** Encodes this image into the specified format and validates the length of the resulting data. */
    encode(format: VFormats): VEncodedImageData;
    /** Dummy function - returns self. */
    decode(): VImageData;
    /**
     * Returns a resampled copy of this image with the given dimensions.
     * ### If you are batch-resizing images, create and reuse a VImageScaler for better performance!
     */
    resize(width: number, height: number, options?: Partial<{
        filter: VFilter;
    }>): VImageData<D>;
    /** Retrieves the constructor of this image's data with a type-safe wrapper. */
    getDataConstructor(): VPixelArrayConstructor<D>;
}
/** Format-encoded image data. */
export declare class VEncodedImageData {
    readonly isEncoded: true;
    width: number;
    height: number;
    format: VFormats;
    data: Uint8Array;
    constructor(data: Uint8Array, width: number, height: number, format: VFormats);
    /** Decodes this image into RGBA pixel data. */
    decode(): VImageData;
    /** If necessary, decodes and encodes this image into the desired format. Otherwise, returns self. */
    encode(format: VFormats): VEncodedImageData;
}