Skip to content
Camera

玩法 / Camera

Camera Class

摄像机


Camera 对象定义 3D 游戏世界的视图。

Camera 的位置在哪里?

在游戏的一个实例中,每个客户端都有自己的与其关联的 Camera 对象。 相机对象仅存在于查看者的客户端上,驻留在该用户的本地中,因此不能直接从服务器进行编辑。

每个客户端的特定 Camera 对象都可以通过该客户端上 Camera.currentCamera 属性进行访问。

Camera 对象如何工作?

相机的属性定义了 3D 游戏世界的当前视图。 其中最重要的是:

  • Camera.currentCamera.worldTransform 表示相机的位置和方向。

  • Camera.currentCamera.rotationMode 属性调整相机的旋转模式,是否跟随人物旋转而旋转、相机固定不旋转、可由鼠标右键控制旋转三种模式。Camera.currentCamera.positionMode 属性调整相机的位置模式。

  • Camera.currentCamera.fov 表示可见的可观察世界的范围。

Hierarchy

Table of contents

Properties

onSwitchComplete: MulticastDelegate<() => void> client
切换摄像机完成的回调
springArm: SpringArm client
弹簧臂
click

Properties

onBeforeDestroyDelegate: MulticastDelegate<() => void>
物体销毁前事件回调
onCustomPropertyChange: Readonly<MulticastDelegate<(path: string, value: unknown, oldValue: unknown) => void>> other
监听自定义属性同步事件
onDestroyDelegate: MulticastDelegate<() => void>
物体销毁后事件回调
onPropertyChange: Readonly<MulticastDelegate<(path: string, value: unknown, oldValue: unknown) => void>>
监听系统属性同步事件

Accessors

downAngleLimit(): number client
获取摄像机向下角度限制
fadeObstructionEnabled(): boolean client
获取是否启用透明效果
fadeObstructionOpacity(): number client
获取透明度
fixedElevation(): boolean client
固定摄像机高度
fov(): number client
获取摄像机视场
maxLagDistance(): number client
位置最大延迟距离
positionLagEnabled(): boolean client
启用位置延迟
positionLagSpeed(): number client
位置延迟速度
positionMode(): CameraPositionMode client
位置模式
preset(value: CameraPreset): void
设置摄像机预设
rotationLagEnabled(): boolean client
启用旋转延迟
rotationLagSpeed(): number client
旋转延迟速度
rotationMode(): CameraRotationMode client
旋转模式
upAngleLimit(): number client
向上角度限制
currentCamera(): Camera client
当前摄像机
click

Accessors

actorFlagValue(): number other
获取对象标记
actorLevel(): number other
获取Actor等级
assetId(): string
获取当前物体使用资源的GUID
gameObjectId(): string
获取物体的唯一标识(唯一标识一个对象的字符串)。
isDestroyed(): boolean
当前物体是否被销毁
isReady(): boolean
当前物体状态
localTransform(): Transform
当前物体本地变换
name(): string
返回当前物体名称
netStatus(): NetStatus
获取当前物体同步状态
parent(): GameObject
获取当前父物体
tag(): string
获取当前物体的标签
worldTransform(): Transform
当前物体世界变换

Methods

