lythreeframe 1.0.5 → 1.0.7

package/dist/index.d.ts

@@ -0,0 +1,42 @@
+export { LYLoadTask } from "./lythreeframe/AssetManagement/Task/Task";
+export { LYAssetManager } from "./lythreeframe/AssetManagement/AssetManager";
+export { AttachmentRules } from "./lythreeframe/Defines";
+export { Delegate } from "./lythreeframe/Delegate";
+export { ThreeJsApp, DefaultRenderParam, DefaultCameraParam, DefaultAppParam } from "./lythreeframe/ThreeJsApp";
+export type { AppParam } from "./lythreeframe/ThreeJsApp";
+export { Controller } from "./lythreeframe/Frame/Controller";
+export { Viewport } from "./lythreeframe/Frame/Viewport";
+export { World } from "./lythreeframe/Frame/World";
+export { Actor } from "./lythreeframe/Object/Actor";
+export { DirectionalLightActor } from "./lythreeframe/Object/Actors/Light/DirectionalLightActor";
+export { BoxActor } from "./lythreeframe/Object/Actors/Shape/BoxActor";
+export { PlaneActor } from "./lythreeframe/Object/Actors/Shape/PlaneActor";
+export { WebGPUPostProcessFactory } from "./lythreeframe/PostProcess/WebGPUPostProcessFactory";
+export { DefaultPostProcessParam } from "./lythreeframe/PostProcess/PostProcessParam";
+export type { PostProcessParam } from "./lythreeframe/PostProcess/PostProcessParam";
+export { DefaultBloomParam } from "./lythreeframe/PostProcess/Param/Bloom";
+export type { BloomParam } from "./lythreeframe/PostProcess/Param/Bloom";
+export { DefaultDenoiseParam } from "./lythreeframe/PostProcess/Param/Denoise";
+export type { DenoiseParam } from "./lythreeframe/PostProcess/Param/Denoise";
+export { DefaultDOFParam } from "./lythreeframe/PostProcess/Param/DOF";
+export type { DOFParam } from "./lythreeframe/PostProcess/Param/DOF";
+export { DefaultGTAOParam } from "./lythreeframe/PostProcess/Param/GTAO";
+export type { GTAOParam } from "./lythreeframe/PostProcess/Param/GTAO";
+export { DefaultOutlineParams } from "./lythreeframe/PostProcess/Param/Outline";
+export type { OutlineParams } from "./lythreeframe/PostProcess/Param/Outline";
+export { DefaultSSRParam } from "./lythreeframe/PostProcess/Param/SSR";
+export type { SSRParam } from "./lythreeframe/PostProcess/Param/SSR";
+export { DefaultToneMappingParams, ToneMappingOptions } from "./lythreeframe/PostProcess/Param/ToneMapping";
+export type { ToneMappingParams } from "./lythreeframe/PostProcess/Param/ToneMapping";
+export { SceneComponent } from "./lythreeframe/Object/Components/SceneComponent";
+export { MeshComponent } from "./lythreeframe/Object/Components/Mesh/MeshComponent";
+export { BoxComponent } from "./lythreeframe/Object/Components/Mesh/Shape/BoxComponent";
+export { PlaneComponent } from "./lythreeframe/Object/Components/Mesh/Shape/PlaneComponent";
+export { SphereComponent } from "./lythreeframe/Object/Components/Mesh/Shape/SphereComponent";
+export { DirectionalLightComponent } from "./lythreeframe/Object/Components/Light/DirectionalLight/DirectionalLightComponent";
+export { LabelComponent } from "./lythreeframe/Object/Components/2D/2DComponent";
+export { Orbital } from "./lythreeframe/Object/PawnV2/Oribital";
+export { FirstPerson } from "./lythreeframe/Object/PawnV2/FirstPerson";
+export type { ITransforming } from "./lythreeframe/Object/PawnV2/TransformControl";
+export { TransformType } from "./lythreeframe/Object/PawnV2/TransformControl";
+export { TransformGizmo } from "./lythreeframe/Object/PawnV2/TransformControl";

package/dist/lythreeframe/AssetManagement/AssetDefines.d.ts

@@ -0,0 +1,6 @@
+export declare enum AssetType {
+    geometry = 1,
+    material = 2,
+    texture = 3,
+    undefined = -1
+}

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

