Camera Class

​

@Component
export default class CameraExample extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected onStart(): void {
        // 下列代码仅在客户端执行
        if(SystemUtil.isClient()) {
            // 获取当前摄像机
            let myCamera = Camera.currentCamera;
            let curCameraIndex = -1;
            // 在场景中随机创建5个摄像机
            let cameraArray = new Array<Camera>();
            for (let i = 0;
i < 5;
i++) {
                let camera = GameObject.spawn<Camera>("Camera") as Camera;
                camera.worldTransform.position = new Vector(MathUtil.randomInt(-1000, 1000), MathUtil.randomInt(-1000, 1000),MathUtil.randomInt(0, 1000));
                camera.worldTransform.rotation = new Rotation(MathUtil.randomInt(-90, 90), MathUtil.randomInt(-30, 30),MathUtil.randomInt(-150, 150));
                cameraArray.push(camera);
                camera.onSwitchComplete.add(() => {
                    console.log("当前摄像机序号 " + i);
                    curCameraIndex = i;
                });
            }
            // 添加一个按键方法：按下键盘“1”，切换摄像机
            InputUtil.onKeyDown(Keys.One, () => {
                console.log("Switch Camera");
                let newCamera = (curCameraIndex + 1) % 5;
                Camera.switch(cameraArray[newCamera], 5, CameraSwitchBlendFunction.Linear);
            });
            // 添加一个按键方法：按下键盘“2”，切换回默认摄像机
            InputUtil.onKeyDown(Keys.Two, () => {
                console.log("Switch Default Camera");
                Camera.switch(myCamera);
            });
        }
    }
}

@Component
export default class CameraExample extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected onStart(): void {
        // 下列代码仅在客户端执行
        if(SystemUtil.isClient()) {
            // 获取当前摄像机
            let myCamera = Camera.currentCamera;
            let curCameraIndex = -1;
            // 在场景中随机创建5个摄像机
            let cameraArray = new Array<Camera>();
            for (let i = 0;
i < 5;
i++) {
                let camera = GameObject.spawn<Camera>("Camera") as Camera;
                camera.worldTransform.position = new Vector(MathUtil.randomInt(-1000, 1000), MathUtil.randomInt(-1000, 1000),MathUtil.randomInt(0, 1000));
                camera.worldTransform.rotation = new Rotation(MathUtil.randomInt(-90, 90), MathUtil.randomInt(-30, 30),MathUtil.randomInt(-150, 150));
                cameraArray.push(camera);
                camera.onSwitchComplete.add(() => {
                    console.log("当前摄像机序号 " + i);
                    curCameraIndex = i;
                });
            }
            // 添加一个按键方法：按下键盘“1”，切换摄像机
            InputUtil.onKeyDown(Keys.One, () => {
                console.log("Switch Camera");
                let newCamera = (curCameraIndex + 1) % 5;
                Camera.switch(cameraArray[newCamera], 5, CameraSwitchBlendFunction.Linear);
            });
            // 添加一个按键方法：按下键盘“2”，切换回默认摄像机
            InputUtil.onKeyDown(Keys.Two, () => {
                console.log("Switch Default Camera");
                Camera.switch(myCamera);
            });
        }
    }
}

@Component
export default class Camera_SpringArm extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected onStart(): void {
        if(SystemUtil.isServer()) {
            // 生成10根柱子用作摄像机弹簧杆碰撞
            for (let i = 0;
i < 10;
i++) {
                GameObject.spawn<Model>("26950",{transform: new Transform(new Vector(100, i * 100, 0), Rotation.zero, Vector.one)});
            }
        }
        // 下列代码仅在客户端执行
        if(SystemUtil.isClient()) {
            // 获取当前摄像机
            let myCamera = Camera.currentCamera;
            // 添加一个按键方法：按下键盘“1”，启用/禁用摄像机弹簧杆碰撞
            InputUtil.onKeyDown(Keys.One, () => {
                myCamera.springArm.collisionEnabled = !myCamera.springArm.collisionEnabled;
                console.log("摄像机弹簧臂的碰撞 " + myCamera.springArm.collisionEnabled);
            });
            // 添加一个按键方法：按下键盘“2”，启用/禁用摄像机弹簧杆移动碰撞检测
            InputUtil.onKeyDown(Keys.Two, () => {
                myCamera.springArm.collisionEnabled = !myCamera.springArm.collisionEnabled;
                console.log("摄像机弹簧臂移动碰撞检测 " + myCamera.springArm.collisionEnabled);
            });
        }
    }
}

@Component
export default class Camera_SpringArm extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected onStart(): void {
        if(SystemUtil.isServer()) {
            // 生成10根柱子用作摄像机弹簧杆碰撞
            for (let i = 0;
i < 10;
i++) {
                GameObject.spawn<Model>("26950",{transform: new Transform(new Vector(100, i * 100, 0), Rotation.zero, Vector.one)});
            }
        }
        // 下列代码仅在客户端执行
        if(SystemUtil.isClient()) {
            // 获取当前摄像机
            let myCamera = Camera.currentCamera;
            // 添加一个按键方法：按下键盘“1”，启用/禁用摄像机弹簧杆碰撞
            InputUtil.onKeyDown(Keys.One, () => {
                myCamera.springArm.collisionEnabled = !myCamera.springArm.collisionEnabled;
                console.log("摄像机弹簧臂的碰撞 " + myCamera.springArm.collisionEnabled);
            });
            // 添加一个按键方法：按下键盘“2”，启用/禁用摄像机弹簧杆移动碰撞检测
            InputUtil.onKeyDown(Keys.Two, () => {
                myCamera.springArm.collisionEnabled = !myCamera.springArm.collisionEnabled;
                console.log("摄像机弹簧臂移动碰撞检测 " + myCamera.springArm.collisionEnabled);
            });
        }
    }
}

