lythreeframe 1.0.2 → 1.0.5

package/src/lythreeframe/Object/Pawn/FirstPerson.ts

@@ -0,0 +1,230 @@
+// import {PointerLockControls} from "three/examples/jsm/controls/PointerLockControls";
+// import {
+//     CapsuleGeometry,
+//     Euler,
+//     MeshBasicMaterial,
+//     Quaternion,
+//     Vector3,
+//     Camera,
+//     Ray,
+//     Plane, PerspectiveCamera
+// } from "three";
+// import {CameraStatus, PawnBase} from "./PawnBase";
+
+// export class LYFirstPerson extends PawnBase
+// {
+//     protected speed: number        = 10
+//     protected cameraHeight: number = 1.5
+
+//     protected mouseUpEvent
+//     protected keyUpEvent
+//     protected keyDownEvent
+
+//     protected isForward: boolean  = false;
+//     protected isBackward: boolean = false;
+//     protected isLeft: boolean     = false;
+//     protected isRight: boolean    = false;
+
+//     protected domElement
+
+//     constructor(world)
+//     {
+//         let ele = world.Element;
+//         let camera = new PerspectiveCamera(60, ele.clientWidth / ele.clientHeight, 0.1, 7000)
+//         super(world,camera,new PointerLockControls(camera, world.renderer.domElement));
+//         this.domElement = world.renderer.domElement
+
+//         this.mouseUpEvent = () =>
+//             {
+//                 this.Control.isLocked ? this.Control.unlock() : this.Control.lock()
+//             }
+//         this.keyDownEvent = (event) =>
+//             {
+//                 this.onKeyDown(event)
+//             }
+//         this.keyUpEvent   = (event) =>
+//             {
+//                 this.onKeyUp(event)
+//             }
+
+//         camera.position.y = Math.max(camera.position.y + this.cameraHeight, 5)
+
+//         this.Camera.updateProjectionMatrix();
+
+
+//         const geometry = new CapsuleGeometry(0.3, 1.2, 4, 8);
+//         const material = new MeshBasicMaterial({
+//             color    : 0x00ff00,
+//             wireframe: true
+//         });
+//         this.cameraStatus.update(this.Camera.position, this.Camera.quaternion, 0)
+//     }
+
+//     protected onKeyDown(event)
+//     {
+//         switch (event.code)
+//         {
+//             case 'ArrowUp':
+//             case 'KeyW':
+//                 this.isForward = true;
+//                 break;
+
+//             case 'ArrowLeft':
+//             case 'KeyA':
+//                 this.isLeft = true;
+//                 break;
+
+//             case 'ArrowDown':
+//             case 'KeyS':
+//                 this.isBackward = true;
+//                 break;
+
+//             case 'ArrowRight':
+//             case 'KeyD':
+//                 this.isRight = true;
+//                 break;
+//         }
+//     }
+
+//     protected onKeyUp(event)
+//     {
+//         switch (event.code)
+//         {
+
+//             case 'ArrowUp':
+//             case 'KeyW':
+//                 this.isForward = false;
+//                 break;
+
+//             case 'ArrowLeft':
+//             case 'KeyA':
+//                 this.isLeft = false;
+//                 break;
+
+//             case 'ArrowDown':
+//             case 'KeyS':
+//                 this.isBackward = false;
+//                 break;
+
+//             case 'ArrowRight':
+//             case 'KeyD':
+//                 this.isRight = false;
+//                 break;
+
+//         }
+//     }
+
+//     tick(deltaTime)
+//     {
+//         super.tick(deltaTime)
+
+//         let movingDirection = new Vector3()
+//         movingDirection.z   = this.isForward ? this.isBackward ? 0 : -1 : this.isBackward ? 1 : 0;
+//         movingDirection.x   = this.isRight ? this.isLeft ? 0 : 1 : this.isLeft ? -1 : 0;
+
+//         movingDirection.applyQuaternion(this.Camera.quaternion)
+//         movingDirection.normalize()
+//         movingDirection.y = 0
+//         movingDirection.multiplyScalar(deltaTime * this.speed);
+
+
+//         let finalY       = this.Camera.position.y
+//         if(this.World.Octree)
+//         {
+//             let ray      = new Ray(this.Camera.position, movingDirection)
+//             const result = this.World.Octree.rayIntersect(ray)
+//             if (result && (result.distance < deltaTime * this.speed))
+//             {
+//                 return
+//             }
+//             let rayDown = new Ray(this.Camera.position, new Vector3(0, -1, 0))
+//             const resultDown = this.World.Octree.rayIntersect(rayDown)
+
+//             if (resultDown)
+//             {
+//                 finalY = resultDown.position.y + this.cameraHeight
+//             }
+//         }
+//         this.Camera.position.set(
+//             this.Camera.position.x + movingDirection.x,
+//             finalY,
+//             this.Camera.position.z + movingDirection.z
+//         )
+//         this.cameraStatus.update(this.Camera.position, this.Camera.quaternion, 0)
+
+//         this.World.markRenderStateDirty();
+//     }
+
+//     get Camera(): Camera
+//     {
+//         return this.Control.camera;
+//     }
+
+//     setCamera(newCamera)
+//     {
+//         super.setCamera(newCamera)
+//         this.Control.camera = newCamera
+//         this.World.markRenderStateDirty();
+//     }
+
+//     possess()
+//     {
+//         this.World.Controller.IsTickable = true
+//         this.IsTickable                  = true;
+//         this.domElement.addEventListener('mouseup', this.mouseUpEvent)
+//         document.addEventListener('keydown', this.keyDownEvent)
+//         document.addEventListener('keyup', this.keyUpEvent)
+//         this.World.markRenderStateDirty();
+//     }
+
+//     unpossess()
+//     {
+//         this.World.Controller.IsTickable = false
+//         this.IsTickable                  = false
+//         this.domElement.removeEventListener('mouseup', this.mouseUpEvent)
+//         document.removeEventListener('keydown', this.keyDownEvent)
+//         document.removeEventListener('keyup', this.keyUpEvent)
+//     }
+
+//     focusTo(targetPos, targetQuat, distance, time = 0, onFinished = null)
+//     {
+//         console.log(targetPos)
+//         this.Camera.position.set(targetPos.x, targetPos.y + this.cameraHeight, targetPos.z);
+//         if (targetQuat instanceof Euler)
+//         {
+//             targetQuat = new Quaternion().setFromEuler(targetQuat)
+//         }
+//         let fV = new Vector3(0, 0, -1)
+//         fV.applyQuaternion(targetQuat)
+//         let lookingTarget = targetPos.clone()
+//         lookingTarget.add(fV.multiplyScalar(100))
+//         lookingTarget.y = targetPos.y + this.cameraHeight
+//         this.Camera.lookAt(lookingTarget.x, targetPos.y + this.cameraHeight, lookingTarget.z)
+        
+//         this.cameraStatus.update(this.Camera.position, this.Camera.quaternion, lookingTarget)
+
+//         if (onFinished)
+//         {
+//             onFinished();
+//         }
+//         this.World.markRenderStateDirty();
+//     }
+    
+//     restore(status: CameraStatus)
+//     {
+//         super.restore(status);
+//         this.focusTo(status.targetPosition, status.cameraQuaternion, status.targetPosition.clone().sub(status.cameraPosition).length())
+//     }
+    
+//     destroy()
+//     {
+//         if (this.Control)
+//         {
+//             this.domElement.removeEventListener('mouseup', this.mouseUpEvent)
+//             document.removeEventListener('keydown', this.keyDownEvent)
+//             document.removeEventListener('keyup', this.keyUpEvent)
+//             this.Control.dispose();
+//         }
+//         super.destroy();
+//     }
+// }

