@galacean/effects-core 1.1.1 → 1.1.2

package/dist/math/value-getter.d.ts

@@ -1,127 +0,0 @@
-import * as spec from '@galacean/effects-specification';
-import type { ColorStop } from '../utils';
-interface KeyFrameMeta {
-    curves: ValueGetter<any>[];
-    index: number;
-    max: number;
-    lineSegCount: number;
-    curveCount: number;
-}
-export declare class ValueGetter<T> {
-    constructor(arg: any);
-    onCreate(props: any): void;
-    getIntegrateValue(t0: number, t1: number, timeScale?: number): T;
-    getIntegrateByTime(t0: number, time: number): T;
-    getValue(time?: number): T;
-    toUniform(meta: KeyFrameMeta): Float32Array;
-    map(func: (n: T) => T): void;
-    scaleXCoord(scale: number): ValueGetter<T>;
-}
-export declare class StaticValue extends ValueGetter<number> {
-    private value;
-    onCreate(arg: number): void;
-    getIntegrateValue(t0: number, t1: number, ts: number): number;
-    getIntegrateByTime(t0: number, t1: number): number;
-    getValue(time?: number): number;
-    toUniform(): Float32Array;
-    map(func: (n: number) => number): this;
-}
-export declare class RandomSetValue<T> extends ValueGetter<T> {
-    private items;
-    onCreate(arg: T[]): void;
-    getValue(t: number): T;
-    map(func: (v: T) => T): this;
-}
-export declare class RandomValue extends ValueGetter<number> {
-    private min;
-    private max;
-    onCreate(props: [min: number, max: number]): void;
-    getValue(time?: number): number;
-    toUniform(): Float32Array;
-    map(func: any): this;
-}
-export declare class RandomVectorValue extends ValueGetter<number[]> {
-    private min;
-    private max;
-    onCreate(props: [min: number[], max: number[]]): void;
-    getValue(time: number): number[];
-    map(func: any): this;
-}
-export declare class LinearValue extends ValueGetter<number> {
-    private min;
-    private max;
-    private xCoord;
-    onCreate(props: [min: number, max: number]): void;
-    getValue(t: number): number;
-    toUniform(): Float32Array;
-    getIntegrateValue(t0: number, t1: number, timeScale?: number): number;
-    getIntegrateByTime(t0: number, t1: number): number;
-    map(func: (num: number) => number): this;
-    scaleXCoord(scale: number): LinearValue;
-}
-export declare class GradientValue extends ValueGetter<number[]> {
-    stops: ColorStop[];
-    onCreate(props: number[][] | Record<string, string>): void;
-    getStops(): ColorStop[];
-    getValue(time: number): number[];
-}
-export type KeyFrame = {
-    inTangent: number;
-    outTangent: number;
-    time: number;
-    value: number;
-};
-export declare class CurveValue extends ValueGetter<number> {
-    keys: KeyFrame[] | number[][];
-    min: number;
-    dist: number;
-    isCurveValue: boolean;
-    static getAllData(meta: KeyFrameMeta, halfFloat?: boolean): Uint16Array | Float32Array;
-    onCreate(props: number[] & number[][]): void;
-    getValue(time: number): number;
-    getIntegrateByTime(t0: number, t1: number): number;
-    getIntegrateValue(t0: number, t1: number, ts: number): number;
-    integrate(time: number, byTime: boolean): number;
-    toData(): Float32Array;
-    toUniform(meta: any): Float32Array;
-    map(func: (num: number) => number): this;
-    scaleXCoord(scale: number): this;
-}
-export declare class LineSegments extends ValueGetter<number> {
-    isLineSeg: boolean;
-    keys: number[][];
-    onCreate(props: ({
-        time: number;
-        value: number;
-    } & number[])[]): void;
-    getValue(time: number): number;
-    getIntegrateValue(t0: number, t1: number, ts?: number): number;
-    getIntegrateByTime(t0: number, t1: number): number;
-    private integrate;
-    toData(): Float32Array;
-    toUniform(meta: any): Float32Array;
-    map(func: (k: number) => number): this;
-    scaleXCoord(scale: number): this;
-}
-export declare class PathSegments extends ValueGetter<number[]> {
-    keys: number[][];
-    values: number[][];
-    onCreate(props: number[][][]): void;
-    getValue(time: number): number[];
-    calculateVec(i: number, dt: number): number[];
-}
-export declare class BezierSegments extends PathSegments {
-    cps: number[][];
-    onCreate(props: number[][][]): void;
-    calculateVec(i: number, t: number): number[];
-}
-export declare function createValueGetter(args: any): ValueGetter<any>;
-export declare function getKeyFrameMetaByRawValue(meta: KeyFrameMeta, value?: [type: spec.ValueType, value: any]): void;
-export declare function createKeyFrameMeta(): {
-    curves: never[];
-    index: number;
-    max: number;
-    lineSegCount: number;
-    curveCount: number;
-};
-export {};

