void InitCompositionResources(ScrollViewer scroll)
{
if (compositor == null)
{
compositor = ElementCompositionPreview.GetElementVisual(Flip).Compositor;
}
if (scroll == null)
{
return;
}
ScrollPropSet = ElementCompositionPreview.GetScrollViewerManipulationPropertySet(Viewer);
if (CenterPointAnimation == null)
{
CenterPointAnimation = compositor.CreateExpressionAnimation("Vector3(visual.Size.X/2,visual.Size.Y/2,0)");
}
if (ScaleAnimation == null)
{
ScaleAnimation = compositor.CreateExpressionAnimation("Clamp(1- (visual.Offset.X + scroll.Translation.X) / visual.Size.X * 0.4, 0f, 1f)");
//ScaleXAnimation = compositor.CreateExpressionAnimation("scroll.Translation.X % visual.Size.X < 0 ? ( -scroll.Translation.X % visual.Size.X) / visual.Size.X > 0.5 ? ( -scroll.Translation.X % visual.Size.X) / visual.Size.X : 1- ( -scroll.Translation.X % visual.Size.X) / visual.Size.X : 1");
ScaleAnimation.SetReferenceParameter("scroll", ScrollPropSet);
}
}
private void InitializeBlurVisuals()
{
var blurEffect = new GaussianBlurEffect()
{
Name = "blur",
BlurAmount = 0.0f,
BorderMode = EffectBorderMode.Hard,
Optimization = EffectOptimization.Balanced,
Source = new CompositionEffectSourceParameter("source")
};
var blurBrush = _compositor.CreateEffectFactory(blurEffect,
new[] { "blur.BlurAmount" })
.CreateBrush();
blurBrush.SetSourceParameter("source", _compositor.CreateDestinationBrush());
_blurredBackgroundImageVisual = _compositor.CreateSpriteVisual();
_blurredBackgroundImageVisual.Brush = blurBrush;
_blurredBackgroundImageVisual.Size = new Vector2((float)Root.ActualWidth, (float)Root.ActualHeight);
ElementCompositionPreview.SetElementChildVisual(BackgroundImageBlurPanel, _blurredBackgroundImageVisual);
}
public PhysiologicalInfo()
{
GenerateTimings();
GeneratePoses();
GeneratePictures();
this.InitializeComponent();
Window.Current.CoreWindow.KeyDown += ContentDialog_KeyDown;
_compositor = ElementCompositionPreview.GetElementVisual(this)?.Compositor;
var _timer = new DispatcherTimer();
_timer.Tick += _timer_Tick;
var t = this.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
_timer.Interval = TimeSpan.FromMilliseconds(1000);
if (!_timer.IsEnabled)
{
_timer.Start();
}
});
}
internal static void TranslateXFrom(this FrameworkElement element, AnimationSettings settings, ref AnimationGroup group)
{
group.CreateAnimations(element, settings,
animGroup =>
{
var visual = ElementCompositionPreview.GetElementVisual(element);
// Since Translation doesn't exist as a property on Visual, we try to fetch it from the PropertySet
if (visual.Properties.TryGetVector3(TargetProperties.Translation, out var translation) == CompositionGetValueStatus.Succeeded)
{
visual.Properties.InsertVector3(TargetProperties.Translation, new Vector3((float)settings.OffsetX, translation.Y, translation.Z));
}
else
{
visual.Properties.InsertVector3(TargetProperties.Translation, new Vector3((float)settings.OffsetX, 0f, 0f));
}
return(animGroup.CreateScalarAnimation <TranslateXAnimation>(
element,
settings,
to: 0f));
});
}
private void BlurifyWithHostBackdrop()
{
try
{
_compositor = ElementCompositionPreview.GetElementVisual(_element).Compositor;
_hostSprite = _compositor.CreateSpriteVisual();
_hostSprite.Size = new Vector2((float)_element.ActualWidth, (float)_element.ActualHeight);
ElementCompositionPreview.SetElementChildVisual(_element, _hostSprite);
if (_hostBackdrop)
{
_hostSprite.Brush = _compositor.CreateHostBackdropBrush();
}
else
{
_hostSprite.Brush = _compositor.CreateBackdropBrush();
}
}
catch (Exception)
{
//not CU
}
}
private void Page_Loaded(object sender, RoutedEventArgs e)
{
// Populate the Effect combobox
IList <ComboBoxItem> effectList = new List <ComboBoxItem>();
foreach (EffectTypes type in Enum.GetValues(typeof(EffectTypes)))
{
ComboBoxItem item = new ComboBoxItem();
item.Tag = type;
item.Content = type.ToString();
effectList.Add(item);
}
EffectSelection.ItemsSource = effectList;
EffectSelection.SelectedIndex = 0;
_hostSprite = _compositor.CreateSpriteVisual();
_hostSprite.Size = new Vector2((float)BackgroundGrid.ActualWidth, (float)BackgroundGrid.ActualHeight);
ElementCompositionPreview.SetElementChildVisual(BackgroundGrid, _hostSprite);
UpdateEffect();
}
public void DetachVisual(VisualImage source)
{
if (_floatingVisual != null)
{
throw new InvalidOperationException("A floating visual is already in use");
}
_floatingVisual = source.ForegroundVisual.Compositor.CreateSpriteVisual();
_floatingVisual.Size = source.ForegroundVisual.Size;
_floatingVisual.Brush = source.ForegroundVisual.Brush;
// Determine the offset from the host to the source element used in the transition
var coordinate = source.TransformToVisual(_hostFrame);
var position = coordinate.TransformPoint(new Point(0, 0));
// Set the sprite to that offset relative to the host
_floatingVisual.Offset = new Vector3((float)position.X + source.ForegroundVisual.Offset.X,
(float)position.Y + source.ForegroundVisual.Offset.Y, 0);
_floatingVisualUri = source.ImageUri;
// Set the sprite as the content under the host
ElementCompositionPreview.SetElementChildVisual(_hostFrame, _floatingVisual);
}
/// <summary>
/// Update layout and webivew on page load
/// </summary>
private void Page_Loaded(object sender, RoutedEventArgs e)
{
_primaryImageOffset = new Vector3((float)(6 * (CircleCanvas.ActualWidth / 18)), (float)CircleCanvas.ActualHeight / 5, 0);
_secondaryImageOffset = new Vector3((float)(1 * (CircleCanvas.ActualWidth / 14)), (float)CircleCanvas.ActualHeight / 7, 20);
_tertiaryImageOffset = new Vector3((float)(20 * (CircleCanvas.ActualWidth / 30)), (float)CircleCanvas.ActualHeight / 10, 40);
// Get backing visuals
_image1 = ElementCompositionPreview.GetElementVisual(Image1);
_image2 = ElementCompositionPreview.GetElementVisual(Image2);
_image3 = ElementCompositionPreview.GetElementVisual(Image3);
// Update XAML element visibility to trigger show animation
Image1.Visibility = Visibility.Visible;
Image2.Visibility = Visibility.Visible;
Image3.Visibility = Visibility.Visible;
_currentPrimary = Image1;
_currentSecondary = Image2;
_currentTertiary = Image3;
UpdateVisualLayout();
UpdateWebview(_currentPrimary);
}
private async void Page_Loaded(object sender, RoutedEventArgs e)
{
_backgroundImageVisual = _compositor.CreateSpriteVisual();
_imageContainer = _compositor.CreateContainerVisual();
_liveCapabilities.Changed += HandleCapabilitiesChanged;
ElementCompositionPreview.SetElementChildVisual(ImageCanvas, _imageContainer);
// Load the image
_surface = await ImageLoader.Instance.LoadFromUriAsync(new Uri("ms-appx:///Assets/Landscapes/Landscape-7.jpg"));
_surface.Brush.Stretch = CompositionStretch.Fill;
_circleMaskSurface = ImageLoader.Instance.LoadCircle(200, Colors.White);
_circleMaskSurface.Brush.Stretch = CompositionStretch.Uniform;
_imageContainer.Size = new Vector2((float)ImageCanvas.ActualWidth, (float)ImageCanvas.ActualHeight);
_imageContainer.Children.InsertAtTop(_backgroundImageVisual);
UpdateVisualSizeAndPosition();
UpdateAlbumArt();
}
private void OnLoaded(object sender, RoutedEventArgs e)
{
if (!_hasInitialLoadedEventFired)
{
var root = VisualTreeHelper.GetChild(this, 0) as UIElement;
_visual = ElementCompositionPreview.GetElementVisual(root);
_hitTest = _visual.Compositor.CreateSpriteVisual();
_hitTest.Brush = _visual.Compositor.CreateColorBrush(Windows.UI.Colors.Transparent);
_hitTest.RelativeSizeAdjustment = Vector2.One;
_container = _visual.Compositor.CreateContainerVisual();
_container.Children.InsertAtBottom(_hitTest);
_container.RelativeSizeAdjustment = Vector2.One;
ElementCompositionPreview.SetElementChildVisual(this, _container);
ConfigureInteractionTracker();
}
_hasInitialLoadedEventFired = true;
}
private void InitializeView(NativeRatingView view)
{
Windows.UI.Xaml.Media.CompositionTarget.Rendering += new EventHandler <object>(DrawRating);
ratings = new List <SpriteVisual>();
var hostVisual = ElementCompositionPreview.GetElementVisual(this);
root = hostVisual.Compositor.CreateContainerVisual();
ElementCompositionPreview.SetElementChildVisual(this, root);
compositor = root.Compositor;
var height = view.Height;
var width = view.Width;
var spaceForTicks = width * 0.6;
var spaceForMargins = width - spaceForTicks;
var tickWidth = (float)(spaceForTicks / view.GetMaxRating);
var tickHeight = (float)(height * 0.6);
var margin = ((spaceForMargins / (Element.GetMaxRating + 1)));
float space = (float)margin;
float yOffset = (((float)height - tickHeight) / 2);
brushSelected = CreateMaskBrush((int)tickWidth, (int)tickHeight, Element.RatingColor.ToWindowsColor());
brushUnselected = CreateMaskBrush((int)tickWidth, (int)tickHeight, Windows.UI.Color.FromArgb(80, 120, 117, 108));
for (int i = 0; i < view.GetMaxRating; i++)
{
tick = compositor.CreateSpriteVisual();
tick.Size = new Vector2(tickWidth, tickHeight);
tick.Offset = new Vector3(space, yOffset, 0);
space += tickWidth + (float)margin;
root.Children.InsertAtTop(tick);
ratings.Add(tick);
}
}
private void ItemContainer_Loaded(object sender, RoutedEventArgs e)
{
var itemsPanel = (ItemsWrapGrid)gridviewImages.ItemsPanelRoot;
var itemContainer = (GridViewItem)sender;
var itemIndex = gridviewImages.IndexFromContainer(itemContainer);
var uc = itemContainer.ContentTemplateRoot as FrameworkElement;
//Debug.WriteLine(itemContainer.ActualWidth);
//Debug.WriteLine(itemContainer.ActualHeight);
//Don't animate if we're not in the visible viewport
if (itemIndex >= itemsPanel.FirstVisibleIndex && itemIndex <= itemsPanel.LastVisibleIndex)
{
var itemVisual = ElementCompositionPreview.GetElementVisual(uc);
float width = (float)itemContainer.ActualWidth;
float height = (float)itemContainer.ActualHeight;
itemVisual.Size = new Vector2(width, height);
itemVisual.CenterPoint = new Vector3(width / 2, height / 2, 1); //GetCenterPoint2(itemContainer, itemContainer.ActualWidth);
itemVisual.Offset = new Vector3(0, 25, 0);
itemVisual.Scale = new Vector3(1, 1, 0);
var relativeIndex = itemIndex - itemsPanel.FirstVisibleIndex;
// Create KeyFrameAnimations
KeyFrameAnimation scaleXAnimation = compositor.CreateScalarKeyFrameAnimation();
scaleXAnimation.InsertExpressionKeyFrame(1f, "0", compositor.CreateCubicBezierEasingFunction(new Vector2(0, 0), new Vector2(0.58f, 1)));
scaleXAnimation.Duration = TimeSpan.FromMilliseconds(200);
// Start animations
itemVisual.StartAnimation("Offset.Y", scaleXAnimation);
}
itemContainer.Loaded -= ItemContainer_Loaded;
}
private void InitializeAnimation(FrameworkElement root, Canvas shadowHost)
{
var rootVisual = ElementCompositionPreview.GetElementVisual(root);
var compositor = rootVisual.Compositor;
#region 阴影
var shadowHostVisual = ElementCompositionPreview.GetElementVisual(shadowHost);
//Create shadow and add it to the Visual Tree
var shadow = compositor.CreateDropShadow();
shadow.Color = Color.FromArgb(255, 75, 75, 80);
var shadowVisual = compositor.CreateSpriteVisual();
shadowVisual.Shadow = shadow;
ElementCompositionPreview.SetElementChildVisual(shadowHost, shadowVisual);
var bindSizeAnimation = compositor.CreateExpressionAnimation("hostVisual.Size");
bindSizeAnimation.SetReferenceParameter("hostVisual", shadowHostVisual);
shadowVisual.StartAnimation("Size", bindSizeAnimation);
var shadowAnimation = compositor.CreateExpressionAnimation("100 * (source.Scale.X - 1)");
shadowAnimation.SetReferenceParameter("source", rootVisual);
shadow.StartAnimation("BlurRadius", shadowAnimation);
#endregion
var pointerEnteredAnimation = compositor.CreateVector3KeyFrameAnimation();
pointerEnteredAnimation.InsertKeyFrame(1.0f, new Vector3(1.02f));
var pointerExitedAnimation = compositor.CreateVector3KeyFrameAnimation();
pointerExitedAnimation.InsertKeyFrame(1.0f, new Vector3(1.0f));
root.PointerEntered += (sender, args) =>
{
//root.Clip = new RectangleGeometry() { Rect = new Rect(0, 0, root.ActualWidth, root.ActualHeight) };
rootVisual.CenterPoint = new Vector3(rootVisual.Size / 2, 0);
rootVisual.StartAnimation("Scale", pointerEnteredAnimation);
};
root.PointerExited += (sender, args) => rootVisual.StartAnimation("Scale", pointerExitedAnimation);
}
private void Content_PointerExited(object sender, PointerRoutedEventArgs e)
{
var content = ElementCompositionPreview.GetElementVisual(sender as UIElement);
var compositor = content.Compositor;
var offsetAnimation = compositor.CreateScalarKeyFrameAnimation();
offsetAnimation.InsertKeyFrame(1.0f, 0);
offsetAnimation.Duration = TimeSpan.FromSeconds(1);
content.StartAnimation("Offset.Z", offsetAnimation);
// Animate Shadow (make it smaller)
var shadow = GetShadowFromContent(sender);
var shadowScaleAnimation = compositor.CreateVector3KeyFrameAnimation();
shadowScaleAnimation.InsertKeyFrame(1.0f, new Vector3(1.0f));
shadowScaleAnimation.Duration = TimeSpan.FromSeconds(.5);
shadow.Visual.StartAnimation("Scale", shadowScaleAnimation);
// Animate shadow (change opacity)
var shadowOpacityAnimation = compositor.CreateScalarKeyFrameAnimation();
shadowOpacityAnimation.InsertKeyFrame(1.0f, _initialShadowOpacity);
shadowOpacityAnimation.Duration = TimeSpan.FromSeconds(1);
shadow.DropShadow.StartAnimation("Opacity", shadowOpacityAnimation);
// Animate shadow (change blur)
var shadowBlurAnimation = compositor.CreateScalarKeyFrameAnimation();
shadowBlurAnimation.InsertKeyFrame(1.0f, _initialShadowBlurRadius);
shadowBlurAnimation.Duration = TimeSpan.FromSeconds(1);
shadow.DropShadow.StartAnimation("BlurRadius", shadowBlurAnimation);
// Set the ZIndex to lowest
Canvas.SetZIndex((UIElement)sender, 1);
Canvas.SetZIndex(shadow, 0);
}
public static void Clip(this FrameworkElement frameworkElement, Geometry geometry)
{
var compositor = Window.Current.Compositor;
var visual = ElementCompositionPreview.GetElementVisual(frameworkElement);
CompositionClip compositionClip = null;
if (geometry is EllipseGeometry ellipseGeometry)
{
var compositionEllipseGeometry = compositor.CreateEllipseGeometry();
compositionEllipseGeometry.Center = new WVector2((float)ellipseGeometry.Center.X, (float)ellipseGeometry.Center.Y);
compositionEllipseGeometry.Radius = new WVector2((float)ellipseGeometry.RadiusX, (float)ellipseGeometry.RadiusY);
compositionClip = compositor.CreateGeometricClip(compositionEllipseGeometry);
}
else if (geometry is LineGeometry lineGeometry)
{
var compositionLineGeometry = compositor.CreateLineGeometry();
compositionLineGeometry.Start = new WVector2((float)lineGeometry.StartPoint.X, (float)lineGeometry.StartPoint.Y);
compositionLineGeometry.End = new WVector2((float)lineGeometry.EndPoint.X, (float)lineGeometry.EndPoint.Y);
compositionClip = compositor.CreateGeometricClip(compositionLineGeometry);
}
else if (geometry is RectangleGeometry rectangleGeometry)
{
var compositionRectangleGeometry = compositor.CreateRectangleGeometry();
compositionRectangleGeometry.Offset = new WVector2((float)rectangleGeometry.Rect.X, (float)rectangleGeometry.Rect.Y);
compositionRectangleGeometry.Size = new WVector2((float)rectangleGeometry.Rect.Width, (float)rectangleGeometry.Rect.Height);
compositionClip = compositor.CreateGeometricClip(compositionRectangleGeometry);
}
visual.Clip = compositionClip;
}
private void UpdatePerspective()
{
Visual visual = ElementCompositionPreview.GetElementVisual(MainPanel);
// Get the size of the area we are enabling perspective for
Vector2 sizeList = new Vector2((float)MainPanel.ActualWidth, (float)MainPanel.ActualHeight);
// Setup the perspective transform.
Matrix4x4 perspective = new Matrix4x4(
1.0f, 0.0f, 0.0f, 0.0f,
0.0f, 1.0f, 0.0f, 0.0f,
0.0f, 0.0f, 1.0f, -1.0f / sizeList.X,
0.0f, 0.0f, 0.0f, 1.0f);
// Set the parent transform to apply perspective to all children
visual.TransformMatrix =
Matrix4x4.CreateTranslation(-sizeList.X / 2, -sizeList.Y / 2, 0f) * // Translate to origin
perspective * // Apply perspective at origin
Matrix4x4.CreateTranslation(sizeList.X / 2, sizeList.Y / 2, 0f); // Translate back to original position
}
private void EnsureComposition()
{
if (_compositor == null)
{
// Get our Compositor and create a SpriteVisual.
_compositor = ElementCompositionPreview.GetElementVisual(this).Compositor;
_visual = _compositor.CreateSpriteVisual();
// Set the size to the size of the page, and make sure to update it whenever
// the page's size changes.
_visual.Size = new Vector2((float)ActualWidth, (float)ActualHeight);
SizeChanged += (s, a) =>
{
_visual.Size = new Vector2((float)ActualWidth, (float)ActualHeight);
};
// Attach our visual to the tree.
ElementCompositionPreview.SetElementChildVisual(this, _visual);
// Create our HueRotation effect.
var graphicsEffect = new HueRotationEffect
{
Name = "HueRotation",
Angle = 0.0f,
Source = new CompositionEffectSourceParameter("Video")
};
var effectFactory = _compositor.CreateEffectFactory(
graphicsEffect,
new string[] { "HueRotation.Angle" });
_effectBrush = effectFactory.CreateBrush();
// Apply our effect brush to our visual.
_visual.Brush = _effectBrush;
}
}
public NavigationFlowSourcePage()
{
InitializeComponent();
_compositor = ElementCompositionPreview.GetElementVisual(this).Compositor;
var listItems = new List <string>();
for (int i = 0; i < 300; i++)
{
listItems.Add($"Item {i}");
}
ItemsGridView.ItemsSource = listItems;
// Set a fade in animation when this page enters the scene
var fadeInAnimation = _compositor.CreateScalarKeyFrameAnimation();
fadeInAnimation.Target = "Opacity";
fadeInAnimation.Duration = TimeSpan.FromSeconds(0.3);
fadeInAnimation.InsertKeyFrame(0, 0);
fadeInAnimation.InsertKeyFrame(1, 1);
// Call GetElementVisual() to work around a bug in Insider Build 15025
ElementCompositionPreview.GetElementVisual(this);
ElementCompositionPreview.SetImplicitShowAnimation(this, fadeInAnimation);
// Set a fade out animation when this page exits the scene
var fadeOutAnimation = _compositor.CreateScalarKeyFrameAnimation();
fadeOutAnimation.Target = "Opacity";
fadeOutAnimation.Duration = TimeSpan.FromSeconds(0.3);
fadeOutAnimation.InsertKeyFrame(0, 1);
fadeOutAnimation.InsertKeyFrame(1, 0);
ElementCompositionPreview.SetImplicitHideAnimation(this, fadeOutAnimation);
}
public void InitAnimation(InitOption Option)
{
if (compositor != null)
{
if (Option == InitOption.AroundImage)
{
for (int i = Flip.SelectedIndex > 2 ? Flip.SelectedIndex - 2 : 0; i < Flip.SelectedIndex + 2 && i < Flip.Items.Count; i++)
{
if (Flip.ContainerFromIndex(i) is UIElement Element)
{
var Visual = ElementCompositionPreview.GetElementVisual(Element);
CenterPointAnimation.SetReferenceParameter("visual", Visual);
Visual.StartAnimation("CenterPoint", CenterPointAnimation);
Visual.StopAnimation("Scale.X");
ScaleAnimation.SetReferenceParameter("visual", Visual);
Visual.StartAnimation("Scale.X", ScaleAnimation);
Visual.StartAnimation("Scale.Y", ScaleAnimation);
}
}
}
else
{
foreach (var Visual in from Item in Flip.Items
let Element = Flip.ContainerFromItem(Item) as UIElement
where Element != null
select ElementCompositionPreview.GetElementVisual(Element))
{
CenterPointAnimation.SetReferenceParameter("visual", Visual);
Visual.StartAnimation("CenterPoint", CenterPointAnimation);
Visual.StopAnimation("Scale.X");
ScaleAnimation.SetReferenceParameter("visual", Visual);
Visual.StartAnimation("Scale.X", ScaleAnimation);
Visual.StartAnimation("Scale.Y", ScaleAnimation);
}
}
}
}
private void AssignParallax()
{
if (ParallaxContent == null)
{
return;
}
if (AssociatedObject == null)
{
return;
}
var scroller = AssociatedObject as ScrollViewer;
if (scroller == null)
{
scroller = VisualHelper.FindChild <ScrollViewer>(AssociatedObject);
}
if (scroller == null)
{
return;
}
CompositionPropertySet scrollerViewerManipulation = ElementCompositionPreview.GetScrollViewerManipulationPropertySet(scroller);
Compositor compositor = scrollerViewerManipulation.Compositor;
ExpressionAnimation expression = compositor.CreateExpressionAnimation(ParallaxMultiplier > 0
? "ScrollManipulation.Translation.Y * ParallaxMultiplier - ScrollManipulation.Translation.Y"
: "ScrollManipulation.Translation.Y * ParallaxMultiplier");
expression.SetScalarParameter("ParallaxMultiplier", (float)ParallaxMultiplier);
expression.SetReferenceParameter("ScrollManipulation", scrollerViewerManipulation);
Visual textVisual = ElementCompositionPreview.GetElementVisual(ParallaxContent);
textVisual.StartAnimation("Offset.Y", expression);
}
private void InitializeAnimations()
{
Visual circleVisual = ElementCompositionPreview.GetElementVisual(CirlceHost);
float radius = (float)CirlceHost.Width / 2.0f;
circleVisual.CenterPoint = new Vector3(radius, radius, 0);
Compositor compositor = circleVisual.Compositor;
var duration = TimeSpan.FromMilliseconds(360);
var easingFunction = compositor.CreateCubicBezierEasingFunction(new Vector2(0.3f, 0.3f), new Vector2(0, 1));
// Show cirlce animations
var circleShowAnimation = compositor.CreateVector2KeyFrameAnimation();
circleShowAnimation.InsertKeyFrame(1, Vector2.One);
circleShowAnimation.InsertKeyFrame(0, Vector2.Zero, easingFunction);
circleShowAnimation.Duration = duration;
circleShowAnimation.Target = "Scale.xy";
ElementCompositionPreview.SetImplicitShowAnimation(CirlceHost, circleShowAnimation);
// Show text animation
var textShowOpacityAnimation = compositor.CreateScalarKeyFrameAnimation();
textShowOpacityAnimation.InsertKeyFrame(0, 0);
textShowOpacityAnimation.InsertKeyFrame(1, 1, easingFunction);
textShowOpacityAnimation.Duration = duration;
textShowOpacityAnimation.Target = "Opacity";
ElementCompositionPreview.SetImplicitShowAnimation(TextGrid, textShowOpacityAnimation);
var textShowOffsetAnimation = compositor.CreateScalarKeyFrameAnimation();
textShowOffsetAnimation.InsertKeyFrame(0, -15);
textShowOffsetAnimation.InsertKeyFrame(1, 0, easingFunction);
textShowOffsetAnimation.Duration = duration;
textShowOffsetAnimation.Target = "Offset.x";
ElementCompositionPreview.SetImplicitShowAnimation(TranslationElement, textShowOffsetAnimation);
}
/// <summary>
/// Shows the image.
/// </summary>
/// <param name="page">The page.</param>
/// <param name="imageBounds">The image bounds.</param>
/// <param name="imageUri">The image URI.</param>
/// <param name="backgroundColor">Color of the background.</param>
private static async void ShowImage(Page page, Rect imageBounds, Uri imageUri, Color backgroundColor)
{
var compositor = ElementCompositionPreview.GetElementVisual(page).Compositor;
var windowSize = new Vector2((float)Window.Current.Bounds.Width, (float)Window.Current.Bounds.Height);
//
// Create a container visual to hold the color fill background and image visuals.
// Configure this visual to scale from the center.
//
var container = compositor.CreateContainerVisual();
container.Size = windowSize;
container.CenterPoint = new Vector3(windowSize.X, windowSize.Y, 0) * .5f;
ElementCompositionPreview.SetElementChildVisual(page, container);
//
// Create the colorfill sprite for the background, set the color to the same as app theme
//
var backgroundSprite = compositor.CreateSpriteVisual();
backgroundSprite.Size = windowSize;
backgroundSprite.Brush = compositor.CreateColorBrush(backgroundColor);
container.Children.InsertAtBottom(backgroundSprite);
//
// Create the image sprite containing the splash screen image. Size and position this to
// exactly cover the Splash screen image so it will be a seamless transition between the two
//
var surface = await SurfaceLoader.LoadFromUri(imageUri);
var imageSprite = compositor.CreateSpriteVisual();
imageSprite.Brush = compositor.CreateSurfaceBrush(surface);
imageSprite.Offset = new Vector3((float)imageBounds.X, (float)imageBounds.Y, 0f);
imageSprite.Size = new Vector2((float)imageBounds.Width, (float)imageBounds.Height);
container.Children.InsertAtTop(imageSprite);
}
/// <summary>
/// Update image source transform.
/// </summary>
/// <param name="viewport">Viewport</param>
/// <param name="viewportImageRect"> The real image area of viewport.</param>
/// <param name="animate">Whether animation is enabled.</param>
private void UpdateImageLayoutWithViewport(Rect viewport, Rect viewportImageRect, bool animate = false)
{
if (!IsValidRect(viewport) || !IsValidRect(viewportImageRect))
{
return;
}
var imageScale = viewport.Width / viewportImageRect.Width;
_imageTransform.ScaleX = _imageTransform.ScaleY = imageScale;
_imageTransform.TranslateX = viewport.X - (viewportImageRect.X * imageScale);
_imageTransform.TranslateY = viewport.Y - (viewportImageRect.Y * imageScale);
_inverseImageTransform.ScaleX = _inverseImageTransform.ScaleY = 1 / imageScale;
_inverseImageTransform.TranslateX = -_imageTransform.TranslateX / imageScale;
_inverseImageTransform.TranslateY = -_imageTransform.TranslateY / imageScale;
var selectedRect = _imageTransform.TransformBounds(_currentCroppedRect);
_restrictedSelectRect = _imageTransform.TransformBounds(_restrictedCropRect);
var startPoint = GetSafePoint(_restrictedSelectRect, new Point(selectedRect.X, selectedRect.Y));
var endPoint = GetSafePoint(_restrictedSelectRect, new Point(
selectedRect.X + selectedRect.Width,
selectedRect.Y + selectedRect.Height));
if (animate)
{
AnimateUIElementOffset(new Point(_imageTransform.TranslateX, _imageTransform.TranslateY), _animationDuration, _sourceImage);
AnimateUIElementScale(imageScale, _animationDuration, _sourceImage);
}
else
{
var targetVisual = ElementCompositionPreview.GetElementVisual(_sourceImage);
targetVisual.Offset = new Vector3((float)_imageTransform.TranslateX, (float)_imageTransform.TranslateY, 0);
targetVisual.Scale = new Vector3((float)imageScale);
}
UpdateSelectedRect(startPoint, endPoint, animate);
}
public DemoPage1()
{
//var visual = ElementCompositionPreview.GetElementVisual(this);
//compositor = visual.Compositor;
this.InitializeComponent();
var visual = ElementCompositionPreview.GetElementVisual(this);
compositor = visual.Compositor;
////////////////////////////////////////////////////////////////////////////////////////////////
//
// 不需要等 Control.Loaded ，就可以取到他的 Visual
// 可見 XAML visual tree 與 Composition tree 的產生順序沒有先後之分
//
////////////////////////////////////////////////////////////////////////////////////////////////
//// 試著取得 [沒有被加至 Visual Tree 的元件] 的 Visual 與 Compositor
//// 會有問題嗎???
//var textBlock = new TextBlock();
//var textBlockVisual = ElementCompositionPreview.GetElementVisual(textBlock);
//var textBlockCompositor = textBlockVisual.Compositor;
}
private void GalleryItem_PointerExited(object sender, PointerRoutedEventArgs e)
{
var element = ElementCompositionPreview.GetElementVisual((UIElement)sender);
var scaleAnimation = _compositor.CreateVector3KeyFrameAnimation();
scaleAnimation.Duration = TimeSpan.FromMilliseconds(durationHover);
scaleAnimation.InsertKeyFrame(1f, new Vector3(1f, 1f, 1f));
element.CenterPoint = new Vector3(275f / 2, 275f / 2, 275f / 2);
element.StartAnimation("Scale", scaleAnimation);
var shadowBorder = (Grid)sender;
ElementCompositionPreview.SetElementChildVisual((UIElement)shadowBorder.FindName("Shadow"), null);
// Update AmbientLight when the item is no longer hovered on
var ambientLightColorAnimation = _compositor.CreateColorKeyFrameAnimation();
ambientLightColorAnimation.Duration = TimeSpan.FromMilliseconds(durationHover);
ambientLightColorAnimation.InsertKeyFrame(1f, ambientLightColorOff);
ambientLight.StartAnimation(nameof(AmbientLight.Color), ambientLightColorAnimation);
}
private void Setup()
{
var firstGearVisual = ElementCompositionPreview.GetElementVisual(FirstGear);
firstGearVisual.Size = new Vector2((float)FirstGear.ActualWidth, (float)FirstGear.ActualHeight);
firstGearVisual.AnchorPoint = new Vector2(0.5f, 0.5f);
for (int i = Container.Children.Count - 1; i > 0; i--)
{
Container.Children.RemoveAt(i);
}
_x = 87;
_y = 0d;
_width = 100;
_height = 100;
_gearDimension = 87;
Count = 1;
_gearVisuals = new List <Visual>()
{
firstGearVisual
};
}
private void UpdateSeeAlsoPanelVerticalTranslationAnimation()
{
var isEnabled = LayoutVisualStates.CurrentState == LargeLayout;
ElementCompositionPreview.SetIsTranslationEnabled(seeAlsoPanel, true);
var targetPanelVisual = ElementCompositionPreview.GetElementVisual(seeAlsoPanel);
targetPanelVisual.Properties.InsertVector3("Translation", Vector3.Zero);
if (isEnabled)
{
var scrollProperties = ElementCompositionPreview.GetScrollViewerManipulationPropertySet(svPanel);
var expression = _compositor.CreateExpressionAnimation("ScrollManipulation.Translation.Y * -1");
expression.SetReferenceParameter("ScrollManipulation", scrollProperties);
expression.Target = "Translation.Y";
targetPanelVisual.StartAnimation(expression.Target, expression);
}
else
{
targetPanelVisual.StopAnimation("Translation.Y");
}
}
//</SnippetDoubleTapped>
//private void SetVideoVisual()
//{
// //<SnippetCompositor>
// Visual elementVisual = ElementCompositionPreview.GetElementVisual(_compositionCanvas);
// var compositor = elementVisual.Compositor;
// _mediaPlayer.SetSurfaceSize(new Size(_compositionCanvas.ActualWidth, _compositionCanvas.ActualHeight));
// MediaPlayerSurface surface = _mediaPlayer.GetSurface(compositor);
// SpriteVisual spriteVisual = compositor.CreateSpriteVisual();
// spriteVisual.Brush = compositor.CreateSurfaceBrush(surface.CompositionSurface);
// ElementCompositionPreview.SetElementChildVisual(_compositionCanvas, spriteVisual);
// //</SnippetCompositor>
//}
private void SetVideoVisualButton_Click(object sender, RoutedEventArgs e)
{
//<SnippetCompositor>
mediaPlayer.SetSurfaceSize(new Size(_compositionCanvas.ActualWidth, _compositionCanvas.ActualHeight));
var compositor = ElementCompositionPreview.GetElementVisual(this).Compositor;
MediaPlayerSurface surface = mediaPlayer.GetSurface(compositor);
SpriteVisual spriteVisual = compositor.CreateSpriteVisual();
spriteVisual.Size =
new System.Numerics.Vector2((float)_compositionCanvas.ActualWidth, (float)_compositionCanvas.ActualHeight);
CompositionBrush brush = compositor.CreateSurfaceBrush(surface.CompositionSurface);
spriteVisual.Brush = brush;
ContainerVisual container = compositor.CreateContainerVisual();
container.Children.InsertAtTop(spriteVisual);
ElementCompositionPreview.SetElementChildVisual(_compositionCanvas, container);
//</SnippetCompositor>
}
protected override void OnApplyTemplate()
{
var gradient = new LinearGradientBrush();
gradient.StartPoint = new Point(0, 0);
gradient.EndPoint = new Point(1, 0);
for (int i = 0; i < _colors.Length; i++)
{
gradient.GradientStops.Add(new GradientStop
{
Color = _colors[i],
Offset = _offsets[i]
});
}
_layoutRoot = (FrameworkElement)GetTemplateChild("LayoutRoot");
_container = (FrameworkElement)GetTemplateChild("Container");
_container.PointerPressed += Thumb_PointerPressed;
_container.PointerMoved += Thumb_PointerMoved;
_container.PointerReleased += Thumb_PointerReleased;
_thumb = (FrameworkElement)GetTemplateChild("Thumb");
_thumbVisual = ElementCompositionPreview.GetElementVisual(_thumb);
_thumbVisual.CenterPoint = new Vector3(24);
_thumbVisual.Scale = new Vector3(0.5f);
_thumbDrop = (Ellipse)GetTemplateChild("ThumbDrop");
Background = gradient;
SetDefault(_value);
base.OnApplyTemplate();
}
public BackDrop()
{
m_rootVisual = ElementCompositionPreview.GetElementVisual(this as UIElement);
Compositor = m_rootVisual.Compositor;
m_blurVisual = Compositor.CreateSpriteVisual();
#if SDKVERSION_14393
CompositionEffectBrush brush = BuildBlurBrush();
brush.SetSourceParameter("source", m_compositor.CreateBackdropBrush());
m_blurBrush = brush;
m_blurVisual.Brush = m_blurBrush;
BlurAmount = 9;
TintColor = Colors.Transparent;
#else
m_blurBrush = Compositor.CreateColorBrush(Colors.White);
m_blurVisual.Brush = m_blurBrush;
#endif
ElementCompositionPreview.SetElementChildVisual(this as UIElement, m_blurVisual);
this.Loading += OnLoading;
this.Unloaded += OnUnloaded;
}
