Godot C# 自定义摄像机

前言

说起来，Unity的社区环境跟插件支持确实要比Godot好很多，比如我们Unity最喜欢的Cinemachine插件，只需要动动手指就能轻松实现很多高级的摄像机动效。

所以一转到Godot就有一种力不从心的感觉，于是既然动不了手指我们就动手。自己做一个想要的摄像机。

Godot版本：4.3 mono

思路

其实没什么好说的，一开始只是想做一个能跟着某个节点移动的摄像机，至于为什么不直接把摄像机作为被跟随节点的子节点呢？因为Godot中的摄像机是按照节点树层次找到并展示最近的一个父级Viewport的，我觉得如果一个场景中有多个摄像机的情况，再加上被跟随节点自带的摄像机可能就不好管理了。还有用Unity习惯了，就这样考虑了。

人都是贪得无厌的，一开始还是只想做一个跟随就好了，结果为了满足自己的奇葩需求，索性就加了一些其他功能。

源码

using System.Collections;
using Godot;

namespace GoDogKit
{
    /// <summary>
    /// A highly customizable camera that automatically follows a target.
    /// </summary>
    public partial class AutoCamera2D : Camera2D
    {
        /// <summary>
        /// The target to follow.
        /// </summary>
        [Export] public Node2D FollowTarget { get; set; } = null;
        /// <summary>
        /// Defines the maximum distance from the target to follow. Does not effect to the predict behaviour.
        /// </summary>
        [Export] public float FollowClamp { get; set; } = 1.0f;

        /// <summary>
        /// Defines the camera's behaviour when following the target.
        /// </summary>
        public enum BehaviourType
        {
            /// <summary>
            /// Follows the target normally. Results in global position copying.
            /// </summary>
            Normal,
            /// <summary>
            /// Smoothly follows the target in a given duration. Results in global position interpolation.
            /// </summary>            
            Inching,
            /// <summary>
            /// Follow the target with a constant speed. It can be faster or slower than the target's speed.
            /// If the follow speed equals or exceeds the target's speed, results just like the Normal behaviour.
            /// If the follow speed is slower than the target's speed, the camera will
            /// be clamped within a given distance from the target aka max distance.
            /// </summary>            
            Slow,
            /// <summary>
            /// Follow the target with predictive behaviour.
            /// It predicts the target's movement based on its last position.
            /// And moves the camera towards the predicted position which 
            /// determined by predict distance with a constant speed.
            /// </summary>
            Predict
        }
        [Export] public BehaviourType Behaviour { get; set; } = BehaviourType.Normal;

        [ExportGroup("Inching Properties")]
        [Export]
        public float InchingDuration
        {
            get => m_inchingDuration;
            set => m_inchingDuration = value;
        }
        private float m_inchingDuration = 1.0f;
        private float m_inchingTimer = 0.0f;

        [ExportGroup("Slow Properties")]
        [Export] public float SlowFollowSpeed { get; set; } = 100.0f;
        [Export] public float SlowFollowMaxDistance { get; set; } = 100.0f;

        [ExportGroup("Predict Properties")]
        [Export] public float PredictFollowSpeed { get; set; } = 100.0f;
        [Export] public float PredictDistance { get; set; } = 100.0f;

        private Vector2 m_targetLastPos = Vector2.Zero;

        public override void _Ready()
        {
            m_inchingTimer = m_inchingDuration;
            m_targetLastPos = Vector2.Zero;
        }

        private void NormalFollow(double delta)
        {
            GlobalPosition = FollowTarget.GlobalPosition;
        }

        private void InchingFollow(double delta)
        {
            float distance = GlobalPosition.DistanceTo(FollowTarget.GlobalPosition);

            // If the target is too close, stop inching.
            if (distance < FollowClamp)
            {
                m_inchingTimer = m_inchingDuration;
                return;
            }

            m_inchingTimer -= (float)delta;

            // If the inching timer has reached 0, reset it and start inching again.
            float rate = m_inchingTimer <= 0.0f ? 1.0f : 1.0f - m_inchingTimer / m_inchingDuration;

            var _x = Mathf.Lerp(GlobalPosition.X, FollowTarget.GlobalPosition.X, rate);
            var _y = Mathf.Lerp(GlobalPosition.Y, FollowTarget.GlobalPosition.Y, rate);

            GlobalPosition = new Vector2(_x, _y);
        }