package/dist/paas-texture-cache.d.ts

@@ -1,24 +0,0 @@
-import type { Engine } from './engine';
-import type { TextureConfigOptions } from './texture';
-import { Texture } from './texture';
-import { type Disposable } from './utils';
-export interface TextureCacheRequest extends TextureConfigOptions {
-    width: number;
-    height: number;
-    name: string;
-    format?: typeof WebGLRenderingContext.RGBA | typeof WebGL2RenderingContext.RGB | typeof WebGLRenderingContext.LUMINANCE;
-    type?: typeof WebGLRenderingContext.UNSIGNED_BYTE | typeof WebGLRenderingContext.FLOAT | typeof WebGL2RenderingContext.HALF_FLOAT;
-    minFilter?: GLenum;
-    magFilter?: GLenum;
-    wrapS?: GLenum;
-    wrapT?: GLenum;
-}
-export declare class PassTextureCache implements Disposable {
-    private textureCache;
-    private textureRef;
-    private engine?;
-    constructor(engine: Engine);
-    requestColorAttachmentTexture(request: TextureCacheRequest): Texture;
-    removeTexture(id: string): void;
-    dispose(): void;
-}

package/dist/pass-render-level.d.ts

@@ -1 +0,0 @@
-export declare function passRenderLevel(l: string | undefined, renderLevel?: string): boolean;

package/dist/plugin-system.d.ts

@@ -1,34 +0,0 @@
-import type * as spec from '@galacean/effects-specification';
-import type { SceneLoadOptions } from './asset-manager';
-import type { Composition } from './composition';
-import type { Plugin, PluginConstructor } from './plugins';
-import type { RenderFrame, Renderer } from './render';
-import type { Scene } from './scene';
-import type { VFXItemConstructor, VFXItemProps } from './vfx-item';
-import { VFXItem } from './vfx-item';
-export declare const pluginLoaderMap: Record<string, PluginConstructor>;
-export declare const defaultPlugins: string[];
-export type PrecompileOptions = {
-    [key: string]: any;
-};
-/**
- * 注册 plugin
- * @param name
- * @param pluginClass class of plugin
- * @param itemClass class of item
- * @param isDefault load
- */
-export declare function registerPlugin<T>(name: string, pluginClass: PluginConstructor, itemClass: VFXItemConstructor, isDefault?: boolean): void;
-export declare function unregisterPlugin(name: string): void;
-export declare class PluginSystem {
-    readonly plugins: Plugin[];
-    constructor(pluginNames: string[]);
-    initializeComposition(composition: Composition, scene: Scene): void;
-    destroyComposition(comp: Composition): void;
-    resetComposition(comp: Composition, renderFrame: RenderFrame): void;
-    createPluginItem(name: string, props: VFXItemProps, composition: Composition): VFXItem<any>;
-    processRawJSON(json: spec.JSONScene, options: SceneLoadOptions): Promise<void[]>;
-    private callStatic;
-    precompile(compositions: spec.Composition[], renderer: Renderer, options?: PrecompileOptions): Promise<void[]>;
-    loadResources(scene: Object, options: SceneLoadOptions): Promise<void[]>;
-}

package/dist/plugins/cal/calculate-item.d.ts

