CinemachineのDolly Pathで１回転させたいが、Pathがねじれる

Question

お世話になっております。

現在、Cinemachine 2.2.9 を利用してDolly CartおよびDolly Pathを使ったカメラ移動を実現しようとしています。
通常の移動ならば問題なくパスを設定した通りに動いてくれるのですが、これらのパスが角度が一定以上だと表と裏がねじれてしまいます。

Cinemachine Smooth Path にて反対のCの字のようなパスを作ろうとすると、1のところでパスがねじれてしまいます。（パスがX字に交差してねじれているのが分かる）

Rollの値を変更してみましたが、この値とこのねじれとは関係がなさそうでRollで与えた回転とは別にこのねじれが発生します。

理想としては下記のようにねじれないでパスが設定できることなのですが、これを実現するにはどのようにすれば良いでしょうか？（下記画像は、画像を加工したイメージ図となります）

#環境
Unity 2018.4.2f1 LTS
Cinemachine 2.2.9

Answer 1

設定をいじるだけでは無理かもしれません。どうやらパス上で姿勢を求める際に上方向をパスオブジェクトの上方向に決め打ちしているようで、ご質問者さんのように宙返り経路を作ろうとすると進行方向が垂直方向をまたぐタイミングで姿勢の飛びが起こってしまうようです。
このねじれはご提示いただいた図のように急激に発生するのに対し、Rollによるねじりはウェイポイント間でなめらかに起こるため、Rollの調整によってこの急激なねじれをほどこうとしてもうまくいかなかったものと思われます。

この上方向問題をどうしたものかと考えた結果、下記のようなスクリプトを作成して、ドリートラック（デフォルトの名前は「DollyTrack1」でしょうか）のCinemachineSmoothPathを削除し、代わりにこちらをアタッチすることにしました。
なお、これによってドリーカート（デフォルトの名前は「DollyCart1」でしょうか）側のパスへの参照が切れるでしょうから、あらためてセットしなおしてやる必要があるかと思います。

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

[AddComponentMenu("Cinemachine/CinemachineVerticalLoopPath")]
[SaveDuringPlay]
public class CinemachineVerticalLoopPath : CinemachineSmoothPath
{
    private readonly List<Vector3> waypointPositions = new List<Vector3>();
    private readonly List<Quaternion> waypointRotations = new List<Quaternion>();

    public override Quaternion EvaluateOrientation(float pos)
    {
        // まずは本来のEvaluateOrientationと同じように処理していく
        var pathRotation = this.transform.rotation;
        if (this.m_Waypoints.Length <= 0)
        {
            return pathRotation;
        }
        var worldForward = this.EvaluateTangent(pos);
        if (worldForward.AlmostZero())
        {
            return pathRotation;
        }

        // そして本来のEvaluateOrientationと同様にLookRotationによる回転を求める
        var worldUp = pathRotation * Vector3.up;
        var baseLookRotation = Quaternion.LookRotation(worldForward, worldUp);

        // ここで、本来のEvaluateOrientationを実行して回転を得ておき...
        var baseRotation = base.EvaluateOrientation(pos);

        // そこからロール成分を抽出する
        var rollRotation = Quaternion.Inverse(baseLookRotation) * baseRotation;

        // 次に、現在のセグメントの両端のインデックスを得て...
        var t = this.GetBoundingIndices(pos, out var indexA, out var indexB) % 1.0f;

        // 各ウェイポイントでの姿勢を更新したのち、セグメント両端の回転を混合し...
        this.UpdateWaypointRotations();
        var rotation = pathRotation * Quaternion.Slerp(this.waypointRotations[indexA], this.waypointRotations[indexB], t);

        // その回転が指す上方向をを使ってLookRotationによる回転を求め、
        // それをロール成分と組み合わせて返す
        return Quaternion.LookRotation(worldForward, rotation * Vector3.up) * rollRotation;
    }

    // 各ウェイポイントにおける回転を求めるためのメソッドを用意する
    private void UpdateWaypointRotations()
    {
        var waypointCount = this.m_Waypoints.Length;
        var waypointCacheCount = this.waypointPositions.Count;
        var needsUpdate = waypointCount > waypointCacheCount;
        if (needsUpdate)
        {
            var waypointCountToAdd = waypointCount - waypointCacheCount;
            for (var i = 0; i < waypointCountToAdd; i++)
            {
                this.waypointPositions.Add(new Vector3());
                this.waypointRotations.Add(new Quaternion());
            }
        }
        else
        {
            for (var i = 0; i < waypointCount; i++)
            {
                if (this.m_Waypoints[i].position != this.waypointPositions[i])
                {
                    needsUpdate = true;
                    break;
                }
            }
        }

        if (waypointCount < waypointCacheCount)
        {
            var elementCountToRemove = waypointCacheCount - waypointCount;
            this.waypointPositions.RemoveRange(waypointCount, elementCountToRemove);
            this.waypointRotations.RemoveRange(waypointCount, elementCountToRemove);
        }

        if ((waypointCount == 0) || !needsUpdate)
        {
            return;
        }

        // 最初のウェイポイントは本来のCinemachineSmoothPathと同様に
        // Vector3.upを上方向とした回転を採用し...
        var inversePathRotation = Quaternion.Inverse(this.transform.rotation);
        var previousTangent = inversePathRotation * this.EvaluateTangent(0);
        this.waypointPositions[0] = this.m_Waypoints[0].position;
        this.waypointRotations[0] = Quaternion.LookRotation(previousTangent, Vector3.up);
        for (var i = 1; i < waypointCount; i++)
        {
            // 以降のウェイポイントは一つ前のウェイポイントの回転に対して
            // 前方向の変化から求めた差分回転を合成した回転を採用する
            var tangent = inversePathRotation * this.EvaluateTangent(i);
            this.waypointPositions[i] = this.m_Waypoints[i].position;
            this.waypointRotations[i] = Quaternion.FromToRotation(previousTangent, tangent) * this.waypointRotations[i - 1];
            previousTangent = tangent;
        }
    }

