Convention-Unity-Demo/Assets/Scripts/Framework/CameraObject.cs

using System.Collections;
#if UNITY_6000_0_OR_NEWER
using Unity.Cinemachine;
#else
using Cinemachine;
#endif
using Convention.WindowsUI.Variant;
using UnityEngine;
using Demo.Game.Attr;
using System.IO;
using Convention;
using Demo.Game.ConfigType;

namespace Demo.Game
{
    namespace ConfigType
    {
        public class CameraObjectConfig : ScriptLoadableConfig
        {
            public bool IsSetupOrthographic = false;
            public bool orthographic;
            public bool IsSetupFieldOfView = false;
            public float fieldOfView;
            public bool IsSetupOrthographicSize = false;
            public float orthographicSize;
            public bool IsSetupNearClipPlane = false;
            public float nearClipPlane;
            public bool IsSetupFarClipPlane = false;
            public float farClipPlane;
            public bool IsSetupDepth = false;
            public float depth;
            public bool IsSetupVirtualCameraFollow = false;
            public int VirtualCameraFollow;
            public bool IsSetupVirtualCameraLookAt = false;
            public int VirtualCameraLookAt;
            public bool IsSetupVirtualCameraFollowOffset = false;
            public Vector3 VirtualCameraFollowOffset;
            public bool IsSetupVirtualCameraLookAtDamping = false;
            public Vector3 VirtualCameraLookAtDamping;

            public override void Deserialize(BinaryReader reader)
            {
                IsSetupOrthographic =BinarySerializeUtility.ReadBool(reader);
                orthographic = BinarySerializeUtility.ReadBool(reader);

                IsSetupFieldOfView = BinarySerializeUtility.ReadBool(reader);
                fieldOfView = BinarySerializeUtility.ReadFloat(reader);

                IsSetupOrthographicSize = BinarySerializeUtility.ReadBool(reader);
                orthographicSize = BinarySerializeUtility.ReadFloat(reader);

                IsSetupNearClipPlane = BinarySerializeUtility.ReadBool(reader);
                nearClipPlane = BinarySerializeUtility.ReadFloat(reader);

                IsSetupFarClipPlane = BinarySerializeUtility.ReadBool(reader);
                farClipPlane = BinarySerializeUtility.ReadFloat(reader);

                IsSetupDepth = BinarySerializeUtility.ReadBool(reader);
                depth = BinarySerializeUtility.ReadFloat(reader);

                IsSetupVirtualCameraFollow = BinarySerializeUtility.ReadBool(reader);
                VirtualCameraFollow = BinarySerializeUtility.ReadInt(reader);

                IsSetupVirtualCameraLookAt = BinarySerializeUtility.ReadBool(reader);
                VirtualCameraLookAt = BinarySerializeUtility.ReadInt(reader);

                IsSetupVirtualCameraFollowOffset = BinarySerializeUtility.ReadBool(reader);
                VirtualCameraFollowOffset = BinarySerializeUtility.ReadVec3(reader);

                IsSetupVirtualCameraLookAtDamping = BinarySerializeUtility.ReadBool(reader);
                VirtualCameraLookAtDamping = BinarySerializeUtility.ReadVec3(reader);

                base.Deserialize(reader);
            }

            public override void Serialize(BinaryWriter writer)
            {
                BinarySerializeUtility.WriteBool(writer, IsSetupOrthographic);
                BinarySerializeUtility.WriteBool(writer, orthographic);

                BinarySerializeUtility.WriteBool(writer, IsSetupFieldOfView);
                BinarySerializeUtility.WriteFloat(writer, fieldOfView);

                BinarySerializeUtility.WriteBool(writer, IsSetupOrthographicSize);
                BinarySerializeUtility.WriteFloat(writer, orthographicSize);

                BinarySerializeUtility.WriteBool(writer, IsSetupNearClipPlane);
                BinarySerializeUtility.WriteFloat(writer, nearClipPlane);

                BinarySerializeUtility.WriteBool(writer, IsSetupFarClipPlane);
                BinarySerializeUtility.WriteFloat(writer, farClipPlane);

                BinarySerializeUtility.WriteBool(writer, IsSetupDepth);
                BinarySerializeUtility.WriteFloat(writer, depth);

                BinarySerializeUtility.WriteBool(writer, IsSetupVirtualCameraFollow);
                BinarySerializeUtility.WriteInt(writer, VirtualCameraFollow);

                BinarySerializeUtility.WriteBool(writer, IsSetupVirtualCameraLookAt);
                BinarySerializeUtility.WriteInt(writer,VirtualCameraLookAt);

                BinarySerializeUtility.WriteBool(writer, IsSetupVirtualCameraFollowOffset);
                BinarySerializeUtility.WriteVec3(writer, VirtualCameraFollowOffset);

                BinarySerializeUtility.WriteBool(writer, IsSetupVirtualCameraLookAtDamping);
                BinarySerializeUtility.WriteVec3(writer, VirtualCameraLookAtDamping);
                base.Serialize(writer);
            }
        }
    }

    [Scriptable(nameof(MakeCameraObject))]
    public class CameraObject : ScriptableObject
    {
        protected override ScriptLoadableConfig MakeConfig()
        {
            return new CameraObjectConfig();
        }
        internal Camera MainCamera => Camera.main;
        private CinemachineCamera m_VirtualCamera;
        private CinemachineCamera VirtualCamera
        {
            get
            {
                if (m_VirtualCamera == null)
                    m_VirtualCamera = GetComponent<CinemachineCamera>();
                return m_VirtualCamera;
            }
        }