@@ -1,84 +0,0 @@
-import * as spec from '@galacean/effects-specification';
-import { Euler, Vector3 } from '@galacean/effects-math/es/core/index';
-import type { ValueGetter } from '../../math';
-import type { Transform } from '../../transform';
-import type { VFXItem, VFXItemContent } from '../../vfx-item';
-import type { SpriteRenderData } from '../sprite/sprite-mesh';
-/**
- * 基础位移属性数据
- */
-export type ItemBasicTransform = {
-    position: Vector3;
-    rotation: Euler;
-    scale: Vector3;
-    path?: ValueGetter<spec.vec3>;
-};
-export type ItemLinearVelOverLifetime = {
-    asMovement?: boolean;
-    x?: ValueGetter<number>;
-    y?: ValueGetter<number>;
-    z?: ValueGetter<number>;
-    enabled?: boolean;
-};
-export interface CalculateItemOptions {
-    delay: number;
-    startSpeed: number;
-    direction: Vector3;
-    startSize: number;
-    sizeAspect: number;
-    duration: number;
-    looping: boolean;
-    endBehavior: number;
-    reusable?: boolean;
-    gravity: Vector3;
-    gravityModifier: ValueGetter<number>;
-    startRotation?: number;
-    start3DRotation?: number;
-}
-export declare class CalculateItem {
-    protected vfxItem: VFXItem<VFXItemContent>;
-    renderData: SpriteRenderData;
-    id: string;
-    active: boolean;
-    name: string;
-    visible: boolean;
-    time: number;
-    protected options: CalculateItemOptions;
-    protected basicTransform: ItemBasicTransform;
-    protected transform: Transform;
-    protected sizeSeparateAxes: boolean;
-    protected sizeXOverLifetime: ValueGetter<number>;
-    protected sizeYOverLifetime: ValueGetter<number>;
-    protected sizeZOverLifetime: ValueGetter<number>;
-    protected rotationOverLifetime: {
-        asRotation?: boolean;
-        separateAxes?: boolean;
-        enabled?: boolean;
-        x?: ValueGetter<number>;
-        y?: ValueGetter<number>;
-        z?: ValueGetter<number>;
-    };
-    gravityModifier: ValueGetter<number>;
-    orbitalVelOverLifetime: {
-        x?: ValueGetter<number>;
-        y?: ValueGetter<number>;
-        z?: ValueGetter<number>;
-        center: [x: number, y: number, z: number];
-        asRotation?: boolean;
-        enabled?: boolean;
-    };
-    speedOverLifetime?: ValueGetter<number>;
-    positionOverLifetime: ValueGetter<number>;
-    linearVelOverLifetime: ItemLinearVelOverLifetime;
-    /*****************/
-    private _velocity;
-    constructor(props: spec.NullContent, vfxItem: VFXItem<VFXItemContent>);
-    get ended(): boolean;
-    get startSize(): Vector3;
-    set startSize(scale: Vector3);
-    get velocity(): Vector3;
-    getWillTranslate(): boolean;
-    updateTime(globalTime: number): void;
-    getRenderData(_time: number, init?: boolean): SpriteRenderData;
-    protected calculateScaling(sizeChanged: boolean, sizeInc: Vector3, init?: boolean): void;
-}

package/dist/plugins/cal/calculate-loader.d.ts

@@ -1,3 +0,0 @@
-import { AbstractPlugin } from '../index';
-export declare class CalculateLoader extends AbstractPlugin {
-}

package/dist/plugins/cal/calculate-vfx-item.d.ts

@@ -1,26 +0,0 @@
-import * as spec from '@galacean/effects-specification';
-import type { VFXItemProps } from '../../vfx-item';
-import { VFXItem } from '../../vfx-item';
-import type { Composition } from '../../composition';
-import type { SpriteRenderData } from '../sprite/sprite-mesh';
-import { CalculateItem } from './calculate-item';
-export declare class CalculateVFXItem extends VFXItem<CalculateItem> {
-    relative?: boolean;
-    cal: any;
-    _v_priority: number;
-    childrenVisible: boolean;
-    renderData: SpriteRenderData;
-    get type(): spec.ItemType;
-    onConstructed(props: VFXItemProps): void;
-    onLifetimeBegin(composition: Composition, content: CalculateItem): void;
-    onItemRemoved(composition: Composition, content: CalculateItem): void;
-    onItemUpdate(dt: number, lifetime: number): void;
-    setScale(x: number, y: number, z: number): void;
-    scale(x: number, y: number, z: number): void;
-    getHitTestParams(force?: boolean): void;
-    getRenderData(): SpriteRenderData;
-    getChildrenVisible(): boolean;
-    setChildrenVisible(visible: boolean): void;
-    protected doCreateContent(composition: Composition): CalculateItem;
-    protected handleVisibleChanged(visible: boolean): void;
-}