lock(target: GameObject, val?: Object): void client
相机锁定目标
lookAt(target: GameObject Vector): void client
摄像机朝向目标
unlock(): void client
取消锁定目标
shake([shake](mw.Camera.md#shake)Info, duration?: number): void client
开始摄像机抖动
stopShake(): void client
停止摄像机抖动
switch(newCamera: Camera, blendTime?: number, blendFunc?: CameraSwitchBlendFunction, blendExp?: number): Camera client
切换摄像机
click

Methods

addComponent<T: extends Script<T>>(constructor: (...args: unknown[]) => T: extends Script<T>, bInReplicates?: boolean): T: extends Script<T>
添加一个脚本组件
asyncGetChildByName(name: string): Promise<GameObject>
异步根据名称查找子物体
asyncReady(): Promise<GameObject>
物体准备好后返回
clone(gameObjectInfo?: GameObjectInfo): GameObject
复制对象
destroy(): void
删除对象
getBoundingBox(nonColliding?: boolean, includeFromChild?: boolean, outer?: Vector): Vector
获取物体包围盒大小
getBounds(onlyCollidingComponents: boolean, originOuter: Vector, boxExtentOuter: Vector, includeFromChild?: boolean): void
获取物体边界
getChildByGameObjectId(gameObjectId: string): GameObject
根据 gameObjectId 查找子物体
getChildByName(name: string): GameObject
根据名称查找子物体
getChildByPath(path: string): GameObject
根据路径查找子物体
getChildren(): GameObject[]
获取子物体
getChildrenBoundingBoxCenter(outer?: Vector): Vector
获取所有子对象包围盒中心点(不包含父对象,父对象不可用返回[0,0,0])
getChildrenByName(name: string): GameObject[]
通过名字查找所有的子物体
getComponent<T: extends Script<T>>(constructor?: (...args: unknown[]) => T: extends Script<T>): T: extends Script<T>
获取指定类型的组件
getComponentPropertys<T: extends Script<T>>(constructor: (...args: unknown[]) => T: extends Script<T>): Map<string, IPropertyOptions>
获取脚本组件属性
getComponents<T: extends Script<T>>(constructor?: (...args: unknown[]) => T: extends Script<T>): T: extends Script<T>[]
获取指定类型的所有组件
getCustomProperties(): string[]
获取所有自定义属性
getCustomProperty<T: extends CustomPropertyType>(propertyName: string): T: extends CustomPropertyType
获取自定义属性
getCustomPropertyChangeDelegate(property): Readonly<MulticastDelegate<(path: string, value: unknown, oldValue: unknown) => void>> other
给定对象属性修改时触发的事件代理
getPropertyChangeDelegate(property): Readonly<MulticastDelegate<(path: string, value: unknown, oldValue: unknown) => void>> other
给定对象属性修改时触发的事件代理
getVisibility(): boolean
获取物体是否被显示
isPrefabActor(): boolean
返回当前物体是否为预制体
moveBy(velocity: Vector, isLocal?: boolean): void other
按给定的速度矢量随时间平滑地移动对象
moveTo(targetPosition: Vector, time: number, isLocal?: boolean, onComplete?: () => void): void other
在指定时间内从当前位置平滑移动至目标位置
rotateBy(rotation: Quaternion Rotation, multiplier: number, isLocal?: boolean): void other
按给定的旋转量随时间平滑地旋转对象
rotateTo(targetRotation: Quaternion Rotation, time: number, isLocal?: boolean, onComplete?: () => void): void other
在指定时间内从当前旋转平滑变化至目标旋转
scaleBy(scale: Vector, isLocal?: boolean): void other
按每秒给定的缩放矢量随时间平滑缩放对象
scaleTo(targetScale: Vector, time: number, isLocal?: boolean, onComplete?: () => void): void other
在指定时间内从当前缩放平滑变化至目标缩放
setAbsolute(absolutePosition?: boolean, absoluteRotation?: boolean, absoluteScale?: boolean): void
设置物体localTransform是相对于父物体或者世界
setCustomProperty(propertyName: string, value: undefined CustomPropertyType): void
设置自定义属性
setVisibility(status: boolean PropertyStatus, propagateToChildren?: boolean): void
设置物体是否被显示
stopMove(): void other
中断moveTo()、moveBy()的进一步移动
stopRotate(): void other
中断从rotateTo()或rotateBy()的进一步旋转
stopScale(): void other
中断从ScaleTo()或ScaleBy()的进一步缩放
asyncFindGameObjectById(gameObjectId: string): Promise<GameObject>
通过 gameObjectId 异步查找 GameObject
asyncGetGameObjectByPath(path: string): Promise<GameObject>
通过路径异步查找物体
asyncSpawn<T: extends GameObject<T>>(assetId: string, gameObjectInfo?: GameObjectInfo): Promise<T: extends GameObject<T>>
异步构造一个物体
bulkPivotTo(gameObjects: GameObject[], transforms: Transform[]): void
批量设置位置
findGameObjectById(gameObjectId: string): GameObject
通过 gameObjectId 查找物体
findGameObjectByName(name: string): GameObject
通过名字查找物体
findGameObjectsByName(name: string): GameObject[]
通过名字查找物体
findGameObjectsByTag(tag: string): GameObject[]
通过自定义标签获取物体
getGameObjectByPath(path: string): GameObject
通过路径查找物体
spawn<T: extends GameObject<T>>(assetId: string, gameObjectInfo?: GameObjectInfo): T: extends GameObject<T>
构造一个物体

Properties


onSwitchComplete

onSwitchComplete: MulticastDelegate<() => void> client

切换摄像机完成的回调

Precautions

切换到当前摄像机完成执行绑定函数

使用示例:创建一个名为"CameraExample"的脚本,放置在对象栏中,打开脚本,输入以下代码保存,运行游戏,在场景中随机创建5个摄像机。按下键盘“1”,切换摄像机.按下键盘“2”,切换回默认摄像机。你将在场景中看到摄像机切换时的效果。代码如下:
ts
@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);
            });
        }
    }
}

springArm

springArm: SpringArm client

弹簧臂

Precautions

摄像机系统由弹簧臂和摄像机组成,实际挂点是弹簧臂负责,而摄像机是挂载弹簧臂尾端。

使用示例:将使用到的资源:"26950"拖入优先加载栏创建一个名为"Camera_SpringArm"的脚本,放置在对象栏中,打开脚本,输入以下代码保存,运行游戏,你将在场景中生成10根柱子用作触发摄像机弹簧杆碰撞,按下键盘“1”,启用/禁用摄像机弹簧杆碰撞,按下键盘“2”,启用/禁用摄像机弹簧杆移动碰撞检测。你可以看到禁用这些属性产生的不同的效果。代码如下:
ts
@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);
            });
        }
    }
}

Accessors


