lythreeframe 1.0.0

package/lythreeFrame/src/Object/Actor.ts

@@ -0,0 +1,571 @@
+import {Mesh, Vector3, Quaternion, Euler, Matrix4, Object3D, Group} from "three";
+import {BaseObject} from "./BaseObject";
+import {MeshComponent} from "./Components/Mesh/MeshComponent";
+import {AttachmentRules} from "../Defines";
+
+import {SceneComponent} from "./Components/SceneComponent.ts";
+import { World } from "../Frame/World.ts";
+
+export class Actor extends BaseObject
+{
+    get world()
+    {
+        return this._world;
+    }
+
+    get name():string
+    {
+        console.log("getname", this._name)
+        return this._name;
+    }
+    set name(name:string)
+    {
+        this._name = name;
+    }
+
+    get rootComponent():SceneComponent
+    {
+        if(!this._rootComponent)
+        {
+            throw Error("rootComponent is invalid")
+        }
+        return this._rootComponent;
+    }
+
+    set rootComponent(newRoot:SceneComponent)
+    {
+        newRoot.detachFromParentComponent();
+        newRoot.parentActor = this;
+        if (this._rootComponent)
+        {
+            let child = this.rootComponent.childrenComponents;
+            for (let i = 0; i < child.length; ++i)
+            {
+                newRoot.addChildComponent(child[i]);
+            }
+            this.rootComponent.destroy();
+        }
+        this._rootComponent = newRoot;
+
+    }
+
+    get childrenComponents()
+    {
+        return this.rootComponent.childrenComponents;
+    }
+
+    get childActors():Actor[]
+    {
+        let ret:Actor[] = []
+        this.rootComponent.threeObject?.children.forEach((elem) =>{
+            let p = elem.userData["LYObject"]?.parentActor;
+            if(p !== this && p instanceof Actor)
+            {
+                ret.push(p);
+            }
+        })
+        return ret;
+    }
+
+    get parentActor():Actor|null
+    {
+        let parent = this.rootComponent.threeObject?.parent?.userData["LYObject"].parentActor as Actor|null;
+        return parent === this ? null: parent;
+    }
+
+    get isVisible():boolean
+    {
+        return this.rootComponent ? this.rootComponent.isVisible : false;
+    }
+
+    protected _name:string = "Actor"
+
+    protected _rootComponent: SceneComponent|null = null;
+    protected _world        : World | null = 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 = null)
+    {
+        super();
+        this.constructRootComponent(myThreeObject);
+    }
+
+    protected constructRootComponent(myThreeObject:Object3D|null = null)
+    {
+        let tObject = myThreeObject ? myThreeObject : new Group()
+        if ((tObject as any).isMesh)
+        {
+            let mesh = tObject as Mesh
+            this._rootComponent             = new MeshComponent(mesh);
+            this.rootComponent.parentActor = this;
+        }
+        else 
+        {
+            this._rootComponent             = new SceneComponent(tObject);
+            this.rootComponent.parentActor = this;
+        }
+    }
+
+    getBoundsCenterPosition(bInWorldSpace = true)
+    {
+        let ret = new Vector3();
+        this.getBounds().getCenter(ret);
+        if (!bInWorldSpace)
+        {
+            return ret.sub(this.getPosition());
+        }
+        else
+        {
+            return ret;
+        }
+    }
+
+    getBoundsTopCenterPosition(bInWorldSpace = true)
+    {
+        let ret    = new Vector3();
+        let bounds = this.rootComponent.getBounds();
+        bounds.getCenter(ret);
+        ret.y = bounds.max.y;
+        if (!bInWorldSpace)
+        {
+            return ret.sub(this.getPosition());
+        }
+        else
+        {
+            return ret;
+        }
+    }
+
+    getBoundsBottomCenterPosition(bInWorldSpace = true)
+    {
+        let ret    = new Vector3();
+        let bounds = this.getBounds();
+        bounds.getCenter(ret);
+
+        ret.y = bounds.min.y;
+        if (!bInWorldSpace)
+        {
+            return ret.sub(this.getPosition());
+        }
+        else
+        {
+            return ret;
+        }
+    }
+
+    getBounds()
+    {
+        return this.rootComponent.getBounds();
+    }
+
+    destroy()
+    {
+        let childActors = this.childActors;
+        childActors.forEach((elem) =>
+        {
+            elem.destroy();
+        });
+        this.rootComponent.destroy();
+    }
+
+    setVisible(bVisible:boolean)
+    {
+        this.rootComponent.setVisible(bVisible);
+    }
+
+    setLayers(layer:number, bAffectChildActor = true)
+    {
+        this.rootComponent.setLayers(layer);
+        if (bAffectChildActor)
+        {
+            this.childActors.forEach((child) =>
+            {
+                child.setLayers(layer, bAffectChildActor);
+            });
+        }
+
+    }
+
+    tick(deltaTime:number):void
+    {
+        super.tick(deltaTime);
+        this.rootComponent.tick(deltaTime);
+    }
+
+    // Local Transforms
+    // // Position
+    getPosition():Vector3
+    {
+        return this.rootComponent.getPosition();
+    }
+    
+    setPosition(position:Vector3):void;
+    setPosition(x:number, y:number, z:number):void;
+    setPosition(...args:[Vector3] | [number, number, number]):void
+    {
+        if(args.length === 1)
+        {
+            this.rootComponent.setPosition(args[0]);
+        }
+        else
+        {
+            this.rootComponent.setPosition(args[0],args[1],args[2]);
+        }
+    }
+  
+    // // Rotation (euler)
+    getRotation():Euler
+    {
+        return this.rootComponent.getRotation();
+    }
+    setRotation(rotation:Euler):void;
+    setRotation(x:number, y:number, z:number):void;
+    setRotation(...args:[Euler]|[x:number, y:number, z:number])
+    {
+        if(args.length === 1)
+        {
+            this.rootComponent.setRotation(args[0]);
+        }
+        else
+        {
+            this.rootComponent.setRotation(args[0],args[1],args[2]);
+        }
+    }
+
+    // // quat
+    getQuaternion():Quaternion
+    {
+        return this.rootComponent.getQuaternion();
+    }
+    
+    setQuaternion(quat:Quaternion):void;
+    setQuaternion(x:number, y:number, z:number, w:number):void;
+    setQuaternion(...args:[Quaternion]|[x:number, y:number, z:number, w:number])
+    {
+        if(args.length === 1)
+        {
+            this.rootComponent.setQuaternion(args[0]);
+        }
+        else
+        {
+            this.rootComponent.setQuaternion(args[0],args[1],args[2],args[3]);
+        }
+    }
+  
+    // // Scale
+    getScale():Vector3
+    {
+        return this.rootComponent.getScale();
+    }
+    
+    setScale(position:Vector3):void;
+    setScale(x:number, y:number, z:number):void;
+    setScale(...args:[Vector3] | [number, number, number]):void
+    {
+        if(args.length === 1)
+        {
+            this.rootComponent.setScale(args[0]);
+        }
+        else
+        {
+            this.rootComponent.setScale(args[0],args[1],args[2]);
+        }
+    }
+    // World Transform 
+    // // Matrix
+    getWorldMatrix():Matrix4
+    {
+        return this.rootComponent.getWorldMatrix();
+    }
+
+    setWorldMatrix(newMatrix:Matrix4):void
+    {
+        this.rootComponent.setWorldMatrix(newMatrix);
+    }
+
+    // // WorldPosition
+    getWorldPosition():Vector3
+    {
+        return this.rootComponent.getWorldPosition();
+    }
+
+    // setWorldPosition(param1, param2 = undefined, param3 = undefined)
+    // {
+
+    // }
+    // // rotation(euler)
+    getWorldRotation():Euler
+    {
+        return this.rootComponent.getWorldRotation();
+    }
+
+    // // rotation(quat)
+    getWorldQuaternion():Quaternion
+    {
+        return this.rootComponent.getWorldQuaternion();
+    }
+
+    // // Scale
+    getWorldScale():Vector3
+    {
+        return this.rootComponent.getWorldScale();
+    }
+
+    getWorldForwardDirection():Vector3
+    {
+        return this.rootComponent.getWorldForwardDirection();
+    }
+
+    getWorldUpDirection():Vector3
+    {
+        return this.rootComponent.getWorldUpDirection();
+    }
+
+    getWorldRightDirection():Vector3
+    {
+        return this.rootComponent.getWorldRightDirection();
+    }
+
+    addLocalOffset(axis:Vector3, value:number)
+    {
+        let pos = this.getPosition();
+        this.setPosition(pos.x + axis.x * value, pos.y + axis.y * value, pos.z + axis.z * value);
+    }
+
+    worldToLocal(vec:Vector3):Vector3
+    {
+        return this.rootComponent.worldToLocal(vec);
+    }
+
+    localToWorld(vec:Vector3):Vector3
+    {
+        return this.rootComponent.localToWorld(vec);
+    }
+
+    getComponents()
+    {
+        return this.rootComponent.childrenComponents;
+    }
+
+    addComponent(newComponent:SceneComponent, attachmentRule:AttachmentRules = AttachmentRules.KeepRelative)
+    {
+        this.rootComponent.addChildComponent(newComponent, attachmentRule);
+        if (this._world)
+        {
+            newComponent.onAddedToWorld(this._world);
+        }
+    }
+
+    removeComponent(targetComponent:SceneComponent)
+    {
+        if (targetComponent === this._rootComponent)
+        {
+            return;
+        }
+        this.rootComponent.removeChildComponent(targetComponent);
+    }
+
+    clearComponent()
+    {
+        this.rootComponent.destroyChildren();
+    }
+
+    addChildActor(newActor:Actor, attachmentRule:AttachmentRules = AttachmentRules.KeepWorld)
+    {
+        if (!(newActor.rootComponent))
+        {
+            console.error("Actor :: addChildActor : the 'newActor' you want to add has no rootcomponent");
+            return;
+        }
+        if (newActor.parentActor === this)
+        {
+            return;
+        }
+        if (attachmentRule === AttachmentRules.KeepRelative)
+        {
+            this.rootComponent.attachComponent(newActor.rootComponent);
+        }
+        if (attachmentRule === AttachmentRules.KeepWorld)
+        {
+            let worldMatrix = newActor.getWorldMatrix();
+            this.rootComponent.attachComponent(newActor.rootComponent);
+            newActor.setWorldMatrix(worldMatrix);
+        }
+        if (this._world)
+        {
+            this._world.viewport.markRenderStateDirty();
+        }
+    }
+
+    removeChildActor(target:Actor)
+    {
+        let worldMatrix = target.getWorldMatrix();
+        this.rootComponent.detachComponent(target.rootComponent);
+        target.setWorldMatrix(worldMatrix);
+    }
+
+    removeFromParent()
+    {
+        if (this.parentActor)
+        {
+            this.parentActor.removeChildActor(this);
+        }
+    }
+
+    onAddedToWorld(world:World)
+    {
+        this._world = world;
+
+        this.rootComponent.onAddedToWorld(this._world);
+
+
+        this.childActors.forEach((elem) =>
+        {
+            elem.onAddedToWorld(world);
+        });
+    }
+
+    onRemovedFromWorld()
+    {
+        this._world = null;
+    }
+
+
+    get isHoverEnabled()
+    {
+        return this.rootComponent.isHoverEnabled;
+    }
+
+    set isHoverEnabled(bCanHorver:boolean)
+    {
+        this.rootComponent.isHoverEnabled = bCanHorver;
+    }
+
+    get isClickEnabled()
+    {
+        return this.rootComponent.isClickEnabled;
+    }
+
+    set isClickEnabled(bCanHorver)
+    {
+        this.rootComponent.isClickEnabled = bCanHorver;
+    }
+
+    // hovering begin
+    addHoveringBeginEvent(newFunc:(component?:SceneComponent)=>void)
+    {
+        this.onHoverBeginEvent.push(newFunc);
+    }
+
+    removeHoveringBeginEvent(target:(component?:SceneComponent)=>void)
+    {
+        let index = this.onHoverBeginEvent.indexOf(target);
+        if (index >= 0)
+        {
+            this.onHoverBeginEvent.splice(index, 1);
+        }
+    }
+
+    clearHoveringBeginEvent()
+    {
+        this.onHoverBeginEvent = [];
+    }
+
+    onComponentHorveringBegin(component:SceneComponent)
+    {
+        for (let i = 0; i < this.onHoverBeginEvent.length; ++i)
+        {
+            this.onHoverBeginEvent[i](component);
+        }
+    }
+
+    // hovering end
+    addHoveringEndEvent(newFunc:(component?:SceneComponent)=>void)
+    {
+        this.onHoverEndEvent.push(newFunc);
+    }
+
+    removeHoveringEndEvent(target:(component?:SceneComponent)=>void)
+    {
+        let index = this.onHoverEndEvent.indexOf(target);
+        if (index >= 0)
+        {
+            this.onHoverEndEvent.splice(index, 1);
+        }
+    }
+
+    clearHoveringEndEvent()
+    {
+        this.onHoverEndEvent = [];
+    }
+
+    onComponentHorveringEnd(component:SceneComponent)
+    {
+        // console.log("onComponentHorveringEnd", this)
+        for (let i = 0; i < this.onHoverEndEvent.length; ++i)
+        {
+            this.onHoverEndEvent[i](component);
+        }
+    }
+
+    //click
+    addClickEvent(newFunc:(component?:SceneComponent)=>void)
+    {
+        this.onClickedEvent.push(newFunc);
+    }
+
+    removeClickEvent(target:(component?:SceneComponent)=>void)
+    {
+        let index = this.onClickedEvent.indexOf(target);
+        if (index >= 0)
+        {
+            this.onClickedEvent.splice(index, 1);
+        }
+    }
+
+    clearClickEvent()
+    {
+        this.onClickedEvent = [];
+    }
+
+    onComponentClicked(component:SceneComponent)
+    {
+        //console.log("onComponentClicked", this.Name, component)
+        for (let i = 0; i < this.onClickedEvent.length; ++i)
+        {
+            this.onClickedEvent[i](component);
+        }
+    }
+
+    // double click
+    addDoubleClickEvent(newFunc:(component?:SceneComponent)=>void)
+    {
+        this.onDoubleClickedEvent.push(newFunc);
+    }
+
+    removeDoubleClickEvent(target:(component?:SceneComponent)=>void)
+    {
+        let index = this.onClickedEvent.indexOf(target);
+        if (index >= 0)
+        {
+            this.onDoubleClickedEvent.splice(index, 1);
+        }
+    }
+    onComponentDoubleClicked(component:SceneComponent)
+    {
+        //console.log("onComponentClicked", this.Name, component)
+        for (let i = 0; i < this.onDoubleClickedEvent.length; ++i)
+        {
+            this.onDoubleClickedEvent[i](component);
+        }
+    }
+    
+    clearDoubleClickEvent()
+    {
+        this.onDoubleClickedEvent = [];
+    }
+}

