@galacean/effects-core 1.1.2 → 1.1.4

package/dist/shape/texture-shape.d.ts

@@ -0,0 +1,11 @@
+import type { Shape, ShapeGeneratorOptions, ShapeParticle } from '.';
+export declare class TextureShape implements Shape {
+    width: number;
+    height: number;
+    block: number[];
+    anchors: Float32Array;
+    arcMode: number;
+    random: number;
+    constructor(arg: any);
+    generate(opt: ShapeGeneratorOptions): ShapeParticle;
+}

package/dist/template-image/index.d.ts

@@ -0,0 +1,67 @@
+import type { TemplateContentV1, TemplateContentV2 } from '@galacean/effects-specification';
+export * from './qcanvas-viewer';
+export * from './qtext';
+export * from './template-v1';
+export declare const DEFAULT_FONTS: string[];
+export interface TextLayout {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface TemplateOptions {
+    templateScale?: number;
+    canvas?: HTMLCanvasElement;
+    textLayouts?: TextLayout[];
+    debug?: boolean;
+    borderColor?: string;
+    borderWidth?: number;
+    flipY?: boolean;
+    scaleX?: number;
+    scaleY?: number;
+    toData?: boolean;
+}
+declare class CanvasPool {
+    readonly elements: HTMLCanvasElement[];
+    constructor();
+    dispose(): void;
+    getCanvas(): HTMLCanvasElement;
+    saveCanvas(cvs: HTMLCanvasElement): void;
+}
+export declare const canvasPool: CanvasPool;
+export declare function getDefaultTemplateCanvasPool(): CanvasPool;
+export declare function getBackgroundImage(template: TemplateContentV2, variables?: Record<string, number | string | string[]>): string | number | string[] | undefined;
+/**
+ * @param {string|HTMLImageElement} url
+ * @param {TemplateContentV2} [template]
+ * @param {Record<string, number | string>} [variables]
+ * @param {TemplateOptions} [opts]
+ * @param {boolean} [flipY]
+ * @returns
+ */
+export declare function combineImageTemplate2(url: string | HTMLImageElement, template?: TemplateContentV2, variables?: Record<string, number | string>, opts?: TemplateOptions, flipY?: boolean): Promise<HTMLCanvasElement>;
+/**
+ * @internal
+ * @deprecated since 2.0.0 - use `combineImageTemplate2` instead
+ */
+export declare function combineImageTemplate2Async(url: string | HTMLImageElement, template?: TemplateContentV2, variables?: Record<string, number | string>, opts?: TemplateOptions, flipY?: boolean): Promise<HTMLCanvasElement | ImageData>;
+/**
+ * @param url
+ * @param template
+ * @param variables
+ * @param opts
+ * @param flipY
+ * @returns
+ */
+export declare function combineImageTemplate(url: string | HTMLImageElement, template: TemplateContentV1 | TemplateContentV2, variables: Record<string, number | string>, opts?: {
+    templateScale?: number;
+    canvas?: HTMLCanvasElement;
+}, flipY?: boolean): Promise<HTMLCanvasElement>;
+/**
+ * @internal
+ * @deprecated since 2.0.0 - use `combineImageTemplate` instead
+ */
+export declare function combineImageTemplateAsync(url: string | HTMLImageElement, template: TemplateContentV1 | TemplateContentV2, variables: Record<string, number | string>, opts?: {
+    templateScale?: number;
+    canvas?: HTMLCanvasElement;
+}, flipY?: boolean): Promise<HTMLCanvasElement | HTMLImageElement | ImageData>;

package/dist/template-image/qcanvas-viewer.d.ts

@@ -0,0 +1,21 @@
+import type { QText } from './qtext';
+declare class QCanvasViewer {
+    width: number;
+    height: number;
+    background: HTMLImageElement;
+    scaleX: number;
+    scaleY: number;
+    renderCanvas: HTMLCanvasElement;
+    renderContext: CanvasRenderingContext2D;
+    textList: QText[];
+    devicePixelRatio: number;
+    flipY: boolean;
+    constructor(canvas: string | HTMLCanvasElement, width: number, height: number, scaleX?: number, scaleY?: number, flipY?: boolean);
+    initDimension(width: number, height: number, scaleX?: number, scaleY?: number): void;
+    clearText(): void;
+    clearCanvasWithContext(ctx: CanvasRenderingContext2D): void;
+    clearCanvas(): void;
+    addObject(text: QText): void;
+    render(): void;
+}
+export { QCanvasViewer };

package/dist/template-image/qtext.d.ts

@@ -0,0 +1,96 @@
+import type { QCanvasViewer } from './qcanvas-viewer';
+import type { IFontMetrics } from './text-metrics';
+declare enum QTextWrapMode {
+    Default = 0,
+    Clip = 1,
+    Ellipsis = 2
+}
+interface QTextOptions {
+    left?: number;
+    top?: number;
+    maxWidth?: number;
+    fontFamily?: string;
+    fontSize?: number;
+    fontWeight?: string;
+    align?: string;
+    verticalAlign?: string;
+    padding?: number;
+    letterSpacing?: number;
+    wrap?: QTextWrapMode;
+    color?: string;
+    fontStyle?: string;
+    angle?: number;
+    name?: string;
+}
+interface QChar {
+    left: number;
+    top: number;
+    char: string;
+    width: number;
+    heigh: number;
+    font: string;
+    fontSize: number;
+    isEllipsis: boolean;
+    scale: number;
+    index: number;
+}
+declare class QText {
+    left: number;
+    top: number;
+    width?: number;
+    height?: number;
+    text: string;
+    name: string;
+    fontSize: number;
+    fontFamily: string;
+    color: string;
+    letterSpacing: number;
+    maxLineWidth: number;
+    wrap: QTextWrapMode;
+    fontStyle: 'normal' | 'italic' | 'oblique' | 'initial' | 'inherit';
+    textAlign: 'center' | 'end' | 'left' | 'right' | 'start';
+    textBaseline: 'alphabetic' | 'bottom' | 'hanging' | 'ideographic' | 'middle' | 'top';
+    scaleX: number;
+    scaleY: number;
+    angle: number;
+    active: boolean;
+    padding: number;
+    fontWeight: string;
+    chars: QChar[];
+    borderColor: string;
+    borderWidth: number;
+    fontProperties: IFontMetrics;
+    fontVariant: string;
+    private viewer;
+    private originX;
+    private originY;
+    private ellipsis;
+    constructor(text: string, options: QTextOptions);
+    update(): void;
+    render(): void;
+    init(viewer: QCanvasViewer): void;
+    getLayout(): {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    private updateDimension;
+    private configTextStyle;
+    private getFontDesc;
+    private configTextLayout;
+    private setRenderTransform;
+    private renderText;
+    private drawCharsInTextBox;
+    private addEllipsisToChars;
+    private createCharsFromText;
+    private addOffsetToChars;
+    private clipCharsWithTextBox;
+    private cloneChars;
+    private replaceCharWithEllipsis;
+    private findEllipsisPositionAndReplaceCharsFromLeft;
+    private findEllipsisPositionAndReplaceCharsFromRight;
+    private drawCharsFromLeft;
+    private drawBorders;
+}
+export { QText, QTextOptions, QTextWrapMode };

package/dist/template-image/template-v1.d.ts

@@ -0,0 +1,27 @@
+import type { TemplateContentV1 } from '@galacean/effects-specification';
+export declare function requestAsync(url: string, opt?: {
+    responseType?: XMLHttpRequestResponseType;
+    method?: string;
+    data?: Document | XMLHttpRequestBodyInit | null;
+}): Promise<unknown>;
+/**
+ *
+ * @param url
+ * @param template
+ * @param variables
+ * @param opts
+ * @param flipY
+ * @returns
+ */
+export declare function combineImageTemplate1(url: string | HTMLImageElement, template: TemplateContentV1, variables: Record<string, number | string | HTMLImageElement>, opts?: {
+    templateScale?: number;
+    canvas?: HTMLCanvasElement;
+}, flipY?: boolean): Promise<HTMLCanvasElement>;
+/**
+ * @internal
+ * @deprecated since 2.0.0 - use `combineImageTemplate1` instead
+ */
+export declare function combineImageTemplate1Async(url: string | HTMLImageElement, template: TemplateContentV1, variables: Record<string, number | string | HTMLImageElement>, opts?: {
+    templateScale?: number;
+    canvas?: HTMLCanvasElement;
+}, flipY?: boolean): Promise<HTMLCanvasElement>;

package/dist/template-image/text-metrics.d.ts

@@ -0,0 +1,18 @@
+export interface IFontMetrics {
+    ascent: number;
+    descent: number;
+    fontSize: number;
+}
+export declare class TextMetrics {
+    static _fonts: {
+        [font: string]: IFontMetrics;
+    };
+    static METRICS_STRING: string;
+    static BASELINE_SYMBOL: string;
+    static BASELINE_MULTIPLIER: number;
+    static HEIGHT_MULTIPLIER: number;
+    private static __canvas;
+    private static __context;
+    static measureFont(font: string): IFontMetrics;
+    static get _canvas(): HTMLCanvasElement;
+}

package/dist/texture/index.d.ts

@@ -0,0 +1,5 @@
+export * from './utils';
+export * from './texture';
+export * from './ktx-texture';
+export * from './texture-factory';
+export * from './types';

package/dist/texture/ktx-texture.d.ts

@@ -0,0 +1,21 @@
+import type { Texture2DSourceOptionsCompressed, TextureDataType } from './types';
+export declare class KTXTexture {
+    private readonly arrayBuffer;
+    private readonly baseOffset;
+    glType: number;
+    glTypeSize: number;
+    glFormat: number;
+    glInternalFormat: number;
+    glBaseInternalFormat: number;
+    pixelWidth: number;
+    pixelHeight: number;
+    loadType: number;
+    pixelDepth: number;
+    numberOfArrayElements: number;
+    numberOfFaces: number;
+    numberOfMipmapLevels: number;
+    bytesOfKeyValueData: number;
+    constructor(arrayBuffer: ArrayBuffer, facesExpected: number, baseOffset?: number);
+    mipmaps(loadMipmaps: boolean): TextureDataType[];
+}
+export declare function getKTXTextureOptions(data: ArrayBuffer): Texture2DSourceOptionsCompressed;

package/dist/texture/texture-factory.d.ts

@@ -0,0 +1,13 @@
+import type { TextureConfigOptions, TextureFactorySourceFrom, TextureSourceOptions } from './types';
+import type { Texture } from './texture';
+export declare class TextureFactory {
+    reloadPending: Record<string, boolean>;
+    constructor();
+    reload(texture: Texture): Promise<void>;
+    canOffloadTexture(sourceFrom?: TextureFactorySourceFrom): boolean;
+    loadSource(sourceFrom: TextureFactorySourceFrom, config?: TextureConfigOptions): Promise<TextureSourceOptions>;
+    private loadMipmapImages;
+    private loadCubeMap;
+}
+export declare function getDefaultTextureFactory(): TextureFactory;
+export declare function setDefaultTextureFactory(factory: TextureFactory): void;

package/dist/texture/texture.d.ts

@@ -0,0 +1,78 @@
+import { TextureSourceType } from './types';
+import type { TextureFactorySourceFrom, TextureSourceOptions, TextureDataType } from './types';
+import type { Engine } from '../engine';
+/**
+ * Texture 抽象类
+ */
+export declare abstract class Texture {
+    /**
+     * Texture 名称
+     */
+    name: string;
+    sourceFrom?: TextureFactorySourceFrom;
+    sourceType?: TextureSourceType;
+    source: TextureSourceOptions;
+    engine: Engine;
+    /**
+     * Texture 高度
+     */
+    width: number;
+    /**
+     * Texture 宽度
+     */
+    height: number;
+    /**
+     * Texture 的全局唯一 id
+     */
+    readonly id: string;
+    protected destroyed: boolean;
+    protected offloaded: boolean;
+    /**
+     * 创建一个新的 Texture 对象。
+     */
+    static create: (engine: Engine, options: TextureSourceOptions) => Texture;
+    /**
+     * 通过数据创建 Texture 对象。
+     * @param data - 要创建的 Texture 数据
+     * @param options - 可选的 Texture 选项
+     */
+    static createWithData: (engine: Engine, data?: TextureDataType, options?: Record<string, any>) => Texture;
+    constructor();
+    get isDestroyed(): boolean;
+    /**
+     * 获取 Texture 的宽度。
+     */
+    getWidth(): number;
+    /**
+     * 获取 Texture 的高度。
+     */
+    getHeight(): number;
+    uploadCurrentVideoFrame(): void;
+    /**
+     * 释放 Texture GPU 资源。
+     * 注意：该方法只释放资源，并不销毁 GPU textureBuffer 对象。
+     * @override
+     */
+    offloadData(): void;
+    /**
+     * 重新加载 Texture  GPU 资源。
+     * @override
+     */
+    reloadData(): void;
+    /**
+     * 更新 Texture 源数据。
+     * @param options - 创建 Texture 选项
+     */
+    abstract updateSource(options: TextureSourceOptions): void;
+    /**
+     * 销毁当前资源。
+     */
+    abstract dispose(): void;
+    /**
+     * 初始化 GPU 资源
+     * @override
+     */
+    initialize(): void;
+    protected assembleOptions(options: TextureSourceOptions): TextureSourceOptions;
+}
+export declare function generateHalfFloatTexture(engine: Engine, data: Uint16Array, width: number, height: number): Texture;

package/dist/texture/types.d.ts

@@ -0,0 +1,165 @@
+import type * as spec from '@galacean/effects-specification';
+type DataRange = [start: number, length: number];
+type ImageSource = HTMLImageElement | HTMLCanvasElement;
+export declare enum TextureLoadAction {
+    whatever = 0,
+    clear = 2
+}
+export declare enum TextureSourceType {
+    none = 0,
+    data = 1,
+    image = 2,
+    compressed = 3,
+    video = 4,
+    canvas = 5,
+    framebuffer = 6,
+    mipmaps = 7
+}
+export type TextureSourceCubeData = [
+    TEXTURE_CUBE_MAP_POSITIVE_X: ImageSource | {
+        data: spec.TypedArray;
+        width: number;
+        height: number;
+    },
+    TEXTURE_CUBE_MAP_NEGATIVE_X: ImageSource | {
+        data: spec.TypedArray;
+        width: number;
+        height: number;
+    },
+    TEXTURE_CUBE_MAP_POSITIVE_Y: ImageSource | {
+        data: spec.TypedArray;
+        width: number;
+        height: number;
+    },
+    TEXTURE_CUBE_MAP_NEGATIVE_Y: ImageSource | {
+        data: spec.TypedArray;
+        width: number;
+        height: number;
+    },
+    TEXTURE_CUBE_MAP_POSITIVE_Z: ImageSource | {
+        data: spec.TypedArray;
+        width: number;
+        height: number;
+    },
+    TEXTURE_CUBE_MAP_NEGATIVE_Z: ImageSource | {
+        data: spec.TypedArray;
+        width: number;
+        height: number;
+    }
+];
+export type TextureCubeSourceURLMap = [
+    TEXTURE_CUBE_MAP_POSITIVE_X: string,
+    TEXTURE_CUBE_MAP_NEGATIVE_X: string,
+    TEXTURE_CUBE_MAP_POSITIVE_Y: string,
+    TEXTURE_CUBE_MAP_NEGATIVE_Y: string,
+    TEXTURE_CUBE_MAP_POSITIVE_Z: string,
+    TEXTURE_CUBE_MAP_NEGATIVE_Z: string
+];
+export type TextureFactorySource2DBinaryMipmapsFrom = {
+    target?: WebGLRenderingContext['TEXTURE_2D'];
+    type: TextureSourceType.mipmaps;
+    bin: string;
+    mipmaps: DataRange[];
+};
+export type TextureFactorySourceCubeBinaryMipmapsFrom = {
+    target: WebGLRenderingContext['TEXTURE_CUBE_MAP'];
+    type: TextureSourceType.mipmaps;
+    bin: string;
+    mipmaps: [
+        TEXTURE_CUBE_MAP_POSITIVE_X: DataRange,
+        TEXTURE_CUBE_MAP_NEGATIVE_X: DataRange,
+        TEXTURE_CUBE_MAP_POSITIVE_Y: DataRange,
+        TEXTURE_CUBE_MAP_NEGATIVE_Y: DataRange,
+        TEXTURE_CUBE_MAP_POSITIVE_Z: DataRange,
+        TEXTURE_CUBE_MAP_NEGATIVE_Z: DataRange
+    ][];
+};
+export interface TextureFactorySource2DFrom {
+    type: TextureSourceType.image | TextureSourceType.video;
+    url: string;
+    target?: WebGLRenderingContext['TEXTURE_2D'];
+}
+export type TextureFactorySourceCubeFrom = {
+    type: TextureSourceType.image;
+    map: TextureCubeSourceURLMap | string[];
+    target: WebGLRenderingContext['TEXTURE_CUBE_MAP'];
+};
+export interface TextureFactorySourceCubeMipmapsFrom {
+    type: TextureSourceType.mipmaps;
+    target: WebGLRenderingContext['TEXTURE_CUBE_MAP'];
+    maps: TextureCubeSourceURLMap[] | string[][];
+}
+export interface TextureFactorySource2DMipmapsFrom {
+    type: TextureSourceType.mipmaps;
+    target?: WebGLRenderingContext['TEXTURE_2D'];
+    urls: string[];
+}
+export interface TextureFactorySourceFromCompressed {
+    type: TextureSourceType.compressed;
+    url: string;
+    target?: number;
+}
+export type TextureFactorySourceFrom = TextureFactorySource2DBinaryMipmapsFrom | TextureFactorySourceCubeBinaryMipmapsFrom | TextureFactorySource2DFrom | TextureFactorySourceCubeFrom | TextureFactorySourceCubeMipmapsFrom | TextureFactorySource2DMipmapsFrom | TextureFactorySourceFromCompressed;
+export interface TextureConfigOptions extends spec.TextureConfigOptionsBase {
+    sourceFrom?: TextureFactorySourceFrom;
+}
+export interface TextureOptionsBase extends TextureConfigOptions, spec.TextureFormatOptions {
+}
+export interface TextureCubeSourceOptionsImage extends TextureOptionsBase {
+    sourceType: TextureSourceType.image | TextureSourceType.data;
+    target: WebGLRenderingContext['TEXTURE_CUBE_MAP'];
+    cube: TextureSourceCubeData;
+}
+export interface TextureCubeSourceOptionsImageMipmaps extends TextureOptionsBase {
+    sourceType?: TextureSourceType.mipmaps;
+    mipmaps: TextureSourceCubeData[];
+    target: WebGLRenderingContext['TEXTURE_CUBE_MAP'];
+}
+export type TextureCubeSourceOptions = TextureCubeSourceOptionsImage | TextureCubeSourceOptionsImageMipmaps;
+export type TextureDataType = {
+    data: spec.TypedArray;
+    width: number;
+    height: number;
+};
+export interface Texture2DSourceOptionsImage extends TextureOptionsBase {
+    sourceType?: TextureSourceType.image;
+    image: ImageSource;
+    target?: WebGLRenderingContext['TEXTURE_2D'];
+    generateMipmap?: boolean;
+}
+export interface Texture2DSourceOptionsData extends TextureOptionsBase {
+    sourceType?: TextureSourceType.data;
+    data: TextureDataType;
+    target?: WebGLRenderingContext['TEXTURE_2D'];
+}
+export interface Texture2DSourceOptionsVideo extends TextureOptionsBase {
+    sourceType?: TextureSourceType.video;
+    video: HTMLVideoElement;
+    target?: WebGLRenderingContext['TEXTURE_2D'];
+    generateMipmap?: boolean;
+}
+export interface Texture2DSourceOptionsImageMipmaps extends TextureOptionsBase {
+    sourceType?: TextureSourceType.mipmaps;
+    mipmaps: (ImageSource | TextureDataType)[];
+    target?: WebGLRenderingContext['TEXTURE_2D'];
+}
+export interface Texture2DSourceOptionsCompressed extends TextureOptionsBase {
+    sourceType?: TextureSourceType.compressed;
+    mipmaps: TextureDataType[];
+    target?: WebGLRenderingContext['TEXTURE_2D'] | WebGLRenderingContext['TEXTURE_CUBE_MAP'];
+}
+export interface Texture2DSourceOptionsFrameBuffer extends TextureOptionsBase {
+    sourceType: TextureSourceType.framebuffer;
+    data?: {
+        width: number;
+        height: number;
+    };
+    target?: WebGLRenderingContext['TEXTURE_2D'];
+}
+export interface Texture2DSourceOptionsNone extends TextureOptionsBase {
+    sourceType?: TextureSourceType.none;
+    target?: GLenum;
+}
+export type Texture2DSourceOptions = Texture2DSourceOptionsImage | Texture2DSourceOptionsData | Texture2DSourceOptionsVideo | Texture2DSourceOptionsImageMipmaps | Texture2DSourceOptionsCompressed | Texture2DSourceOptionsFrameBuffer | Texture2DSourceOptionsNone;
+export type TextureSourceOptions = Texture2DSourceOptions | TextureCubeSourceOptions;
+export {};

package/dist/texture/utils.d.ts

@@ -0,0 +1,5 @@
+import type * as spec from '@galacean/effects-specification';
+import type { Texture2DSourceOptions, TextureCubeSourceOptions } from './types';
+type TextureJSONOptions = spec.SerializedTextureSource & spec.TextureConfigOptionsBase & spec.TextureFormatOptions;
+export declare function deserializeMipmapTexture(texOpts: TextureJSONOptions, bins: ArrayBuffer[], files?: spec.BinaryFile[]): Promise<Texture2DSourceOptions | TextureCubeSourceOptions>;
+export {};

package/dist/ticker.d.ts

@@ -0,0 +1,48 @@
+/**
+ * 定时器类
+ */
+export declare class Ticker {
+    tickers: ((dt: number) => void)[];
+    private paused;
+    private lastTime;
+    private targetFPS;
+    private interval;
+    private intervalId;
+    private resetTickers;
+    constructor(fps?: number);
+    /**
+     * FPS 帧率设置
+     */
+    getFPS(): number;
+    setFPS(fps: number): void;
+    /**
+     * 获取定时器暂停标志位
+     * @returns 暂停标志位
+     */
+    getPaused(): boolean;
+    /**
+     * 定时器开始方法
+     */
+    start(): void;
+    /**
+     * 定时器停止方法
+     */
+    stop(): void;
+    /**
+     * 定时器暂停方法
+     */
+    pause(): void;
+    /**
+     * 定时器恢复方法
+     */
+    resume(): void;
+    /**
+     * 定时器 tick 方法
+     */
+    tick(): void;
+    /**
+     * 定时器添加计时方法
+     * @param ticker - 定时器类
+     */
+    add(ticker: (dt: number) => void): void;
+}