@Component
export default class Example_Camera_DownAngleLimit extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected onStart(): void {
        // 下列代码仅在客户端执行
        if(SystemUtil.isClient()) {
            // 获取当前客户端的玩家(自己)
            let myPlayer = Player.localPlayer;
            // 获取玩家角色
            let myCharacter = myPlayer.character;
            // 获取当前摄像机
            let myCamera = Camera.currentCamera;
            // 开启摄像机位置延迟
            myCamera.positionLagEnabled = true;
            // 位置延迟恢复速度1
            myCamera.positionLagSpeed = 1;
            // 最大位置延迟距离200
            myCamera.maxLagDistance = 200;
            // 开启摄像机旋转延迟
            myCamera.rotationLagEnabled = true;
            // 旋转延迟恢复速度2
            myCamera.rotationLagSpeed = 2;
            // 设置摄像机角度限制
            myCamera.upAngleLimit = 30
            myCamera.downAngleLimit = 10;
            // 添加一个按键方法：按下键盘“1”，固定摄像机高度后跳跃
            InputUtil.onKeyDown(Keys.One, () => {
                myCamera.fixedElevation = true;
                myCharacter.jump();
                setTimeout(() => {
                    myCamera.fixedElevation = false;
                }, 1000);
            });
            // 添加一个按键方法：按住键盘“2”，增大摄像机FOV
            InputUtil.onKeyPress(Keys.Two, () => {
                myCamera.fov += 1;
            });
            // 添加一个按键方法：按住键盘“3”，减少摄像机FOV
            InputUtil.onKeyPress(Keys.Three, () => {
                myCamera.fov -= 1;
            });
        }
    }
}

@Component
export default class Example_Camera_DownAngleLimit extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected onStart(): void {
        // 下列代码仅在客户端执行
        if(SystemUtil.isClient()) {
            // 获取当前客户端的玩家(自己)
            let myPlayer = Player.localPlayer;
            // 获取玩家角色
            let myCharacter = myPlayer.character;
            // 获取当前摄像机
            let myCamera = Camera.currentCamera;
            // 开启摄像机位置延迟
            myCamera.positionLagEnabled = true;
            // 位置延迟恢复速度1
            myCamera.positionLagSpeed = 1;
            // 最大位置延迟距离200
            myCamera.maxLagDistance = 200;
            // 开启摄像机旋转延迟
            myCamera.rotationLagEnabled = true;
            // 旋转延迟恢复速度2
            myCamera.rotationLagSpeed = 2;
            // 设置摄像机角度限制
            myCamera.upAngleLimit = 30
            myCamera.downAngleLimit = 10;
            // 添加一个按键方法：按下键盘“1”，固定摄像机高度后跳跃
            InputUtil.onKeyDown(Keys.One, () => {
                myCamera.fixedElevation = true;
                myCharacter.jump();
                setTimeout(() => {
                    myCamera.fixedElevation = false;
                }, 1000);
            });
            // 添加一个按键方法：按住键盘“2”，增大摄像机FOV
            InputUtil.onKeyPress(Keys.Two, () => {
                myCamera.fov += 1;
            });
            // 添加一个按键方法：按住键盘“3”，减少摄像机FOV
            InputUtil.onKeyPress(Keys.Three, () => {
                myCamera.fov -= 1;
            });
        }
    }
}

@Component
export default class Example_Camera_FixedElevation extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected onStart(): void {
        // 下列代码仅在客户端执行
        if(SystemUtil.isClient()) {
            // 获取当前客户端的玩家(自己)
            let myPlayer = Player.localPlayer;
            // 获取玩家角色
            let myCharacter = myPlayer.character;
            // 获取当前摄像机
            let myCamera = Camera.currentCamera;
            // 开启透明效果
            myCamera.transparencyEnabled = true;
            // 添加一个按键方法：按下键盘“1”，增大透明度
            InputUtil.onKeyDown(Keys.One, () => {
                myCamera.transparency += 0.1;
            });
            // 添加一个按键方法：按住键盘“2”，减小透明度
            InputUtil.onKeyPress(Keys.Two, () => {
                myCamera.transparency -= 0.1;
            });
        }
    }
}

@Component
export default class Example_Camera_FixedElevation extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected onStart(): void {
        // 下列代码仅在客户端执行
        if(SystemUtil.isClient()) {
            // 获取当前客户端的玩家(自己)
            let myPlayer = Player.localPlayer;
            // 获取玩家角色
            let myCharacter = myPlayer.character;
            // 获取当前摄像机
            let myCamera = Camera.currentCamera;
            // 开启透明效果
            myCamera.transparencyEnabled = true;
            // 添加一个按键方法：按下键盘“1”，增大透明度
            InputUtil.onKeyDown(Keys.One, () => {
                myCamera.transparency += 0.1;
            });
            // 添加一个按键方法：按住键盘“2”，减小透明度
            InputUtil.onKeyPress(Keys.Two, () => {
                myCamera.transparency -= 0.1;
            });
        }
    }
}

