虚拟相机的基本操作

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

namespace XS
{
    public enum TrackLayer
    {
        Defualt = 0,
        LayerTerrain = 10,
        LayerBuilding = 19,
    }

    [SLua.CustomLuaClass]
    public static class TrackCinemachineHelper
    {
        private static int layerOrigin = 0;
        private static Transform objCurTrackDolly = null;
    
        private static Camera m_mainCamera;
        public static Camera mainCamera
        {
            get
            {
                if(null == m_mainCamera)
                {
                    GameObject objMainCamera = GameObject.Find("Main Camera");
                    if(objMainCamera)
                    {
                        m_mainCamera = objMainCamera.GetComponent<Camera>();
                        layerOrigin = m_mainCamera.cullingMask;
                    }
                }

                return m_mainCamera;
            }
            set
            {
                m_mainCamera = value;
            }
        }

        private static GameObject m_objEnterMainSceneEeffect;
        public static GameObject objEnterMainSceneEffect
        {
            get
            {
                if (null == m_objEnterMainSceneEeffect)
                {
                    m_objEnterMainSceneEeffect = mainCamera.transform.Find("effectPoint").gameObject;
                }

                return m_objEnterMainSceneEeffect;
            }
            set
            {
                m_objEnterMainSceneEeffect = value;
            }
        }

        private static GameObject m_objTrackPoint;
        public static GameObject objTrackPoint
        {
            get
            {
                if(null == m_objTrackPoint)
                {
                    if(Application.isPlaying)
                    {
                        m_objTrackPoint = new GameObject("trackPoint");
                        m_objTrackPoint.transform.position = objTrackTest.transform.position;
                        m_objTrackPoint.transform.rotation = objTrackTest.transform.rotation;
                    }
                }

                return m_objTrackPoint;
            }
            set
            {
                m_objTrackPoint = value;
            }
        }
        private static GameObject m_objTrackTest;
        public static GameObject objTrackTest
        {
            get
            {
                if (null == m_objTrackTest)
                {
                    m_objTrackTest = GameObject.Find("Trace_Test");
                }

                return m_objTrackTest;
            }
            set
            {
                m_objTrackTest = value;
            }
        }

        private static GameObject m_objMachineSystem;
        public static GameObject objMachineSystem
        {
            get
            {
                if (null == m_objMachineSystem)
                {
                    m_objMachineSystem = GameObject.Find("CinemachineSystem");
                    if (null == m_objMachineSystem) return null;

                    m_objMachineSystem.transform.position = Vector3.zero;
                }

                return m_objMachineSystem;
            }
            set
            {
                m_objMachineSystem = value;
            }
        }


        private static GameObject m_objTrackNode = null;
        public static GameObject objTrackNode
        {
            get
            {
                if(null == m_objTrackNode && objMachineSystem != null)
                {
                    if(objMachineSystem.transform.Find("CTrackMainVCamera") != null)
                    {
                        m_objTrackNode = objMachineSystem.transform.Find("CTrackMainVCamera").gameObject;
                    }
                }

                return m_objTrackNode;
            }
            set
            {
                m_objTrackNode = value;
            }
        }

        private static CinemachineVirtualCamera m_trackCameraNode = null;
        public static CinemachineVirtualCamera trackCameraNode
        {
            get
            {
                if(null == m_trackCameraNode && objTrackNode != null)
                {
                    m_trackCameraNode = objTrackNode.transform.Find("CMvcam").GetComponent<CinemachineVirtualCamera>();
                }

                return m_trackCameraNode;
            }
            set
            {
                m_trackCameraNode = value;
            }
        }

        private static CinemachineSmoothPath m_dolyPath = null;
        public static CinemachineSmoothPath dolyPath
        {
            get
            {
                if(null == m_dolyPath && objTrackNode != null)
                {
                    m_dolyPath = objTrackNode.transform.Find("DollyTrack").GetComponent<CinemachineSmoothPath>();
                }

                return m_dolyPath;
            }
            set
            {
                m_dolyPath = value;
            }
        }

        private static CinemachineTrackedDolly m_dollyTrack;
        public static CinemachineTrackedDolly dollyTrick
        {
            get
            {
                if(null == m_dollyTrack && trackCameraNode != null)
                {
                    m_dollyTrack = trackCameraNode.GetCinemachineComponent<CinemachineTrackedDolly>();
                    m_dollyTrack.m_XDamping = 0;
                    m_dollyTrack.m_YawDamping = 0;
                    m_dollyTrack.m_ZDamping = 0;
                }

                return m_dollyTrack;
            }
        }

        private static CinemachineComposer m_composer;
        public static CinemachineComposer composer
        {
            get
            {
                if(null == m_composer)
                {
                    m_composer = trackCameraNode.GetCinemachineComponent<CinemachineComposer>();
                }

                return m_composer;
            }
            set
            {
                m_composer = value;
            }
        }

