PrimordialUniverse/modules/Charactor.js

import settings from "./utils/settings.js"

export default class Charactor {

    constructor(newMeshes, particleSystems, skeletons, animationGroups) {

        this.mesh = newMeshes[0]
        this.particleSystem = particleSystems[0]
        this.skeleton = skeletons[0]
        this.modelData = { newMeshes, particleSystems, skeletons, animationGroups }

        // 设置人物动画权重
        this.animation = {}
        animationGroups.forEach((ani, index) => {

            this.animation[ani.name] = ani
            ani.play(true)

            if(index == 0) {
                ani.setWeightForAllAnimatables(1);
                this.actionType = ani.name + "-" + ani.name
            }
            else ani.setWeightForAllAnimatables(0);

        })

        // 动画沙漏， 用于人物模型动画权重转换
        this.aniHourglass = {
            upper: 0,
            lower: 1,
        }

        // 人物行走数据，通过startWalk更新
        this.walkData = {
            pathArr: [],
            currentPoint: 0
        }
    }

    set visible(isVisible) {
        this.modelData.newMeshes.forEach(mesh => mesh.isVisible = isVisible)
    }

    get visible() {
        return this.mesh.isVisible
    }

    updateAniTrans() {

        // 实时更新角色模型动画
        if(this.aniHourglass.upper > 0) {

            // 10帧动画过渡
            this.aniHourglass.upper = (this.aniHourglass.upper * 10 - 1) / 10
            this.aniHourglass.lower = (this.aniHourglass.lower * 10 + 1) / 10

            let fromAni = this.actionType.split("-")[0]
            let toAni = this.actionType.split("-")[1]

            this.animation[fromAni].setWeightForAllAnimatables(this.aniHourglass.upper);
            this.animation[toAni].setWeightForAllAnimatables(this.aniHourglass.lower);

        }
    }

    AniTransfromTo(aniName) {

        let lastAniName = this.actionType.split("-")[1]
        if(lastAniName == aniName) return

        // 颠倒沙漏
        this.aniHourglass = {
            upper: 1,
            lower: 0,
        }

        this.actionType = lastAniName + "-" + aniName
    }

    startWalk(pathArr, charactorManager) {

        this.walkData = {
            pathArr: pathArr,
            currentPoint: 0
        }
        
        if(pathArr.length >= 2 && this.actionType.split("-")[1] != "Walking") 
        {
            let video = pathArr[0].video
            if(video.isLoaded) {
                this.AniTransfromTo("Walking")
                this.walkByPath(charactorManager)
            } else {
                video.onloadeddata = () => {
                    this.AniTransfromTo("Walking")
                    this.walkByPath(charactorManager)
                }
            }
        }
    }
    
    walkByPath(charactorManager) {

        let charactor = this

        let { pathArr, currentPoint } = charactor.walkData

        // 更新房间的视频贴图
        let video = pathArr[currentPoint].video
        video.play()
        charactorManager.app.updateHouseVideo(video)

        let nextPos = pathArr[currentPoint+1].point
        let nextVideo = pathArr[currentPoint+1].video

        if(!nextVideo)
        {
            // 即将走到终点之前，获取终点旋转视频
            let endPointId = pathArr[currentPoint+1].id

            console.log("[3D] send(getRotateVideoUrl): ", endPointId + "/" + endPointId)
            window.connection.socket.emit("getRotateVideoUrl", {
                videoPath: endPointId + "/" + endPointId,
                sceneCode: settings.sceneCode,
                roomId: settings.roomId,
                userId: settings.userId,
            });
            window.connection.socket.emit("getRotateVideoUrl", {
                videoPath: endPointId + "/" + endPointId + "_rotate",
                sceneCode: settings.sceneCode,
                roomId: settings.roomId,
                userId: settings.userId,
            });

        }

        // 要跳转的位置与当前位置相同的话，就直接跳过，否则动画会出bug
        if(nextPos.x == this.mesh.position.x && nextPos.z == this.mesh.position.z) 
        {
            console.warn("跳转点位与当前点位相同, 已跳过！")

            if(pathArr[currentPoint+1].video) {
                charactor.walkByPath(charactorManager)
            } else {
                charactor.AniTransfromTo("Idle")
                charactorManager.app.cameraController.lockCamera(false)
            }
            return
        }


        let startingPoint = charactor.mesh.position.clone();
        startingPoint.y = nextPos.y;
        let walkDirc = nextPos.subtract(startingPoint).normalize();

        // 行走动画
        const walkAni = new BABYLON.Animation("walk", "position", settings.video.frameRate, 
            BABYLON.Animation.ANIMATIONTYPE_VECTOR3, BABYLON.Animation.ANIMATIONLOOPMODE_RELATIVE);

        let walkFrameNum = settings.video.frameRate * video.duration
        const walkKeyFrames = [{
            frame: 0,
            value: charactor.mesh.position
        },{
            frame: walkFrameNum,
            value: nextPos
        }]; 

        walkAni.setKeys(walkKeyFrames);


        // 转身动画
        const newQuar = BABYLON.Quaternion.FromUnitVectorsToRef(new BABYLON.Vector3(0, 0, 1), walkDirc, new BABYLON.Quaternion())
        const turnAroundAni = new BABYLON.Animation("turnAround", "rotationQuaternion", settings.video.frameRate, 
            BABYLON.Animation.ANIMATIONTYPE_QUATERNION, BABYLON.Animation.ANIMATIONLOOPMODE_RELATIVE);

        let turnAroundFrameNum = settings.video.frameRate * 0.2  // 0.2秒的帧数
        const turnAroundFrames = [{
            frame: 0,
            value: charactor.mesh.rotationQuaternion
        },{
            frame: turnAroundFrameNum,
            value: newQuar
        }]; 

        turnAroundAni.setKeys(turnAroundFrames);

        
        charactorManager.app.scene.beginDirectAnimation(charactor.mesh, [walkAni, turnAroundAni], 0, Math.max(walkFrameNum, turnAroundFrameNum), false, 1, 
            () => {
                // 如果还有下一个点位就继续走，否则变为站立
                if(pathArr[++charactor.walkData.currentPoint].video) {
                    charactor.walkByPath(charactorManager)
                } else {
                    charactor.AniTransfromTo("Idle")
                    charactorManager.app.cameraController.lockCamera(false)
                }
            });
    }
}