Unity第三人称视角+跟踪

是否对错

已于 2023-09-03 14:54:08 修改

阅读量512

点赞数 1

文章标签： unity 游戏引擎

于 2023-09-03 14:53:02 首次发布

本文链接：https://blog.csdn.net/qq_53077771/article/details/132524135

版权

1.效果实现：

简易版链接: https://pan.baidu.com/s/1kC9DOpQztD-a6G-cM42tgQ 提取码: ure9

全视角旋转简易视频

带动画版视频：

全视角（人物动画，人物方向）

2.进行Preject Settings设置

Input Manager

复制Horizontal，改轴

复制Vertical，改轴

将MouseY修改反向，使得鼠标上下移动控制摄像机正常

3.代码实现

PlayerCharacter

代码主要实现了功能有：

1.判断物体是否在地板上，主要是为了实现落地时的动画

2.动画实现：静止，行走，跑步，跳跃，落地动画（这里是Asset Store资源自带的动画,可自行去寻找资源，进行参数调整即可，或直接Asset Store里面查询3D角色，可以找到同一个资源）

3.人物朝向摄像机方向水平分量，并以此为正方向进行前后左右移动并旋转

注意：设置一个root，也就是摄像对准的目标

PlayerCharacter挂在在人物身上，将摄像机和对准目标进行选定

using UnityEngine;

[RequireComponent(typeof(Rigidbody))]
public class PlayerCharacter : MonoBehaviour
{
    [SerializeField] private float m_WalkSpeed = 2.0f;//行走速度
    [SerializeField] private float m_RunSpeed = 3.5f;//跑步速度
    [SerializeField] private float m_RotateSpeed = 3.0f;//旋转速度
    [SerializeField] private float m_JumpForce = 300.0f;//跳跃力度
    [SerializeField] private float m_RunningStart = 1.0f;// 跑步启动时长
    [SerializeField] private Photographer _photographer;//摄像机
    [SerializeField] private Transform _followingTarget;//摄像对准

    public Vector3 CurrentInput { get; private set; }
    public float MaxWalkSpeed = 5;

    // member
    private Rigidbody m_RigidBody;

    private Animator m_Animator = null;//动画
    private float m_MoveTime = 0;
    private float m_MoveSpeed = 0.0f;
    private bool m_IsGround = true;

    private void Awake()
    {
        m_RigidBody = GetComponent<Rigidbody>();

        m_Animator = this.GetComponentInChildren<Animator>();//动画
        m_MoveSpeed = m_WalkSpeed;
        _photographer.InitCamera(_followingTarget);
    }

    private void Update()
    {
        if (m_RigidBody == null) return;//为空直接返回
        if (m_Animator == null) return;
        // 是否离地
        float rayDistance = 0.3f;//射线的距离
        Vector3 rayOrigin = (this.transform.position + (Vector3.up * rayDistance * 0.5f));//射线的距离
        bool ground = Physics.Raycast(rayOrigin, Vector3.down, rayDistance, LayerMask.GetMask("Default")); //判断角色当前是否在地面上
        if (ground != m_IsGround)
        {
            m_IsGround = ground;

            // landing动画
            if (m_IsGround)
            {
                m_Animator.Play("landing");
            }
        }

        // input
        float h = Input.GetAxis("Horizontal");//水平
        float v = Input.GetAxis("Vertical");//垂直
        bool isMove = ((h != 0) || (v != 0));

        m_MoveTime = isMove ? (m_MoveTime + Time.deltaTime) : 0;
        bool isRun = (m_RunningStart <= m_MoveTime);

        // move speed (walk / run)
        float moveSpeed = isRun ? m_RunSpeed : m_WalkSpeed;
        m_MoveSpeed = isMove ? Mathf.Lerp(m_MoveSpeed, moveSpeed, (8.0f * Time.deltaTime)) : m_WalkSpeed;

        if (isMove)
        {
            // 获取当前摄像机的朝向
            Vector3 cameraForward = _photographer.transform.forward;

            cameraForward.y = 0;
            cameraForward.Normalize();
            // 将物体的旋转朝向设为摄像机的朝向
            transform.rotation = Quaternion.LookRotation(cameraForward);

            Vector3 inputDirection = new Vector3(h, 0, v);

            if (inputDirection != Vector3.zero)
            {
                float rotationAmount = Vector3.Angle(Vector3.forward, inputDirection) * Mathf.Sign(inputDirection.x);
                transform.Rotate(0, rotationAmount, 0);
            }
        }

        m_Animator.SetBool("isMove", isMove);
        m_Animator.SetBool("isRun", isRun);
        // jump
        if (Input.GetButtonDown("Jump") && m_IsGround)//按键jump并且在地面
        {
            m_Animator.Play("jump");
            m_RigidBody.AddForce(Vector3.up * m_JumpForce);
        }

        UpdateMovementInput();
    }

    private void FixedUpdate()
    {
        m_RigidBody.MovePosition(m_RigidBody.position + CurrentInput * m_MoveSpeed * Time.fixedDeltaTime);
    }

    private void UpdateMovementInput()
    {
        Quaternion rot = Quaternion.Euler(0, _photographer.Yaw, 0);

        SetMovementInput(rot * Vector3.forward * Input.GetAxis("Vertical") +
                                            rot * Vector3.right * Input.GetAxis("Horizontal"));
    }

    public void SetMovementInput(Vector3 input)
    {
        CurrentInput = Vector3.ClampMagnitude(input, 1);
    }

}

Photographer

实现摄像机由鼠标控制全方位旋转

注意：Photographer代码挂在在Photographer上，并对参数进行调整，将ArmLengthCurve前后坐标设置为（-90，0.8），（90，10），实现上下旋转时镜头的拉近和推远，每个结点要选择Clamp平滑

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

public class Photographer : MonoBehaviour
{
    public float Pitch { get; private set; }//记录绕X旋转量
    public float Yaw { get; private set; }//绕y轴旋转

    public float mouseSensitivity = 5;//鼠标灵敏度

    public float cameraRotatingSpeed = 80;
    public float cameraYSpeed = 5;
    private Transform _target;
    private Transform _camera;
    [SerializeField] private AnimationCurve _armLengthCurve;

    private void Awake()
    {
        _camera = transform.GetChild(0);
    }

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

    public void InitCamera(Transform target)
    {
        _target = target;
        transform.position = target.position;
    }

    // Update is called once per frame
    private void Update()
    {
        UpdateRotation();
        UpdatePosition();
        UpdateArmLength();
    }

    private void UpdateRotation()
    {
        Yaw += Input.GetAxis("Mouse X") * mouseSensitivity;
        Yaw += Input.GetAxis("CameraRateX") * cameraRotatingSpeed * Time.deltaTime;
        Pitch += Input.GetAxis("Mouse Y") * mouseSensitivity;
        Pitch += Input.GetAxis("CameraRateY") * cameraRotatingSpeed * Time.deltaTime;
        Pitch = Mathf.Clamp(Pitch, -90, 90);//限制在上下90度

        transform.rotation = Quaternion.Euler(Pitch, Yaw, 0);
    }

    private void UpdatePosition()
    {
        Vector3 position = _target.position;
        float newY = Mathf.Lerp(transform.position.y, position.y, Time.deltaTime * cameraYSpeed);
        transform.position = new Vector3(position.x, newY, position.z);
    }

    private void UpdateArmLength()
    {
        _camera.localPosition = new Vector3(0, 0, _armLengthCurve.Evaluate(Pitch) * -1);
    }
}