public async static Task StartClipAnimation(this FrameworkElement element, ClipAnimationDirection direction, float to,
double duration = 800, int delay = 0, CompositionEasingFunction easing = null, Action completed = null)
{
CompositionScopedBatch batch = null;
var visual = element.Visual();
// After we get the Visual of the View, we need to SIZE it 'cause by design the
// Size is (0,0). Without doing this, clipping will not work.
visual.Size = new Vector2(element.ActualWidth.ToFloat(), element.ActualHeight.ToFloat());
var compositor = visual.Compositor;
if (visual.Clip == null)
{
var clip = compositor.CreateInsetClip();
visual.Clip = clip;
}
if (completed != null)
{
batch = compositor.CreateScopedBatch(CompositionBatchTypes.Animation);
batch.Completed += (s, e) => completed();
}
if (delay > 0)
{
await Task.Delay(delay);
}
visual.Clip.StartAnimation($"{direction.ToString()}Inset", compositor.CreateScalarKeyFrameAnimation(to, duration, easing));
if (batch != null)
{
batch.End();
}
}
public async static Task StartOffsetAnimation(this UIElement element, AnimationAxis axis, float to = 0,
double duration = 800, int delay = 0, CompositionEasingFunction easing = null, Action completed = null)
{
CompositionScopedBatch batch = null;
var visual = element.Visual();
var compositor = visual.Compositor;
if (completed != null)
{
batch = compositor.CreateScopedBatch(CompositionBatchTypes.Animation);
batch.Completed += (s, e) => completed();
}
if (delay > 0)
{
await Task.Delay(delay);
}
visual.StartAnimation($"Offset.{axis.ToString()}", compositor.CreateScalarKeyFrameAnimation(to, duration, easing));
if (batch != null)
{
batch.End();
}
}
public async static Task StartOffsetAnimation(this UIElement element, Vector2? to = null,
double duration = 800, int delay = 0, CompositionEasingFunction easing = null, Action completed = null)
{
CompositionScopedBatch batch = null;
var visual = element.Visual();
var compositor = visual.Compositor;
if (completed != null)
{
batch = compositor.CreateScopedBatch(CompositionBatchTypes.Animation);
batch.Completed += (s, e) => completed();
}
if (to == null)
{
to = Vector2.Zero;
}
if (delay > 0)
{
await Task.Delay(delay);
}
visual.StartAnimation("Offset", compositor.CreateVector3KeyFrameAnimation(to.Value, duration, easing));
if (batch != null)
{
batch.End();
}
}
// CompositorExtensions
public static ScalarKeyFrameAnimation CreateScalarKeyFrameAnimation(this Compositor compositor, float to, float? from, TimeSpan duration, TimeSpan? delay, CompositionEasingFunction ease)
{
var ani = compositor.CreateScalarKeyFrameAnimation();
// Set duration and delay time
ani.Duration = duration;
if (delay.HasValue)
ani.DelayTime = delay.Value;
// Insert "to" and "from" keyframes
ani.InsertKeyFrame(1, to, ease ?? compositor.CreateLinearEasingFunction());
if (from.HasValue)
{
ani.InsertKeyFrame(0, from.Value);
}
return ani;
}
// CompositionObject Vector3 animation
public static void BeginVector3Animation(this CompositionObject compObj, String propertyPath, Vector3 to, Vector3?from, TimeSpan duration, TimeSpan?delay, CompositionEasingFunction ease)
{
compObj.StartAnimation(propertyPath, compObj.Compositor.CreateVector3KeyFrameAnimation(to, from, duration, delay, ease));
}
static public void TranslateY(this UIElement element, double milliseconds, double start, double end, CompositionEasingFunction easingFunction = null)
{
ElementCompositionPreview.SetIsTranslationEnabled(element, true);
element.StartAnimation("Translation.Y", CreateScalarAnimation(milliseconds, start, end, easingFunction));
}
static public void Blur(this UIElement element, double milliseconds, double start, double end, CompositionEasingFunction easingFunction = null)
{
var brush = CreateBlurEffectBrush();
element.SetBrush(brush);
brush.StartAnimation("Blur.BlurAmount", CreateScalarAnimation(milliseconds, start, end, easingFunction));
}
public static Task StartOpacityAnimationAsync(this Visual visual, float?from = null, float to = 1.0f,
double duration = 800, int delay = 0, CompositionEasingFunction easing = null,
AnimationIterationBehavior iterationBehavior = AnimationIterationBehavior.Count)
{
CompositionScopedBatch batch;
var compositor = visual.Compositor;
var taskSource = new TaskCompletionSource <bool>();
void Completed(object o, CompositionBatchCompletedEventArgs e)
{
batch.Completed -= Completed;
taskSource.SetResult(true);
}
batch = compositor.CreateScopedBatch(CompositionBatchTypes.Animation);
batch.Completed += Completed;
visual.StartAnimation("Opacity",
compositor.CreateScalarKeyFrameAnimation(from, to, duration, delay, easing, iterationBehavior));
batch.End();
return(taskSource.Task);
}
public static Task StartTranslationAnimationAsync(this UIElement element, AnimationAxis axis, float?from = null, float to = 0,
double duration = 800, int delay = 0, CompositionEasingFunction easing = null,
AnimationIterationBehavior iterationBehavior = AnimationIterationBehavior.Count)
{
CompositionScopedBatch batch;
ElementCompositionPreview.SetIsTranslationEnabled(element, true);
var visual = element.Visual();
var compositor = visual.Compositor;
var taskSource = new TaskCompletionSource <bool>();
void Completed(object o, CompositionBatchCompletedEventArgs e)
{
batch.Completed -= Completed;
taskSource.SetResult(true);
}
batch = compositor.CreateScopedBatch(CompositionBatchTypes.Animation);
batch.Completed += Completed;
visual.StartAnimation($"Translation.{axis}", compositor.CreateScalarKeyFrameAnimation(from, to, duration, delay, easing, iterationBehavior));
batch.End();
return(taskSource.Task);
}
/// <summary>
/// Inserts a KeyFrame in the KeyFrameAnimation by converting
/// the given Expression to appropriate string
/// </summary>
/// <param name="normalizedProgressKey">The time the key frame should occur at, expressed as
/// a percentage of the animation Duration. Allowed value is from 0.0 to 1.0.</param>
/// <param name="expression">The expression which has to be converted to string to calculate the value of the KeyFrame.</param>
/// <param name="easingFunction">The easing function to use when interpolating between frames.</param>
public void InsertExpressionKeyFrame(float normalizedProgressKey, Expression <CompositionLambda <T> > expression,
CompositionEasingFunction easingFunction = null)
{
Animation.InsertExpressionKeyFrame(normalizedProgressKey, expression, easingFunction);
}
public static Task StartSizeAnimationAsync(this Visual visual, Vector2?from = null, Vector2?to = null,
double duration = 800, int delay = 0, CompositionEasingFunction easing = null,
AnimationIterationBehavior iterationBehavior = AnimationIterationBehavior.Count)
{
CompositionScopedBatch batch;
var compositor = visual.Compositor;
var taskSource = new TaskCompletionSource <bool>();
void Completed(object o, CompositionBatchCompletedEventArgs e)
{
batch.Completed -= Completed;
taskSource.SetResult(true);
}
batch = compositor.CreateScopedBatch(CompositionBatchTypes.Animation);
batch.Completed += Completed;
if (to == null)
{
to = Vector2.One;
}
visual.StartAnimation("Size",
compositor.CreateVector2KeyFrameAnimation(from, to.Value, duration, delay, easing, iterationBehavior));
batch.End();
return(taskSource.Task);
}
public static ScalarKeyFrameAnimation CreateScalarKeyFrameAnimation(this Compositor compositor, float to, double duration, CompositionEasingFunction easing)
{
var animation = compositor.CreateScalarKeyFrameAnimation();
animation.Duration = TimeSpan.FromMilliseconds(duration);
animation.InsertKeyFrame(1.0f, to, easing);
return animation;
}
public static Vector3KeyFrameAnimation CreateVector3KeyFrameAnimation(this Compositor compositor, Vector2 to, double duration, CompositionEasingFunction easing)
{
var animation = compositor.CreateVector3KeyFrameAnimation();
animation.Duration = TimeSpan.FromMilliseconds(duration);
animation.InsertKeyFrame(1.0f, new Vector3(to, 1.0f), easing);
return animation;
}
public static QuaternionKeyFrameAnimation AddKeyFrame(this QuaternionKeyFrameAnimation animation, float normalizedProgressKey, Quaternion value, CompositionEasingFunction ease = null)
{
animation.InsertKeyFrame(normalizedProgressKey, value, ease);
return animation;
}
public static void StartTranslationAnimation(this UIElement element, AnimationAxis axis, float?from = null, float to = 0,
double duration = 800, int delay = 0, CompositionEasingFunction easing = null, Action completed = null,
AnimationIterationBehavior iterationBehavior = AnimationIterationBehavior.Count)
{
CompositionScopedBatch batch = null;
ElementCompositionPreview.SetIsTranslationEnabled(element, true);
var visual = element.Visual();
var compositor = visual.Compositor;
if (completed != null)
{
batch = compositor.CreateScopedBatch(CompositionBatchTypes.Animation);
batch.Completed += (s, e) => completed();
}
visual.StartAnimation($"Translation.{axis}", compositor.CreateScalarKeyFrameAnimation(from, to, duration, delay, easing, iterationBehavior));
batch?.End();
}
/// <summary>
/// Adds a Vector3KeyFrame with X Y & Z components.
/// </summary>
/// <param name="animation"></param>
/// <param name="normalizedProgressKey"></param>
/// <param name="x"></param>
/// <param name="y"></param>
/// <param name="z"></param>
/// <param name="ease"></param>
/// <returns></returns>
public static Vector3KeyFrameAnimation AddKeyFrame(this Vector3KeyFrameAnimation animation, float normalizedProgressKey, float x, float y, float z, CompositionEasingFunction ease = null)
{
animation.InsertKeyFrame(normalizedProgressKey, new Vector3(x, y, z), ease);
return animation;
}
/// <summary>
/// Adds a Vector3KeyFrame where the X & Y components are set to the input value and the Z component defaults to 1f.
/// </summary>
/// <param name="animation"></param>
/// <param name="normalizedProgressKey"></param>
/// <param name="value"></param>
/// <param name="ease"></param>
/// <returns></returns>
public static Vector3KeyFrameAnimation AddScaleKeyFrame(this Vector3KeyFrameAnimation animation, float normalizedProgressKey, float value, CompositionEasingFunction ease = null)
{
animation.InsertKeyFrame(normalizedProgressKey, new Vector3(value, value, 1f), ease);
return animation;
}
public static T AddKeyFrame<T>(this T animation, float normalizedProgressKey, string expression, CompositionEasingFunction ease = null) where T : KeyFrameAnimation
{
animation.InsertExpressionKeyFrame(normalizedProgressKey, expression, ease);
return animation;
}
public static Task StartClipAnimationAsync(this Visual visual, ClipAnimationDirection direction, float to,
double duration = 800, int delay = 0, CompositionEasingFunction easing = null,
AnimationIterationBehavior iterationBehavior = AnimationIterationBehavior.Count)
{
CompositionScopedBatch batch;
if (visual.Size.X.Equals(0) || visual.Size.Y.Equals(0))
{
throw new ArgumentException("The visual is not properly sized.");
}
var compositor = visual.Compositor;
if (visual.Clip == null)
{
var clip = compositor.CreateInsetClip();
visual.Clip = clip;
}
var taskSource = new TaskCompletionSource <bool>();
void Completed(object o, CompositionBatchCompletedEventArgs e)
{
batch.Completed -= Completed;
taskSource.SetResult(true);
}
batch = compositor.CreateScopedBatch(CompositionBatchTypes.Animation);
batch.Completed += Completed;
visual.Clip.StartAnimation($"{direction}Inset",
compositor.CreateScalarKeyFrameAnimation(null, to, duration, delay, easing, iterationBehavior));
batch.End();
return(taskSource.Task);
}
// Create Vector2 animation from compositor
public static Vector2KeyFrameAnimation CreateVector2KeyFrameAnimation(this Compositor compositor, Vector2 to, Vector2?from, TimeSpan duration, TimeSpan?delay, CompositionEasingFunction ease)
{
// Set duration and delay time
Vector2KeyFrameAnimation ani = compositor.CreateVector2KeyFrameAnimation();
ani.Duration = duration;
if (delay.HasValue)
{
ani.DelayTime = delay.Value;
}
// Insert "to" and "from" keyframes
ani.InsertKeyFrame(1, to, ease ?? compositor.CreateLinearEasingFunction());
if (from.HasValue)
{
ani.InsertKeyFrame(0, from.Value);
}
return(ani);
}
public static Task StartClipAnimationAsync(this FrameworkElement element, ClipAnimationDirection direction, float to,
double duration = 800, int delay = 0, CompositionEasingFunction easing = null,
AnimationIterationBehavior iterationBehavior = AnimationIterationBehavior.Count)
{
CompositionScopedBatch batch;
var visual = element.Visual();
// After we get the Visual of the View, we need to SIZE it 'cause by design the
// Size is (0,0). Without doing this, clipping will not work.
visual.Size = element.RenderSize.ToVector2();
var compositor = visual.Compositor;
if (visual.Clip == null)
{
var clip = compositor.CreateInsetClip();
visual.Clip = clip;
}
var taskSource = new TaskCompletionSource <bool>();
void Completed(object o, CompositionBatchCompletedEventArgs e)
{
batch.Completed -= Completed;
taskSource.SetResult(true);
}
batch = compositor.CreateScopedBatch(CompositionBatchTypes.Animation);
batch.Completed += Completed;
visual.Clip.StartAnimation($"{direction}Inset",
compositor.CreateScalarKeyFrameAnimation(null, to, duration, delay, easing, iterationBehavior));
batch.End();
return(taskSource.Task);
}
PathKeyFrameAnimation CreatePathKeyFrameAnimation(float initialProgress, CompositionPath initialValue, CompositionEasingFunction initialEasingFunction)
{
var result = _c.CreatePathKeyFrameAnimation();
result.Duration = TimeSpan.FromTicks(c_durationTicks);
result.InsertKeyFrame(initialProgress, initialValue, initialEasingFunction);
return(result);
}
public KeyFrame(float normalizedProgressKey, T value, CompositionEasingFunction easing = null)
{
Key = normalizedProgressKey;
Value = value;
Easing = easing;
}
private static KeyFrameAnimation CreateAnimationByType(Compositor compositor, VisualPropertyType type,
double duration = 800, double delay = 0, CompositionEasingFunction easing = null)
{
KeyFrameAnimation animation;
switch (type)
{
case VisualPropertyType.Offset:
case VisualPropertyType.Scale:
animation = compositor.CreateVector3KeyFrameAnimation();
break;
case VisualPropertyType.Size:
animation = compositor.CreateVector2KeyFrameAnimation();
break;
case VisualPropertyType.Opacity:
case VisualPropertyType.RotationAngleInDegrees:
animation = compositor.CreateScalarKeyFrameAnimation();
break;
default:
return(null);
}
animation.InsertExpressionKeyFrame(1.0f, "this.FinalValue", easing);
animation.Duration = TimeSpan.FromMilliseconds(duration);
animation.DelayTime = TimeSpan.FromMilliseconds(delay);
animation.Target = type.ToString();
return(animation);
}
public static void StartOpacityAnimation(this Visual visual, float?from = null, float to = 1.0f,
double duration = 800, int delay = 0, CompositionEasingFunction easing = null, Action completed = null,
AnimationIterationBehavior iterationBehavior = AnimationIterationBehavior.Count)
{
CompositionScopedBatch batch = null;
var compositor = visual.Compositor;
if (completed != null)
{
batch = compositor.CreateScopedBatch(CompositionBatchTypes.Animation);
batch.Completed += (s, e) => completed();
}
visual.StartAnimation("Opacity",
compositor.CreateScalarKeyFrameAnimation(from, to, duration, delay, easing, iterationBehavior));
batch?.End();
}
static public CompositionAnimation CreateVector3Animation(double milliseconds, Vector3 start, Vector3 end, CompositionEasingFunction easingFunction = null)
{
var animation = Window.Current.Compositor.CreateVector3KeyFrameAnimation();
animation.InsertKeyFrame(0.0f, start);
animation.InsertKeyFrame(1.0f, end);
animation.Duration = TimeSpan.FromMilliseconds(milliseconds);
return(animation);
}
/// <summary>
/// Inserts a KeyFrame in the KeyFrameAnimation by converting
/// the given Expression to appropriate string
/// </summary>
/// <typeparam name="T">Type of the Expression</typeparam>
/// <param name="animation">KeyFrameAnimation</param>
/// <param name="normalizedProgressKey">The time the key frame should occur at, expressed as
/// a percentage of the animation Duration. Allowed value is from 0.0 to 1.0.</param>
/// <param name="expression">The expression used to calculate the value of the key frame.</param>
/// <param name="easingFunction">Easing Function (optional)</param>
/// <returns>KeyFrameAnimation</returns>
public static KeyFrameAnimation InsertExpressionKeyFrame <T>(this KeyFrameAnimation animation, float normalizedProgressKey,
Expression <CompositionExpression <T> > expression, CompositionEasingFunction easingFunction = null)
{
var result = CompositionExpressionEngine.CreateCompositionExpression(expression);
animation.InsertExpressionKeyFrame(normalizedProgressKey, result.Expression, easingFunction);
animation.SetParameters(result.Parameters);
return(animation);
}
public static void StartTranslationAnimation(this UIElement element, Vector3?from = null, Vector3?to = null,
double duration = 800, int delay = 0, CompositionEasingFunction easing = null, Action completed = null,
AnimationIterationBehavior iterationBehavior = AnimationIterationBehavior.Count)
{
CompositionScopedBatch batch = null;
ElementCompositionPreview.SetIsTranslationEnabled(element, true);
var visual = element.Visual();
var compositor = visual.Compositor;
if (completed != null)
{
batch = compositor.CreateScopedBatch(CompositionBatchTypes.Animation);
batch.Completed += (s, e) => completed();
}
if (to == null)
{
to = Vector3.Zero;
}
visual.StartAnimation("Translation", compositor.CreateVector3KeyFrameAnimation(from, to.Value, duration, delay, easing, iterationBehavior));
batch?.End();
}
public static void EnableImplicitAnimation(this Visual visual, VisualPropertyType typeToAnimate,
double duration = 800, double delay = 0, CompositionEasingFunction easing = null)
{
var compositor = visual.Compositor;
var animationCollection = compositor.CreateImplicitAnimationCollection();
foreach (var type in GetValues <VisualPropertyType>())
{
if (!typeToAnimate.HasFlag(type))
{
continue;
}
var animation = CreateAnimationByType(compositor, type, duration, delay, easing);
if (animation != null)
{
animationCollection[type.ToString()] = animation;
}
}
visual.ImplicitAnimations = animationCollection;
}
ColorKeyFrameAnimation CreateColorKeyFrameAnimation(float initialProgress, Color initialValue, CompositionEasingFunction initialEasingFunction)
{
var result = _c.CreateColorKeyFrameAnimation();
result.Duration = TimeSpan.FromTicks(c_durationTicks);
result.InterpolationColorSpace = CompositionColorSpace.Rgb;
result.InsertKeyFrame(initialProgress, initialValue, initialEasingFunction);
return(result);
}
static public CompositionAnimation CreateScalarAnimation(double milliseconds, double start, double end, CompositionEasingFunction easingFunction = null)
{
var animation = Window.Current.Compositor.CreateScalarKeyFrameAnimation();
animation.InsertKeyFrame(0.0f, (float)start, easingFunction);
animation.InsertKeyFrame(1.0f, (float)end, easingFunction);
animation.Duration = TimeSpan.FromMilliseconds(milliseconds);
return(animation);
}
public static void BeginVector3Animation(UIElement element, string propertyPath, Vector3 to, Vector3? from, TimeSpan duration, TimeSpan? delay, CompositionEasingFunction ease)
{
element.GetVisual().BeginVector3Animation(propertyPath, to, from, duration, delay, ease);
}
static public void Fade(this UIElement element, double milliseconds, double start, double end, CompositionEasingFunction easingFunction = null)
{
element.StartAnimation(nameof(Visual.Opacity), CreateScalarAnimation(milliseconds, start, end, easingFunction));
}
public static void BeginVector3Animation(this CompositionObject compObj, string propertyPath, Vector3 to, Vector3? from, TimeSpan duration, TimeSpan? delay, CompositionEasingFunction ease)
{
compObj.StartAnimation(propertyPath,
compObj.Compositor.CreateVector3KeyFrameAnimation(to, from, duration, delay, ease));
}
static public void Scale(this FrameworkElement element, double milliseconds, double start, double end, CompositionEasingFunction easingFunction = null)
{
element.SetCenterPoint(element.ActualWidth / 2.0, element.ActualHeight / 2.0);
var vectorStart = new Vector3((float)start, (float)start, 0);
var vectorEnd = new Vector3((float)end, (float)end, 0);
element.StartAnimation(nameof(Visual.Scale), CreateVector3Animation(milliseconds, vectorStart, vectorEnd, easingFunction));
}
public static Vector3KeyFrameAnimation CreateVector3KeyFrameAnimation(this Compositor compositor, Vector3?from, Vector3 to,
double duration, double delay = 0, CompositionEasingFunction easing = null, AnimationIterationBehavior iterationBehavior = AnimationIterationBehavior.Count)
{
var animation = compositor.CreateVector3KeyFrameAnimation();
animation.Duration = TimeSpan.FromMilliseconds(duration);
animation.DelayTime = TimeSpan.FromMilliseconds(delay);
if (from.HasValue)
{
animation.InsertKeyFrame(0.0f, from.Value, easing);
}
animation.InsertKeyFrame(1.0f, to, easing);
animation.IterationBehavior = iterationBehavior;
return(animation);
}
/// <summary> Inserts a KeyFrame whose value is calculated using the specified ExpressionNode. </summary>
/// <param name="normalizedProgressKey">The time the key frame should occur at, expressed as a percentage of the animation Duration. Allowed value is from 0.0 to 1.0.</param>
/// <param name="expressionNode">The root ExpressionNode that represents the ExpressionAnimation.</param>
/// <param name="easing">The easing function to use when interpolating between frames.</param>
public static void InsertExpressionKeyFrame(this KeyFrameAnimation keyframeAnimation, float normalizedProgressKey, ExpressionNode expressionNode, CompositionEasingFunction easing = null)
{
keyframeAnimation.InsertExpressionKeyFrame(normalizedProgressKey, expressionNode.ToExpressionString(), easing);
expressionNode.SetAllParameters(keyframeAnimation);
}
// UIElement Vector3 animation
public static void BeginVector3Animation(UIElement element, String propertyPath, Vector3 to, Vector3?from, TimeSpan duration, TimeSpan?delay, CompositionEasingFunction ease)
{
element.GetVisual().BeginVector3Animation(propertyPath, to, from, duration, delay, ease);
}
