archgine 1.0.34 → 1.0.38

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

@@ -0,0 +1,11 @@
+import { Application } from './application';
+import { IAppOffscreenConfig } from './app-offscreen';
+import { MainScene } from '../scenes/main-scene';
+export declare class AppCvs<Config extends IAppOffscreenConfig> extends Application<Config> {
+    params: Config;
+    mainScene: MainScene<Config>;
+    constructor(config?: Config);
+    destroy(): void;
+    load(url?: string, layers?: string[]): Promise<void>;
+    trans2MainScene(): void;
+}

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

@@ -0,0 +1,19 @@
+import { IApplicationConfig } from './application';
+import { OpeView } from '../core/ope-view';
+export interface IAppOffscreenConfig extends IApplicationConfig {
+}
+export declare class AppOffscreen<Config extends IAppOffscreenConfig> {
+    params: Config;
+    cvs: OffscreenCanvas;
+    worker: Worker;
+    view: OpeView<Config>;
+    readonly workerMessageHandler: (e: MessageEvent) => void;
+    constructor(config?: Config);
+    destroy(): void;
+    bindEvents(): void;
+    unbindEvents(): void;
+    handleWorkerMessage(e: MessageEvent): void;
+    resize(): void;
+    load(url: string, layers?: string[], lv?: number): Promise<void>;
+    start(): void;
+}

package/lib/applications/application.d.ts

@@ -1,9 +1,9 @@
+import { IRenderer2, IRenderer2Config } from '../interfaces';
 import { default as EventDispatcher } from '../core/event-dispatcher';
-import { IRenderer2Config } from '../interfaces';
-import { default as Scene } from '../scenes/scene';
 import { default as Box2 } from '../math/box2';
-import { default as Renderer2 } from '../renders/renderer2';
 import { View } from '../core/view';