        public static CameraObject MakeCameraObject()
        {
            Transform mainCameraTransform = Editor.EditorController.instance.MainGameController.MainCameraTransform;
            if (mainCameraTransform.GetComponent<CameraObject>() != null)
            {
                Debug.LogError($"Too much {nameof(CameraObject)}", mainCameraTransform);
                return null;
            }
            // Binding Output
            FindFirstObjectByType<SceneGameWindow>().ModuleCamera =
                mainCameraTransform.gameObject.GetComponent<CinemachineCamera>();
            return mainCameraTransform.gameObject.AddComponent<CameraObject>();
        }

        public override IEnumerator UnloadScript()
        {
            yield return base.UnloadScript();
            FindFirstObjectByType<SceneGameWindow>().ModuleCamera = null;
        }

        /// <summary>
        /// 设置是否为正交相机
        /// </summary>
        [Convention.RScript.Variable.Attr.Method]
        public void SetOrthographic(bool orthographic)
        {
            GetConfig<CameraObjectConfig>().IsSetupOrthographic = true;
            GetConfig<CameraObjectConfig>().orthographic = MainCamera.orthographic = orthographic;
        }

        /// <summary>
        /// 设置相机视野角度
        /// </summary>
        [Convention.RScript.Variable.Attr.Method]
        public void SetFieldOfView(float fieldOfView)
        {
            GetConfig<CameraObjectConfig>().IsSetupFieldOfView = true;
            GetConfig<CameraObjectConfig>().fieldOfView = MainCamera.fieldOfView = fieldOfView;
        }

        /// <summary>
        /// 设置正交相机的尺寸
        /// </summary>
        [Convention.RScript.Variable.Attr.Method]
        public void SetOrthographicSize(float orthographicSize)
        {
            GetConfig<CameraObjectConfig>().IsSetupOrthographicSize = true;
            GetConfig<CameraObjectConfig>().orthographicSize = MainCamera.orthographicSize = orthographicSize;
        }

        /// <summary>
        /// 设置近裁剪面距离
        /// </summary>
        [Convention.RScript.Variable.Attr.Method]
        public void SetNearClipPlane(float nearClipPlane)
        {
            GetConfig<CameraObjectConfig>().IsSetupNearClipPlane = true;
            GetConfig<CameraObjectConfig>().nearClipPlane = MainCamera.nearClipPlane = nearClipPlane;
        }

        /// <summary>
        /// 设置远裁剪面距离
        /// </summary>
        [Convention.RScript.Variable.Attr.Method]
        public void SetFarClipPlane(float farClipPlane)
        {
            GetConfig<CameraObjectConfig>().IsSetupFarClipPlane = true;
            GetConfig<CameraObjectConfig>().farClipPlane = MainCamera.farClipPlane = farClipPlane;
        }

        /// <summary>
        /// 设置相机深度
        /// </summary>
        [Convention.RScript.Variable.Attr.Method]
        public void SetDepth(float depth)
        {
            GetConfig<CameraObjectConfig>().IsSetupDepth = true;
            GetConfig<CameraObjectConfig>().depth = MainCamera.depth = depth;
        }

        /// <summary>
        /// 设置虚拟相机跟随目标
        /// </summary>
        [Convention.RScript.Variable.Attr.Method]
        public void SetVirtualCameraFollow(ScriptableObject target)
        {
            GetConfig<CameraObjectConfig>().IsSetupVirtualCameraFollow = true;
            GetConfig<CameraObjectConfig>().VirtualCameraFollow = GetRoot().FindIndex(target);
            VirtualCamera.Follow = target.transform;
        }

        /// <summary>
        /// 设置虚拟相机观察目标
        /// </summary>
        [Convention.RScript.Variable.Attr.Method]
        public void SetVirtualCameraLookAt(ScriptableObject target)
        {
            GetConfig<CameraObjectConfig>().IsSetupVirtualCameraLookAt = true;
            GetConfig<CameraObjectConfig>().VirtualCameraLookAt = GetRoot().FindIndex(target);
            VirtualCamera.LookAt = target.transform;
        }

        /// <summary>
        /// 设置虚拟相机跟随偏移
        /// </summary>
        /// <param name="x">X轴偏移</param>
        /// <param name="y">Y轴偏移</param>
        /// <param name="z">Z轴偏移</param>
        [Convention.RScript.Variable.Attr.Method]
        public void SetVirtualCameraFollowOffset(float x, float y, float z)
        {
            var body = VirtualCamera.GetCinemachineComponent(CinemachineCore.Stage.Body) as CinemachineFollow;
            if (body != null)
            {
                GetConfig<CameraObjectConfig>().IsSetupVirtualCameraFollowOffset = true;
                GetConfig<CameraObjectConfig>().VirtualCameraFollowOffset = new Vector3(x, y, z);
                body.FollowOffset = new Vector3(x, y, z);
            }
        }

        /// <summary>
        /// 设置虚拟相机观察阻尼
        /// </summary>
        /// <param name="x">X轴阻尼</param>
        /// <param name="y">Y轴阻尼</param>
        /// <param name="z">Z轴阻尼</param>
        [Convention.RScript.Variable.Attr.Method]
        public void SetVirtualCameraLookAtDamping(float x, float y, float z)
        {
            var aim = VirtualCamera.GetCinemachineComponent(CinemachineCore.Stage.Body) as CinemachineRotationComposer;
            if (aim != null)
            {
                GetConfig<CameraObjectConfig>().IsSetupVirtualCameraLookAtDamping = true;
                GetConfig<CameraObjectConfig>().VirtualCameraLookAtDamping = new Vector3(x, y, z);
                aim.Damping = new(x, y);
            }
        }
    }
}