private void FindMixers(Playable parent, int port, Playable node) { if (PlayableExtensions.IsValid <Playable>(node)) { Type playableType = node.GetPlayableType(); if (playableType == typeof(AnimationMixerPlayable) || playableType == typeof(AnimationLayerMixerPlayable)) { int inputCount = PlayableExtensions.GetInputCount <Playable>(node); for (int i = 0; i < inputCount; i++) { this.FindMixers(node, i, PlayableExtensions.GetInput <Playable>(node, i)); } AnimationOutputWeightProcessor.WeightInfo item = new AnimationOutputWeightProcessor.WeightInfo { parentMixer = parent, mixer = node, port = port, modulate = (playableType == typeof(AnimationLayerMixerPlayable)) }; this.m_Mixers.Add(item); } else { int inputCount2 = PlayableExtensions.GetInputCount <Playable>(node); for (int j = 0; j < inputCount2; j++) { this.FindMixers(parent, port, PlayableExtensions.GetInput <Playable>(node, j)); } } } }
public override void PrepareFrame(Playable playable, FrameData info) { if (!(this.director == null) && this.director.get_isActiveAndEnabled() && !(this.director.get_playableAsset() == null)) { if (this.director.get_playableGraph().IsValid()) { int rootPlayableCount = this.director.get_playableGraph().GetRootPlayableCount(); for (int i = 0; i < rootPlayableCount; i++) { Playable rootPlayable = this.director.get_playableGraph().GetRootPlayable(i); if (PlayableExtensions.IsValid <Playable>(rootPlayable)) { PlayableExtensions.SetSpeed <Playable>(rootPlayable, (double)info.get_effectiveSpeed()); } } } if (info.get_evaluationType() == null) { if (Application.get_isPlaying()) { this.director.Pause(); } this.UpdateTime(playable); this.director.Evaluate(); } else if (Application.get_isPlaying()) { if (PlayableExtensions.GetTime <Playable>(playable) < this.director.get_time()) { this.UpdateTime(playable); } this.director.Play(); } } }
public override void PrepareFrame(Playable playable, FrameData info) { if (this.m_timeControl != null) { this.m_timeControl.SetTime(PlayableExtensions.GetTime <Playable>(playable)); } }
// Called when the state of the playable is set to Play public override void OnBehaviourPlay(Playable playable, FrameData info) { maxTime = (float)PlayableExtensions.GetDuration(playable); var trans = EntityMgr.GetComponentObject <Transform>(Owner); if (EntityMgr.HasComponent <JumpState>(Owner) && trans != null) { var jumpState = EntityMgr.GetComponentData <JumpState>(Owner); jumpCount = math.clamp(jumpState.JumpCount + 1, 1, GameConst.MaxJumpCount); startYPos = trans.localPosition.y; if (jumpState.JumpCount == 0) { jumpState.OriginYPos = trans.localPosition.y; jumpState.AscentHeight = 4; } else if (jumpState.JumpCount == 1) { jumpState.AscentHeight = 2.6f; } else if (jumpState.JumpCount == 2) { //第三段跳只是前进 jumpState.AscentHeight = 0; } else { } jumpState.JumpCount = jumpCount; jumpState.JumpStatus = JumpState.State.StartJump; // Debug.Log("jumpState.JumpCount : "+jumpState.JumpCount); EntityMgr.SetComponentData <JumpState>(Owner, jumpState); } Debug.Log("start jump"); // EntityMgr.SetComponentData<TimelineState>(Owner, new TimelineState{NewStatus=newState, InterruptStatus=interruptState}); }
private void Evaluate(Playable playable, FrameData frameData) { if (this.m_IntervalTree != null) { double time = PlayableExtensions.GetTime <Playable>(playable); this.m_ActiveBit = ((this.m_ActiveBit != 0) ? 0 : 1); this.m_CurrentListOfActiveClips.Clear(); this.m_IntervalTree.IntersectsWith(DiscreteTime.GetNearestTick(time), this.m_ActiveBit, ref this.m_CurrentListOfActiveClips); for (int i = 0; i < this.m_ActiveClips.Count; i++) { RuntimeElement runtimeElement = this.m_ActiveClips[i]; if (runtimeElement.intervalBit != this.m_ActiveBit) { runtimeElement.enable = false; } } for (int j = 0; j < this.m_CurrentListOfActiveClips.Count; j++) { this.m_CurrentListOfActiveClips[j].EvaluateAt(time, frameData); } this.m_ActiveClips.Clear(); this.m_ActiveClips.AddRange(this.m_CurrentListOfActiveClips); int count = this.m_EvaluateCallbacks.Count; for (int k = 0; k < count; k++) { this.m_EvaluateCallbacks[k].Evaluate(); } } }
private void Create(TimelineClip clip, Playable clipPlayable, Playable parentMixer) { this.m_Clip = clip; this.m_Playable = clipPlayable; this.m_ParentMixer = parentMixer; PlayableExtensions.SetPlayState <Playable>(clipPlayable, 0); }
public override void EvaluateAt(double localTime, FrameData frameData) { this.enable = true; float num; if (this.clip.IsPreExtrapolatedTime(localTime)) { num = this.clip.EvaluateMixIn((double)((float)this.clip.start)); } else if (this.clip.IsPostExtrapolatedTime(localTime)) { num = this.clip.EvaluateMixOut((double)((float)this.clip.end)); } else { num = this.clip.EvaluateMixIn(localTime) * this.clip.EvaluateMixOut(localTime); } if (PlayableExtensions.IsValid <Playable>(this.mixer)) { PlayableExtensions.SetInputWeight <Playable, Playable>(this.mixer, this.playable, num); } double time = this.clip.ToLocalTime(localTime); if (time.CompareTo(0.0) >= 0) { this.SetTime(time); } this.SetDuration(this.clip.extrapolatedDuration); }
/// <summary> /// Waits for the given IPlayable to be done. /// </summary> static public IEnumerator WaitToComplete <U>(this U inPlayable) where U : struct, IPlayable { while (!PlayableExtensions.IsDone(inPlayable)) { yield return(null); } }
public TwoDBlendTree(int layerId, PlayableGraph PlayableGraph, AnimationLayerMixerPlayable parentAnimationLayerMixerPlayable, TwoDAnimationInput TwoDAnimationInput) : base(layerId, parentAnimationLayerMixerPlayable) { this.TwoDAnimationInput = TwoDAnimationInput; this.TwoDBlendTreeAnimationClips = TwoDAnimationInput.TwoDBlendTreeAnimationClipInputs.ConvertAll(i => new TwoDBlendTreeAnimationClip(i.AnimationClip, i.TreePosition, i.Speed)); this.TwoDBlendTreeAnimationClipsPositions = this.TwoDBlendTreeAnimationClips.ConvertAll(c => c.TreePosition).ToArray(); this.Weights = new float[this.TwoDBlendTreeAnimationClipsPositions.Length]; //create a playable mixer this.AnimationMixerPlayable = AnimationMixerPlayable.Create(PlayableGraph); foreach (var TwoDBlendTreeAnimationClip in TwoDBlendTreeAnimationClips) { var animationClipPlayable = AnimationClipPlayable.Create(PlayableGraph, TwoDBlendTreeAnimationClip.AnimationClip); animationClipPlayable.SetApplyFootIK(false); animationClipPlayable.SetApplyPlayableIK(false); animationClipPlayable.SetSpeed(TwoDBlendTreeAnimationClip.Speed); TwoDBlendTreeAnimationClip.InputHandler = PlayableExtensions.AddInput(this.AnimationMixerPlayable, animationClipPlayable, 0); PlayableExtensions.Play(animationClipPlayable); TwoDBlendTreeAnimationClip.AnimationClipPlayable = animationClipPlayable; } this.Inputhandler = PlayableExtensions.AddInput(parentAnimationLayerMixerPlayable, this.AnimationMixerPlayable, 0); if (TwoDAnimationInput.AvatarMask != null) { parentAnimationLayerMixerPlayable.SetLayerMaskFromAvatarMask((uint)this.Inputhandler, TwoDAnimationInput.AvatarMask); } }
public override void EvaluateAt(double localTime, FrameData frameData) { if (frameData.get_timeHeld()) { this.enable = false; } else { bool flag = frameData.get_seekOccurred() || frameData.get_timeLooped() || frameData.get_evaluationType() == 0; if (localTime <= this.start + this.duration - this.m_FinishTail) { float num = this.clip.EvaluateMixIn(localTime) * this.clip.EvaluateMixOut(localTime); if (PlayableExtensions.IsValid <Playable>(this.mixer)) { PlayableExtensions.SetInputWeight <Playable, Playable>(this.mixer, this.playable, num); } if (!this.m_Started || flag) { double num2 = this.clip.ToLocalTime(Math.Max(localTime, this.clip.start)); double num3 = Math.Max(this.clip.start - localTime, 0.0) * this.clip.timeScale; double num4 = this.m_Clip.duration * this.clip.timeScale; this.m_AudioClipPlayable.Seek(num2, num3, num4); this.m_Started = true; } } } }
public override void ProcessFrame(Playable playable, FrameData info, object playerData) { //IL_0018: Unknown result type (might be due to invalid IL or missing references) //IL_001e: Invalid comparison between Unknown and I4 //IL_0020: Unknown result type (might be due to invalid IL or missing references) //IL_0026: Unknown result type (might be due to invalid IL or missing references) //IL_0051: Unknown result type (might be due to invalid IL or missing references) //IL_0056: Unknown result type (might be due to invalid IL or missing references) //IL_0057: Unknown result type (might be due to invalid IL or missing references) //IL_005f: Unknown result type (might be due to invalid IL or missing references) if (!m_eventInstance.isValid()) { if (!StartInstance()) { return; } } else if ((int)info.get_evaluationType() == 1 && PlayableExtensions.GetPreviousTime <Playable>(playable) > PlayableExtensions.GetTime <Playable>(playable)) { StopInstance(); if (!StartInstance()) { return; } } RESULT val = m_eventInstance.setVolume(info.get_weight() * m_volume); if ((int)val != 0) { Log.Warning($"Failed to set event instance volume: {val}.", 112, "C:\\BuildAgents\\AgentB\\work\\cub_client_win64_develop\\client\\DofusCube.Unity\\Assets\\Core\\Code\\Audio\\AudioEventPlayableBehaviour.cs"); } }
public static float NormalizeMixer(Playable mixer) { float result; if (!PlayableExtensions.IsValid <Playable>(mixer)) { result = 0f; } else { int inputCount = PlayableExtensions.GetInputCount <Playable>(mixer); float num = 0f; for (int i = 0; i < inputCount; i++) { num += PlayableExtensions.GetInputWeight <Playable>(mixer, i); } if (num > Mathf.Epsilon && num < 1f) { for (int j = 0; j < inputCount; j++) { PlayableExtensions.SetInputWeight <Playable>(mixer, j, PlayableExtensions.GetInputWeight <Playable>(mixer, j) / num); } } result = Mathf.Clamp01(num); } return(result); }
public override void ProcessFrame(Playable playable, FrameData info, object playerData) { //IL_000f: Unknown result type (might be due to invalid IL or missing references) //IL_0010: Unknown result type (might be due to invalid IL or missing references) //IL_0015: Unknown result type (might be due to invalid IL or missing references) //IL_0019: Unknown result type (might be due to invalid IL or missing references) //IL_006a: Unknown result type (might be due to invalid IL or missing references) //IL_00ac: Unknown result type (might be due to invalid IL or missing references) //IL_00b3: Unknown result type (might be due to invalid IL or missing references) //IL_00ba: Unknown result type (might be due to invalid IL or missing references) //IL_00bf: Unknown result type (might be due to invalid IL or missing references) //IL_00c7: Unknown result type (might be due to invalid IL or missing references) //IL_00f6: Unknown result type (might be due to invalid IL or missing references) //IL_013b: Unknown result type (might be due to invalid IL or missing references) if (!(null == m_characterObject)) { PlayableGraph graph = PlayableExtensions.GetGraph <Playable>(playable); double time = PlayableExtensions.GetTime <Playable>(graph.GetRootPlayable(0)); foreach (TimelineClip clip in m_clips) { double start = clip.get_start(); if (time < start) { if (clip.IsPreExtrapolatedTime(time)) { CharacterObjectColorModifierPlayableAsset characterObjectColorModifierPlayableAsset = (CharacterObjectColorModifierPlayableAsset)clip.get_asset(); m_characterObject.SetColorModifier(characterObjectColorModifierPlayableAsset.startColor); m_currentClip = characterObjectColorModifierPlayableAsset; return; } } else { double end = clip.get_end(); if (time <= end) { CharacterObjectColorModifierPlayableAsset characterObjectColorModifierPlayableAsset2 = (CharacterObjectColorModifierPlayableAsset)clip.get_asset(); float num = Mathf.InverseLerp((float)start, (float)end, (float)time); Color colorModifier = Color.Lerp(characterObjectColorModifierPlayableAsset2.startColor, characterObjectColorModifierPlayableAsset2.endColor, num); m_characterObject.SetColorModifier(colorModifier); m_currentClip = characterObjectColorModifierPlayableAsset2; return; } if (clip.IsPostExtrapolatedTime(time)) { CharacterObjectColorModifierPlayableAsset characterObjectColorModifierPlayableAsset3 = (CharacterObjectColorModifierPlayableAsset)clip.get_asset(); m_characterObject.SetColorModifier(characterObjectColorModifierPlayableAsset3.endColor); m_currentClip = characterObjectColorModifierPlayableAsset3; return; } } } if (null != m_currentClip) { m_characterObject.SetColorModifier(m_currentClip.endColor); m_currentClip = null; } } }
public void LiveLink() { if (PlayableExtensions.IsValid <AnimationOffsetPlayable>(this.m_AnimationOffsetPlayable)) { this.m_AnimationOffsetPlayable.SetPosition(this.position); this.m_AnimationOffsetPlayable.SetRotation(this.rotation); } }
private void CreateActivationPlayable(GameObject root, PlayableGraph graph, List <Playable> outplayables) { ScriptPlayable <ActivationControlPlayable> scriptPlayable = ActivationControlPlayable.Create(graph, root, this.postPlayback); if (PlayableExtensions.IsValid <ScriptPlayable <ActivationControlPlayable> >(scriptPlayable)) { outplayables.Add(scriptPlayable); } }
public override void OnBehaviourPause(Playable playable, FrameData info) { if (!(this.gameObject == null)) { if (info.get_evaluationType() == null || PlayableExtensions.GetGraph <Playable>(playable).IsPlaying()) { this.gameObject.SetActive(false); } } }
private void Create(TimelineClip clip, Playable clipPlayable, Playable parentMixer, double startDelay, double finishTail) { this.m_Clip = clip; this.m_Playable = clipPlayable; this.m_AudioClipPlayable = (AudioClipPlayable)clipPlayable; this.m_ParentMixer = parentMixer; this.m_StartDelay = startDelay; this.m_FinishTail = finishTail; PlayableExtensions.SetPlayState <Playable>(clipPlayable, 0); }
public void Evaluate() { for (int i = 0; i < this.m_Mixers.Count; i++) { AnimationOutputWeightProcessor.WeightInfo weightInfo = this.m_Mixers[i]; float num = (!weightInfo.modulate) ? 1f : PlayableExtensions.GetInputWeight <Playable>(weightInfo.parentMixer, weightInfo.port); PlayableExtensions.SetInputWeight <Playable>(weightInfo.parentMixer, weightInfo.port, num * WeightUtility.NormalizeMixer(weightInfo.mixer)); } PlayableOutputExtensions.SetWeight <AnimationPlayableOutput>(this.m_Output, WeightUtility.NormalizeMixer(this.m_LayerMixer)); }
private static Playable ConnectPlayablesToMixer(PlayableGraph graph, List <Playable> playables) { Playable playable = Playable.Create(graph, playables.Count); for (int num = 0; num != playables.Count; num++) { ControlPlayableAsset.ConnectMixerAndPlayable(graph, playable, playables[num], num); } PlayableExtensions.SetPropagateSetTime <Playable>(playable, true); return(playable); }
private static Playable ConnectPlayablesToMixer(PlayableGraph graph, List <Playable> playables) { Playable val = Playable.Create(graph, playables.Count); for (int i = 0; i != playables.Count; i++) { ConnectMixerAndPlayable(graph, val, playables[i], i); } PlayableExtensions.SetPropagateSetTime <Playable>(val, true); return(val); }
public override void PrepareFrame(Playable playable, FrameData info) { //IL_0009: Unknown result type (might be due to invalid IL or missing references) //IL_0010: Unknown result type (might be due to invalid IL or missing references) if (m_curve != null) { float num = (float)PlayableExtensions.GetTime <Playable>(playable); float num2 = (float)PlayableExtensions.GetDuration <Playable>(playable); float num3 = num / num2; float num4 = m_curve.Evaluate(num3); CubeSRP.SetLightIntensityFactor((object)this, num4); } }
public override Playable CreatePlayable(PlayableGraph graph, GameObject owner) { var playable = ScriptPlayable <NavMeshBehaviour> .Create(graph); var navMeshBehaviour = playable.GetBehaviour(); var x = PlayableExtensions.GetDuration(playable); var a = start.Resolve(graph.GetResolver()); var b = end.Resolve(graph.GetResolver()); var l = lookTarget.Resolve(graph.GetResolver()); navMeshBehaviour.Init(a, b, l, (float)clipDuration); navMeshBehaviour.offset = offset; return(playable); }
public BlendedAnimationLayer(PlayableGraph PlayableGraph, AnimationLayerMixerPlayable parentAnimationLayerMixerPlayable, int layerId, List <BlendedAnimationClip> blendedAnimationClips, BlendedAnimationSpeedCurve BlendedAnimationSpeedCurve) : base(layerId, parentAnimationLayerMixerPlayable) { BlendedAnimationClips = blendedAnimationClips; this.BlendedAnimationSpeedCurve = BlendedAnimationSpeedCurve; //create a playable mixer this.AnimationMixerPlayable = AnimationMixerPlayable.Create(PlayableGraph); foreach (var blendedAnimationClip in blendedAnimationClips) { var animationClipPlayable = AnimationClipPlayable.Create(PlayableGraph, blendedAnimationClip.AnimationClip); animationClipPlayable.SetApplyFootIK(false); animationClipPlayable.SetApplyPlayableIK(false); blendedAnimationClip.InputHandler = PlayableExtensions.AddInput(this.AnimationMixerPlayable, animationClipPlayable, 0); PlayableExtensions.Play(animationClipPlayable); blendedAnimationClip.AnimationClipPlayable = animationClipPlayable; } //calculate blendings for (var i = 0; i < blendedAnimationClips.Count; i++) { if (i == 0) { blendedAnimationClips[i].Blending = blendedAnimationClips[i].Blending.SetWeightTimePoints( AnimationWeightStartIncreasingTime: 0f, AnimationWeightEndIncreasingTime: blendedAnimationClips[i].WeightTime, AnimationWeightStartDecreasingTime: blendedAnimationClips[i].WeightTime, AnimationWeightEndDecreasingTime: blendedAnimationClips[i + 1].WeightTime ); } else if (i == blendedAnimationClips.Count - 1) { blendedAnimationClips[i].Blending = blendedAnimationClips[i].Blending.SetWeightTimePoints( AnimationWeightStartIncreasingTime: blendedAnimationClips[i - 1].WeightTime, AnimationWeightEndIncreasingTime: blendedAnimationClips[i].WeightTime, AnimationWeightStartDecreasingTime: blendedAnimationClips[i].WeightTime, AnimationWeightEndDecreasingTime: 1f ); } else { blendedAnimationClips[i].Blending = blendedAnimationClips[i].Blending.SetWeightTimePoints( AnimationWeightStartIncreasingTime: blendedAnimationClips[i - 1].WeightTime, AnimationWeightEndIncreasingTime: blendedAnimationClips[i].WeightTime, AnimationWeightStartDecreasingTime: blendedAnimationClips[i].WeightTime, AnimationWeightEndDecreasingTime: blendedAnimationClips[i + 1].WeightTime ); } } }
private static void SetAnimationMixerPlayableWeight(AnimationMixerPlayable AnimationMixerPlayable, AnimationClipPlayable AnimationClipPlayable, int inputHandler, float weight) { if (PlayableExtensions.GetInputWeight(AnimationMixerPlayable, inputHandler) == 0f && weight > 0f) { AnimationClipPlayable.SetTime(0f); AnimationClipPlayable.Play(); } else if (weight == 0f) { AnimationClipPlayable.Pause(); } PlayableExtensions.SetInputWeight(AnimationMixerPlayable, inputHandler, weight); }
private Playable CreateTrackPlayable(PlayableGraph graph, Playable timelinePlayable, TrackAsset track, GameObject go, bool createOutputs) { Playable result; TimelinePlayable.ConnectionCache connectionCache; if (!track.compilable) { result = timelinePlayable; } else if (this.m_PlayableCache.TryGetValue(track, out connectionCache)) { result = connectionCache.playable; } else if (track.get_name() == "root") { result = timelinePlayable; } else { TrackAsset trackAsset = track.parent as TrackAsset; Playable playable = (!(trackAsset != null)) ? timelinePlayable : this.CreateTrackPlayable(graph, timelinePlayable, trackAsset, go, createOutputs); Playable playable2 = TimelinePlayable.CreatePlayableGraph(graph, track, go, this.m_IntervalTree); bool flag = false; if (!PlayableExtensions.IsValid <Playable>(playable2)) { throw new InvalidOperationException(string.Concat(new object[] { track.get_name(), "(", track.GetType(), ") did not produce a valid playable. Use the compilable property to indicate whether the track is valid for processing" })); } if (PlayableExtensions.IsValid <Playable>(playable) && PlayableExtensions.IsValid <Playable>(playable2)) { int inputCount = PlayableExtensions.GetInputCount <Playable>(playable); PlayableExtensions.SetInputCount <Playable>(playable, inputCount + 1); flag = graph.Connect <Playable, Playable>(playable2, 0, playable, inputCount); PlayableExtensions.SetInputWeight <Playable>(playable, inputCount, 1f); } if (createOutputs && flag) { this.CreateTrackOutput(graph, track, playable, PlayableExtensions.GetInputCount <Playable>(playable) - 1); } this.CacheTrack(track, playable2, (!flag) ? -1 : (PlayableExtensions.GetInputCount <Playable>(playable) - 1), playable); result = playable2; } return(result); }
public sealed override void PrepareFrame(Playable playable, FrameData info) { if (this.m_HasFired) { if (this.HasLooped(PlayableExtensions.GetTime <Playable>(playable), info) || this.CanRestoreEvent(PlayableExtensions.GetTime <Playable>(playable), info)) { this.Restore_internal(); } } if (!this.m_HasFired && this.CanTriggerEvent(PlayableExtensions.GetTime <Playable>(playable), info)) { this.Trigger_internal(); } this.m_PreviousTime = PlayableExtensions.GetTime <Playable>(playable); }
private void PlayTwoDBlendedAnimation(int layerID, TwoDAnimationInput TwoDAnimationInput) { if (this.AllAnimationLayersCurrentlyPlaying.ContainsKey(layerID)) { this.DestroyLayer(layerID); } TwoDBlendTree TwoDBlendTree = new TwoDBlendTree(layerID, this.GlobalPlayableGraph, this.AnimationLayerMixerPlayable, TwoDAnimationInput); this.AllAnimationLayersCurrentlyPlaying[layerID] = TwoDBlendTree; this.OrderedByInputHandlerAnimationLayers.Add(TwoDBlendTree); this.SortLayers(); PlayableExtensions.SetInputWeight(this.AnimationLayerMixerPlayable, this.AllAnimationLayersCurrentlyPlaying[layerID].Inputhandler, 1f); }
private void PlaySequencedAnimation(int layerID, SequencedAnimationInput SequencedAnimationInput, Action OnAnimationEnd) { if (this.AllAnimationLayersCurrentlyPlaying.ContainsKey(layerID)) { this.DestroyLayer(layerID); } var SequencedAnimationLayer = new SequencedAnimationLayer(this.GlobalPlayableGraph, this.AnimationLayerMixerPlayable, layerID, SequencedAnimationInput, OnAnimationEnd); this.AllAnimationLayersCurrentlyPlaying[layerID] = SequencedAnimationLayer; this.OrderedByInputHandlerAnimationLayers.Add(SequencedAnimationLayer); this.SortLayers(); PlayableExtensions.SetInputWeight(this.AnimationLayerMixerPlayable, SequencedAnimationLayer.Inputhandler, 1f); }
private void PlayBlendedAnimation(int layerID, BlendedAnimationInput BlendedAnimationInput, Func <float> InputWeightProvider) { if (this.AllAnimationLayersCurrentlyPlaying.ContainsKey(layerID)) { this.DestroyLayer(layerID); } BlendedAnimationLayer BlendedAnimationLayer = new BlendedAnimationLayer(this.GlobalPlayableGraph, this.AnimationLayerMixerPlayable, layerID, BlendedAnimationInput, InputWeightProvider); this.AllAnimationLayersCurrentlyPlaying[layerID] = BlendedAnimationLayer; this.OrderedByInputHandlerAnimationLayers.Add(BlendedAnimationLayer); this.SortLayers(); PlayableExtensions.SetInputWeight(this.AnimationLayerMixerPlayable, this.AllAnimationLayersCurrentlyPlaying[layerID].Inputhandler, 1f); }
public override void ProcessFrame(Playable playable, FrameData info, object playerData) { if (!(this.boundGameObject == null)) { int inputCount = PlayableExtensions.GetInputCount <Playable>(playable); bool active = false; for (int i = 0; i < inputCount; i++) { if (PlayableExtensions.GetInputWeight <Playable>(playable, i) > 0f) { active = true; break; } } this.boundGameObject.SetActive(active); } }