archgine 1.0.56 → 1.0.58

package/lib/animations/animation-action.d.ts

@@ -0,0 +1,52 @@
+import { IAnimationAction, IAnimationClip, IAnimationMixer, IInterpolant, IObject2, IPropertyMixer } from '../interfaces';
+export declare const ZeroCurvatureEnding = 2400;
+export declare const LoopRepeat = 2201;
+export declare const LoopPingPong = 2202;
+export declare const LoopOnce = 2200;
+export declare const ZeroSlopeEnding = 2401;
+export declare const WrapAroundEnding = 2402;
+export declare class AnimationAction implements IAnimationAction {
+    blendMode: number;
+    loop: number;
+    time: number;
+    timeScale: number;
+    weight: number;
+    repetitions: number;
+    paused: boolean;
+    enabled: boolean;
+    clampWhenFinished: boolean;
+    zeroSlopeAtStart: boolean;
+    zeroSlopeAtEnd: boolean;
+    _mixer: IAnimationMixer;
+    _clip: IAnimationClip;
+    _localRoot: IObject2 | undefined;
+    _interpolantSettings: any;
+    _interpolants: IInterpolant[];
+    _propertyBindings: IPropertyMixer[];
+    _cacheIndex: number | undefined;
+    _byClipCacheIndex: number | undefined;
+    _timeScaleInterpolant: IInterpolant | undefined;
+    _weightInterpolant: IInterpolant | undefined;
+    _loopCount: number;
+    _startTime: number | undefined;
+    _effectiveTimeScale: number;
+    _effectiveWeight: number;
+    constructor(mixer: IAnimationMixer, clip: IAnimationClip, localRoot?: IObject2, blendMode?: number);
+    play(): this;
+    stop(): this;
+    reset(): this;
+    isRunning(): boolean;
+    isScheduled(): boolean;
+    startAt(time: number): this;
+    setLoop(mode: number, repetitions: number): this;
+    stopFading(): this;
+    stopWarping(): this;
+    getMixer(): IAnimationMixer;
+    getClip(): IAnimationClip;
+    getRoot(): IObject2 | undefined;
+    _update(time: number, deltaTime: number, timeDirection: number, accuIndex: number): void;
+    _updateWeight(time: number): number;
+    _updateTimeScale(time: number): number;
+    _updateTime(deltaTime: number): number;
+    _setEndings(atStart: boolean, atEnd: boolean, pingPong: boolean): void;
+}

package/lib/animations/animation-clip.d.ts

@@ -0,0 +1,20 @@
+import { IAnimationClip, IClip, IKeyframeTrack, IObject2 } from '../interfaces';
+export declare class AnimationClip implements IAnimationClip {
+    name: string;
+    duration: number;
+    tracks: IKeyframeTrack[];
+    blendMode: number;
+    uuid: string;
+    constructor(name: string, duration: number | undefined, tracks: IKeyframeTrack[], blendMode?: number);
+    static parse(json: any): AnimationClip;
+    static toJSON(clip: IAnimationClip): IClip;
+    static findByName(objectOrClipArray: IObject2 | Array<IAnimationClip>, name: string): IAnimationClip | undefined;
+    resetDuration(): this;
+    trim(): this;
+    validate(): boolean;
+    optimize(): this;
+    clone(): this;
+    toJSON(): IClip;
+}
+export declare const NormalAnimationBlendMode = 2500;
+export declare const AdditiveAnimationBlendMode = 2501;

package/lib/animations/animation-mixer.d.ts