package/src/lythreeframe/Object/Pawn/Oribital.ts

@@ -0,0 +1,276 @@
+// import {Euler, Quaternion, Vector3,Vector2, PerspectiveCamera} from "three";
+// import {gsap} from 'gsap';
+
+// import {CameraStatus, PawnBase} from "./PawnBase";
+// import {LYThreeWorld} from "../../Frame";
+// import {OrbitControls} from "three/examples/jsm/controls/OrbitControls";
+// import {PersepecticeCameraStatus} from "./CameraStatus";
+
+
+// export class LYOrbital extends PawnBase
+// {
+//     protected anim
+//     private minAzimuthAngle: number;
+//     private maxAzimuthAngle: number;
+//     private minPolarAngle: number;
+//     private maxPolarAngle: number;
+//     override cameraStatus:PersepecticeCameraStatus
+//     constructor(world: LYThreeWorld)
+//     {
+//         let ele    = world.Element;
+//         let camera = new PerspectiveCamera(60, ele.clientWidth / ele.clientHeight, 0.5, 7000)
+//         super(world, camera, new OrbitControls(camera, world.renderer.domElement));
+
+//         this.Camera.updateProjectionMatrix();
+//         // this.enabled = false;
+//         //this.Control.maxDistance = 300;
+//         this.Control.maxPolarAngle = 0.49 * Math.PI;
+//         this.minAzimuthAngle       = this.Control.minAzimuthAngle
+//         this.maxAzimuthAngle       = this.Control.maxAzimuthAngle
+//         this.minPolarAngle         = this.Control.minPolarAngle
+//         this.maxPolarAngle         = this.Control.maxPolarAngle
+//         this.IsTickable            = true
+
+//         this.cameraStatus = new PersepecticeCameraStatus(this.Camera, this.Camera.position)
+//     }
+
+//     tick(deltaTime:number)
+//     {
+//         super.tick(deltaTime);
+
+//     }
+
+//     set enabled(newEnable: boolean)
+//     {
+//         this.Control.panSpeed    = newEnable ? 1 : 0;
+//         this.Control.rotateSpeed = newEnable ? 1 : 0;
+//         this.Control.zoomSpeed   = newEnable ? 1 : 0;
+//     }
+    
+//     possess()
+//     {
+//         super.possess()
+//         this.Control.addEventListener('change', this.changeEvent)
+//         this.World.markRenderStateDirty();  
+//     }
+
+//     unpossess()
+//     {
+//         super.unpossess()
+//         this.Control.removeEventListener("change", this.changeEvent)
+//         this.onCameraMove = null
+//         if (this.anim)
+//         {
+//             this.anim.kill();
+//         }
+//     }
+
+//     get Camera()
+//     {
+//         return this.Control.object
+//     }
+
+//     setCamera(newCamera)
+//     {
+//         super.setCamera(newCamera)
+//         this.Control.object = newCamera
+//         this.Control.update();
+//         this.World.markRenderStateDirty();
+//     }
+
+//     setPosition(param1, param2 = undefined, param3 = undefined)
+//     {
+//         super.setPosition(param1, param2, param3);
+//         this.Control.update();
+//         this.World.markRenderStateDirty();
+//     }
+
+//     setQuaternion(newQuat)
+//     {
+//         super.setQuaternion(newQuat);
+//         this.Control.update()
+//         this.World.markRenderStateDirty();
+//     }
+
+//     // focusTo 
+//     // @targetPos  Three.Vector3                   : where your camera face to 
+//     // @targetQuat Three.Quaternion or Three.Euler : rotation of your camera
+//     // @distance   float                           : how far between targetPos and your camera's position
+//     // @time       float                           : how long will this process finish
+//     focusTo(targetPos: Vector3, targetQuat: Quaternion | Euler, distance: number, time: number = 0, onGoing: Function | null = null, onFinished: Function | null = null)
+//     {
+//         let finalQuat = null
+
+//         if (targetQuat instanceof Euler)
+//         {
+//             finalQuat = new Quaternion().setFromEuler(targetQuat)
+//         }
+//         else
+//         {
+//             finalQuat = targetQuat
+//         }
+//         if (!targetQuat)
+//         {
+//             finalQuat = this.Camera.quaternion
+//         }
+//         finalQuat.normalize()
+//         let dir = new Vector3(0, 0, 1);
+//         dir.applyQuaternion(finalQuat).multiplyScalar(-1);
+//         dir.normalize()
+//         // quat
+//         let startQuat = this.Camera.quaternion.clone();
+//         // position
+//         let startPos  = this.Camera.position.clone();
+//         let endPos    = new Vector3(targetPos.x + dir.x * distance * -1, targetPos.y + dir.y * distance * -1, targetPos.z + dir.z * distance * -1);
+
+//         let posDir       = new Vector3();
+//         posDir.x         = endPos.x - startPos.x;
+//         posDir.y         = endPos.y - startPos.y;
+//         posDir.z         = endPos.z - startPos.z;
+//         let movingLength = posDir.length();
+//         posDir.normalize();
+
+//         // target
+//         let startTarget    = this.Control.target.clone()
+//         let targetDir      = new Vector3();
+//         targetDir.x        = targetPos.x - startTarget.x;
+//         targetDir.y        = targetPos.y - startTarget.y;
+//         targetDir.z        = targetPos.z - startTarget.z;
+//         let targetDistance = targetDir.length();
+//         targetDir.normalize();
+        
+//         this.cameraStatus.updateTargetPosition(targetPos)
+
+//         // start animation
+//         if (this.anim)
+//         {
+//             this.anim.kill();
+//         }
+//         if (movingLength + targetDistance < 0.1)
+//         {
+//             return
+//         }
+//         //this.enabled = false;
+//         let obj   = {alpha: 0}
+//         let _this = this
+//         this.anim = gsap.to(obj, {
+//             duration  : time,
+//             alpha     : 1,
+//             onUpdate  : () =>
+//                 {
+//                     let alpha     = obj.alpha;
+//                     let camPos    = new Vector3(startPos.x + posDir.x * alpha * movingLength, startPos.y + posDir.y * alpha * movingLength, startPos.z + posDir.z * alpha * movingLength)
+//                     let targetPos = new Vector3(startTarget.x + targetDir.x * alpha * targetDistance, startTarget.y + targetDir.y * alpha * targetDistance, startTarget.z + targetDir.z * alpha * targetDistance)
+//                     _this.Control.object.position.copy(camPos);
+//                     _this.Control.target.copy(targetPos);
+
+//                     _this.Control.update();
+
+
+//                     if (onGoing)
+//                     {
+//                         onGoing()
+//                     }
+//                     _this.World.markRenderStateDirty();
+//                 },
+//             onComplete: function ()
+//                 {
+//                     //_this.enabled = true;
+
+//                     if (onFinished)
+//                     {
+//                         onFinished()
+//                     }
+//                     _this.World.markRenderStateDirty();
+//                 }
+//         });
+//     }
+
+//     stopFocusing()
+//     {
+//         if (this.anim)
+//         {
+//             this.anim.kill();
+//             this.anim = null
+//         }
+//         //this.enabled = true
+//     }
+
+//     startLockCameraRotation(axis: Vector2)
+//     {
+//         this.minAzimuthAngle = this.Control.minAzimuthAngle
+//         this.maxAzimuthAngle = this.Control.maxAzimuthAngle
+//         this.minPolarAngle   = this.Control.minPolarAngle
+//         this.maxPolarAngle   = this.Control.maxPolarAngle
+
+//         if (axis.x === 1)
+//         {
+//             const curAngle             = this.Control.getPolarAngle()
+//             this.Control.minPolarAngle = curAngle
+//             this.Control.maxPolarAngle = curAngle
+//         }
+//         else
+//         {
+//             const curAngle               = this.Control.getAzimuthalAngle()
+//             this.Control.minAzimuthAngle = curAngle
+//             this.Control.maxAzimuthAngle = curAngle
+//         }
+//     }
+
+//     stopLockCameraRotation()
+//     {
+//         this.Control.minAzimuthAngle = this.minAzimuthAngle
+//         this.Control.maxAzimuthAngle = this.maxAzimuthAngle
+//         this.Control.minPolarAngle   = this.minPolarAngle
+//         this.Control.maxPolarAngle   = this.maxPolarAngle
+//     }
+
+//     zoomIn()
+//     {
+//         this.focusTo(this.cameraStatus.targetPosition, this.cameraStatus.cameraQuaternion, this.cameraStatus.targetPosition.clone().sub(this.cameraStatus.cameraPosition).length() * 0.9)
+//     }
+
+//     zoomOut()
+//     {
+//         this.focusTo(this.cameraStatus.targetPosition, this.cameraStatus.cameraQuaternion, this.cameraStatus.targetPosition.clone().sub(this.cameraStatus.cameraPosition).length() * 1.1)
+//     }
+    
+//     restore(status: PersepecticeCameraStatus)
+//     {
+//         super.restore(status);
+//         this.cameraStatus.copy(status)
+
+//         this.focusTo(status.targetPosition, status.cameraQuaternion, status.targetPosition.clone().sub(status.cameraPosition).length())
+//         this.Camera.near = status.near
+//         this.Camera.far = status.far
+//         this.Camera.fov = status.fov
+      
+//     }
+
+//     protected onChangeEvent()
+//     {
+//         super.onChangeEvent();
+
+//         this.World.markRenderStateDirty()
+//         this.onChangeOnce = []
+ 
+//         this.cameraStatus.update(this.Camera, this.Control.target)
+//         let camPos    = this.Control.object.position.clone()
+//         let targetPos = this.Control.target.clone()
+//     }
+
+//     destroy()
+//     {
+//         if (this.anim)
+//         {
+//             this.anim.kill();
+//             this.anim = null
+//         }
+//         if (this.Control)
+//         {
+//             this.Control.removeEventListener("change", this.changeEvent)
+//             this.Control.dispose();
+//         }
+//         super.destroy();
+//     }
+// }

