protected override ExpressionVariant EvaluateCore(TimeSpan now, ExpressionVariant currentValue) { var starting = ExpressionVariant.Create(_startingValue); var ctx = new ExpressionEvaluationContext { Parameters = Parameters, Target = TargetObject, CurrentValue = currentValue, FinalValue = _finalValue ?? starting, StartingValue = starting, ForeignFunctionInterface = BuiltInExpressionFfi.Instance }; var elapsed = now - _startedAt; var res = EvaluateImpl(elapsed, currentValue, ref ctx); if (_iterationBehavior == AnimationIterationBehavior.Count && !_finished && elapsed > _totalDuration) { // Active check? TargetObject.Compositor.RemoveFromClock(this); _finished = true; } return(res); }
public override void Initialize(TimeSpan startedAt, ExpressionVariant startingValue, CompositionProperty property) { _startingValue = startingValue; var hs = new HashSet <(string, string)>(); _expression.CollectReferences(hs); base.Initialize(property, hs); }
public override void Initialize(TimeSpan startedAt, ExpressionVariant startingValue, CompositionProperty property) { _startedAt = startedAt; _startingValue = startingValue.CastOrDefault <T>(); var hs = new HashSet <(string, string)>(); // TODO: Update subscriptions based on the current keyframe rather than keeping subscriptions to all of them foreach (var frame in _keyFrames) { frame.Expression?.CollectReferences(hs); } Initialize(property, hs); }
protected override ExpressionVariant EvaluateCore(TimeSpan now, ExpressionVariant currentValue) { var ctx = new ExpressionEvaluationContext { Parameters = Parameters, Target = TargetObject, ForeignFunctionInterface = BuiltInExpressionFfi.Instance, StartingValue = _startingValue, FinalValue = _finalValue ?? _startingValue, CurrentValue = currentValue }; return(_expression.Evaluate(ref ctx)); }
bool StartAnimationGroupPart(CompositionAnimation animation, string target, ExpressionVariant finalValue) { if (animation.Target == null) { throw new ArgumentException("Animation Target can't be null"); } if (animation.Target == target) { StartAnimation(animation.Target, animation, finalValue); return(true); } else { StartAnimation(animation.Target, animation); return(false); } }
void SetVariant(string key, ExpressionVariant value) => _propertySet.Set(key, value);
internal bool StartAnimationGroup(ICompositionAnimationBase grp, string target, ExpressionVariant finalValue) { if (grp is CompositionAnimation animation) { return(StartAnimationGroupPart(animation, target, finalValue)); } if (grp is CompositionAnimationGroup group) { var matched = false; foreach (var a in group.Animations) { if (a.Target == null) { throw new ArgumentException("Animation Target can't be null"); } if (StartAnimationGroupPart(a, target, finalValue)) { matched = true; } } return(matched); } throw new ArgumentException(); }
public Value(IExpressionObject o) { Object = o; Variant = default; }
internal void Set(string key, ExpressionVariant value) { _objects.Remove(key); _variants[key] = value; }
private ExpressionVariant EvaluateImpl(TimeSpan elapsed, ExpressionVariant currentValue, ref ExpressionEvaluationContext ctx) { if (elapsed < _delayTime) { if (_delayBehavior == AnimationDelayBehavior.SetInitialValueBeforeDelay) { return(ExpressionVariant.Create(GetKeyFrame(ref ctx, _keyFrames[0]))); } return(currentValue); } elapsed -= _delayTime; var iterationNumber = elapsed.Ticks / _duration.Ticks; if (_iterationBehavior == AnimationIterationBehavior.Count && iterationNumber >= _iterationCount) { return(ExpressionVariant.Create(GetKeyFrame(ref ctx, _keyFrames[_keyFrames.Length - 1]))); } var evenIterationNumber = iterationNumber % 2 == 0; elapsed = TimeSpan.FromTicks(elapsed.Ticks % _duration.Ticks); var reverse = _direction == PlaybackDirection.Alternate ? !evenIterationNumber : _direction == PlaybackDirection.AlternateReverse ? evenIterationNumber : _direction == PlaybackDirection.Reverse; var iterationProgress = elapsed.TotalSeconds / _duration.TotalSeconds; if (reverse) { iterationProgress = 1 - iterationProgress; } var left = new ServerKeyFrame <T> { Value = _startingValue }; var right = _keyFrames[_keyFrames.Length - 1]; for (var c = 0; c < _keyFrames.Length; c++) { var kf = _keyFrames[c]; if (kf.Key < iterationProgress) { // this is the last frame if (c == _keyFrames.Length - 1) { return(ExpressionVariant.Create(GetKeyFrame(ref ctx, kf))); } left = kf; right = _keyFrames[c + 1]; break; } } var keyProgress = Math.Max(0, Math.Min(1, (iterationProgress - left.Key) / (right.Key - left.Key))); var easedKeyProgress = (float)right.EasingFunction.Ease(keyProgress); if (float.IsNaN(easedKeyProgress) || float.IsInfinity(easedKeyProgress)) { return(currentValue); } return(ExpressionVariant.Create(_interpolator.Interpolate( GetKeyFrame(ref ctx, left), GetKeyFrame(ref ctx, right), easedKeyProgress ))); }