package/lythreeFrame/src/Object/Actors/Camera/CameraActor.ts

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

package/lythreeFrame/src/Object/Actors/Light/DirectionalLightActor.ts

@@ -0,0 +1,18 @@
+
+import {ColorRepresentation} from "three";
+import {Actor} from "../../Actor.ts";
+import {DirectionalLightComponent} from "../../Components/Light/DirectionalLight/DirectionalLightComponent.ts";
+
+export class DirectionalLightActor extends Actor
+{
+    protected lightComponent : DirectionalLightComponent
+    constructor(color:ColorRepresentation = 0xffffff, intensity:number = 1)
+    {
+        super();
+        this.lightComponent = new DirectionalLightComponent(color, intensity)
+        this.rootComponent = this.lightComponent
+        this.lightComponent.castShadow = true
+    }
+    
+   
+}

package/lythreeFrame/src/Object/Actors/Shape/BoxActor.ts

@@ -0,0 +1,20 @@
+
+import {Material, MeshBasicMaterial} from "three";
+import {Actor} from "../../Actor.ts";
+import {BoxComponent} from "../../Components/Mesh/Shape/BoxComponent.ts";
+
+export class BoxActor extends Actor
+{
+    constructor(  
+        width         :number   = 1,
+        height        :number   = 1,
+        depth         :number   = 1,
+        widthSegments :number   = 1,
+        heightSegments:number   = 1,
+        depthSegments :number   = 1,
+        material      :Material = new MeshBasicMaterial())
+    {
+        super();
+        this.addComponent(new BoxComponent(width, height, depth, widthSegments,heightSegments,depthSegments, material))
+    }
+}