        private void SlowFollow(double delta)
        {
            float distance = GlobalPosition.DistanceTo(FollowTarget.GlobalPosition);

            // If the target is too close, stop following.
            if (distance < FollowClamp)
            {
                return;
            }

            // If the target is too far, move it to max distance position.
            if (distance > SlowFollowMaxDistance)
            {
                Vector2 distanceVec = (FollowTarget.GlobalPosition - GlobalPosition).Normalized() * SlowFollowMaxDistance;
                GlobalPosition = FollowTarget.GlobalPosition - distanceVec;
                return;
            }

            var _x = Mathf.MoveToward(GlobalPosition.X, FollowTarget.GlobalPosition.X, (float)delta * SlowFollowSpeed);
            var _y = Mathf.MoveToward(GlobalPosition.Y, FollowTarget.GlobalPosition.Y, (float)delta * SlowFollowSpeed);

            GlobalPosition = new Vector2(_x, _y);
        }

        private void PredictFollow(double delta)
        {
            // Predict the direction of the target based on its last position.
            Vector2 predictedDir = (FollowTarget.GlobalPosition - m_targetLastPos).Normalized();

            Vector2 predictedPos = FollowTarget.GlobalPosition + predictedDir * PredictDistance;

            var _x = Mathf.MoveToward(GlobalPosition.X, predictedPos.X, (float)delta * PredictFollowSpeed);
            var _y = Mathf.MoveToward(GlobalPosition.Y, predictedPos.Y, (float)delta * PredictFollowSpeed);

            GlobalPosition = new Vector2(_x, _y);

            // Record the last position of the target for the next prediction.
            m_targetLastPos = FollowTarget.GlobalPosition;
        }       

        public override void _PhysicsProcess(double delta)
        {
            // If there is no target, do nothing.
            if (FollowTarget == null) return;

            switch (Behaviour)
            {
                case BehaviourType.Normal: NormalFollow(delta); break;
                case BehaviourType.Inching: InchingFollow(delta); break;
                case BehaviourType.Slow: SlowFollow(delta); break;
                case BehaviourType.Predict: PredictFollow(delta); break;
            }
        }
    }
}

其实结构还是非常简单明了的（因为我也写不出很复杂的东西）。通过预设值决定摄像机的具体行为逻辑，就是这么简单。

哦对了，Godot的2D和3D的区别跟Unity不一样，Unity的2D是伪2D，而Godot的2D是真2D，

所以2D跟3D之间的沟壑可能比Unity大。所以我先做了2D的相机。

这个的操作方式应该跟Unity的差不多，就是调整数值还有选模式。主要这些模式都是我硬编的，其实我也不知道应该怎么为这些模式命名：

1.Normal，普通行为，就一直跟着，其实就是复制位置。

2.Inching，我管它叫缓动，从代码可以看出，这玩意跟时间有关，设计之初是想实现“在规定时间结束时，镜头恰好到达物体位置”，结构因为插值插的太快了，所以只能看出一点点效果，所以之后应该会大改或者直接砍掉；

3.Slow，慢跟随。其实也可以快，通过控制跟随速度营造出“镜头和物体相对运动的效果”。

实际上镜头跟随太慢会被限制在一个距离内，从而避免物体跑太快了以至于跑出镜头外。

// If the target is too far, move it to max distance position.

if (distance > SlowFollowMaxDistance)

{

Vector2 distanceVec = (FollowTarget.GlobalPosition - GlobalPosition).Normalized() * SlowFollowMaxDistance;

GlobalPosition = FollowTarget.GlobalPosition - distanceVec;

return;

}

限制手段就是这个：当相对距离超过限定距离时，根据等式关系减去偏移量。

为什么要单独拿出来记录呢？因为我之前写那个Untiy卡牌拖拽模型的时候，就是遇到了这种“锁定偏移量”的类似问题，当时还强调了一下，结果现在做开发的时候又又又错了。