private void AnimateToLayerHelper(SpriteVisual target)
{
// Create AnimationGroup for target visual propery animation
CompositionAnimationGroup animationGroup = _compositor.CreateAnimationGroup();
// Scale
Vector3KeyFrameAnimation scaleAnimation = _compositor.CreateVector3KeyFrameAnimation();
scaleAnimation.InsertKeyFrame(0.0f, target.Scale);
scaleAnimation.InsertKeyFrame(1.0f, this.DepthTreatment.ChildScale);
scaleAnimation.Duration = ConfigurationConstants.FocusAnimationDuration;
scaleAnimation.Target = "Scale";
animationGroup.Add(scaleAnimation);
target.StartAnimationGroup(animationGroup);
// Update item color to match items in new layer. Preserve content if any.
var brushType = target.Brush.GetType();
if (brushType != typeof(CompositionSurfaceBrush) && brushType != typeof(CompositionEffectBrush))
{
target.Brush = LayerColor;
}
}
private void EnsureFunctionBarAninmation(Compositor compositor)
{
if (_functionBarAnimation != null)
{
return;
}
ConnectedAnimationService animationService = ConnectedAnimationService.GetForCurrentView();
_functionBarAnimation = compositor.CreateAnimationGroup();
ScalarKeyFrameAnimation offsetAnimation = compositor.CreateScalarKeyFrameAnimation();
offsetAnimation.Target = "Offset.x";
offsetAnimation.InsertKeyFrame(0, -5.0f);
offsetAnimation.InsertKeyFrame(1, 0, animationService.DefaultEasingFunction);
offsetAnimation.Duration = animationService.DefaultDuration;
ScalarKeyFrameAnimation opacityAnimation = compositor.CreateScalarKeyFrameAnimation();
opacityAnimation.Target = "Opacity";
opacityAnimation.InsertKeyFrame(0, 0);
opacityAnimation.InsertKeyFrame(1, 1, animationService.DefaultEasingFunction);
opacityAnimation.Duration = animationService.DefaultDuration;
_functionBarAnimation.Add(offsetAnimation);
_functionBarAnimation.Add(opacityAnimation);
}
public CompositionAnimationGroup GetShadowFocusAnimations(Compositor compositor, Layer layer)
{
var newShadowBlurRadius = BlurRadius + _focusShadowBlurRadiusIncreaseAmount;
var oldShadowOffset = Offset;
var additionalShadowOffsetAmount = _focusShadowOffsetIncreaseAmount;
var newShadowOffset = new Vector3(oldShadowOffset.X + additionalShadowOffsetAmount, oldShadowOffset.Y +
additionalShadowOffsetAmount, oldShadowOffset.Z + additionalShadowOffsetAmount);
// Create AnimationGroup
CompositionAnimationGroup animationGroup = compositor.CreateAnimationGroup();
// Blur Radius
ScalarKeyFrameAnimation shadowBlurAnimation = compositor.CreateScalarKeyFrameAnimation();
shadowBlurAnimation.InsertKeyFrame(0.0f, BlurRadius);
shadowBlurAnimation.InsertKeyFrame(1.0f, newShadowBlurRadius);
shadowBlurAnimation.Duration = ConfigurationConstants.FocusAnimationDuration;
shadowBlurAnimation.Target = "BlurRadius";
animationGroup.Add(shadowBlurAnimation);
// Offset
Vector3KeyFrameAnimation shadowOffsetAnimation = compositor.CreateVector3KeyFrameAnimation();
shadowOffsetAnimation.InsertKeyFrame(0.0f, Offset);
shadowOffsetAnimation.InsertKeyFrame(1.0f, newShadowOffset);
shadowOffsetAnimation.Duration = ConfigurationConstants.FocusAnimationDuration;
shadowOffsetAnimation.Target = "Offset";
animationGroup.Add(shadowOffsetAnimation);
return(animationGroup);
}
private static void AssignReorderAnimation(ListViewBase listView, TimeSpan duration)
{
Compositor compositor = ElementCompositionPreview.GetElementVisual(listView).Compositor;
ImplicitAnimationCollection animationCollection = (ImplicitAnimationCollection)listView.GetValue(ReorderAnimationProperty);
if (animationCollection is null)
{
animationCollection = compositor.CreateImplicitAnimationCollection();
listView.SetValue(ReorderAnimationProperty, animationCollection);
}
if (duration == TimeSpan.Zero)
{
animationCollection.Remove(nameof(Visual.Offset));
}
else
{
Vector3KeyFrameAnimation offsetAnimation = compositor.CreateVector3KeyFrameAnimation();
offsetAnimation.InsertExpressionKeyFrame(1.0f, "this.FinalValue");
offsetAnimation.Duration = duration;
offsetAnimation.Target = nameof(Visual.Offset);
CompositionAnimationGroup animationGroup = compositor.CreateAnimationGroup();
animationGroup.Add(offsetAnimation);
animationCollection[nameof(Visual.Offset)] = animationGroup;
}
}
private CompositionAnimationGroup CreateOffsetAnimation()
{
Vector3KeyFrameAnimation offsetAnimation = _compositor.CreateVector3KeyFrameAnimation();
offsetAnimation.InsertExpressionKeyFrame(1.0f, "this.FinalValue");
offsetAnimation.Duration = TimeSpan.FromSeconds(.4);
offsetAnimation.Target = "Offset";
ScalarKeyFrameAnimation fadeAnimation = _compositor.CreateScalarKeyFrameAnimation();
fadeAnimation.InsertKeyFrame(1f, 0.8f);
fadeAnimation.Duration = TimeSpan.FromSeconds(.4);
fadeAnimation.Target = "Opacity";
ScalarKeyFrameAnimation rotationAnimation = _compositor.CreateScalarKeyFrameAnimation();
rotationAnimation.InsertKeyFrame(.5f, 0.160f);
rotationAnimation.InsertKeyFrame(1f, 0f);
rotationAnimation.Duration = TimeSpan.FromSeconds(.4);
rotationAnimation.Target = "RotationAngle";
CompositionAnimationGroup animationGroup = _compositor.CreateAnimationGroup();
animationGroup.Add(offsetAnimation);
animationGroup.Add(rotationAnimation);
animationGroup.Add(fadeAnimation);
return(animationGroup);
}
private void Batch_Completed(object sender, CompositionBatchCompletedEventArgs args)
{
// Start the second part of the animations
// Get offset/size of new active scenario button
var activeScenarioNum = _scenarios.IndexOf(_currentScenario);
var buttonWidth = (float)ProgressIndicatorStackPanel.Children[activeScenarioNum].RenderSize.Width;
var buttonOffset = ProgressIndicatorStackPanel.Children[activeScenarioNum].GetOffset(ProgressIndicatorStackPanel);
var offsetDeltaX = Math.Abs(buttonOffset.X - _activeScenarioVisualIndicator.Offset.X);
CompositionAnimationGroup animationGroup = _compositor.CreateAnimationGroup();
// Animate line size
ScalarKeyFrameAnimation sizeShrinkAnimation = _compositor.CreateScalarKeyFrameAnimation();
sizeShrinkAnimation.Duration = ConfigurationConstants.NavAnimationDuration;
sizeShrinkAnimation.InsertKeyFrame(0.0f, _activeScenarioVisualIndicator.Size.X);
sizeShrinkAnimation.InsertKeyFrame(1.0f, buttonWidth);
sizeShrinkAnimation.Target = "Size.X";
animationGroup.Add(sizeShrinkAnimation);
if (buttonOffset.X > _activeScenarioVisualIndicator.Offset.X)
{
// Animate line to new offset
ScalarKeyFrameAnimation offsetAnimation = _compositor.CreateScalarKeyFrameAnimation();
offsetAnimation.InsertKeyFrame(0.0f, _activeScenarioVisualIndicator.Offset.X);
offsetAnimation.InsertKeyFrame(1.0f, buttonOffset.X);
offsetAnimation.Duration = ConfigurationConstants.NavAnimationDuration;
offsetAnimation.Target = "Offset.X";
animationGroup.Add(offsetAnimation);
}
_activeScenarioVisualIndicator.StartAnimationGroup(animationGroup);
}
private static CompositionAnimationGroup CreateOffsetAnimation(Compositor compositor)
{
// Define Offset Animation for the Animation group
Vector3KeyFrameAnimation offsetAnimation = compositor.CreateVector3KeyFrameAnimation();
offsetAnimation.InsertExpressionKeyFrame(1.0f, "this.FinalValue");
offsetAnimation.Duration = TimeSpan.FromSeconds(.2);
// Define Animation Target for this animation to animate using definition.
offsetAnimation.Target = "Offset";
//// Define Rotation Animation for Animation Group.
//ScalarKeyFrameAnimation rotationAnimation = compositor.CreateScalarKeyFrameAnimation();
//rotationAnimation.InsertKeyFrame(.5f, 0.160f);
//rotationAnimation.InsertKeyFrame(1f, 0f);
//rotationAnimation.Duration = TimeSpan.FromSeconds(.4);
//// Define Animation Target for this animation to animate using definition.
//rotationAnimation.Target = "RotationAngle";
// Add Animations to Animation group.
CompositionAnimationGroup animationGroup = compositor.CreateAnimationGroup();
animationGroup.Add(offsetAnimation);
//animationGroup.Add(rotationAnimation);
return(animationGroup);
}
private void EnsureAnimation()
{
if (_animationGroup != null)
{
return;
}
var linear = Window.Current.Compositor.CreateLinearEasingFunction();
_opacityAnimation = Window.Current.Compositor.CreateScalarKeyFrameAnimation();
_opacityAnimation.DelayBehavior = AnimationDelayBehavior.SetInitialValueBeforeDelay;
_opacityAnimation.DelayTime = TimeSpan.FromMilliseconds(200);
_opacityAnimation.InsertKeyFrame(0, 0);
_opacityAnimation.InsertKeyFrame(0.2f, 0, linear);
_opacityAnimation.InsertKeyFrame(1, 1, linear);
_opacityAnimation.Duration = TimeSpan.FromMilliseconds(600);
_opacityAnimation.Target = nameof(Visual.Opacity);
_flyInTranslationAnimation = Window.Current.Compositor.CreateVector3KeyFrameAnimation();
_flyInTranslationAnimation.DelayBehavior = AnimationDelayBehavior.SetInitialValueBeforeDelay;
_flyInTranslationAnimation.DelayTime = TimeSpan.FromMilliseconds(200);
_flyInTranslationAnimation.InsertKeyFrame(0, new Vector3(0, 2000, 0));
_flyInTranslationAnimation.InsertKeyFrame(1, Vector3.Zero);
_flyInTranslationAnimation.Duration = TimeSpan.FromMilliseconds(600);
_flyInTranslationAnimation.Target = "Translation";
_animationGroup = Window.Current.Compositor.CreateAnimationGroup();
_animationGroup.Add(_opacityAnimation);
_animationGroup.Add(_flyInTranslationAnimation);
}
internal CompositionAnimationGroup GetCompositionAnimationGroup(UIElement parent)
{
Compositor compositor = ElementCompositionPreview.GetElementVisual(parent).Compositor;
CompositionAnimationGroup animations = compositor.CreateAnimationGroup();
foreach (IImplicitTimeline timeline in this)
{
animations.Add(timeline.GetAnimation(parent, out _));
}
return(animations);
}
private CompositionAnimationGroup CreateOpacityAnimation()
{
ScalarKeyFrameAnimation fadeAnimation = _compositor.CreateScalarKeyFrameAnimation();
fadeAnimation.InsertKeyFrame(1.0f, 0.0f);
fadeAnimation.Duration = TimeSpan.FromSeconds(.35);
fadeAnimation.Target = "Opacity";
CompositionAnimationGroup animationGroup = _compositor.CreateAnimationGroup();
animationGroup.Add(fadeAnimation);
return(animationGroup);
}
private static CompositionAnimationGroup CreateOffsetAnimation(Compositor compositor, double duration)
{
Vector3KeyFrameAnimation offsetAnimation = compositor.CreateVector3KeyFrameAnimation();
offsetAnimation.InsertExpressionKeyFrame(1.0f, "this.FinalValue");
offsetAnimation.Duration = TimeSpan.FromMilliseconds(duration);
offsetAnimation.Target = nameof(Visual.Offset);
CompositionAnimationGroup animationGroup = compositor.CreateAnimationGroup();
animationGroup.Add(offsetAnimation);
return(animationGroup);
}
public static CompositionAnimationGroup CreateListOffsetAnimationGroup(Compositor compositor)
{
Vector3KeyFrameAnimation offsetAnimation = compositor.CreateVector3KeyFrameAnimation();
offsetAnimation.InsertExpressionKeyFrame(1f, "this.FinalValue");
offsetAnimation.Duration = TimeSpan.FromMilliseconds(400);
offsetAnimation.Target = "Offset";
CompositionAnimationGroup animationGroup = compositor.CreateAnimationGroup();
animationGroup.Add(offsetAnimation);
return(animationGroup);
}
public static void SetupImplicitShowAnimations(UIElement target)
{
Compositor compositor = ElementCompositionPreview.GetElementVisual(target).Compositor;
CompositionAnimationGroup animations = compositor.CreateAnimationGroup();
ScalarKeyFrameAnimation scalarAnimation = compositor.CreateScalarKeyFrameAnimation();
scalarAnimation.InsertKeyFrame(0.0f, 0f);
scalarAnimation.InsertKeyFrame(1.0f, 1f);
scalarAnimation.Duration = TimeSpan.FromSeconds(3);
scalarAnimation.Target = nameof(Visual.Opacity);
animations.Add(scalarAnimation);
ElementCompositionPreview.SetImplicitShowAnimation(target, animations);
}
private CompositionAnimationGroup CreateLayoutAnimation(Compositor compositor)
{
var offsetAnimation = compositor.CreateVector3KeyFrameAnimation();
offsetAnimation.InsertExpressionKeyFrame(1.0f, "this.FinalValue");
offsetAnimation.Duration = TimeSpan.FromSeconds(0.5);
//Define Animation Target for this animation to animate using definition.
offsetAnimation.Target = nameof(Visual.Offset);
//Add Animations to Animation group.
CompositionAnimationGroup animationGroup = compositor.CreateAnimationGroup();
animationGroup.Add(offsetAnimation);
return(animationGroup);
}
private static CompositionAnimationGroup CreateOffsetAnimation(Compositor compositor)
{
// Define Offset Animation for the Animation group
Vector3KeyFrameAnimation offsetAnimation = compositor.CreateVector3KeyFrameAnimation();
offsetAnimation.InsertExpressionKeyFrame(1.0f, "this.FinalValue");
offsetAnimation.Duration = TimeSpan.FromSeconds(.3);
// Define Animation Target for this animation to animate using definition.
offsetAnimation.Target = "Offset";
// Add Animation to Animation group.
CompositionAnimationGroup animationGroup = compositor.CreateAnimationGroup();
animationGroup.Add(offsetAnimation);
return(animationGroup);
}
private void UpdateActiveScenarioIndicator(Scenario oldScenario)
{
oldScenario.IsActive = false;
_currentScenario.IsActive = true;
var activeScenarioNum = _scenarios.IndexOf(_currentScenario);
// Update nav active scenario indicator
// Get offset/size of new active scenario button
var buttonWidth = (float)ProgressIndicatorStackPanel.Children[activeScenarioNum].RenderSize.Width;
var buttonOffset = ProgressIndicatorStackPanel.Children[activeScenarioNum].GetOffset(ProgressIndicatorStackPanel);
var offsetDeltaX = Math.Abs(buttonOffset.X - _activeScenarioVisualIndicator.Offset.X);
// Scoped batch for first half of the animation
var batch = _compositor.CreateScopedBatch(CompositionBatchTypes.Animation);
batch.Completed += Batch_Completed;
CompositionAnimationGroup animationGroup = _compositor.CreateAnimationGroup();
// Animate line size
ScalarKeyFrameAnimation sizeGrowAnimation = _compositor.CreateScalarKeyFrameAnimation();
sizeGrowAnimation.Duration = ConfigurationConstants.NavAnimationDuration;
sizeGrowAnimation.InsertKeyFrame(0.0f, _activeScenarioVisualIndicator.Size.X);
sizeGrowAnimation.InsertKeyFrame(1.0f, offsetDeltaX + _activeScenarioVisualIndicator.Size.X);
sizeGrowAnimation.Target = "Size.X";
if (buttonOffset.X < _activeScenarioVisualIndicator.Offset.X)
{
// Add offset animation to size change, to make the line appear to move to the left
ScalarKeyFrameAnimation offsetAnimation = _compositor.CreateScalarKeyFrameAnimation();
offsetAnimation.InsertKeyFrame(0.0f, _activeScenarioVisualIndicator.Offset.X);
offsetAnimation.InsertKeyFrame(1.0f, buttonOffset.X);
offsetAnimation.Duration = ConfigurationConstants.NavAnimationDuration;
offsetAnimation.Target = "Offset.X";
animationGroup.Add(offsetAnimation);
}
animationGroup.Add(sizeGrowAnimation);
_activeScenarioVisualIndicator.StartAnimationGroup(animationGroup);
batch.End();
}
private void Dispose(bool IsDisposing)
{
_visual?.Dispose();
_visual = null;
_brush?.Dispose();
_brush = null;
_surface?.Dispose();
_surface = null;
_animations?.Dispose();
_animations = null;
if (IsDisposing)
{
GC.SuppressFinalize(this);
}
}
public static ImplicitAnimationCollection CreateReorderAnimationCollection(MUXC.ItemsRepeater itemsRepeater)
{
Compositor compositor = ElementCompositionPreview.GetElementVisual(itemsRepeater).Compositor;
Vector3KeyFrameAnimation offsetAnimation = compositor.CreateVector3KeyFrameAnimation();
offsetAnimation.InsertExpressionKeyFrame(1.0f, "this.FinalValue");
offsetAnimation.Duration = TimeSpan.FromMilliseconds(ReorderAnimationDuration);
offsetAnimation.Target = nameof(Visual.Offset);
CompositionAnimationGroup animationGroup = compositor.CreateAnimationGroup();
animationGroup.Add(offsetAnimation);
ImplicitAnimationCollection animationCollection = compositor.CreateImplicitAnimationCollection();
animationCollection[nameof(Visual.Offset)] = animationGroup;
return(animationCollection);
}
public void AnimateAddedVisual(SpriteVisual target)
{
float currShadowBlurRadius = 0f;
Vector3 currShadowOffset = new Vector3();
if (target.Shadow != null)
{
currShadowBlurRadius = ((DropShadow)(target.Shadow)).BlurRadius;
currShadowOffset = ((DropShadow)(target.Shadow)).Offset;
}
else
{
DropShadow shadow = _compositor.CreateDropShadow();
shadow.Color = ConfigurationConstants.ShadowColor;
shadow.Opacity = ConfigurationConstants.ShadowOpacity;
target.Shadow = shadow;
}
// Create AnimationGroup for shadow change animation
CompositionAnimationGroup animationGroup = _compositor.CreateAnimationGroup();
// Animate shadow blur radius change
ScalarKeyFrameAnimation shadowBlurAnimation = _compositor.CreateScalarKeyFrameAnimation();
shadowBlurAnimation.InsertKeyFrame(0.0f, currShadowBlurRadius);
shadowBlurAnimation.InsertKeyFrame(1.0f, DepthTreatment.ShadowTreatment.BlurRadius);
shadowBlurAnimation.Duration = ConfigurationConstants.FocusAnimationDuration;
shadowBlurAnimation.Target = "BlurRadius";
animationGroup.Add(shadowBlurAnimation);
// Animate shadow offset change
Vector3KeyFrameAnimation shadowOffsetAnimation = _compositor.CreateVector3KeyFrameAnimation();
shadowOffsetAnimation.InsertKeyFrame(0.0f, currShadowOffset);
shadowOffsetAnimation.InsertKeyFrame(1.0f, DepthTreatment.ShadowTreatment.Offset);
shadowOffsetAnimation.Duration = ConfigurationConstants.FocusAnimationDuration;
shadowOffsetAnimation.Target = "Offset";
animationGroup.Add(shadowOffsetAnimation);
target.Shadow.StartAnimationGroup(animationGroup);
AnimateToLayerHelper(target);
}
public CompositionAnimationGroup GetVisualFocusAnimations(Compositor compositor, Layer layer)
{
var oldscale = ChildScale;
var newScale = new Vector3(oldscale.X * _focusScaleIncreaseFactor, oldscale.Y * _focusScaleIncreaseFactor, oldscale.Z);
// Create AnimationGroup
CompositionAnimationGroup animationGroup = compositor.CreateAnimationGroup();
// Scale
Vector3KeyFrameAnimation scaleAnimation = compositor.CreateVector3KeyFrameAnimation();
scaleAnimation.InsertKeyFrame(0.0f, oldscale);
scaleAnimation.InsertKeyFrame(1.0f, newScale);
scaleAnimation.Duration = ConfigurationConstants.FocusAnimationDuration;
scaleAnimation.Target = "Scale";
animationGroup.Add(scaleAnimation);
return(animationGroup);
}
private void EnsureImplicitAnimations(FrameworkElement element)
{
if (_implicitAnimations == null)
{
Compositor compositor = ElementCompositionPreview.GetElementVisual(this).Compositor;
CubicBezierEasingFunction easeIn = compositor.CreateCubicBezierEasingFunction(new Vector2(0.215f, 0.61f), new Vector2(0.355f, 1f));
Vector3KeyFrameAnimation offsetAnimation = compositor.CreateVector3KeyFrameAnimation();
offsetAnimation.Target = nameof(Visual.Offset);
offsetAnimation.InsertExpressionKeyFrame(1.0f, "this.FinalValue", easeIn);
offsetAnimation.Duration = TimeSpan.FromMilliseconds(500);
CompositionAnimationGroup animationGroup = compositor.CreateAnimationGroup();
animationGroup.Add(offsetAnimation);
_implicitAnimations = compositor.CreateImplicitAnimationCollection();
_implicitAnimations[nameof(Visual.Offset)] = animationGroup;
}
}
private void CreateAnimation(Size TargetSize, Vector3 StartOffset, bool OnTop, TimeSpan Duration)
{
if (easing == null)
{
easing = _compositor.CreateCubicBezierEasingFunction(new Vector2(0.17f, 0.67f), new Vector2(0.44f, 0.999f));
}
_animations = _compositor.CreateAnimationGroup();
var scalean = _compositor.CreateVector3KeyFrameAnimation();
scalean.InsertKeyFrame(0f, Vector3.Zero);
scalean.InsertKeyFrame(0.2f, Vector3.One, easing);
scalean.InsertKeyFrame(1f, new Vector3(0.06f, 0.06f, 1f), easing);
scalean.Duration = Duration;
scalean.Target = "Scale";
scalean.StopBehavior = AnimationStopBehavior.SetToInitialValue;
var offsetan = _compositor.CreateVector3KeyFrameAnimation();
offsetan.InsertKeyFrame(0f, StartOffset, easing);
if (OnTop)
{
//在上半部分
offsetan.InsertKeyFrame(1f, new Vector3(rnd.Next(-(int)TargetSize.Width, (int)TargetSize.Width) + (int)TargetSize.Width / 2, rnd.Next(-(int)(TargetSize.Height * 1.5), 0) + (int)TargetSize.Height / 2, 0f), easing);
}
else
{
//在下半部分
offsetan.InsertKeyFrame(1f, new Vector3(rnd.Next(-(int)TargetSize.Width, (int)TargetSize.Width) + (int)TargetSize.Width / 2, rnd.Next(0, (int)(TargetSize.Height * 1.5)) + (int)TargetSize.Height / 2, 0f), easing);
}
offsetan.Duration = Duration;
offsetan.Target = "Offset";
offsetan.StopBehavior = AnimationStopBehavior.SetToInitialValue;
_animations.Add(scalean);
_animations.Add(offsetan);
}
public void SetDepthTreatments(DepthTreatmentConfigurations depthTreatmentConfig)
{
DepthTreatment = depthTreatmentConfig;
RefreshApplyDepthTreatments();
// Shadow Focus Animation
_shadowAnimationGroup = DepthTreatment.ShadowTreatment.GetShadowFocusAnimations(_compositor, this);
// Additional Focus Animations
_visualAnimationGroup = DepthTreatment.GetVisualFocusAnimations(_compositor, this);
// Create reversed animation groups to run on unfocus
_reversedShadowAnimationGroup = _compositor.CreateAnimationGroup();
_reversedVisualAnimationGroup = _compositor.CreateAnimationGroup();
foreach (KeyFrameAnimation animation in _shadowAnimationGroup)
{
animation.Direction = AnimationDirection.Reverse;
_reversedShadowAnimationGroup.Add(animation);
}
foreach (KeyFrameAnimation animation in _visualAnimationGroup)
{
animation.Direction = AnimationDirection.Reverse;
_reversedVisualAnimationGroup.Add(animation);
}
}
public static void StartAnimation(this CompositionObject compositionObject, CompositionAnimationGroup animation)
{
compositionObject.StartAnimationGroup(animation);
}
/// <summary>
/// Initializes the Composition elements
/// </summary>
private void InitComposition()
{
// Compositor
_compositor = ElementCompositionPreview.GetElementVisual(this).Compositor;
// CompositionGenerator
_generator = CompositionGeneratorFactory.GetCompositionGenerator(_compositor);
// Fade Out Animation
_fadeOutAnimation = _compositor.CreateScalarKeyFrameAnimation();
_fadeOutAnimation.InsertKeyFrame(1f, 0);
_fadeOutAnimation.Duration = TransitionDuration;
// Fade In Animation
_fadeInAnimation = _compositor.CreateScalarKeyFrameAnimation();
_fadeInAnimation.InsertKeyFrame(1f, 1);
_fadeInAnimation.Duration = TransitionDuration;
// Color Animation
_colorAnimation = _compositor.CreateColorKeyFrameAnimation();
_colorAnimation.Duration = TransitionDuration;
// Offset Animation
_offsetAnimation = _compositor.CreateVector3KeyFrameAnimation();
_offsetAnimation.Target = "Offset";
_offsetAnimation.Duration = TransitionDuration;
_offsetAnimation.InsertKeyFrame(1f, Vector3.Zero);
// Alignment animations
_alignXAnimation = _compositor.CreateScalarKeyFrameAnimation();
_alignXAnimation.Duration = AlignmentTransitionDuration;
_alignYAnimation = _compositor.CreateScalarKeyFrameAnimation();
_alignYAnimation.Duration = AlignmentTransitionDuration;
// ZoomIn Animation Group
_scaleAnimation = _compositor.CreateVector3KeyFrameAnimation();
_scaleAnimation.Target = "Scale";
_scaleAnimation.InsertKeyFrame(1f, Vector3.One);
_scaleAnimation.Duration = TransitionDuration;
_zoomInAnimationGroup = _compositor.CreateAnimationGroup();
_zoomInAnimationGroup.Add(_scaleAnimation);
_zoomInAnimationGroup.Add(_offsetAnimation);
// Visuals
_rootContainer = _compositor.CreateContainerVisual();
_frameLayer = _compositor.CreateLayerVisual();
_frameBackgroundVisual = _compositor.CreateSpriteVisual();
_frameContentVisual = _compositor.CreateSpriteVisual();
_placeholderContentVisual = _compositor.CreateSpriteVisual();
_placeholderBackgroundVisual = _compositor.CreateSpriteVisual();
_nextVisualContent = _compositor.CreateSpriteVisual();
_frameLayer.Children.InsertAtTop(_frameBackgroundVisual);
_frameLayer.Children.InsertAtTop(_frameContentVisual);
_frameLayer.Children.InsertAtTop(_placeholderBackgroundVisual);
_frameLayer.Children.InsertAtTop(_placeholderContentVisual);
_frameLayer.Children.InsertAtTop(_nextVisualContent);
// Placeholder content
_placeholderContentMask = _generator.CreateGeometrySurface(PlaceholderSize, GetPlaceHolderGeometry(),
PlaceholderColor, PlaceholderBackground);
_placeholderContentBrush = _compositor.CreateSurfaceBrush(_placeholderContentMask.Surface);
_placeholderContentVisual.Brush = _placeholderContentBrush;
// Placeholder background
_placeholderBackgroundVisual.Brush = _compositor.CreateColorBrush(PlaceholderBackground);
// By default placeholder visual will not be visible
HidePlaceholder();
// Shadow visual
_shadowVisual = _compositor.CreateSpriteVisual();
_rootContainer.Children.InsertAtBottom(_shadowVisual);
_rootContainer.Children.InsertAtTop(_frameLayer);
_frameBackgroundVisual.Brush = _compositor.CreateColorBrush(FrameBackground);
// Create the effect to create the opacity mask
var layerEffect = new CompositeEffect
{
// CanvasComposite.DestinationIn - Intersection of source and mask.
// Equation: O = MA * S
// where O - Output pixel, MA - Mask Alpha, S - Source pixel.
Mode = CanvasComposite.DestinationIn,
Sources =
{
new CompositionEffectSourceParameter("source"),
new CompositionEffectSourceParameter("mask")
}
};
var layerEffectFactory = _compositor.CreateEffectFactory(layerEffect);
_layerEffectBrush = layerEffectFactory.CreateBrush();
// The mask for the imageFrame
_frameLayerMask = _generator.CreateMaskSurface(new Size(0, 0), null);
_layerEffectBrush.SetSourceParameter("mask", _compositor.CreateSurfaceBrush(_frameLayerMask.Surface));
// Apply the mask effect to the frameLayer
_frameLayer.Effect = _layerEffectBrush;
ElementCompositionPreview.SetElementChildVisual(this, _rootContainer);
}
private void StackAndScaleAnimation(bool horizontally, bool fromLeftTop)
{
CompositionAnimationGroup animationGroupB = compositor.CreateAnimationGroup();
CompositionAnimationGroup animationGroupF = compositor.CreateAnimationGroup();
visualB.CenterPoint = new Vector3((visualB.Size.X / 2.0f), (visualB.Size.Y / 2.0f), 0.0f);
visualF.CenterPoint = new Vector3((visualF.Size.X / 2.0f), (visualF.Size.Y / 2.0f), 0.0f);
Vector3 small = new Vector3(0.7f, 0.7f, 7f);
Vector3 big = new Vector3(1.4f, 1.4f, 1f);
int dir = fromLeftTop ? -1 : 1;
if (isFrontVisible)
{
imageBack.Source = Source;
visualB.Offset = new Vector3(0f, 0f, 0f);
}
else
{
imageFront.Source = Source;
visualF.Offset = new Vector3(0f, 0f, 0f);
}
Vector3 vector;
if (horizontally)
{
vector = new Vector3(dir * (int)ActualWidth, 0f, 0f);
}
else
{
vector = new Vector3(0f, dir * (int)ActualHeight, 0f);
}
if (Direction == Direction.Next)
{
if (isFrontVisible)
{
imageBack.SetValue(Canvas.ZIndexProperty, 0);
imageFront.SetValue(Canvas.ZIndexProperty, 1);
animationGroupB.Add(animations.CreateOpacityAnimation(0.5f, 1f, Duration));
animationGroupB.Add(animations.CreateScaleAnimation(small, vOne, Duration));
animationGroupF.Add(animations.CreateSlideAnimation(vZero, vector, Duration));
visualB.StartAnimationGroup(animationGroupB);
visualF.StartAnimationGroup(animationGroupF);
}
else
{
imageBack.SetValue(Canvas.ZIndexProperty, 1);
imageFront.SetValue(Canvas.ZIndexProperty, 0);
animationGroupF.Add(animations.CreateOpacityAnimation(0.5f, 1f, Duration));
animationGroupF.Add(animations.CreateScaleAnimation(small, vOne, Duration));
animationGroupB.Add(animations.CreateSlideAnimation(vZero, vector, Duration));
visualB.StartAnimationGroup(animationGroupB);
visualF.StartAnimationGroup(animationGroupF);
}
}
else
{
if (isFrontVisible)
{
imageBack.SetValue(Canvas.ZIndexProperty, 1);
imageFront.SetValue(Canvas.ZIndexProperty, 0);
visualB.Opacity = 1;
visualB.Scale = vOne;
animationGroupB.Add(animations.CreateSlideAnimation(vector, vZero, Duration));
animationGroupF.Add(animations.CreateOpacityAnimation(1f, 0.5f, Duration));
animationGroupF.Add(animations.CreateScaleAnimation(vOne, small, Duration));
visualB.StartAnimationGroup(animationGroupB);
visualF.StartAnimationGroup(animationGroupF);
}
else
{
imageBack.SetValue(Canvas.ZIndexProperty, 0);
imageFront.SetValue(Canvas.ZIndexProperty, 1);
visualF.Opacity = 1;
visualF.Scale = vOne;
animationGroupF.Add(animations.CreateSlideAnimation(vector, vZero, Duration));
animationGroupB.Add(animations.CreateOpacityAnimation(1f, 0.5f, Duration));
animationGroupB.Add(animations.CreateScaleAnimation(vOne, small, Duration));
visualB.StartAnimationGroup(animationGroupB);
visualF.StartAnimationGroup(animationGroupF);
}
}
}
private void ScaleAndOpacityAnimation()
{
CompositionAnimationGroup animationGroupB = compositor.CreateAnimationGroup();
CompositionAnimationGroup animationGroupF = compositor.CreateAnimationGroup();
visualB.CenterPoint = new Vector3((visualB.Size.X / 2.0f), (visualB.Size.Y / 2.0f), 0.0f);
visualF.CenterPoint = new Vector3((visualF.Size.X / 2.0f), (visualF.Size.Y / 2.0f), 0.0f);
oldVisual.Offset = new Vector3(0f, 0f, 0f);
newVisual.Offset = new Vector3(0f, 0f, 0f);
Vector3 small = new Vector3(0.7f, 0.7f, 7f);
Vector3 big = new Vector3(1.4f, 1.4f, 1f);
if (Direction == Direction.Next)
{
if (isFrontVisible)
{
imageBack.Source = Source;
animationGroupB.Add(animations.CreateOpacityAnimation(0f, 1f, Duration));
animationGroupB.Add(animations.CreateScaleAnimation(small, vOne, Duration));
animationGroupF.Add(animations.CreateOpacityAnimation(1f, 0f, Duration));
animationGroupF.Add(animations.CreateScaleAnimation(vOne, big, Duration));
visualB.StartAnimationGroup(animationGroupB);
visualF.StartAnimationGroup(animationGroupF);
}
else
{
imageFront.Source = Source;
animationGroupF.Add(animations.CreateOpacityAnimation(0f, 1f, Duration));
animationGroupF.Add(animations.CreateScaleAnimation(small, vOne, Duration));
animationGroupB.Add(animations.CreateOpacityAnimation(1f, 0f, Duration));
animationGroupB.Add(animations.CreateScaleAnimation(vOne, big, Duration));
visualB.StartAnimationGroup(animationGroupB);
visualF.StartAnimationGroup(animationGroupF);
}
}
else
{
if (isFrontVisible)
{
imageBack.Source = Source;
animationGroupB.Add(animations.CreateOpacityAnimation(0f, 1f, Duration));
animationGroupB.Add(animations.CreateScaleAnimation(big, vOne, Duration));
animationGroupF.Add(animations.CreateOpacityAnimation(1f, 0f, Duration));
animationGroupF.Add(animations.CreateScaleAnimation(vOne, small, Duration));
visualB.StartAnimationGroup(animationGroupB);
visualF.StartAnimationGroup(animationGroupF);
}
else
{
imageFront.Source = Source;
animationGroupF.Add(animations.CreateOpacityAnimation(0f, 1f, Duration));
animationGroupF.Add(animations.CreateScaleAnimation(big, vOne, Duration));
animationGroupB.Add(animations.CreateOpacityAnimation(1f, 0f, Duration));
animationGroupB.Add(animations.CreateScaleAnimation(vOne, small, Duration));
visualB.StartAnimationGroup(animationGroupB);
visualF.StartAnimationGroup(animationGroupF);
}
}
}
private void CreateAnimation()
{
ElementCompositionPreview.SetIsTranslationEnabled(this, true);
var compositor = Window.Current.Compositor;
_animationGroup = compositor.CreateAnimationGroup();
_propertySet = compositor.CreatePropertySet();
var visual = ElementCompositionPreview.GetElementVisual(this);
// translation
var translationAnimation = compositor.CreateScalarKeyFrameAnimation();
translationAnimation.InsertExpressionKeyFrame(1f, "props.TranslateTo");
translationAnimation.SetReferenceParameter("props", _propertySet);
translationAnimation.StopBehavior = AnimationStopBehavior.SetToFinalValue;
translationAnimation.Duration = TimeSpan.FromSeconds(0.6);
_translationY = translationAnimation;
// shadow
var shadowVisual = compositor.CreateSpriteVisual();
var dropShadow = compositor.CreateDropShadow();
dropShadow.BlurRadius = 0;
shadowVisual.Shadow = dropShadow;
ElementCompositionPreview.SetElementChildVisual(xamlShadow, shadowVisual);
_shadow = dropShadow;
// sync size
var imgVisual = ElementCompositionPreview.GetElementVisual(xamlImg);
var bindSizeAnimation = compositor.CreateExpressionAnimation("hostVisual.Size");
bindSizeAnimation.SetReferenceParameter("hostVisual", imgVisual);
shadowVisual.StartAnimation("Size", bindSizeAnimation);
var blurRadiusAnimationIn = compositor.CreateScalarKeyFrameAnimation();
blurRadiusAnimationIn.InsertExpressionKeyFrame(1f, "props.BlurRadius");
blurRadiusAnimationIn.SetReferenceParameter("props", _propertySet);
blurRadiusAnimationIn.StopBehavior = AnimationStopBehavior.SetToFinalValue;
blurRadiusAnimationIn.Duration = TimeSpan.FromSeconds(0.6);
blurRadiusAnimationIn.Target = "BlurRadius";
_blurShadowIn = blurRadiusAnimationIn;
var blurRadiusAnimationOut = compositor.CreateScalarKeyFrameAnimation();
var easing = compositor.CreateCubicBezierEasingFunction(new Vector2(0.27f, 0.72f), new Vector2(0.82f, 0.29f));
blurRadiusAnimationOut.InsertExpressionKeyFrame(1f, "props.BlurRadius");
blurRadiusAnimationOut.SetReferenceParameter("props", _propertySet);
blurRadiusAnimationOut.StopBehavior = AnimationStopBehavior.SetToFinalValue;
blurRadiusAnimationOut.Duration = TimeSpan.FromSeconds(0.6);
blurRadiusAnimationOut.Target = "BlurRadius";
_blurShadowOut = blurRadiusAnimationOut;
var opacityAnimation = compositor.CreateScalarKeyFrameAnimation();
opacityAnimation.InsertExpressionKeyFrame(1f, "props.Opacity");
opacityAnimation.SetReferenceParameter("props", _propertySet);
opacityAnimation.StopBehavior = AnimationStopBehavior.SetToFinalValue;
opacityAnimation.Duration = TimeSpan.FromSeconds(0.6);
opacityAnimation.Target = "Opacity";
_opacityShadow = opacityAnimation;
}
/// <summary>
/// Disposes the resources
/// </summary>
public void Dispose()
{
// Clean up resources
_compositor = null;
Source = null;
DataContext = null;
Foreground = null;
Background = null;
_scheduledObject = null;
_currentObject = null;
// Clean up Composition Objects
_imageSurface?.Dispose();
_imageSurface = null;
_nextImageSurface?.Dispose();
_nextImageSurface = null;
_frameLayerMask?.Dispose();
_frameLayerMask = null;
_placeholderContentMask?.Dispose();
_placeholderContentMask = null;
_placeholderContentBrush?.Dispose();
_placeholderContentBrush = null;
_nextSurfaceBrush?.Dispose();
_nextSurfaceBrush = null;
_rootContainer?.Dispose();
_rootContainer = null;
_shadowVisual?.Dispose();
_shadowVisual = null;
_frameLayer?.Dispose();
_frameLayer = null;
_frameBackgroundVisual?.Dispose();
_frameBackgroundVisual = null;
_placeholderBackgroundVisual?.Dispose();
_placeholderBackgroundVisual = null;
_placeholderContentVisual?.Dispose();
_placeholderContentVisual = null;
_frameContentVisual?.Dispose();
_frameContentVisual = null;
_nextVisualContent?.Dispose();
_nextVisualContent = null;
_shadow?.Dispose();
_shadow = null;
_layerEffectBrush?.Dispose();
_layerEffectBrush = null;
_imageOptions = null;
_zoomInAnimationGroup?.Dispose();
_zoomInAnimationGroup = null;
_fadeOutAnimation?.Dispose();
_fadeOutAnimation = null;
_fadeInAnimation?.Dispose();
_fadeInAnimation = null;
_colorAnimation?.Dispose();
_colorAnimation = null;
_alignXAnimation?.Dispose();
_alignXAnimation = null;
_alignYAnimation?.Dispose();
_alignYAnimation = null;
_offsetAnimation?.Dispose();
_offsetAnimation = null;
_scaleAnimation?.Dispose();
_scaleAnimation = null;
// Dispose the generator at the end to allow the
// dependant composition objects to unsubscribe from
// generator events
_generator?.Dispose();
_generator = null;
}
/// <summary>
/// Creates the default backwards composition animation
/// </summary>
/// <param name="outElement"></param>
/// <param name="inElement"></param>
/// <returns></returns>
CompositionStoryboard CreateCompositionExpoZoomBackward(FrameworkElement outElement, FrameworkElement inElement)
{
Compositor compositor = ElementCompositionPreview.GetElementVisual(outElement).Compositor;
Visual outVisual = ElementCompositionPreview.GetElementVisual(outElement);
Visual inVisual = ElementCompositionPreview.GetElementVisual(inElement);
CompositionAnimationGroup outgroup = compositor.CreateAnimationGroup();
CompositionAnimationGroup ingroup = compositor.CreateAnimationGroup();
TimeSpan outDuration = TimeSpan.FromSeconds(0.3);
TimeSpan inDuration = TimeSpan.FromSeconds(0.4);
CubicBezierEasingFunction ease = compositor.CreateCubicBezierEasingFunction(
new Vector2(0.95f, 0.05f),
new Vector2(0.79f, 0.04f));
CubicBezierEasingFunction easeOut = compositor.CreateCubicBezierEasingFunction(
new Vector2(0.19f, 1.0f),
new Vector2(0.22f, 1.0f));
// OUT ELEMENT
{
outVisual.CenterPoint = outVisual.Size.X > 0
? new Vector3(outVisual.Size / 2f, 0f)
: new Vector3((float)this.ActualWidth / 2f, (float)this.ActualHeight / 2f, 0f);
// SCALE OUT
var sO = compositor.CreateVector3KeyFrameAnimation();
sO.Duration = outDuration;
sO.Target = nameof(outVisual.Scale);
sO.InsertKeyFrame(1, new Vector3(0.7f, 0.7f, 1.0f), ease);
outgroup.Add(sO);
// FADE OUT
var op = compositor.CreateScalarKeyFrameAnimation();
op.Duration = outDuration;
op.Target = nameof(outVisual.Opacity);
op.InsertKeyFrame(1, 0f, ease);
outgroup.Add(op);
}
// IN ELEMENT
{
inVisual.CenterPoint = inVisual.Size.X > 0
? new Vector3(inVisual.Size / 2f, 0f)
: new Vector3((float)this.ActualWidth / 2f, (float)this.ActualHeight / 2f, 0f);
// SCALE IN
ingroup.Add(
inVisual.CreateVector3KeyFrameAnimation(nameof(Visual.Scale))
.AddScaleKeyFrame(0, 1.3f)
.AddScaleKeyFrame(1, 1f, easeOut)
.SetDuration(inDuration)
.SetDelayTime(outDuration)
.SetDelayBehavior(AnimationDelayBehavior.SetInitialValueBeforeDelay));
// FADE IN
inVisual.Opacity = 0f;
var op = inVisual.Compositor.CreateScalarKeyFrameAnimation();
op.DelayTime = outDuration;
op.Duration = inDuration;
op.Target = nameof(outVisual.Opacity);
op.InsertKeyFrame(1, 0f, easeOut);
op.InsertKeyFrame(1, 1f, easeOut);
ingroup.Add(op);
}
CompositionStoryboard group = new CompositionStoryboard();
group.Add(new CompositionTimeline(outVisual, outgroup, ease));
group.Add(new CompositionTimeline(inVisual, ingroup, easeOut));
return(group);
}
/// <summary>
/// Adds an ExpressionAnimation<T> to the specified animation group.
/// </summary>
/// <typeparam name="T">Type of the property being animated.</typeparam>
/// <param name="animationGroup">Animation Group</param>
/// <param name="expressionAnimation">ExpressionAnimation<T></param>
public static void Add <T>(this CompositionAnimationGroup animationGroup,
ExpressionAnimation <T> expressionAnimation)
{
animationGroup.Add(expressionAnimation.Animation);
}
/// <summary>
/// Adds a KeyFrameAnimation<T> to the specified animation group.
/// </summary>
/// <typeparam name="T">Type of the property being animated.</typeparam>
/// <param name="animationGroup">Animation Group</param>
/// <param name="keyframeAnimation">KeyFrameAnimation<T></param>
public static void Add <T>(this CompositionAnimationGroup animationGroup,
KeyFrameAnimation <T> keyframeAnimation)
{
animationGroup.Add(keyframeAnimation.Animation);
}
