Beispiel #1
0
        private async void OnLoaded(object sender, RoutedEventArgs e)
        {
            _compositor = Window.Current.Compositor;
            _generator  = _compositor.CreateCompositionGenerator();

            var size = new Vector2(GridWidth, GridHeight);

            _topOffset = -GridHeight / 2f;

            // Create the left image visual
            var leftImageVisual = _compositor.CreateSpriteVisual();

            leftImageVisual.Size = size;

            // Left Image Surface
            var leftImageSurface = await _generator.CreateImageSurfaceAsync(new Uri("ms-appx:///Assets/Images/Image1.jpg"), size.ToSize(), ImageSurfaceOptions.Default);

            // Left Mask Geometry

            _leftGeometry = CanvasGeometry.CreateRectangle(_generator.Device, new Rect(0f, 0f, 2f * (GridWidth * _splitValue) / 100f, 2f * GridHeight));
            var leftOffset = -(GridWidth * _splitValue) / 100f;
            // Left Masked Brush
            var leftMaskedBrush = _compositor.CreateMaskBrush();

            leftMaskedBrush.Source = _compositor.CreateSurfaceBrush(leftImageSurface);
            _leftGaussianSurface   = _generator.CreateGaussianMaskSurface(size.ToSize(), _leftGeometry, new Vector2(leftOffset, _topOffset), _blurRadius);
            leftMaskedBrush.Mask   = _compositor.CreateSurfaceBrush(_leftGaussianSurface);
            leftImageVisual.Brush  = leftMaskedBrush;

            // Create the right image visual
            var rightImageVisual = _compositor.CreateSpriteVisual();

            rightImageVisual.Size = size;

            // Right Image Surface
            var rightImageSurface = await _generator.CreateImageSurfaceAsync(new Uri("ms-appx:///Assets/Images/Image2.jpg"), size.ToSize(), ImageSurfaceOptions.Default);

            // Right Mask Geometry
            _rightGeometry = CanvasGeometry.CreateRectangle(_generator.Device, new Rect(0, 0, 2f * (GridWidth * (100f - _splitValue)) / 100, 2f * GridHeight));

            // Right Masked Brush
            var rightMaskedBrush = _compositor.CreateMaskBrush();

            rightMaskedBrush.Source = _compositor.CreateSurfaceBrush(rightImageSurface);
            _rightGaussianSurface   = _generator.CreateGaussianMaskSurface(size.ToSize(), _rightGeometry, new Vector2(-leftOffset, _topOffset), _blurRadius);
            rightMaskedBrush.Mask   = _compositor.CreateSurfaceBrush(_rightGaussianSurface);
            rightImageVisual.Brush  = rightMaskedBrush;

            var visualContainer = _compositor.CreateContainerVisual();

            visualContainer.Size = size;
            visualContainer.Children.InsertAtTop(leftImageVisual);
            visualContainer.Children.InsertAtTop(rightImageVisual);

            ElementCompositionPreview.SetElementChildVisual(ImageGrid, visualContainer);
        }
Beispiel #2
0
        private async void OnPageLoaded(object sender, RoutedEventArgs e)
        {
            _compositor = Window.Current.Compositor;
            _generator  = _compositor.CreateCompositionGenerator();

            var size = new Vector2(GridWidth, GridWidth);
            // Create the image visual
            var imageVisual = _compositor.CreateSpriteVisual();

            imageVisual.Size = size;
            var imageSurface = await _generator.CreateImageSurfaceAsync(new Uri("ms-appx:///Assets/Images/cat.png"),
                                                                        size.ToSize(), ImageSurfaceOptions.Default);

            imageVisual.Brush = _compositor.CreateSurfaceBrush(imageSurface);
            ElementCompositionPreview.SetElementChildVisual(ImageGrid, imageVisual);

            //Create the mask visual
            var maskVisual = _compositor.CreateSpriteVisual();

            maskVisual.Size = size;

            // Create the combined geometry
            var ellipse1 = CanvasGeometry.CreateEllipse(_generator.Device, GridWidth / 2, GridWidth / 2, GridWidth * 0.375f, GridWidth * 0.1875f);
            var ellipse2 = CanvasGeometry.CreateEllipse(_generator.Device, GridWidth / 2, GridWidth / 2, GridWidth * 0.1875f, GridWidth * 0.375f);

            _combinedGeometry = ellipse1.CombineWith(ellipse2, Matrix3x2.Identity, CanvasGeometryCombine.Union);

            // Create SurfaceBrush from MaskSurface

            ElementCompositionPreview.SetElementChildVisual(MaskGrid, maskVisual);

            var outputVisual = _compositor.CreateSpriteVisual();

            outputVisual.Size = size;

            var maskedBrush = _compositor.CreateMaskBrush();

            maskedBrush.Source = imageVisual.Brush;
            _gaussianSurface   = _generator.CreateGaussianMaskSurface(size.ToSize(), _combinedGeometry, Vector2.Zero, 0);
            maskedBrush.Mask   = _compositor.CreateSurfaceBrush(_gaussianSurface);

            maskVisual.Brush   = _compositor.CreateSurfaceBrush(_gaussianSurface);;
            outputVisual.Brush = maskedBrush;

            ElementCompositionPreview.SetElementChildVisual(OutputGrid, outputVisual);
        }
Beispiel #3
0
 /// <summary>
 /// Creates a custom shaped Effect Brush using BackdropBrush and an IGaussianMaskSurface
 /// </summary>
 /// <param name="compositor">Compositor</param>
 /// <param name="mask">IMaskSurface</param>
 /// <param name="blendColor">Color to blend in the BackdropBrush</param>
 /// <param name="blurRadius">Blur Amount of the Backdrop Brush</param>
 /// <param name="backdropBrush">Backdrop Brush (optional). If not provided, then compositor creates it.</param>
 /// <returns>CompositionEffectBrush</returns>
 public static CompositionEffectBrush CreateGaussianMaskedBackdropBrush(this Compositor compositor, IGaussianMaskSurface mask,
                                                                        Color blendColor, float blurRadius, CompositionBackdropBrush backdropBrush = null)
 {
     return(CompositionExtensions.CreateBackdropBrush(compositor, mask, blendColor, blurRadius, backdropBrush));
 }