package/src/lythreeframe/Object/Pawn/PawnBase.ts

@@ -0,0 +1,189 @@
+// import {BaseObject} from "../BaseObject.js";
+// import {Quaternion, Vector3, Camera, Euler, Vector2} from "three";
+// import {LYThreeWorld} from "../../Frame";
+// import {ICameraStatus, CameraStatus} from "./CameraStatus";
+
+
+// // Base class for control method, should not be used directly
+// export class PawnBase extends BaseObject implements ICameraStatus
+// {
+//     protected control
+//     protected world: LYThreeWorld
+//     protected camera: Camera
+//     protected cameraStatus:CameraStatus
+//     protected onCameraMove:Function|null = null
+
+//     protected onChangeOnce:Function[] = []
+//     protected onChange:Function[] = []
+
+//     protected changeEvent:Function
+
+//     constructor(world: LYThreeWorld, camera: Camera, control)
+//     {
+//         super();
+//         this.control = control;
+//         this.world   = world
+//         this.camera = camera
+//         // this.cameraStatus = new CameraStatus(this.Camera.position, this.Camera.quaternion, this.Camera.position, 1)
+        
+//         this.onChange     = []
+//         this.onChangeOnce = []
+//         this.changeEvent = ()=>{
+//             this.onChangeEvent()
+//         }
+//     }
+    
+//     get CameraStatus():CameraStatus
+//     {
+//         return this.cameraStatus
+//     }
+    
+//     tick(deltaTime)
+//     {
+//         super.tick(deltaTime)
+//     }
+
+//     possess()
+//     {
+       
+//     }
+
+//     unpossess()
+//     {
+//         this.onChange     = []
+//         this.onChangeOnce = []
+//     }
+
+//     set enabled(newEnable:boolean)
+//     {
+
+//     }
+    
+//     startLockCameraRotation(axis: Vector2)
+//     {
+        
+//     }
+//     restore(status: CameraStatus) {}
+
+//     stopLockCameraRotation()
+//     {
+        
+//     }
+    
+//     setPosition(param1, param2 = undefined, param3 = undefined)
+//     {
+//         if (param1 instanceof Vector3)
+//         {
+//             this.Camera.position.set(param1.x, param1.y, param1.z);
+//         }
+//         if (typeof (param1) === "number" && typeof (param2) === "number" && typeof (param3) === "number")
+//         {
+//             this.Camera.position.set(param1, param2, param3);
+//         }
+
+//         if (this.world)
+//         {
+//             this.world.markRenderStateDirty();
+//         }
+//     }
+
+//     setQuaternion(newQuat)
+//     {
+//         if (newQuat instanceof Quaternion)
+//         {
+//             this.Camera.rotation.setFromQuaternion(newQuat);
+//             if (this.world)
+//             {
+//                 this.world.markRenderStateDirty();
+//             }
+//         }
+//     }
+
+//     get Camera()
+//     {
+//         return this.camera
+//     }
+
+//     setCamera(newCamera)
+//     {
+
+//     }
+
+//     get Control()
+//     {
+//         return this.control
+//     }
+
+//     get World()
+//     {
+//         return this.world;
+//     }
+
+//     focusTo(targetPos: Vector3, targetQuat: Quaternion | Euler, distance: number, time: number, onGoing: Function | null = null, onFinished: Function | null = null)
+//     {
+
+//     }
+
+//     moveTo(targetPos: Vector3)
+//     {
+
+//     }
+    
+//     stopFocusing()
+//     {
+     
+//     }
+//     destroy()
+//     {
+//         this.unpossess()
+//         if (this.control)
+//         {
+//             this.control = null;
+//         }
+//         super.destroy();
+//     }
+
+//     zoomIn()
+//     {
+        
+//     }
+    
+//     zoomOut()
+//     {
+        
+//     }
+    
+//     protected onChangeEvent()
+//     {
+//         for (let i = 0; i < this.onChange.length; ++i)
+//         {
+//             this.onChange[i]();
+//         }
+//         for (let i = 0; i < this.onChangeOnce.length; ++i)
+//         {
+//             this.onChangeOnce[i]();
+//         }
+//         this.onChangeOnce = []
+//     }
+
+//     addOnChangeEvent(event, bOnce = false)
+//     {
+//         if (bOnce)
+//         {
+//             this.onChangeOnce.push(event)
+//         }
+//         else
+//         {
+//             this.onChange.push(event)
+//         }
+//     }
+
+//     removeOnChangeEvent(event)
+//     {
+//         let index = this.onChange.indexOf(event)
+//         if (index >= 0)
+//         {
+//             this.onChange.splice(index, 1);
+//         }
+//     }
+// }