downAngleLimit

get downAngleLimit(): number client

set downAngleLimit(value): void client

获取摄像机向下角度限制

Precautions

摄像机向下旋转时的最大角度使用范围在0-90之间。

Returns

number

设置摄像机向下角度限制

Precautions

摄像机向下旋转时的最大角度使用范围在0-90之间。

Parameters

value number角度限制
使用示例: 创建一个名为"Example_Camera_DownAngleLimit"的脚本,放置在对象栏中,打开脚本,输入以下代码保存,运行游戏,置摄像机角度限制,上抬最大角度为30,下旋最大角度为10。你将在场景中看到摄像机旋转受限的效果。代码如下:
ts
@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;
            });
        }
    }
}

fadeObstructionEnabled

get fadeObstructionEnabled(): boolean client

set fadeObstructionEnabled(value): void client

获取是否启用透明效果

Precautions

在进入弹簧臂范围的物体会透明,离开后恢复

Returns

boolean

设置是否启用透明效果

Precautions

在进入弹簧臂范围的物体会透明,离开后恢复

Parameters

valueboolean

fadeObstructionOpacity

get fadeObstructionOpacity(): number client

set fadeObstructionOpacity(value): void client

获取透明度

Precautions

范围0-1,值越大透明度越高,1是完全透明

Returns

number

设置透明度

Precautions

范围0-1,值越大透明度越高,1是完全透明

Parameters

valuenumber
使用示例: 创建一个名为"Example_Camera_FixedElevation"的脚本,放置在对象栏中,打开脚本,输入以下代码保存,运行游戏,按下键盘“1”,固定摄像机高度后跳跃。你将在场景中看到角色跳跃时摄像机跟随角色高度的效果。代码如下:
ts
@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;
            });
        }
    }
}

fixedElevation

get fixedElevation(): boolean client

set fixedElevation(value): void client

固定摄像机高度

Precautions

无论挂点如何移动摄像机位置的z轴值不会被改变。

Returns

boolean

固定摄像机高度

Precautions

无论挂点如何移动摄像机位置的z轴值不会被改变。

Parameters

value boolean是否固定
使用示例: 创建一个名为"Example_Camera_FixedElevation"的脚本,放置在对象栏中,打开脚本,输入以下代码保存,运行游戏,按下键盘“1”,固定摄像机高度后跳跃。你将在场景中看到角色跳跃时摄像机跟随角色高度的效果。代码如下:
ts
@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;
            });
        }
    }
}

fov

get fov(): number client

set fov(value): void client

获取摄像机视场

Precautions

FOV,也就是透视模式下的水平视野角度,FOV越大,可见的视野角度越大

Returns

number

设置摄像机视场

Precautions

FOV,也就是透视模式下的水平视野角度,FOV越大,可见的视野角度越大

Parameters

value number视场
使用示例: 创建一个名为"Example_Camera_FOV"的脚本,放置在对象栏中,打开脚本,输入以下代码保存,运行游戏,按住键盘“2”,增大摄像机FOV,按住键盘“3”,减少摄像机FOV。你将在场景中看到摄像机FOV变化的效果。代码如下:
ts
@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;
            });
        }
    }
}

maxLagDistance

get maxLagDistance(): number client

set maxLagDistance(value): void client

位置最大延迟距离

Precautions

控制人物在位移时,摄像机与挂点的最大距离

Returns

number

位置最大延迟距离

Precautions

控制人物在位移时,摄像机与挂点的最大距离

Parameters

value number延迟最大距离
使用示例: 创建一个名为"Example_Camera_MaxLagDistance"的脚本,放置在对象栏中,打开脚本,输入以下代码保存,运行游戏,开启位置延迟后设置最大位置延迟距离为200,你将在场景中看到摄像机位置延迟后摄像机最远只延迟200cm的效果。代码如下:
ts
@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;
        }
    }
}

positionLagEnabled

get positionLagEnabled(): boolean client

set positionLagEnabled(value): void client

启用位置延迟

Precautions

开启后在人物位移时,对摄像机跟随人物的运动进行延迟,关闭则没有延迟效果

Returns

boolean

启用位置延迟

Precautions

开启后在人物位移时,对摄像机跟随人物的运动进行延迟,关闭则没有延迟效果

Parameters

value boolean是否开启
使用示例: 创建一个名为"Example_Camera_PositionLagEnabled"的脚本,放置在对象栏中,打开脚本,输入以下代码保存,运行游戏,你将在场景中看到摄像机位置延迟的效果。代码如下:
ts
@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;
            });
        }
    }
}

positionLagSpeed

get positionLagSpeed(): number client

set positionLagSpeed(value): void client

位置延迟速度

Precautions

控制人物在位移时,摄像机抵达目标位置的速度

Returns

number

设置摄像机位置延迟速度

Precautions

控制人物在位移时,摄像机抵达目标位置的速度

Parameters

