MyComponent_TpsCamera第三人称通用相机

注：个人用的第三人称相机...

查看：MyComponent_PositionMachine虚拟位置电机

查看：MyComponent_RotationMachine虚拟旋转电机

查看：MyComponent_Vector3Constraint向量\欧拉角约束器

 

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

/*
 * 作者：闪电Y黑客
 *
 * 日期：2019.3.25
 * 
 * 功能：用于计算tps第三人称相机位置的组件
 * 
 * 版本：002
 * 
 * 
 * 
 * 主要3个点：
 * 
 * 锚点Anchor_Point：
 *  可获取它的Transform组件（使用：Get_Transform_Anchor_Point() 方法）
 *  tps像机的基点会一直跟随锚点，
 *  所以跟随都是把锚点的Transform赋值为player的Transform，（使用：Set_Follow_Anchor_Transform() 方法）
 *  或者把锚点塞到player下面作为子物体。   (使用：Set_Follow_Anchor_Parent() 方法)
 *  
 * 计算点Calculation_Point：
 *  可获取它的Transform组件（使用：Get_Transform_Calculation_Point() 方法）
 *  计算点为tps相机旋转位移后得出的相机点的位置和方向，
 *  所以可以把相机的Transform赋值为计算点Calculation的Transform，（使用：Get_Transform_Calculation_Point() 方法）
 *  或者把相机塞到计算点下面作为子物体。（使用：Set_Follow_Calculation_Child() 方法）
 * 
 * 
 * 旋转点Rotation_Point：
 *  可获取它的Transform组件（使用：Get_Transform_Rotation_Point() 方法）
 *  用于同步炮台、人物转向等...
 *  
 * 支撑点Support_Point：
 *  可获取它的transform组件（使用：Get_Transform_Support_Point() 方法）
 *  为旋转点左右偏离后的位置，计算点则根据支撑点位置进行前后移动，
 *  用于同步炮台、人物转向等...
 *      
 * 
 */

namespace MyTool.Component
{
    /// <summary>
    /// tps第三人称通用相机
    /// </summary>
    public class MyComponent_TpsCamera : MonoBehaviour
    {

        //===[公共]===
        /// <summary>
        /// 拉伸速度
        /// </summary>
        public float Distance_Speed = 0.01f;//拉伸速度
        /// <summary>
        /// 旋转速度
        /// </summary>
        public float Rotation_Speed = 0.01f;//旋转速度
        /// <summary>
        /// 跟随速度
        /// </summary>
        public float Follow_Speed = 0.1f;//跟随速度

        /// <summary>
        /// 障碍穿越激活
        /// </summary>
        public bool Activation_ObstacleCrossing = false;//障碍穿越激活
        /// <summary>
        /// 旋转激活
        /// </summary>
        public bool Activation_Rotating = true;//旋转激活
        /// <summary>
        /// 拉近激活
        /// </summary>
        public bool Activation_Distance = true;//拉近激活

        /// <summary>
        /// x轴翻转
        /// </summary>
        public bool Reverse_Mouse_X = false;//x轴翻转
        /// <summary>
        /// y轴翻转
        /// </summary>
        public bool Reverse_Mouse_Y = false;//y轴翻转
        /// <summary>
        /// 拉近翻转
        /// </summary>
        public bool Reverse_Mouse_ScrollWheel = false;//拉近翻转

        /// <summary>
        /// 节点偏移坐标
        /// </summary>
        public Vector3 Node_Offset;//节点偏移坐标
        /// <summary>
        /// 节点旋转
        /// </summary>
        public Vector3 Node_EulerAngles;//节点旋转

        /// <summary>
        /// 拉伸约束
        /// </summary>
        public MyComponent_Vector3Constraint DistanceConstraint;//拉伸约束
        /// <summary>
        /// 旋转约束
        /// </summary>
        public MyComponent_Vector3Constraint RotationConstraint;//旋转约束
        /// <summary>
        /// 跟随约束
        /// </summary>
        public MyComponent_Vector3Constraint FollowConstraint;//跟随约束

