lythreeframe 1.3.14 → 2.0.1

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';
@@ -42,6 +41,9 @@ export { LevelComponent } from "./src/Object/Components/Level/LevelComponent";
 export { DirectionalLightComponent } from "./src/Object/Components/Light/DirectionalLight/DirectionalLightComponent";
 export { AmbientLightComponent } from './src/Object/Components/Light/AmbientLight/AmbientLightComponent';
 export { LabelComponent } from "./src/Object/Components/2D/2DComponent";
+export { CSS3DWebPanelComponent } from "./src/Object/Components/2D/CSS3DWebPanelComponent";
+export { Text3DComponent } from "./src/Object/Components/Text/Text3DComponent";
+export type { Text3DOptions } from "./src/Object/Components/Text/Text3DComponent";
 export { SkyComponent } from "./src/Object/Components/Sky/SkyComponent";
 export type { SkyComponentParam } from "./src/Object/Components/Sky/SkyComponent";
 export { DefaultSkyParam } from "./src/Object/Components/Sky/SkyComponent";
@@ -66,8 +68,12 @@ export type { LensFlareParam } from "./src/PostProcess/Param/LensFlare";
 export { PostProcessManager } from "./src/Frame/Rendering/PostProcess";
 export { Orbital } from "./src/Object/PawnV2/Oribital";
 export { FirstPerson } from "./src/Object/PawnV2/FirstPerson";
+export { Spectator } from "./src/Object/PawnV2/Spectator";
+export { Pawn } from "./src/Object/PawnV2/Pawn";
 export type { ITransforming } from "./src/Object/PawnV2/TransformControl";
 export type { TransformType } from "./src/Object/PawnV2/TransformControl";
 export type { TransformGizmoOptions } from "./src/Object/PawnV2/TransformControl";
 export { TransformGizmo } from "./src/Object/PawnV2/TransformControl";
 export { ThreeObjectLibrary } from "./src/Library/ResourceLibrary";
+export { PhysicsWorld, ColliderComponent, BoxColliderComponent, SphereColliderComponent, CapsuleColliderComponent, MeshColliderComponent, CollisionResponse, CollisionChannel, CollisionShapeType } from "./src/Physics";
+export type { LineTraceHitResult, PhysicsHitResult, CollisionResponseMap } from "./src/Physics";

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

