lythreeframe 1.0.0

package/lythreeFrame/src/Object/Components/SceneComponent.ts

@@ -0,0 +1,809 @@
+import {Actor} from "../Actor.ts";
+import {Box3, Euler, Group, Matrix4, Object3D, Quaternion, Vector3} from "three";
+import {Component} from "./Component.ts";
+import { World } from "../../Frame/World.ts";
+import { AttachmentRules } from "@threeframe/src/Defines.ts";
+
+export class SceneComponent extends Component
+{
+    set parentActor(value:Actor | null)
+    {
+        this.childrenComponents.forEach((elem) =>
+        {
+            elem.parentActor = value;
+        });
+        super.parentActor = value;
+    }
+
+    get parentActor():Actor | null
+    {
+        return super.parentActor;
+    }
+
+    protected bCanHover:boolean         = false;
+    protected bCanClick:boolean         = false;
+    protected world:World | null = null;
+
+    constructor(newThreeObject:Object3D)
+    {
+        super(newThreeObject);
+        this._name = "SceneComponent"
+    }
+
+    createDefaultThreeObject()
+    {
+        this.threeObject = new Group();
+    }
+
+    get isVisible():boolean
+    {
+        if(!this.threeObject)
+        {
+            return false
+        }
+        return this.threeObject.visible;
+    }
+
+    setVisible(bVisible:boolean)
+    {
+        if (!this.threeObject)
+        {
+            throw Error("threeObject is invalid")
+        }
+        this.threeObject.visible = bVisible;
+        if (this.world)
+        {
+            this.world.viewport.markRenderStateDirty();
+        }
+    }
+
+    setLayers(layer:number):void
+    {
+        if (!this.threeObject)
+        {
+            throw Error("threeObject is invalid")
+        }
+        this.threeObject.layers.set(layer);
+        let childComps = this.childrenComponents;
+        childComps.forEach((elem) =>
+        {
+            elem.setLayers(layer);
+        });
+    }
+
+    getBoundsCenterPositionWS():Vector3
+    {
+        let ret = new Vector3();
+        this.getBounds().getCenter(ret);
+        return this.getWorldPosition();
+    }
+
+    getBoundsTopCenterPositionWS():Vector3
+    {
+        let ret    = new Vector3();
+        let bounds = this.getBounds();
+        bounds.getCenter(ret);
+        ret.y = bounds.max.y;
+        return ret;
+    }
+
+    getBoundsBottomCenterPositionWS():Vector3
+    {
+        let ret    = new Vector3();
+        let bounds = this.getBounds();
+        bounds.getCenter(ret);
+        ret.y = bounds.min.y;
+        return ret;
+    }
+
+    getBounds():Box3
+    {
+        if (!this.threeObject)
+        {
+            throw Error("threeObject is invalid")
+        }
+        let ret = new Box3();
+        ret.setFromObject(this.threeObject, false);
+        if (ret.isEmpty())
+        {
+            ret.min = ret.max = this.getWorldPosition();
+        }
+        return ret;
+    }
+
+    get parentComponent():SceneComponent | null
+    {
+        if (!this.threeObject)
+        {
+            throw Error("threeObject is invalid")
+        }
+        let target = this.threeObject?.parent?.userData.LYObject
+        if(!target)
+        {
+            return null
+        }
+        if(!(target instanceof SceneComponent))
+        {
+            return null
+        }
+        if(target.parentActor !== this.parentActor)
+        {
+            return null
+        }
+        return target as SceneComponent;
+    }
+
+    get childrenComponents()
+    {
+        if (!this.threeObject)
+        {
+            throw Error("threeObject is invalid")
+        }
+        let childrens = [];
+    
+        for (let i = 0; i < this.threeObject.children.length; ++i)
+        {
+            if (!this.threeObject.children[i].userData.LYObject)
+            {
+                console.warn("One of children component has no parentActor", this.threeObject.children[i].userData.LYObject, this.threeObject.children[i]);
+                continue;
+            }
+            if (this.threeObject.children[i].userData.LYObject.parentActor === this.parentActor)
+            {
+                childrens.push(this.threeObject.children[i].userData.LYObject);
+            }
+        }
+    
+        return childrens;
+    }
+
+    onAddedToWorld(world:World)
+    {
+        this.world    = world;
+        let childrens = this.childrenComponents;
+        for (let i = 0; i < childrens.length; ++i)
+        {
+            childrens[i].onAddedToWorld(this.world);
+        }
+    }
+
+    destroy()
+    {
+        this.isHoverEnabled = false;
+        this.isClickEnabled = false;
+        this.detachFromParentActor();
+        this.detachFromParentComponent();
+        this.destroyChildren();
+        this.destroyObject();
+        if (this.world)
+        {
+            this.world.viewport.markRenderStateDirty();
+        }
+    }
+
+    destroyObject()
+    {
+        if (!this.threeObject)
+        {
+            return;
+        }
+        if (this.threeObject.parent)
+        {
+            this.threeObject.parent.remove(this.threeObject);
+        }
+
+        super.destroyObject();
+    }
+
+    // Local Transforms
+    // // Position
+    getPosition()
+    {
+        if (!this.threeObject)
+        {
+            throw Error("threeObject is invalid")
+        }
+        if (this.threeObject.matrixAutoUpdate)
+        {
+            return this.threeObject.position.clone();
+        }
+        else
+        {
+            const position   = new Vector3();
+            const quaternion = new Quaternion();
+            const scale      = new Vector3();
+            this.threeObject.matrix.decompose(position, quaternion, scale);
+            return position;
+        }
+    }
+    
+    setPosition(position:Vector3):void;
+    setPosition(x:number, y:number, z:number):void;
+    setPosition(...args:[Vector3] | [number, number, number]):void
+    {
+        if (!this.threeObject)
+        {
+            throw Error("threeObject is invalid")
+        }
+
+        let newPosition:Vector3 | null = null;
+
+        if (args.length === 1 && args[0] instanceof Vector3)
+        {
+            newPosition = new Vector3().copy(args[0]);
+        }
+        else if (args.length === 3 &&
+            typeof args[0] === "number" &&
+            typeof args[1] === "number" &&
+            typeof args[2] === "number")
+        {
+            newPosition = new Vector3(args[0], args[1], args[2]);
+        }
+
+        if (!newPosition)
+        {
+            return;
+        }
+
+        this.threeObject.position.copy(newPosition);
+
+        if (!this.threeObject.matrixAutoUpdate)
+        {
+            this.threeObject.matrix.setPosition(newPosition.x, newPosition.y, newPosition.z);
+        }
+
+        this.threeObject.updateMatrix();
+        this.threeObject.updateMatrixWorld(true);
+
+        if (this.world)
+        {
+            this.world.viewport.markRenderStateDirty();
+        }
+    }
+
+    // // Rotation
+    getRotation()
+    {
+        if (!this.threeObject)
+        {
+            throw Error("threeObject is invalid")
+        }
+        if (this.threeObject.matrixAutoUpdate)
+        {
+            return this.threeObject.rotation.clone();
+        }
+        else
+        {
+            const position   = new Vector3();
+            const quaternion = new Quaternion();
+            const scale      = new Vector3();
+            this.threeObject.matrix.decompose(position, quaternion, scale);
+            return new Euler().setFromQuaternion(quaternion);
+        }
+    }
+
+    setRotation(rotation:Euler):void;
+    setRotation(x:number, y:number, z:number):void;
+    setRotation(...args:[Euler]|[x:number, y:number, z:number])
+    {
+        if (!this.threeObject)
+        {
+            throw Error("threeObject is invalid")
+        }
+        let newRotation:Euler | null = null;
+        if (args[0] instanceof Euler)
+        {
+            newRotation = new Euler().copy(args[0]);
+        }
+        if (typeof (args[0]) === "number" && typeof (args[1]) === "number" && typeof (args[2]) === "number")
+        {
+            newRotation = new Euler(args[0], args[1], args[2]);
+        }
+        if (!newRotation)
+        {
+            return;
+        }
+        this.threeObject.rotation.copy(newRotation);
+
+        this.threeObject.updateMatrix();
+        this.threeObject.updateMatrixWorld(true);
+        if (this.world)
+        {
+            this.world.viewport.markRenderStateDirty();
+        }
+    }
+
+    // // quat
+    getQuaternion()
+    {
+        if (!this.threeObject)
+        {
+            throw Error("threeObject is invalid")
+        }
+        if (this.threeObject.matrixAutoUpdate)
+        {
+            return this.threeObject.quaternion.clone();
+        }
+        else
+        {
+            const position   = new Vector3();
+            const quaternion = new Quaternion();
+            const scale      = new Vector3();
+            this.threeObject.matrix.decompose(position, quaternion, scale);
+            return quaternion;
+        }
+    }
+
+    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 (!this.threeObject)
+        {
+            throw Error("threeObject is invalid")
+        }
+        let newQuat:Quaternion | null = null;
+        if (args[0] instanceof Quaternion)
+        {
+            newQuat = new Quaternion().copy(args[0]);
+        }
+        if (typeof args[0] === "number" && typeof args[1] === "number" && typeof args[2] === "number" && typeof args[3] === "number")
+        {
+            newQuat = new Quaternion(args[0], args[1], args[2], args[3]);
+        }
+        if (!newQuat)
+        {
+            console.error("setQuaternion failed,param is invalid", args);
+            return;
+        }
+        this.threeObject.quaternion.copy(newQuat);
+
+        if (!this.threeObject.matrixAutoUpdate)
+        {
+            const position   = new Vector3();
+            const quaternion = new Quaternion();
+            const scale      = new Vector3();
+            this.threeObject.matrix.decompose(position, quaternion, scale);
+            this.threeObject.matrix.compose(position, newQuat, scale);
+        }
+        if (this.world)
+        {
+            this.world.viewport.markRenderStateDirty();
+        }
+
+        this.threeObject.updateMatrix();
+        this.threeObject.updateMatrixWorld(true);
+
+    }
+
+    // // Scale
+    getScale()
+    {
+        if (!this.threeObject)
+        {
+            throw Error("threeObject is invalid")
+        }
+        if (this.threeObject.matrixAutoUpdate)
+        {
+            return this.threeObject.scale.clone();
+        }
+        else
+        {
+            const position   = new Vector3();
+            const quaternion = new Quaternion();
+            const scale      = new Vector3();
+            this.threeObject.matrix.decompose(position, quaternion, scale);
+            return scale;
+        }
+    }
+
+    setScale(position:Vector3):void;
+    setScale(x:number, y:number, z:number):void;
+    setScale(...args:[Vector3] | [number, number, number]):void
+    {
+        if (!this.threeObject)
+        {
+            throw Error("threeObject is invalid")
+        }
+
+        let newScale:Vector3 | null = null;
+        if (args[0] instanceof Vector3)
+        {
+            newScale = new Vector3().copy(args[0]);
+        }
+
+        if (typeof (args[0]) === "number" && typeof (args[1]) === "number" && typeof (args[2]) === "number")
+        {
+            newScale = new Vector3(args[0], args[1], args[2]);
+        }
+        if (!newScale)
+        {
+            return;
+        }
+        this.threeObject.scale.copy(newScale);
+        // if(!this.threeObject.matrixAutoUpdate)
+        // {
+        //     const position = new Vector3();
+        //     const quaternion = new Quaternion()
+        //     const scale = new Vector3();
+        //     this.threeObject.matrix.decompose(position, quaternion, scale)
+        //     this.threeObject.matrix.compose(position, quaternion, new Vector3(param1, param2, param3))
+        // }
+        this.threeObject.updateMatrix();
+        this.threeObject.updateMatrixWorld(true);
+
+        if (this.world)
+        {
+            this.world.viewport.markRenderStateDirty();
+        }
+    }
+
+    // matrix 
+    getMatrix():Matrix4
+    {
+        if (!this.threeObject)
+        {
+            throw Error("threeObject is invalid")
+        }
+        return this.threeObject.matrix;
+    }
+
+    setMatrix(matrix:Matrix4)
+    {
+        if (!this.threeObject)
+        {
+            throw Error("threeObject is invalid")
+        }
+        // this.threeObject.matrix.copy(matrix)
+        matrix.decompose(this.threeObject.position, this.threeObject.quaternion, this.threeObject.scale);
+        this.threeObject.updateMatrix();
+        this.threeObject.updateMatrixWorld(true);
+        this.world?.viewport.markRenderStateDirty();
+    }
+
+    // World Transform 
+    // // WorldPosition
+    getWorldPosition()
+    {
+        if (!this.threeObject)
+        {
+            throw Error("threeObject is invalid")
+        }
+        let location = new Vector3();
+        this.threeObject.getWorldPosition(location);
+        return location;
+    }
+
+
+    // // rotation(euler)
+    getWorldRotation()
+    {
+        if (!this.threeObject)
+        {
+            throw Error("threeObject is invalid")
+        }
+        let rotation = new Quaternion();
+        this.threeObject.getWorldQuaternion(rotation);
+        return new Euler().setFromQuaternion(rotation);
+    }
+
+
+    // // rotation(quat)
+    getWorldQuaternion()
+    {
+        if (!this.threeObject)
+        {
+            throw Error("threeObject is invalid")
+        }
+        let rotation = new Quaternion();
+        this.threeObject.getWorldQuaternion(rotation);
+        return rotation;
+    }
+
+    // // Scale
+    getWorldScale()
+    {
+        if (!this.threeObject)
+        {
+            throw Error("threeObject is invalid")
+        }
+        let scale = new Vector3();
+        this.threeObject.getWorldScale(scale);
+        return scale;
+    }
+
+    // // Matrix
+    getWorldMatrix()
+    {
+        if (!this.threeObject)
+        {
+            throw Error("threeObject is invalid")
+        }
+        this.threeObject.updateMatrixWorld(true);
+        return this.threeObject.matrixWorld.clone();
+    }
+
+    setWorldMatrix(newMatrix:Matrix4)
+    {
+        if (!this.threeObject)
+        {
+            throw Error("threeObject is invalid")
+        }
+        if (this.threeObject.parent)
+        {
+            this.threeObject.parent.updateMatrixWorld(true);
+            // 计算父对象的逆世界矩阵
+            const parentInverseWorldMatrix = this.threeObject.parent.matrixWorld.clone().invert();
+            // 计算物体的本地矩阵
+            const cLocalMatrix             = new Matrix4().multiplyMatrices(parentInverseWorldMatrix, newMatrix);
+
+            // 更新物体的本地矩阵
+            this.setMatrix(cLocalMatrix);
+            // this.threeObject.matrix.copy(cLocalMatrix);
+            // this.threeObject.matrixAutoUpdate = false;
+            // this.threeObject.matrix.decompose(this.threeObject.position, this.threeObject.quaternion, this.threeObject.scale);
+
+        }
+        else
+        {
+            this.setMatrix(newMatrix);
+
+            // // 没有父对象时直接设置世界矩阵为本地矩阵
+            // this.threeObject.matrix.copy(newMatrix);
+            // this.threeObject.matrixAutoUpdate = false;
+
+        }
+
+        // 更新世界矩阵
+        this.threeObject.updateMatrixWorld(true);
+
+        if (this.world)
+        {
+            // 强制场景重新渲染
+            this.world.viewport.markRenderStateDirty();
+        }
+
+
+    }
+
+    getWorldForwardDirection()
+    {
+        if (!this.threeObject)
+        {
+            throw Error("threeObject is invalid")
+        }
+        let ret = new Vector3();
+        this.threeObject.getWorldDirection(ret);
+        return ret;
+    }
+
+    getWorldUpDirection()
+    {
+        if (!this.threeObject)
+        {
+            throw Error("threeObject is invalid")
+        }
+        let ret = new Vector3(0, 1, 0);
+        ret.applyQuaternion(this.getWorldQuaternion());
+        return ret;
+    }
+
+    getWorldRightDirection()
+    {
+        if (!this.threeObject)
+        {
+            throw Error("threeObject is invalid")
+        }
+        let ret = new Vector3(1, 0, 0);
+        ret.applyQuaternion(this.getWorldQuaternion());
+        return ret;
+    }
+
+    worldToLocal(vec:Vector3):Vector3
+    {
+        if (!this.threeObject)
+        {
+            throw Error("threeObject is invalid")
+        }
+        return this.threeObject.worldToLocal(vec);
+    }
+
+    localToWorld(vec:Vector3):Vector3
+    {
+        if (!this.threeObject)
+        {
+            throw Error("threeObject is invalid")
+        }
+        return this.threeObject.localToWorld(vec);
+    }
+
+    // Attachment
+    // // to another component
+    // this function will not set newComponent's parentActor
+    attachComponent(newComponent:SceneComponent)
+    {
+        if (!this.threeObject)
+        {
+            throw Error("threeObject is invalid")
+        }
+        if (!newComponent.threeObject)
+        {
+            throw Error("newComponent threeObject is invalid")
+        }
+        this.threeObject.add(newComponent.threeObject);
+        if (this.world)
+        {
+            newComponent.onAddedToWorld(this.world);
+        }
+    }
+
+    detachComponent(target:SceneComponent)
+    {
+        if (!this.threeObject)
+        {
+            throw Error("threeObject is invalid")
+        }
+        if (!target.threeObject)
+        {
+            throw Error("target threeObject is invalid")
+        }
+        this.threeObject.remove(target.threeObject);
+    }
+
+      // newComponent's parentActor will be the same as this
+    addChildComponent(newComponent:SceneComponent, attachmentRule:AttachmentRules = AttachmentRules.KeepRelative)
+    {
+        if (!this.threeObject)
+        {
+            throw Error("threeObject is invalid")
+        }
+        if (!newComponent.threeObject)
+        {
+            throw Error("newComponent threeObject is invalid")
+        }
+        newComponent.parentActor = this.parentActor;
+
+        if(attachmentRule = AttachmentRules.KeepWorld)
+        {
+            let worldMatrix = newComponent.getWorldMatrix();
+            this.threeObject.add(newComponent.threeObject);
+            newComponent.setWorldMatrix(worldMatrix);
+        }
+        else
+        {
+            this.threeObject.add(newComponent.threeObject);
+        }
+        
+        if (this.world)
+        {
+            newComponent.onAddedToWorld(this.world);
+        }
+
+        this.threeObject.updateMatrix();
+        this.threeObject.updateMatrixWorld(true);
+    }
+
+    removeChildComponent(targetComponent:SceneComponent)
+    {
+        if (!this.threeObject)
+        {
+            throw Error("threeObject is invalid")
+        }
+        if (!targetComponent.threeObject)
+        {
+            throw Error("targetComponent threeObject is invalid")
+        }
+        this.threeObject.remove(targetComponent.threeObject);
+        targetComponent.destroy();
+    }
+
+
+    detachFromParentComponent()
+    {
+        if (this.parentComponent)
+        {
+            this.parentComponent.removeChildComponent(this);
+        }
+    }
+
+    detachFromParentActor()
+    {
+        if (this.parentActor)
+        {
+            this.parentActor = null;
+        }
+
+    }
+
+    destroyChildren()
+    {
+        if (!this.threeObject)
+        {
+            return;
+        }
+        for (let i = 0; i < this.threeObject.children.length; ++i)
+        {
+            this.threeObject.children[i].userData.LYObject.destroy();
+        }
+    }
+
+    /* horver */
+    set isHoverEnabled(bCanHorver:boolean)
+    {
+        this.bCanHover = bCanHorver;
+        
+        let children = this.childrenComponents;
+        for (let i = 0; i < children.length; ++i)
+        {
+            children[i].isHoverEnabled = this.bCanHover;
+        }
+    }
+
+    get isHoverEnabled()
+    {
+        return this.bCanHover;
+    }
+
+    // click
+    set isClickEnabled(bCanClick:boolean)
+    {
+        this.bCanClick = bCanClick;
+
+        let children = this.childrenComponents;
+        for (let i = 0; i < children.length; ++i)
+        {
+            children[i].isClickEnabled = this.bCanClick;
+        }
+    }
+
+    get isClickEnabled()
+    {
+        return this.bCanClick;
+    }
+
+    onHorveringBegin()
+    {
+        if (!this.isHoverEnabled)
+        {
+            return;
+        }
+        if (this.parentActor)
+        {
+            let comp = this;
+            this.parentActor.onComponentHorveringBegin(comp);
+        }
+    }
+
+    onHorveringEnd()
+    {
+        if (!this.isHoverEnabled)
+        {
+            return;
+        }
+        if (this.parentActor)
+        {
+            let comp = this;
+            this.parentActor.onComponentHorveringEnd(comp);
+        }
+    }
+
+    /* click */
+    onClicked()
+    {
+        if (this.parentActor)
+        {
+            let comp = this;
+            this.parentActor.onComponentClicked(comp);
+        }
+    }
+
+    onDoubleClicked()
+    {
+        if (this.parentActor)
+        {
+            let comp = this;
+            this.parentActor.onComponentDoubleClicked(comp);
+        }
+    }
+
+}