package/dist/plugins/camera/camera-controller-node.d.ts

@@ -1,17 +0,0 @@
-import type * as spec from '@galacean/effects-specification';
-import { Euler, Vector3 } from '@galacean/effects-math/es/core/index';
-import { Transform } from '../../transform';
-export declare class CameraController {
-    private readonly transform;
-    near: number;
-    far: number;
-    fov: number;
-    clipMode?: spec.CameraClipMode;
-    position: Vector3;
-    rotation: Euler;
-    private options;
-    private readonly translateOverLifetime?;
-    private readonly rotationOverLifetime?;
-    constructor(transform: Transform, model: spec.CameraContent);
-    update(lifetime: number): void;
-}

package/dist/plugins/camera/camera-vfx-item-loader.d.ts

@@ -1,3 +0,0 @@
-import { AbstractPlugin } from '../index';
-export declare class CameraVFXItemLoader extends AbstractPlugin {
-}

package/dist/plugins/camera/camera-vfx-item.d.ts

@@ -1,13 +0,0 @@
-import * as spec from '@galacean/effects-specification';
-import { VFXItem } from '../../vfx-item';
-import { CameraController } from './camera-controller-node';
-export declare class CameraVFXItem extends VFXItem<CameraController> {
-    private model;
-    private controller;
-    get type(): spec.ItemType;
-    onConstructed(props: spec.CameraItem): void;
-    onItemUpdate(dt: number, lifetime: number): void;
-    private updateCamera;
-    getCurrentPosition(): import("@galacean/effects-math/es").Vector3;
-    protected doCreateContent(): CameraController;
-}

package/dist/plugins/index.d.ts

@@ -1,26 +0,0 @@
-export * from './plugin';
-export * from './camera/camera-controller-node';
-export * from './camera/camera-vfx-item-loader';
-export * from './camera/camera-vfx-item';
-export * from './interact/click-handler';
-export * from './interact/event-system';
-export * from './interact/interact-loader';
-export * from './interact/interact-mesh';
-export * from './interact/interact-vfx-item';
-export * from './interact/interact-item';
-export * from './sprite/sprite-loader';
-export * from './sprite/sprite-vfx-item';
-export * from './sprite/sprite-item';
-export * from './sprite/sprite-mesh';
-export * from './sprite/filter-sprite-vfx-item';
-export * from './particle/particle-loader';
-export * from './particle/particle-mesh';
-export * from './particle/particle-vfx-item';
-export * from './particle/particle-system';
-export * from './cal/calculate-loader';
-export * from './cal/calculate-vfx-item';
-export * from './cal/calculate-item';
-export * from './text/text-item';
-export * from './text/text-loader';
-export * from './text/text-mesh';
-export * from './text/text-vfx-item';

package/dist/plugins/interact/click-handler.d.ts