value number延迟速度
使用示例: 创建一个名为"Example_Camera_PositionLagSpeed"的脚本,放置在对象栏中,打开脚本,输入以下代码保存,运行游戏,开启位置延迟后设置位置延迟恢复速度为1,你将在场景中看到摄像机位置延迟后摄像机缓慢恢复位置的效果。代码如下:
ts
@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;
            });
        }
    }
}

positionMode

get positionMode(): CameraPositionMode client

set positionMode(value): void client

位置模式

Precautions

摄像机的位置模式。固定模式:摄像机固定在某一位置,不可移动。跟随模式:摄像机跟随某个物体(默认是人物角色)一直移动。

Returns

CameraPositionMode

位置模式

Precautions

摄像机的位置模式。固定模式:摄像机固定在某一位置,不可移动。跟随模式:摄像机跟随某个物体(默认是人物角色)一直移动。

Parameters

value CameraPositionMode位置模式
使用示例: 创建一个名为"Example_Camera_PositionMode"的脚本,放置在对象栏中,打开脚本,输入以下代码保存,运行游戏,按下键盘“2”,切换摄像机的位置模式。你将在场景中看到摄像机不同位置模式的效果并在控制台看到打印的摄像机当前位置模式。代码如下:
ts
@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]);
            });
        }
    }
}

preset

set preset(value): void

设置摄像机预设

Precautions

摄像机提供预设视角模式。第一人称,第三人称,俯视角,默认,TPS过肩视角,FPS射击视角。

Parameters

value CameraPreset预设
使用示例: 创建一个名为"Camera_Preset"的脚本,放置在对象栏中,打开脚本,输入以下代码保存,运行游戏,按下键盘“1”,切换摄像机预设。你将在场景中看到摄像机不同预设的效果。代码如下:
ts
@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]);
            });
        }
    }
}

rotationLagEnabled

get rotationLagEnabled(): boolean client

set rotationLagEnabled(value): void client

启用旋转延迟

Precautions

开启后在视角旋转时,对摄像机跟随人物的运动进行延迟,关闭则没有延迟效果

Returns

boolean

启用旋转延迟

Precautions

开启后在视角旋转时,对摄像机跟随人物的运动进行延迟,关闭则没有延迟效果

Parameters

value boolean是否开启
使用示例: 创建一个名为"Example_Camera_RotationLagEnabled"的脚本,放置在对象栏中,打开脚本,输入以下代码保存,运行游戏,开启摄像机旋转延迟,你将在场景中看到摄像机旋转时延迟的效果。代码如下:
ts
@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;
            });
        }
    }
}

rotationLagSpeed

get rotationLagSpeed(): number client

set rotationLagSpeed(value): void client

旋转延迟速度

Precautions

控制视角在旋转时,摄像机抵达目标位置的角速度

Returns

number

旋转延迟速度

Precautions

控制视角在旋转时,摄像机抵达目标位置的角速度

Parameters

value number延迟速度
使用示例: 创建一个名为"Example_Camera_RotationLagSpeed"的脚本,放置在对象栏中,打开脚本,输入以下代码保存,运行游戏,开启摄像机旋转延迟,你将在场景中看到摄像机旋转时延迟的效果。代码如下:
ts
@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;
            });
        }
    }
}

rotationMode

get rotationMode(): CameraRotationMode client

set rotationMode(value): void client

旋转模式

Precautions

摄像机旋转模式。固定朝向:摄像机固定朝向某一个方向。跟随朝向:摄像机跟随目标面朝方向。控制朝向:摄像机的朝向受到输入控制。

Returns

CameraRotationMode

旋转模式

Precautions

摄像机旋转模式。固定朝向:摄像机固定朝向某一个方向。跟随朝向:摄像机跟随目标面朝方向。控制朝向:摄像机的朝向受到输入控制。

Parameters

value CameraRotationMode旋转模式
使用示例: 创建一个名为"Example_Camera_RotationMode"的脚本,放置在对象栏中,打开脚本,输入以下代码保存,运行游戏,按下键盘“3”,切换摄像机的旋转模式。你将在场景中看到摄像机不同旋转模式的效果并在控制台看到打印的摄像机当前旋转模式。代码如下:
ts
@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]);
            });
        }
    }
}

upAngleLimit

get upAngleLimit(): number client

set upAngleLimit(value): void client

向上角度限制

Precautions

摄像机向上旋转时的最大角度使用范围在0-90之间。

Returns

number

向上角度限制

Precautions

摄像机向上旋转时的最大角度使用范围在0-91之间。

Parameters

value number角度限制
使用示例: 创建一个名为"Example_Camera_UpAngleLimit"的脚本,放置在对象栏中,打开脚本,输入以下代码保存,运行游戏,置摄像机角度限制,上抬最大角度为30,下旋最大角度为10。你将在场景中看到摄像机旋转受限的效果。代码如下:
ts
@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;
            });
        }
    }
}

currentCamera

Static get currentCamera(): Camera client

当前摄像机

Precautions

当前正在使用的摄像机

Returns

