lythreeframe 1.0.0

package/lythreeFrame/exporter.ts

@@ -0,0 +1,36 @@
+// Loading functionality
+export {LYLoadTask} from "./src/AssetManagement/Task/Task";
+export {LYAssetManager} from "./src/AssetManagement/AssetManager";
+
+// Tools
+export {LYMaterialLibrary} from "./src/Library/MaterialLibrary";
+export {AttachmentRules} from "./src/Defines";
+export {Delegate as LYDelegate} from "./src/Delegate";
+
+// FrameRoot
+export {ThreeJsApp} from "./src/ThreeJsApp";
+export {Controller} from "./src/Frame/Controller";
+
+// Actors
+export {Actor} from "./src/Object/Actor";
+export {DirectionalLightActor} from "./src/Object/Actors/Light/DirectionalLightActor";
+export {BoxActor} from "./src/Object/Actors/Shape/BoxActor";
+export {PlaneActor} from "./src/Object/Actors/Shape/PlaneActor";
+
+// Components
+export {SceneComponent} from "./src/Object/Components/SceneComponent";
+export {MeshComponent} from "./src/Object/Components/Mesh/MeshComponent";
+export {BoxComponent} from "./src/Object/Components/Mesh/Shape/BoxComponent";
+export {PlaneComponent} from "./src/Object/Components/Mesh/Shape/PlaneComponent";
+export {SphereComponent} from "./src/Object/Components/Mesh/Shape/SphereComponent";
+
+export {DirectionalLightComponent} from "./src/Object/Components/Light/DirectionalLight/DirectionalLightComponent";
+export {LabelComponent} from "./src/Object/Components/2D/2DComponent";
+
+// Pawn
+export {Orbital} from "./src/Object/PawnV2/Oribital";
+export {FirstPerson} from "./src/Object/PawnV2/FirstPerson";
+
+
+// Shader
+export {ColorShader} from "./src/Shader/Postprocess/ColorShader";

package/lythreeFrame/src/AssetManagement/AssetDefines.ts

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

package/lythreeFrame/src/AssetManagement/AssetManager.ts