@@ -0,0 +1,52 @@
+import { default as EventDispatcher } from '../core/event-dispatcher';
+import { IAnimationAction, IAnimationMixer, IAnimationMixerStats, IInterpolant, IObject2, IPropertyMixer, IActionsForClip, IAnimationClip } from '../interfaces';
+export declare class AnimationMixer extends EventDispatcher implements IAnimationMixer {
+    stats: IAnimationMixerStats;
+    time: number;
+    timeScale: number;
+    _root?: IObject2;
+    _accuIndex: number;
+    _actions: IAnimationAction[];
+    _nActiveActions: number;
+    _actionsByClip: {
+        [p: string]: IActionsForClip;
+    };
+    _bindings: any[];
+    _nActiveBindings: number;
+    _bindingsByRootAndName: {
+        [p: string]: {
+            [k: string]: IPropertyMixer;
+        };
+    };
+    _controlInterpolants: IInterpolant[];
+    _nActiveControlInterpolants: number;
+    constructor(root?: IObject2);
+    destroy(): void;
+    bind(root: IObject2): void;
+    _bindAction(action: IAnimationAction, prototypeAction?: IAnimationAction): void;
+    _activateAction(action: IAnimationAction): void;
+    _deactivateAction(action: IAnimationAction): void;
+    _initMemoryManager(): void;
+    _isActiveAction(action: IAnimationAction): boolean;
+    _addInactiveAction(action: IAnimationAction, clipUuid: string, rootUuid: string): void;
+    _removeInactiveAction(action: IAnimationAction): void;
+    _removeInactiveBindingsForAction(action: IAnimationAction): void;
+    _lendAction(action: IAnimationAction): void;
+    _takeBackAction(action: IAnimationAction): void;
+    _addInactiveBinding(binding: IPropertyMixer, rootUuid: string, trackName: string): void;
+    _removeInactiveBinding(binding: IPropertyMixer): void;
+    _lendBinding(binding: IPropertyMixer): void;
+    _takeBackBinding(binding: IPropertyMixer): void;
+    _lendControlInterpolant(): IInterpolant;
+    _takeBackControlInterpolant(interpolant: IInterpolant): void;
+    clipAction(clip: string | IAnimationClip, optionalRoot?: IObject2, blendMode?: number): IAnimationAction | undefined;
+    existingAction(clip: string | IAnimationClip, optionalRoot: IObject2): IAnimationAction | undefined;
+    removeAction(action?: IAnimationAction): void;
+    stopAllAction(): this;
+    update(deltaTime: number): this;
+    setTime(timeInSeconds: number): this;
+    getRoot(): IObject2 | undefined;
+    uncacheClip(clip: IAnimationClip): void;
+    uncacheRoot(root: IObject2): void;
+    uncacheAction(clip: IAnimationClip, optionalRoot: IObject2): void;
+}

package/lib/animations/animation-utils.d.ts

@@ -0,0 +1,7 @@
+import { TKeyframeTrackValues } from '../interfaces';
+export declare const isTypedArray: (object: any) => boolean;
+export declare const arraySlice: <T extends TKeyframeTrackValues>(array: T, from?: number, to?: number) => T;
+export declare const convertArray: <T extends TKeyframeTrackValues>(array: TKeyframeTrackValues, type: Float32ArrayConstructor | ArrayConstructor, forceClone?: boolean) => T;
+export declare const getKeyframeOrder: (times: number[]) => number[];
+export declare const sortedArray: (values: Array<number>, stride: number, orders: Array<number>) => Array<number>;
+export declare const flattenJSON: (jsonKeys: any[], times: number[], values: number[], valuePropertyName: string) => void;

package/lib/animations/keyframe-track.d.ts

@@ -0,0 +1,33 @@
+import { IInterpolant, IKeyframeTrack, ITrack, TKeyframeTrackValues } from '../interfaces';
+export declare const InterpolateDiscrete = 2300;
+export declare const InterpolateLinear = 2301;
+export declare const InterpolateSmooth = 2302;
+type InterpolantFactory = (this: KeyframeTrack, result: Float32Array) => (IInterpolant | undefined);
+export declare abstract class KeyframeTrack implements IKeyframeTrack {
+    name: string;
+    times: Float32Array;
+    values: TKeyframeTrackValues;
+    ValueTypeName: string;
+    ValueBufferType: Float32ArrayConstructor | ArrayConstructor;
+    DefaultInterpolation: number;
+    createInterpolant: InterpolantFactory;
+    InterpolantFactoryMethodDiscrete: ((result?: Float32Array) => IInterpolant) | undefined;
+    InterpolantFactoryMethodLinear: ((result?: Float32Array) => IInterpolant) | undefined;
+    InterpolantFactoryMethodSmooth: ((result?: Float32Array) => IInterpolant) | undefined;
+    constructor(name: string, times: number[], values: any[], interpolation?: number);
+    static DefaultInterpolation: number;
+    static toJSON(track: IKeyframeTrack): ITrack;
+    _InterpolantFactoryMethodDiscrete(result?: Float32Array): IInterpolant;
+    _InterpolantFactoryMethodLinear(result?: Float32Array): IInterpolant;
+    _InterpolantFactoryMethodSmooth(result?: Float32Array): IInterpolant;
+    getValueSize(): number;
+    setInterpolation(interpolation: number): this;
+    getInterpolation(): number | undefined;
+    shift(timeOffset: number): this;
+    scale(timeScale: number): this;
+    trim(startTime: number, endTime: number): this;
+    validate(): boolean;
+    optimize(): this;
+    clone(): IKeyframeTrack;
+}
+export {};