package/lythreeFrame/src/Object/Actors/Shape/CurveActor.ts

@@ -0,0 +1,11 @@
+// import {CurveMaterial, LYBaseActor, LYCurveComponent} from "../../../../LYCustomFrame";
+// import {Vector3} from "three";
+// import { MeshLineMaterial } from 'three.meshline';
+// export class LYCurveActor extends LYBaseActor
+// {
+//     constructor(points:Vector3[] = [], material:MeshLineMaterial = CurveMaterial, tension:number = 0)
+//     {
+//         super();
+//         this.addComponent(new LYCurveComponent(points, material, tension))
+//     }
+// }

package/lythreeFrame/src/Object/Actors/Shape/PlaneActor.ts

@@ -0,0 +1,27 @@
+
+import {Material, MeshBasicMaterial} from "three";
+import {Actor} from "../../Actor.ts";
+import {PlaneComponent} from "../../Components/Mesh/Shape/PlaneComponent.ts";
+
+export class PlaneActor extends Actor
+{
+    get planeComponent(): PlaneComponent | null
+    {
+        return this._planeComponent;
+    }
+    private _planeComponent: PlaneComponent|null;
+    constructor(width:number, height:number, material:Material = new MeshBasicMaterial(), widthSegments:number = 1, heightSegments:number = 1)
+    {
+        super();
+        this._planeComponent = new PlaneComponent(width, height, material, widthSegments,heightSegments )
+        this._planeComponent.setRotation(Math.PI * 0.5 * -1 , 0,0)
+        this.addComponent(this._planeComponent)
+        this._planeComponent.receiveShadow = true
+    }
+    destroy()
+    {
+        this._planeComponent?.destroy()
+        this._planeComponent = null
+        super.destroy();
+    }
+}

package/lythreeFrame/src/Object/Actors/Shape/TubeActor.ts

@@ -0,0 +1,37 @@
+
+import {Material, MeshBasicMaterial} from "three";
+import {Actor} from "../../Actor.ts";
+
+export class LYTubeActor extends Actor
+{
+    constructor(width:number = 1, height:number = 1, depth:number = 1, material:Material = new MeshBasicMaterial())
+    {
+        // const points = [{
+        //     x: 0,
+        //     y: 0,
+        //     z: 0
+        // },
+        //     {
+        //         x: 100,
+        //         y: 0,
+        //         z: 0
+        //     },
+        //     {
+        //         x: 100,
+        //         y: 0,
+        //         z: 200
+        //     },
+        // ];
+        //
+        // const path = createPath(points);
+        //
+        // const pipeGeometry = new TubeGeometry(path, 256, radius, 64);
+        // const pipeMaterial = new MeshPhongMaterial({
+        //     color
+        // });
+        // const pipe = new Mesh(pipeGeometry, pipeMaterial);
+        //
+        // super();
+        // this.addComponent(new LYBoxComponent(width, height, depth, material))
+    }
+}