lythreeframe 2.0.0 → 2.0.2

package/dist/index.d.ts

@@ -21,8 +21,7 @@ export type { ViewportParam } from './src/Frame/Parameters/ViewportParameters';
 export { DefaultViewportParam } from './src/Frame/Parameters/ViewportParameters';
 export type { WorldParam } from "./src/Frame/Parameters/WorldParameter";
 export { DefaultWorldParam } from "./src/Frame/Parameters/WorldParameter";
-export type { RendererParameters } from './src/Frame/Parameters/RendererParameters';
-export { DefaultRendererParameters } from './src/Frame/Parameters/RendererParameters';
+export { RendererType } from './src/Frame/Parameters/ViewportParameters';
 export { Actor } from "./src/Object/Actor";
 export { DirectionalLightActor } from "./src/Object/Actors/Light/DirectionalLightActor";
 export { AmbientLightActor } from './src/Object/Actors/Light/AmbientLightActor';

package/dist/src/AssetManagement/AssetManager.d.ts

@@ -16,12 +16,12 @@ export declare class AssetManager {
     protected readonly gltfLoader: GLTFLoader;
     protected readonly loadingManager: LoadingManager;
     protected app: ThreeJsApp;
-    constructor(app: ThreeJsApp);
+    private dracoPath;
+    constructor(app: ThreeJsApp, dracoPath: string);
     get LoadingManager(): LoadingManager;
     get KTX2Loader(): KTX2Loader | null;
     init(): Promise<void>;
-    setupKTX2Loader(transcoderPath: string): Promise<void>;
-    setupDracoLoader(dracoPath: string): void;
+    setupDracoLoader(): void;
     convertThreeObjectToLYObject(parentLYComponent: SceneComponent, threejsObject: Object3D): SceneComponent | null;
     collectResourcesAndReferences(object: Object3D): void;
     checkMeshResource(mesh: Mesh): void;

package/dist/src/Frame/Controller.d.ts

@@ -1,5 +1,5 @@
 import { ThreeJsApp } from "../ThreeJsApp";
-import { Euler, Intersection, OrthographicCamera, PerspectiveCamera, Quaternion, Raycaster, Vector2, Vector3 } from "three/webgpu";
+import { Box3, Euler, Intersection, Object3D, OrthographicCamera, PerspectiveCamera, Quaternion, Raycaster, Vector2, Vector3 } from "three/webgpu";
 import { World } from "./World";
 import { Viewport } from "./Viewport";
 import { Pawn } from "../Object/PawnV2/Pawn";
@@ -74,17 +74,36 @@ export declare class Controller {
     protected _onActorHoverBeginDelegate: Delegate<[ActorHoverEvent]>;
     protected _onActorHoverEndDelegate: Delegate<[ActorHoverEvent]>;
     protected _onClickNothingDelegate: Delegate<[void]>;
+    protected _onPointerDownDelegate: Delegate<[PointerEvent]>;
+    protected _onPointerUpDelegate: Delegate<[PointerEvent]>;
+    protected _onPointerMoveDelegate: Delegate<[PointerEvent]>;
+    protected _onPointerCancelDelegate: Delegate<[PointerEvent]>;
+    protected _onWheelDelegate: Delegate<[WheelEvent]>;
+    protected _onKeyDownDelegate: Delegate<[KeyboardEvent]>;
+    protected _onKeyUpDelegate: Delegate<[KeyboardEvent]>;
+    protected _onContextMenuDelegate: Delegate<[MouseEvent]>;
+    protected _onPointerLockChangeDelegate: Delegate<[Event]>;
+    protected _onWindowBlurDelegate: Delegate<[Event]>;
+    protected _onRawClickDelegate: Delegate<[MouseEvent]>;
     protected pointerPosition: Vector2;
     protected pointerLeftDownPosition: Vector2;
     protected readonly _tempVec2: Vector2;
     protected readonly _raycastVec2: Vector2;
     protected readonly doubleClickDelay: number;
     protected leftClickTimer: number | null;
-    protected onPointerMove: (event: MouseEvent) => void;
-    protected onPointerEnter: (event: MouseEvent) => void;
-    protected onPointerLeave: (event: MouseEvent) => void;
-    protected onPointerUp: (event: MouseEvent) => void;
-    protected onPointerDown: (event: MouseEvent) => void;
+    protected onPointerMove: (event: PointerEvent) => void;
+    protected onPointerEnter: (event: PointerEvent) => void;
+    protected onPointerLeave: (event: PointerEvent) => void;
+    protected onPointerUp: (event: PointerEvent) => void;
+    protected onPointerDown: (event: PointerEvent) => void;
+    protected onPointerCancel: (event: PointerEvent) => void;
+    protected onWheel: (event: WheelEvent) => void;
+    protected onKeyDown: (event: KeyboardEvent) => void;
+    protected onKeyUp: (event: KeyboardEvent) => void;
+    protected onContextMenu: (event: MouseEvent) => void;
+    protected onPointerLockChange: (event: Event) => void;
+    protected onWindowBlur: (event: Event) => void;
+    protected onClick: (event: MouseEvent) => void;
     get camera(): PerspectiveCamera | OrthographicCamera;
     get world(): World;
     get viewPort(): Viewport;
@@ -100,20 +119,40 @@ export declare class Controller {
     get onActorHoverBeginDelegate(): Delegate<[ActorHoverEvent]>;
     get onActorHoverEndDelegate(): Delegate<[ActorHoverEvent]>;
     get onClickNothingDelegate(): Delegate<[void]>;
+    get onPointerDownDelegate(): Delegate<[PointerEvent]>;
+    get onPointerUpDelegate(): Delegate<[PointerEvent]>;
+    get onPointerMoveDelegate(): Delegate<[PointerEvent]>;
+    get onPointerCancelDelegate(): Delegate<[PointerEvent]>;
+    get onWheelDelegate(): Delegate<[WheelEvent]>;
+    get onKeyDownDelegate(): Delegate<[KeyboardEvent]>;
+    get onKeyUpDelegate(): Delegate<[KeyboardEvent]>;
+    get onContextMenuDelegate(): Delegate<[MouseEvent]>;
+    get onPointerLockChangeDelegate(): Delegate<[Event]>;
+    get onWindowBlurDelegate(): Delegate<[Event]>;
+    get onRawClickDelegate(): Delegate<[MouseEvent]>;
     constructor(app: ThreeJsApp);
+    createInitialPawn(): void;
     init(): void;
     updateCamera(): void;
     switchPawn(pawn: Pawn, cameraMoveTime?: number): Promise<void>;
     tick(deltaTime: number): void;
     destroy(): void;
-    protected onPointerMoveEvent(event: MouseEvent): void;
+    protected onPointerMoveEvent(event: PointerEvent): void;
     protected clearHovering(): void;
-    protected onPointerUpEvent(event: MouseEvent): void;
+    protected onPointerUpEvent(event: PointerEvent): void;
     protected handleFirstClick(): void;
     protected handleDoubleClick(): void;
-    protected onPointerDownEvent(event: MouseEvent): void;
-    protected onPointerEnterEvent(_event: MouseEvent): void;
-    protected onPointerLeaveEvent(_event: MouseEvent): void;
+    protected onPointerDownEvent(event: PointerEvent): void;
+    protected onPointerEnterEvent(_event: PointerEvent): void;
+    protected onPointerLeaveEvent(_event: PointerEvent): void;
+    protected onPointerCancelEvent(event: PointerEvent): void;
+    protected onWheelEvent(event: WheelEvent): void;
+    protected onKeyDownEvent(event: KeyboardEvent): void;
+    protected onKeyUpEvent(event: KeyboardEvent): void;
+    protected onContextMenuEvent(event: MouseEvent): void;
+    protected onPointerLockChangeEvent(event: Event): void;
+    protected onWindowBlurEvent(event: Event): void;
+    protected onClickEvent(event: MouseEvent): void;
     protected fireComponentHoverBegin(component: SceneComponent, hit: Intersection): void;
     protected fireComponentHoverEnd(component: SceneComponent): void;
     protected fireComponentClick(component: SceneComponent, hit: Intersection, isDoubleClick: boolean): void;
@@ -127,6 +166,9 @@ export declare class Controller {
     protected removeCorePointerListeners(): void;
     getHitResultUnderCursor(checkInteractable?: boolean): HitResult | null;
     getHitResultFromScreenPoint(x: number, y: number, checkInteractable?: boolean): HitResult | null;
+    getAllHitResultUnderCursor(_checkInteractable?: boolean): HitResult[] | null;
     protected getAllHitResultFromScreenPoint(x: number, y: number): HitResult[];
     focusTo(targetPos: Vector3, targetQuat: Quaternion | Euler, distance: number, time: number, onGoing?: (() => void) | null, onFinished?: (() => void) | null): void;
+    focusToBounds(bounds: Box3, time: number, computeOptimalQuat?: boolean, onGoing?: (() => void) | null, onFinished?: (() => void) | null): void;
+    focusToObject(targetObejct: Object3D, time: number, computeOptimalQuat?: boolean, onGoing?: (() => void) | null, onFinished?: (() => void) | null): void;
 }

package/dist/src/Frame/Parameters/AppParameter.d.ts

@@ -6,7 +6,6 @@ import { Viewport } from "../Viewport";
 import { ViewportParam } from "./ViewportParameters";
 import { AssetManager } from "../../AssetManagement/AssetManager";
 import { PostProcessParam } from "../../PostProcess/PostProcessParam";
-import { RendererParameters } from "./RendererParameters";
 export interface AppClass {
     assetManagerClass: typeof AssetManager;
     controllerClass: typeof Controller;
@@ -14,7 +13,7 @@ export interface AppClass {
     viewportClass: typeof Viewport;
 }
 export interface AppParam {
-    renderParam?: RendererParameters;
+    dracoPath: string;
     cameraParam?: CameraParam;
     postProcessParam?: PostProcessParam;
     worldParam?: WorldParam;

package/dist/src/Frame/Parameters/ViewportParameters.d.ts

@@ -1,7 +1,19 @@
+import { PostProcessParam } from 'lythreeframe/src/PostProcess/PostProcessParam';
+import { WebGLRendererParameters } from 'three';
+import { WebGPURendererParameters } from 'three/src/renderers/webgpu/WebGPURenderer.js';
+export declare enum RendererType {
+    WebGPU = 0,
+    WebGL = 1
+}
 export interface ViewportParam {
     elementId: string | null;
-    isLabelRendererNeeded: boolean;
+    renderer: {
+        type: RendererType;
+        param?: WebGPURendererParameters | WebGLRendererParameters;
+    };
+    isLabelRendererNeeded?: boolean;
     isCSS3DRendererNeeded?: boolean;
-    isUILayerNeeded: boolean;
+    isUILayerNeeded?: boolean;
+    postProcess?: PostProcessParam;
 }
 export declare const DefaultViewportParam: ViewportParam;

package/dist/src/Frame/Rendering/WebGLPostProcess.d.ts

@@ -0,0 +1,41 @@
+import { Camera, Data3DTexture, Object3D, Scene, WebGLRenderer } from "three";
+import { EffectComposer } from "three/examples/jsm/postprocessing/EffectComposer.js";
+import { PostProcessParam, PostProcessStepParam } from '../../PostProcess/PostProcessParam';
+export declare class WebGLPostProcessManager {
+    private postProcessParam;
+    private composer;
+    private outlineObjects;
+    private renderPass;
+    private outlinePass;
+    private bloomPass;
+    private dofPass;
+    private gtaoPass;
+    private smaaPass;
+    private fxaaPass;
+    private lutPass;
+    private outputPass;
+    private lut3dTexture;
+    private renderer;
+    protected scene: Scene;
+    protected camera: Camera;
+    private onDirtyCallback;
+    constructor(renderer: WebGLRenderer, scene: Scene, camera: Camera, postProcessParam: PostProcessParam, onDirtyCallback?: () => void);
+    get processing(): EffectComposer | null;
+    updateCamera(camera: Camera): void;
+    setup(): void;
+    private buildPipeline;
+    private getStepParam;
+    private updateAllParameters;
+    private updateGTAOParameters;
+    private updateOutlineParameters;
+    updateSteps(steps: PostProcessStepParam[]): void;
+    addOutlineObject(obj: Object3D): void;
+    setOutlineObjects(objects: Object3D[]): void;
+    removeOutlineObject(obj: Object3D): void;
+    setLUT3DTexture(lutTexture: Data3DTexture | null): void;
+    getLUT3DTexture(): Data3DTexture | null;
+    render(): boolean;
+    resize(width: number, height: number): void;
+    destroy(): void;
+    private markDirty;
+}

package/dist/src/Frame/Viewport.d.ts

@@ -1,15 +1,17 @@
+import { WebGPURendererParameters } from "three/src/renderers/webgpu/WebGPURenderer.js";
 import { Object3D, ShadowMapType, ToneMapping, WebGPURenderer } from "three/webgpu";
 import { ThreeJsApp } from "../ThreeJsApp";
 import { PostProcessParam, PostProcessStepParam } from './../PostProcess/PostProcessParam';
-import { RendererParameters } from './Parameters/RendererParameters';
-import { ViewportParam } from './Parameters/ViewportParameters';
+import { RendererType, ViewportParam } from './Parameters/ViewportParameters';
 import { PostProcessManager } from "./Rendering/PostProcess";
+import { WebGLRenderer, WebGLRendererParameters } from "three";
+import { WebGLPostProcessManager } from "./Rendering/WebGLPostProcess";
 export declare class Viewport {
     get uiDom(): HTMLDivElement | null;
     protected _uiDom: HTMLDivElement | null;
     get canvas(): HTMLElement | null;
     get outer(): HTMLElement | null;
-    get renderer(): WebGPURenderer;
+    get renderer(): WebGPURenderer | WebGLRenderer;
     get app(): ThreeJsApp;
     private _renderer;
     private labelRenderer;
@@ -19,19 +21,17 @@ export declare class Viewport {
     private _outerContainer;
     private _canvasContainer;
     private isRenderStateDirty;
-    private postProcessParam;
-    protected postProcessManager: PostProcessManager | null;
-    constructor(app: ThreeJsApp, viewportParam: ViewportParam, rendererParam: RendererParameters, postProcessParam: PostProcessParam);
-    protected createRenderer(rendererParam: RendererParameters): void;
+    protected postProcessManager: PostProcessManager | WebGLPostProcessManager | null;
+    constructor(app: ThreeJsApp, viewportParam: ViewportParam);
+    protected createRenderer(type: RendererType, rendererParam?: WebGPURendererParameters | WebGLRendererParameters): void;
     protected createLabelRenderer(): void;
     protected createCSS3DRenderer(): void;
     protected createUILayer(): void;
     init(): void;
-    protected setupPostProcess(): void;
+    protected setupPostProcess(postProcessParam: PostProcessParam): void;
     /** Create the PostProcessManager instance. Override in subclass to use custom manager. */
-    protected createPostProcessManager(): PostProcessManager;
+    protected createPostProcessManager(postProcessParam: PostProcessParam): PostProcessManager | WebGLPostProcessManager;
     updatePostProcess(steps: PostProcessStepParam[]): void;
-    updateRendererSettings(data: RendererParameters): void;
     addOutlineObject(obj: Object3D): void;
     setOutlineObjects(objects: Object3D[]): void;
     removeOutlineObject(obj: Object3D): void;
@@ -42,12 +42,9 @@ export declare class Viewport {
     /** Called after post-processing render, before label renderer. Override in subclass to render additional content. */
     protected onAfterPostProcessRender(): void;
     renderAsImage(width?: number, height?: number): Promise<string>;
-    setAlpha(alpha: boolean): void;
     setShadowMapEnabled(enabled: boolean): void;
     setShadowMapType(type: ShadowMapType): void;
     setToneMapping(toneMapping: ToneMapping): void;
     setToneMappingExposure(exposure: number): void;
-    setDepth(depth: boolean): void;
-    setStencil(stencil: boolean): void;
     destroy(): void;
 }

package/dist/src/Frame/World.d.ts

@@ -1,4 +1,4 @@
-import { Scene } from "three/webgpu";
+import { ClippingGroup, Plane, Scene } from "three/webgpu";
 import { ThreeJsApp } from "../ThreeJsApp";
 import { Viewport } from "./Viewport";
 import { Controller } from "./Controller";
@@ -18,6 +18,7 @@ export declare class World {
     protected actors: Set<Actor>;
     protected tickableActors: Set<Actor>;
     protected worldParam: WorldParam;
+    protected _clippingGroup: ClippingGroup | null;
     constructor(app: ThreeJsApp, worldParam: WorldParam);
     init(): void;
     addTickableActor(actor: Actor): void;
@@ -29,4 +30,6 @@ export declare class World {
     removeActors(actors: Actor[]): void;
     getActorById(id: string): Actor | null;
     getActorsByIds(ids: string[]): Actor[];
+    addActorClipping(target: Actor, planes: Plane[]): void;
+    removeActorClipping(target: Actor, oldParent?: Actor | null): void;
 }

package/dist/src/Object/Actor.d.ts

@@ -83,4 +83,5 @@ export declare class Actor extends BaseObject {
     onActorHoverEnd(component: SceneComponent): void;
     onActorClick(component: SceneComponent): void;
     onActorDoubleClick(component: SceneComponent): void;
+    landToGround(): void;
 }

package/dist/src/Object/Components/2D/2DComponent.d.ts

@@ -2,11 +2,15 @@ import { CSS2DObject } from "three/examples/jsm/renderers/CSS2DRenderer.js";
 import { Vector2 } from "three/webgpu";
 import { SceneComponent } from "../SceneComponent";
 import { ThreeJsApp } from "../../../ThreeJsApp";
+export interface LabelComponentOptions {
+    center?: Vector2;
+    enablePointerEvents?: boolean;
+}
 export declare class LabelComponent extends SceneComponent {
     get threeObject(): CSS2DObject;
     set threeObject(newThreeObject: CSS2DObject);
     protected obj: CSS2DObject;
-    constructor(app: ThreeJsApp, domElement: HTMLElement, center?: Vector2, uuid?: string);
+    constructor(app: ThreeJsApp, domElement: HTMLElement, options?: LabelComponentOptions, uuid?: string);
     set isHoverEnabled(_bCanHorver: boolean);
     set isClickEnabled(_bCanClick: boolean);
     setVisible(bVisible: boolean): void;

package/dist/src/Object/Components/2D/SpiriteComponent.d.ts

@@ -0,0 +1,15 @@
+import { Sprite, SpriteMaterial } from 'three/webgpu';
+import { ThreeJsApp } from '../../../ThreeJsApp';
+import { SceneComponent } from "../SceneComponent";
+export interface SpriteOptions {
+    material?: SpriteMaterial;
+    textureUrl?: string;
+    color?: number | string;
+}
+export declare class SpriteComponent extends SceneComponent {
+    get threeObject(): Sprite;
+    protected set threeObject(newThreeObject: Sprite);
+    protected obj: Sprite;
+    constructor(app: ThreeJsApp, options?: SpriteOptions);
+    protected createDefaultObject(): Sprite;
+}

package/dist/src/Object/Components/Mesh/Line/CurveComponent.d.ts

@@ -5,7 +5,12 @@ export declare class CurveComponent extends SceneComponent {
     private curve;
     protected createDefaultObject(): Line;
     constructor(app: ThreeJsApp, uuid?: string);
-    setPoints(points: Vector3[], closed?: boolean, curveType?: 'centripetal' | 'chordal' | 'catmullrom', tension?: number): void;
+    setPoints(points: Vector3[], options?: {
+        closed?: boolean;
+        curveType?: 'centripetal' | 'chordal' | 'catmullrom';
+        tension?: number;
+        showLine?: boolean;
+    }): void;
     getPointAt(u: number): Vector3 | null;
     getTangentAt(u: number): Vector3 | null;
     getLength(): number;

package/dist/src/Object/PawnV2/FirstPerson.d.ts

@@ -1,6 +1,6 @@
 import { Pawn } from "./Pawn";
 import { ThreeJsApp } from "../../ThreeJsApp";
-import { Vector3, Quaternion } from "three/webgpu";
+import { Vector3, Quaternion, Euler } from "three/webgpu";
 import { SceneComponent } from "../Components/SceneComponent";
 export declare class FirstPerson extends Pawn {
     moveSpeed: number;
@@ -23,6 +23,19 @@ export declare class FirstPerson extends Pawn {
     constructor(app: ThreeJsApp);
     protected constructRootComponent(): SceneComponent;
     landToGround(): void;
+    private syncRotation;
+    /**
+     * Override setRotation to intercept external rotation changes.
+     * Extracts Pitch to internal state and only applies Yaw to the physical pawn.
+     */
+    setRotation(rotation: Euler): void;
+    setRotation(x: number, y: number, z: number): void;
+    /**
+     * Override setQuaternion to intercept external rotation changes.
+     * Extracts Pitch to internal state and only applies Yaw to the physical pawn.
+     */
+    setQuaternion(quat: Quaternion): void;
+    setQuaternion(x: number, y: number, z: number, w: number): void;
     possess(): void;
     unpossess(): void;
     getTargetCameraState(): {

package/dist/src/Object/PawnV2/TopDown.d.ts

@@ -0,0 +1,56 @@
+import { Pawn } from "./Pawn";
+import { Euler, Quaternion, Vector3 } from "three/webgpu";
+import { ThreeJsApp } from "../../ThreeJsApp";
+export interface TopDownOptions {
+    enablePan?: boolean;
+    enableRotate?: boolean;
+    enableZoom?: boolean;
+    distance?: number;
+    minDistance?: number;
+    maxDistance?: number;
+    rotateSpeed?: number;
+    zoomSpeed?: number;
+    enableDamping?: boolean;
+    dampingFactor?: number;
+}
+export declare class TopDown extends Pawn {
+    enablePan: boolean;
+    enableRotate: boolean;
+    enableZoom: boolean;
+    distance: number;
+    minDistance: number;
+    maxDistance: number;
+    rotateSpeed: number;
+    zoomSpeed: number;
+    enableDamping: boolean;
+    dampingFactor: number;
+    private _isDragging;
+    private _lastPointerPosition;
+    private _targetPosition;
+    private _targetQuaternion;
+    private _targetDistance;
+    private _focusTween;
+    constructor(app: ThreeJsApp, options?: TopDownOptions);
+    possess(): void;
+    getTargetCameraState(): {
+        position: Vector3;
+        quaternion: Quaternion;
+    };
+    private updateCameraFromPawn;
+    unpossess(): void;
+    private onContextMenu;
+    private onPointerDown;
+    private onPointerMove;
+    private onPointerUp;
+    private setCameraDraggingState;
+    private onWheel;
+    tick(deltaTime: number): void;
+    setPosition(position: Vector3): void;
+    setPosition(x: number, y: number, z: number): void;
+    setRotation(rotation: Euler): void;
+    setRotation(x: number, y: number, z: number): void;
+    setQuaternion(quat: Quaternion): void;
+    setQuaternion(x: number, y: number, z: number, w: number): void;
+    focusTo(targetPos: Vector3, targetQuat: Quaternion | Euler, distance: number, time: number, onGoing?: (() => void) | null, onFinished?: (() => void) | null): void;
+    stopFocusing(): void;
+}

package/dist/src/Physics/MeshColliderComponent.d.ts

@@ -1,6 +1,7 @@
 import { Box3, Matrix4, Mesh, MeshBasicMaterial, Object3D, Vector3 } from "three/webgpu";
 import { ThreeJsApp } from "../ThreeJsApp";
 import { ColliderComponent } from "./ColliderComponent";
+import { RaycastHit } from "./PhysicsWorld";
 export declare class MeshColliderComponent extends ColliderComponent {
     get sourceObject(): Object3D<import("three").Object3DEventMap> | null;
     protected _sourceObject: Object3D | null;
@@ -28,11 +29,8 @@ export declare class MeshColliderComponent extends ColliderComponent {
     private mergeGeometries;
     destroy(): void;
     getWorldAABB(out?: Box3): Box3;
-    raycast(origin: Vector3, dir: Vector3, maxDistance: number): {
-        point: Vector3;
-        normal: Vector3;
-        distance: number;
-    } | null;
+    raycastAll(origin: Vector3, dir: Vector3, maxDistance: number): RaycastHit[];
+    raycast(origin: Vector3, dir: Vector3, maxDistance: number): RaycastHit | null;
     protected intersectRayAabb(origin: Vector3, dir: Vector3, maxDistance: number, box: Box3): boolean;
     protected intersectRayTriangle(origin: Vector3, dir: Vector3, a: Vector3, b: Vector3, c: Vector3, maxDistance: number): {
         point: Vector3;

package/dist/src/Physics/PhysicsWorld.d.ts

@@ -8,6 +8,11 @@ export interface LineTraceHitResult {
     distance: number;
     blocking: boolean;
 }
+export interface RaycastHit {
+    point: Vector3;
+    normal: Vector3;
+    distance: number;
+}
 export declare class PhysicsWorld {
     protected colliders: Set<ColliderComponent>;
     protected previousOverlapPairs: Map<string, [ColliderComponent, ColliderComponent]>;

package/dist/src/ThreeJsApp.d.ts

@@ -1,33 +1,33 @@
 import { World } from "./Frame/World";
 import { Viewport } from "./Frame/Viewport";
 import { Controller } from "./Frame/Controller";
-import { Clock, OrthographicCamera, PerspectiveCamera } from "three/webgpu";
+import { OrthographicCamera, PerspectiveCamera, Timer } from "three/webgpu";
 import { Delegate } from './Delegate';
 import { CameraParam } from './Frame/Parameters/CameraParameter';
 import { AppParam } from './Frame/Parameters/AppParameter';
 import { AssetManager } from './AssetManagement/AssetManager';
 export declare class ThreeJsApp {
     get camera(): PerspectiveCamera | OrthographicCamera;
-    get clock(): Clock;
+    get clock(): Timer;
     get world(): World;
     get viewport(): Viewport;
     get controller(): Controller;
     get assetManager(): AssetManager;
-    protected _clock: Clock;
+    protected _clock: Timer;
     protected _camera: PerspectiveCamera | OrthographicCamera;
     protected _world: World;
     protected _viewport: Viewport;
     protected _controller: Controller;
     protected _assetManager: AssetManager;
     protected _tickingFunctions: Array<(delta: number) => void>;
-    get appParam(): AppParam;
-    protected _appParam: AppParam;
+    protected _isTickPaused: boolean;
     get onCameraChangedDelegate(): Delegate<[void]>;
     protected _onCameraChangedDelegate: Delegate<[void]>;
     constructor(appParam?: AppParam);
     protected postConstruct(): void;
     init(): void;
     protected tick(deltaTime: number): void;
+    setTickPaused(pause: boolean): void;
     addTickingFunction(func: (deltaTime: number) => void): void;
     removeTickingFunction(func: (deltaTime: number) => void): void;
     destroy(): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lythreeframe",
-  "version": "2.0.0",
+  "version": "2.0.2",
   "description": "Three.js 封装",
   "main": "dist/bundle.cjs.js",
   "module": "dist/bundle.esm.js",