public override Vector?GetValue(Keyframe <Vector?> keyframe, double keyframeProgress)
        {
            var pathKeyframe = (PathKeyframe)keyframe;
            var path         = pathKeyframe.Path;

            if (path == null || path.Contours.Count == 0)
            {
                return(keyframe.StartValue);
            }

            if (ValueCallback != null)
            {
                return(ValueCallback.GetValueInternal(pathKeyframe.StartFrame.Value, pathKeyframe.EndFrame.Value,
                                                      pathKeyframe.StartValue, pathKeyframe.EndValue, LinearCurrentKeyframeProgress,
                                                      keyframeProgress, Progress));
            }

            if (_pathMeasureKeyframe != pathKeyframe)
            {
                _pathMeasure?.Dispose();
                _pathMeasure         = new PathMeasure(path);
                _pathMeasureKeyframe = pathKeyframe;
            }

            return(_pathMeasure.GetPosTan(keyframeProgress * _pathMeasure.Length));
        }
Example #2
0
        public override Vector2?GetValue(Keyframe <Vector2?> keyframe, float keyframeProgress)
        {
            var pathKeyframe = (PathKeyframe)keyframe;
            var path         = pathKeyframe.Path;

            if (path == null || path.IsEmpty)
            {
                return(keyframe.StartValue);
            }

            if (ValueCallback != null)
            {
                var value = ValueCallback.GetValueInternal(pathKeyframe.StartFrame.Value, pathKeyframe.EndFrame.Value,
                                                           pathKeyframe.StartValue, pathKeyframe.EndValue, LinearCurrentKeyframeProgress,
                                                           keyframeProgress, Progress);
                if (value != null)
                {
                    return(value);
                }
            }

            if (_pathMeasureKeyframe != pathKeyframe)
            {
                _pathMeasure?.Dispose();
                _pathMeasure         = new SKPathMeasure(path);
                _pathMeasureKeyframe = pathKeyframe;
            }
            _pathMeasure.GetPositionAndTangent(keyframeProgress * _pathMeasure.Length, out var pos, out _);
            return(new Vector2(pos.X, pos.Y));
        }
Example #3
0
        public override float?GetValue(Keyframe <float?> keyframe, float keyframeProgress)
        {
            if (keyframe.StartValue == null || keyframe.EndValue == null)
            {
                throw new System.InvalidOperationException("Missing values for keyframe.");
            }

            if (ValueCallback != null)
            {
                return(ValueCallback.GetValueInternal(keyframe.StartFrame.Value, keyframe.EndFrame.Value, keyframe.StartValue, keyframe.EndValue, keyframeProgress, LinearCurrentKeyframeProgress, Progress));
            }

            return(MathExt.Lerp(keyframe.StartValue.Value, keyframe.EndValue.Value, keyframeProgress));
        }
        public override Color?GetValue(Keyframe <Color?> keyframe, float keyframeProgress)
        {
            if (keyframe.StartValue == null || keyframe.EndValue == null)
            {
                throw new System.InvalidOperationException("Missing values for keyframe.");
            }
            var startColor = keyframe.StartValue;
            var endColor   = keyframe.EndValue;

            if (ValueCallback != null)
            {
                return(ValueCallback.GetValueInternal(keyframe.StartFrame.Value, keyframe.EndFrame.Value, startColor, endColor, keyframeProgress, LinearCurrentKeyframeProgress, Progress));
            }

            return(GammaEvaluator.Evaluate(keyframeProgress, startColor.Value, endColor.Value));
        }
Example #5
0
        public override ScaleXy GetValue(Keyframe <ScaleXy> keyframe, float keyframeProgress)
        {
            if (keyframe.StartValue == null || keyframe.EndValue == null)
            {
                throw new InvalidOperationException("Missing values for keyframe.");
            }
            var startTransform = keyframe.StartValue;
            var endTransform   = keyframe.EndValue;

            if (ValueCallback != null)
            {
                return(ValueCallback.GetValueInternal(keyframe.StartFrame.Value, keyframe.EndFrame.Value,
                                                      startTransform, endTransform,
                                                      keyframeProgress, LinearCurrentKeyframeProgress, Progress));
            }

            return(new ScaleXy(MathExt.Lerp(startTransform.ScaleX, endTransform.ScaleX, keyframeProgress), MathExt.Lerp(startTransform.ScaleY, endTransform.ScaleY, keyframeProgress)));
        }
Example #6
0
        public override Vector2?GetValue(Keyframe <Vector2?> keyframe, float keyframeProgress)
        {
            if (keyframe.StartValue == null || keyframe.EndValue == null)
            {
                throw new System.InvalidOperationException("Missing values for keyframe.");
            }

            var startPoint = keyframe.StartValue;
            var endPoint   = keyframe.EndValue;

            if (ValueCallback != null)
            {
                return(ValueCallback.GetValueInternal(keyframe.StartFrame.Value, keyframe.EndFrame.Value, startPoint, endPoint, keyframeProgress, LinearCurrentKeyframeProgress, Progress));
            }

            _point.X = startPoint.Value.X + keyframeProgress * (endPoint.Value.X - startPoint.Value.X);
            _point.Y = startPoint.Value.Y + keyframeProgress * (endPoint.Value.Y - startPoint.Value.Y);

            return(_point);
        }