@@ -0,0 +1,23 @@
+import { BufferGeometry, LoadingManager, Material, Mesh, Texture } from 'three';
+import { SceneComponent } from "../Object/Components/SceneComponent";
+import { LYLoadTask } from "./Task/Task";
+import { TAssetPointer } from "./AssetPointer/AssetPointer";
+import { DRACOLoader, GLTFLoader } from 'three/examples/jsm/Addons.js';
+export declare class LYAssetManager {
+    protected assetPointer: Map<string, TAssetPointer<BufferGeometry | Texture | Material>>;
+    protected readonly dracoLoader: DRACOLoader;
+    protected readonly gltfLoader: GLTFLoader;
+    protected readonly loadingManager: LoadingManager;
+    constructor();
+    get LoadingManager(): LoadingManager;
+    static Get(): LYAssetManager;
+    static ClearAssets(): void;
+    convertThreeObjectToLYObject(parentLYComponent: SceneComponent, threejsObject: any): SceneComponent | null;
+    private collectResourcesAndReferences;
+    checkMeshResource(mesh: Mesh): void;
+    loadMultiGLTFAsGroup(tasks: LYLoadTask[], onProgress?: ((url: string, loaded: number, total: number) => void) | null, onAllFinished?: (() => void) | null): void;
+    loadFile(filepath: string | undefined, onLoadFinished: (data: any) => void): void;
+    addAsset(asset: BufferGeometry | Material | Texture, referenceCount?: number): void;
+    releaseAsset(asset: BufferGeometry | Material | Texture): void;
+    clearAssets(): void;
+}

package/dist/lythreeframe/AssetManagement/AssetPointer/AssetPointer.d.ts

@@ -0,0 +1,9 @@
+import { BufferGeometry, Material, Texture } from "three";
+import { TSmartPointer } from "../../Container/SmartPointer";
+export declare class TAssetPointer<T extends BufferGeometry | Texture | Material> extends TSmartPointer<T> {
+    get uuid(): string;
+    private readonly _uuid;
+    constructor(value: T, referenceCount?: number);
+    release(): void;
+    forceRelease(): void;
+}

package/dist/lythreeframe/AssetManagement/Task/Task.d.ts

@@ -0,0 +1,7 @@
+export declare class LYLoadTask {
+    private readonly paths;
+    private readonly onLoaded;
+    constructor(paths: string[], onLoaded: (loaded: any) => void);
+    get Paths(): string[];
+    onLoadingFinished(loaded: any): void;
+}

package/dist/lythreeframe/Container/SmartPointer.d.ts

@@ -0,0 +1,10 @@
+export declare class TSmartPointer<T> {
+    protected referenceCount: number;
+    protected value: T | null;
+    constructor(value: T, referenceCount?: number);
+    getRefCount(): number;
+    addRef(count?: number): void;
+    release(): void;
+    forceRelease(): void;
+    getValue(): T | null;
+}

package/dist/lythreeframe/Defines.d.ts

@@ -0,0 +1,4 @@
+export declare enum AttachmentRules {
+    KeepWorld = 1,
+    KeepRelative = 2
+}

package/dist/lythreeframe/Delegate.d.ts

@@ -0,0 +1,8 @@
+export declare class Delegate<T extends any[]> {
+    private functions;
+    constructor();
+    broadcast(...args: T): void;
+    add(func: (...args: T) => void): void;
+    remove(func: (...args: T) => void): void;
+    clear(): void;
+}

package/dist/lythreeframe/Factory/CameraFactory.d.ts

@@ -0,0 +1,20 @@
+import { OrthographicCamera, PerspectiveCamera } from "three";
+export interface CameraParam {
+    near: number;
+    far: number;
+    param: PerspectiveCameraParam | OrthographicCameraParam;
+}
+export interface PerspectiveCameraParam {
+    fov: number;
+    aspect: number;
+}
+export interface OrthographicCameraParam {
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+}
+export declare class CameraFactory {
+    static createCamera(param: CameraParam): PerspectiveCamera | OrthographicCamera;
+    static updataCamera(param: CameraParam, camera: PerspectiveCamera | OrthographicCamera): PerspectiveCamera | OrthographicCamera | undefined;
+}

package/dist/lythreeframe/Factory/RendererFactory.d.ts

@@ -0,0 +1,2 @@
+export declare class RendererFactory {
+}

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

