示例#1
0
        /// <summary>
        /// Get the two clips that need to be mixed together for the current frame.
        /// </summary>
        /// <param name="playable">The track's playable.</param>
        /// <param name="clipIndexA">The output index for the first clip. Use with
        /// TimelineTools.GetPlayableBehaviour to get the corresponding clip.</param>
        /// <param name="clipIndexB">The output index for the second clip. Use with
        /// TimelineTools.GetPlayableBehaviour to get the corresponding clip.</param>
        public static void FindClipsToMix(Playable playable, out int clipIndexA, out int clipIndexB)
        {
            for (int i = 0; i < playable.GetInputCount(); i++)
            {
                float weight = playable.GetInputWeight(i);

                if (weight > 0 && weight < 1f)
                {
                    clipIndexA = i;
                    clipIndexB = i + 1;
                    return;
                }
            }

            clipIndexA = -1;
            clipIndexB = -1;
        }
示例#2
0
    public override void ProcessFrame(Playable playable, FrameData info, object playerData)
    {
        int inputCount = playable.GetInputCount();

        for (int i = 0; i < inputCount; i++)
        {
            var playableInput          = (ScriptPlayable <PostProcessBehaviour>)playable.GetInput(i);
            PostProcessBehaviour input = playableInput.GetBehaviour();
            float inputWeight          = playable.GetInputWeight(i);
            if (Mathf.Approximately(inputWeight, 0f))
            {
                continue;
            }
            float normalizedTime = (float)(playableInput.GetTime() / playableInput.GetDuration());
            input.ChangeWeight(normalizedTime);
        }
    }
 public override void ProcessFrame(Playable playable, FrameData info, object playerData)
 {
     if (!(this.boundGameObject == null))
     {
         int  inputCount = playable.GetInputCount <Playable>();
         bool active     = false;
         for (int i = 0; i < inputCount; i++)
         {
             if (playable.GetInputWeight(i) > 0f)
             {
                 active = true;
                 break;
             }
         }
         this.boundGameObject.SetActive(active);
     }
 }
    public override void ProcessFrame(Playable playable, FrameData info, object playerData)
    {
        m_TrackBinding = playerData as Text;

        if (m_TrackBinding == null)
        {
            return;
        }

        if (!m_FirstFrameHappened)
        {
            m_DefaultText        = m_TrackBinding.text;
            m_FirstFrameHappened = true;
        }

        int inputCount = playable.GetInputCount();

        float totalWeight    = 0f;
        float greatestWeight = 0f;
        int   currentInputs  = 0;

        for (int i = 0; i < inputCount; i++)
        {
            float inputWeight = playable.GetInputWeight(i);
            ScriptPlayable <TextSwitcherBehaviour> inputPlayable = (ScriptPlayable <TextSwitcherBehaviour>)playable.GetInput(i);
            TextSwitcherBehaviour input = inputPlayable.GetBehaviour();

            totalWeight += inputWeight;

            if (inputWeight > greatestWeight)
            {
                m_TrackBinding.text = input.text;
                greatestWeight      = inputWeight;
            }

            if (!Mathf.Approximately(inputWeight, 0f))
            {
                currentInputs++;
            }
        }

        if (currentInputs != 1 && 1f - totalWeight > greatestWeight)
        {
            m_TrackBinding.text = m_DefaultText;
        }
    }
        // NOTE: This function is called at runtime and edit time.  Keep that in mind when setting the values of properties.
        public override void ProcessFrame(Playable playable, FrameData info, object playerData)
        {
            GameObject trackBinding = playerData as GameObject;

            if (!trackBinding)
            {
                return;
            }

            int inputCount = playable.GetInputCount();

            for (int i = 0; i < inputCount; i++)
            {
                float inputWeight = playable.GetInputWeight(i);
                if (inputWeight > 0.001f && !played.Contains(i))
                {
                    played.Add(i);
                    ScriptPlayable <BarkBehaviour> inputPlayable = (ScriptPlayable <BarkBehaviour>)playable.GetInput(i);
                    BarkBehaviour input = inputPlayable.GetBehaviour();
                    if (Application.isPlaying)
                    {
                        if (input.useConversation)
                        {
                            DialogueManager.Bark(input.conversation, trackBinding.transform, input.listener);
                        }
                        else
                        {
                            DialogueManager.BarkString(input.text, trackBinding.transform, input.listener);
                        }
                    }
                    else
                    {
                        var message = DialogueActor.GetActorName(trackBinding.transform) + " bark: " + input.GetEditorBarkText();
                        if (input.useConversation)
                        {
                            message += " (may vary)";
                        }
                        PreviewUI.ShowMessage(message, 2, 1);
                    }
                }
                else if (inputWeight <= 0.001f && played.Contains(i))
                {
                    played.Remove(i);
                }
            }
        }