package/lib/animations/property-binding.d.ts

@@ -0,0 +1,68 @@
+import { IAnimationObjectGroup, IObject2, IParsedTrack, IPropertyBinding, TKeyframeTrackValues } from '../interfaces';
+export declare class PropertyBinding implements IPropertyBinding {
+    path: string;
+    parsedPath: IParsedTrack;
+    node: IObject2 | undefined;
+    rootNode: IObject2;
+    getValue: (targetArray: TKeyframeTrackValues, offset: number) => void;
+    setValue: (sourceArray: TKeyframeTrackValues, offset: number) => void;
+    targetObject: IObject2 | undefined;
+    propertyName: string | undefined;
+    resolvedProperty: any;
+    propertyIndex: number;
+    BindingType: IPropertyBindingType;
+    Versioning: IPropertyVersioning;
+    GetterByBindingType: ((buffer: TKeyframeTrackValues, offset: number) => void)[];
+    SetterByBindingTypeAndVersioning: ((buffer: TKeyframeTrackValues, offset: number) => void)[][];
+    constructor(rootNode: IObject2, path: string, parsedPath?: IParsedTrack);
+    static create(root: IObject2 | IAnimationObjectGroup, path: string, parsedPath?: IParsedTrack): IPropertyBinding;
+    /**
+     * Replaces spaces with underscores and removes unsupported characters from
+     * node names, to ensure compatibility with parseTrackName().
+     *
+     * @param {string} name Node name to be sanitized.
+     * @return {string}
+     */
+    static sanitizeNodeName(name: string): string;
+    static parseTrackName(trackName: string): IParsedTrack;
+    static findNode(root: IObject2, nodeName: string | number): IObject2 | undefined;
+    _getValue_unavailable(): void;
+    _setValue_unavailable(): void;
+    _getValue_direct(buffer: TKeyframeTrackValues, offset: number): void;
+    _getValue_array(buffer: TKeyframeTrackValues, offset: number): void;
+    _getValue_arrayElement(buffer: TKeyframeTrackValues, offset: number): void;
+    _getValue_toArray(buffer: TKeyframeTrackValues, offset: number): void;
+    _getValue_color(buffer: TKeyframeTrackValues, offset: number): void;
+    _setValue_direct(buffer: TKeyframeTrackValues, offset: number): void;
+    _setValue_direct_setNeedsUpdate(buffer: TKeyframeTrackValues, offset: number): void;
+    _setValue_direct_setMatrixWorldNeedsUpdate(buffer: TKeyframeTrackValues, offset: number): void;
+    _setValue_array(buffer: TKeyframeTrackValues, offset: number): void;
+    _setValue_array_setNeedsUpdate(buffer: TKeyframeTrackValues, offset: number): void;
+    _setValue_array_setMatrixWorldNeedsUpdate(buffer: TKeyframeTrackValues, offset: number): void;
+    _setValue_arrayElement(buffer: TKeyframeTrackValues, offset: number): void;
+    _setValue_arrayElement_setNeedsUpdate(buffer: TKeyframeTrackValues, offset: number): void;
+    _setValue_arrayElement_setMatrixWorldNeedsUpdate(buffer: TKeyframeTrackValues, offset: number): void;
+    _setValue_fromArray(buffer: TKeyframeTrackValues, offset: number): void;
+    _setValue_fromArray_setNeedsUpdate(buffer: TKeyframeTrackValues, offset: number): void;
+    _setValue_fromArray_setMatrixWorldNeedsUpdate(buffer: TKeyframeTrackValues, offset: number): void;
+    _setValue_color(buffer: TKeyframeTrackValues, offset: number): void;
+    _setValue_color_setNeedsUpdate(buffer: TKeyframeTrackValues, offset: number): void;
+    _setValue_color_setMatrixWorldNeedsUpdate(buffer: TKeyframeTrackValues, offset: number): void;
+    _getValue_unbound(targetArray: TKeyframeTrackValues, offset: number): void;
+    _setValue_unbound(sourceArray: TKeyframeTrackValues, offset: number): void;
+    bind(): void;
+    unbind(): void;
+}
+interface IPropertyBindingType {
+    Direct: number;
+    EntireArray: number;
+    ArrayElement: number;
+    HasFromToArray: number;
+    ColorString: number;
+}
+interface IPropertyVersioning {
+    None: number;
+    NeedsUpdate: number;
+    MatrixWorldNeedsUpdate: number;
+}
+export {};