@@ -0,0 +1,40 @@
+import { ThreeJsApp } from "../ThreeJsApp";
+import { Intersection, OrthographicCamera, PerspectiveCamera } from "three";
+import { World } from "./World";
+import { Viewport } from "./Viewport";
+import { Pawn } from "../Object/PawnV2/Pawn";
+import { Delegate } from "../Delegate";
+export declare class Controller {
+    private prepareClickComponent;
+    get camera(): PerspectiveCamera | OrthographicCamera;
+    get world(): World;
+    get viewPort(): Viewport;
+    get pawn(): Pawn;
+    private app;
+    private _pawn;
+    private raycaster;
+    private onPointerMove;
+    private onPointerEnter;
+    private onPointerLeave;
+    private onPointerUp;
+    private onPointerDown;
+    private pointerPosition;
+    private readonly doubleClickDelay;
+    private leftClickTimer;
+    private pointerLeftDownPosition;
+    private hoveringComponent;
+    private _pointButtonIsDown;
+    get onClickNothingDelegate(): Delegate<[void]>;
+    private _onClickNothingDelegate;
+    constructor(app: ThreeJsApp);
+    init(): void;
+    tick(deltaTime: number): void;
+    destroy(): void;
+    onPointerMoveEvent(event: MouseEvent): void;
+    onPointerUpEvent(event: MouseEvent): void;
+    onPointerDownEvent(event: MouseEvent): void;
+    onPointerEnterEvent(event: MouseEvent): void;
+    onPointerLeaveEvent(event: MouseEvent): void;
+    getHitResultUnderCursor(): Intersection | null;
+    getHitResultFromScreenPoint(x: number, y: number): Intersection | null;
+}

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

@@ -0,0 +1,50 @@
+import { PostProcessParam } from './../PostProcess/PostProcessParam';
+import { WebGPURendererParameters } from "three/src/renderers/webgpu/WebGPURenderer.js";
+import { WebGPURenderer } from "three/webgpu";
+import { BloomParam } from "../PostProcess/Param/Bloom";
+import { GTAOParam } from "../PostProcess/Param/GTAO";
+import { ToneMappingParams } from "../PostProcess/Param/ToneMapping";
+import { ThreeJsApp } from "../ThreeJsApp";
+import { SSRParam } from "../PostProcess/Param/SSR";
+import { OutlineParams } from '../PostProcess/Param/Outline';
+import { Object3D } from 'three/src/Three.WebGPU.Nodes.js';
+import { DOFParam } from '../PostProcess/Param/DOF';
+export declare class Viewport {
+    get canvas(): HTMLElement;
+    get renderer(): WebGPURenderer;
+    get app(): ThreeJsApp;
+    private _renderer;
+    private labelRenderer;
+    protected _app: ThreeJsApp | null;
+    private resizeObserver;
+    private _canvas;
+    private isRenderStateDirty;
+    private postProcessParam;
+    private postProcessing;
+    private scenePass;
+    private bloomPass;
+    private dofPass;
+    private GTAOPass;
+    private denoiseGTAOPass;
+    private ssrPass;
+    private outlinePass;
+    private fxaaPass;
+    private smaaPass;
+    private outlineObjects;
+    constructor(app: ThreeJsApp, elementId: string, rendererParam?: WebGPURendererParameters, postProcessParam?: PostProcessParam);
+    init(): void;
+    setupPostProcess(): void;
+    updateToneMappingParam(params: ToneMappingParams): void;
+    updateBloomPass(params: BloomParam): void;
+    updateGTAOParam(params: GTAOParam | null): void;
+    updateDOFParam(params: DOFParam | null): void;
+    updateSSRParam(params: SSRParam | null): void;
+    updateOutlineParam(params: OutlineParams | null): void;
+    addOutlineObject(obj: Object3D): void;
+    removeOutlineObject(obj: Object3D): void;
+    destroyPostProcess(): void;
+    onWindowResize(): void;
+    markRenderStateDirty(): void;
+    render(): void;
+    destroy(): void;
+}

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

@@ -0,0 +1,18 @@
+import { Scene } from "three";
+import { ThreeJsApp } from "../ThreeJsApp";
+import { Viewport } from "./Viewport";
+import { Controller } from "./Controller";
+import { Actor } from "../Object/Actor";
+export declare class World {
+    get scene(): Scene;
+    get viewport(): Viewport;
+    get controller(): Controller;
+    protected _scene: Scene;
+    protected app: ThreeJsApp;
+    protected actors: Set<Actor>;
+    constructor(app: ThreeJsApp);
+    init(): void;
+    tick(deltaTime: number): void;
+    addActor(actor: Actor): void;
+    destroy(): void;
+}

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

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

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

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

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

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

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