@Component
export default class Example_Camera_FixedElevation extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected onStart(): void {
        // 下列代码仅在客户端执行
        if(SystemUtil.isClient()) {
            // 获取当前客户端的玩家(自己)
            let myPlayer = Player.localPlayer;
            // 获取玩家角色
            let myCharacter = myPlayer.character;
            // 获取当前摄像机
            let myCamera = Camera.currentCamera;
            // 开启摄像机位置延迟
            myCamera.positionLagEnabled = true;
            // 位置延迟恢复速度1
            myCamera.positionLagSpeed = 1;
            // 最大位置延迟距离200
            myCamera.maxLagDistance = 200;
            // 开启摄像机旋转延迟
            myCamera.rotationLagEnabled = true;
            // 旋转延迟恢复速度2
            myCamera.rotationLagSpeed = 2;
            // 设置摄像机角度限制
            myCamera.upAngleLimit = 30
            myCamera.downAngleLimit = 10;
            // 添加一个按键方法：按下键盘“1”，固定摄像机高度后跳跃
            InputUtil.onKeyDown(Keys.One, () => {
                myCamera.fixedElevation = true;
                myCharacter.jump();
                setTimeout(() => {
                    myCamera.fixedElevation = false;
                }, 1000);
            });
            // 添加一个按键方法：按住键盘“2”，增大摄像机FOV
            InputUtil.onKeyPress(Keys.Two, () => {
                myCamera.fov += 1;
            });
            // 添加一个按键方法：按住键盘“3”，减少摄像机FOV
            InputUtil.onKeyPress(Keys.Three, () => {
                myCamera.fov -= 1;
            });
        }
    }
}

@Component
export default class Example_Camera_FixedElevation extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected onStart(): void {
        // 下列代码仅在客户端执行
        if(SystemUtil.isClient()) {
            // 获取当前客户端的玩家(自己)
            let myPlayer = Player.localPlayer;
            // 获取玩家角色
            let myCharacter = myPlayer.character;
            // 获取当前摄像机
            let myCamera = Camera.currentCamera;
            // 开启摄像机位置延迟
            myCamera.positionLagEnabled = true;
            // 位置延迟恢复速度1
            myCamera.positionLagSpeed = 1;
            // 最大位置延迟距离200
            myCamera.maxLagDistance = 200;
            // 开启摄像机旋转延迟
            myCamera.rotationLagEnabled = true;
            // 旋转延迟恢复速度2
            myCamera.rotationLagSpeed = 2;
            // 设置摄像机角度限制
            myCamera.upAngleLimit = 30
            myCamera.downAngleLimit = 10;
            // 添加一个按键方法：按下键盘“1”，固定摄像机高度后跳跃
            InputUtil.onKeyDown(Keys.One, () => {
                myCamera.fixedElevation = true;
                myCharacter.jump();
                setTimeout(() => {
                    myCamera.fixedElevation = false;
                }, 1000);
            });
            // 添加一个按键方法：按住键盘“2”，增大摄像机FOV
            InputUtil.onKeyPress(Keys.Two, () => {
                myCamera.fov += 1;
            });
            // 添加一个按键方法：按住键盘“3”，减少摄像机FOV
            InputUtil.onKeyPress(Keys.Three, () => {
                myCamera.fov -= 1;
            });
        }
    }
}

@Component
export default class Example_Camera_FOV extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected onStart(): void {
        // 下列代码仅在客户端执行
        if(SystemUtil.isClient()) {
            // 获取当前客户端的玩家(自己)
            let myPlayer = Player.localPlayer;
            // 获取玩家角色
            let myCharacter = myPlayer.character;
            // 获取当前摄像机
            let myCamera = Camera.currentCamera;
            // 开启摄像机位置延迟
            myCamera.positionLagEnabled = true;
            // 位置延迟恢复速度1
            myCamera.positionLagSpeed = 1;
            // 最大位置延迟距离200
            myCamera.maxLagDistance = 200;
            // 开启摄像机旋转延迟
            myCamera.rotationLagEnabled = true;
            // 旋转延迟恢复速度2
            myCamera.rotationLagSpeed = 2;
            // 设置摄像机角度限制
            myCamera.upAngleLimit = 30
            myCamera.downAngleLimit = 10;
            // 添加一个按键方法：按下键盘“1”，固定摄像机高度后跳跃
            InputUtil.onKeyDown(Keys.One, () => {
                myCamera.fixedElevation = true;
                myCharacter.jump();
                setTimeout(() => {
                    myCamera.fixedElevation = false;
                }, 1000);
            });
            // 添加一个按键方法：按住键盘“2”，增大摄像机FOV
            InputUtil.onKeyPress(Keys.Two, () => {
                myCamera.fov += 1;
            });
            // 添加一个按键方法：按住键盘“3”，减少摄像机FOV
            InputUtil.onKeyPress(Keys.Three, () => {
                myCamera.fov -= 1;
            });
        }
    }
}

@Component
export default class Example_Camera_FOV extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected onStart(): void {
        // 下列代码仅在客户端执行
        if(SystemUtil.isClient()) {
            // 获取当前客户端的玩家(自己)
            let myPlayer = Player.localPlayer;
            // 获取玩家角色
            let myCharacter = myPlayer.character;
            // 获取当前摄像机
            let myCamera = Camera.currentCamera;
            // 开启摄像机位置延迟
            myCamera.positionLagEnabled = true;
            // 位置延迟恢复速度1
            myCamera.positionLagSpeed = 1;
            // 最大位置延迟距离200
            myCamera.maxLagDistance = 200;
            // 开启摄像机旋转延迟
            myCamera.rotationLagEnabled = true;
            // 旋转延迟恢复速度2
            myCamera.rotationLagSpeed = 2;
            // 设置摄像机角度限制
            myCamera.upAngleLimit = 30
            myCamera.downAngleLimit = 10;
            // 添加一个按键方法：按下键盘“1”，固定摄像机高度后跳跃
            InputUtil.onKeyDown(Keys.One, () => {
                myCamera.fixedElevation = true;
                myCharacter.jump();
                setTimeout(() => {
                    myCamera.fixedElevation = false;
                }, 1000);
            });
            // 添加一个按键方法：按住键盘“2”，增大摄像机FOV
            InputUtil.onKeyPress(Keys.Two, () => {
                myCamera.fov += 1;
            });
            // 添加一个按键方法：按住键盘“3”，减少摄像机FOV
            InputUtil.onKeyPress(Keys.Three, () => {
                myCamera.fov -= 1;
            });
        }
    }
}