使用示例:创建一个名为"CurrentCamera"的脚本,放置在对象栏中,打开脚本,输入以下代码保存,运行游戏,在场景中随机创建5个摄像机。按下键盘“1”,切换摄像机。按下键盘“2”,切换回默认摄像机。你将在场景中看到摄像机切换时的效果。代码如下:
ts
@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);
            });
        }
    }
}
Camera

Methods


lock

lock(target, val?): void client

相机锁定目标

Parameters

target GameObject目标物体
val? ObjectlockInterval,lockSpeed,lockRange,lockDistance,lockOffset,bPause参数集合 default:null
val.bPause? boolean-
val.lockDistance? number-
val.lockInterval? number-
val.lockOffset? Vector-
val.lockRange? number-
val.lockRotationY? boolean-
val.lockRotationZ? boolean-
val.lockSpeed? number-

Precautions

当前摄像机按照参数设置锁定目标对象。

使用示例:创建一个名为"Example_Camera_Lock"的脚本,放置在对象栏中,打开脚本,输入以下代码保存,运行游戏,创建一个敌方角色作为锁定目标。敌方角色会持续追踪玩家角色。按下键盘“1”,锁定敌方角色。按下键盘“2”,手动取消锁定:当bPause参数true时,需要手动取消锁定才能结束锁定流程。按下键盘“3”,角色摄像机朝向目标(无追踪效果)。你将在场景中看到锁定切换时的效果。代码如下:
ts
@Component
export default class Example_Camera_Lock extends Script {
    // 当脚本被实例后,会在第一帧更新前调用此函数
    protected onStart(): void {
        // 下列代码仅在客户端执行
        if(SystemUtil.isClient()) {
            // 获取当前客户端的玩家(自己)
            let myPlayer = Player.localPlayer;
            // 获取当前玩家角色
            let myCharacter = myPlayer.character;
            // 创建一个敌方角色作为锁定目标
            let enemy = Player.spawnDefaultCharacter();
            enemy.switchToFlying()
            enemy.worldTransform.position = new Vector(1000, 500, 130);
            // 敌方角色追踪玩家角色
            TimeUtil.setInterval(() => {
                let distance = Vector.subtract(myCharacter.worldTransform.position, enemy.worldTransform.position);
                if(distance.length < 200) {
                    enemy.addMovement(new Vector(0, 0, 5));
                } else {
                    let dir = distance.normalized;
                    enemy.addMovement(dir);
                    enemy.worldTransform.rotation = distance.toRotation();
                }
            }, 0.02)
            // 添加一个按键方法:按下键盘“1”,锁定敌方角色
            InputUtil.onKeyDown(Keys.One, () => {
                console.error("Start Lock");
                let myCamera = Camera.currentCamera;
                myCamera.lock(enemy, {lockInterval:0, lockSpeed: 0, lockRange: 500, lockDistance: 5000, lockOffset: new Vector(0, 0, 80), bPause: true});
            });
            // 添加一个按键方法:按下键盘“2”,手动取消锁定:当bPause参数true时,需要手动取消锁定才能结束锁定流程
            InputUtil.onKeyDown(Keys.Two, () => {
                let myCamera = Camera.currentCamera;
                myCamera.unlock();
            });
            // 添加一个按键方法:按下键盘“3”,角色看向目标(无追踪效果)
            InputUtil.onKeyDown(Keys.Three, () => {
                let myCamera = Camera.currentCamera;
                myCamera.lookAt(enemy);
            });
        }
    }
}
@Component
export default class Example_Camera_Lock extends Script {
    // 当脚本被实例后,会在第一帧更新前调用此函数
    protected onStart(): void {
        // 下列代码仅在客户端执行
        if(SystemUtil.isClient()) {
            // 获取当前客户端的玩家(自己)
            let myPlayer = Player.localPlayer;
            // 获取当前玩家角色
            let myCharacter = myPlayer.character;
            // 创建一个敌方角色作为锁定目标
            let enemy = Player.spawnDefaultCharacter();
            enemy.switchToFlying()
            enemy.worldTransform.position = new Vector(1000, 500, 130);
            // 敌方角色追踪玩家角色
            TimeUtil.setInterval(() => {
                let distance = Vector.subtract(myCharacter.worldTransform.position, enemy.worldTransform.position);
                if(distance.length < 200) {
                    enemy.addMovement(new Vector(0, 0, 5));
                } else {
                    let dir = distance.normalized;
                    enemy.addMovement(dir);
                    enemy.worldTransform.rotation = distance.toRotation();
                }
            }, 0.02)
            // 添加一个按键方法:按下键盘“1”,锁定敌方角色
            InputUtil.onKeyDown(Keys.One, () => {
                console.error("Start Lock");
                let myCamera = Camera.currentCamera;
                myCamera.lock(enemy, {lockInterval:0, lockSpeed: 0, lockRange: 500, lockDistance: 5000, lockOffset: new Vector(0, 0, 80), bPause: true});
            });
            // 添加一个按键方法:按下键盘“2”,手动取消锁定:当bPause参数true时,需要手动取消锁定才能结束锁定流程
            InputUtil.onKeyDown(Keys.Two, () => {
                let myCamera = Camera.currentCamera;
                myCamera.unlock();
            });
            // 添加一个按键方法:按下键盘“3”,角色看向目标(无追踪效果)
            InputUtil.onKeyDown(Keys.Three, () => {
                let myCamera = Camera.currentCamera;
                myCamera.lookAt(enemy);
            });
        }
    }
}

