Unity 锁定相机第二弹

最新推荐文章于 2023-01-03 10:11:16 发布
最新推荐文章于 2023-01-03 10:11:16 发布
阅读量1.4k 收藏
点赞数 2
分类专栏： Unity
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/SmillCool/article/details/126055706
版权

战斗相机 目标锁定 屏幕区域划分 相机转动逻辑 游戏体验优化
关键词由CSDN通过智能技术生成

前段时间 写的战斗相机一旦切换目标过快 相机就太晃了 晃的想吐
然后参考了某个游戏的战斗相机后 做了以下逻辑改动

大概是这样的

1.当每次攻击时锁定最近的目标 找到目标之后 如果目标在一区内则相机不需要转动
2.如果目标在二区内 相机转动到目标出现出现在1区内后停止转动
3.如果目标在屏幕外 相机转动到目标出现在中上区后停止转动
4.停止转动后 如果仅角色移动 相机只跟随角色移动

根据以上需求 优化了部分逻辑

1.添加了一个屏幕位置枚举

private enum TARGETPOSTYPE {
        /// <summary>
        /// 屏幕中上部分
        /// </summary>
        MIDDLESCREENTOP,
        /// <summary>
        /// 屏幕中部（0.45-0.55）
        /// </summary>
        MIDDLESCREEN,
        /// <summary>
        /// 屏幕中部（0.25-0.75）
        /// </summary>
        ONESCREEN,
        /// <summary>
        /// 屏幕左部（0-0.25）
        /// </summary>
        TWOSCREENLEFT,
        /// <summary>
        /// 屏幕右部（0.75-1）
        /// </summary>
        TWOSCREENRIGHT,
        /// <summary>
        /// 屏幕外
        /// </summary>
        OUTSIDESCREEN,
        NONE,
    }

2.获取目标在屏幕上的位置（0-1）

/// <summary>
    /// 获取目标的屏幕位置
    /// </summary>
    /// <param name="camera"></param>
    /// <param name="targetPos"></param>
    /// <returns></returns>
    public Vector2 GetPosInScreenPos(Camera camera, Vector3 targetPos) {
        Vector3 viewPos = camera.WorldToViewportPoint(targetPos);
        Vector3 dir = (targetPos - camera.transform.position).normalized;
        float dot = Vector3.Dot(camera.transform.forward, dir);

        if(dot > 0)
            return viewPos;
        else
            return new Vector2(-1, -1);
    }

3.每次攻击确定目标的屏幕位置枚举

/// <summary>
    /// 保存每次锁定时锁定目标在屏幕位置
    /// </summary>
    private void SaveLockTargetScreenType() {
        targetShouldType = TARGETPOSTYPE.NONE;
        TARGETPOSTYPE targetPosType = GetTargetInScreenType();

        switch(targetPosType) {
            case TARGETPOSTYPE.TWOSCREENLEFT:
            case TARGETPOSTYPE.TWOSCREENRIGHT:
                targetShouldType = TARGETPOSTYPE.ONESCREEN;
                break;
            case TARGETPOSTYPE.OUTSIDESCREEN:
                targetShouldType = TARGETPOSTYPE.MIDDLESCREENTOP;
                break;
        }
    }

4.监测目标当前屏幕位置枚举 与 需要到达的屏幕位置枚举

/// <summary>
    /// 获取目标的屏幕位置枚举
    /// </summary>
    /// <param name="target2"></param>
    /// <returns></returns>
    private TARGETPOSTYPE GetTargetInScreenType() {
        Vector2 screenPos = GetPosInScreenPos(camera, target2.position);
        Vector2 selfScreenPos = GetPosInScreenPos(camera, target.position);
        if(screenPos.x >= 0 && screenPos.x < 0.25f)
            return TARGETPOSTYPE.TWOSCREENLEFT;
        else if(screenPos.x >= 0.25 && screenPos.x <= 0.75) {
            if(screenPos.x >= 0.45 && screenPos.x <= 0.55) {
                if(screenPos.y >= selfScreenPos.y)
                    return TARGETPOSTYPE.MIDDLESCREENTOP;
                return TARGETPOSTYPE.MIDDLESCREEN;
            } else
                return TARGETPOSTYPE.ONESCREEN;
        } else if(screenPos.x > 0.75f && screenPos.x <= 1)
            return TARGETPOSTYPE.TWOSCREENRIGHT;
        else
            return TARGETPOSTYPE.OUTSIDESCREEN;
    }