@@ -0,0 +1,286 @@
+import {BufferGeometry, FileLoader, LoadingManager, Material, Mesh, Texture,} from 'three';
+import {MeshComponent} from "../Object/Components/Mesh/MeshComponent";
+import {SceneComponent} from "../Object/Components/SceneComponent.ts";
+import {LYLoadTask} from "./Task/Task.ts";
+import {TAssetPointer} from "./AssetPointer/AssetPointer.ts";
+import { DRACOLoader, GLTF, GLTFLoader } from 'three/examples/jsm/Addons.js';
+
+// this class should be a singleton
+export class LYAssetManager
+{
+    protected assetPointer:Map<string, TAssetPointer<BufferGeometry | Texture | Material>> = new Map();
+    protected readonly dracoLoader:DRACOLoader;
+    protected readonly gltfLoader:GLTFLoader;
+    protected readonly loadingManager:LoadingManager;
+
+    constructor()
+    {
+        this.dracoLoader = new DRACOLoader();
+        this.dracoLoader.setDecoderPath(`./SceneResource/draco/`);
+        this.dracoLoader.setDecoderConfig({type:"js"});
+        this.dracoLoader.preload();
+
+        this.loadingManager = new LoadingManager();
+
+        this.gltfLoader = new GLTFLoader(this.loadingManager);
+        this.gltfLoader.setDRACOLoader(this.dracoLoader);
+    }
+
+    get LoadingManager():LoadingManager
+    {
+        return this.loadingManager;
+    }
+
+    static Get()
+    {
+        return assetManager;
+    }
+
+    static ClearAssets()
+    {
+        assetManager.clearAssets();
+    }
+
+    convertThreeObjectToLYObject(parentLYComponent:SceneComponent, threejsObject:any):SceneComponent | null
+    {
+        let location = threejsObject.position.clone();
+        let rotation = threejsObject.rotation.clone();
+        let scale    = threejsObject.scale.clone();
+
+        let newComp            = null;
+        let children           = threejsObject.children;
+        threejsObject.children = [];
+        if (threejsObject.type === "Group" || threejsObject.type === "Object3D")
+        {
+            newComp = new SceneComponent(threejsObject);
+        }
+        else if (threejsObject.isMesh)
+        {
+            let obj = threejsObject as Mesh;
+            newComp = new MeshComponent(obj);
+            // assetManager.#collectMatAndGeoInMesh(threejsObject)
+            threejsObject.layers.set(0);
+        }
+        else
+        {
+            newComp = new SceneComponent(threejsObject);
+        }
+        if (newComp === null)
+        {
+            threejsObject.children = children;
+            //threejsObject.parent = parent
+            console.log("Unprocess", threejsObject);
+            return null;
+        }
+        parentLYComponent.addChildComponent(newComp);
+
+        newComp.setPosition(location);
+        newComp.setRotation(rotation);
+        newComp.setScale(scale);
+        for (let i = 0; i < children.length; ++i)
+        {
+            this.convertThreeObjectToLYObject(newComp, children[i]);
+        }
+        return threejsObject.userData.LYObject;
+    }
+
+    private collectResourcesAndReferences(gltf:GLTF)
+    {
+        function countResource(map:Map<any, number>, resource:any)
+        {
+            if (!map.has(resource))
+            {
+                map.set(resource, 1);
+            }
+            else
+            {
+                map.set(resource, map.get(resource)! + 1);
+            }
+        }
+
+        const resources = {
+            geometries:new Map<BufferGeometry, number>(),
+            materials :new Map<Material, number>(),
+            textures  :new Map<Texture, number>()
+        };
+
+
+        gltf.scene.traverse((child:any) =>
+        {
+            if (child.geometry && child.geometry instanceof BufferGeometry)
+            {
+                countResource(resources.geometries, child.geometry);
+            }
+            if (child.material)
+            {
+                const mats = Array.isArray(child.material) ? child.material : [child.material];
+                mats.forEach((mat:Material|null) =>
+                {
+                    if (mat)
+                    {
+                        countResource(resources.materials, mat);
+                        Object.entries(mat).forEach(([key, value]) =>
+                            {
+                                if (value instanceof Texture)
+                                {
+                                    countResource(resources.textures, value);
+                                }
+                            }
+                        );
+                    }
+                });
+            }
+        });
+
+        function createPointer(manager:LYAssetManager, map:Map<BufferGeometry | Material | Texture, number>)
+        {
+            map.forEach((value, key:BufferGeometry | Material | Texture) =>
+            {
+                manager.addAsset(key, value);
+            });
+        }
+
+        createPointer(this, resources.geometries);
+        createPointer(this, resources.materials);
+        createPointer(this, resources.textures);
+
+        // console.log('Geometries:', Array.from(resources.geometries.entries()));
+        // console.log('Materials:', Array.from(resources.materials.entries()));
+        // console.log('Textures:', Array.from(resources.textures.entries()));
+        // console.log('assetPointer:', this.assetPointer);
+    }
+
+    public checkMeshResource(mesh:Mesh)
+    {
+        if(mesh.geometry)
+        {
+            if(!mesh.geometry.userData["assetPointer"])
+            {
+                this.addAsset(mesh.geometry)
+            }
+        }
+        
+        if(mesh.material)
+        {
+            const mats = Array.isArray(mesh.material) ? mesh.material : [mesh.material];
+            mats.forEach((material) => {
+                if (material) 
+                {
+                    if(!material.userData["assetPointer"])
+                    {
+                        this.addAsset(material)
+                    }
+                    Object.entries(material).forEach(([key, value]) => {
+                        if (value instanceof Texture)
+                        {
+                            if(!value.userData["assetPointer"])
+                            {
+                                this.addAsset(value)
+                            }
+                        }
+                    });
+                }
+            });
+        }
+    }
+    
+    loadMultiGLTFAsGroup(tasks:LYLoadTask[], onProgress:((url:string, loaded:number, total:number) => void) | null = null, onAllFinished:(() => void) | null = null)
+    {
+        this.loadingManager.onLoad     = onAllFinished ? () =>
+            {
+                this.loadingManager.onLoad = () =>
+                    {
+                    };
+                onAllFinished();
+            } : () =>
+            {
+                this.loadingManager.onLoad = () =>
+                    {
+                    };
+            };
+        this.loadingManager.onProgress = onProgress ? (url, loaded, total) =>
+            {
+                onProgress(url, loaded, total);
+            } : () =>
+            {
+            };
+        tasks.forEach(
+            (task) =>
+            {
+                task.Paths.forEach(
+                    (path) =>
+                    {
+                        const onGlbLoaded = (glb:GLTF) =>
+                            {
+                                task.onLoadingFinished(glb);
+                                this.collectResourcesAndReferences(glb);
+                            };
+                        try
+                        {
+                            this.gltfLoader.load(path, (glb:GLTF) =>
+                            {
+                                onGlbLoaded(glb);
+                            });
+                        } catch (e)
+                        {
+                            console.error(e, path);
+                        }
+                    });
+            }
+        );
+    }
+
+    loadFile(filepath = '', onLoadFinished:(data:any)=>void)
+    {
+        const loader = new FileLoader();
+        loader.load(filepath, (data) =>
+        {
+            onLoadFinished(data);
+        });
+    }
+
+    addAsset(asset:BufferGeometry | Material | Texture, referenceCount:number = 1)
+    {
+        let pointer:TAssetPointer<BufferGeometry | Material | Texture> | null = null;
+        if (!asset.userData["assetPointer"])
+        {
+            pointer                        = new TAssetPointer(asset, referenceCount);
+            asset.userData["assetPointer"] = pointer;
+        }
+        else
+        {
+            pointer = asset.userData["assetPointer"] as TAssetPointer<BufferGeometry | Material | Texture>;
+            pointer.addRef(referenceCount);
+        }
+        if (pointer)
+        {
+            this.assetPointer.set(pointer.uuid, pointer);
+        }
+    }
+
+    releaseAsset(asset:BufferGeometry | Material | Texture)
+    {
+        // let uuid = asset.uuid
+        let p = asset.userData["assetPointer"] as TAssetPointer<BufferGeometry | Material | Texture>;
+        if (p)
+        {
+            p.release();
+        }
+        else
+        {
+            asset.dispose();
+        }
+    }
+
+    clearAssets()
+    {
+        let pointers = Array.from(this.assetPointer.values());
+        pointers.forEach((p) =>
+        {
+            p.forceRelease();
+        });
+        this.assetPointer.clear();
+    }
+}
+
+let assetManager = new LYAssetManager();