lookAt

lookAt(target): void client

摄像机朝向目标

Parameters

target GameObject Vector目标
使用示例:创建一个名为"Example_Camera_LookAt"的脚本,放置在对象栏中,打开脚本,输入以下代码保存,运行游戏,创建一个敌方角色作为锁定目标。敌方角色会持续追踪玩家角色。按下键盘“1”,锁定敌方角色。按下键盘“2”,手动取消锁定:当bPause参数true时,需要手动取消锁定才能结束锁定流程。按下键盘“3”,角色摄像机朝向目标(无追踪效果)。你将在场景中看到锁定切换时的效果。代码如下:
ts
@Component
export default class Example_Camera_LookAt extends Script {
    // 当脚本被实例后,会在第一帧更新前调用此函数
    protected onStart(): void {
        // 下列代码仅在客户端执行
        if(SystemUtil.isClient()) {
            // 获取当前客户端的玩家(自己)
            let myPlayer = Player.localPlayer;
            // 获取当前玩家角色
            let myCharacter = myPlayer.character;
            // 创建一个敌方角色作为锁定目标
            let enemy = Player.spawnDefaultCharacter();
            enemy.switchToFlying()
            enemy.worldTransform.position = new Vector(1000, 500, 130);
            // 敌方角色追踪玩家角色
            TimeUtil.setInterval(() => {
                let distance = Vector.subtract(myCharacter.worldTransform.position, enemy.worldTransform.position);
                if(distance.length < 200) {
                    enemy.addMovement(new Vector(0, 0, 5));
                } else {
                    let dir = distance.normalized;
                    enemy.addMovement(dir);
                    enemy.worldTransform.rotation = distance.toRotation();
                }
            }, 0.02)
            // 添加一个按键方法:按下键盘“1”,锁定敌方角色
            InputUtil.onKeyDown(Keys.One, () => {
                console.error("Start Lock");
                let myCamera = Camera.currentCamera;
                myCamera.lock(enemy, {lockInterval:0, lockSpeed: 0, lockRange: 500, lockDistance: 5000, lockOffset: new Vector(0, 0, 80), bPause: true});
            });
            // 添加一个按键方法:按下键盘“2”,手动取消锁定:当bPause参数true时,需要手动取消锁定才能结束锁定流程
            InputUtil.onKeyDown(Keys.Two, () => {
                let myCamera = Camera.currentCamera;
                myCamera.unlock();
            });
            // 添加一个按键方法:按下键盘“3”,角色看向目标(无追踪效果)
            InputUtil.onKeyDown(Keys.Three, () => {
                let myCamera = Camera.currentCamera;
                myCamera.lookAt(enemy);
            });
        }
    }
}
@Component
export default class Example_Camera_LookAt extends Script {
    // 当脚本被实例后,会在第一帧更新前调用此函数
    protected onStart(): void {
        // 下列代码仅在客户端执行
        if(SystemUtil.isClient()) {
            // 获取当前客户端的玩家(自己)
            let myPlayer = Player.localPlayer;
            // 获取当前玩家角色
            let myCharacter = myPlayer.character;
            // 创建一个敌方角色作为锁定目标
            let enemy = Player.spawnDefaultCharacter();
            enemy.switchToFlying()
            enemy.worldTransform.position = new Vector(1000, 500, 130);
            // 敌方角色追踪玩家角色
            TimeUtil.setInterval(() => {
                let distance = Vector.subtract(myCharacter.worldTransform.position, enemy.worldTransform.position);
                if(distance.length < 200) {
                    enemy.addMovement(new Vector(0, 0, 5));
                } else {
                    let dir = distance.normalized;
                    enemy.addMovement(dir);
                    enemy.worldTransform.rotation = distance.toRotation();
                }
            }, 0.02)
            // 添加一个按键方法:按下键盘“1”,锁定敌方角色
            InputUtil.onKeyDown(Keys.One, () => {
                console.error("Start Lock");
                let myCamera = Camera.currentCamera;
                myCamera.lock(enemy, {lockInterval:0, lockSpeed: 0, lockRange: 500, lockDistance: 5000, lockOffset: new Vector(0, 0, 80), bPause: true});
            });
            // 添加一个按键方法:按下键盘“2”,手动取消锁定:当bPause参数true时,需要手动取消锁定才能结束锁定流程
            InputUtil.onKeyDown(Keys.Two, () => {
                let myCamera = Camera.currentCamera;
                myCamera.unlock();
            });
            // 添加一个按键方法:按下键盘“3”,角色看向目标(无追踪效果)
            InputUtil.onKeyDown(Keys.Three, () => {
                let myCamera = Camera.currentCamera;
                myCamera.lookAt(enemy);
            });
        }
    }
}