        //===[私有]======

        private MyComponent_PositionMachine PositionMachine;//拉伸位置电机
        private MyComponent_RotationMachine RotationMachine;//旋转电机
        private MyComponent_PositionMachine FollowMachine;//跟随位置电机

        private Transform Calculation_Point;//计算点(camera)
        private Transform Support_Point;//支撑点
        private Transform Rotation_Point;//旋转点
        private Transform Anchor_Point;//锚点（player） 

        private float Collision_distance = 1;//障碍穿越的检测射线延伸长度
        private int LayerMask = 0;//障碍穿越的遮罩层

        //===[操控数值]======
        private float Control_X;
        private float Control_Y;
        private float Control_Z;



        #region 初始化

        private void Awake()
        {
            //===[建立节点]======
            Calculation_Point = new GameObject("Calculation_Point").transform;//计算点
            Support_Point = new GameObject("Support_Point").transform;//支撑点
            Rotation_Point = new GameObject("Rotation_Point").transform;//旋转点
            Anchor_Point = new GameObject("Anchor_Point").transform;//锚点

            //======[初始化节点结构]======
            Calculation_Point.parent = Support_Point;//计算点.父=支撑点
            Support_Point.parent = Rotation_Point;//支撑点.父=旋转点
            Rotation_Point.parent = transform;//旋转点.父 = 基点（自身transform）

            //======[初始化节点偏离]======
            transform.localPosition = Vector3.zero;
            Rotation_Point.localPosition = new Vector3(0, Node_Offset.y, 0);//旋转点上下改变
            Support_Point.localPosition = new Vector3(Node_Offset.x, 0, 0);//支撑点左右改变
            Calculation_Point.localPosition = new Vector3(0, 0, Node_Offset.z);//计算点前后改变   

            //======[初始化旋转节点]======
            transform.localEulerAngles = Vector3.zero;
            Rotation_Point.localEulerAngles = Node_EulerAngles;//给旋转节点赋初始旋转角度
            Support_Point.localEulerAngles = Vector3.zero;
            Calculation_Point.localEulerAngles = Vector3.zero;

            //===[建立虚拟电机组件]======
            PositionMachine = Rotation_Point.gameObject.AddComponent<MyComponent_PositionMachine>();
            RotationMachine = Rotation_Point.gameObject.AddComponent<MyComponent_RotationMachine>();
            FollowMachine = Rotation_Point.gameObject.AddComponent<MyComponent_PositionMachine>();

            //======[电机组件添加向量约束器]======
            PositionMachine.PositionConstraint = DistanceConstraint;
            RotationMachine.RotationConstraint = RotationConstraint;
            FollowMachine.PositionConstraint = FollowConstraint;

            //======[电机位置重置]======
            PositionMachine.Set_Machine_Reset(new Vector3(0, 0, Node_Offset.z));
            RotationMachine.Set_Machine_Reset(Node_EulerAngles);


        }

        #endregion



        #region 赋值



        /// <summary>
        /// 相机操控赋值，用于控制相机旋转和拉伸
        /// </summary>
        /// <param name="TpsCamera_Control">操控值向量</param>
        public void Set_TpsCamera_Control(Vector3 TpsCamera_Control)
        {
            Control_X = TpsCamera_Control.x;
            Control_Y = TpsCamera_Control.y;
            Control_Z = TpsCamera_Control.z;
        }

        /// <summary>
        /// 相机操控赋值，用于控制相机旋转和拉伸
        /// </summary>
        /// <param name="X">x值</param>
        /// <param name="Y">y值</param>
        /// <param name="Z">z值</param>
        public void Set_TpsCamera_Control(float X, float Y, float Z)
        {
            Control_X = X;
            Control_Y = Y;
            Control_Z = Z;
        }


        /// <summary>
        /// 设置跟随：锚点和Follow_Target同步位置和转向
        /// </summary>
        /// <param name="Follow_Target">要跟随的游戏物体</param>
        public void Set_Follow_Anchor_Transform(Transform Follow_Target)
        {
            Anchor_Point.position = Follow_Target.position;
            Anchor_Point.rotation = Follow_Target.rotation;
        }

