public void InsertKeyFrame(float progress, T value, CompositionEasingFunction?easing)
{
if (typeof(T) == typeof(bool) && easing != null)
{
throw new ArgumentException($"This method cannot be called on {nameof(BooleanKeyFrameAnimation)}.");
}
InsertKeyFrameCommon(progress, value, easing);
}
public void InsertExpressionKeyFrame(float progress, TExpression expression, CompositionEasingFunction?easing)
{
if (progress < 0 || progress > 1)
{
throw new ArgumentException($"Progress must be >=0 and <=1. Value: {progress}");
}
_keyFrames.Add(progress, new ExpressionKeyFrame(progress, easing, expression));
}
void InsertKeyFrameCommon(float progress, T value, CompositionEasingFunction?easing)
{
if (progress < 0 || progress > 1)
{
throw new ArgumentException($"Progress must be >=0 and <=1. Value: {progress}");
}
// It is legal to insert a key frame at a progress value that already has
// a key frame. Last one wins.
_keyFrames[progress] = new ValueKeyFrame(progress, easing, value);
}
public bool TryInsertExpressionKeyFrame(KeyFrameAnimation animation, TimeSpan duration)
{
if (this.expression is null)
{
return(false);
}
CompositionEasingFunction?easingFunction = animation.Compositor.TryCreateEasingFunction(EasingType, EasingMode);
if (easingFunction is null)
{
animation.InsertExpressionKeyFrame(GetNormalizedProgress(duration), this.expression);
}
else
{
animation.InsertExpressionKeyFrame(GetNormalizedProgress(duration), this.expression, easingFunction);
}
return(true);
}
internal ValueKeyFrame(float progress, CompositionEasingFunction?easing, T value)
: base(progress, easing)
{
Value = value;
}
internal ExpressionKeyFrame(float progress, CompositionEasingFunction?easing, TExpression expression)
: base(progress, easing, expression)
{
Expression = expression;
}
public CompositionAnimation GetAnimation(CompositionObject targetHint, out CompositionObject?target)
{
CompositionEasingFunction?easingFunction = targetHint.Compositor.TryCreateEasingFunction(EasingType, EasingMode);
(AnimationIterationBehavior iterationBehavior, int iterationCount) = Repeat.ToBehaviorAndCount();
target = null;
if (typeof(T) == typeof(bool))
{
return(targetHint.Compositor.CreateBooleanKeyFrameAnimation(
Property,
GetToAs <bool>(),
GetFromAs <bool>(),
Delay,
Duration,
iterationBehavior: iterationBehavior,
iterationCount: iterationCount));
}
if (typeof(T) == typeof(float))
{
return(targetHint.Compositor.CreateScalarKeyFrameAnimation(
Property,
GetToAs <float>(),
GetFromAs <float>(),
Delay,
Duration,
easingFunction,
iterationBehavior: iterationBehavior,
iterationCount: iterationCount));
}
if (typeof(T) == typeof(double))
{
return(targetHint.Compositor.CreateScalarKeyFrameAnimation(
Property,
(float)GetToAs <double>(),
(float?)GetFromAs <double>(),
Delay,
Duration,
easingFunction,
iterationBehavior: iterationBehavior,
iterationCount: iterationCount));
}
if (typeof(T) == typeof(Vector2))
{
return(targetHint.Compositor.CreateVector2KeyFrameAnimation(
Property,
GetToAs <Vector2>(),
GetFromAs <Vector2>(),
Delay,
Duration,
easingFunction,
iterationBehavior: iterationBehavior,
iterationCount: iterationCount));
}
if (typeof(T) == typeof(Vector3))
{
return(targetHint.Compositor.CreateVector3KeyFrameAnimation(
Property,
GetToAs <Vector3>(),
GetFromAs <Vector3>(),
Delay,
Duration,
easingFunction,
iterationBehavior: iterationBehavior,
iterationCount: iterationCount));
}
if (typeof(T) == typeof(Vector4))
{
return(targetHint.Compositor.CreateVector4KeyFrameAnimation(
Property,
GetToAs <Vector4>(),
GetFromAs <Vector4>(),
Delay,
Duration,
easingFunction,
iterationBehavior: iterationBehavior,
iterationCount: iterationCount));
}
if (typeof(T) == typeof(Color))
{
return(targetHint.Compositor.CreateColorKeyFrameAnimation(
Property,
GetToAs <Color>(),
GetFromAs <Color>(),
Delay,
Duration,
easingFunction,
iterationBehavior: iterationBehavior,
iterationCount: iterationCount));
}
if (typeof(T) == typeof(Quaternion))
{
return(targetHint.Compositor.CreateQuaternionKeyFrameAnimation(
Property,
GetToAs <Quaternion>(),
GetFromAs <Quaternion>(),
Delay,
Duration,
easingFunction,
iterationBehavior: iterationBehavior,
iterationCount: iterationCount));
}
throw new InvalidOperationException("Invalid animation type");
}
public static CompositionAnimation GetAnimation <TKeyFrame>(
CompositionObject target,
string property,
TimeSpan?delay,
TimeSpan duration,
RepeatOption repeat,
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.DelayTime = delay !.Value;
}
animation.Target = property;
(animation.IterationBehavior, animation.IterationCount) = repeat.ToBehaviorAndCount();
return(animation);
}
private protected ExpressionKeyFrame(float progress, CompositionEasingFunction?easing, Expression expression)
: base(progress, easing)
{
Expression = expression;
}
private protected KeyFrame(float progress, CompositionEasingFunction?easing)
{
Progress = progress;
Easing = easing;
}