示例#6
0
    public override void ProcessFrame(Playable playable, FrameData info, object playerData)
    {
        this.m_TrackBinding = (playerData as Text);
        if (this.m_TrackBinding == null)
        {
            return;
        }
        if (!this.m_FirstFrameHappened)
        {
            this.m_DefaultColor       = this.m_TrackBinding.color;
            this.m_DefaultFontSize    = this.m_TrackBinding.fontSize;
            this.m_DefaultText        = this.m_TrackBinding.text;
            this.m_FirstFrameHappened = true;
        }
        int   inputCount = playable.GetInputCount <Playable>();
        Color a          = Color.clear;
        float num        = 0f;
        float num2       = 0f;
        float num3       = 0f;
        int   num4       = 0;

        for (int i = 0; i < inputCount; i++)
        {
            float inputWeight = playable.GetInputWeight(i);
            TextSwitcherBehaviour behaviour = ((ScriptPlayable <T>)playable.GetInput(i)).GetBehaviour();
            a    += behaviour.color * inputWeight;
            num  += (float)behaviour.fontSize * inputWeight;
            num2 += inputWeight;
            if (inputWeight > num3)
            {
                this.m_TrackBinding.text = behaviour.text;
                num3 = inputWeight;
            }
            if (!Mathf.Approximately(inputWeight, 0f))
            {
                num4++;
            }
        }
        this.m_TrackBinding.color    = a + this.m_DefaultColor * (1f - num2);
        this.m_TrackBinding.fontSize = Mathf.RoundToInt(num + (float)this.m_DefaultFontSize * (1f - num2));
        if (num4 != 1 && 1f - num2 > num3)
        {
            this.m_TrackBinding.text = this.m_DefaultText;
        }
    }
        public override void ProcessFrame(Playable playable, FrameData info, object playerData)
        {
            Color finalColor = Color.black;

            int inputCount = playable.GetInputCount();

            for (int i = 0; i < inputCount; i++)
            {
                float inputWeight = playable.GetInputWeight(i);
                ScriptPlayable <AmbientLightControlBehaviour> inputPlayable = (ScriptPlayable <AmbientLightControlBehaviour>)playable.GetInput(i);
                AmbientLightControlBehaviour input = inputPlayable.GetBehaviour();

                // Use the above variables to process each frame of this playable.
                finalColor += input.color * inputWeight;
            }

            RenderSettings.ambientLight = finalColor;
        }
示例#8
0
        public override void PrepareFrame(Playable playable, FrameData info)
        {
            int inputCount = playable.GetInputCount();

            for (int i = 0; i < inputCount; i++)
            {
                float inputWeight = playable.GetInputWeight(i);
                ScriptPlayable <GfxAnimatorBehaviour> inputPlayable = (ScriptPlayable <GfxAnimatorBehaviour>)playable.GetInput(i);
                GfxAnimatorBehaviour input = inputPlayable.GetBehaviour();

                if (inputWeight == 1.0f && animationName != input.animationName)
                {
                    animationName = input.animationName;
                }
            }

            base.PrepareFrame(playable, info);
        }
 private void SyncWeight(float weight)
 {
     if (director.playableGraph.IsValid())
     {
         int rootPlayableCount = director.playableGraph.GetRootPlayableCount();
         for (int i = 0; i < rootPlayableCount; i++)
         {
             Playable rootPlayable = director.playableGraph.GetRootPlayable(i);
             if (rootPlayable.IsValid() && rootPlayable.CanSetWeights())
             {
                 for (int j = 0; j < rootPlayable.GetInputCount(); j++)
                 {
                     rootPlayable.SetInputWeight(j, weight);
                 }
             }
         }
     }
 }