@@ -0,0 +1,27 @@
+import { Vector3, Quaternion, Object3D, Box3, Plane, Euler } from "three";
+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/lythreeframe/Library/ResourceLibrary.d.ts

@@ -0,0 +1,6 @@
+import { Mesh } from "three";
+export declare class ResourceLibrary {
+    static disposeMeshMaterial(mesh: Mesh): void;
+    static disposeMeshGeometry(mesh: Mesh): void;
+    static disposeMeshResource(mesh: Mesh): void;
+}

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

@@ -0,0 +1,86 @@
+import { Vector3, Quaternion, Euler, Matrix4, Object3D } from "three";
+import { BaseObject } from "./BaseObject";
+import { AttachmentRules } from "../Defines";
+import { SceneComponent } from "./Components/SceneComponent";
+import { World } from "../Frame/World";
+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;
+    protected _name: string;
+    protected _rootComponent: SceneComponent | null;
+    protected _world: World | null;
+    protected onClickedEvent: ((component?: SceneComponent) => void)[];
+    protected onDoubleClickedEvent: ((component?: SceneComponent) => void)[];
+    protected onHoverBeginEvent: ((component?: SceneComponent) => void)[];
+    protected onHoverEndEvent: ((component?: SceneComponent) => void)[];
+    constructor(myThreeObject?: Object3D | null);
+    protected constructRootComponent(myThreeObject?: Object3D | null): void;
+    getBoundsCenterPosition(bInWorldSpace?: boolean): Vector3;
+    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);
+    addHoveringBeginEvent(newFunc: (component?: SceneComponent) => void): void;
+    removeHoveringBeginEvent(target: (component?: SceneComponent) => void): void;
+    clearHoveringBeginEvent(): void;
+    onComponentHorveringBegin(component: SceneComponent): void;
+    addHoveringEndEvent(newFunc: (component?: SceneComponent) => void): void;
+    removeHoveringEndEvent(target: (component?: SceneComponent) => void): void;
+    clearHoveringEndEvent(): void;
+    onComponentHorveringEnd(component: SceneComponent): void;
+    addClickEvent(newFunc: (component?: SceneComponent) => void): void;
+    removeClickEvent(target: (component?: SceneComponent) => void): void;
+    clearClickEvent(): void;
+    onComponentClicked(component: SceneComponent): void;
+    addDoubleClickEvent(newFunc: (component?: SceneComponent) => void): void;
+    removeDoubleClickEvent(target: (component?: SceneComponent) => void): void;
+    onComponentDoubleClicked(component: SceneComponent): void;
+    clearDoubleClickEvent(): void;
+}

package/dist/lythreeframe/Object/Actors/Camera/CameraActor.d.ts

@@ -0,0 +1,4 @@
+import { Actor } from "../../Actor";
+export declare class CameraActor extends Actor {
+    constructor();
+}

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

@@ -0,0 +1,7 @@
+import { ColorRepresentation } from "three";
+import { Actor } from "../../Actor";
+import { DirectionalLightComponent } from "../../Components/Light/DirectionalLight/DirectionalLightComponent";
+export declare class DirectionalLightActor extends Actor {
+    protected lightComponent: DirectionalLightComponent;
+    constructor(color?: ColorRepresentation, intensity?: number);
+}

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

@@ -0,0 +1,5 @@
+import { Material } from "three";
+import { Actor } from "../../Actor";
+export declare class BoxActor extends Actor {
+    constructor(width?: number, height?: number, depth?: number, widthSegments?: number, heightSegments?: number, depthSegments?: number, material?: Material);
+}

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

@@ -0,0 +1,9 @@
+import { Material } from "three";
+import { Actor } from "../../Actor";
+import { PlaneComponent } from "../../Components/Mesh/Shape/PlaneComponent";
+export declare class PlaneActor extends Actor {
+    get planeComponent(): PlaneComponent | null;
+    private _planeComponent;
+    constructor(width: number, height: number, material?: Material, widthSegments?: number, heightSegments?: number);
+    destroy(): void;
+}

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

@@ -0,0 +1,10 @@
+export declare abstract class BaseObject {
+    get IsTickable(): boolean;
+    set IsTickable(bCanTick: boolean);
+    get uuid(): string;
+    protected bCanTick: boolean;
+    protected _uuid: string;
+    protected constructor(uuid?: string);
+    tick(deltaTime: number): void;
+    destroy(): void;
+}

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