        private static CinemachineBrain m_cMBrain;
        public static CinemachineBrain cMBrain
        {
            get
            {
                if(null == m_cMBrain && mainCamera != null)
                {
                    m_cMBrain = mainCamera.GetComponent<CinemachineBrain>();
                }

                return m_cMBrain;
            }
            set
            {
                m_cMBrain = value;
            }
        }



        //路径点
        public static List<CinemachineSmoothPath.Waypoint> m_LstWayPoint = new List<CinemachineSmoothPath.Waypoint>();

        /// <summary>
        /// 增加位置点到Doly
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <param name="z"></param>
        /// <param name="roll"></param>
        public static void SetPositionToDolyPath(float x, float y, float z, float roll = 0)
        {
            CinemachineSmoothPath.Waypoint waypoint = new CinemachineSmoothPath.Waypoint();
            waypoint.roll = roll;
            waypoint.position = new Vector3(x, y ,z);

            m_LstWayPoint.Add(waypoint);
        }

        /// <summary>
        //转化路点为轨迹
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <param name="z"></param>
        /// <param name="roll"></param>
        public static void ConvertWayPointToTrack()
        {
            if (null == dolyPath)
                return;

            CinemachineSmoothPath.Waypoint[] wayPoints = new CinemachineSmoothPath.Waypoint[m_LstWayPoint.Count];
            for (int i = 0; i < m_LstWayPoint.Count; i++)
            {
                wayPoints[i] = m_LstWayPoint[i];
            }

            dolyPath.InvalidateDistanceCache();
            dolyPath.m_Waypoints = wayPoints;
            dollyTrick.m_Path = dolyPath;
        }

        /// <summary>
        /// 设置相机的朝向
        /// </summary>
        public static void SetCameraUp(int up)
        {
            if(null == dollyTrick)
            {
                return;
            }

            dollyTrick.m_CameraUp = (CinemachineTrackedDolly.CameraUpMode)up;
        }

        /// <summary>
        /// 设置相机的优先级
        /// </summary>
        /// <param name="priority"></param>
        public static void SetCameraPriority(int priority)
        {
            if (null == trackCameraNode)
                return;

            trackCameraNode.Priority = priority;
        }

        /// <summary>
        /// 播放进入主场景特效
        /// </summary>
        public static void PlayDollyEffect(bool is_Play)
        {
            if (null == objEnterMainSceneEffect)
                return;

            objEnterMainSceneEffect.SetActive(is_Play);
        }

        /// <summary>
        /// 设置根节点位置
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <param name="z"></param>
        public static void SetRootPostition(float x, float y, float z)
        {
            if (null == objTrackNode)
                return;

            Vector3 vecPositon = new Vector3(x, y, z);
            objTrackNode.transform.position = vecPositon;
        }

        /// <summary>
        /// 设置根节点位置
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <param name="z"></param>
        public static void SetPolyDamp(float x, float y, float z)
        {
            if (null == dollyTrick)
                return;

            dollyTrick.m_PathOffset.x = x;
            dollyTrick.m_PathOffset.y = y;
            dollyTrick.m_PathOffset.z = z;
        }

        /// <summary>
        /// 设置轨迹的位置
        /// </summary>
        public static void SetTrackPositon(float fIndexPath)
        {
            if (null == dollyTrick)
                return;

            dollyTrick.m_PathPosition = fIndexPath;
        }

        /// <summary>
        /// 改变所有子物体的层次
        /// </summary>
        /// <param name="objTarget"></param>
        public static void SetTargetLayer(bool is_building)
        {
            if (null == trackCameraNode.Follow)
                return;

            int layer = is_building ? (int)TrackLayer.LayerBuilding : (int)TrackLayer.LayerTerrain;
            Transform[] trans = trackCameraNode.Follow.GetComponentsInChildren<Transform>(true);
            foreach (Transform tran in trans)
            {
                if (null == tran)
                    continue;

                tran.gameObject.layer = layer;
            }
        }

        /// <summary>
        /// 改变所有子物体的层次
        /// </summary>
        /// <param name="objTarget"></param>
        public static void SetMainCameraLayer()
        {
            mainCamera.cullingMask =
                (1 << (int)TrackLayer.LayerTerrain) +
                (1 << (int)TrackLayer.Defualt);

            SetTargetLayer(false);
        }

        /// <summary>
        /// 设置硬切模式
        /// </summary>
        public static void SetCutModel()
        {
            CinemachineBrain brain = mainCamera.gameObject.GetComponent<CinemachineBrain>();
            if(null == brain)
            {
                return;
            }
            brain.m_DefaultBlend.m_Style = CinemachineBlendDefinition.Style.Cut;
        }

        /// <summary>
        /// 设置混合模式
        /// </summary>
        public static void SetBlendModel(int model, float durTime)
        {
            CinemachineBrain brain = mainCamera.gameObject.GetComponent<CinemachineBrain>();
            if (null == brain)
            {
                return;
            }
            brain.m_DefaultBlend.m_Style = (CinemachineBlendDefinition.Style)model;
            brain.m_DefaultBlend.m_Time = durTime;
        }