@Component
export default class Example_Camera_MaxLagDistance extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected onStart(): void {
        // 下列代码仅在客户端执行
        if(SystemUtil.isClient()) {
            // 获取当前客户端的玩家(自己)
            let myPlayer = Player.localPlayer;
            // 获取玩家角色
            let myCharacter = myPlayer.character;
            // 获取当前摄像机
            let myCamera = Camera.currentCamera;
        }
    }
}

@Component
export default class Example_Camera_MaxLagDistance extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected onStart(): void {
        // 下列代码仅在客户端执行
        if(SystemUtil.isClient()) {
            // 获取当前客户端的玩家(自己)
            let myPlayer = Player.localPlayer;
            // 获取玩家角色
            let myCharacter = myPlayer.character;
            // 获取当前摄像机
            let myCamera = Camera.currentCamera;
        }
    }
}

@Component
export default class Example_Camera_PositionLagEnabled extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected onStart(): void {
        // 下列代码仅在客户端执行
        if(SystemUtil.isClient()) {
            // 获取当前客户端的玩家(自己)
            let myPlayer = Player.localPlayer;
            // 获取玩家角色
            let myCharacter = myPlayer.character;
            // 获取当前摄像机
            let myCamera = Camera.currentCamera;
            // 开启摄像机位置延迟
            myCamera.positionLagEnabled = true;
            // 位置延迟恢复速度1
            myCamera.positionLagSpeed = 1;
            // 添加一个按键方法：按下键盘“1”，固定摄像机高度后跳跃
            InputUtil.onKeyDown(Keys.One, () => {
                myCamera.fixedElevation = true;
                myCharacter.jump();
                setTimeout(() => {
                    myCamera.fixedElevation = false;
                }, 1000);
            });
            // 添加一个按键方法：按住键盘“2”，增大摄像机FOV
            InputUtil.onKeyPress(Keys.Two, () => {
                myCamera.fov += 1;
            });
            // 添加一个按键方法：按住键盘“3”，减少摄像机FOV
            InputUtil.onKeyPress(Keys.Three, () => {
                myCamera.fov -= 1;
            });
        }
    }
}

@Component
export default class Example_Camera_PositionLagEnabled extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected onStart(): void {
        // 下列代码仅在客户端执行
        if(SystemUtil.isClient()) {
            // 获取当前客户端的玩家(自己)
            let myPlayer = Player.localPlayer;
            // 获取玩家角色
            let myCharacter = myPlayer.character;
            // 获取当前摄像机
            let myCamera = Camera.currentCamera;
            // 开启摄像机位置延迟
            myCamera.positionLagEnabled = true;
            // 位置延迟恢复速度1
            myCamera.positionLagSpeed = 1;
            // 添加一个按键方法：按下键盘“1”，固定摄像机高度后跳跃
            InputUtil.onKeyDown(Keys.One, () => {
                myCamera.fixedElevation = true;
                myCharacter.jump();
                setTimeout(() => {
                    myCamera.fixedElevation = false;
                }, 1000);
            });
            // 添加一个按键方法：按住键盘“2”，增大摄像机FOV
            InputUtil.onKeyPress(Keys.Two, () => {
                myCamera.fov += 1;
            });
            // 添加一个按键方法：按住键盘“3”，减少摄像机FOV
            InputUtil.onKeyPress(Keys.Three, () => {
                myCamera.fov -= 1;
            });
        }
    }
}

@Component
export default class Example_Camera_PositionLagSpeed extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected onStart(): void {
        // 下列代码仅在客户端执行
        if(SystemUtil.isClient()) {
            // 获取当前客户端的玩家(自己)
            let myPlayer = Player.localPlayer;
            // 获取玩家角色
            let myCharacter = myPlayer.character;
            // 获取当前摄像机
            let myCamera = Camera.currentCamera;
            // 开启摄像机位置延迟
            myCamera.positionLagEnabled = true;
            // 位置延迟恢复速度1
            myCamera.positionLagSpeed = 1;
            // 添加一个按键方法：按下键盘“1”，固定摄像机高度后跳跃
            InputUtil.onKeyDown(Keys.One, () => {
                myCamera.fixedElevation = true;
                myCharacter.jump();
                setTimeout(() => {
                    myCamera.fixedElevation = false;
                }, 1000);
            });
            // 添加一个按键方法：按住键盘“2”，增大摄像机FOV
            InputUtil.onKeyPress(Keys.Two, () => {
                myCamera.fov += 1;
            });
            // 添加一个按键方法：按住键盘“3”，减少摄像机FOV
            InputUtil.onKeyPress(Keys.Three, () => {
                myCamera.fov -= 1;
            });
        }
    }
}

@Component
export default class Example_Camera_PositionLagSpeed extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected onStart(): void {
        // 下列代码仅在客户端执行
        if(SystemUtil.isClient()) {
            // 获取当前客户端的玩家(自己)
            let myPlayer = Player.localPlayer;
            // 获取玩家角色
            let myCharacter = myPlayer.character;
            // 获取当前摄像机
            let myCamera = Camera.currentCamera;
            // 开启摄像机位置延迟
            myCamera.positionLagEnabled = true;
            // 位置延迟恢复速度1
            myCamera.positionLagSpeed = 1;
            // 添加一个按键方法：按下键盘“1”，固定摄像机高度后跳跃
            InputUtil.onKeyDown(Keys.One, () => {
                myCamera.fixedElevation = true;
                myCharacter.jump();
                setTimeout(() => {
                    myCamera.fixedElevation = false;
                }, 1000);
            });
            // 添加一个按键方法：按住键盘“2”，增大摄像机FOV
            InputUtil.onKeyPress(Keys.Two, () => {
                myCamera.fov += 1;
            });
            // 添加一个按键方法：按住键盘“3”，减少摄像机FOV
            InputUtil.onKeyPress(Keys.Three, () => {
                myCamera.fov -= 1;
            });
        }
    }
}