unlock

unlock(): void client

取消锁定目标

使用示例:创建一个名为"Example_Camera_Unlock"的脚本,放置在对象栏中,打开脚本,输入以下代码保存,运行游戏,创建一个敌方角色作为锁定目标。敌方角色会持续追踪玩家角色。按下键盘“1”,锁定敌方角色。按下键盘“2”,手动取消锁定:当bPause参数true时,需要手动取消锁定才能结束锁定流程。按下键盘“3”,角色摄像机朝向目标(无追踪效果)。你将在场景中看到锁定切换时的效果。代码如下:
ts
@Component
export default class Example_Camera_Unlock extends Script {
    // 当脚本被实例后,会在第一帧更新前调用此函数
    protected onStart(): void {
        // 下列代码仅在客户端执行
        if(SystemUtil.isClient()) {
            // 获取当前客户端的玩家(自己)
            let myPlayer = Player.localPlayer;
            // 获取当前玩家角色
            let myCharacter = myPlayer.character;
            // 创建一个敌方角色作为锁定目标
            let enemy = Player.spawnDefaultCharacter();
            enemy.switchToFlying()
            enemy.worldTransform.position = new Vector(1000, 500, 130);
            // 敌方角色追踪玩家角色
            TimeUtil.setInterval(() => {
                let distance = Vector.subtract(myCharacter.worldTransform.position, enemy.worldTransform.position);
                if(distance.length < 200) {
                    enemy.addMovement(new Vector(0, 0, 5));
                } else {
                    let dir = distance.normalized;
                    enemy.addMovement(dir);
                    enemy.worldTransform.rotation = distance.toRotation();
                }
            }, 0.02)
            // 添加一个按键方法:按下键盘“1”,锁定敌方角色
            InputUtil.onKeyDown(Keys.One, () => {
                console.error("Start Lock");
                let myCamera = Camera.currentCamera;
                myCamera.lock(enemy, {lockInterval:0, lockSpeed: 0, lockRange: 500, lockDistance: 5000, lockOffset: new Vector(0, 0, 80), bPause: true});
            });
            // 添加一个按键方法:按下键盘“2”,手动取消锁定:当bPause参数true时,需要手动取消锁定才能结束锁定流程
            InputUtil.onKeyDown(Keys.Two, () => {
                let myCamera = Camera.currentCamera;
                myCamera.unlock();
            });
            // 添加一个按键方法:按下键盘“3”,角色看向目标(无追踪效果)
            InputUtil.onKeyDown(Keys.Three, () => {
                let myCamera = Camera.currentCamera;
                myCamera.lookAt(enemy);
            });
        }
    }
}
@Component
export default class Example_Camera_Unlock extends Script {
    // 当脚本被实例后,会在第一帧更新前调用此函数
    protected onStart(): void {
        // 下列代码仅在客户端执行
        if(SystemUtil.isClient()) {
            // 获取当前客户端的玩家(自己)
            let myPlayer = Player.localPlayer;
            // 获取当前玩家角色
            let myCharacter = myPlayer.character;
            // 创建一个敌方角色作为锁定目标
            let enemy = Player.spawnDefaultCharacter();
            enemy.switchToFlying()
            enemy.worldTransform.position = new Vector(1000, 500, 130);
            // 敌方角色追踪玩家角色
            TimeUtil.setInterval(() => {
                let distance = Vector.subtract(myCharacter.worldTransform.position, enemy.worldTransform.position);
                if(distance.length < 200) {
                    enemy.addMovement(new Vector(0, 0, 5));
                } else {
                    let dir = distance.normalized;
                    enemy.addMovement(dir);
                    enemy.worldTransform.rotation = distance.toRotation();
                }
            }, 0.02)
            // 添加一个按键方法:按下键盘“1”,锁定敌方角色
            InputUtil.onKeyDown(Keys.One, () => {
                console.error("Start Lock");
                let myCamera = Camera.currentCamera;
                myCamera.lock(enemy, {lockInterval:0, lockSpeed: 0, lockRange: 500, lockDistance: 5000, lockOffset: new Vector(0, 0, 80), bPause: true});
            });
            // 添加一个按键方法:按下键盘“2”,手动取消锁定:当bPause参数true时,需要手动取消锁定才能结束锁定流程
            InputUtil.onKeyDown(Keys.Two, () => {
                let myCamera = Camera.currentCamera;
                myCamera.unlock();
            });
            // 添加一个按键方法:按下键盘“3”,角色看向目标(无追踪效果)
            InputUtil.onKeyDown(Keys.Three, () => {
                let myCamera = Camera.currentCamera;
                myCamera.lookAt(enemy);
            });
        }
    }
}

shake

Static shake(shakeInfo, duration?): void client

开始摄像机抖动

Parameters