    // CinemachineSmoothPathのGetBoundingIndicesをそのまま持ってくる
    private float GetBoundingIndices(float pos, out int indexA, out int indexB)
    {
        pos = this.StandardizePos(pos);
        var numWaypoints = this.m_Waypoints.Length;
        if (numWaypoints < 2)
        {
            indexA = indexB = 0;
        }
        else
        {
            indexA = Mathf.FloorToInt(pos);
            if (indexA >= numWaypoints)
            {
                pos -= this.MaxPos;
                indexA = 0;
            }

            indexB = indexA + 1;
            if (indexB == numWaypoints)
            {
                if (this.Looped)
                {
                    indexB = 0;
                }
                else
                {
                    --indexB;
                    --indexA;
                }
            }
        }

        return pos;
    }
}

また、これだけだとインスペクター上でウェイポイントエディタが使えなくなってしまうようです。残念ながらCinemachineSmoothPathEditorは派生不許可のようなので、下記のようにCinemachineSmoothPathEditorを丸写ししたものをEditorフォルダに入れておくことにしました。
CinemachineSmoothPathEditorの属性を[CustomEditor(typeof(CinemachineVerticalLoopPath), true)]に変えて派生クラスでも使用できるようにするという手もあるかもしれませんが、これだとCinemachineのコードがパッケージから再読み込みされた際に元に戻ってしまう可能性があり、いまいちかな...と思いました。

using System.Collections.Generic;
using Cinemachine;
using Cinemachine.Editor;
using UnityEditor;
using UnityEditorInternal;
using UnityEngine;

[CustomEditor(typeof(CinemachineVerticalLoopPath))]
internal sealed class CinemachineVerticalLoopPathEditor : BaseEditor<CinemachineVerticalLoopPath>
{
    // 省略...内容はCinemachineSmoothPathEditor.csの丸写し

    // ただし最後のDrawGizmosはCinemachinePathEditor.DrawPathGizmoを使っているため
    // 丸写しのままでは動作しない
    [DrawGizmo(GizmoType.Active | GizmoType.NotInSelectionHierarchy
             | GizmoType.InSelectionHierarchy | GizmoType.Pickable, typeof(CinemachineSmoothPath))]
    private static void DrawGizmos(CinemachineSmoothPath path, GizmoType selectionType)
    {
        DrawPathGizmo(path,
            (Selection.activeGameObject == path.gameObject)
            ? path.m_Appearance.pathColor : path.m_Appearance.inactivePathColor);
    }
    
    // そこで、CinemachinePathEditor.csからDrawPathGizmoを持ってきて、こちらを使う
    private static void DrawPathGizmo(CinemachinePathBase path, Color pathColor)
    {
        // Draw the path
        var colorOld = Gizmos.color;
        Gizmos.color = pathColor;
        var step = 1f / path.m_Resolution;
        var lastPos = path.EvaluatePosition(path.MinPos);
        var lastW = (path.EvaluateOrientation(path.MinPos) * Vector3.right * path.m_Appearance.width) / 2;
        for (var t = path.MinPos + step; t <= (path.MaxPos + (step / 2)); t += step)
        {
            var p = path.EvaluatePosition(t);
            var q = path.EvaluateOrientation(t);
            var w = (q * Vector3.right * path.m_Appearance.width) / 2;
            var w2 = w * 1.2f;
            var p0 = p - w2;
            var p1 = p + w2;
            Gizmos.DrawLine(p0, p1);
            Gizmos.DrawLine(lastPos - lastW, p - w);
            Gizmos.DrawLine(lastPos + lastW, p + w);
            #if false
                // Show the normals, for debugging
                Gizmos.color = Color.red;
                Vector3 y = (q * Vector3.up) * width / 2;
                Gizmos.DrawLine(p, p + y);
                Gizmos.color = pathColor;
            #endif
            lastPos = p;
            lastW = w;
        }

        Gizmos.color = colorOld;
    }
}

ちょっと試したかぎりではレールに異常なねじれは生じなくなったように見えましたが、いかがでしょうかね?

Comments

[hogefugapiyo]

お返事が遅くなり申し訳有りません。
早速スクリプトの内容を確認しながら手元でも実装チェックを行ってみました。
ご提示いただいた画像のようにしっかりとオブジェクトの上が維持されており、ねじれることがなくなりました。

スクリプト中に詳細なコメントまで記述いただいてありがとうございます。問題の起こった原因と理由を理解し、そしてそれをどう解決しているのかがわかりやすく非常に助かりました。