package/lythreeFrame/src/AssetManagement/AssetPointer/AssetPointer.ts

@@ -0,0 +1,41 @@
+
+import {BufferGeometry, Material, Texture} from "three";
+import {TSmartPointer} from "../../Container/SmartPointer.ts";
+
+export class TAssetPointer<T extends BufferGeometry|Texture|Material> extends TSmartPointer<T>
+{
+    get uuid():string
+    {
+        return this._uuid;
+    }
+    private readonly _uuid:string
+    constructor(value: T, referenceCount:number = 1) 
+    {
+        super(value,referenceCount);
+        this._uuid = value.uuid
+    }
+
+    override release():void
+    {
+        if (this.value !== null)
+        {
+            this.referenceCount--;
+            
+            if (this.referenceCount === 0)
+            {
+                this.value.dispose();
+                this.value = null;
+            }
+        }
+    }
+
+    forceRelease()
+    {
+        if (this.value !== null)
+        {
+            this.value.dispose();
+            this.value = null
+            this.referenceCount = 0
+        }
+    }
+}

package/lythreeFrame/src/AssetManagement/Task/Task.ts

@@ -0,0 +1,24 @@
+export class LYLoadTask
+{
+    private readonly  paths    : string[]
+    private readonly  onLoaded : (loaded:any)=>void | null
+
+    constructor(paths:string[], onLoaded:(loaded:any)=>void )
+    {
+        this.paths = paths;
+        this.onLoaded = onLoaded;
+    }
+
+    get Paths()
+    {
+        return this.paths
+    }
+
+    onLoadingFinished(loaded:any)
+    {
+        if (this.onLoaded)
+        {
+            this.onLoaded(loaded)
+        }
+    }
+}

package/lythreeFrame/src/Container/SmartPointer.ts

