lythreeframe 1.3.3 → 1.3.4

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

@@ -0,0 +1,52 @@
+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 { PostProcessManager } from "./Rendering/PostProcess";
+export declare class Viewport {
+    get uiDom(): HTMLDivElement | null;
+    protected _uiDom: HTMLDivElement | null;
+    get canvas(): HTMLElement | null;
+    get outer(): HTMLElement | null;
+    get renderer(): WebGPURenderer;
+    get app(): ThreeJsApp;
+    private _renderer;
+    private labelRenderer;
+    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 createLabelRenderer(): void;
+    protected createUILayer(): void;
+    init(): void;
+    protected setupPostProcess(): void;
+    /** Create the PostProcessManager instance. Override in subclass to use custom manager. */
+    protected createPostProcessManager(): PostProcessManager;
+    updatePostProcess(steps: PostProcessStepParam[]): void;
+    updateRendererSettings(data: RendererParameters): void;
+    addOutlineObject(obj: Object3D): void;
+    setOutlineObjects(objects: Object3D[]): void;
+    removeOutlineObject(obj: Object3D): void;
+    destroyPostProcess(): void;
+    onWindowResize(): void;
+    markRenderStateDirty(): void;
+    render(): void;
+    /** 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

@@ -0,0 +1,29 @@
+import { 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";
+export declare class World {
+    get scene(): Scene;
+    get viewport(): Viewport;
+    get controller(): Controller;
+    get rootActor(): LevelActor;
+    protected _rootActor: LevelActor | null;
+    protected app: ThreeJsApp;
+    protected actors: Set<Actor>;
+    protected tickableActors: Set<Actor>;
+    protected worldParam: WorldParam;
+    constructor(app: ThreeJsApp, worldParam: WorldParam);
+    init(): void;
+    addTickableActor(actor: Actor): void;
+    removeTickableActor(actor: Actor): void;
+    tick(deltaTime: number): void;
+    destroy(): void;
+    addActor(actor: Actor): void;
+    removeActor(actor: Actor): void;
+    removeActors(actors: Actor[]): void;
+    getActorById(id: string): Actor | null;
+    getActorsByIds(ids: string[]): Actor[];
+}

package/dist/src/Geometry/PlaneGeometry.d.ts

@@ -0,0 +1,3 @@
+import { BufferGeometry } from "three/webgpu";
+declare function createPlaneGeometryFaceUp(): BufferGeometry;
+export { createPlaneGeometryFaceUp };

package/dist/src/Geometry/TriangleGeometry.d.ts

@@ -0,0 +1,3 @@
+import { BufferGeometry } from "three/webgpu";
+declare function createArrowHeadGeometry(): BufferGeometry;
+export { createArrowHeadGeometry };

package/dist/src/Library/ContainerLibrary.d.ts

@@ -0,0 +1,3 @@
+export declare class LYContainerLibrary {
+    static AreUnorderedArrayEqual(arr1: any[], arr2: any[]): boolean;
+}

package/dist/src/Library/Debounce.d.ts

@@ -0,0 +1 @@
+export declare function debounce<T extends (...args: any[]) => any>(func: T, delay: number): (...args: Parameters<T>) => void;

package/dist/src/Library/Math.d.ts

@@ -0,0 +1,27 @@
+import { Vector3, Quaternion, Object3D, Box3, Plane, Euler } from "three/webgpu";
+export interface Segment {
+    pointA: Vector3;
+    pointB: Vector3;
+}
+export declare class LYMath {
+    static degreeToRadians(degree: number): number;
+    static radiansToDegree(radians: number): number;
+    static threeJsEulerAngleAsDegree(euler: Euler): {
+        x: number;
+        y: number;
+        z: number;
+    };
+    static getQuatFromAxis(forwardVector: Vector3, upVector?: Vector3): Quaternion;
+    static MaxVector(v1: Vector3, v2: Vector3): Vector3;
+    static clamp(value: number, min: number, max: number): number;
+    static getPlaneConstantFromPointAndNormal(point: Vector3, normal: Vector3): number;
+    static getSizeAndCenterOfObject3D(object: Object3D): {
+        boundingBox: Box3;
+        size: Vector3;
+        center: Vector3;
+    };
+    static SegmentsIntersection(segmentA: Segment, segmentB: Segment): Vector3 | null;
+    static getCenterPointInPoints(points: Vector3[]): Vector3;
+    static contructPlane(dirction: Vector3, position: Vector3, quaternion: Quaternion, scale: Vector3): Plane;
+    static intersectRayPlane(rayOrigin: Vector3, rayDirection: Vector3, planeNormal: Vector3, planePoint: Vector3): Vector3 | null;
+}

package/dist/src/Library/ResourceLibrary.d.ts

@@ -0,0 +1,7 @@
+import { Mesh, Object3D } from "three/webgpu";
+export declare class ThreeObjectLibrary {
+    static disposeMaterialTextures(material: any): void;
+    static disposeMeshMaterial(mesh: Mesh): void;
+    static disposeMeshResource(mesh: Mesh, recursive?: boolean): void;
+    static disposeObject3DResource(object: Object3D): void;
+}

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

@@ -0,0 +1,86 @@
+import { Euler, Matrix4, Quaternion, Vector3 } from "three/webgpu";
+import { AttachmentRules } from "../Defines";
+import { BaseObject } from "./BaseObject";
+import { World } from "../Frame/World";
+import { ThreeJsApp } from "../ThreeJsApp";
+import { SceneComponent } from "./Components/SceneComponent";
+import { Delegate } from "../Delegate";
+export declare class Actor extends BaseObject {
+    get world(): World | null;
+    get name(): string;
+    set name(name: string);
+    get rootComponent(): SceneComponent;
+    set rootComponent(newRoot: SceneComponent);
+    get childrenComponents(): any[];
+    get childActors(): Actor[];
+    get parentActor(): Actor | null;
+    get isVisible(): boolean;
+    get isTickEnabled(): boolean;
+    set isTickEnabled(bCanTick: boolean);
+    protected _name: string;
+    protected _rootComponent: SceneComponent | null;
+    protected _world: World | null;
+    protected app: ThreeJsApp;
+    protected _onHoverBeginDelegate: Delegate<[SceneComponent]>;
+    protected _onHoverEndDelegate: Delegate<[SceneComponent]>;
+    protected _onClickDelegate: Delegate<[SceneComponent]>;
+    protected _onDoubleClickDelegate: Delegate<[SceneComponent]>;
+    get onHoverBeginDelegate(): Delegate<[SceneComponent]>;
+    get onHoverEndDelegate(): Delegate<[SceneComponent]>;
+    get onClickDelegate(): Delegate<[SceneComponent]>;
+    get onDoubleClickDelegate(): Delegate<[SceneComponent]>;
+    constructor(app: ThreeJsApp, uuid?: string);
+    protected constructRootComponent(): SceneComponent;
+    getBoundsCenterPosition(bInWorldSpace?: boolean): Vector3;
+    getChildActorById(id: string, bRecursive?: boolean): Actor | null;
+    getChildActorsByIds(ids: string[], bRecursive?: boolean): Actor[];
+    getComponentById(id: string): SceneComponent | null;
+    getBoundsTopCenterPosition(bInWorldSpace?: boolean): Vector3;
+    getBoundsBottomCenterPosition(bInWorldSpace?: boolean): Vector3;
+    getBounds(): import("three").Box3;
+    destroy(): void;
+    setVisible(bVisible: boolean): void;
+    setLayers(layer: number, bAffectChildActor?: boolean): void;
+    tick(deltaTime: number): void;
+    getPosition(): Vector3;
+    setPosition(position: Vector3): void;
+    setPosition(x: number, y: number, z: number): void;
+    getRotation(): Euler;
+    setRotation(rotation: Euler): void;
+    setRotation(x: number, y: number, z: number): void;
+    getQuaternion(): Quaternion;
+    setQuaternion(quat: Quaternion): void;
+    setQuaternion(x: number, y: number, z: number, w: number): void;
+    getScale(): Vector3;
+    setScale(position: Vector3): void;
+    setScale(x: number, y: number, z: number): void;
+    getWorldMatrix(): Matrix4;
+    setWorldMatrix(newMatrix: Matrix4): void;
+    getWorldPosition(): Vector3;
+    getWorldRotation(): Euler;
+    getWorldQuaternion(): Quaternion;
+    getWorldScale(): Vector3;
+    getWorldForwardDirection(): Vector3;
+    getWorldUpDirection(): Vector3;
+    getWorldRightDirection(): Vector3;
+    addLocalOffset(axis: Vector3, value: number): void;
+    worldToLocal(vec: Vector3): Vector3;
+    localToWorld(vec: Vector3): Vector3;
+    getComponents(): any[];
+    addComponent(newComponent: SceneComponent, attachmentRule?: AttachmentRules): void;
+    removeComponent(targetComponent: SceneComponent): void;
+    clearComponent(): void;
+    addChildActor(newActor: Actor, attachmentRule?: AttachmentRules): void;
+    removeChildActor(target: Actor): void;
+    removeFromParent(): void;
+    onAddedToWorld(world: World): void;
+    onRemovedFromWorld(): void;
+    get isHoverEnabled(): boolean;
+    set isHoverEnabled(bCanHorver: boolean);
+    get isClickEnabled(): boolean;
+    set isClickEnabled(bCanHorver: boolean);
+    onActorHoverBegin(component: SceneComponent): void;
+    onActorHoverEnd(component: SceneComponent): void;
+    onActorClick(component: SceneComponent): void;
+    onActorDoubleClick(component: SceneComponent): void;
+}

package/dist/src/Object/Actors/Level/LevelActor.d.ts

@@ -0,0 +1,13 @@
+import { Scene } from "three/webgpu";
+import { ThreeJsApp } from "../../../ThreeJsApp";
+import { Actor } from "../../Actor";
+import { LevelComponent } from "../../Components/Level/LevelComponent";
+export declare class LevelActor extends Actor {
+    get scene(): Scene;
+    protected _scene: Scene | null;
+    constructor(app: ThreeJsApp, uuid?: string);
+    protected constructRootComponent(): LevelComponent;
+    tick(_deltaTime: number): void;
+    destroy(): void;
+    clearLevel(): void;
+}

package/dist/src/Object/Actors/Light/AmbientLightActor.d.ts

@@ -0,0 +1,9 @@
+import { ColorRepresentation } from "three/webgpu";
+import { Actor } from "../../Actor";
+import { ThreeJsApp } from "../../../ThreeJsApp";
+import { AmbientLightComponent } from "../../Components/Light/AmbientLight/AmbientLightComponent";
+export declare class AmbientLightActor extends Actor {
+    protected lightComponent: AmbientLightComponent | null;
+    constructor(app: ThreeJsApp, color?: ColorRepresentation, intensity?: number, uuid?: string);
+    protected constructRootComponent(): AmbientLightComponent;
+}

package/dist/src/Object/Actors/Light/DirectionalLightActor.d.ts

@@ -0,0 +1,9 @@
+import { ColorRepresentation } from "three/webgpu";
+import { Actor } from "../../Actor";
+import { DirectionalLightComponent } from "../../Components/Light/DirectionalLight/DirectionalLightComponent";
+import { ThreeJsApp } from "../../../ThreeJsApp";
+export declare class DirectionalLightActor extends Actor {
+    protected lightComponent: DirectionalLightComponent | null;
+    constructor(app: ThreeJsApp, color?: ColorRepresentation, intensity?: number, uuid?: string);
+    protected constructRootComponent(): DirectionalLightComponent;
+}

package/dist/src/Object/Actors/Shape/BoxActor.d.ts

@@ -0,0 +1,7 @@
+import { Actor } from "../../Actor";
+import { BoxComponent } from "../../Components/Mesh/Shape/BoxComponent";
+import { ThreeJsApp } from "../../../ThreeJsApp";
+export declare class BoxActor extends Actor {
+    constructor(app: ThreeJsApp, uuid?: string);
+    protected constructRootComponent(): BoxComponent;
+}

package/dist/src/Object/Actors/Shape/PlaneActor.d.ts

@@ -0,0 +1,8 @@
+import { Actor } from "../../Actor";
+import { PlaneComponent } from "../../Components/Mesh/Shape/PlaneComponent";
+import { ThreeJsApp } from "../../../ThreeJsApp";
+export declare class PlaneActor extends Actor {
+    constructor(app: ThreeJsApp, uuid?: string);
+    protected constructRootComponent(): PlaneComponent;
+    destroy(): void;
+}

package/dist/src/Object/Actors/Sky/SkyActor.d.ts

@@ -0,0 +1,9 @@
+import { ThreeJsApp } from "../../../ThreeJsApp";
+import { Actor } from "../../Actor";
+import { SkyComponent } from "../../Components/Sky/SkyComponent";
+export declare class SkyActor extends Actor {
+    protected _name: string;
+    protected skyComponent: SkyComponent | null;
+    constructor(app: ThreeJsApp, uuid?: string);
+    protected constructRootComponent(): SkyComponent;
+}

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

@@ -0,0 +1,14 @@
+export declare abstract class BaseObject {
+    get isTickEnabled(): boolean;
+    set isTickEnabled(bCanTick: boolean);
+    get uuid(): string;
+    protected bCanTick: boolean;
+    protected tickEvents: ((deltaTime: number) => void)[];
+    protected _uuid: string;
+    protected constructor(uuid?: string);
+    tick(deltaTime: number): void;
+    addTickEvent(event: (deltaTime: number) => void): void;
+    removeTickEvent(event: (deltaTime: number) => void): void;
+    clearTickEvents(): void;
+    destroy(): void;
+}

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

@@ -0,0 +1,14 @@
+import { CSS2DObject } from "three/examples/jsm/renderers/CSS2DRenderer.js";
+import { Vector2 } from "three/webgpu";
+import { SceneComponent } from "../SceneComponent";
+import { ThreeJsApp } from "../../../ThreeJsApp";
+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);
+    set isHoverEnabled(_bCanHorver: boolean);
+    set isClickEnabled(_bCanClick: boolean);
+    setVisible(bVisible: boolean): void;
+    destroy(): void;
+}

package/dist/src/Object/Components/Component.d.ts

@@ -0,0 +1,18 @@
+import { Object3D } from "three/webgpu";
+import { BaseObject } from "../BaseObject";
+import { Actor } from "../Actor";
+export declare abstract class Component extends BaseObject {
+    set parentActor(value: Actor | null);
+    get parentActor(): Actor | null;
+    get threeObject(): Object3D | null;
+    set threeObject(newThreeObject: Object3D);
+    get name(): string;
+    set name(name: string);
+    protected obj: Object3D | null;
+    protected _parentActor: Actor | null;
+    protected _name: string;
+    protected constructor(uuid?: string);
+    protected createDefaultObject(_arg?: any): Object3D | null;
+    destroyObject(): void;
+    destroy(): void;
+}

package/dist/src/Object/Components/Level/LevelComponent.d.ts

@@ -0,0 +1,9 @@
+import { Scene } from "three";
+import { SceneComponent } from "../SceneComponent";
+import { ThreeJsApp } from "../../../ThreeJsApp";
+export declare class LevelComponent extends SceneComponent {
+    get threeObject(): Scene;
+    protected set threeObject(newThreeObject: Scene);
+    constructor(app: ThreeJsApp, uuid?: string);
+    protected createDefaultObject(): Scene;
+}

package/dist/src/Object/Components/Light/AmbientLight/AmbientLightComponent.d.ts

@@ -0,0 +1,16 @@
+import { LightComponent } from "../LightComponent";
+import { ColorRepresentation, AmbientLight, Vector3 } from "three/webgpu";
+import { World } from "../../../../Frame/World";
+import { ThreeJsApp } from "../../../../ThreeJsApp";
+export declare class AmbientLightComponent extends LightComponent {
+    get threeObject(): AmbientLight;
+    set threeObject(newThreeObject: AmbientLight);
+    get castShadow(): boolean;
+    set castShadow(value: boolean);
+    constructor(app: ThreeJsApp, color?: ColorRepresentation, intensity?: number, uuid?: string);
+    protected createDefaultObject(): AmbientLight;
+    setPosition(...args: [Vector3] | [number, number, number]): void;
+    update(): void;
+    onAddedToWorld(world: World): void;
+    destroy(): void;
+}

package/dist/src/Object/Components/Light/DirectionalLight/DirectionalLightComponent.d.ts

@@ -0,0 +1,16 @@
+import { LightComponent } from "../LightComponent";
+import { ColorRepresentation, DirectionalLight, Vector3 } from "three/webgpu";
+import { World } from "../../../../Frame/World";
+import { ThreeJsApp } from "../../../../ThreeJsApp";
+export declare class DirectionalLightComponent extends LightComponent {
+    get threeObject(): DirectionalLight;
+    set threeObject(newThreeObject: DirectionalLight);
+    get castShadow(): boolean;
+    set castShadow(value: boolean);
+    constructor(app: ThreeJsApp, color?: ColorRepresentation, intensity?: number, uuid?: string);
+    protected createDefaultObject(): DirectionalLight;
+    setPosition(...args: [Vector3] | [number, number, number]): void;
+    update(): void;
+    onAddedToWorld(world: World): void;
+    destroy(): void;
+}

package/dist/src/Object/Components/Light/LightComponent.d.ts

@@ -0,0 +1,12 @@
+import { ColorRepresentation, Light } from "three/webgpu";
+import { SceneComponent } from "../SceneComponent";
+import { ThreeJsApp } from "../../../ThreeJsApp";
+export declare abstract class LightComponent extends SceneComponent {
+    get threeObject(): Light;
+    set threeObject(newThreeObject: Light);
+    get color(): number;
+    set color(color: ColorRepresentation);
+    get intensity(): number;
+    set intensity(intensity: number);
+    protected constructor(app: ThreeJsApp, uuid?: string);
+}

package/dist/src/Object/Components/Mesh/CustomMeshComponent.d.ts

@@ -0,0 +1,63 @@
+import { BufferGeometry, Color, Material, Mesh, Vector2, Vector3 } from "three/webgpu";
+import { SceneComponent } from "../SceneComponent";
+import { TAssetPointer } from "../../../AssetManagement/AssetPointer/AssetPointer";
+import { ThreeJsApp } from "../../../ThreeJsApp";
+/**
+ * 自定义模型数据接口
+ * 用户需要填写顶点、索引等必备数据来生成自定义模型
+ */
+export interface CustomMeshData {
+    /** 顶点位置数组 */
+    vertices: Vector3[];
+    /** 索引数组（可选，如果不提供或为空则使用耳切法自动三角化） */
+    indices?: number[];
+    /** 法线数组（可选，如果不提供则自动计算） */
+    normals?: Vector3[];
+    /** UV坐标数组（可选） */
+    uvs?: Vector2[];
+    /** 颜色数组（可选） */
+    colors?: Color[];
+}
+/**
+ * 自定义模型组件
+ * 根据用户填写的顶点、索引等数据生成自定义3D模型
+ */
+export declare class CustomMeshComponent extends SceneComponent {
+    get threeObject(): Mesh;
+    protected set threeObject(newThreeObject: Mesh);
+    get geometry(): BufferGeometry | null;
+    set geometry(geo: BufferGeometry);
+    get geometryPtr(): TAssetPointer<BufferGeometry>;
+    set geometryPtr(geo: TAssetPointer<BufferGeometry>);
+    get material(): Material;
+    get materialPtr(): TAssetPointer<Material>;
+    set material(newMat: Material);
+    set materialPtr(newMat: TAssetPointer<Material>);
+    protected _geometryPtr: TAssetPointer<BufferGeometry> | null;
+    protected _materialPtr: TAssetPointer<Material> | null;
+    protected _meshData: CustomMeshData;
+    constructor(app: ThreeJsApp, meshData: CustomMeshData, material: Material, uuid?: string);
+    /**
+     * 计算2D多边形的有向面积（用于判断顶点顺序）
+     * 正值表示逆时针，负值表示顺时针
+     */
+    private calculatePolygonArea;
+    /**
+     * 根据用户数据构建几何体
+     */
+    protected constructGeometry(data: CustomMeshData): BufferGeometry;
+    /**
+     * 更新几何体数据
+     */
+    set meshData(data: CustomMeshData);
+    get meshData(): CustomMeshData;
+    protected createDefaultObject(): Mesh;
+    set castShadow(bCast: boolean);
+    get castShadow(): boolean;
+    set receiveShadow(bReceive: boolean);
+    get receiveShadow(): boolean;
+    getBoundsCenterPosition(): Vector3;
+    getBoundsTopCenterPosition(): Vector3;
+    getBoundsBottomCenterPosition(): Vector3;
+    destroyObject(): void;
+}

package/dist/src/Object/Components/Mesh/MeshComponent.d.ts

@@ -0,0 +1,28 @@
+import { BufferGeometry, Material, Mesh, Vector3 } from "three/webgpu";
+import { SceneComponent } from "../SceneComponent";
+import { TAssetPointer } from "../../../AssetManagement/AssetPointer/AssetPointer";
+import { ThreeJsApp } from "../../../ThreeJsApp";
+export declare class MeshComponent extends SceneComponent {
+    get threeObject(): Mesh;
+    protected set threeObject(newThreeObject: Mesh);
+    get geometry(): BufferGeometry | null;
+    set geometry(geo: BufferGeometry);
+    get geometryPtr(): TAssetPointer<BufferGeometry>;
+    set geometryPtr(geo: TAssetPointer<BufferGeometry>);
+    get material(): Material | Material[];
+    get materialPtr(): TAssetPointer<Material>[];
+    set material(newMat: Material | Material[]);
+    set materialPtr(newMat: TAssetPointer<Material> | TAssetPointer<Material>[]);
+    protected _geometryPtr: TAssetPointer<BufferGeometry> | null;
+    protected _materialPtr: TAssetPointer<Material>[];
+    constructor(app: ThreeJsApp, geometry: BufferGeometry, material: Material | Material[], uuid?: string);
+    protected createDefaultObject(): Mesh;
+    set castShadow(bCast: boolean);
+    get castShadow(): boolean;
+    set receiveShadow(bReceive: boolean);
+    get receiveShadow(): boolean;
+    getBoundsCenterPosition(): Vector3;
+    getBoundsTopCenterPosition(): Vector3;
+    getBoundsBottomCenterPosition(): Vector3;
+    destroyObject(): void;
+}

package/dist/src/Object/Components/Mesh/Shape/BoxComponent.d.ts

@@ -0,0 +1,6 @@
+import { Material } from "three/webgpu";
+import { MeshComponent } from "../MeshComponent";
+import { ThreeJsApp } from "../../../../ThreeJsApp";
+export declare class BoxComponent extends MeshComponent {
+    constructor(app: ThreeJsApp, width?: number, height?: number, depth?: number, widthSegments?: number, heightSegments?: number, depthSegments?: number, material?: Material, uuid?: string);
+}

package/dist/src/Object/Components/Mesh/Shape/PlaneComponent.d.ts

@@ -0,0 +1,6 @@
+import { Material } from "three/webgpu";
+import { MeshComponent } from "../MeshComponent";
+import { ThreeJsApp } from "../../../../ThreeJsApp";
+export declare class PlaneComponent extends MeshComponent {
+    constructor(app: ThreeJsApp, width: number, height: number, material: Material, widthSegments?: number, heightSegments?: number, uuid?: string);
+}

package/dist/src/Object/Components/Mesh/Shape/SphereComponent.d.ts

@@ -0,0 +1,6 @@
+import { MeshBasicMaterial } from "three/webgpu";
+import { MeshComponent } from "../MeshComponent";
+import { ThreeJsApp } from "../../../../ThreeJsApp";
+export declare class SphereComponent extends MeshComponent {
+    constructor(app: ThreeJsApp, radius: number, material?: MeshBasicMaterial, widthSegments?: number, heightSegments?: number, uuid?: string);
+}

package/dist/src/Object/Components/Mesh/Sprite/SpriteComponent.d.ts

@@ -0,0 +1,9 @@
+import { Sprite, Texture } from "three/webgpu";
+import { SceneComponent } from "../../SceneComponent";
+import { ThreeJsApp } from "../../../../ThreeJsApp";
+export declare class SpriteComponent extends SceneComponent {
+    get threeObject(): Sprite;
+    set threeObject(newThreeObject: Sprite);
+    constructor(app: ThreeJsApp, texture: Texture, uuid?: string);
+    protected createDefaultObject(): Sprite;
+}

package/dist/src/Object/Components/SceneComponent.d.ts

@@ -0,0 +1,79 @@
+import { Actor } from "../Actor";
+import { Box3, Euler, Matrix4, Object3D, Quaternion, Vector3 } from "three/webgpu";
+import { Component } from "./Component";
+import { World } from "../../Frame/World";
+import { AttachmentRules } from "../../Defines";
+import { ThreeJsApp } from "../../ThreeJsApp";
+import { Delegate } from "../../Delegate";
+export declare class SceneComponent extends Component {
+    set parentActor(value: Actor | null);
+    get parentActor(): Actor | null;
+    protected bCanHover: boolean;
+    protected bCanClick: boolean;
+    protected _onHoverBeginDelegate: Delegate<[void]>;
+    protected _onHoverEndDelegate: Delegate<[void]>;
+    protected _onClickDelegate: Delegate<[void]>;
+    protected _onDoubleClickDelegate: Delegate<[void]>;
+    get onHoverBeginDelegate(): Delegate<[void]>;
+    get onHoverEndDelegate(): Delegate<[void]>;
+    get onClickDelegate(): Delegate<[void]>;
+    get onDoubleClickDelegate(): Delegate<[void]>;
+    get world(): World;
+    protected app: ThreeJsApp;
+    constructor(app: ThreeJsApp, uuid?: string);
+    protected createDefaultObject(): Object3D;
+    tick(deltaTime: number): void;
+    get isVisible(): boolean;
+    setVisible(bVisible: boolean): void;
+    setLayers(layer: number): void;
+    getComponentById(id: string, bRecursive?: boolean): SceneComponent | null;
+    getBoundsCenterPositionWS(): Vector3;
+    getBoundsTopCenterPositionWS(): Vector3;
+    getBoundsBottomCenterPositionWS(): Vector3;
+    getBounds(): Box3;
+    get parentComponent(): SceneComponent | null;
+    get childrenComponents(): any[];
+    onAddedToWorld(world: World): void;
+    destroy(): void;
+    destroyObject(): void;
+    getPosition(): Vector3;
+    setPosition(position: Vector3): void;
+    setPosition(x: number, y: number, z: number): void;
+    getRotation(): Euler;
+    setRotation(rotation: Euler): void;
+    setRotation(x: number, y: number, z: number): void;
+    getQuaternion(): Quaternion;
+    setQuaternion(quat: Quaternion): void;
+    setQuaternion(x: number, y: number, z: number, w: number): void;
+    getScale(): Vector3;
+    setScale(position: Vector3): void;
+    setScale(x: number, y: number, z: number): void;
+    getMatrix(): Matrix4;
+    setMatrix(matrix: Matrix4): void;
+    getWorldPosition(): Vector3;
+    getWorldRotation(): Euler;
+    getWorldQuaternion(): Quaternion;
+    getWorldScale(): Vector3;
+    getWorldMatrix(): Matrix4;
+    setWorldMatrix(newMatrix: Matrix4): void;
+    getWorldForwardDirection(): Vector3;
+    getWorldUpDirection(): Vector3;
+    getWorldRightDirection(): Vector3;
+    worldToLocal(vec: Vector3): Vector3;
+    localToWorld(vec: Vector3): Vector3;
+    attachComponent(newComponent: SceneComponent): void;
+    detachComponent(target: SceneComponent): void;
+    addChildComponent(newComponent: SceneComponent, attachmentRule?: AttachmentRules): void;
+    removeChildComponent(targetComponent: SceneComponent): void;
+    detachFromParentComponent(): void;
+    detachFromParentActor(): void;
+    destroyChildren(): void;
+    set isHoverEnabled(bCanHorver: boolean);
+    get isHoverEnabled(): boolean;
+    set isClickEnabled(bCanClick: boolean);
+    get isClickEnabled(): boolean;
+    onHorveringBegin(): void;
+    onHorveringEnd(): void;
+    onClicked(): void;
+    onDoubleClicked(): void;
+}

package/dist/src/Object/Components/Sky/SkyComponent.d.ts

@@ -0,0 +1,22 @@
+import { SkyMesh } from "three/examples/jsm/objects/SkyMesh.js";
+import { SceneComponent } from "../SceneComponent";
+import { ThreeJsApp } from "../../../ThreeJsApp";
+export interface SkyComponentParam {
+    turbidity: number;
+    rayleigh: number;
+    mieCoefficient: number;
+    mieDirectionalG: number;
+    elevation: number;
+    azimuth: number;
+}
+export declare const DefaultSkyParam: SkyComponentParam;
+export declare class SkyComponent extends SceneComponent {
+    get threeObject(): SkyMesh;
+    protected set threeObject(newThreeObject: SkyMesh);
+    private skyParam;
+    private sunPosition;
+    constructor(app: ThreeJsApp, skyparam?: SkyComponentParam, uuid?: string);
+    protected createDefaultObject(): SkyMesh;
+    private updateSky;
+    destroyObject(): void;
+}

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

@@ -0,0 +1,11 @@
+import { Pawn } from "./Pawn";
+import { Controller } from "../../Frame/Controller";
+import { Vector3, Quaternion } from "three/webgpu";
+export declare class FirstPerson extends Pawn {
+    constructor(controller: Controller);
+    getFocuingData(): {
+        position: Vector3;
+        quaternion: Quaternion;
+        distance: number;
+    } | null;
+}