        /// <summary>
        /// 设置跟随：锚点设为Follow_Target的子物体进行跟随
        /// </summary>
        /// <param name="Follow_Target">要跟随的游戏物体</param>
        public void Set_Follow_Anchor_Parent(Transform Follow_Target)
        {
            Anchor_Point.parent = Follow_Target;
            Anchor_Point.localPosition = Vector3.zero;
            Anchor_Point.localEulerAngles = Vector3.zero;
        }

        /// <summary>
        /// 计算点设置跟随：把物体设为计算点的子物体进行跟随
        /// </summary>
        /// <param name="Child_Object">子物体</param>
        public void Set_Follow_Calculation_Child(Transform Child_Object)
        {
            Child_Object.parent = Calculation_Point;
            Child_Object.localPosition = Vector3.zero;
            Child_Object.localEulerAngles = Vector3.zero;
        }

        /// <summary>
        /// 激活障碍穿越
        /// </summary>
        /// <param name="collision_distance">检测延伸长度</param>
        /// <param name="LayerMask">遮罩层</param>
        public void Set_Activation_Obstacle_Crossing(float collision_distance, int LayerMask)
        {
            this.Collision_distance = collision_distance;
            this.LayerMask = LayerMask;
            Activation_ObstacleCrossing = true;
        }

        /// <summary>
        /// 重置相机状态
        /// </summary>
        public void Set_Reset_TpsCamera()
        {

            //======[初始化节点偏离]======
            transform.position = Anchor_Point.position; //给基点赋锚点位置
            Rotation_Point.localPosition = new Vector3(0, Node_Offset.y, 0);//旋转点上下改变
            Support_Point.localPosition = new Vector3(Node_Offset.x, 0, 0);//支撑点左右改变
            Calculation_Point.localPosition = new Vector3(0, 0, Node_Offset.z);//计算点前后改变   

            //======[初始化旋转节点]======
            transform.eulerAngles = Anchor_Point.eulerAngles;//给基点赋锚点角度
            Rotation_Point.localEulerAngles = Node_EulerAngles;//给旋转节点赋初始旋转角度
            Support_Point.localEulerAngles = Vector3.zero;
            Calculation_Point.localEulerAngles = Vector3.zero;

            //======[电机位置重置]======
            PositionMachine.Set_Machine_Reset(new Vector3(0, 0, Node_Offset.z));
            RotationMachine.Set_Machine_Reset(Node_EulerAngles);

        }

        #endregion



        #region 取值

        /// <summary>
        /// 获取锚点Transform组件，返回锚点的位置和角度
        /// </summary>
        /// <returns>锚点的位置和角度</returns>
        public Transform Get_Transform_Anchor_Point()
        {
            return Anchor_Point;
        }

        /// <summary>
        /// 获取旋转点Transform组件，返回旋转点的位置和角度
        /// </summary>
        /// <returns>旋转点的位置和角度</returns>
        public Transform Get_Transform_Rotation_Point()
        {
            return Rotation_Point;
        }

        /// <summary>
        /// 获取支撑点Transform组件，返回支撑点的位置和角度
        /// </summary>
        /// <returns>支撑点的位置和角度</returns>
        public Transform Get_Transform_Support_Point()
        {
            return Support_Point;
        }

        /// <summary>
        /// 获取计算点Transform组件，返回计算点的位置和角度
        /// </summary>
        /// <returns>计算点的位置和角度</returns>
        public Transform Get_Transform_Calculation_Point()
        {
            return Calculation_Point;
        }

        /// <summary>
        /// 获取计算点Transform组件，返回计算点的位置和角度
        /// </summary>
        /// <param name="Calculation_Transform">要计算点的Transform组件</param>
        /// <returns></returns>
        public Transform Get_Transform_Calculation_Point(ref Transform Calculation_Transform)
        {
            Calculation_Transform.position = Calculation_Point.position;
            Calculation_Transform.rotation = Calculation_Point.rotation;

            return Calculation_Point;
        }

