archgine 1.0.38 → 1.0.40

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

@@ -1,11 +1,16 @@
-import { Application } from './application';
-import { IAppOffscreenConfig } from './app-offscreen';
+import { Application, IApplicationConfig } from './application';
 import { MainScene } from '../scenes/main-scene';
-export declare class AppCvs<Config extends IAppOffscreenConfig> extends Application<Config> {
+import { ITree } from '../interfaces';
+import { Adapter } from '../extras/adapter';
+export declare class AppCvs<Config extends IApplicationConfig> extends Application<Config> {
     params: Config;
+    adapter: Adapter;
     mainScene: MainScene<Config>;
     constructor(config?: Config);
     destroy(): void;
     load(url?: string, layers?: string[]): Promise<void>;
+    getLayers(lv?: number): ITree[];
     trans2MainScene(): void;
+    fullScreen(): void;
+    updateLayersVisibility(ids: string | string[], visible?: boolean): void;
 }

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

@@ -1,19 +1,33 @@
 import { IApplicationConfig } from './application';
 import { OpeView } from '../core/ope-view';
-export interface IAppOffscreenConfig extends IApplicationConfig {
-}
-export declare class AppOffscreen<Config extends IAppOffscreenConfig> {
+import { APP_ENUM, 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 {
     params: Config;
     cvs: OffscreenCanvas;
     worker: Worker;
     view: OpeView<Config>;
+    boundingBox: Box2;
     readonly workerMessageHandler: (e: MessageEvent) => void;
-    constructor(config?: Config);
+    readonly cameraHandler: (e: MessageEvent) => void;
+    readonly runningHandler: (time: DOMHighResTimeStamp) => void;
+    constructor(config: Config | undefined, worker: Worker);
     destroy(): void;
     bindEvents(): void;
     unbindEvents(): void;
     handleWorkerMessage(e: MessageEvent): void;
+    handleCameraChanged(e: MessageEvent): void;
+    promiseWorkerResponse<T>(task: APP_ENUM, data: any): Promise<T>;
     resize(): void;
-    load(url: string, layers?: string[], lv?: number): Promise<void>;
+    load(url: string, layers?: string[]): Promise<void>;
+    getLayers(lv?: number): Promise<ITree[]>;
+    fullscreen(): Promise<void>;
+    saveCameraPosition(id?: string): void;
+    restoreCameraPosition(id?: string): void;
+    clearCameraPosition(id?: string): void;
+    updateLayersVisibility(ids: string | string[], visible?: boolean): void;
     start(): void;
+    running(time: DOMHighResTimeStamp): void;
+    stop(): void;
 }

package/lib/applications/application.d.ts

@@ -8,6 +8,20 @@ export interface IApplicationConfig extends IRenderer2Config {
     frameInterval?: number;
     syncDelay?: number;
     animateDuration?: number;
+    defaultFill?: string;
+    defaultStroke?: string;
+    infoFill?: string;
+    infoStroke?: string;
+    primaryFill?: string;
+    primaryStroke?: string;
+    successFill?: string;
+    successStroke?: string;
+    warningFill?: string;
+    warningStroke?: string;
+    dangerFill?: string;
+    dangerStroke?: string;
+    activeFill?: string;
+    activeStroke?: string;
 }
 /**
  * @author Dio Zhu
@@ -25,8 +39,8 @@ export declare abstract class Application<Config extends IApplicationConfig> ext
     view: View<any>;
     readonly runningHandler: (time: DOMHighResTimeStamp) => void;
     protected constructor(config?: Config);
-    destroy(): void;
     get isLoadingScene(): boolean;
+    destroy(): void;
     trans2LoadingScene(): void;
     hasScene(scene: Scene): boolean;
     pushScene(scene: Scene): void;

package/lib/controls/orbit-controller.d.ts

@@ -152,5 +152,6 @@ export declare enum EventsEnum {
     PINCH_OUT = "pinchout",
     SWIPE = "swipe",
     CHANGE_START = "change_start",
-    CHANGE_END = "change_end"
+    CHANGE_END = "change_end",
+    CAMERA_CHANGED = "cameraChanged"
 }

package/lib/core/camera2.d.ts

@@ -1,5 +1,5 @@
 import { default as Vector2 } from '../math/vector2';
-import { ICamera2, ICamera2Config, ICamera2Position, IObject2, IVector2 } from '../interfaces';
+import { ICamera2, ICamera2Config, ICamera2Position, IObject2, IPoint2, IVector2 } from '../interfaces';
 import { default as Matrix3 } from '../math/matrix3';
 import { Object2 } from './object2';
 import { default as Box2 } from '../math/box2';
@@ -34,6 +34,7 @@ export default class Camera2<Config extends ICamera2Config> extends Object2 impl
     get pixelWidth(): number;
     set(l?: number, r?: number, t?: number, b?: number): void;
     setByBox(box: Box2): void;
+    setTRS(t?: IPoint2, r?: number, s?: number): void;
     resize(): void;
     setSize(w: number, h: number): void;
     getWorldDirection(target: Vector2): Vector2;

package/lib/core/monitor.d.ts

@@ -9,6 +9,13 @@ interface IMonitorRecord {
 }
 export declare class Monitor {
     static idCounter: number;
+    static children: Monitor[];
+    static isRunning: boolean;
+    static actived: boolean;
+    static duration: number;
+    static lastTime: number;
+    static messages: IMonitorRecord[];
+    static maxLetters: number;
     id: number;
     timers: Map<string, number[]>;
     timersDuration: Map<string, number>;
@@ -16,6 +23,12 @@ export declare class Monitor {
     countersAmount: Map<string, number>;
     out: IMonitorRecord[];
     constructor();
+    static active(duration?: number): void;
+    static add(o: Monitor): void;
+    static remove(o: Monitor): void;
+    static handleStart(): void;
+    static runLoop(): void;
+    static runFrames(): void;
     destroy(): void;
     addTimer(key: string, t?: number, duration?: number): void;
     addTimerDuration(key: string, duration: number): void;
@@ -34,18 +47,5 @@ export declare class Monitor {
     stdDev(durations: number[], avg: number): number;
     fd(d: number): string;
     fx(d: number, l?: number): number;
-    static children: Monitor[];
-    static isRunning: boolean;
-    static actived: boolean;
-    static duration: number;
-    static lastTime: number;
-    static messages: IMonitorRecord[];
-    static maxLetters: number;
-    static active(duration?: number): void;
-    static add(o: Monitor): void;
-    static remove(o: Monitor): void;
-    static handleStart(): void;
-    static runLoop(): void;
-    static runFrames(): void;
 }
 export {};

package/lib/core/object2.d.ts

@@ -1,5 +1,5 @@
 import { default as EventDispatcher } from './event-dispatcher';
-import { IAnimationClip, IBox2, ICamera2, IObject2, IPoint2, IVector2 } from '../interfaces';
+import { IAnimationClip, IBox2, ICamera2, IMatrix3, IObject2, IPoint2, IVector2 } from '../interfaces';
 import { default as Vector2 } from '../math/vector2';
 import { default as Matrix3 } from '../math/matrix3';
 import { default as Box2 } from '../math/box2';
@@ -16,7 +16,6 @@ export declare class Object2 extends EventDispatcher implements IObject2 {
     name: string;
     type: string;
     featureKey: string;
-    _version: number;
     parent: IObject2 | undefined;
     children: IObject2[];
     up: Vector2;
@@ -49,13 +48,14 @@ export declare class Object2 extends EventDispatcher implements IObject2 {
     animations: IAnimationClip[];
     finalSize?: IPoint2;
     userData: any;
-    [prop: string]: any;
     DefaultUp: Vector2;
+    [prop: string]: any;
     private _autoSort;
     constructor(config?: IObject2Config);
-    set needsUpdate(v: boolean);
+    _version: number;
     get version(): number;
     set version(v: number);
+    set needsUpdate(v: boolean);
     destroy(): void;
     setPosition(v: IVector2): this;
     translate(x: number, y: number): void;
@@ -67,7 +67,7 @@ export declare class Object2 extends EventDispatcher implements IObject2 {
     localToWorld(v: Vector2): Vector2;
     worldToLocal(v: Vector2): Vector2;
     lookAt(v: Vector2): void;
-    applyMatrix3(matrix: Matrix3): void;
+    applyMatrix3(matrix: IMatrix3): void;
     updateMatrix(): void;
     updateMatrixWorld(force?: boolean): void;
     updateWorldMatrix(updateParents?: boolean, updateChildren?: boolean): void;

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

@@ -1,9 +1,8 @@
-import { IBox2, ICamera2, ICamera2Config, ICanvas, IRenderer2Config, IView } from '../interfaces';
+import { ICamera2, ICamera2Config, ICanvas, IRenderer2Config } from '../interfaces';
 import { IOrbitControlsConfig } from '../controls/orbit-controls';
-import { default as Scene } from '../scenes/scene';
 import { OrbitController } from '../controls/orbit-controller';
-import { default as Box2 } from '../math/box2';
 import { IAxesHelperConfig } from '../helpers/axes-helper';
+import { View } from './view';
 export interface IViewConfig extends IRenderer2Config {
     name?: string;
     cvs?: ICanvas;
@@ -15,26 +14,11 @@ export interface IViewConfig extends IRenderer2Config {
 /**
  * @author Dio Zhu 2024.8.22
  */
-export declare class OpeView<Config extends IViewConfig> implements IView {
+export declare class OpeView<Config extends IViewConfig> extends View<Config> {
     name: string;
-    params: Config;
-    visible: boolean;
-    cvs: ICanvas | undefined;
-    scene: Scene | undefined;
-    scenes: Scene[];
-    camera: ICamera2 | undefined;
-    controller?: OrbitController;
+    controller: OrbitController;
     constructor(config?: Config);
     destroy(): void;
-    initController(camera?: ICamera2, dom?: HTMLElement): void;
+    initController(camera?: ICamera2): void;
     handleCameraChanged(e: any): void;
-    reset(): void;
-    bindScene(scene: Scene): void;
-    resetCameraByBoundingBox(box: IBox2, animate?: boolean): void;
-    computeScenesBoundingBox(scenes: Scene[], target?: Box2): Box2;
-    expandScenesBoundingBox(scenes: Scene[], box?: Box2): void;
-    /**
-     * @see Application.running
-     */
-    update(time?: DOMHighResTimeStamp): void;
 }

package/lib/core/view.d.ts

@@ -1,9 +1,10 @@
-import { IBox2, ICamera2, ICamera2Config, ICanvas, IRenderer2Config, IView } from '../interfaces';
+import { IBox2, ICamera2, ICamera2Config, ICamera2Position, ICanvas, IRenderer2Config, IView } from '../interfaces';
 import { IOrbitControlsConfig } from '../controls/orbit-controls';
 import { default as Scene } from '../scenes/scene';
 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';
 export interface IViewConfig extends IRenderer2Config {
     name?: string;
     cvs?: ICanvas;
@@ -11,6 +12,7 @@ export interface IViewConfig extends IRenderer2Config {
     controls?: IOrbitControlsConfig;
     axesHelper?: IAxesHelperConfig;
     alignStageCenter?: boolean;
+    animateDuration?: number;
 }
 /**
  * @author Dio Zhu 2024.8.22
@@ -22,19 +24,26 @@ export declare class View<Config extends IViewConfig> implements IView {
     cvs: ICanvas | undefined;
     scene: Scene | undefined;
     scenes: Scene[];
-    camera: ICamera2 | undefined;
+    camera: ICamera2;
     controller?: OrbitController;
+    tween?: Tween;
+    animateDuration: number;
     constructor(config?: Config);
     destroy(): void;
     bindScene(scene: Scene): void;
+    saveCameraPosition(id?: string): void;
+    clearCameraPosition(id?: string): void;
+    restoreCameraPosition(id?: string): void;
     fullscreen(padding?: number, animate?: boolean): void;
     handleCameraChanged(e: any): void;
     reset(): void;
-    resetCameraByBoundingBox(box: IBox2, animate?: boolean): void;
-    computeScenesBoundingBox(scenes: Scene[], target?: Box2): Box2;
+    resetCameraByBoundingBox(box: IBox2, animate?: boolean): Promise<void>;
+    animateCamera(from: ICamera2Position, to: ICamera2Position): Promise<void>;
+    computeBoundingBox(scenes: Scene[], target?: Box2): Box2;
     expandScenesBoundingBox(scenes: Scene[], box?: Box2): void;
     /**
      * @see Application.running
      */
     update(time?: DOMHighResTimeStamp): void;
 }
+export declare const CAMERA_SESSION_KEY = "camera_position_";

package/lib/environment.worker.js

@@ -11,6 +11,8 @@ var Pe = {
   fps: 60,
   syncDelay: 800,
   animateDuration: 600,
+  mergeRendering: !1,
+  // 合并渲染
   usedCache: !1,
   showPoints: !1,
   wireframe: !1,
@@ -3995,7 +3997,7 @@ Fu.__DOMHandler = Eu;
 Fu.normalizeLineEndings = Le;
 Fu.DOMParser = Ie;
 var gr = Fu.DOMParser;
-const Er = "1.0.38";
+const Er = "1.0.40";
 function vr() {
   return typeof window < "u" && ({}.toString.call(window) === "[object Window]" || {}.toString.call(window) === "[object global]");
 }

package/lib/extras/adapter.d.ts

@@ -1,21 +1,60 @@
 import { default as EventDispatcher } from '../core/event-dispatcher';
 import { default as Box2 } from '../math/box2';
-import { IShape2 } from '../interfaces';
+import { IObject2, ITree } from '../interfaces';
+import { IApplicationConfig } from '../applications/application';
 export declare class Adapter extends EventDispatcher {
     name: string;
+    params: IApplicationConfig;
     boundingBox: Box2;
-    resources: Record<string, IShape2[]>;
+    resources: Record<string, IObject2[]>;
+    _resourcesMap: Record<string, IObject2>;
+    _resourcesTree: ITree[];
     private _svg?;
     private _svgRoot?;
     private _viewBox;
     private _elementsMap;
-    constructor();
+    constructor(config?: IApplicationConfig);
     destroy(): void;
-    load(url: string, layers?: string[], lv?: number): Promise<void>;
+    clear(): void;
+    load(url: string, layers?: string[]): Promise<void>;
     init(str?: string): void;
+    /**
+     * background:
+     *    ...
+     *
+     * gros
+     * rm
+     *    ...
+     * gros-labels
+     * rm-labels
+     *    ...
+     */
     initResources(): void;
+    initResourcesTree(): void;
     initResource(id: string): void;
-    getElementById(id: string): Element | undefined;
+    getResources(): IObject2[] | undefined;
+    getLayers(lv?: number): ITree[];
+    getElementById(id?: string): Element | undefined;
+    getSymbolElement(el?: Element): Element | undefined;
+    trans2Shape(el?: Element, flipY?: boolean): IObject2 | undefined;
+    transG(el?: Element, flipY?: boolean): IObject2 | undefined;
+    transSymbol(el?: Element, flipY?: boolean): IObject2 | undefined;
+    transPath(el?: Element, flipY?: boolean): IObject2 | undefined;
+    transUse(el?: Element, flipY?: boolean): IObject2 | undefined;
+    transCircle(el?: Element, flipY?: boolean): IObject2 | undefined;
+    /**
+     * test linked to asset
+     * 1、old version: split with ';', use first；
+     * 2、new version: use 'aid' attribute；
+     * 3、use 'assetId' + SPLITTER + LABEL_TAG save to elementsMap;
+     */
+    transText(el?: Element, flipY?: boolean): IObject2 | undefined;
+    getAssetLabelId(assetId: string): string;
+    getResourceById(id?: string): IObject2 | undefined;
+    getResourceTreeById(t: ITree | ITree[], id?: string): ITree | undefined;
+    updateLayersVisibility(ids: string | string[], visible?: boolean): void;
+    _updateAllLayersVisibility(visible?: boolean): void;
+    _updateLayersVisibility(t: ITree, visible?: boolean): void;
 }
 export declare enum AdapterEnum {
     INITIALIZATION_START = "INITIALIZATION_START",

package/lib/extras/svg-app.d.ts

@@ -15,20 +15,6 @@ export interface ISvgAppConfig extends IApplicationConfig {
     selectEnable?: boolean;
     multiSelectEnable?: boolean;
     socialDistanceEnable?: boolean;
-    defaultFill?: string;
-    defaultStroke?: string;
-    infoFill?: string;
-    infoStroke?: string;
-    primaryFill?: string;
-    primaryStroke?: string;
-    successFill?: string;
-    successStroke?: string;
-    warningFill?: string;
-    warningStroke?: string;
-    dangerFill?: string;
-    dangerStroke?: string;
-    activeFill?: string;
-    activeStroke?: string;
 }
 export declare class SvgApp<Config extends ISvgAppConfig> extends EventDispatcher implements IApp {
     name: string;

package/lib/geometries/circle-geo2.d.ts

@@ -5,7 +5,7 @@ export interface ICircleGeo2 extends IGeo2Config {
     end?: number;
 }
 export declare class CircleGeo2<Config extends ICircleGeo2> extends Geo2<Config> {
-    readonly name: string;
+    readonly isCircle: boolean;
     radius: number;
     start: number;
     end: number;

package/lib/geometries/geo2.d.ts

@@ -4,18 +4,18 @@ import { IBox2, IContext2D, IGeo2, IMatrix3, IPath2Command, IPoint2 } from '../i
 export interface IGeo2Config {
     points?: IPoint2[];
     commands?: string | IPath2Command[];
+    flipY?: boolean;
 }
 export declare class Geo2<Config extends IGeo2Config> extends SVGPathData implements IGeo2 {
-    readonly name: string;
-    _version: number;
+    name: string;
     params: Config;
     viewMatrix: Matrix3;
     boundingBox: IBox2;
     constructor(config?: Config);
-    set needsUpdate(v: boolean);
+    _version: number;
     get version(): number;
     set version(v: number);
-    static getInstanceByPath(o: Element): Geo2<any> | undefined;
+    set needsUpdate(v: boolean);
     static render(ctx: IContext2D, commands: IPath2Command[]): void;
     setFromPoints(ps?: IPoint2[]): IGeo2;
     recomputePath(): void;

package/lib/geometries/polygon-geo2.d.ts

@@ -1,6 +1,5 @@
 import { Geo2, IGeo2Config } from './geo2';
 export declare class PolygonGeo2<Config extends IGeo2Config> extends Geo2<Config> {
-    readonly name: string;
     constructor(config?: Config);
     recomputePath(): this;
 }

package/lib/geometries/polyline-geo2.d.ts

@@ -6,7 +6,6 @@ export interface IPolylineGeo2Options extends IGeo2Config {
     arrowDeg?: number;
 }
 export declare class PolylineGeo2<Config extends IPolylineGeo2Options> extends Geo2<Config> {
-    readonly name: string;
     arrowLength: number;
     arrowDeg: number;
     stArrow: boolean;

package/lib/helpers/geo-helper.d.ts

@@ -0,0 +1,12 @@
+import { Geo2 } from '../geometries/geo2';
+import { SVGCommand } from 'svg-pathdata/src/types';
+import { IShape2Config } from '../objects/shape2';
+export declare class GeoHelper {
+    params: IShape2Config;
+    constructor(config?: IShape2Config);
+    destroy(): void;
+    static getInstanceByElement(o: Element, flipY?: boolean): Geo2<any> | undefined;
+    static getInstanceByPath(o: Element, flipY?: boolean): Geo2<any> | undefined;
+    static getInstanceByCircle(o: Element, flipY?: boolean): Geo2<any> | undefined;
+    static getInstance(cmd: string | SVGCommand[], flipY?: boolean): Geo2<any> | undefined;
+}

package/lib/helpers/mat-helper.d.ts

@@ -0,0 +1,10 @@
+import { IMat2 } from '../interfaces';
+import { IShape2Config } from '../objects/shape2';
+export declare class MatHelper {
+    params: IShape2Config;
+    constructor(config?: IShape2Config);
+    destroy(): void;
+    static getInstance(config: IShape2Config): IMat2;
+    static setCache(config: IShape2Config, mtl: IMat2): void;
+}
+export declare function getMatFeatureKey(o: any): string;

package/lib/helpers/merge-helper.d.ts

@@ -0,0 +1,7 @@
+import { IShape2 } from '../interfaces';
+import { IShape2Config } from '../objects/shape2';
+import { ITextConfig } from '../shapes2/text';
+export declare class MergeHelper {
+    static getShapeByElement(el: Element, config: IShape2Config, flipY?: boolean): IShape2;
+    static getText(config: ITextConfig): IShape2;
+}

package/lib/index.d.ts

@@ -10,4 +10,5 @@ export { AssetTypeEnum, LayerTypeEnum } from './env/enums';
 export type { ITree } from './interfaces';
 export type { IApp, IDummyVo, IDummy } from './extras/interfaces';
 export { AppEnum, SvgApp } from './extras/svg-app';
+export { AppOffscreen } from './applications/app-offscreen';
 export { defaultConfig, EnvironmentWorker, RendererWorker, };