@Component
export default class Example_Camera_PositionMode extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected onStart(): void {
        // 下列代码仅在客户端执行
        if(SystemUtil.isClient()) {
            // 获取当前客户端的玩家(自己)
            let myPlayer = Player.localPlayer;
            // 获取当前玩家控制的角色
            let myCharacter = myPlayer.character;
            // 获取当前摄像机
            let myCamera = Camera.currentCamera;
            // 打印当前角色摄像机的位置模式和旋转模式
            console.log("当前角色摄像机的位置模式 " + CameraPositionMode[myCamera.positionMode]);
            console.log("当前角色摄像机的旋转模式 " + CameraRotationMode[myCamera.rotationMode]);
            let preset = 0;
            // 添加一个按键方法：按下键盘“1”，切换摄像机预设
            InputUtil.onKeyDown(Keys.One, () => {
                myCamera.preset = (preset + 1) % 6;
                console.log("当前角色相机预设 " + CameraPreset[preset]);
                preset++;
            });
            // 添加一个按键方法：按下键盘“2”，切换摄像机的位置模式
            InputUtil.onKeyDown(Keys.Two, () => {
                myCamera.positionMode = (myCamera.positionMode + 1) % 2;
                console.log("当前角色摄像机的位置模式 " + CameraPositionMode[myCamera.positionMode]);
            });
            // 添加一个按键方法：按下键盘“3”，切换摄像机的旋转模式
            InputUtil.onKeyDown(Keys.Three, () => {
                myCamera.rotationMode = (myCamera.rotationMode + 1) % 3;
                console.log("当前角色摄像机的旋转模式 " + CameraRotationMode[myCamera.rotationMode]);
            });
        }
    }
}

@Component
export default class Example_Camera_PositionMode extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected onStart(): void {
        // 下列代码仅在客户端执行
        if(SystemUtil.isClient()) {
            // 获取当前客户端的玩家(自己)
            let myPlayer = Player.localPlayer;
            // 获取当前玩家控制的角色
            let myCharacter = myPlayer.character;
            // 获取当前摄像机
            let myCamera = Camera.currentCamera;
            // 打印当前角色摄像机的位置模式和旋转模式
            console.log("当前角色摄像机的位置模式 " + CameraPositionMode[myCamera.positionMode]);
            console.log("当前角色摄像机的旋转模式 " + CameraRotationMode[myCamera.rotationMode]);
            let preset = 0;
            // 添加一个按键方法：按下键盘“1”，切换摄像机预设
            InputUtil.onKeyDown(Keys.One, () => {
                myCamera.preset = (preset + 1) % 6;
                console.log("当前角色相机预设 " + CameraPreset[preset]);
                preset++;
            });
            // 添加一个按键方法：按下键盘“2”，切换摄像机的位置模式
            InputUtil.onKeyDown(Keys.Two, () => {
                myCamera.positionMode = (myCamera.positionMode + 1) % 2;
                console.log("当前角色摄像机的位置模式 " + CameraPositionMode[myCamera.positionMode]);
            });
            // 添加一个按键方法：按下键盘“3”，切换摄像机的旋转模式
            InputUtil.onKeyDown(Keys.Three, () => {
                myCamera.rotationMode = (myCamera.rotationMode + 1) % 3;
                console.log("当前角色摄像机的旋转模式 " + CameraRotationMode[myCamera.rotationMode]);
            });
        }
    }
}

@Component
export default class Camera_Preset extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected onStart(): void {
        // 下列代码仅在客户端执行
        if(SystemUtil.isClient()) {
            // 获取当前客户端的玩家(自己)
            let myPlayer = Player.localPlayer;
            // 获取当前玩家控制的角色
            let myCharacter = myPlayer.character;
            // 获取当前摄像机
            let myCamera = Camera.currentCamera;
            // 打印当前角色摄像机的位置模式和旋转模式
            console.log("当前角色摄像机的位置模式 " + CameraPositionMode[myCamera.positionMode]);
            console.log("当前角色摄像机的旋转模式 " + CameraRotationMode[myCamera.rotationMode]);
            let preset = 0;
            // 添加一个按键方法：按下键盘“1”，切换摄像机预设
            InputUtil.onKeyDown(Keys.One, () => {
                myCamera.preset = (preset + 1) % 6;
                console.log("当前角色相机预设 " + CameraPreset[preset]);
                preset++;
            });
            // 添加一个按键方法：按下键盘“2”，切换摄像机的位置模式
            InputUtil.onKeyDown(Keys.Two, () => {
                myCamera.positionMode = (myCamera.positionMode + 1) % 2;
                console.log("当前角色摄像机的位置模式 " + CameraPositionMode[myCamera.positionMode]);
            });
            // 添加一个按键方法：按下键盘“3”，切换摄像机的旋转模式
            InputUtil.onKeyDown(Keys.Three, () => {
                myCamera.rotationMode = (myCamera.rotationMode + 1) % 3;
                console.log("当前角色摄像机的旋转模式 " + CameraRotationMode[myCamera.rotationMode]);
            });
        }
    }
}