/// <summary>
    /// 是否停止相机转动
    /// </summary>
    /// <param name="LockType"></param>
    /// <param name="target2"></param>
    /// <returns></returns>
    private bool StopCameraRot() {
        TARGETPOSTYPE targetPosType = GetTargetInScreenType();
        if(targetPosType <= targetShouldType) return true;
        return false;
    }

5.到达位置后改变相机转动逻辑 从战斗相机改成自由相机

if(beginCalcStop && !StopCameraRot()) {
                cameraMoveWay1 = false;
            } else if(!cameraMoveWay1) {
                cameraMoveWay1 = true;
                beginCalcStop = false;
            }

            Vector3 pos = camera.transform.position;

            if(cameraMoveWay1) {
                CameraMoveWay1(target,  pos);
            } else
                CameraMoveWay2(target,  pos);

 全部的代码是下面这样的：

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class test2 : MonoBehaviour {


    #region 锁定相机新逻辑
    private enum TARGETPOSTYPE {
        /// <summary>
        /// 屏幕中上部分
        /// </summary>
        MIDDLESCREENTOP,
        /// <summary>
        /// 屏幕中部（0.45-0.55）
        /// </summary>
        MIDDLESCREEN,
        /// <summary>
        /// 屏幕中部（0.25-0.75）
        /// </summary>
        ONESCREEN,
        /// <summary>
        /// 屏幕左部（0-0.25）
        /// </summary>
        TWOSCREENLEFT,
        /// <summary>
        /// 屏幕右部（0.75-1）
        /// </summary>
        TWOSCREENRIGHT,
        /// <summary>
        /// 屏幕外
        /// </summary>
        OUTSIDESCREEN,
        NONE,
    }
    /// <summary>
    /// 每次刷新锁定时 确认目标应该去的位置
    /// </summary>
    private TARGETPOSTYPE targetShouldType;

    bool cameraMoveWay1 = false;
    bool beginCalcStop = false;
    #endregion

    /// <summary>
    /// 角色
    /// </summary>
    public Transform target;
    /// <summary>
    /// 目标
    /// </summary>
    public Transform target2;
    /// <summary>
    /// 相机
    /// </summary>
    public Camera camera;
    /// <summary>
    /// 相机距离角色水平距离
    /// </summary>
    public float _radius;
    /// <summary>
    /// 相机看向角色正前方多少米处
    /// </summary>
    public float cameraLookDis;
    /// <summary>
    /// 相机距离角色竖直距离
    /// </summary>
    public float _camHeight;
    /// <summary>
    /// 相机旋转角速度变化曲线
    /// </summary>
    public AnimationCurve _cameraAngleSpeedCurve;
    /// <summary>
    /// 相机角速度
    /// </summary>
    public float cameraSpeed;

    public bool reset;

    // Start is called before the first frame update
    void Start() {
    }

    // Update is called once per frame
    void Update() {
        if(reset) {
            if(beginCalcStop && !StopCameraRot()) {
                cameraMoveWay1 = false;
            } else if(!cameraMoveWay1) {
                cameraMoveWay1 = true;
                beginCalcStop = false;
            }

            Vector3 pos = camera.transform.position;

            if(cameraMoveWay1) {
                CameraMoveWay1(target,  pos);
            } else
                CameraMoveWay2(target,  pos);
        }
    }
    /// <summary>
    /// 获取当前角度标准距离后的位置
    /// </summary>
    /// <returns></returns>
    private Vector3 GetDisPos(Vector3 pos, Vector3 _lookat) {
        Vector3 view = _lookat - pos;
        view.y = 0.0f;
        view.Normalize();
        Vector3 endPos = _lookat - view * _radius;
        endPos.y = 0f;
        return endPos;
    }

    private Vector3 GetCurPos(Vector3 center, Vector3 curPos, float angle) {
        return RotateRound(curPos, center, Vector3.up, angle);
    }

    /// <summary>
    /// 围绕某点旋转指定角度
    /// </summary>
    /// <param name="position">自身坐标</param>
    /// <param name="center">旋转中心</param>
    /// <param name="axis">围绕旋转轴</param>
    /// <param name="angle">旋转角度</param>
    /// <returns></returns>
    private Vector3 RotateRound(Vector3 position, Vector3 center, Vector3 axis, float angle) {
        return Quaternion.AngleAxis(angle, axis) * (position - center) + center;
    }
    /// <summary>
    /// 求出两个向量之间的夹角+-180
    /// </summary>
    /// <param name="from"></param>
    /// <param name="to"></param>
    /// <returns></returns>
    public float Angle_180(Vector3 from, Vector3 to) {
        from.y = 0; to.y = 0;
        Vector3 v3 = Vector3.Cross(from, to);
        if(v3.y > 0)
            return Vector3.Angle(from, to);
        else
            return -Vector3.Angle(from, to);
    }


    /// <summary>
    /// 攻击刷新镜头锁定
    /// </summary>
    /// <param name="target"></param>
    public void AttackUpdate() {
        SaveLockTargetScreenType();
        beginCalcStop = true;
        cameraMoveWay1 = false;
    }

    /// <summary>
    /// 获取当前角度标准距离后的位置
    /// </summary>
    /// <returns></returns>
    private Vector3 GetDisPos(Transform target, Vector3 pos, Vector3 _dir) {
        Vector3 _lookat = target.position - _dir.normalized * cameraLookDis;
        Vector3 view = _lookat - pos;
        view.y = 0.0f;
        view.Normalize();
        Vector3 endPos = _lookat - view * _radius;
        endPos.y = 0f;
        Debug.DrawLine(target.position, endPos, Color.yellow);
        return endPos;
    }

    #region 锁定相机新逻辑
    /// <summary>
    /// 转动方式1 保持主角在屏幕中间 不管锁定目标位置
    /// </summary>
    /// <param name="target"></param>
    /// <param name="dir"></param>
    /// <param name="pos"></param>
    private void CameraMoveWay1(Transform target, Vector3 pos) {
        Vector3 dir = target.position - target2.position;
        dir.y = 0.0f;
        Vector3 lookat = target.position - dir.normalized * cameraLookDis;
        //相机看向目标
        camera.transform.LookAt(lookat);
        Vector3 disEndPos = GetDisPos(target, pos, dir);
        Vector3 curPos = GetCurPos(target.position, disEndPos, 0);

        //相机位置赋值
        camera.transform.position = curPos + Vector3.up * (_camHeight + target.position.y);
    }

    /// <summary>
    /// 转动方式2 保持主角和锁定角色同屏
    /// </summary>
    /// <param name="target"></param>
    /// <param name="dir"></param>
    /// <param name="pos"></param>
    /// <param name="lookat"></param>
    private void CameraMoveWay2(Transform target, Vector3 pos) {
        Vector3 dir = target.position - target2.position;
        dir.y = 0.0f;
        Vector3 lookat = target.position - dir.normalized * cameraLookDis;
        //相机看向目标
        camera.transform.LookAt(lookat);
        //角色到相机的水平方向上的向量
        Vector3 roted = dir.normalized * _radius;
        //相机应该移动到平面上的位置
        Vector3 endPos = lookat + roted;
        //当前相机在校准和角色的水平距离后在平面上的位置
        Vector3 disEndPos = GetDisPos(pos, lookat);
        Vector3 curPos = endPos;
        //当前位置和应到位置的的角度（+-180）
        float angle = Angle_180(disEndPos - lookat, endPos - lookat);
        //根据角度获取曲线上的速度倍率
        float curSpeedRate = _cameraAngleSpeedCurve.Evaluate(Mathf.Abs(angle));
        float curSpeed = cameraSpeed;
        //根据角度调整旋转方向
        if(angle > 0) curSpeed *= 1;
        else if(angle < 0) curSpeed *= -1;
        //根据角度调整位置
        if(Mathf.Abs(angle) > Mathf.Abs(curSpeed * Time.deltaTime * curSpeedRate)) {
            float rotAngle = curSpeed * Time.deltaTime * curSpeedRate;
            //根据圆心角度半径求出旋转角度后应到的位置
            curPos = GetCurPos(target.position, disEndPos, rotAngle);
        }
        //相机位置赋值
        camera.transform.position = curPos + Vector3.up * (_camHeight + target.position.y);
    }

    /// <summary>
    /// 保存每次锁定时锁定目标在屏幕位置
    /// </summary>
    private void SaveLockTargetScreenType() {
        targetShouldType = TARGETPOSTYPE.NONE;
        TARGETPOSTYPE targetPosType = GetTargetInScreenType();

        switch(targetPosType) {
            case TARGETPOSTYPE.TWOSCREENLEFT:
            case TARGETPOSTYPE.TWOSCREENRIGHT:
                targetShouldType = TARGETPOSTYPE.ONESCREEN;
                break;
            case TARGETPOSTYPE.OUTSIDESCREEN:
                targetShouldType = TARGETPOSTYPE.MIDDLESCREENTOP;
                break;
        }
    }

    /// <summary>
    /// 获取目标的屏幕位置枚举
    /// </summary>
    /// <param name="target2"></param>
    /// <returns></returns>
    private TARGETPOSTYPE GetTargetInScreenType() {
        Vector2 screenPos = GetPosInScreenPos(camera, target2.position);
        Vector2 selfScreenPos = GetPosInScreenPos(camera, target.position);
        if(screenPos.x >= 0 && screenPos.x < 0.25f)
            return TARGETPOSTYPE.TWOSCREENLEFT;
        else if(screenPos.x >= 0.25 && screenPos.x <= 0.75) {
            if(screenPos.x >= 0.45 && screenPos.x <= 0.55) {
                if(screenPos.y >= selfScreenPos.y)
                    return TARGETPOSTYPE.MIDDLESCREENTOP;
                return TARGETPOSTYPE.MIDDLESCREEN;
            } else
                return TARGETPOSTYPE.ONESCREEN;
        } else if(screenPos.x > 0.75f && screenPos.x <= 1)
            return TARGETPOSTYPE.TWOSCREENRIGHT;
        else
            return TARGETPOSTYPE.OUTSIDESCREEN;
    }

    /// <summary>
    /// 是否停止相机转动
    /// </summary>
    /// <param name="LockType"></param>
    /// <param name="target2"></param>
    /// <returns></returns>
    private bool StopCameraRot() {
        TARGETPOSTYPE targetPosType = GetTargetInScreenType();
        if(targetPosType <= targetShouldType) return true;
        return false;
    }

    /// <summary>
    /// 获取目标的屏幕位置
    /// </summary>
    /// <param name="camera"></param>
    /// <param name="targetPos"></param>
    /// <returns></returns>
    public Vector2 GetPosInScreenPos(Camera camera, Vector3 targetPos) {
        Vector3 viewPos = camera.WorldToViewportPoint(targetPos);
        Vector3 dir = (targetPos - camera.transform.position).normalized;
        float dot = Vector3.Dot(camera.transform.forward, dir);

        if(dot > 0)
            return viewPos;
        else
            return new Vector2(-1, -1);
    }
    #endregion
}