@@ -1,66 +0,0 @@
-import type * as spec from '@galacean/effects-specification';
-import type { Matrix4, Ray, TriangleLike, Vector2, Vector3 } from '@galacean/effects-math/es/core/index';
-import type { CompVFXItem } from '../../comp-vfx-item';
-export declare enum HitTestType {
-    triangle = 1,
-    box = 2,
-    sphere = 3,
-    custom = 4
-}
-export interface BoundingBoxData {
-    type: HitTestType;
-    area: (TriangleLike | Record<string, Vector3>)[];
-}
-export interface BoundingBoxTriangle extends BoundingBoxData {
-    type: HitTestType.triangle;
-    area: TriangleLike[];
-}
-export interface BoundingBoxSphere extends BoundingBoxData {
-    type: HitTestType.sphere;
-    area: {
-        center: Vector3;
-        size: Vector3;
-    }[];
-}
-export interface HitTestTriangleParams {
-    type: HitTestType.triangle;
-    triangles: TriangleLike[];
-    backfaceCulling?: boolean;
-    behavior?: spec.InteractBehavior;
-}
-export interface HitTestBoxParams {
-    type: HitTestType.box;
-    center: Vector3;
-    size: Vector3;
-    behavior?: spec.InteractBehavior;
-}
-export interface HitTestSphereParams {
-    type: HitTestType.sphere;
-    center: Vector3;
-    radius: number;
-    behavior?: spec.InteractBehavior;
-}
-export interface HitTestCustomParams {
-    type: HitTestType.custom;
-    collect(ray: Ray, pointInCanvas: Vector2): Vector3[] | void;
-    behavior?: spec.InteractBehavior;
-}
-export type Region = {
-    compContent: CompVFXItem;
-    name: string;
-    id: string;
-    position: Vector3;
-    behavior?: spec.InteractBehavior;
-    parentId?: string;
-    hitPositions?: Vector3[];
-};
-export type HitTestParams = {
-    camera: {
-        position: Vector3;
-        direction: Vector3;
-        viewProjection: Matrix4;
-    };
-    x: number;
-    y: number;
-    inRect: (position: Vector3, width: number, height: number) => boolean;
-};

package/dist/plugins/interact/event-system.d.ts

@@ -1,37 +0,0 @@
-import * as spec from '@galacean/effects-specification';
-import type { Disposable } from '../../utils';
-export declare const EVENT_TYPE_CLICK = "click";
-export declare const EVENT_TYPE_TOUCH_START = "touchstart";
-export declare const EVENT_TYPE_TOUCH_MOVE = "touchmove";
-export declare const EVENT_TYPE_TOUCH_END = "touchend";
-export declare const InteractBehavior: typeof spec.InteractBehavior;
-export type TouchEventType = {
-    x: number;
-    y: number;
-    vx: number;
-    vy: number;
-    ts: number;
-    dx: number;
-    dy: number;
-    width: number;
-    height: number;
-    origin: Event;
-};
-export type TouchParams = {
-    clientX: number;
-    clientY: number;
-    target: EventTarget;
-};
-export declare class EventSystem implements Disposable {
-    private target;
-    allowPropagation: boolean;
-    enabled: boolean;
-    private handlers;
-    private nativeHandlers;
-    constructor(target: HTMLCanvasElement | null, allowPropagation?: boolean);
-    bindListeners(): void;
-    dispatchEvent(type: string, event: TouchEventType): void;
-    addEventListener(type: string, callback: (event: TouchEventType) => void): () => void;
-    removeEventListener(type: string, callback: (event: TouchEventType) => void): void;
-    dispose(): void;
-}

package/dist/plugins/interact/interact-item.d.ts

@@ -1,2 +0,0 @@
-export declare class InteractItem {
-}

package/dist/plugins/interact/interact-loader.d.ts

@@ -1,13 +0,0 @@
-import { AbstractPlugin } from '../index';
-import type { RenderFrame } from '../../render';
-import type { Composition } from '../../composition';
-import type { VFXItem } from '../../vfx-item';
-import type { InteractItem } from './interact-item';
-export declare class InteractLoader extends AbstractPlugin {
-    private mesh;
-    onCompositionItemLifeBegin(composition: Composition, item: VFXItem<InteractItem>): void;
-    onCompositionItemRemoved(composition: Composition, item: VFXItem<InteractItem>): void;
-    prepareRenderFrame(composition: Composition, renderFrame: RenderFrame): boolean;
-    private addMesh;
-    private removeMesh;
-}

package/dist/plugins/interact/interact-mesh.d.ts

@@ -1,16 +0,0 @@
-import type * as spec from '@galacean/effects-specification';
-import type { MeshRendererOptions } from '../../render';
-import { Mesh } from '../../render';
-import type { Transform } from '../../transform';
-import type { Engine } from '../../engine';
-export declare class InteractMesh {
-    private readonly transform;
-    private readonly engine;
-    mesh: Mesh;
-    private readonly color;
-    constructor(props: spec.InteractContent, rendererOptions: MeshRendererOptions, transform: Transform, engine: Engine);
-    updateMesh(): void;
-    private createMaterial;
-    private createGeometry;
-    private createMesh;
-}