@@ -1,23 +1,26 @@
-import { BufferGeometry, LoadingManager, Material, Mesh, Texture } from "three/webgpu";
-import { SceneComponent } from "../Object/Components/SceneComponent";
-import { TAssetPointer } from "./AssetPointer/AssetPointer";
-import { DRACOLoader, GLTF, GLTFLoader } from 'three/examples/jsm/Addons.js';
-import { Object3D } from "three/webgpu";
-import { ThreeJsApp } from "../ThreeJsApp";
-import { MaterialAssetPointer } from "./AssetPointer/Assets/MaterialAssetPointer";
-import { TextureAssetPointer } from "./AssetPointer/Assets/TextureAssetPointer";
-import { GeometryAssetPointer } from "./AssetPointer/Assets/GeometryAssetPointer";
+import { BufferGeometry, LoadingManager, Material, Mesh, Texture } from 'three/webgpu';
+import { SceneComponent } from '../Object/Components/SceneComponent';
+import { TAssetPointer } from './AssetPointer/AssetPointer';
+import { DRACOLoader, GLTF, GLTFLoader, KTX2Loader } from 'three/examples/jsm/Addons.js';
+import { Object3D } from 'three/webgpu';
+import { ThreeJsApp } from '../ThreeJsApp';
+import { MaterialAssetPointer } from './AssetPointer/Assets/MaterialAssetPointer';
+import { TextureAssetPointer } from './AssetPointer/Assets/TextureAssetPointer';
+import { GeometryAssetPointer } from './AssetPointer/Assets/GeometryAssetPointer';
 export declare class AssetManager {
     protected geometryAssets: Map<string, GeometryAssetPointer>;
     protected textureAssets: Map<string, TextureAssetPointer>;
     protected materialAssets: Map<string, MaterialAssetPointer>;
-    protected dracoLoader: DRACOLoader | null;
+    protected static _dracoLoader: DRACOLoader | null;
+    protected static _ktx2Loader: KTX2Loader | null;
     protected readonly gltfLoader: GLTFLoader;
     protected readonly loadingManager: LoadingManager;
     protected app: ThreeJsApp;
     constructor(app: ThreeJsApp);
     get LoadingManager(): LoadingManager;
+    get KTX2Loader(): KTX2Loader | null;
     init(): Promise<void>;
+    setupKTX2Loader(transcoderPath: string): Promise<void>;
     setupDracoLoader(dracoPath: string): void;
     convertThreeObjectToLYObject(parentLYComponent: SceneComponent, threejsObject: Object3D): SceneComponent | null;
     collectResourcesAndReferences(object: Object3D): void;
@@ -31,5 +34,6 @@ export declare class AssetManager {
     addTextureAsset(asset: Texture, referenceCount?: number): TextureAssetPointer;
     addGeometryAsset(asset: BufferGeometry, referenceCount?: number): GeometryAssetPointer;
     releaseAsset(asset: BufferGeometry | Material | Texture): void;
+    dispose(): void;
     clearAssets(): 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): 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,6 @@ export interface AppClass {
     viewportClass: typeof Viewport;
 }
 export interface AppParam {
-    renderParam?: RendererParameters;
     cameraParam?: CameraParam;
     postProcessParam?: PostProcessParam;
     worldParam?: WorldParam;

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

@@ -1,6 +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;
-    isUILayerNeeded: boolean;
+    renderer: {
+        type: RendererType;
+        param?: WebGPURendererParameters | WebGLRendererParameters;
+    };
+    isLabelRendererNeeded?: boolean;
+    isCSS3DRendererNeeded?: 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,35 +1,37 @@
+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;
+    private css3dRenderer;
     protected _app: ThreeJsApp | null;
     private resizeObserver;
     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;
@@ -40,13 +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;
-    setLogarithmicDepthBufferEnabled(enabled: boolean): void;
-    setDepth(depth: boolean): void;
-    setStencil(stencil: boolean): void;
     destroy(): void;
 }

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

@@ -1,20 +1,24 @@
-import { Scene } from "three/webgpu";
+import { ClippingGroup, Plane, Scene } from "three/webgpu";
 import { ThreeJsApp } from "../ThreeJsApp";
 import { Viewport } from "./Viewport";
 import { Controller } from "./Controller";
 import { Actor } from "../Object/Actor";
 import { LevelActor } from "../Object/Actors/Level/LevelActor";
 import { WorldParam } from "./Parameters/WorldParameter";
+import { PhysicsWorld } from "../Physics/PhysicsWorld";
 export declare class World {
     get scene(): Scene;
     get viewport(): Viewport;
     get controller(): Controller;
     get rootActor(): LevelActor;
+    get physics(): PhysicsWorld;
     protected _rootActor: LevelActor | null;
+    protected _physics: PhysicsWorld;
     protected app: ThreeJsApp;
     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;
@@ -26,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/CSS3DWebPanelComponent.d.ts

@@ -0,0 +1,26 @@
+import { CSS3DObject } from "three/examples/jsm/Addons.js";
+import { Mesh } from "three";
+import { SceneComponent } from "../SceneComponent";
+import { ThreeJsApp } from "../../../ThreeJsApp";
+export declare class CSS3DWebPanelComponent extends SceneComponent {
+    get threeObject(): CSS3DObject;
+    set threeObject(newThreeObject: CSS3DObject);
+    protected obj: CSS3DObject;
+    private wrapper;
+    private iframe;
+    private targetMesh;
+    private readonly meshes;
+    private readonly depthMaskMeshes;
+    private readonly alphaPunchMeshes;
+    private tickFunc;
+    private readonly cameraWorldPos;
+    private readonly panelWorldPos;
+    private readonly rayDir;
+    private readonly raycaster;
+    private occlusionCandidates;
+    constructor(app: ThreeJsApp, meshes: Mesh[], rawUrl: string, uuid?: string);
+    protected createDefaultObject(): CSS3DObject;
+    private setupMasks;
+    private setupOcclusionTick;
+    destroy(): 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

@@ -0,0 +1,18 @@
+import { CatmullRomCurve3, Line, Vector3 } from "three/webgpu";
+import { SceneComponent } from "../../SceneComponent";
+import { ThreeJsApp } from "../../../../ThreeJsApp";
+export declare class CurveComponent extends SceneComponent {
+    private curve;
+    protected createDefaultObject(): Line;
+    constructor(app: ThreeJsApp, uuid?: string);
+    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;
+    getCurve(): CatmullRomCurve3 | null;
+}

package/dist/src/Object/Components/Text/Text3DComponent.d.ts

@@ -0,0 +1,56 @@
+import { Object3D } from "three/webgpu";
+import { SceneComponent } from "../SceneComponent";
+import { ThreeJsApp } from "../../../ThreeJsApp";
+export interface Text3DOptions {
+    text?: string;
+    fontUrl?: string;
+    size?: number;
+    height?: number;
+    curveSegments?: number;
+    bevelEnabled?: boolean;
+    bevelThickness?: number;
+    bevelSize?: number;
+    bevelOffset?: number;
+    bevelSegments?: number;
+    color?: string;
+    sideColor?: string;
+    isUnlit?: boolean;
+}
+export declare class Text3DComponent extends SceneComponent {
+    private _text;
+    private _fontUrl;
+    private _size;
+    private _height;
+    private _curveSegments;
+    private _bevelEnabled;
+    private _bevelThickness;
+    private _bevelSize;
+    private _bevelOffset;
+    private _bevelSegments;
+    private _color;
+    private _sideColor;
+    private _isUnlit;
+    private _font;
+    private _mesh;
+    private _group;
+    private static _fontLoader;
+    private static _fontCache;
+    constructor(app: ThreeJsApp, options?: Text3DOptions, uuid?: string);
+    protected createDefaultObject(): Object3D;
+    get text(): string;
+    set text(value: string);
+    get color(): string;
+    set color(value: string);
+    get sideColor(): string;
+    set sideColor(value: string);
+    get size(): number;
+    set size(value: number);
+    get height(): number;
+    set height(value: number);
+    get fontUrl(): string;
+    set fontUrl(value: string);
+    private loadFontAndRefresh;
+    private refreshGeometry;
+    private updateMaterial;
+    destroy(): void;
+}

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

@@ -1,11 +1,57 @@
 import { Pawn } from "./Pawn";
-import { Controller } from "../../Frame/Controller";
-import { Vector3, Quaternion } from "three/webgpu";
+import { ThreeJsApp } from "../../ThreeJsApp";
+import { Vector3, Quaternion, Euler } from "three/webgpu";
+import { SceneComponent } from "../Components/SceneComponent";
 export declare class FirstPerson extends Pawn {
-    constructor(controller: Controller);
-    getFocuingData(): {
+    moveSpeed: number;
+    lookSpeed: number;
+    enableGravity: boolean;
+    gravity: number;
+    eyeHeight: number;
+    private _verticalVelocity;
+    private _yaw;
+    private _pitch;
+    private _targetPos;
+    private _clickMarker;
+    private _moveForward;
+    private _moveBackward;
+    private _moveLeft;
+    private _moveRight;
+    private _moveUp;
+    private _moveDown;
+    private _isRightDragging;
+    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(): {
         position: Vector3;
         quaternion: Quaternion;
-        distance: number;
-    } | null;
+    };
+    private onContextMenu;
+    private onBlur;
+    private onMouseDown;
+    private onMouseUp;
+    private onClick;
+    private onPointerLockChange;
+    private onMouseMove;
+    private setCameraDraggingState;
+    private onKeyDown;
+    private onKeyUp;
+    tick(deltaTime: number): void;
+    private updateCameraFromPawn;
 }

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

@@ -1,22 +1,45 @@
 import { Pawn } from "./Pawn";
-import { Controller } from "../../Frame/Controller";
-import { OrbitControls } from "three/examples/jsm/controls/OrbitControls.js";
-import { Euler, Quaternion, Vector3 } from "three";
+import { Euler, Quaternion, Vector3 } from "three/webgpu";
+import { ThreeJsApp } from "../../ThreeJsApp";
 export declare class Orbital extends Pawn {
-    private anim;
-    get control(): OrbitControls;
-    protected _control: OrbitControls;
-    protected changeEvent: () => void;
-    get camera(): import("three").PerspectiveCamera | import("three").OrthographicCamera;
-    constructor(controller: Controller);
+    distance: number;
+    minDistance: number;
+    maxDistance: number;
+    rotateSpeed: number;
+    zoomSpeed: number;
+    minPolarAngle: number;
+    maxPolarAngle: number;
+    minAzimuthAngle: number;
+    maxAzimuthAngle: number;
+    enableDamping: boolean;
+    dampingFactor: number;
+    private _isDragging;
+    private _lastPointerPosition;
+    private _targetPosition;
+    private _targetQuaternion;
+    private _targetDistance;
+    private _focusTween;
+    constructor(app: ThreeJsApp);
     possess(): void;
-    unpossess(): void;
-    onChange(): void;
-    focusTo(targetPos: Vector3, targetQuat: Quaternion | Euler, distance: number, time: number, onGoing?: (() => void) | null, onFinished?: (() => void) | null): void;
-    getFocuingData(): {
+    getTargetCameraState(): {
         position: Vector3;
         quaternion: Quaternion;
-        distance: number;
-    } | null;
+    };
+    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;
 }