package/lib/animations/property-mixer.d.ts

@@ -0,0 +1,29 @@
+import { IPropertyBinding, IPropertyMixer, TKeyframeTrackValues } from '../interfaces';
+export declare class PropertyMixer implements IPropertyMixer {
+    binding: IPropertyBinding;
+    valueSize: number;
+    buffer: TKeyframeTrackValues;
+    _workIndex: number;
+    _mixBufferRegion: Function;
+    _mixBufferRegionAdditive: Function;
+    _setIdentity: Function;
+    _origIndex: number;
+    _addIndex: number;
+    _cacheIndex: number | undefined;
+    cumulativeWeight: number;
+    cumulativeWeightAdditive: number;
+    useCount: number;
+    referenceCount: number;
+    constructor(binding: IPropertyBinding, typeName: string, valueSize: number);
+    accumulate(accuIndex: number, weight: number): void;
+    accumulateAdditive(weight: number): void;
+    apply(accuIndex: number): void;
+    saveOriginalState(): void;
+    restoreOriginalState(): void;
+    _setAdditiveIdentityNumeric(): void;
+    _setAdditiveIdentityQuaternion(): void;
+    _setAdditiveIdentityOther(): void;
+    _select(buffer: Float64Array, dstOffset: number, srcOffset: number, t: number, stride: number): void;
+    _lerp(buffer: Float64Array, dstOffset: number, srcOffset: number, t: number, stride: number): void;
+    _lerpAdditive(buffer: Float64Array, dstOffset: number, srcOffset: number, t: number, stride: number): void;
+}

package/lib/animations/tracks/boolean-keyframe-track.d.ts

@@ -0,0 +1,5 @@
+import { KeyframeTrack } from '../keyframe-track';
+export declare class BooleanKeyframeTrack extends KeyframeTrack {
+    ValueTypeName: string;
+    DefaultInterpolation: number;
+}

package/lib/animations/tracks/color-keyframe-track.d.ts

@@ -0,0 +1,4 @@
+import { KeyframeTrack } from '../keyframe-track';
+export declare class ColorKeyframeTrack extends KeyframeTrack {
+    ValueTypeName: string;
+}

package/lib/animations/tracks/number-keyframe-track.d.ts

@@ -0,0 +1,4 @@
+import { KeyframeTrack } from '../keyframe-track';
+export declare class NumberKeyframeTrack extends KeyframeTrack {
+    ValueTypeName: string;
+}

package/lib/animations/tracks/string-keyframe-track.d.ts

@@ -0,0 +1,5 @@
+import { KeyframeTrack } from '../keyframe-track';
+export declare class StringKeyframeTrack extends KeyframeTrack {
+    ValueTypeName: string;
+    DefaultInterpolation: number;
+}

package/lib/animations/tracks/vector1-keyframe-track.d.ts

@@ -0,0 +1,4 @@
+import { KeyframeTrack } from '../keyframe-track';
+export declare class Vector1KeyframeTrack extends KeyframeTrack {
+    ValueTypeName: string;
+}

package/lib/animations/tracks/vector2-keyframe-track.d.ts

@@ -0,0 +1,4 @@
+import { KeyframeTrack } from '../keyframe-track';
+export declare class Vector2KeyframeTrack extends KeyframeTrack {
+    ValueTypeName: string;
+}

