lythreeframe 1.0.1 → 1.0.5

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

@@ -1,230 +0,0 @@
-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/lythreeFrame/src/Object/Pawn/Oribital.ts

@@ -1,276 +0,0 @@
-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.ts";
-
-
-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/lythreeFrame/src/Object/Pawn/PawnBase.ts

@@ -1,189 +0,0 @@
-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);
-        }
-    }
-}