lythreeframe 1.0.0

package/lythreeFrame/src/Object/Pawn/CameraStatus.ts

@@ -0,0 +1,262 @@
+// import {Euler, OrthographicCamera, PerspectiveCamera, Quaternion, Vector3} from "three";
+// import {LYMath} from "../../Math/Math.ts";
+
+// export class CameraStatus
+// {
+
+//     get cameraQuaternion(): Quaternion
+//     {
+//         return this._cameraQuaternion;
+//     }
+//     get targetPosition(): Vector3
+//     {
+//         return this._targetPosition;
+//     }
+//     get cameraPosition(): Vector3
+//     {
+//         return this._cameraPosition;
+//     }
+//     private _cameraPosition:Vector3
+//     private _targetPosition:Vector3
+//     private _cameraQuaternion:Quaternion
+
+//     type:string = ""
+//     constructor(camera:PerspectiveCamera|OrthographicCamera, targetPosition:Vector3)
+//     {
+//         this._cameraPosition   = new Vector3()
+//         this._cameraQuaternion = new Quaternion()
+//         this._targetPosition   = new Vector3()
+//         this.update(camera,targetPosition)
+//     }
+
+//     update(camera:PerspectiveCamera|OrthographicCamera,  targetPosition:Vector3)
+//     {
+//         this.updateCameraPosition(camera.position)
+//         this.updateCameraQuaternion(camera.quaternion)
+//         this.updateTargetPosition(targetPosition)
+
+//     }
+
+//     updateCameraPosition(cameraPosition:Vector3)
+//     {
+//         this._cameraPosition.copy(cameraPosition)
+//     }
+
+//     updateCameraQuaternion(cameraQuaternion:Quaternion)
+//     {
+//         this._cameraQuaternion.copy(cameraQuaternion)
+//     }
+
+//     updateTargetPosition(targetPosition:Vector3)
+//     {
+//         this._targetPosition.copy(targetPosition)
+//     }
+    
+//     copy(other:CameraStatus)
+//     {
+//         this.updateCameraPosition(other.cameraPosition)
+//         this.updateCameraQuaternion(other.cameraQuaternion)
+//         this.updateTargetPosition(other.targetPosition)
+//     }
+    
+//     toObject():object
+//     {
+//         let euler = new Euler().setFromQuaternion(this._cameraQuaternion)
+        
+//         return {
+//             position: this._cameraPosition.toArray(),
+//             euler   : LYMath.threeJsEulerAngleAsDegree(euler),
+//             type    : this.type
+//         }
+//     }
+    
+//     fromObject(object)
+//     {
+//         this.updateCameraPosition(new Vector3().fromArray(object.position))
+//         let euler = new Euler(LYMath.degreeToRadians(object.euler.x),LYMath.degreeToRadians(object.euler.y),LYMath.degreeToRadians(object.euler.z))
+//         this.updateCameraQuaternion(new Quaternion().setFromEuler(euler))
+//     }
+// }
+
+// export interface ICameraStatus
+// {
+//     restore(status:CameraStatus):void
+// }
+
+// export class PersepecticeCameraStatus extends CameraStatus
+// {
+//     get fov(): number
+//     {
+//         return this._fov;
+//     }
+//     get far(): number
+//     {
+//         return this._far;
+//     }
+//     get near(): number
+//     {
+//         return this._near;
+//     }
+
+//     private _near: number = 1
+//     private _far: number = 1
+//     private _fov: number = 60
+//     constructor(camera:PerspectiveCamera, targetPosition:Vector3)
+//     {
+//         super(camera,targetPosition)
+//         this.type = "perspective"
+//     }
+
+//     update(camera:PerspectiveCamera,  targetPosition:Vector3)
+//     {
+//         this.updateCameraPosition(camera.position)
+//         this.updateCameraQuaternion(camera.quaternion)
+//         this.updateTargetPosition(targetPosition)
+
+//         this.updateFar(camera.far)
+//         this.updateNear(camera.near)
+//         this.updateFOV(camera.fov)
+//     }
+    
+//     updateNear(near:number)
+//     {
+//         this._near = near
+//     }
+//     updateFar(far:number)
+//     {
+//         this._far = far
+//     }
+//     updateFOV(fov:number)
+//     {
+//         this._fov = fov
+//     }
+    
+//     copy(other:PersepecticeCameraStatus)
+//     {
+//         this.updateFOV(other.fov)
+//         this.updateNear(other.near)
+//         this.updateFar(other.far)
+//         super.copy(other)
+//     }
+
+//     toObject():object
+//     {
+//         let obj = super.toObject()
+//         obj.near = this._near
+//         obj.far = this._far
+//         obj.fov = this._fov
+//         return obj
+//     }
+//     fromObject(object)
+//     {
+//         super.fromObject(object)
+//         this.updateFOV(object.fov)
+//         this.updateNear(object.near)
+//         this.updateFar(object.far)
+//     }
+// }
+
+// export class OrthographicCameraStatus extends CameraStatus
+// {
+  
+
+//     constructor(camera:OrthographicCamera, targetPosition:Vector3)
+//     {
+//         super(camera,targetPosition)
+//         this.type = "orthographic"
+
+//     }
+//     get zoom(): number
+//     {
+//         return this._zoom;
+//     }
+//     private _zoom:number = 1
+//     update(camera:OrthographicCamera,  targetPosition:Vector3)
+//     {
+//         this.updateCameraPosition(camera.position)
+//         this.updateCameraQuaternion(camera.quaternion)
+//         this.updateTargetPosition(targetPosition)
+//         this.updateCameraZoom(camera.zoom)
+//         this.updateCameraView(camera.left, camera.right, camera.top, camera.bottom)
+//     }
+//     updateCameraZoom(cameraZoom:number)
+//     {
+//         this._zoom = cameraZoom
+//     }
+
+//     get bottom(): number
+//     {
+//         return this._bottom;
+//     }
+//     get top(): number
+//     {
+//         return this._top;
+//     }
+//     get right(): number
+//     {
+//         return this._right;
+//     }
+//     get left(): number
+//     {
+//         return this._left;
+//     }
+//     private _left:number  = -100
+//     private _right:number = -100
+//     private _top:number    = -100
+//     private _bottom:number = -100
+//     updateCameraView(left:number, right:number, top:number, bottom:number)
+//     {
+//         this._left   = left
+//         this._right  = right
+//         this._top    = top
+//         this._bottom = bottom
+//     }
+//     get far(): number
+//     {
+//         return this._far;
+//     }
+//     get near(): number
+//     {
+//         return this._near;
+//     }
+
+//     private _near: number = 1
+//     private _far: number = 1
+//     updateNear(near:number)
+//     {
+//         this._near = near
+//     }
+//     updateFar(far:number)
+//     {
+//         this._far = far
+//     }
+    
+//     copy(other:OrthographicCameraStatus)
+//     {
+//         this.updateCameraView(other.left, other.right,other.top,other.bottom)
+//         this.updateNear(other.near)
+//         this.updateFar(other.far)
+//         super.copy(other)
+//     }
+
+//     toObject():object
+//     {
+//         let obj    = super.toObject()
+//         obj.left   = this.left
+//         obj.right  = this.right
+//         obj.top    = this.top
+//         obj.bottom = this.bottom
+//         obj.zoom   = this.zoom
+//         obj.near   = this.near
+//         obj.far    = this.far
+//         return obj
+//     }
+    
+//     fromObject(object)
+//     {
+//         super.fromObject(object)
+//         this.updateCameraView(object.left, object.right, object.top, object.bottom)
+//         this.updateNear(object.near)
+//         this.updateFar(object.far)
+//     }
+// }

package/lythreeFrame/src/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();
+    }
+}