@@ -0,0 +1,13 @@
+import { CSS2DObject } from "three/examples/jsm/renderers/CSS2DRenderer.js";
+import { Vector2 } from "three";
+import { SceneComponent } from "../SceneComponent";
+export declare class LabelComponent extends SceneComponent {
+    get threeObject(): CSS2DObject;
+    set threeObject(newThreeObject: CSS2DObject);
+    protected obj: CSS2DObject;
+    constructor(domElement: HTMLElement, center?: Vector2);
+    set isHoverEnabled(bCanHorver: boolean);
+    set isClickEnabled(bCanClick: boolean);
+    setVisible(bVisible: boolean): void;
+    destroy(): void;
+}

package/dist/lythreeframe/Object/Components/Camera/CameraComponent.d.ts

@@ -0,0 +1,26 @@
+import { SceneComponent } from "../SceneComponent";
+import { OrthographicCamera, PerspectiveCamera } from "three";
+interface CameraParam {
+    near: number;
+    far: number;
+    param: PerspectiveCameraParam | OrthographicCameraParam;
+}
+interface PerspectiveCameraParam {
+    fov: number;
+    aspect: number;
+}
+interface OrthographicCameraParam {
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+}
+export declare class CameraComponent extends SceneComponent {
+    get threeObject(): PerspectiveCamera | OrthographicCamera;
+    get camera(): PerspectiveCamera | OrthographicCamera;
+    private set threeObject(value);
+    protected obj: PerspectiveCamera | OrthographicCamera;
+    constructor(param?: CameraParam);
+    updateCamera(param: CameraParam): void;
+}
+export {};

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

@@ -0,0 +1,17 @@
+import { Object3D } from "three";
+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(newThreeObject: Object3D);
+    destroyObject(): void;
+    destroy(): void;
+}

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

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

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

@@ -0,0 +1,12 @@
+import { ColorRepresentation, Light } from "three";
+import { SceneComponent } from "../SceneComponent";
+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 obj: Light | null;
+    protected constructor(light: Light);
+}

package/dist/lythreeframe/Object/Components/Mesh/InstanceMesh/InstanceMeshComponent.d.ts

@@ -0,0 +1,7 @@
+import { BufferGeometry, Material, Matrix4 } from "three";
+import { MeshComponent } from "../MeshComponent";
+export declare class LYInstanceMeshComponent extends MeshComponent {
+    constructor(geometry: BufferGeometry, material: Material | Material[], matrices: Matrix4[]);
+    update(matrices: Matrix4[]): void;
+    destroy(): void;
+}

package/dist/lythreeframe/Object/Components/Mesh/InstanceMesh/MultiInstanceMeshComponent.d.ts

@@ -0,0 +1,13 @@
+import { Matrix4, Object3D } from "three";
+import { SceneComponent } from "../../SceneComponent";
+export declare class LYMultiInstanceMeshComponent extends SceneComponent {
+    get matrices(): Matrix4[];
+    private ins;
+    private count;
+    private object;
+    private _matrices;
+    constructor(object: Object3D, matrices: Matrix4[]);
+    private collectMeshes;
+    update(matrices: Matrix4[]): void;
+    destroy(): void;
+}

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

@@ -0,0 +1,22 @@
+import { BufferGeometry, Material, Mesh } from 'three';
+import { Vector3 } from "three";
+import { SceneComponent } from "../SceneComponent";
+export declare class MeshComponent extends SceneComponent {
+    get threeObject(): Mesh | null;
+    set threeObject(newThreeObject: Mesh);
+    protected obj: Mesh | null;
+    get geometry(): BufferGeometry | null;
+    set geometry(geo: BufferGeometry);
+    get material(): Material | Material[] | null;
+    set material(newMat: Material | Material[]);
+    constructor(mesh: Mesh);
+    constructor(geometry: BufferGeometry, material: Material | Material[] | null);
+    set castShadow(bCast: boolean);
+    get castShadow(): boolean;
+    set receiveShadow(bReceive: boolean);
+    get receiveShadow(): boolean;
+    getBoundsCenterPosition(): Vector3;
+    getBoundsTopCenterPosition(): Vector3;
+    getBoundsBottomCenterPosition(): Vector3;
+    destroyObject(): void;
+}

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

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

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

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

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

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

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

@@ -0,0 +1,8 @@
+import { Sprite, Texture } from "three";
+import { SceneComponent } from "../../SceneComponent";
+export declare class SpriteComponent extends SceneComponent {
+    get threeObject(): Sprite;
+    set threeObject(newThreeObject: Sprite);
+    protected obj: Sprite;
+    constructor(texture: Texture);
+}