lythreeframe 1.0.0

package/lythreeFrame/src/Object/Controller/Controller.ts

@@ -0,0 +1,764 @@
+
+// import {LYRaycaster} from '../Raycast/Raycaster';
+// import {PerspectiveCamera, Quaternion, Vector2, Camera, Object3D, Vector3, Mesh} from "three";
+// import {LYOrbital} from "../Pawn/Oribital";
+// import {ITransforming, LYTransformControl} from "../Pawn/TransformControl";
+// import {LYDelegate} from "../../Delegate";
+// import {LYThreeWorld} from "../../Frame";
+
+// import {SceneComponent} from "../Components/SceneComponent.ts";
+// import {PawnBase} from "../Pawn/PawnBase.ts";
+
+// const maxClickTime = 0.15; // The time between left mouse button down and left mouse button up if greater than this, will not trigger click event. 
+
+// // forever tick
+// export class LYController 
+// {
+//     protected hoverable: SceneComponent[] = []
+//     protected clickable: SceneComponent[] = []
+//     protected blockingMesh: Mesh[]        = []
+//     protected world:LYThreeWorld
+//     protected pawn: PawnBase | null           = null
+//     protected cameraStat
+//     protected camera: Camera | null
+//     protected transformControl
+//     protected onClickNullEvent: Function[]    = []
+//     protected bLeftMouseButtonDown: boolean   = false
+//     protected leftMouseButtonDownTime: number = 0
+
+//     protected onMouseUpDelegate: LYDelegate    = new LYDelegate();
+//     protected onMouseMoveDelegate: LYDelegate  = new LYDelegate();
+//     protected onMouseEnterDelegate: LYDelegate = new LYDelegate();
+//     protected onMouseLeaveDelegate: LYDelegate = new LYDelegate();
+
+//     protected resizeObserver
+//     protected onPointerUpFunc: Function
+//     protected onPointerDownFunc: Function
+//     protected onPointerMoveFunc: Function
+//     protected onPointerEnterFunc: Function
+//     protected onPointerLeaveFunc: Function
+
+//     protected pointer: Vector2;
+//     private hoveringComp: SceneComponent[] = [];
+
+//     private ray                                    = null;
+//     public bLockCameraRotationByMouseMove: boolean = false;
+//     public bCameraRotationLockedAlready: boolean   = true;
+//     private startPointerDownPos: Vector2;
+
+//     protected onCameraMoveEvents: Function[]    = []
+//     private onCameraMove: Function
+//     private onCameraChangedDelegate: LYDelegate = new LYDelegate()
+
+//     get hoverDepth(): number
+//     {
+//         return this._hoverDepth;
+//     }
+
+//     set hoverDepth(value: number)
+//     {
+//         this._hoverDepth = Math.floor(value);
+//     }
+
+//     private _hoverDepth: number = 1;
+
+//     constructor(world: LYThreeWorld)
+//     {
+
+//         this.world = world
+
+
+//         this.transformControl = null;
+
+//         this.pointer = new Vector2();
+
+//         this.ray       = null
+//         this.hoverable = [];
+//         this.clickable = []
+
+//         this.cameraStat = null;
+
+//         this.IsTickable = true;
+
+//         this.leftMouseButtonDownTime = 0;
+//         this.bLeftMouseButtonDown    = false;
+
+//         this.onPointerMoveFunc  = () =>
+//             {
+//                 this.onPointerMove(event)
+//             };
+//         this.onPointerDownFunc  = () =>
+//             {
+//                 this.onPointerDown(event)
+//             };
+//         this.onPointerUpFunc    = () =>
+//             {
+//                 this.onPointerUp(event)
+//             };
+//         this.onPointerEnterFunc = () =>
+//             {
+//                 this.onMouseEnterCanvas()
+//             };
+//         this.onPointerLeaveFunc = () =>
+//             {
+//                 this.onMouseLeaveCanvas()
+//             };
+//         this.onCameraMove       = () =>
+//             {
+//                 this.onCameraMoveEvents.forEach((elem) =>
+//                 {
+//                     elem()
+//                 })
+//             }
+//         this.switchPawnMode(new LYOrbital(this.world))
+
+//     }
+
+//     init()
+//     {
+//         // if (!this.camera)
+//         // {
+//         //     let ele = this.world.Element;
+//         //     this.switchCamera(new PerspectiveCamera(90, ele.clientWidth / ele.clientHeight, 0.5, 7000))
+//         // }
+//         // if (!this.pawn)
+//         // {
+//         //     this.pawn = new LYOrbital(this.world, this.Camera);
+//         //     this.pawn.possess(this.onCameraMove);
+//         // }
+
+//         this.resizeObserver = new ResizeObserver((entries) =>
+//         {
+//             for (let entry of entries)
+//             {
+//                 if (entry.contentBoxSize)
+//                 {
+//                     this.onWindowResize()
+//                 }
+//             }
+//         });
+//         this.resizeObserver.observe(this.world.OuterElement);
+
+//         this.onMouseEnterCanvas()
+//         let ele = this.world.Element
+//         ele.addEventListener('mouseenter', this.onPointerEnterFunc);
+//         ele.addEventListener("mouseleave", this.onPointerLeaveFunc);
+//     }
+
+    
+//     addCameraMoveEvent(newFunc: Function)
+//     {
+//         this.onCameraMoveEvents.push(newFunc)
+//     }
+
+//     removeCameraMoveEvent(target: Function)
+//     {
+//         let index = this.onCameraMoveEvents.indexOf(target)
+//         if (index >= 0)
+//         {
+//             this.onCameraMoveEvents.splice(index, 1)
+//         }
+//     }
+
+//     get OnMouseUp()
+//     {
+//         return this.onMouseUpDelegate
+//     }
+
+//     get OnMouseMove()
+//     {
+//         return this.onMouseMoveDelegate
+//     }
+
+//     get onMouseEnter()
+//     {
+//         return this.onMouseEnterDelegate
+//     }
+
+//     get onMouseLeave()
+//     {
+//         return this.onMouseLeaveDelegate
+//     }
+
+//     // forever tick
+//     set IsTickable(bCanTick)
+//     {
+//         super.IsTickable = true;
+//     }
+
+//     // tick function, not supposed to be called
+//     tick(deltaTime:number)
+//     {
+
+//         if (this.pawn)
+//         {
+//             this.pawn.tick(deltaTime)
+//         }
+//         if (this.transformControl)
+//         {
+//             this.transformControl.tick(deltaTime)
+
+//         }
+//         if (this.bLeftMouseButtonDown)
+//         {
+//             this.leftMouseButtonDownTime += deltaTime
+//         }
+//     }
+
+//     // current camera
+//     get Camera(): Camera | null
+//     {
+//         return this.pawn?.Camera || null;
+//     }
+
+//     get onCameraChanged(): LYDelegate
+//     {
+//         return this.onCameraChangedDelegate
+//     }
+    
+//     // control method
+//     get PawnMode()
+//     {
+//         return this.pawn
+//     }
+
+//     switchPawnMode(newPawn: PawnBase)
+//     {
+//         let oldPawn = this.pawn
+
+//         this.pawn = newPawn
+//         if (oldPawn)
+//         {
+//             oldPawn.unpossess();
+//             oldPawn.destroy();
+//         }
+//         this.pawn.addOnChangeEvent(this.onCameraMove)
+//         this.pawn.possess();
+//         this.onCameraChanged.broadcast()
+
+//         this.world.markRenderStateDirty();
+//     }
+
+//     // transform position
+//     setPosition(param1, param2 = undefined, param3 = undefined)
+//     {
+//         if (this.pawn)
+//         {
+//             this.pawn.setPosition(param1, param2, param3)
+//             this.world.markRenderStateDirty();
+//         }
+//     }
+
+//     // transform quaternion
+//     setQuaternion(newQuat)
+//     {
+//         if (this.pawn)
+//         {
+//             this.pawn.setQuaternion(newQuat)
+//             this.world.markRenderStateDirty();
+//         }
+//     }
+
+//     // transform euler
+//     setRotation(newEuler)
+//     {
+//         if (this.pawn)
+//         {
+//             this.pawn.setQuaternion(new Quaternion().setFromEuler(newEuler))
+//             this.world.markRenderStateDirty();
+//         }
+//     }
+
+//     // focus
+//     focusTo(targetPos, targetQuat, distance, time, onGoing: Function | null = null, onFinished: Function | null = null)
+//     {
+//         this.pawn.focusTo(targetPos, targetQuat, distance, time, onGoing, onFinished)
+//     }
+
+//     movePawnTo(targetPos: Vector3)
+//     {
+
+//     }
+
+//     enableTransformControl(primaryTarget: ITransforming, multiTargets: ITransforming[], onUpdate: Function | null = null, onDragging: Function | null)
+//     {
+//         if (this.transformControl)
+//         {
+//            this.disableTransformControl()
+//         }
+//         this.transformControl = new LYTransformControl(this.world, this.Camera)
+//         this.transformControl.possess()
+//         this.transformControl.setSpace("local")
+//         this.transformControl.setTarget(primaryTarget, multiTargets, onUpdate, onDragging)
+//         this.transformControl.setAxis(primaryTarget.getAllowedTransformType().translate)
+//         this.world?.markRenderStateDirty()
+//     }
+
+  
+    
+//     disableTransformControl()
+//     {
+//         if (this.transformControl)
+//         {
+//             this.transformControl.destroy();
+//         }
+//         this.transformControl = null
+//         this.world?.markRenderStateDirty()
+//     }
+
+//     getTransformToolMode(): "translate" | "rotate" | "scale"
+//     {
+//         return this.transformControl.getMode()
+//     }
+
+//     setTransformToolMode(mode: "translate" | "rotate" | "scale"): void
+//     {
+//         this.transformControl.setMode(mode)
+//     }
+
+//     setTransformToolAxis(axis: "X" | "Y" | "Z" | "E" | "XY" | "YZ" | "XZ" | "XYZ" | "XYZE" | null): void
+//     {
+//         this.transformControl.setAxis(axis)
+//     }
+
+
+//     onWindowResize()
+//     {
+//         let ele = this.world.OuterElement;
+//         if (!ele)
+//         {
+//             return
+//         }
+//         this.Camera.aspect = ele.clientWidth / ele.clientHeight;
+//         this.Camera.updateProjectionMatrix();
+//         this.world.renderer.setSize(ele.clientWidth, ele.clientHeight);
+//         this.world.labelRenderer.setSize(ele.clientWidth, ele.clientHeight);
+//         if (this.world.Composer)
+//         {
+//             this.world.Composer.setSize(ele.clientWidth, ele.clientHeight)
+//         }
+//         this.world.markRenderStateDirty();
+//     }
+
+//     onPointerMove(event)
+//     {
+//         let ele          = this.world.OuterElement;
+//         const canvasRect = this.world.Element.getBoundingClientRect();
+//         const offsetX    = canvasRect.left;
+//         const offsetY    = canvasRect.top;
+
+//         const pointer = new Vector2(((event.clientX - offsetX) / ele.clientWidth) * 2 - 1, 1 - ((event.clientY - offsetY) / ele.clientHeight) * 2)
+
+//         if (event.buttons !== 0)
+//         {
+//             this.pawn.stopFocusing()
+//             if (this.bLockCameraRotationByMouseMove && (!this.bCameraRotationLockedAlready))
+//             {
+//                 const deltaX = Math.abs(pointer.x - this.startPointerDownPos.x)
+//                 const deltaY = Math.abs(pointer.y - this.startPointerDownPos.y)
+//                 if (Math.min(deltaY, deltaX) > 0.002)
+//                 {
+//                     this.bCameraRotationLockedAlready = true
+//                     this.PawnMode.startLockCameraRotation(deltaX > deltaY ? new Vector2(1, 0) : new Vector2(0, 1))
+//                 }
+//             }
+//             return
+//         }
+//         this.pointer = pointer
+
+//         let hover        = this.getHitResultUnderCursor(this.hoverable, this._hoverDepth)
+//         let newHoverComp = []
+//         hover.forEach((elem) =>
+//         {
+//             if (elem.hitComp)
+//             {
+//                 newHoverComp.push(elem.hitComp)
+//             }
+//         })
+
+//         this.hoveringComp.forEach((elem) =>
+//         {
+//             if (newHoverComp.indexOf(elem) < 0)
+//             {
+//                 elem.onHorveringEnd();
+//             }
+//         })
+
+//         newHoverComp.forEach((elem) =>
+//         {
+//             if (this.hoveringComp.indexOf(elem) < 0)
+//             {
+//                 elem.onHorveringBegin();
+//             }
+//         })
+
+//         this.hoveringComp = newHoverComp
+
+//         this.OnMouseMove.broadcast(event)
+//     }
+
+//     onPointerDown(event)
+//     {
+//         // left mouse button
+//         if (event.button === 0)
+//         {
+//             this.bLeftMouseButtonDown = true;
+//             if (this.bLockCameraRotationByMouseMove)
+//             {
+//                 let ele                           = this.world.OuterElement;
+//                 const canvasRect                  = this.world.Element.getBoundingClientRect();
+//                 const offsetX                     = canvasRect.left;
+//                 const offsetY                     = canvasRect.top;
+//                 this.pointer.x                    = ((event.clientX - offsetX) / ele.clientWidth) * 2 - 1;
+//                 this.pointer.y                    = 1 - ((event.clientY - offsetY) / ele.clientHeight) * 2;
+//                 this.startPointerDownPos          = this.pointer.clone()
+//                 this.bCameraRotationLockedAlready = false
+//             }
+//         }
+//     }
+
+//     onPointerUp(event)
+//     {
+//         if (event.button === 0)
+//         {
+//             this.bLeftMouseButtonDown = false;
+//             if (this.leftMouseButtonDownTime < maxClickTime)
+//             {
+//                 this.onClick(event)
+//             }
+
+//             this.leftMouseButtonDownTime = 0;
+
+//             this.PawnMode.stopLockCameraRotation()
+
+//             this.bCameraRotationLockedAlready = true
+//         }
+//         this.OnMouseUp.broadcast(event)
+//     }
+
+//     onMouseEnterCanvas()
+//     {
+//         let ele = this.world.Element
+//         ele.addEventListener('pointermove', this.onPointerMoveFunc);
+//         ele.addEventListener("pointerup", this.onPointerUpFunc);
+//         ele.addEventListener("pointerdown", this.onPointerDownFunc);
+//         this.onMouseEnterDelegate.broadcast()
+//     }
+
+//     onMouseLeaveCanvas()
+//     {
+//         let ele = this.world.Element
+//         ele.removeEventListener('pointermove', this.onPointerMoveFunc);
+//         ele.removeEventListener("pointerup", this.onPointerUpFunc);
+//         ele.removeEventListener("pointerdown", this.onPointerDownFunc);
+//         this.onMouseLeaveDelegate.broadcast()
+
+//     }
+
+//     projectWorldPositionToScreen(pos: Vector3)
+//     {
+//         let temp = new Vector3().copy(pos)
+//         temp.project(this.Camera)
+//         let ele      = this.world.Element
+//         const width  = ele.clientWidth;
+//         const height = ele.clientHeight;
+
+//         const screenX = (temp.x + 1) / 2 * width;
+//         const screenY = (1 - temp.y) / 2 * height;
+//         return new Vector2(screenX, screenY)
+//     }
+
+//     // excute when click nothing
+//     addClickNullEvent(func)
+//     {
+//         if (!func)
+//         {
+//             return
+//         }
+//         this.onClickNullEvent.push(func)
+//     }
+
+//     removeClickNullEvent(func)
+//     {
+//         let index = this.onClickNullEvent.indexOf(func)
+//         if (index >= 0)
+//         {
+//             this.onClickNullEvent.splice(index, 1)
+//         }
+//     }
+
+//     onClick(event)
+//     {
+//         let ele = this.world.Element;
+
+//         let bound      = ele.getBoundingClientRect();
+//         this.pointer.x = ((event.clientX - bound.left) / ele.offsetWidth) * 2 - 1;// 标准设备横坐标
+//         this.pointer.y = -((event.clientY - bound.top) / ele.offsetHeight) * 2 + 1;// 标准设备纵坐标
+
+//         if (this.clickable.length > 0)
+//         {
+//             let res = this.getHitResultUnderCursor(this.clickable)
+
+//             if (res.length === 0)
+//             {
+//                 this.onClickNullEvent.forEach((elem) =>
+//                 {
+//                     elem()
+//                 })
+//                 return
+//             }
+//             let hitComp = res[0].hitComp
+//             let hitInfo = res[0].hitInfo
+
+//             if (hitComp)
+//             {
+//                 hitComp.onClicked();
+//             }
+//             else
+//             {
+//                 this.onClickNullEvent.forEach((elem) =>
+//                 {
+//                     elem()
+//                 })
+//             }
+//         }
+//         else
+//         {
+//             this.onClickNullEvent.forEach((elem) =>
+//             {
+//                 elem()
+//             })
+//         }
+//     }
+
+//     addBlockable(object: Mesh)
+//     {
+//         let index = this.blockingMesh.indexOf(object)
+//         if (index >= 0)
+//         {
+//             return
+//         }
+//         this.blockingMesh.push(object)
+//     }
+
+//     removeBlockable(object: Mesh)
+//     {
+//         let index = this.blockingMesh.indexOf(object)
+//         if (index >= 0)
+//         {
+//             this.blockingMesh.splice(index, 1)
+//         }
+//     }
+
+//     // line trace
+//     registAsHoverable(LYObject: SceneComponent)
+//     {
+//         let index = this.hoverable.indexOf(LYObject)
+//         if (index >= 0)
+//         {
+//             return
+//         }
+
+//         this.hoverable.push(LYObject)
+//     }
+
+//     unregistAsHoverable(LYObject: SceneComponent)
+//     {
+//         let index = this.hoverable.indexOf(LYObject)
+//         if (index >= 0)
+//         {
+//             this.hoverable.splice(index, 1)
+//         }
+//     }
+
+//     registAsClickable(LYObject: SceneComponent)
+//     {
+//         if (!LYObject)
+//         {
+//             console.error("Controller::registAsClickable : clickable is null", LYObject)
+//             return
+//         }
+
+//         let index = this.clickable.indexOf(LYObject)
+//         if (index >= 0)
+//         {
+//             return
+//         }
+//         this.clickable.push(LYObject)
+//     }
+
+//     unregistAsClickable(LYObject: SceneComponent)
+//     {
+//         let index = this.clickable.indexOf(LYObject)
+//         if (index >= 0)
+//         {
+//             this.clickable.splice(index, 1)
+//         }
+//     }
+    
+    
+//     public getHitResultUnderCursor(objects: SceneComponent[] = [], depth: number = 1)
+//     {
+//         if (!this.ray)
+//         {
+//             this.ray = new LYRaycaster(this.world)
+//         }
+//         if (!this.Camera)
+//         {
+//             return []
+//         }
+//         this.ray.setFromCamera(this.pointer, this.Camera)
+//         let retVal  = [];
+//         let realHit = new Set()
+        
+//         if(objects.length === 0)
+//         {
+//             let arr = new Set(this.clickable.concat(this.hoverable))
+//             arr.forEach((elem)=>{
+//                 realHit.add(elem.threeObject)
+//             })
+//         }
+//         else
+//         {
+//             objects.forEach((obj) =>
+//             {
+//                 realHit.add(obj.threeObject)
+//             })
+//         }
+        
+        
+//         this.blockingMesh.forEach((obj) =>
+//         {
+//             realHit.add(obj)
+//         })
+//         let traced = this.ray.intersectObjects(Array.from(realHit), false)
+//         if (traced.length === 0)
+//         {
+//             return retVal
+//         }
+
+//         for (let i = 0; (i < traced.length) && (i < depth); ++i)
+//         {
+//             let myObj = traced[i].object.userData["LYObject"]
+//             if (this.blockingMesh.indexOf(traced[i].object) >= 0)
+//             {
+//                 return retVal
+//             }
+//             if (myObj instanceof SceneComponent)
+//             {
+//                 retVal.push({
+//                     hitComp: myObj,
+//                     hitInfo: traced[i]
+//                 })
+//             }
+//         }
+//         return retVal
+//     }
+
+//     public getHitOnScreentPosition(clientX: number, clientY: number, traceObjects: Object3D[])
+//     {
+//         if (!this.ray)
+//         {
+//             this.ray = new LYRaycaster(this.world)
+//         }
+//         let ele          = this.world.OuterElement;
+//         const canvasRect = this.world.Element.getBoundingClientRect();
+//         const offsetX    = canvasRect.left;
+//         const offsetY    = canvasRect.top;
+//         const pointer    = new Vector2(((clientX - offsetX) / ele.clientWidth) * 2 - 1, 1 - ((clientY - offsetY) / ele.clientHeight) * 2)
+//         this.ray.setFromCamera(pointer, this.Camera)
+//         let traced = this.ray.intersectObjects(traceObjects, true)
+//         return traced
+//     }
+
+//     getTracedResultFromObjects(clientX: number, clientY: number, objects: Object3D[] = this.world?.scene?.children)
+//     {
+//         if (!this.ray)
+//         {
+//             this.ray = new LYRaycaster(this.world)
+//         }
+//         let ele          = this.world.OuterElement;
+//         const canvasRect = this.world.Element.getBoundingClientRect();
+//         const offsetX    = canvasRect.left;
+//         const offsetY    = canvasRect.top;
+//         const pointer    = new Vector2(((clientX - offsetX) / ele.clientWidth) * 2 - 1, 1 - ((clientY - offsetY) / ele.clientHeight) * 2)
+//         this.ray.setFromCamera(pointer, this.Camera)
+//         let traced = this.ray.intersectObjects(objects, true)
+//         return traced
+//     }
+
+//     lineTrace(origin: Vector3, direction: Vector3, ignoreObjects: Object3D[] | null = null)
+//     {
+//         if (!this.ray)
+//         {
+//             this.ray = new LYRaycaster(this.world)
+//         }
+
+//         this.ray.setOriginAndDirection(origin, direction)
+
+//         let traced = this.ray.intersectObjects(this.world.scene?.children, true)
+//         for (let i = 0; i < traced.length; ++i)
+//         {
+//             if (!ignoreObjects || ignoreObjects.length === 0)
+//             {
+//                 return traced[i]
+//             }
+//             if (ignoreObjects.indexOf(traced[i].object) < 0)
+//             {
+//                 return traced[i]
+//             }
+//         }
+//         return null
+//     }
+
+//     setViewOffset(offsetX: number, offsetY: number)
+//     {
+//         let ele = this.world.OuterElement;
+//         let w   = ele.clientWidth
+//         let h   = ele.clientHeight
+//         if (this.Camera instanceof PerspectiveCamera)
+//         {
+//             this.Camera.setViewOffset(w, h, w * offsetX, h * offsetY, w, h)
+//         }
+//     }
+
+//     setViewOffsetX(offsetX: number)
+//     {
+//         let ele = this.world.OuterElement;
+//         let w   = ele.clientWidth
+//         let h   = ele.clientHeight
+//         if (this.Camera instanceof PerspectiveCamera)
+//         {
+//             this.Camera.setViewOffset(w, h, w * offsetX, 0, w, h)
+//         }
+//     }
+
+//     destroy(): void
+//     {
+//         if (this.pawn)
+//         {
+//             this.pawn.unpossess();
+//             this.pawn.destroy();
+//             this.pawn = null;
+//         }
+//         this.resizeObserver.disconnect();
+//         let ele = this.world.Element
+//         ele.removeEventListener('mouseenter', this.onPointerEnterFunc);
+//         ele.removeEventListener("mouseleave", this.onPointerLeaveFunc);
+
+//         this.onMouseLeaveCanvas()
+
+//         this.hoverable        = [];
+//         this.clickable        = [];
+//         this.blockingMesh     = []
+//         this.cameraStat       = null;
+//         this.camera           = null;
+//         this.transformControl = null;
+//         this.onClickNullEvent = [];
+
+//         this.onMouseEnterDelegate.clear()
+//         this.onMouseLeaveDelegate.clear()
+//         this.onMouseMoveDelegate.clear()
+//         this.onCameraChanged.clear()
+//     }
+// }