示例#10
0
        //============================================================================================
        /**
        *  @brief Recursive function which destroys a playable and any child playables
        *         
        *********************************************************************************************/
        private void ClearPlayable(ref Playable a_playable)
        {
            if (!a_playable.IsValid())
                return;

            int inputCount = a_playable.GetInputCount();

            for(int i=0; i < inputCount; ++i)
            {
                var playable = a_playable.GetInput(i);

                ClearPlayable(ref playable);

                playable.Destroy();
            }

            a_playable.Destroy();
        }
示例#11
0
//----------------------------------------------------------------------------------------------------------------------
    // Called each frame while the state is set to Play
    public override void ProcessFrame(Playable playable, FrameData info, object playerData) {
        int inputCount = playable.GetInputCount<Playable>();
        if (inputCount == 0 ) {
            return; // it doesn't work as mixer.
        }

        if (m_boundGameObject== null ) {
            return;
        }
        
        GetActiveTimelineClipInto(m_clipAssets, m_playableDirector.time, out TimelineClip clip, out T activePlayableAsset);
        if (null == clip)
            return;
        
        ProcessActiveClipV(activePlayableAsset, m_playableDirector.time, clip);
        m_boundGameObject.SetActive(true);
        
    }
示例#12
0
    //Happens in Play mode
    //Uses the NavMeshAgent to control the units, delegating their movement and animations to the AI
    private void ProcessPlayModeFrame(Playable playable)
    {
        int inputCount = playable.GetInputCount();

        for (int i = 0; i < inputCount; i++)
        {
            float inputWeight = playable.GetInputWeight(i);
            if (inputWeight > 0f)
            {
                ScriptPlayable <EnemyControlBehaviour> inputPlayable;
                inputPlayable = (ScriptPlayable <EnemyControlBehaviour>)playable.GetInput(i);
                EnemyControlBehaviour input = inputPlayable.GetBehaviour();

                NavMeshAgent agent = enemy.GetComponent <NavMeshAgent>();
                agent.SetDestination(input.targetPosition);
            }
        }
    }
示例#13
0
    public override void ProcessFrame(Playable playable, FrameData info, object playerData)
    {
        m_TrackBinding = playerData as Image;

        if (m_TrackBinding == null)
        {
            return;
        }

        if (!m_FirstFrameHappened)
        {
            m_DefaultColor       = m_TrackBinding.color;
            m_FirstFrameHappened = true;
        }

        int inputCount = playable.GetInputCount();

        Color blendedColor   = Color.clear;
        float totalWeight    = 0f;
        float greatestWeight = 0f;
        int   currentInputs  = 0;

        for (int i = 0; i < inputCount; i++)
        {
            float inputWeight = playable.GetInputWeight(i);
            ScriptPlayable <FadeInImageBehaviour> inputPlayable = (ScriptPlayable <FadeInImageBehaviour>)playable.GetInput(i);
            FadeInImageBehaviour input = inputPlayable.GetBehaviour();

            blendedColor += input.color * inputWeight;
            totalWeight  += inputWeight;

            if (inputWeight > greatestWeight)
            {
                greatestWeight = inputWeight;
            }

            if (!Mathf.Approximately(inputWeight, 0f))
            {
                currentInputs++;
            }
        }

        m_TrackBinding.color = blendedColor + m_DefaultColor * (1f - totalWeight);
    }
    // NOTE: This function is called at runtime and edit time.  Keep that in mind when setting the values of properties.
    public override void ProcessFrame(Playable playable, FrameData info, object playerData)
    {
        var trackBinding  = playerData as BattleCharacterBehaviour;
        var finalPosition = Vector3.zero;

        if (!trackBinding)
        {
            return;
        }

        int inputCount = playable.GetInputCount(); //get the number of all clips on this track

        BattleTransformBehaviour input = null;

        for (int i = 0; i < inputCount; i++)
        {
            float inputWeight = playable.GetInputWeight(i);
            if (inputWeight == 0)
            {
                continue;
            }
            ScriptPlayable <BattleTransformBehaviour> inputPlayable = (ScriptPlayable <BattleTransformBehaviour>)playable.GetInput(i);
            input = inputPlayable.GetBehaviour();

            var position = ResolveRelativeVector(input.position, input.relative, trackBinding, input.targetIndex);

            // Use the above variables to process each frame of this playable.
            finalPosition += position * inputWeight;
        }

        //assign the result to the bound object
        trackBinding.transform.position = finalPosition;
        if (input != null)
        {
            if (input.flip)
            {
                trackBinding.transform.eulerAngles = trackBinding.FormationPosition.x < 0 ? new Vector3(0, -90, 0) : new Vector3(0, 90, 0);
            }
            else
            {
                trackBinding.transform.eulerAngles = trackBinding.FormationPosition.x < 0 ? new Vector3(0, 90, 0) : new Vector3(0, -90, 0);
            }
        }
    }
示例#15
0
        public override void ProcessFrame(Playable playable, FrameData info, object playerData)
        {
            base.ProcessFrame(playable, info, playerData);

            if (MainCamera == null)
            {
                return;
            }

            int       activeInputs   = 0;
            ClipInfo  clipA          = new ClipInfo();
            ClipInfo  clipB          = new ClipInfo();
            Texture2D overlayTexture = null;

            for (int i = 0; i < playable.GetInputCount(); ++i)
            {
                float weight = playable.GetInputWeight(i);
                ScriptPlayable <CameraFadePlayableBehaviour> clip = (ScriptPlayable <CameraFadePlayableBehaviour>)playable.GetInput(i);

                CameraFadePlayableBehaviour shot = clip.GetBehaviour();
                if (shot != null &&
                    shot.IsValid &&
                    playable.GetPlayState() == PlayState.Playing &&
                    weight > 0.0001f)
                {
                    clipA = clipB;

                    clipB.weight         = weight;
                    clipB.localTime      = clip.GetTime();
                    clipB.duration       = clip.GetDuration();
                    clipB.overlayTexture = shot.overlayTexture;

                    if (++activeInputs == 2)
                    {
                        break;
                    }
                }
            }

            overlayTexture = (clipB.overlayTexture != null) ? clipB.overlayTexture : clipA.overlayTexture;
            float _weight = clipB.weight;

            MainCamera.SetTimelineFadeOverride(overlayTexture, _weight);
        }
        public override void ProcessFrame(Playable playable, FrameData info, object playerData)
        {
            Transform binding = playerData as Transform;

            if (binding == null)
            {
                return;
            }

            int inputCount = playable.GetInputCount();

            if (inputCount == 0)
            {
                return;
            }

            float   totalWeight     = 0;
            Vector3 lookAtDirection = new Vector3();

            for (int i = 0; i < inputCount; i++)
            {
                var inputPlayable  = (ScriptPlayable <EZTransformConstraintBehaviour>)playable.GetInput(i);
                var inputBehaviour = inputPlayable.GetBehaviour();
                if (inputBehaviour.target == null || inputBehaviour.target.position == binding.position)
                {
                    continue;
                }

                float inputWeight = playable.GetInputWeight(i);
                if (inputWeight == 0)
                {
                    continue;
                }

                totalWeight += inputWeight;

                lookAtDirection += (inputBehaviour.target.position - binding.position).normalized * inputWeight;
            }
            if (totalWeight < 1e-5)
            {
                return;
            }
            binding.rotation = Quaternion.LookRotation(lookAtDirection, binding.up);
        }
        public override void ProcessFrame(Playable playable, FrameData info, object playerData)
        {
            if (transform == null)
            {
                return;
            }

            int inputCount = playable.GetInputCount();

            float scaleTotalWeight = 0f;

            Vector3 blendedPosition = Vector3.zero;
            Vector3 blendedRotation = Vector3.zero;
            Vector3 blendedScale    = Vector3.zero;

            for (int i = 0; i < inputCount; i++)
            {
                var            playableInput = (ScriptPlayable <TweenBehaviour>)playable.GetInput(i);
                TweenBehaviour input         = playableInput.GetBehaviour();

                float inputWeight = playable.GetInputWeight(i);

                double duration        = playableInput.GetDuration();
                float  inverseDuration = 1f / (float)duration;

                float normalisedTime      = (float)(playableInput.GetTime() * inverseDuration);
                float tweenPosProgress    = input.position.currentCurve.Evaluate(normalisedTime);
                float tweenRotateProgress = input.rotation.currentCurve.Evaluate(normalisedTime);
                float tweenScaleProgress  = input.scale.currentCurve.Evaluate(normalisedTime);

                scaleTotalWeight += inputWeight;
                blendedPosition  += Vector3.Lerp(input.position.startOffSet, input.position.endOffSet, tweenPosProgress) * inputWeight;

                blendedRotation += Vector3.Lerp(input.rotation.startOffSet, input.rotation.endOffSet, tweenRotateProgress) * inputWeight;

                blendedScale += Vector3.Lerp(input.scale.startOffSet, input.scale.endOffSet, tweenScaleProgress) * inputWeight;
            }

            transform.localPosition = defaultPosition + blendedPosition;

            transform.rotation = defaultRotation * Quaternion.Euler(blendedRotation);

            transform.localScale = defaultScale + blendedScale;
        }
        public override void ProcessFrame(Playable playable, FrameData info, object playerData)
        {
            var trackBinding = playerData as LaserPerformance;

            if (!trackBinding)
            {
                return;
            }

            var clipTime = Director.time;
            var gradient = new Gradient();

            for (var i = 0; i < playable.GetInputCount(); i++)
            {
                var inputWeight    = playable.GetInputWeight(i);
                var inputPlayable  = (ScriptPlayable <LaserPerformanceBehaviour>)playable.GetInput(i);
                var inputBehaviour = inputPlayable.GetBehaviour();

                if (inputWeight > 0.5f)
                {
                    trackBinding.ChangeState(inputBehaviour.color, inputBehaviour.dimmer, inputBehaviour.motion);

                    trackBinding.IntensityMultiplier = inputBehaviour.intensityMultiplier;

                    trackBinding.Speed          = inputBehaviour.speed;
                    trackBinding.OffsetStrength = inputBehaviour.offsetStrength;

                    trackBinding.panRange  = new Range(inputBehaviour.panRange.min, inputBehaviour.panRange.max);
                    trackBinding.tiltRange = new Range(inputBehaviour.tiltRange.min, inputBehaviour.tiltRange.max);

                    var clip = Clips[i];
                    clipTime = Director.time - clip.start;
                }

                if (inputWeight > 0)
                {
                    gradient = GradientExtensions.Lerp(gradient, inputBehaviour.laserGradient, inputWeight);
                }
            }

            trackBinding.LaserGradient = gradient;

            trackBinding.ProcessFrame(Director.time, clipTime);
        }
示例#19
0
    public override void ProcessFrame(Playable playable, FrameData info, object playerData)
    {
        if (trackBindingImage == null)
        {
            trackBindingImage = playerData as Image;
            initialAlphaValue = trackBindingImage.color.a;
        }
        int   inputCount = playable.GetInputCount();
        float alpha      = 0f;

        for (int i = 0; i < inputCount; ++i)
        {
            float inputWeight = playable.GetInputWeight(i);
            ScriptPlayable <ImageAlphaBehaviour> inputPlayable = (ScriptPlayable <ImageAlphaBehaviour>)playable.GetInput(i);
            ImageAlphaBehaviour input = inputPlayable.GetBehaviour();
            alpha += input.Alpha * inputWeight;
        }
        trackBindingImage.color = new Color(trackBindingImage.color.r, trackBindingImage.color.g, trackBindingImage.color.b, alpha);
    }
示例#20
0
    // Called each frame while the state is set to Play
    public override void ProcessFrame(Playable playable, FrameData info, object playerData)
    {
        Debug.Log("MoveMixer.PrepareFrame");

        int inputCount = playable.GetInputCount();

        if (inputCount > 0)
        {
            GameObject role = playerData as GameObject;

            float inputWeight = playable.GetInputWeight(0);
            ScriptPlayable <PosBehaviour> inputPlayable = (ScriptPlayable <PosBehaviour>)playable.GetInput(0);
            PosBehaviour input = inputPlayable.GetBehaviour();

            Vector3 blendedPosition = input.result;

            role.transform.position = blendedPosition;
        }
    }
示例#21
0
    public void Initialize(AnimationClip[] clipsToPlay, Playable owner, PlayableGraph graph)

    {
        owner.SetInputCount(1);

        mixer = AnimationMixerPlayable.Create(graph, clipsToPlay.Length);

        graph.Connect(mixer, 0, owner, 0);

        owner.SetInputWeight(0, 1);

        for (int clipIndex = 0; clipIndex < mixer.GetInputCount(); ++clipIndex)

        {
            graph.Connect(AnimationClipPlayable.Create(graph, clipsToPlay[clipIndex]), 0, mixer, clipIndex);

            mixer.SetInputWeight(clipIndex, 1.0f);
        }
    }
示例#22
0
    public override void ProcessFrame(Playable playable, FrameData info, object playerData)
    {
        m_TrackBinding = playerData as UITweener;

        if (m_TrackBinding == null)
        {
            return;
        }

        if (!m_FirstFrameHappened)
        {
            m_FirstFrameHappened = true;
        }

        int inputCount = playable.GetInputCount();

        float totalWeight   = 0f;
        int   currentInputs = 0;

        blendedFactor = 0;
        for (int i = 0; i < inputCount; i++)
        {
            float inputWeight = playable.GetInputWeight(i);
            ScriptPlayable <TweenerBehaviour> inputPlayable = (ScriptPlayable <TweenerBehaviour>)playable.GetInput(i);
            TweenerBehaviour input = inputPlayable.GetBehaviour();

            float normalisedTime = (float)(inputPlayable.GetTime() * input.inverseDuration);
            //Debug.Log(inputWeight);
            blendedFactor += normalisedTime;// * inputWeight;

            totalWeight += inputWeight;

            if (!Mathf.Approximately(inputWeight, 0f))
            {
                currentInputs++;
            }
        }

        blendedFactor += defaultFactor * (1f - totalWeight);

        m_TrackBinding.ProgressNormalized = blendedFactor;
        m_TrackBinding.Animate();
    }
示例#23
0
        public override void PrepareFrame(Playable playable, FrameData info)
        {
            Reset();

            var inputCount = playable.GetInputCount();
            var weightSum  = 0f;

            if (NormalizeInputs)
            {
                for (var i = 0; i < inputCount; i++)
                {
                    if (GetIkFromInput(playable, i).IsValid())
                    {
                        weightSum += playable.GetInputWeight(i);
                    }
                }
            }
            else
            {
                weightSum = 1;
            }

            if (weightSum > 0)
            {
                for (var i = 0; i < inputCount; i++)
                {
                    var weight = playable.GetInputWeight(i);

                    if (weight > 0)
                    {
                        var ikPlayable = GetIkFromInput(playable, i);

                        if (ikPlayable.IsValid())
                        {
                            var behavior = ikPlayable.GetBehaviour();
                            // TODO: Need to investigate, how to prepare frames in input before evaluating mixer
                            behavior.PrepareFrame(ikPlayable, info);
                            Add(behavior, weight / weightSum);
                        }
                    }
                }
            }
        }
示例#24
0
        protected override float Mix(Playable playable, FrameData info, WetDecal trackBinding)
        {
            var inputCount = playable.GetInputCount();

            var totalWeight       = 0f;
            var blendedSaturation = 0f;

            for (var i = 0; i < inputCount; i++)
            {
                var inputWeight   = playable.GetInputWeight(i);
                var inputPlayable = (ScriptPlayable <Data>)playable.GetInput(i);
                var input         = inputPlayable.GetBehaviour();

                blendedSaturation += input.Saturation * inputWeight;
                totalWeight       += inputWeight;
            }

            return(blendedSaturation + Default * (1f - totalWeight));
        }
示例#25
0
        public override void ProcessFrame(Playable playable, FrameData info, object playerData)
        {
            Transform binding = playerData as Transform;

            if (binding == null)
            {
                return;
            }

            int inputCount = playable.GetInputCount();

            if (inputCount == 0)
            {
                return;
            }

            float   totalWeight = 0;
            Vector3 outputScale = new Vector3();

            for (int i = 0; i < inputCount; i++)
            {
                var inputPlayable  = (ScriptPlayable <EZTransformConstraintBehaviour>)playable.GetInput(i);
                var inputBehaviour = inputPlayable.GetBehaviour();
                if (inputBehaviour.target == null)
                {
                    continue;
                }

                float inputWeight = playable.GetInputWeight(i);
                if (inputWeight == 0)
                {
                    continue;
                }

                totalWeight += inputWeight;
                outputScale += inputBehaviour.target.localScale * inputWeight;
            }
            if (totalWeight < 1e-5)
            {
                return;
            }
            binding.localScale = outputScale / totalWeight;
        }
示例#26
0
    // NOTE: This function is called at runtime and edit time.  Keep that in mind when setting the values of properties.
    public override void ProcessFrame(Playable playable, FrameData info, object playerData)
    {
        ActorManager trackBinding = playerData as ActorManager;

        if (!trackBinding)
            return;

        int inputCount = playable.GetInputCount ();

        for (int i = 0; i < inputCount; i++)
        {
            float inputWeight = playable.GetInputWeight(i);
            ScriptPlayable<CustomStabBehaviour> inputPlayable = (ScriptPlayable<CustomStabBehaviour>)playable.GetInput(i);
            CustomStabBehaviour input = inputPlayable.GetBehaviour ();
            
            // Use the above variables to process each frame of this playable.
            
        }
    }
    private List <Node> GetInputsFromPlayableNode(Playable h)
    {
        var inputs = new List <Node>();

        if (h.IsValid())
        {
            for (int port = 0; port < h.GetInputCount(); ++port)
            {
                Playable playable = h.GetInput(port);
                if (playable.IsValid())
                {
                    float weight = h.GetInputWeight(port);
                    Node  node   = CreateNodeFromPlayable(playable, weight);
                    inputs.Add(node);
                }
            }
        }
        return(inputs);
    }
        public override void ProcessFrame(Playable playable, FrameData info, object playerData)
        {
            Transform binding = playerData as Transform;

            if (binding == null)
            {
                return;
            }

            int inputCount = playable.GetInputCount();

            if (inputCount == 0)
            {
                return;
            }

            float      totalWeight    = 0;
            Quaternion outputRotation = new Quaternion();

            for (int i = 0; i < inputCount; i++)
            {
                var inputPlayable  = (ScriptPlayable <EZTransformConstraintBehaviour>)playable.GetInput(i);
                var inputBehaviour = inputPlayable.GetBehaviour();
                if (inputBehaviour.target == null)
                {
                    continue;
                }

                float inputWeight = playable.GetInputWeight(i);
                if (inputWeight == 0)
                {
                    continue;
                }

                totalWeight   += inputWeight;
                outputRotation = QuaternionExt.Cumulate(outputRotation, inputBehaviour.target.rotation.Scale(inputWeight));
            }
            if (totalWeight < 1e-5)
            {
                return;
            }
            binding.rotation = outputRotation;
        }
        public override void ProcessFrame(Playable playable, FrameData info, object playerData)
        {
            Renderer renderer = playerData as Renderer;

            if (renderer == null)
            {
                return;
            }

            if (lastRenderer != null &&
                (lastRenderer != renderer || lastIndex != materialIndex || lastPropertyName != propertyName))
            {
                lastRenderer.SetPropertyBlock(null, lastIndex);
            }
            lastRenderer     = renderer;
            lastIndex        = materialIndex;
            lastPropertyName = propertyName;
            if (propertyName == null)
            {
                return;
            }

            int inputCount = playable.GetInputCount();

            float   totalWeight = 0;
            Vector4 outputValue = Vector4.zero;

            for (int i = 0; i < inputCount; i++)
            {
                var inputPlayable  = (ScriptPlayable <EZMaterialVectorPlayableBehaviour>)playable.GetInput(i);
                var inputBehaviour = inputPlayable.GetBehaviour();

                float inputWeight = playable.GetInputWeight(i);
                totalWeight += inputWeight;

                outputValue += inputBehaviour.value * inputWeight;
            }

            renderer.GetPropertyBlock(propertyBlock, materialIndex);
            outputValue = Vector4.Lerp(value, outputValue, totalWeight);
            propertyBlock.SetVector(propertyName, outputValue);
            renderer.SetPropertyBlock(propertyBlock, materialIndex);
        }
    public override void ProcessFrame(Playable playable, FrameData info, object playerData)
    {
        int inputCount = playable.GetInputCount();

        for (int i = 0; i < inputCount; i++)
        {
            float inputWeight = playable.GetInputWeight(i);

            if (!Mathf.Approximately(inputWeight, 1f))
            {
                continue;
            }

            ScriptPlayable <CutsceneScriptControlBehaviour> inputPlayable = (ScriptPlayable <CutsceneScriptControlBehaviour>)playable.GetInput(i);
            CutsceneScriptControlBehaviour input = inputPlayable.GetBehaviour();

            input.playerInput.enabled = input.playerInputEnabled;
        }
    }