package/lib/applications/app-cvs.d.ts

@@ -1,25 +1,37 @@
 import { Application, IApplicationConfig } from './application';
 import { MainScene } from '../scenes/main-scene';
-import { IEvent, IObject2, ITree } from '../interfaces';
+import { IBox2, IEvent, IObject2, ITree } from '../interfaces';
 import { Adapter } from '../extras/adapter';
+import { AnimateScene } from '../scenes/animate-scene';
+import { AppDirector } from './app-director';
 export declare class AppCvs<Config extends IApplicationConfig> extends Application<Config> {
     params: Config;
     adapter: Adapter;
     private dynamicLoadedHandler;
     private initializationCompleteHandler;
     mainScene: MainScene<Config>;
+    animateScene: AnimateScene<Config>;
+    director: AppDirector<Config>;
     private _url?;
     private _layers?;
     private _tic?;
     private _t;
+    private rayCaster;
+    private intersects;
+    private readonly _cameraChangedHandler;
     constructor(config?: Config);
     destroy(): void;
+    bindEvents(): void;
+    unbindEvents(): void;
+    handleCameraChanged(): void;
     trans2LoadingScene(): Promise<void>;
     load(url?: string, layers?: string[]): Promise<void>;
     pushResources2Scene(res?: IObject2[]): void;
     reload(): Promise<void>;
     /** overwrite */
+    assetTypeChanged(v?: string): void;
     usedCacheChanged(v?: boolean): Promise<void>;
+    bgPassChanged(v?: boolean): Promise<void>;
     getLayers(lv?: number): ITree[];
     trans2MainScene(): void;
     bindAdapterEvents(): void;
@@ -27,7 +39,19 @@ export declare class AppCvs<Config extends IApplicationConfig> extends Applicati
     handleDynamicLoaded(e: IEvent): void;
     handleInitializationComplete(e: IEvent): void;
     fullScreen(): void;
+    handleViewTap(e: any, out?: IObject2[]): IObject2[];
     updateLayersVisibility(ids: string | string[], visible?: boolean): void;
+    selectByIds(ids: string | string[]): void;
+    clearSelected(ids?: string | string[]): void;
+    multiSelectByRange(box: IBox2): void;
+    targetByIds(ids: string | string[]): Promise<void>;
+    getAssetIdsByType(assetType: string): string[] | undefined;
+    setFillByIds(ids: string[], c: string): void;
+    clearFill(): void;
+    setStrokeByIds(ids: string[], c: string): void;
+    clearStroke(): void;
+    fontZoomIn(v?: number): void;
+    fontZoomOut(v?: number): void;
     /** overwrite */
     running(time: DOMHighResTimeStamp): void;
 }

package/lib/applications/app-director.d.ts

@@ -0,0 +1,22 @@
+import { EffectDirector } from '../effects/effect-director';
+import { IAnimationAction, IAnimationClip, IBox2, IObject2, IScene } from '../interfaces';
+import { IApplicationConfig } from './application';
+export declare class AppDirector<Config extends IApplicationConfig> extends EffectDirector {
+    name: string;
+    params: IApplicationConfig;
+    _selectedClip: IAnimationClip;
+    selectedAction?: IAnimationAction;
+    _selectedIds: string[];
+    constructor(config?: Config);
+    destroy(): void;
+    /** @override */
+    bind(oriScene?: IScene, desScene?: IScene): void;
+    hasSelected(id: string): boolean;
+    clearSelected(ids?: string | string[]): void;
+    selectByIds(ids: string | string[], toggle?: boolean): void;
+    toggleSelectByIds(ids: string | string[], toggle?: boolean): void;
+    multiSelectByRange(box: IBox2, toggle?: boolean): void;
+    /** @override */
+    update(): void;
+    updateGlobalSelectAnimate(o?: IObject2): void;
+}

package/lib/applications/app-offscreen.d.ts

@@ -1,6 +1,6 @@
 import { IApplicationConfig } from './application';
 import { OpeView } from '../core/ope-view';
