lythreeframe 1.3.14 → 2.0.1

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

@@ -1,22 +1,23 @@
-import { Euler, Quaternion, Vector3 } from "three";
+import { Euler, Quaternion, Vector3 } from "three/webgpu";
 import { Controller } from "../../Frame/Controller";
-export declare abstract class Pawn {
+import { Actor } from "../Actor";
+import { ThreeJsApp } from "../../ThreeJsApp";
+export declare abstract class Pawn extends Actor {
     get camera(): import("three").PerspectiveCamera | import("three").OrthographicCamera;
+    get enabled(): boolean;
     set enabled(value: boolean);
-    get control(): any;
-    protected _control: any | null;
+    protected _enabled: boolean;
+    static inputFilter: () => boolean;
     protected controller: Controller;
-    protected isTickEnabled: boolean;
-    protected constructor(controller: Controller);
+    protected constructor(app: ThreeJsApp);
     tick(_deltaTime: number): void;
     possess(): void;
     unpossess(): void;
-    focusTo(_targetPos: Vector3, _targetQuat: Quaternion | Euler, _distance: number, _time: number, _onGoing?: (() => void) | null, _onFinished?: (() => void) | null): void;
-    stopFocusing(): void;
-    getFocuingData(): {
+    abstract getTargetCameraState(): {
         position: Vector3;
         quaternion: Quaternion;
-        distance: number;
-    } | null;
+    };
+    focusTo(_targetPos: Vector3, _targetQuat: Quaternion | Euler, _distance: number, _time: number, _onGoing?: (() => void) | null, _onFinished?: (() => void) | null): void;
+    stopFocusing(): void;
     destroy(): void;
 }

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

@@ -0,0 +1,19 @@
+import { Pawn } from "./Pawn";
+import { ThreeJsApp } from "../../ThreeJsApp";
+import { Vector3, Quaternion } from "three/webgpu";
+import { SceneComponent } from "../Components/SceneComponent";
+export declare class Spectator extends Pawn {
+    moveSpeed: number;
+    lookSpeed: number;
+    eyeHeight: number;
+    constructor(app: ThreeJsApp);
+    protected constructRootComponent(): SceneComponent;
+    possess(): void;
+    unpossess(): void;
+    getTargetCameraState(): {
+        position: Vector3;
+        quaternion: Quaternion;
+    };
+    tick(deltaTime: number): void;
+    private updateCameraFromPawn;
+}

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/Object/PawnV2/TransformControl.d.ts

@@ -1,7 +1,7 @@
 import { Pawn } from "./Pawn";
-import { Matrix4, Scene } from "three/webgpu";
+import { Matrix4, Scene, Vector3, Quaternion } from "three/webgpu";
 import { TransformControls } from "three/examples/jsm/controls/TransformControls.js";
-import { Controller } from "../../Frame/Controller";
+import { ThreeJsApp } from "../../ThreeJsApp";
 export interface TransformType {
     rotate: "X" | "Y" | "Z" | "E" | "XY" | "YZ" | "XZ" | "XYZ" | "XYZE" | null;
     scale: "X" | "Y" | "Z" | "E" | "XY" | "YZ" | "XZ" | "XYZ" | "XYZE" | null;
@@ -34,11 +34,15 @@ export declare class TransformGizmo extends Pawn {
     protected onChangeEvent: () => void;
     protected onUpdateFunction: (() => void) | null;
     protected onDraggingFunction: ((event: boolean) => void) | null;
-    constructor(controller: Controller, options?: TransformGizmoOptions);
+    constructor(app: ThreeJsApp, options?: TransformGizmoOptions);
     /** Get the scene where gizmo should be added */
     private getTargetScene;
     possess(): void;
     unpossess(): void;
+    getTargetCameraState(): {
+        position: Vector3;
+        quaternion: Quaternion;
+    };
     refresh(): void;
     protected onChange(): void;
     protected onDraggingChanged(event: {

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

@@ -0,0 +1,22 @@
+import { Box3, Mesh, Object3D, Vector3 } from "three/webgpu";
+import { ThreeJsApp } from "../ThreeJsApp";
+import { ColliderComponent } from "./ColliderComponent";
+export declare class BoxColliderComponent extends ColliderComponent {
+    get halfExtents(): Vector3;
+    protected _halfExtents: Vector3;
+    protected _debugMesh: Mesh | null;
+    constructor(app: ThreeJsApp, halfExtents?: Vector3, uuid?: string);
+    getWorldAABB(out?: Box3): Box3;
+    protected createDebugObject(): Object3D | null;
+    protected destroyDebugObject(_debugObject: Object3D): void;
+    protected onDebugTick(_deltaTime: number): void;
+    raycast(origin: Vector3, dir: Vector3, maxDistance: number): {
+        point: Vector3;
+        normal: Vector3;
+        distance: number;
+    } | null;
+    protected intersectRayAabbRaw(origin: Vector3, dir: Vector3, min: Vector3, max: Vector3): {
+        t: number;
+        normal: Vector3;
+    } | null;
+}

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

@@ -0,0 +1,40 @@
+import { Box3, Mesh, Object3D, Vector3 } from "three/webgpu";
+import { ThreeJsApp } from "../ThreeJsApp";
+import { ColliderComponent } from "./ColliderComponent";
+export declare class CapsuleColliderComponent extends ColliderComponent {
+    get radius(): number;
+    get halfHeight(): number;
+    protected _radius: number;
+    protected _halfHeight: number;
+    protected _debugRoot: Object3D | null;
+    protected _debugCylinder: Mesh | null;
+    protected _debugTop: Mesh | null;
+    protected _debugBottom: Mesh | null;
+    protected readonly _tmpA: Vector3;
+    protected readonly _tmpB: Vector3;
+    protected readonly _tmpBA: Vector3;
+    protected readonly _tmpOA: Vector3;
+    protected readonly _tmpPoint: Vector3;
+    protected readonly _tmpNormal: Vector3;
+    constructor(app: ThreeJsApp, radius?: number, halfHeight?: number, uuid?: string);
+    getWorldAABB(out?: Box3): Box3;
+    raycast(origin: Vector3, dir: Vector3, maxDistance: number): {
+        point: Vector3;
+        normal: Vector3;
+        distance: number;
+    } | null;
+    protected raycastSphere(origin: Vector3, dir: Vector3, maxDistance: number, center: Vector3, radius: number): {
+        point: Vector3;
+        normal: Vector3;
+        distance: number;
+    } | null;
+    protected makeSphereHit(origin: Vector3, dir: Vector3, t: number, center: Vector3): {
+        point: Vector3;
+        normal: Vector3;
+        distance: number;
+    };
+    protected createDebugObject(): Object3D | null;
+    protected destroyDebugObject(_debugObject: Object3D): void;
+    protected onDebugTick(_deltaTime: number): void;
+    protected onDebugStyleChanged(): void;
+}

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

@@ -0,0 +1,62 @@
+import { Box3, Object3D, Vector3 } from "three/webgpu";
+import { Delegate } from "../Delegate";
+import { ThreeJsApp } from "../ThreeJsApp";
+import { SceneComponent } from "../Object/Components/SceneComponent";
+import { World } from "../Frame/World";
+import { CollisionChannel, CollisionResponse } from "./CollisionTypes";
+export type CollisionResponseMap = Partial<Record<CollisionChannel, CollisionResponse>>;
+export interface PhysicsHitResult {
+    self: ColliderComponent;
+    other: ColliderComponent;
+    point: Vector3;
+    normal: Vector3;
+    penetrationDepth: number;
+}
+export declare abstract class ColliderComponent extends SceneComponent {
+    get debugEnabled(): boolean;
+    set debugEnabled(value: boolean);
+    get debugColor(): number;
+    set debugColor(value: number);
+    get debugOpacity(): number;
+    set debugOpacity(value: number);
+    get collisionEnabled(): boolean;
+    set collisionEnabled(value: boolean);
+    get generateOverlapEvents(): boolean;
+    set generateOverlapEvents(value: boolean);
+    get generateHitEvents(): boolean;
+    set generateHitEvents(value: boolean);
+    get objectType(): CollisionChannel;
+    set objectType(value: CollisionChannel);
+    get onBeginOverlapDelegate(): Delegate<[ColliderComponent]>;
+    get onEndOverlapDelegate(): Delegate<[ColliderComponent]>;
+    get onHitDelegate(): Delegate<[PhysicsHitResult]>;
+    protected _collisionEnabled: boolean;
+    protected _generateOverlapEvents: boolean;
+    protected _generateHitEvents: boolean;
+    protected _objectType: CollisionChannel;
+    protected _responseMap: CollisionResponseMap;
+    protected _onBeginOverlapDelegate: Delegate<[ColliderComponent]>;
+    protected _onEndOverlapDelegate: Delegate<[ColliderComponent]>;
+    protected _onHitDelegate: Delegate<[PhysicsHitResult]>;
+    protected _registeredInWorld: boolean;
+    protected _debugEnabled: boolean;
+    protected _debugColor: number;
+    protected _debugOpacity: number;
+    protected _debugObject: Object3D | null;
+    constructor(app: ThreeJsApp, uuid?: string);
+    setCollisionResponse(channel: CollisionChannel, response: CollisionResponse): void;
+    setCollisionResponses(map: CollisionResponseMap): void;
+    getCollisionResponse(channel: CollisionChannel): CollisionResponse;
+    getMutualResponse(other: ColliderComponent): CollisionResponse;
+    abstract getWorldAABB(out?: Box3): Box3;
+    tick(deltaTime: number): void;
+    onAddedToWorld(world: World): void;
+    destroy(): void;
+    protected getDebugAttachParent(): Object3D | null;
+    protected createDebugObject(): Object3D | null;
+    protected destroyDebugObject(_debugObject: Object3D): void;
+    protected onDebugTick(_deltaTime: number): void;
+    protected onDebugStyleChanged(): void;
+    protected enableDebug(): void;
+    protected disableDebug(): void;
+}

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

@@ -0,0 +1,17 @@
+export declare enum CollisionResponse {
+    Ignore = "Ignore",
+    Overlap = "Overlap",
+    Block = "Block"
+}
+export declare enum CollisionChannel {
+    WorldStatic = "WorldStatic",
+    WorldDynamic = "WorldDynamic",
+    Pawn = "Pawn",
+    Visibility = "Visibility",
+    Camera = "Camera",
+    Trigger = "Trigger"
+}
+export declare enum CollisionShapeType {
+    Sphere = "Sphere",
+    Box = "Box"
+}

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

@@ -0,0 +1,44 @@
+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;
+    protected _mesh: Mesh | null;
+    protected _debugEntries: Array<{
+        parent: Object3D;
+        obj: Object3D;
+    }>;
+    protected _debugMaterial: MeshBasicMaterial | null;
+    protected readonly _tmpAabb: Box3;
+    protected readonly _tmpMat: Matrix4;
+    protected readonly _tmpCorner: Vector3;
+    protected readonly _tmpBoxCorner: Array<Vector3>;
+    protected readonly _tmpA: Vector3;
+    protected readonly _tmpB: Vector3;
+    protected readonly _tmpC: Vector3;
+    protected readonly _tmpEdge1: Vector3;
+    protected readonly _tmpEdge2: Vector3;
+    protected readonly _tmpP: Vector3;
+    protected readonly _tmpT: Vector3;
+    protected readonly _tmpQ: Vector3;
+    protected readonly _tmpN: Vector3;
+    constructor(app: ThreeJsApp, sourceObject?: Object3D | null, uuid?: string);
+    setSourceObject(sourceObject: Object3D | null): void;
+    private mergeGeometries;
+    destroy(): void;
+    getWorldAABB(out?: Box3): Box3;
+    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;
+        normal: Vector3;
+        distance: number;
+    } | null;
+    protected getDebugAttachParent(): Object3D | null;
+    protected createDebugObject(): Object3D | null;
+    protected destroyDebugObject(_debugObject: Object3D): void;
+    protected onDebugStyleChanged(): void;
+}

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

@@ -0,0 +1,36 @@
+import { Box3, Vector3 } from "three/webgpu";
+import { CollisionChannel } from "./CollisionTypes";
+import { ColliderComponent, PhysicsHitResult } from "./ColliderComponent";
+export interface LineTraceHitResult {
+    collider: ColliderComponent;
+    point: Vector3;
+    normal: Vector3;
+    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]>;
+    protected previousBlockPairs: Map<string, [ColliderComponent, ColliderComponent]>;
+    protected _debugDrawEnabled: boolean;
+    get debugDrawEnabled(): boolean;
+    set debugDrawEnabled(value: boolean);
+    registerCollider(collider: ColliderComponent): void;
+    unregisterCollider(collider: ColliderComponent): void;
+    clear(): void;
+    lineTraceSingle(start: Vector3, end: Vector3, traceChannel?: CollisionChannel, ignoreCollider?: ColliderComponent): LineTraceHitResult | null;
+    lineTraceMulti(start: Vector3, end: Vector3, traceChannel?: CollisionChannel, ignoreCollider?: ColliderComponent): LineTraceHitResult[];
+    tick(_deltaTime: number): void;
+    protected computeAabbHit(self: ColliderComponent, other: ColliderComponent, a: Box3, b: Box3): PhysicsHitResult;
+    protected getPairKey(a: ColliderComponent, b: ColliderComponent): string;
+    protected intersectRayAabb(origin: Vector3, dir: Vector3, maxDistance: number, box: Box3): {
+        point: Vector3;
+        normal: Vector3;
+        distance: number;
+    } | null;
+}

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

@@ -0,0 +1,14 @@
+import { Box3, Mesh, Object3D } from "three/webgpu";
+import { ThreeJsApp } from "../ThreeJsApp";
+import { ColliderComponent } from "./ColliderComponent";
+export declare class SphereColliderComponent extends ColliderComponent {
+    get radius(): number;
+    protected _radius: number;
+    protected _debugMesh: Mesh | null;
+    constructor(app: ThreeJsApp, radius?: number, uuid?: string);
+    getWorldAABB(out?: Box3): Box3;
+    protected createDebugObject(): Object3D | null;
+    protected destroyDebugObject(_debugObject: Object3D): void;
+    protected onDebugTick(_deltaTime: number): void;
+    protected onDebugStyleChanged(): void;
+}

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

@@ -0,0 +1,9 @@
+export { PhysicsWorld } from "./PhysicsWorld";
+export type { LineTraceHitResult } from "./PhysicsWorld";
+export { ColliderComponent } from "./ColliderComponent";
+export type { PhysicsHitResult, CollisionResponseMap } from "./ColliderComponent";
+export { BoxColliderComponent } from "./BoxColliderComponent";
+export { SphereColliderComponent } from "./SphereColliderComponent";
+export { CapsuleColliderComponent } from "./CapsuleColliderComponent";
+export { MeshColliderComponent } from "./MeshColliderComponent";
+export { CollisionResponse, CollisionChannel, CollisionShapeType } from "./CollisionTypes";

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": "1.3.14",
+  "version": "2.0.1",
   "description": "Three.js 封装",
   "main": "dist/bundle.cjs.js",
   "module": "dist/bundle.esm.js",
@@ -14,7 +14,7 @@
   "peerDependencies": {
     "earcut": "^3.0.2",
     "gsap": "^3.14.2",
-    "three": "^0.181.2"
+    "three": "^0.183.2"
   },
   "files": [
     "dist"
@@ -22,13 +22,13 @@
   "devDependencies": {
     "@rollup/plugin-typescript": "^12.3.0",
     "@types/earcut": "^3.0.0",
-    "@types/three": "^0.182.0",
+    "@types/three": "^0.183.0",
     "earcut": "^3.0.2",
     "gsap": "^3.14.2",
     "javascript-obfuscator": "^5.1.0",
     "rollup": "^4.55.1",
     "rollup-plugin-obfuscator": "^1.1.0",
-    "three": "^0.181.2",
+    "three": "^0.183.2",
     "tslib": "^2.8.1",
     "typescript": "^5.9.3"
   },