        #endregion



        #region 运算方法

        /// <summary>
        /// 相机旋转控制
        /// </summary>
        /// <param name="x">相机x轴操控值</param>
        /// <param name="y">相机y轴操控值</param>
        private void TpsCameraRotating(float x, float y)
        {
            x = (Reverse_Mouse_X) ? -x : x;
            y = ((Reverse_Mouse_Y) ? -y : y);

            Rotation_Point.localEulerAngles = RotationMachine
                .Set_MachineActivation(Activation_Rotating)//电机激活
                .SetTarget_Controlled(x, y, 0)//设置旋转轴控制数值
                .Run_EulerAngle_SmoothDampAngle()//运行平滑欧拉角旋转
                .Constraint_Local()//以父系坐标轴进行限制旋转
                .Get_RotationSave();//获取电机旋转角度
        }

        /// <summary>
        /// 相机拉伸控制
        /// </summary>
        /// <param name="z">相机z轴拉伸操控值</param>
        private void TpsCameraDistance(float z)
        {
            z = ((Reverse_Mouse_ScrollWheel) ? -z : z);

            Calculation_Point.localPosition = PositionMachine
                .Set_MachineActivation(Activation_Distance)//电机激活
                .SetTarget_Controlled(0, 0, z)//设置移动轴控制数值
                .Run_SmoothDampAngle()//运行平滑移动
                .Constraint_Local()//以父系坐标轴进行限制移动
                .Get_PositionSave();//获取电机移动位置


            if (Activation_ObstacleCrossing)
            {    //障碍穿越         
                Calculation_Point.position = MyTool.Static.CameraMove.Obstacle_crossing(transform.position, Calculation_Point.position - transform.position, Collision_distance, LayerMask);
            }

        }

        #endregion



        // Update is called once per frame
        void LateUpdate()
        {
            //===[电机速度赋值]======
            PositionMachine.PositionMoveSpeed = Distance_Speed;
            RotationMachine.RotationMoveSpeed = Rotation_Speed;
            FollowMachine.PositionMoveSpeed = Follow_Speed;

            TpsCameraRotating(Control_X, Control_Y);//旋转
            TpsCameraDistance(Control_Z);//拉伸

            //===[相机基点跟随]======
            transform.position = FollowMachine
                .SetTarget_Position(Anchor_Point.position)//给移动电机设置目标位置
                .Run_SmoothDampAngle()//运行平滑移动模式
                .Constraint_Scope()//约束于目标附近进行移动
                .Get_PositionSave();//获取电机位置

        }

    }

}

 

使用例子：

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

public class ceshi002 : MonoBehaviour
{

    public Transform player001;
    public Transform camera001;

    public float Mouse_XSpeed = 3;//鼠标X轴速度
    public float Mouse_YSpeed = 3;//鼠标Y轴速度
    public float Mouse_ScrollWheelSpeed = 3;//鼠标滚轮速度

    public MyComponent_TpsCamera MyComponent_TpsCamera;//tps相机组件


    private Vector3 cameraController;//操控变量

   
    void Start()
    {
        MyComponent_TpsCamera.Set_Follow_Anchor_Parent(player001);//设玩家为父物体
        MyComponent_TpsCamera.Set_Follow_Calculation_Child(camera001);//摄像机设为子物体
    }

    void Update()
    {
        //===【鼠标操控获取】====
        MyComponent_TpsCamera.Activation_Rotating = Input.GetMouseButton(1);    //判断激活旋转
        cameraController.x = -Input.GetAxis("Mouse Y") * Mouse_XSpeed;
        cameraController.y = Input.GetAxis("Mouse X") * Mouse_YSpeed;
        cameraController.z = Input.GetAxis("Mouse ScrollWheel") * Mouse_ScrollWheelSpeed;

        //===【相机控制赋值】====
        MyComponent_TpsCamera.Set_TpsCamera_Control(cameraController);

    }
}

 

扔上去直接运行...

 

移动延迟跟随：

旋转，旋转限制，拉近，拉近限制，障碍穿越: