static SplineCameraTrigger.SplineAnimatorTweak AddTweak(SplineAnimator target,
                                                            out SplineCameraTrigger trigger)
    {
        trigger = null;

        var sequencers = Object.FindObjectsOfType(typeof(SplineCameraSequencer)) as SplineCameraSequencer[];

        if (sequencers.Length < 1)
        {
            return(null);
        }

        var seq = sequencers[0];
        var t   = FindTweak(seq, target, out trigger);

        if (t != null)
        {
            return(t);
        }

        if (!seq.activeTrigger)
        {
            return(null);
        }
        trigger = seq.activeTrigger;

        var arr = (trigger.tweaks != null) ? new ArrayList(trigger.tweaks): new ArrayList();

        t        = new SplineCameraTrigger.SplineAnimatorTweak();
        t.target = target;
        arr.Add(t);
        trigger.tweaks = arr.ToArray(typeof(SplineCameraTrigger.SplineAnimatorTweak)) as SplineCameraTrigger.SplineAnimatorTweak[];

        return(t);
    }
    static SplineCameraTrigger.SplineAnimatorTweak FindTweak(SplineAnimator target, out SplineCameraTrigger trigger)
    {
        trigger = null;
        var sequencers = Object.FindObjectsOfType(typeof(SplineCameraSequencer)) as SplineCameraSequencer[];

        foreach (var s in sequencers)
        {
            var tweak = FindTweak(s, target, out trigger);
            if (tweak != null)
            {
                return(tweak);
            }
        }
        return(null);
    }
    public void Invalidate()
    {
        if (m_ActiveTrigger)
        {
            m_ActiveTrigger.OnCameraExit();
        }
        m_ActiveTrigger = null;
        m_Triggers      = CollectTriggers(transform);
        SortTriggers(m_Triggers);
        foreach (var trigger in m_Triggers)
        {
            trigger.UpdatePositionOnSpline();
        }
        SortTriggers(m_Triggers);
        ForceDisableCameras(m_Triggers);

        SetLightGroup(defaultLightGroup);
    }
 static SplineCameraTrigger.SplineAnimatorTweak FindTweak(SplineCameraSequencer seq, SplineAnimator target,
                                                          out SplineCameraTrigger trigger)
 {
     trigger = seq.activeTrigger;
     if (!trigger)
     {
         return(null);
     }
     if (trigger.tweaks == null)
     {
         return(null);
     }
     foreach (var tweak in trigger.tweaks)
     {
         if (tweak != null && tweak.target == target)
         {
             return(tweak);
         }
     }
     trigger = null;
     return(null);
 }
    public void Sample(int frame, float frameFraction, int frameCount, WrapMode wrapMode)
    {
        if (BulletTime.paused && !BulletTime.isEditing)
        {
            if (m_ActiveTrigger)
            {
                m_ActiveTrigger.OnCameraExit();
                m_ActiveTrigger = null;
            }
            return;
        }

        if (wrapMode == WrapMode.Loop)
        {
            frame %= frameCount;
        }
        else if (wrapMode == WrapMode.PingPong)
        {
            frame = (int)Mathf.PingPong((float)frame, (float)frameCount);
        }

        var lastTrigger = m_ActiveTrigger;

        m_ActiveTrigger = null;

        int triggerIndex = -1;

        if (wrapMode == WrapMode.Loop && triggers.Length > 0)
        {
            triggerIndex    = triggers.Length - 1;
            m_ActiveTrigger = triggers[triggerIndex];
        }

        for (int q = 0; q < triggers.Length; ++q)
        {
            if (frame >= triggers[q].splineAnimatorFrame || m_ActiveTrigger == null)
            {
                triggerIndex = q;
            }
        }

        int triggerLengthInFrames = 0;

        if (triggerIndex >= 0)
        {
            m_ActiveTrigger = triggers[triggerIndex];
            var nextTriggerIndex = (triggerIndex + 1) % triggers.Length;
            triggerLengthInFrames = triggers[nextTriggerIndex].splineAnimatorFrame - triggers[triggerIndex].splineAnimatorFrame;

            if (triggerLengthInFrames < 0)             // wrap
            {
                triggerLengthInFrames = frameCount + triggerLengthInFrames;
            }
        }


        if (lastTrigger != m_ActiveTrigger)
        {
            if (lastTrigger)
            {
                lastTrigger.OnCameraExit();
            }
            m_ActiveTrigger.OnCameraEnter();

            var lightGroup = m_ActiveTrigger.lightGroup;
            if (!lightGroup)
            {
                lightGroup = defaultLightGroup;
            }
            if (lightGroup)
            {
                BulletTime.SetActiveLightGroup(lightGroup);
            }
        }
        if (m_ActiveTrigger)
        {
            var timeInTrigger = BulletTime.MakeFrameTimeDbl(frame - m_ActiveTrigger.splineAnimatorFrame, BulletTime.frameRate, frameFraction);
            if (timeInTrigger < 0)
            {
                timeInTrigger = BulletTime.MakeFrameTimeDbl(frameCount, BulletTime.frameRate) + timeInTrigger;
            }

            double normalizedTimeInTrigger = 0;
            if (triggerLengthInFrames > 0)
            {
                normalizedTimeInTrigger = timeInTrigger / BulletTime.MakeFrameTimeDbl(triggerLengthInFrames, BulletTime.frameRate);
            }

            m_ActiveTrigger.OnCameraStay((float)timeInTrigger, Mathf.Clamp((float)normalizedTimeInTrigger, 0f, 1f));
        }

        if (BulletTime.isEditing)
        {
            var lightGroup = m_ActiveTrigger.lightGroup;
            if (!lightGroup)
            {
                lightGroup = defaultLightGroup;
            }
            if (lightGroup)
            {
                SetLightGroup(lightGroup);
            }
        }
    }