@Component
export default class Camera_Preset extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected onStart(): void {
        // 下列代码仅在客户端执行
        if(SystemUtil.isClient()) {
            // 获取当前客户端的玩家(自己)
            let myPlayer = Player.localPlayer;
            // 获取当前玩家控制的角色
            let myCharacter = myPlayer.character;
            // 获取当前摄像机
            let myCamera = Camera.currentCamera;
            // 打印当前角色摄像机的位置模式和旋转模式
            console.log("当前角色摄像机的位置模式 " + CameraPositionMode[myCamera.positionMode]);
            console.log("当前角色摄像机的旋转模式 " + CameraRotationMode[myCamera.rotationMode]);
            let preset = 0;
            // 添加一个按键方法：按下键盘“1”，切换摄像机预设
            InputUtil.onKeyDown(Keys.One, () => {
                myCamera.preset = (preset + 1) % 6;
                console.log("当前角色相机预设 " + CameraPreset[preset]);
                preset++;
            });
            // 添加一个按键方法：按下键盘“2”，切换摄像机的位置模式
            InputUtil.onKeyDown(Keys.Two, () => {
                myCamera.positionMode = (myCamera.positionMode + 1) % 2;
                console.log("当前角色摄像机的位置模式 " + CameraPositionMode[myCamera.positionMode]);
            });
            // 添加一个按键方法：按下键盘“3”，切换摄像机的旋转模式
            InputUtil.onKeyDown(Keys.Three, () => {
                myCamera.rotationMode = (myCamera.rotationMode + 1) % 3;
                console.log("当前角色摄像机的旋转模式 " + CameraRotationMode[myCamera.rotationMode]);
            });
        }
    }
}

@Component
export default class RotationLagEnabled extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected onStart(): void {
        // 下列代码仅在客户端执行
        if(SystemUtil.isClient()) {
            // 获取当前客户端的玩家(自己)
            let myPlayer = Player.localPlayer;
            // 获取玩家角色
            let myCharacter = myPlayer.character;
            // 获取当前摄像机
            let myCamera = Camera.currentCamera;
            // 开启摄像机位置延迟
            myCamera.positionLagEnabled = true;
            // 位置延迟恢复速度1
            myCamera.positionLagSpeed = 1;
            // 最大位置延迟距离200
            myCamera.maxLagDistance = 200;
            // 开启摄像机旋转延迟
            myCamera.rotationLagEnabled = true;
            // 旋转延迟恢复速度2
            myCamera.rotationLagSpeed = 2;
            // 设置摄像机角度限制
            myCamera.upAngleLimit = 30
            myCamera.downAngleLimit = 10;
            // 添加一个按键方法：按下键盘“1”，固定摄像机高度后跳跃
            InputUtil.onKeyDown(Keys.One, () => {
                myCamera.fixedElevation = true;
                myCharacter.jump();
                setTimeout(() => {
                    myCamera.fixedElevation = false;
                }, 1000);
            });
            // 添加一个按键方法：按住键盘“2”，增大摄像机FOV
            InputUtil.onKeyPress(Keys.Two, () => {
                myCamera.fov += 1;
            });
            // 添加一个按键方法：按住键盘“3”，减少摄像机FOV
            InputUtil.onKeyPress(Keys.Three, () => {
                myCamera.fov -= 1;
            });
        }
    }
}

@Component
export default class RotationLagEnabled extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected onStart(): void {
        // 下列代码仅在客户端执行
        if(SystemUtil.isClient()) {
            // 获取当前客户端的玩家(自己)
            let myPlayer = Player.localPlayer;
            // 获取玩家角色
            let myCharacter = myPlayer.character;
            // 获取当前摄像机
            let myCamera = Camera.currentCamera;
            // 开启摄像机位置延迟
            myCamera.positionLagEnabled = true;
            // 位置延迟恢复速度1
            myCamera.positionLagSpeed = 1;
            // 最大位置延迟距离200
            myCamera.maxLagDistance = 200;
            // 开启摄像机旋转延迟
            myCamera.rotationLagEnabled = true;
            // 旋转延迟恢复速度2
            myCamera.rotationLagSpeed = 2;
            // 设置摄像机角度限制
            myCamera.upAngleLimit = 30
            myCamera.downAngleLimit = 10;
            // 添加一个按键方法：按下键盘“1”，固定摄像机高度后跳跃
            InputUtil.onKeyDown(Keys.One, () => {
                myCamera.fixedElevation = true;
                myCharacter.jump();
                setTimeout(() => {
                    myCamera.fixedElevation = false;
                }, 1000);
            });
            // 添加一个按键方法：按住键盘“2”，增大摄像机FOV
            InputUtil.onKeyPress(Keys.Two, () => {
                myCamera.fov += 1;
            });
            // 添加一个按键方法：按住键盘“3”，减少摄像机FOV
            InputUtil.onKeyPress(Keys.Three, () => {
                myCamera.fov -= 1;
            });
        }
    }
}

@Component
export default class Example_Camera_RotationLagSpeed extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected onStart(): void {
        // 下列代码仅在客户端执行
        if(SystemUtil.isClient()) {
            // 获取当前客户端的玩家(自己)
            let myPlayer = Player.localPlayer;
            // 获取玩家角色
            let myCharacter = myPlayer.character;
            // 获取当前摄像机
            let myCamera = Camera.currentCamera;
            // 开启摄像机位置延迟
            myCamera.positionLagEnabled = true;
            // 位置延迟恢复速度1
            myCamera.positionLagSpeed = 1;
            // 最大位置延迟距离200
            myCamera.maxLagDistance = 200;
            // 开启摄像机旋转延迟
            myCamera.rotationLagEnabled = true;
            // 旋转延迟恢复速度2
            myCamera.rotationLagSpeed = 2;
            // 设置摄像机角度限制
            myCamera.upAngleLimit = 30
            myCamera.downAngleLimit = 10;
            // 添加一个按键方法：按下键盘“1”，固定摄像机高度后跳跃
            InputUtil.onKeyDown(Keys.One, () => {
                myCamera.fixedElevation = true;
                myCharacter.jump();
                setTimeout(() => {
                    myCamera.fixedElevation = false;
                }, 1000);
            });
            // 添加一个按键方法：按住键盘“2”，增大摄像机FOV
            InputUtil.onKeyPress(Keys.Two, () => {
                myCamera.fov += 1;
            });
            // 添加一个按键方法：按住键盘“3”，减少摄像机FOV
            InputUtil.onKeyPress(Keys.Three, () => {
                myCamera.fov -= 1;
            });
        }
    }
}