shakeInfo CameraShakeInfo抖动信息
duration? number持续时间(秒) default: 1 range: 不做限制 type: 浮点数
使用示例:创建一个名为"Example_Camera_Shake"的脚本,放置在对象栏中,打开脚本,输入以下代码保存,运行游戏,按下键盘“1”,抖动相机5秒。按下键盘“2”,停止相机抖动。你将在场景中看到摄像机镜头抖动时的效果。代码如下:
ts
@Component
export default class Example_Camera_Shake extends Script {
    // 当脚本被实例后,会在第一帧更新前调用此函数
    protected onStart(): void {
        // 下列代码仅在客户端执行
        if(SystemUtil.isClient()) {
            // 添加一个按键方法:按下键盘“1”,抖动相机5秒
            InputUtil.onKeyDown(Keys.One, () => {
                console.log("Start Shake ");
                Camera.shake({positionYAmplitude: 1, positionYFrequency: 0.5, positionZAmplitude: 1, positionZFrequency: 1}, 5);
            });
            // 添加一个按键方法:按下键盘“2”,停止相机抖动
            InputUtil.onKeyUp(Keys.Two, () => {
                console.log("Stop Shake ");
                Camera.stopShake();
            });
        }
    }
}
@Component
export default class Example_Camera_Shake extends Script {
    // 当脚本被实例后,会在第一帧更新前调用此函数
    protected onStart(): void {
        // 下列代码仅在客户端执行
        if(SystemUtil.isClient()) {
            // 添加一个按键方法:按下键盘“1”,抖动相机5秒
            InputUtil.onKeyDown(Keys.One, () => {
                console.log("Start Shake ");
                Camera.shake({positionYAmplitude: 1, positionYFrequency: 0.5, positionZAmplitude: 1, positionZFrequency: 1}, 5);
            });
            // 添加一个按键方法:按下键盘“2”,停止相机抖动
            InputUtil.onKeyUp(Keys.Two, () => {
                console.log("Stop Shake ");
                Camera.stopShake();
            });
        }
    }
}

stopShake

Static stopShake(): void client

停止摄像机抖动

使用示例:创建一个名为"Example_Camera_StopShake"的脚本,放置在对象栏中,打开脚本,输入以下代码保存,运行游戏,按下键盘“1”,抖动相机5秒。按下键盘“2”,停止相机抖动。你将在场景中看到摄像机镜头抖动时的效果。代码如下:
ts
@Component
export default class Example_Camera_StopShake extends Script {
    // 当脚本被实例后,会在第一帧更新前调用此函数
    protected onStart(): void {
        // 下列代码仅在客户端执行
        if(SystemUtil.isClient()) {
            // 添加一个按键方法:按下键盘“1”,抖动相机5秒
            InputUtil.onKeyDown(Keys.One, () => {
                console.log("Start Shake ");
                Camera.shake({positionYAmplitude: 1, positionYFrequency: 0.5, positionZAmplitude: 1, positionZFrequency: 1}, 5);
            });
            // 添加一个按键方法:按下键盘“2”,停止相机抖动
            InputUtil.onKeyUp(Keys.Two, () => {
                console.log("Stop Shake ");
                Camera.stopShake();
            });
        }
    }
}
@Component
export default class Example_Camera_StopShake extends Script {
    // 当脚本被实例后,会在第一帧更新前调用此函数
    protected onStart(): void {
        // 下列代码仅在客户端执行
        if(SystemUtil.isClient()) {
            // 添加一个按键方法:按下键盘“1”,抖动相机5秒
            InputUtil.onKeyDown(Keys.One, () => {
                console.log("Start Shake ");
                Camera.shake({positionYAmplitude: 1, positionYFrequency: 0.5, positionZAmplitude: 1, positionZFrequency: 1}, 5);
            });
            // 添加一个按键方法:按下键盘“2”,停止相机抖动
            InputUtil.onKeyUp(Keys.Two, () => {
                console.log("Stop Shake ");
                Camera.stopShake();
            });
        }
    }
}

switch

Static switch(newCamera, blendTime?, blendFunc?, blendExp?): Camera client

切换摄像机

Parameters

newCamera Camera想要切换的目标摄像机对象,当传入的参数类型为 Transform 时会使用该 Transform 的位置跟旋转生成一个 Camera 再进行切换。
blendTime? number混合时间(秒) default: 0 range: 不做限制 type: 浮点数
blendFunc? CameraSwitchBlendFunction切换时用到的混合函数 default: Linear
blendExp? number混合额外变量,用于控制混合时的快慢程度,具体作用看枚举 SwitchCameraBlendFunction default: 0 range: 不做限制 type: 浮点数

Returns

Camera目标camera对象
使用示例:创建一个名为"Example_Camera_Switch"的脚本,放置在对象栏中,打开脚本,输入以下代码保存,运行游戏,在场景中随机创建5个摄像机。按下键盘“1”,切换摄像机。按下键盘“2”,切换回默认摄像机。你将在场景中看到摄像机切换时的效果。代码如下:
ts
@Component
export default class Example_Camera_Switch 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 Example_Camera_Switch 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);
            });
        }
    }
}