package/dist/plugins/interact/interact-vfx-item.d.ts

@@ -1,28 +0,0 @@
-import * as spec from '@galacean/effects-specification';
-import type { VFXItemProps } from '../../vfx-item';
-import { VFXItem } from '../../vfx-item';
-import type { HitTestTriangleParams, BoundingBoxTriangle } from './click-handler';
-import type { Composition } from '../../composition';
-import { InteractMesh } from './interact-mesh';
-import type { InteractItem } from './interact-item';
-import type { Engine } from '../../engine';
-export declare class InteractVFXItem extends VFXItem<InteractItem> {
-    previewContent: InteractMesh | null;
-    private ui;
-    private clickable;
-    private dragEvent;
-    private bouncingArg;
-    engine?: Engine;
-    constructor(props: VFXItemProps, composition: Composition);
-    get type(): spec.ItemType;
-    onConstructed(options: spec.InteractItem): void;
-    onLifetimeBegin(composition: Composition): void;
-    onItemUpdate(): void;
-    onItemRemoved(composition: Composition): void;
-    getBoundingBox(): BoundingBoxTriangle | void;
-    getHitTestParams(): HitTestTriangleParams | void;
-    protected doCreateContent(composition: Composition): InteractItem;
-    private beginDragTarget;
-    private endDragTarget;
-    private handleDragMove;
-}

package/dist/plugins/particle/burst.d.ts

@@ -1,21 +0,0 @@
-export declare class Burst {
-    once: boolean;
-    disabled: boolean;
-    private now;
-    private index;
-    private internalCycles;
-    private readonly time;
-    private readonly interval;
-    private readonly count;
-    private readonly cycles;
-    private readonly probability;
-    constructor(opts: any);
-    getGeneratorOptions(timePassed: number, lifetime: number): {
-        index: number;
-        total: number;
-        count: number;
-        cycleIndex: number;
-    } | null | undefined;
-    reset(): void;
-    clone(): Burst;
-}

package/dist/plugins/particle/link.d.ts

@@ -1,21 +0,0 @@
-declare class LinkNode<T> {
-    content: T;
-    next: LinkNode<T> | null;
-    pre: LinkNode<T> | null;
-    constructor(content: T);
-}
-export declare class Link<T> {
-    private readonly sort;
-    first: LinkNode<T>;
-    last: LinkNode<T>;
-    length: number;
-    constructor(sort: (a: T, b: T) => number);
-    findNodeByContent(filter: (d: T) => boolean): LinkNode<T> | undefined;
-    private insertNode;
-    shiftNode(content: T): LinkNode<T> | undefined;
-    pushNode(content: T): LinkNode<T> | undefined;
-    removeNode(node: LinkNode<T>): void;
-    forEach(func: (content: T, index: number) => void, thisObj?: any): void;
-    forEachReverse(func: (content: T, index: number) => void, thisObj?: any): void;
-}
-export {};

package/dist/plugins/particle/particle-loader.d.ts

@@ -1,18 +0,0 @@
-import * as spec from '@galacean/effects-specification';
-import type { Composition } from '../../composition';
-import type { Renderer, RenderFrame } from '../../render';
-import { type VFXItem } from '../../vfx-item';
-import { AbstractPlugin } from '../index';
-import type { ParticleSystem } from './particle-system';
-import type { PrecompileOptions } from '../../plugin-system';
-import type { Engine } from '../../engine';
-export declare class ParticleLoader extends AbstractPlugin {
-    private meshes;
-    engine: Engine;
-    static precompile(compositions: spec.Composition[], renderer: Renderer, options?: PrecompileOptions): Promise<any>;
-    onCompositionItemLifeBegin(composition: Composition, item: VFXItem<ParticleSystem>): void;
-    onCompositionItemRemoved(composition: Composition, item: VFXItem<ParticleSystem>): void;
-    prepareRenderFrame(composition: Composition, pipeline: RenderFrame): boolean;
-    private add;
-    private remove;
-}