lythreeframe 1.3.13 → 2.0.0

package/dist/index.d.ts

@@ -42,6 +42,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 +69,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

@@ -53,6 +53,7 @@ export declare class Controller {
     protected _app: ThreeJsApp;
     protected _pawn: Pawn | null;
     protected raycaster: Raycaster;
+    protected _switchPawnTween: gsap.core.Tween | null;
     protected hoveringComponent: SceneComponent | null;
     protected hoveringActor: Actor | null;
     protected prepareClickComponent: SceneComponent | null;
@@ -102,6 +103,7 @@ export declare class Controller {
     constructor(app: ThreeJsApp);
     init(): void;
     updateCamera(): void;
+    switchPawn(pawn: Pawn, cameraMoveTime?: number): Promise<void>;
     tick(deltaTime: number): void;
     destroy(): void;
     protected onPointerMoveEvent(event: MouseEvent): void;

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

@@ -1,6 +1,7 @@
 export interface ViewportParam {
     elementId: string | null;
     isLabelRendererNeeded: boolean;
+    isCSS3DRendererNeeded?: boolean;
     isUILayerNeeded: boolean;
 }
 export declare const DefaultViewportParam: ViewportParam;

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

@@ -13,6 +13,7 @@ export declare class Viewport {
     get app(): ThreeJsApp;
     private _renderer;
     private labelRenderer;
+    private css3dRenderer;
     protected _app: ThreeJsApp | null;
     private resizeObserver;
     private _outerContainer;
@@ -23,6 +24,7 @@ export declare class Viewport {
     constructor(app: ThreeJsApp, viewportParam: ViewportParam, rendererParam: RendererParameters, postProcessParam: PostProcessParam);
     protected createRenderer(rendererParam: RendererParameters): void;
     protected createLabelRenderer(): void;
+    protected createCSS3DRenderer(): void;
     protected createUILayer(): void;
     init(): void;
     protected setupPostProcess(): void;
@@ -45,7 +47,6 @@ export declare class Viewport {
     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

@@ -5,12 +5,15 @@ 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>;

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/Mesh/Line/CurveComponent.d.ts

@@ -0,0 +1,13 @@
+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[], closed?: boolean, curveType?: 'centripetal' | 'chordal' | 'catmullrom', tension?: number): 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,44 @@
 import { Pawn } from "./Pawn";
-import { Controller } from "../../Frame/Controller";
+import { ThreeJsApp } from "../../ThreeJsApp";
 import { Vector3, Quaternion } 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;
+    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;
 }

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/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,46 @@
+import { Box3, Matrix4, Mesh, MeshBasicMaterial, Object3D, Vector3 } from "three/webgpu";
+import { ThreeJsApp } from "../ThreeJsApp";
+import { ColliderComponent } from "./ColliderComponent";
+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;
+    raycast(origin: Vector3, dir: Vector3, maxDistance: number): {
+        point: Vector3;
+        normal: Vector3;
+        distance: number;
+    } | 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,31 @@
+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 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;
+}