玩法 / 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
↳
Camera
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
切换到当前摄像机完成执行绑定函数
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
摄像机系统由弹簧臂和摄像机组成,实际挂点是弹簧臂负责,而摄像机是挂载弹簧臂尾端。
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
• | • | ||||
---|---|---|---|---|---|
获取摄像机向下角度限制 Precautions 摄像机向下旋转时的最大角度使用范围在0-90之间。 Returns
| 设置摄像机向下角度限制 Precautions 摄像机向下旋转时的最大角度使用范围在0-90之间。 Parameters
|
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
• | • | ||||
---|---|---|---|---|---|
获取是否启用透明效果 Precautions 在进入弹簧臂范围的物体会透明,离开后恢复 Returns
| 设置是否启用透明效果 Precautions 在进入弹簧臂范围的物体会透明,离开后恢复 Parameters
|
fadeObstructionOpacity
• | • | ||||
---|---|---|---|---|---|
获取透明度 Precautions 范围0-1,值越大透明度越高,1是完全透明 Returns
| 设置透明度 Precautions 范围0-1,值越大透明度越高,1是完全透明 Parameters
|
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
• | • | ||||
---|---|---|---|---|---|
固定摄像机高度 Precautions 无论挂点如何移动摄像机位置的z轴值不会被改变。 Returns
| 固定摄像机高度 Precautions 无论挂点如何移动摄像机位置的z轴值不会被改变。 Parameters
|
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
• | • | ||||
---|---|---|---|---|---|
获取摄像机视场 Precautions FOV,也就是透视模式下的水平视野角度,FOV越大,可见的视野角度越大 Returns
| 设置摄像机视场 Precautions FOV,也就是透视模式下的水平视野角度,FOV越大,可见的视野角度越大 Parameters
|
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
• | • | ||||
---|---|---|---|---|---|
位置最大延迟距离 Precautions 控制人物在位移时,摄像机与挂点的最大距离 Returns
| 位置最大延迟距离 Precautions 控制人物在位移时,摄像机与挂点的最大距离 Parameters
|
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
• | • | ||||
---|---|---|---|---|---|
启用位置延迟 Precautions 开启后在人物位移时,对摄像机跟随人物的运动进行延迟,关闭则没有延迟效果 Returns
| 启用位置延迟 Precautions 开启后在人物位移时,对摄像机跟随人物的运动进行延迟,关闭则没有延迟效果 Parameters
|
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
• | • | ||||
---|---|---|---|---|---|
位置延迟速度 Precautions 控制人物在位移时,摄像机抵达目标位置的速度 Returns
| 设置摄像机位置延迟速度 Precautions 控制人物在位移时,摄像机抵达目标位置的速度 Parameters
|
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
• | • | ||||
---|---|---|---|---|---|
位置模式 Precautions 摄像机的位置模式。固定模式:摄像机固定在某一位置,不可移动。跟随模式:摄像机跟随某个物体(默认是人物角色)一直移动。 Returns
| 位置模式 Precautions 摄像机的位置模式。固定模式:摄像机固定在某一位置,不可移动。跟随模式:摄像机跟随某个物体(默认是人物角色)一直移动。 Parameters
|
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
• | ||
---|---|---|
设置摄像机预设 Precautions 摄像机提供预设视角模式。第一人称,第三人称,俯视角,默认,TPS过肩视角,FPS射击视角。 Parameters
|
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
• | • | ||||
---|---|---|---|---|---|
启用旋转延迟 Precautions 开启后在视角旋转时,对摄像机跟随人物的运动进行延迟,关闭则没有延迟效果 Returns
| 启用旋转延迟 Precautions 开启后在视角旋转时,对摄像机跟随人物的运动进行延迟,关闭则没有延迟效果 Parameters
|
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
• | • | ||||
---|---|---|---|---|---|
旋转延迟速度 Precautions 控制视角在旋转时,摄像机抵达目标位置的角速度 Returns
| 旋转延迟速度 Precautions 控制视角在旋转时,摄像机抵达目标位置的角速度 Parameters
|
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
• | • | ||||
---|---|---|---|---|---|
旋转模式 Precautions 摄像机旋转模式。固定朝向:摄像机固定朝向某一个方向。跟随朝向:摄像机跟随目标面朝方向。控制朝向:摄像机的朝向受到输入控制。 Returns
| 旋转模式 Precautions 摄像机旋转模式。固定朝向:摄像机固定朝向某一个方向。跟随朝向:摄像机跟随目标面朝方向。控制朝向:摄像机的朝向受到输入控制。 Parameters
|
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
• | • | ||||
---|---|---|---|---|---|
向上角度限制 Precautions 摄像机向上旋转时的最大角度使用范围在0-90之间。 Returns
| 向上角度限制 Precautions 摄像机向上旋转时的最大角度使用范围在0-91之间。 Parameters
|
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
• |
---|
当前摄像机 Precautions 当前正在使用的摄像机 Returns |
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? Object | lockInterval,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
当前摄像机按照参数设置锁定目标对象。
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 | 目标 |
---|
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: 浮点数 |
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对象 |
---|
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);
});
}
}
}