-import { APP_ENUM, ITree } from '../interfaces';
+import { APP_ENUM, IEvent, ITree } from '../interfaces';
 import { default as EventDispatcher } from '../core/event-dispatcher';
 import { default as Box2 } from '../math/box2';
 export declare class AppOffscreen<Config extends IApplicationConfig> extends EventDispatcher {
@@ -9,6 +9,8 @@ export declare class AppOffscreen<Config extends IApplicationConfig> extends Eve
     worker: Worker;
     view: OpeView<Config>;
     boundingBox: Box2;
+    private readonly viewTapHandler;
+    private readonly multiSelectByRangeHandler;
     readonly workerMessageHandler: (e: MessageEvent) => void;
     readonly cameraHandler: (e: MessageEvent) => void;
     readonly runningHandler: (time: DOMHighResTimeStamp) => void;
@@ -16,20 +18,38 @@ export declare class AppOffscreen<Config extends IApplicationConfig> extends Eve
     destroy(): void;
     bindEvents(): void;
     unbindEvents(): void;
+    handleViewTap(e: IEvent): Promise<void>;
     handleWorkerMessage(e: MessageEvent): void;
     handleCameraChanged(e: MessageEvent): void;
-    promiseWorkerResponse<T>(task: APP_ENUM, data: any): Promise<T>;
+    promiseWorkerResponse<T>(task: APP_ENUM, data?: any): Promise<T>;
+    handleMultiSelectByRange(e: any): Promise<void>;
     resize(): void;
     load(url: string, layers?: string[]): Promise<void>;
     getLayers(lv?: number): Promise<ITree[]>;
+    assetTypeChanged(v?: string): void;
     usedCacheChanged(v?: boolean): void;
     debounceCacheChanged(v?: boolean): void;
     wireframeChanged(v?: boolean): void;
+    bgPassChanged(v?: boolean): void;
+    selectEnableChanged(v?: boolean): Promise<void>;
+    multiSelectEnableChanged(v?: boolean): Promise<void>;
+    zoomToSelectEnableChanged(v?: boolean): Promise<void>;
+    svgLoadingTypeChanged(v: number): Promise<void>;
     fullscreen(): Promise<void>;
     saveCameraPosition(id?: string): void;
     restoreCameraPosition(id?: string): void;
     clearCameraPosition(id?: string): void;
     updateLayersVisibility(ids: string | string[], visible?: boolean): void;
+    clearSelected(ids?: string | string[]): Promise<void>;
+    selectByIds(ids: string | string[]): void;
+    targetByIds(ids: string | string[]): void;
+    getAssetIdsByType(assetType: string): Promise<string[] | undefined>;
+    setFillByIds(ids: string[], c: string): void;
+    clearFill(): void;
+    setStrokeByIds(ids: string[], c: string): void;
+    clearStroke(): void;
+    fontZoomIn(v?: number): Promise<void>;
+    fontZoomOut(v?: number): Promise<void>;
     start(): void;
     running(time: DOMHighResTimeStamp): void;
     stop(): void;

package/lib/applications/application.d.ts

@@ -8,6 +8,13 @@ export interface IApplicationConfig extends IRenderer2Config {
     frameInterval?: number;
     syncDelay?: number;
     animateDuration?: number;
+    assetType: string;
+    svgLoadingType: number;
+    selectEnable?: boolean;
+    multiSelectEnable?: boolean;
+    zoomToSelectEnable?: boolean;
+    bgPass?: boolean;
+    axesHelper?: any;
     defaultFill?: string;
     defaultStroke?: string;
     infoFill?: string;
@@ -42,7 +49,12 @@ export declare abstract class Application<Config extends IApplicationConfig> ext
     get isLoadingScene(): boolean;
     destroy(): void;
     usedCacheChanged(v?: boolean): Promise<void>;
+    svgLoadingTypeChanged(v: number): void;
     wireframeChanged(v?: boolean): void;
+    bgPassChanged(v?: boolean): void;
+    selectEnableChanged(v?: boolean): void;
+    multiSelectEnableChanged(v?: boolean): void;
+    zoomToSelectEnableChanged(v?: boolean): void;
     trans2LoadingScene(): Promise<void>;
     hasScene(scene: Scene): boolean;
     pushScene(scene: Scene): void;

package/lib/core/camera2.d.ts

@@ -43,13 +43,13 @@ export default class Camera2<Config extends ICamera2Config> extends Object2 impl
     updateMatrixWorld(force?: boolean): void;
     updateProjectionMatrix(): void;
     updateViewMatrix(): void;
-    update(): void;
+    update(dispatch?: boolean): void;
     computeBoundingBox(): Box2;
     updateBoundingBox(): void;
     toJSON(): any;
     fromJSON(o: any): void;
     clone(): any;
-    copy(source: Camera2<Config>, recursive?: boolean): IObject2;
+    copy(source: Camera2<Config>, recursive?: boolean, deep?: boolean): IObject2;
 }
 export declare enum CAMERA_ENUM {
     UPDATE = "update"

package/lib/core/object2.d.ts

@@ -93,11 +93,12 @@ export declare class Object2 extends EventDispatcher implements IObject2 {
     traverse(callback: Function): void;
     traverseVisible(callback: Function): void;
     traverseAncestors(callback: Function): void;
-    onBeforeRender(renderer: any, scene: IObject2, camera?: ICamera2): void;
+    onBeforeRender(renderer: any, scene: IObject2, camera?: ICamera2, deltaTime?: number): void;
     render(ctx: IContext2D): void;
     onAfterRender(renderer: any, scene: IObject2, camera?: ICamera2): void;
     setSelectable(v: boolean): void;
     raycast(raycaster: IRaycaster, out?: IObject2[]): IObject2[];
-    clone(recursive?: boolean): IObject2;
-    copy(source: IObject2, recursive?: boolean): IObject2;
+    getByRange(box: IBox2, recursive?: boolean, out?: IObject2[]): IObject2[];
+    clone(recursive?: boolean, deep?: boolean): IObject2;
+    copy(source: IObject2, recursive?: boolean, deep?: boolean): IObject2;
 }

package/lib/core/ope-view.d.ts

@@ -1,8 +1,10 @@
-import { ICamera2, ICamera2Config, ICanvas, IRenderer2Config } from '../interfaces';
+import { ICamera2Config, ICanvas, IEvent, IObject2, IRenderer2Config } from '../interfaces';
 import { IOrbitControlsConfig } from '../controls/orbit-controls';
 import { OrbitController } from '../controls/orbit-controller';
 import { IAxesHelperConfig } from '../helpers/axes-helper';
 import { View } from './view';
+import { RayCaster } from './ray-caster';
+import { DynamicDrawRect } from '../extras/dynamic-draw-rect';
 export interface IViewConfig extends IRenderer2Config {
     name?: string;
     cvs?: ICanvas;
@@ -12,13 +14,32 @@ export interface IViewConfig extends IRenderer2Config {
     alignStageCenter?: boolean;
 }
 /**
+ * Operate view
  * @author Dio Zhu 2024.8.22
  */
 export declare class OpeView<Config extends IViewConfig> extends View<Config> {
     name: string;
     controller: OrbitController;
+    container: HTMLElement;
+    graph: DynamicDrawRect;
+    zoomToSelectEnable?: boolean;
+    multiSelectEnable?: boolean;
+    rayCaster: RayCaster;
+    intersects: IObject2[];
+    private controllerPanStartHandler;
+    private controllerPanEndHandler;
+    private controllerPanMoveHandler;
+    private controllerPointerOverHandler;
     constructor(config?: Config);
     destroy(): void;
-    initController(camera?: ICamera2): void;
+    zoomToSelectEnableChanged(v?: boolean): void;
+    multiSelectEnableChanged(v?: boolean): void;
+    bindControllerEvents(): void;
+    unbindControllerEvents(): void;
+    handlePanStart(e: IEvent): void;
+    handlePanEnd(e: IEvent): Promise<void>;
+    handleControllerPanMove(e: IEvent): void;
+    handleControllerPointerOver(e: IEvent): void;
+    handleMultiSelectorSelected(e: IEvent): void;
     handleCameraChanged(e: any): void;
 }

package/lib/core/tic.d.ts

@@ -2,6 +2,7 @@ export declare class Tic {
     duration: number;
     generator?: Generator<undefined, void, unknown>;
     t: number | null;
+    private stopped;
     constructor(list: number | any[], callback: Function, duration?: number);
     next(): void;
     queue(len: number, callback: Function): Generator<undefined, void, unknown>;

package/lib/core/view.d.ts

@@ -5,6 +5,7 @@ import { OrbitController } from '../controls/orbit-controller';
 import { default as Box2 } from '../math/box2';
 import { IAxesHelperConfig } from '../helpers/axes-helper';
 import { Tween } from '@tweenjs/tween.js';
+import { default as EventDispatcher } from './event-dispatcher';
 export interface IViewConfig extends IRenderer2Config {
     name?: string;
     cvs?: ICanvas;
@@ -17,7 +18,7 @@ export interface IViewConfig extends IRenderer2Config {
 /**
  * @author Dio Zhu 2024.8.22
  */
-export declare class View<Config extends IViewConfig> implements IView {
+export declare class View<Config extends IViewConfig> extends EventDispatcher implements IView {
     name: string;
     params: Config;
     visible: boolean;

package/lib/effects/debounce-pass.d.ts

@@ -6,8 +6,18 @@ export declare class DebouncePass extends Pass {
     scene: Scene;
     camera: ICamera2 | undefined;
     fsQuad: FullScreenQuad;
+    debounceQuad: FullScreenQuad;
+    cacheQuad: FullScreenQuad;
     version: number;
+    private debounceRenderHandler;
     constructor(scene: Scene, camera?: ICamera2, clear?: boolean, needsSwap?: boolean);
+    destroy(): void;
     get currentVersion(): number;
+    get isChanged(): boolean;
+    get isDebounceChanged(): boolean;
     render(renderer: IRenderer2, writeBuffer: IRenderTarget, readBuffer: IRenderTarget): void;
+    saveCache(org: FullScreenQuad, dst: FullScreenQuad): void;
+    renderCache(org: FullScreenQuad, dst: FullScreenQuad): void;
+    finalRender(org: FullScreenQuad, renderer: IRenderer2, writeBuffer: IRenderTarget, readBuffer: IRenderTarget): void;
+    debounceRender(renderer: IRenderer2, writeBuffer: IRenderTarget, readBuffer: IRenderTarget): void;
 }

package/lib/effects/effect-director.d.ts

@@ -0,0 +1,16 @@
+import { Clock } from '../core/clock';
+import { AnimationMixer } from '../animations/animation-mixer';
+import { IScene } from '../interfaces';
+import { default as Box2 } from '../math/box2';
+export declare class EffectDirector {
+    name: string;
+    clock: Clock;
+    oriScene?: IScene;
+    desScene?: IScene;
+    mixer?: AnimationMixer;
+    constructor();
+    destroy(): void;
+    bind(oriScene?: IScene, desScene?: IScene): void;
+    getBoundingBoxByIds(ids: string | string[], out?: Box2): Box2;
+    update(): void;
+}

package/lib/effects/paper-pass.d.ts

@@ -0,0 +1,13 @@
+import { ICamera2, IRenderer2, IRenderTarget } from '../interfaces';
+import { FullScreenQuad, Pass } from './pass';
+export declare class PaperPass extends Pass {
+    name: string;
+    fsQuad: FullScreenQuad;
+    ctx: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D;
+    camera: ICamera2 | undefined;
+    version: number;
+    constructor(camera?: ICamera2);
+    destroy(): void;
+    get currentVersion(): number;
+    render(renderer: IRenderer2, writeBuffer: IRenderTarget, readBuffer: IRenderTarget): void;
+}

package/lib/effects/pass.d.ts

@@ -25,6 +25,7 @@ export declare class FullScreenQuad {
     width: number;
     height: number;
     dpr: number;
+    version: number;
     constructor();
     destroy(): void;
     render(renderer: IRenderer2): void;

package/lib/effects/render-cached-pass.d.ts

@@ -7,9 +7,7 @@ export declare class RenderCachedPass extends Pass {
     camera: ICamera2 | undefined;
     fsQuad: FullScreenQuad;
     version: number;
-    private debounceRenderHandler;
     constructor(scene: Scene, camera?: ICamera2, clear?: boolean, needsSwap?: boolean);
     get currentVersion(): number;
     render(renderer: IRenderer2, writeBuffer: IRenderTarget, readBuffer: IRenderTarget): void;
-    handleDebounceRender(renderer: IRenderer2, writeBuffer: IRenderTarget, readBuffer: IRenderTarget): void;
 }