+import { EffectComposer } from '../effects/effect-composer';
+import { default as Scene } from '../scenes/scene';
 export interface IApplicationConfig extends IRenderer2Config {
     frameInterval?: number;
     syncDelay?: number;
@@ -11,7 +11,7 @@ export interface IApplicationConfig extends IRenderer2Config {
 }
 /**
  * @author Dio Zhu
- * @since 2024.8.22
+ * @since 2024.11.13
  */
 export declare abstract class Application<Config extends IApplicationConfig> extends EventDispatcher {
     name: string;
@@ -19,13 +19,15 @@ export declare abstract class Application<Config extends IApplicationConfig> ext
     scenes: Scene[];
     nextScenes: Scene[];
     nextBoundingBox: Box2;
-    renderer: Renderer2<Config>;
-    view: View<Config>;
-    runningHandler: () => void;
+    loadingScene: Scene;
+    composer: EffectComposer;
+    renderer: IRenderer2;
+    view: View<any>;
+    readonly runningHandler: (time: DOMHighResTimeStamp) => void;
     protected constructor(config?: Config);
     destroy(): void;
-    setViewAreaLimit(v: number): void;
-    updateScenes(): void;
+    get isLoadingScene(): boolean;
+    trans2LoadingScene(): void;
     hasScene(scene: Scene): boolean;
     pushScene(scene: Scene): void;
     clearScenes(): void;
@@ -35,5 +37,6 @@ export declare abstract class Application<Config extends IApplicationConfig> ext
     trans2Scenes(...scenes: Scene[]): void;
     start(): void;
     /** @description application's lifeCycle */
-    running(): void;
+    running(time: DOMHighResTimeStamp): void;
+    stop(): void;
 }

package/lib/controls/interactive-controls.d.ts

@@ -1,10 +1,10 @@
 import { OrbitControls } from './orbit-controls';
-import { ICamera2, ICanvas } from '../interfaces';
+import { ICamera2 } from '../interfaces';
 export declare class InteractiveControls extends OrbitControls {
     name: string;
     mouseButtons: any;
     private readonly clickHandler;
-    constructor(camera: ICamera2, domElement: ICanvas);
+    constructor(camera: ICamera2, domElement: HTMLElement);
     destroy(): void;
     bindMapEvents(): void;
     unbindMapEvents(): void;

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

@@ -1,6 +1,6 @@
-import { ICamera2, IVector2 } from '../interfaces';
+import { ICamera2, IOrbitController, IVector2 } from '../interfaces';
 import { default as EventDispatcher } from '../core/event-dispatcher';
-export declare class OrbitController extends EventDispatcher {
+export declare class OrbitController extends EventDispatcher implements IOrbitController {
     name: string;
     isSvg: boolean;
     dom: HTMLElement;

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

@@ -1,6 +1,6 @@
 import { default as Vector2 } from '../math/vector2';
 import { default as EventDispatcher } from '../core/event-dispatcher';
-import { ICamera2, ICanvas, IMatrix3, IVector2 } from '../interfaces';
+import { ICamera2, IMatrix3, IVector2 } from '../interfaces';
 interface IScene {
 }
 export interface IOrbitControlsConfig {
@@ -22,7 +22,7 @@ export interface IOrbitControlsConfig {
 export declare class OrbitControls extends EventDispatcher {
     name: string;
     camera: ICamera2;
-    domElement: ICanvas;
+    domElement: HTMLElement;
     domOffset: Vector2;
     enableNegateControl: boolean;
     focus: Vector2;
@@ -44,20 +44,22 @@ export declare class OrbitControls extends EventDispatcher {
         ONE: TouchEnum;
         TWO: TouchEnum;
     };
-    private _lastPosition;
     target0: IVector2;
     position0: IVector2;
     scene: IScene | null;
     enabled: boolean;
     state: number;
     EPS: number;
+    scaled: number;
+    rotateTheta: number;
+    enableDamping: boolean;
+    dampingFactor: number;
+    private _lastPosition;
     private pointers;
     private pointerPositions;
-    scaled: number;
     private rotateStart;
     private rotateEnd;
     private rotateDelta;
-    rotateTheta: number;
     private panStart;
     private panEnd;
     private panDelta;
@@ -66,15 +68,13 @@ export declare class OrbitControls extends EventDispatcher {
     private dollyEnd;
     private dollyDelta;
     private dollyOffset;
-    enableDamping: boolean;
-    dampingFactor: number;
     private readonly contextMenuHandler;
     private readonly pointerDownHandler;
     private readonly pointerUpHandler;
     private readonly pointerCancelHandler;
     private readonly pointerMoveHandler;
     private readonly wheelHandler;
-    constructor(camera: ICamera2, domElement: ICanvas);
+    constructor(camera: ICamera2, domElement: HTMLElement);
     destroy(): void;
     update(): void;
     pan(deltaX: number, deltaY: number): void;

package/lib/core/camera2.d.ts

@@ -1,28 +1,15 @@
 import { default as Vector2 } from '../math/vector2';
-import { ICamera2, ICamera2Position, IObject2, IVector2 } from '../interfaces';
+import { ICamera2, ICamera2Config, ICamera2Position, IObject2, IVector2 } from '../interfaces';
 import { default as Matrix3 } from '../math/matrix3';
 import { Object2 } from './object2';
 import { default as Box2 } from '../math/box2';
-export interface ICamera2Config {
-    width?: number;
-    height?: number;
-    aspect?: number;
-    left?: number;
-    right?: number;
-    top?: number;
-    bottom?: number;
-    eye?: number[];
-    up?: number[];
-    helperEnable?: boolean;
-    flipY?: boolean;
-}
 interface IView {
     enabled: boolean;
     width: number;
     height: number;
     offset: IVector2;
 }
-export default class Camera2<Config extends ICamera2Config = ICamera2Config> extends Object2 implements ICamera2 {
+export default class Camera2<Config extends ICamera2Config> extends Object2 implements ICamera2 {
     readonly isCamera: boolean;
     type: string;
     name: string;
@@ -61,7 +48,7 @@ export default class Camera2<Config extends ICamera2Config = ICamera2Config> ext
     toJSON(): any;
     fromJSON(o: any): void;
     clone(): any;
-    copy(source: Camera2, recursive?: boolean): IObject2;
+    copy(source: Camera2<Config>, recursive?: boolean): IObject2;
 }
 export declare enum CAMERA_ENUM {
     UPDATE = "update"

package/lib/core/object2.d.ts

@@ -16,7 +16,7 @@ export declare class Object2 extends EventDispatcher implements IObject2 {
     name: string;
     type: string;
     featureKey: string;
-    version: number;
+    _version: number;
     parent: IObject2 | undefined;
     children: IObject2[];
     up: Vector2;
@@ -54,6 +54,8 @@ export declare class Object2 extends EventDispatcher implements IObject2 {
     private _autoSort;
     constructor(config?: IObject2Config);
     set needsUpdate(v: boolean);
+    get version(): number;
+    set version(v: number);
     destroy(): void;
     setPosition(v: IVector2): this;
     translate(x: number, y: number): void;

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

@@ -0,0 +1,40 @@
+import { IBox2, ICamera2, ICamera2Config, 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';
+export interface IViewConfig extends IRenderer2Config {
+    name?: string;
+    cvs?: ICanvas;
+    camera?: ICamera2Config;
+    controls?: IOrbitControlsConfig;
+    axesHelper?: IAxesHelperConfig;
+    alignStageCenter?: boolean;
+}
+/**
+ * @author Dio Zhu 2024.8.22
+ */
+export declare class OpeView<Config extends IViewConfig> implements IView {
+    name: string;
+    params: Config;
+    visible: boolean;
+    cvs: ICanvas | undefined;
+    scene: Scene | undefined;
+    scenes: Scene[];
+    camera: ICamera2 | undefined;
+    controller?: OrbitController;
+    constructor(config?: Config);
+    destroy(): void;
+    initController(camera?: ICamera2, dom?: HTMLElement): 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,6 +1,5 @@
-import { IBox2, ICamera2, ICanvas, IRenderer2Config, IView } from '../interfaces';
+import { IBox2, ICamera2, ICamera2Config, ICanvas, IRenderer2Config, IView } from '../interfaces';
 import { IOrbitControlsConfig } from '../controls/orbit-controls';
-import { ICamera2Config } from './camera2';
 import { default as Scene } from '../scenes/scene';
 import { OrbitController } from '../controls/orbit-controller';
 import { default as Box2 } from '../math/box2';
@@ -20,7 +19,6 @@ export declare class View<Config extends IViewConfig> implements IView {
     name: string;
     params: Config;
     visible: boolean;
-    container: HTMLElement;
     cvs: ICanvas | undefined;
     scene: Scene | undefined;
     scenes: Scene[];
@@ -28,15 +26,15 @@ export declare class View<Config extends IViewConfig> implements IView {
     controller?: OrbitController;
     constructor(config?: Config);
     destroy(): void;
-    initController(camera?: ICamera2, dom?: HTMLElement): void;
+    bindScene(scene: Scene): void;
+    fullscreen(padding?: number, animate?: boolean): 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(): void;
+    update(time?: DOMHighResTimeStamp): void;
 }