@@ -0,0 +1,54 @@
+
+export class TSmartPointer<T>
+{
+    protected referenceCount:number                  = 1;
+    protected value:T | null                         = null;
+
+    constructor(value:T, referenceCount:number = 1)
+    {
+        this.value          = value;
+        this.referenceCount = referenceCount;
+    }
+
+    getRefCount():number
+    {
+        return this.referenceCount;
+    }
+
+    addRef(count:number = 1):void
+    {
+        if (this.value !== null)
+        {
+            this.referenceCount+=count;
+        }
+    }
+
+    release():void
+    {
+        if (this.value !== null)
+        {
+            this.referenceCount--;
+            console.log(`Reference count decreased to: ${this.referenceCount}`);
+
+            if (this.referenceCount === 0)
+            {
+                console.log("No more references. Deleting object.");
+                this.value = null;
+            }
+        }
+    }
+
+    forceRelease()
+    {
+        if (this.value !== null)
+        {
+            this.value = null
+            this.referenceCount = 0
+        }
+    }
+    
+    getValue():T | null
+    {
+        return this.value;
+    }
+}

package/lythreeFrame/src/Defines.ts

@@ -0,0 +1,11 @@
+// export const LYAttachmentRules = 
+// {
+//     KeepWorld: 1,
+//     KeepRelative: 2,
+// }
+
+export enum AttachmentRules
+{
+    KeepWorld = 1,
+    KeepRelative = 2,
+}

package/lythreeFrame/src/Delegate.ts

@@ -0,0 +1,37 @@
+export class Delegate<T extends any[]>
+{
+    private functions:Array<(...args:T) => void>;
+
+    constructor()
+    {
+        this.functions = [];
+    }
+
+    broadcast(...args:T):void
+    {
+        this.functions.forEach((func) => func(...args));
+    }
+
+    add(func:(...args:T) => void):void
+    {
+        this.functions.push(func);
+    }
+
+    remove(func:(...args:T) => void):void
+    {
+        const index = this.functions.indexOf(func);
+        if (index >= 0)
+        {
+            this.functions.splice(index, 1);
+        }
+        else
+        {
+            console.warn("function not found");
+        }
+    }
+
+    clear():void
+    {
+        this.functions = [];
+    }
+}

package/lythreeFrame/src/Factory/CameraFactory.ts

@@ -0,0 +1,81 @@
+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 class CameraFactory
+{
+    static createCamera(param:CameraParam)
+    {
+        let cam:PerspectiveCamera | OrthographicCamera | null = null;
+        if ("fov" in param.param && "aspect" in param.param)
+        {
+            cam = new PerspectiveCamera(param.param.fov, param.param.aspect, param.near, param.far);
+        }
+        if ("left" in param.param && "right" in param.param && "top" in param.param && "bottom" in param.param)
+        {
+            cam = new OrthographicCamera(param.param.left, param.param.right, param.param.top, param.param.bottom, param.near, param.far);
+        }
+        if (!cam)
+        {
+            console.error("create camera failed");
+            debugger
+            throw Error("create camera failed");
+        }
+        return cam
+    }
+
+    static updataCamera(param:CameraParam, camera:PerspectiveCamera | OrthographicCamera)
+    {
+        if ("fov" in param.param && "aspect" in param.param)
+        {
+            if (camera instanceof PerspectiveCamera)
+            {
+                camera.near   = param.near;
+                camera.far    = param.far;
+                camera.fov    = param.param.fov;
+                camera.aspect = param.param.aspect;
+                return camera
+            }
+            else
+            {
+                return new PerspectiveCamera(param.param.fov, param.param.aspect, param.near, param.far);
+            }
+        }
+        if ("left" in param.param && "right" in param.param && "top" in param.param && "bottom" in param.param)
+        {
+            if (camera instanceof OrthographicCamera)
+            {
+                camera.near   = param.near;
+                camera.far    = param.far;
+                camera.left   = param.param.left;
+                camera.right  = param.param.right;
+                camera.top    = param.param.top;
+                camera.bottom = param.param.bottom;
+                return camera
+            }
+            else
+            {
+                return new OrthographicCamera(param.param.left, param.param.right, param.param.top, param.param.bottom, param.near, param.far);
+            }
+        }
+    }
+}

package/lythreeFrame/src/Factory/RendererFactory.ts

@@ -0,0 +1,7 @@
+import { CSS2DRenderer } from "three/examples/jsm/renderers/CSS2DRenderer.js";
+
+
+export class RendererFactory
+{
+   
+}