攻击的时候触发AttackUpdate方法就会按照规则执行

每个rpg游戏必然有着自己的战斗相机特殊要求 ，这个只是记录自己的经历，程序不易，且行且珍惜

一梭键盘任平生
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【Unity笔记】相机的跟随方式
GuitarAndBike的博客
09-11 498
一、直接把主相机作为Player角色的子物体，并自行固定好相机的位置和角度 优点：使用方便 缺点：使用不灵活，相机转动死板，体验不好，相机瞬间移动位置 二、固定相机跟随，这种相机有一个参考对象，它会保持与该参考对象固定的位置，跟随改参考对象发生移动 优点：简单，方便 缺点：无法一直跟随角色身后，适合固定视角游戏 using UnityEngine; using System.Collections...
unity 第三人称相机跟随脚本
08-01
unity 第三人称相机跟随脚本
Unity制作RPG游戏——战斗注视LockOn实现方法
xy_learning的博客
05-05 476
战斗注视LockOn实现方法
Unity摄像机对象锁定旋转运镜模拟
我与岁月的森林的博客
12-27 2732
在3D模式下如何模拟实现Unity摄像机对象锁定旋转运镜，可以分为两个部分，第一是实现对象锁定，第二是实现旋转运镜。对象锁定就是无论摄像机如何运动，始终保持对象位于摄像机成像区域的固定位置，旋转运镜就是使得摄像机围绕对象进行旋转运动。
Unity OpenVR锁定头盔视角
翻肚鱼儿的博客
01-03 1153
unity
详解Unity中的摄像机及实例应用
梦小天幼的博客
04-17 1万+
Unity中，通过摄像机来呈现给玩家精彩纷呈的游戏世界。开发者可以通过摄像机来固定玩家的游玩视角，渲染出特定画面来呈现给玩家。本文介绍了Camera组件的相关参数以及如何使用摄像机的一些应用实例和误区。......
【Unity】如何限制相机、物体的移动角度、位置等
NS_Speak（IVAV）
11-15 3262
Mathf.DeltaAngle(float current,float target)---------返回两个角夹角的最小值。Mathf.ClosestPowerOfTwo(float x)------------返回 2 的 x 次方。Mathf.Pow(float x,float y)--------返回 x 的 y 次方。Mathf.Round()--------四舍五入，返回值为 Float 类型。Mathf.Sqrt(float x)-----------返回 x 的平方根。
Unity 照相机特效
01-11
默认情况下，Unity项目会包含一个主相机，但你可以根据需要添加多个相机来实现不同的视角或特效。 1. **相机滤镜（Camera Filters）**：Camera Filter Pack是Unity的一个扩展包，它提供了多种预设的照相机特效，如...
unity自定义弹出框功能
08-25
unity自定义弹出框功能 Unity 是一个功能强大且广泛应用的游戏引擎，自定义弹出框功能是 Unity 中的一个重要组件，能为用户提供更加友好的交互体验。下面我们将详细介绍 Unity 自定义弹出框功能的实现。 Unity ...
Unity相机移动动画插件
07-22
Unity相机移动动画插件是专为游戏开发者设计的一款强大工具，它允许你在Unity引擎中创建流畅、复杂的相机路径动画。这款插件的核心功能是提供了一种简单易用的方式来控制游戏中的相机，使其能够沿着预定义的路径平滑...
Unity3D游戏开发 第二版
02-26
《Unity3D游戏开发 第二版》是一本深入讲解Unity3D引擎的权威教程，针对游戏开发者和爱好者提供了全面而详尽的知识体系。随着游戏行业的快速发展，Unity3D因其强大的功能、易用性和跨平台特性，已成为全球最受欢迎的...
unity 固定摄影机
12-30 468
[code="java"] #pragma strict @script AddComponentMenu("Level4/Cameras/FixedCamera") /////////////////////////////////////////////////////////// //固定角度摄影机,主体 //思路:用变量offsetPos存放,摄影机与target的位置关系, ...
unity 锁定相机绕锁定目标的弧形运动
SmillCool的博客
07-14 986
相机圆周运动
Unity物体始终处于视口中心
皮皮#2500
02-24 1685
将此代码挂在相机下 using System.Collections; using System.Collections.Generic; using UnityEngine; public class Trace : MonoBehaviour { // Use this for initialization void Start () { } // Update is c...
NO.3——在Unity3D中实现摄像机跟随的三种方法
热门推荐
ghl1390490928的博客
04-28 3万+
在设计第一人称射击游戏以及RPG游戏时，往往需要在主角身上或者近邻位置设置一个摄像机，使其能够跟随主角的移动，提升游戏体验，这里介绍三种实现摄像机跟随的方法。 （一）固定摄像机方法，常用于RPG游戏第一种方法，在Unity的坐标系中，我将摄像机固定在主角头部上边靠后位置，这样，主角在移动过程中，摄像机也随着移动，最后在游戏场景中大概是这个样子： 也就是说，摄...
Unity视角控制和Camera的移动
必运滔
06-22 1万+
类似第一人称射击游戏 把脚本绑定到camera里 using UnityEngine; using System.Collections; public class CameraControll : MonoBehaviour { public float near = 20.0f; public float far = 100.0f; public float sensitiv
关于Unity 接入VR镜头的设置
DoyoFish的博客
07-13 1万+
自己在网上找了很久，如何在Unity工程里接入VR相关的教程，但是要么是版本不同，要么是没有自己想要的。作为一个入门者，只想弄明白如何让Unity里的场景能够在VR眼镜里正常显示。折腾了大半天，终于弄明白是怎么弄的了，接下来把我的心路历程分享一下，也许能帮忙也说不定。一、如何在Unity工程里加入VR1.在网上或者Unity/Asset Store里下载VRTK，这是一个插件，或者叫做工具。有了这...
Unity 运行状态下动态保存 预制体/预制体上脚本参数
SmillCool的博客
11-15 4397
Unity 运行状态下动态保存 预制体/预制体上脚本参数
unity 相机锁定
最新发布
09-08
在Unity中实现相机锁定可以分为两个步骤：对象锁定和旋转运镜。对象锁定是指让相机始终保持一个固定位置，无论相机如何运动。旋转运镜是指让相机围绕某个对象进行旋转运动。 实现对象锁定的思路是让相机的Local坐标...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

一梭键盘任平生

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值