        /// <summary>
        ///  转换相对位置
        /// </summary>
        /// <param name="objTarget"></param>
        public static void ConvertReleativePosition(GameObject objTarget)
        {
            if (null == objTarget || null == dolyPath)
                return;

            Vector3 releativePosition = objTrackTest.transform.InverseTransformPoint(dolyPath.transform.position);
            dolyPath.transform.position = objTrackPoint.transform.TransformPoint(releativePosition);
        }

        /// <summary>
        /// 设置相机的朝向和跟随目标
        /// </summary>
        public static void SeFollowTarget(GameObject objTarget)
        {
            m_LstWayPoint.Clear();
            if (null == trackCameraNode)
            {
                return;
            }

            if (null == objTarget )
            {
                trackCameraNode.LookAt = null;
                trackCameraNode.Follow = null;
                return;
            }

            if(Application.isPlaying)
            {
                objTrackPoint.transform.position = objTarget.transform.position;
            }
            
            trackCameraNode.LookAt = objTarget.transform;
            trackCameraNode.Follow = objTarget.transform;
          
            SetTargetLayer(false);
        }

        /// <summary>
        /// 开始轨迹
        /// </summary>
        /// <param name="prority"></param>
        public static void StartTrack(int prority)
        {
            SetCameraPriority(prority);
        }

        /// <summary>
        ///结束相机轨迹
        /// </summary>
        public static void ExitTrack(int minPrority)
        {
            m_LstWayPoint.Clear();
            SetCameraPriority(minPrority);
        }

        public static void SetCamerLayer()
        {
            SetTargetLayer(true);
            mainCamera.cullingMask = layerOrigin;
        }

        /// <summary>
        /// 设置poly起始位置
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <param name="z"></param>
        public static void SetPolyPostition(float x, float y, float z)
        {
            if (null == dolyPath)
                return;

            Vector3 vecPositon = new Vector3(x, y, z);
            dolyPath.transform.position = vecPositon;
        }

        /// <summary>
        /// 判定是否相机同一个目标
        /// </summary>
        /// <param name="objTarget"></param>
        /// <returns></returns>
        public static bool isSameCinemeTarget(GameObject objTarget)
        { 
            if(null == trackCameraNode || null == trackCameraNode.LookAt)
            {
                return false;
            }

            return objTarget == trackCameraNode.LookAt.gameObject;
        }

        /// <summary>
        /// 设置poly旋转
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <param name="z"></param>
        public static void SetPolyRotation(float x, float y, float z)
        {
            if (null == dolyPath)
                return;

            dolyPath.transform.rotation = Quaternion.Euler(new Vector3(x, y, z));
        }

        /// <summary>
        /// 设置Composer偏移
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <param name="z"></param>
        public static void SetCameraComposeOffsetParams(float x, float y, float z)
        {
            if (null == composer)
                return;

            composer.m_TrackedObjectOffset = new Vector3(x, y, z);
        }


        /// <summary>
        /// 设置Composer偏移
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <param name="z"></param>
        public static void InitTargetDollyData()
        {
            m_LstWayPoint.Clear();
        }
		
		   /// <summary>
        /// 设置Composer偏移
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <param name="z"></param>
        public static void SetCameraBrainEnable(bool bEnable)
        {
            if (null == cMBrain)
                return;
            cMBrain.enabled = bEnable;
        }

        /// <summary>
        /// 设置Composer偏移
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <param name="z"></param>
        public static void SetTargetDollyPosition(GameObject objTarget, float fPos)
        {
            if (null == objTarget || null == dolyPath)
                return;

            Vector3 vecPosition = dolyPath.EvaluatePosition(fPos);
            objTarget.transform.position = vecPosition;
        }

        public static void SetBrainCut()
        {
            cMBrain.m_DefaultBlend = new CinemachineBlendDefinition(0, 0);
        }

        /// <summary>
        ///结束相机轨迹
        /// </summary>
        public static void ExitTragetTrack()
        {
            //cMBrain.enabled = true;
            TrackCinemachineHelper.mainCamera = null;
            TrackCinemachineHelper.m_cMBrain = null;
            TrackCinemachineHelper.m_composer = null;
            TrackCinemachineHelper.m_dollyTrack = null;
            TrackCinemachineHelper.m_objEnterMainSceneEeffect = null;
            TrackCinemachineHelper.m_objMachineSystem = null;
            TrackCinemachineHelper.m_objTrackNode = null;
            TrackCinemachineHelper.m_objTrackTest = null;
            TrackCinemachineHelper.m_dolyPath = null;
            TrackCinemachineHelper.m_objTrackPoint = null;
            TrackCinemachineHelper.m_trackCameraNode = null;
        }
    }
}