public static T SetDelay<T>(this T animation, TimeSpan delayTime, AnimationDelayBehavior behavior)
where T : KeyFrameAnimation
{
animation.DelayBehavior = behavior;
animation.DelayTime = delayTime;
return animation;
}
/// <summary>
/// Sets the delay time in seconds
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="animation"></param>
/// <param name="delayTime">Delay Time in seconds</param>
/// <returns></returns>
public static T SetDelay<T>(this T animation, double delayTime, AnimationDelayBehavior behavior)
where T : KeyFrameAnimation
{
animation.DelayTime = TimeSpan.FromSeconds(delayTime);
animation.DelayBehavior = behavior;
return animation;
}
public KeyFrameAnimationInstance(
IInterpolator <T> interpolator, ServerKeyFrame <T>[] keyFrames,
PropertySetSnapshot snapshot, ExpressionVariant?finalValue,
ServerObject target,
AnimationDelayBehavior delayBehavior, TimeSpan delayTime,
PlaybackDirection direction, TimeSpan duration,
AnimationIterationBehavior iterationBehavior,
int iterationCount, AnimationStopBehavior stopBehavior) : base(target, snapshot)
{
_interpolator = interpolator;
_keyFrames = keyFrames;
_finalValue = finalValue;
_delayBehavior = delayBehavior;
_delayTime = delayTime;
_direction = direction;
_duration = duration;
_iterationBehavior = iterationBehavior;
_iterationCount = iterationCount;
_stopBehavior = stopBehavior;
if (_iterationBehavior == AnimationIterationBehavior.Count)
{
_totalDuration = delayTime.Add(TimeSpan.FromTicks(iterationCount * _duration.Ticks));
}
if (_keyFrames.Length == 0)
{
throw new InvalidOperationException("Animation has no key frames");
}
if (_duration.Ticks <= 0)
{
throw new InvalidOperationException("Invalid animation duration");
}
}
public Composition(string property, TimeSpan?delay, RepeatOption repeat, AnimationDelayBehavior delayBehavior)
: base(property, delay, repeat)
{
this.delayBehavior = delayBehavior;
}
public static T SetDelayBehavior<T>(this T animation, AnimationDelayBehavior behavior)
where T : KeyFrameAnimation
{
animation.DelayBehavior = behavior;
return animation;
}
public static CompositionAnimation GetAnimation <TKeyFrame>(
CompositionObject target,
string property,
TimeSpan?delay,
TimeSpan duration,
RepeatOption repeat,
AnimationDelayBehavior delayBehavior,
ArraySegment <TKeyFrame> keyFrames)
where TKeyFrame : struct, IKeyFrameInfo
{
KeyFrameAnimation animation;
if (typeof(T) == typeof(bool))
{
BooleanKeyFrameAnimation boolAnimation = target.Compositor.CreateBooleanKeyFrameAnimation();
foreach (var keyFrame in keyFrames)
{
if (keyFrame.TryInsertExpressionKeyFrame(boolAnimation, duration))
{
continue;
}
boolAnimation.InsertKeyFrame(keyFrame.GetNormalizedProgress(duration), keyFrame.GetValueAs <bool>());
}
animation = boolAnimation;
}
else if (typeof(T) == typeof(float))
{
ScalarKeyFrameAnimation scalarAnimation = target.Compositor.CreateScalarKeyFrameAnimation();
foreach (var keyFrame in keyFrames)
{
if (keyFrame.TryInsertExpressionKeyFrame(scalarAnimation, duration))
{
continue;
}
CompositionEasingFunction?easingFunction = target.Compositor.TryCreateEasingFunction(keyFrame.EasingType, keyFrame.EasingMode);
if (easingFunction is null)
{
scalarAnimation.InsertKeyFrame(keyFrame.GetNormalizedProgress(duration), keyFrame.GetValueAs <float>());
}
else
{
scalarAnimation.InsertKeyFrame(keyFrame.GetNormalizedProgress(duration), keyFrame.GetValueAs <float>(), easingFunction);
}
}
animation = scalarAnimation;
}
else if (typeof(T) == typeof(double))
{
ScalarKeyFrameAnimation scalarAnimation = target.Compositor.CreateScalarKeyFrameAnimation();
foreach (var keyFrame in keyFrames)
{
if (keyFrame.TryInsertExpressionKeyFrame(scalarAnimation, duration))
{
continue;
}
CompositionEasingFunction?easingFunction = target.Compositor.TryCreateEasingFunction(keyFrame.EasingType, keyFrame.EasingMode);
if (easingFunction is null)
{
scalarAnimation.InsertKeyFrame(keyFrame.GetNormalizedProgress(duration), (float)keyFrame.GetValueAs <double>());
}
else
{
scalarAnimation.InsertKeyFrame(keyFrame.GetNormalizedProgress(duration), (float)keyFrame.GetValueAs <double>(), easingFunction);
}
}
animation = scalarAnimation;
}
else if (typeof(T) == typeof(Vector2))
{
Vector2KeyFrameAnimation vector2Animation = target.Compositor.CreateVector2KeyFrameAnimation();
foreach (var keyFrame in keyFrames)
{
if (keyFrame.TryInsertExpressionKeyFrame(vector2Animation, duration))
{
continue;
}
CompositionEasingFunction?easingFunction = target.Compositor.TryCreateEasingFunction(keyFrame.EasingType, keyFrame.EasingMode);
if (easingFunction is null)
{
vector2Animation.InsertKeyFrame(keyFrame.GetNormalizedProgress(duration), keyFrame.GetValueAs <Vector2>());
}
else
{
vector2Animation.InsertKeyFrame(keyFrame.GetNormalizedProgress(duration), keyFrame.GetValueAs <Vector2>(), easingFunction);
}
}
animation = vector2Animation;
}
else if (typeof(T) == typeof(Vector3))
{
Vector3KeyFrameAnimation vector3Animation = target.Compositor.CreateVector3KeyFrameAnimation();
foreach (var keyFrame in keyFrames)
{
if (keyFrame.TryInsertExpressionKeyFrame(vector3Animation, duration))
{
continue;
}
CompositionEasingFunction?easingFunction = target.Compositor.TryCreateEasingFunction(keyFrame.EasingType, keyFrame.EasingMode);
if (easingFunction is null)
{
vector3Animation.InsertKeyFrame(keyFrame.GetNormalizedProgress(duration), keyFrame.GetValueAs <Vector3>());
}
else
{
vector3Animation.InsertKeyFrame(keyFrame.GetNormalizedProgress(duration), keyFrame.GetValueAs <Vector3>(), easingFunction);
}
}
animation = vector3Animation;
}
else if (typeof(T) == typeof(Vector4))
{
Vector4KeyFrameAnimation vector4Animation = target.Compositor.CreateVector4KeyFrameAnimation();
foreach (var keyFrame in keyFrames)
{
if (keyFrame.TryInsertExpressionKeyFrame(vector4Animation, duration))
{
continue;
}
CompositionEasingFunction?easingFunction = target.Compositor.TryCreateEasingFunction(keyFrame.EasingType, keyFrame.EasingMode);
if (easingFunction is null)
{
vector4Animation.InsertKeyFrame(keyFrame.GetNormalizedProgress(duration), keyFrame.GetValueAs <Vector4>());
}
else
{
vector4Animation.InsertKeyFrame(keyFrame.GetNormalizedProgress(duration), keyFrame.GetValueAs <Vector4>(), easingFunction);
}
}
animation = vector4Animation;
}
else if (typeof(T) == typeof(Color))
{
ColorKeyFrameAnimation colorAnimation = target.Compositor.CreateColorKeyFrameAnimation();
foreach (var keyFrame in keyFrames)
{
if (keyFrame.TryInsertExpressionKeyFrame(colorAnimation, duration))
{
continue;
}
CompositionEasingFunction?easingFunction = target.Compositor.TryCreateEasingFunction(keyFrame.EasingType, keyFrame.EasingMode);
if (easingFunction is null)
{
colorAnimation.InsertKeyFrame(keyFrame.GetNormalizedProgress(duration), keyFrame.GetValueAs <Color>());
}
else
{
colorAnimation.InsertKeyFrame(keyFrame.GetNormalizedProgress(duration), keyFrame.GetValueAs <Color>(), easingFunction);
}
}
animation = colorAnimation;
}
else if (typeof(T) == typeof(Quaternion))
{
QuaternionKeyFrameAnimation quaternionAnimation = target.Compositor.CreateQuaternionKeyFrameAnimation();
foreach (var keyFrame in keyFrames)
{
if (keyFrame.TryInsertExpressionKeyFrame(quaternionAnimation, duration))
{
continue;
}
CompositionEasingFunction?easingFunction = target.Compositor.TryCreateEasingFunction(keyFrame.EasingType, keyFrame.EasingMode);
if (easingFunction is null)
{
quaternionAnimation.InsertKeyFrame(keyFrame.GetNormalizedProgress(duration), keyFrame.GetValueAs <Quaternion>());
}
else
{
quaternionAnimation.InsertKeyFrame(keyFrame.GetNormalizedProgress(duration), keyFrame.GetValueAs <Quaternion>(), easingFunction);
}
}
animation = quaternionAnimation;
}
else
{
throw new InvalidOperationException("Invalid animation type");
}
animation.Duration = duration;
if (delay.HasValue)
{
animation.DelayBehavior = delayBehavior;
animation.DelayTime = delay !.Value;
}
animation.Target = property;
(animation.IterationBehavior, animation.IterationCount) = repeat.ToBehaviorAndCount();
return(animation);
}