@Component
export default class Example_Camera_RotationLagSpeed extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected onStart(): void {
        // 下列代码仅在客户端执行
        if(SystemUtil.isClient()) {
            // 获取当前客户端的玩家(自己)
            let myPlayer = Player.localPlayer;
            // 获取玩家角色
            let myCharacter = myPlayer.character;
            // 获取当前摄像机
            let myCamera = Camera.currentCamera;
            // 开启摄像机位置延迟
            myCamera.positionLagEnabled = true;
            // 位置延迟恢复速度1
            myCamera.positionLagSpeed = 1;
            // 最大位置延迟距离200
            myCamera.maxLagDistance = 200;
            // 开启摄像机旋转延迟
            myCamera.rotationLagEnabled = true;
            // 旋转延迟恢复速度2
            myCamera.rotationLagSpeed = 2;
            // 设置摄像机角度限制
            myCamera.upAngleLimit = 30
            myCamera.downAngleLimit = 10;
            // 添加一个按键方法：按下键盘“1”，固定摄像机高度后跳跃
            InputUtil.onKeyDown(Keys.One, () => {
                myCamera.fixedElevation = true;
                myCharacter.jump();
                setTimeout(() => {
                    myCamera.fixedElevation = false;
                }, 1000);
            });
            // 添加一个按键方法：按住键盘“2”，增大摄像机FOV
            InputUtil.onKeyPress(Keys.Two, () => {
                myCamera.fov += 1;
            });
            // 添加一个按键方法：按住键盘“3”，减少摄像机FOV
            InputUtil.onKeyPress(Keys.Three, () => {
                myCamera.fov -= 1;
            });
        }
    }
}

@Component
export default class Example_Camera_RotationMode extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected onStart(): void {
        // 下列代码仅在客户端执行
        if(SystemUtil.isClient()) {
            // 获取当前客户端的玩家(自己)
            let myPlayer = Player.localPlayer;
            // 获取当前玩家控制的角色
            let myCharacter = myPlayer.character;
            // 获取当前摄像机
            let myCamera = Camera.currentCamera;
            // 打印当前角色摄像机的位置模式和旋转模式
            console.log("当前角色摄像机的位置模式 " + CameraPositionMode[myCamera.positionMode]);
            console.log("当前角色摄像机的旋转模式 " + CameraRotationMode[myCamera.rotationMode]);
            let preset = 0;
            // 添加一个按键方法：按下键盘“1”，切换摄像机预设
            InputUtil.onKeyDown(Keys.One, () => {
                myCamera.preset = (preset + 1) % 6;
                console.log("当前角色相机预设 " + CameraPreset[preset]);
                preset++;
            });
            // 添加一个按键方法：按下键盘“2”，切换摄像机的位置模式
            InputUtil.onKeyDown(Keys.Two, () => {
                myCamera.positionMode = (myCamera.positionMode + 1) % 2;
                console.log("当前角色摄像机的位置模式 " + CameraPositionMode[myCamera.positionMode]);
            });
            // 添加一个按键方法：按下键盘“3”，切换摄像机的旋转模式
            InputUtil.onKeyDown(Keys.Three, () => {
                myCamera.rotationMode = (myCamera.rotationMode + 1) % 3;
                console.log("当前角色摄像机的旋转模式 " + CameraRotationMode[myCamera.rotationMode]);
            });
        }
    }
}

@Component
export default class Example_Camera_RotationMode extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected onStart(): void {
        // 下列代码仅在客户端执行
        if(SystemUtil.isClient()) {
            // 获取当前客户端的玩家(自己)
            let myPlayer = Player.localPlayer;
            // 获取当前玩家控制的角色
            let myCharacter = myPlayer.character;
            // 获取当前摄像机
            let myCamera = Camera.currentCamera;
            // 打印当前角色摄像机的位置模式和旋转模式
            console.log("当前角色摄像机的位置模式 " + CameraPositionMode[myCamera.positionMode]);
            console.log("当前角色摄像机的旋转模式 " + CameraRotationMode[myCamera.rotationMode]);
            let preset = 0;
            // 添加一个按键方法：按下键盘“1”，切换摄像机预设
            InputUtil.onKeyDown(Keys.One, () => {
                myCamera.preset = (preset + 1) % 6;
                console.log("当前角色相机预设 " + CameraPreset[preset]);
                preset++;
            });
            // 添加一个按键方法：按下键盘“2”，切换摄像机的位置模式
            InputUtil.onKeyDown(Keys.Two, () => {
                myCamera.positionMode = (myCamera.positionMode + 1) % 2;
                console.log("当前角色摄像机的位置模式 " + CameraPositionMode[myCamera.positionMode]);
            });
            // 添加一个按键方法：按下键盘“3”，切换摄像机的旋转模式
            InputUtil.onKeyDown(Keys.Three, () => {
                myCamera.rotationMode = (myCamera.rotationMode + 1) % 3;
                console.log("当前角色摄像机的旋转模式 " + CameraRotationMode[myCamera.rotationMode]);
            });
        }
    }
}

@Component
export default class Example_Camera_UpAngleLimit extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected onStart(): void {
        // 下列代码仅在客户端执行
        if(SystemUtil.isClient()) {
            // 获取当前客户端的玩家(自己)
            let myPlayer = Player.localPlayer;
            // 获取玩家角色
            let myCharacter = myPlayer.character;
            // 获取当前摄像机
            let myCamera = Camera.currentCamera;
            // 开启摄像机位置延迟
            myCamera.positionLagEnabled = true;
            // 位置延迟恢复速度1
            myCamera.positionLagSpeed = 1;
            // 最大位置延迟距离200
            myCamera.maxLagDistance = 200;
            // 开启摄像机旋转延迟
            myCamera.rotationLagEnabled = true;
            // 旋转延迟恢复速度2
            myCamera.rotationLagSpeed = 2;
            // 设置摄像机角度限制
            myCamera.upAngleLimit = 30
            myCamera.downAngleLimit = 10;
            // 添加一个按键方法：按下键盘“1”，固定摄像机高度后跳跃
            InputUtil.onKeyDown(Keys.One, () => {
                myCamera.fixedElevation = true;
                myCharacter.jump();
                setTimeout(() => {
                    myCamera.fixedElevation = false;
                }, 1000);
            });
            // 添加一个按键方法：按住键盘“2”，增大摄像机FOV
            InputUtil.onKeyPress(Keys.Two, () => {
                myCamera.fov += 1;
            });
            // 添加一个按键方法：按住键盘“3”，减少摄像机FOV
            InputUtil.onKeyPress(Keys.Three, () => {
                myCamera.fov -= 1;
            });
        }
    }
}

@Component
export default class Example_Camera_UpAngleLimit extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected onStart(): void {
        // 下列代码仅在客户端执行
        if(SystemUtil.isClient()) {
            // 获取当前客户端的玩家(自己)
            let myPlayer = Player.localPlayer;
            // 获取玩家角色
            let myCharacter = myPlayer.character;
            // 获取当前摄像机
            let myCamera = Camera.currentCamera;
            // 开启摄像机位置延迟
            myCamera.positionLagEnabled = true;
            // 位置延迟恢复速度1
            myCamera.positionLagSpeed = 1;
            // 最大位置延迟距离200
            myCamera.maxLagDistance = 200;
            // 开启摄像机旋转延迟
            myCamera.rotationLagEnabled = true;
            // 旋转延迟恢复速度2
            myCamera.rotationLagSpeed = 2;
            // 设置摄像机角度限制
            myCamera.upAngleLimit = 30
            myCamera.downAngleLimit = 10;
            // 添加一个按键方法：按下键盘“1”，固定摄像机高度后跳跃
            InputUtil.onKeyDown(Keys.One, () => {
                myCamera.fixedElevation = true;
                myCharacter.jump();
                setTimeout(() => {
                    myCamera.fixedElevation = false;
                }, 1000);
            });
            // 添加一个按键方法：按住键盘“2”，增大摄像机FOV
            InputUtil.onKeyPress(Keys.Two, () => {
                myCamera.fov += 1;
            });
            // 添加一个按键方法：按住键盘“3”，减少摄像机FOV
            InputUtil.onKeyPress(Keys.Three, () => {
                myCamera.fov -= 1;
            });
        }
    }
}

@Component
export default class CurrentCamera extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected onStart(): void {
        // 下列代码仅在客户端执行
        if(SystemUtil.isClient()) {
            // 获取当前摄像机
            let myCamera = Camera.currentCamera;
            let curCameraIndex = -1;
            // 在场景中随机创建5个摄像机
            let cameraArray = new Array<Camera>();
            for (let i = 0;
i < 5;
i++) {
                let camera = GameObject.spawn<Camera>("Camera") as Camera;
                camera.worldTransform.position = new Vector(MathUtil.randomInt(-1000, 1000), MathUtil.randomInt(-1000, 1000),MathUtil.randomInt(0, 1000));
                camera.worldTransform.rotation = new Rotation(MathUtil.randomInt(-90, 90), MathUtil.randomInt(-30, 30),MathUtil.randomInt(-150, 150));
                cameraArray.push(camera);
                camera.onSwitchComplete.add(() => {
                    console.log("当前摄像机序号 " + i);
                    curCameraIndex = i;
                });
            }
            // 添加一个按键方法：按下键盘“1”，切换摄像机
            InputUtil.onKeyDown(Keys.One, () => {
                console.log("Switch Camera");
                let newCamera = (curCameraIndex + 1) % 5;
                Camera.switch(cameraArray[newCamera], 5, CameraSwitchBlendFunction.Linear);
            });
            // 添加一个按键方法：按下键盘“2”，切换回默认摄像机
            InputUtil.onKeyDown(Keys.Two, () => {
                console.log("Switch Default Camera");
                Camera.switch(myCamera);
            });
        }
    }
}

@Component
export default class CurrentCamera extends Script {
    // 当脚本被实例后，会在第一帧更新前调用此函数
    protected onStart(): void {
        // 下列代码仅在客户端执行
        if(SystemUtil.isClient()) {
            // 获取当前摄像机
            let myCamera = Camera.currentCamera;
            let curCameraIndex = -1;
            // 在场景中随机创建5个摄像机
            let cameraArray = new Array<Camera>();
            for (let i = 0;
i < 5;
i++) {
                let camera = GameObject.spawn<Camera>("Camera") as Camera;
                camera.worldTransform.position = new Vector(MathUtil.randomInt(-1000, 1000), MathUtil.randomInt(-1000, 1000),MathUtil.randomInt(0, 1000));
                camera.worldTransform.rotation = new Rotation(MathUtil.randomInt(-90, 90), MathUtil.randomInt(-30, 30),MathUtil.randomInt(-150, 150));
                cameraArray.push(camera);
                camera.onSwitchComplete.add(() => {
                    console.log("当前摄像机序号 " + i);
                    curCameraIndex = i;
                });
            }
            // 添加一个按键方法：按下键盘“1”，切换摄像机
            InputUtil.onKeyDown(Keys.One, () => {
                console.log("Switch Camera");
                let newCamera = (curCameraIndex + 1) % 5;
                Camera.switch(cameraArray[newCamera], 5, CameraSwitchBlendFunction.Linear);
            });
            // 添加一个按键方法：按下键盘“2”，切换回默认摄像机
            InputUtil.onKeyDown(Keys.Two, () => {
                console.log("Switch Default Camera");
                Camera.switch(myCamera);
            });
        }
    }
}