public BackDrop() { visual = ElementCompositionPreview.GetElementVisual(this); compositor = visual.Compositor; blurredVisual = compositor.CreateSpriteVisual(); var graphicsEffect = new BlendEffect { Mode = BlendEffectMode.HardLight, Background = new ColorSourceEffect() { Name = "Tint", Color = Color.FromArgb(175, 0, 0, 0), }, Foreground = new GaussianBlurEffect() { Name = "Blur", Source = new CompositionEffectSourceParameter("source"), BlurAmount = 10f, Optimization = EffectOptimization.Balanced, BorderMode = EffectBorderMode.Hard, } }; effectFactory = compositor.CreateEffectFactory(graphicsEffect); var effectBrush = effectFactory.CreateBrush(); effectBrush.SetSourceParameter("source", compositor.CreateBackdropBrush()); blurredVisual.Brush = effectBrush; ElementCompositionPreview.SetElementChildVisual(this, blurredVisual); this.SizeChanged += BackDrop_SizeChanged; }
private void Department_Loaded(object sender, RoutedEventArgs e) { effectVisual = compositor.CreateSpriteVisual(); var destinationBrush = compositor.CreateBackdropBrush(); //Create the Effect you want var graphicsEffect = new GaussianBlurEffect { Name = "Blur", BlurAmount = 0f, BorderMode = EffectBorderMode.Hard, Optimization = EffectOptimization.Balanced, Source = new CompositionEffectSourceParameter("Background") }; effectFactory = compositor.CreateEffectFactory(graphicsEffect, new[] { "Blur.BlurAmount" }); effectBrush = effectFactory.CreateBrush(); effectBrush.SetSourceParameter("Background", destinationBrush); effectVisual.Brush = effectBrush; effectVisual.Size = new System.Numerics.Vector2(900, 400); ElementCompositionPreview.SetElementChildVisual(CoverImage, effectVisual); //Create Spring Animation for nature increase and decrease value _springAnimation = compositor.CreateSpringScalarAnimation(); _springAnimation.Period = TimeSpan.FromSeconds(0.70); //_springAnimation.DampingRatio = 0.25f; }
private void applyBlurBackDrop(Panel panel) { _compositor = ElementCompositionPreview.GetElementVisual(this).Compositor; _blurSprite = _compositor.CreateSpriteVisual(); _blurSprite.Size = new Vector2((float)panel.ActualWidth, (float)panel.ActualHeight); ElementCompositionPreview.SetElementChildVisual(panel, _blurSprite); // Create an effect description GaussianBlurEffect blurEffect = new GaussianBlurEffect() { Name = "Blur", BlurAmount = 2.0f, BorderMode = EffectBorderMode.Hard, Optimization = EffectOptimization.Balanced }; blurEffect.Source = new CompositionEffectSourceParameter("source"); CompositionEffectFactory blurEffectFactory = _compositor.CreateEffectFactory(blurEffect); CompositionEffectBrush blurBrush = blurEffectFactory.CreateBrush(); // Create a BackdropBrush and bind it to the EffectSourceParameter “source” CompositionBackdropBrush backdropBrush = _compositor.CreateBackdropBrush(); blurBrush.SetSourceParameter("source", backdropBrush); _blurSprite.Brush = blurBrush; }
private void Initialize() { _compositor = ElementCompositionPreview.GetElementVisual(this).Compositor; _frostEffect = new GaussianBlurEffect { Name = "Blur", BlurAmount = 0.0f, BorderMode = EffectBorderMode.Hard, Optimization = EffectOptimization.Balanced, Source = new CompositionEffectSourceParameter("backdropBrush") }; // Create an instance of the effect and set its source to a CompositionBackdropBrush _effectFactory = _compositor.CreateEffectFactory(_frostEffect); _backdropBrush = _compositor.CreateHostBackdropBrush(); _effectBrush = _effectFactory.CreateBrush(); // Create a Visual to contain the frosted glass effect _frostVisual = _compositor.CreateSpriteVisual(); _frostVisual.Brush = _effectBrush; _frostVisual.Size = new Vector2((float)ActualWidth, (float)ActualHeight); _effectBrush.SetSourceParameter("backdropBrush", _backdropBrush); // Add the blur as a child of the host in the visual tree ElementCompositionPreview.SetElementChildVisual(this, _frostVisual); }
protected override void OnNavigatedTo(NavigationEventArgs e) { base.OnNavigatedTo(e); _compositor = ElementCompositionPreview.GetElementVisual(this)?.Compositor; _visual = ElementCompositionPreview.GetElementVisual(Image); _pointLight = _compositor.CreatePointLight(); _pointLight.Color = Colors.White; var graphicsEffect = new CompositeEffect { Mode = CanvasComposite.Add, Sources = { new CompositionEffectSourceParameter("ImageSource"), new SceneLightingEffect() { AmbientAmount = 0, DiffuseAmount = .75f, SpecularAmount = 0, } } }; _effectFactory = _compositor.CreateEffectFactory(graphicsEffect); var lightRootVisual = ElementCompositionPreview.GetElementVisual(this); _pointLight.CoordinateSpace = lightRootVisual; _pointLight.Targets.Add(lightRootVisual); var brush = _effectFactory.CreateBrush(); PointerMoved += Lighting_PointerMoved; }
private void CreateBrush() { effectBrush = effectFactory.CreateBrush(); effectBrush.SetSourceParameter(EffectSource, surfaceBrush); effectBrush.Properties.InsertScalar(TemperatureEffectPath, 0f); effectBrush.Properties.InsertScalar(TintEffectPath, 0f); }
private void setupBlurEffect() { Compositor compositor = Window.Current.Compositor; GaussianBlurEffect blurEffect = new GaussianBlurEffect() { BlurAmount = BlurAmount, BorderMode = EffectBorderMode.Soft, Optimization = EffectOptimization.Balanced, Source = new ArithmeticCompositeEffect() { MultiplyAmount = 0, Source1Amount = .7f, Source2Amount = .3f, Source1 = new CompositionEffectSourceParameter("backdrop"), // Source2 = new CompositionEffectSourceParameter("backdrop") Source2 = new ColorSourceEffect() { Color = BlurColor } } }; var backdropBrush = compositor.CreateHostBackdropBrush(); CompositionEffectFactory effectFacotory = compositor.CreateEffectFactory(blurEffect); var blurBrush = effectFacotory.CreateBrush(); blurBrush.SetSourceParameter("backdrop", backdropBrush); CompositionBrush = blurBrush; }
/// <inheritdoc cref="XamlCompositionBrushBase"/> protected override void OnConnected() { if (CompositionBrush == null) { // Effects setup SceneLightingEffect sceneLightingEffect = new SceneLightingEffect // Base lighting effect { Name = "Light", SpecularShine = (float)SpecularShine, SpecularAmount = (float)SpecularAmount, DiffuseAmount = (float)DiffuseAmount, AmbientAmount = 0 }; _LuminanceEffect = new LuminanceToAlphaEffect { Source = sceneLightingEffect }; // Map the bright areas of the light to an opacity mask _InverseEffect = new InvertEffect { Source = _LuminanceEffect }; // Invert the colors to make the brighter areas white _Factory = Window.Current.Compositor.CreateEffectFactory(_InverseEffect, new[] { "Light.DiffuseAmount", "Light.SpecularShine", "Light.SpecularAmount" }); // Create and store the brush _Brush = _Factory.CreateBrush(); CompositionBrush = _Brush; } base.OnConnected(); }
private void Page_Loaded(object sender, RoutedEventArgs e) { //Create Visual to contain effect effectVisual = compositor.CreateSpriteVisual(); var destinationBrush = compositor.CreateBackdropBrush(); //Create the Effect you want var graphicsEffect = new GaussianBlurEffect { Name = "Blur", BlurAmount = 0f, BorderMode = EffectBorderMode.Hard, Source = new CompositionEffectSourceParameter("Background") }; effectFactory = compositor.CreateEffectFactory(graphicsEffect, new[] { "Blur.BlurAmount" }); effectBrush = effectFactory.CreateBrush(); effectBrush.SetSourceParameter("Background", destinationBrush); effectVisual.Brush = effectBrush; //By the default the Visual have the size width and height (defined in Vector 2) 0 and 0 ResizeVisual(); ElementCompositionPreview.SetElementChildVisual(Back, effectVisual); //Create Spring Animation for nature increase and decrease value _springAnimation = compositor.CreateSpringScalarAnimation(); _springAnimation.Period = TimeSpan.FromSeconds(0.5); _springAnimation.DampingRatio = 0.75f; }
//LightingTypes _selectedLight = LightingTypes.PointDiffuse; private void SetImageEffect(CompositionImage image) { if (_effectFactory == null) { return; } // Create the effect brush and bind the normal map CompositionEffectBrush brush = _effectFactory.CreateBrush(); //ComboBoxItem item = LightingSelection.SelectedValue as ComboBoxItem; //switch ((LightingTypes)item.Tag) switch (SelectedLight) { case LightingTypes.SpotLightSpecular: case LightingTypes.PointSpecular: case LightingTypes.DistantDiffuse: case LightingTypes.DistantSpecular: brush.SetSourceParameter("NormalMap", _circleNormalsBrush); break; default: brush.SetSourceParameter("NormalMap", _flatNormalsBrush); break; } // Update the CompositionImage to use the custom effect brush image.Brush = brush; }
async Task CreateTintEffectBrushAsync(Uri uri) { Xamarin.Forms.Image element = this.Element as Xamarin.Forms.Image; if (Control == null || Element == null || element.Width < 0 || element.Height < 0) { return; } SetupCompositor(); spriteVisual = compositor.CreateSpriteVisual(); spriteVisual.Size = new Vector2((float)element.Width, (float)element.Height); imageSurface = await generator.CreateImageSurfaceAsync(uri, new Windows.Foundation.Size(element.Width, element.Height), ImageSurfaceOptions.DefaultOptimized); CompositionSurfaceBrush surfaceBrush = compositor.CreateSurfaceBrush(imageSurface.Surface); CompositionBrush targetBrush = surfaceBrush; if (this.TintColor == Color.Transparent) { // Don't apply tint effect effectBrush = null; } else { // Set target brush to tint effect brush Windows.UI.Color nativeColor = GetNativeColor(this.TintColor); IGraphicsEffect graphicsEffect = new CompositeEffect { Mode = CanvasComposite.DestinationIn, Sources = { new ColorSourceEffect { Name = "colorSource", Color = nativeColor }, new CompositionEffectSourceParameter("mask") } }; CompositionEffectFactory effectFactory = compositor.CreateEffectFactory(graphicsEffect, new[] { "colorSource.Color" }); effectBrush = effectFactory.CreateBrush(); effectBrush.SetSourceParameter("mask", surfaceBrush); SetTint(nativeColor); targetBrush = effectBrush; } spriteVisual.Brush = targetBrush; ElementCompositionPreview.SetElementChildVisual(Control, spriteVisual); }
protected override void OnConnected() { // return if Uri String is null or empty if (String.IsNullOrEmpty(ImageUriString)) { return; } Compositor compositor = Window.Current.Compositor; // Use LoadedImageSurface API to get ICompositionSurface from image uri provided _surface = LoadedImageSurface.StartLoadFromUri(new Uri(ImageUriString)); // Load Surface onto SurfaceBrush _surfaceBrush = compositor.CreateSurfaceBrush(_surface); _surfaceBrush.Stretch = CompositionStretch.UniformToFill; // CompositionCapabilities: Are Tint+Temperature and Saturation supported? bool usingFallback = !CompositionCapabilities.GetForCurrentView().AreEffectsSupported(); if (usingFallback) { // If Effects are not supported, Fallback to image without effects CompositionBrush = _surfaceBrush; return; } // Define Effect graph IGraphicsEffect graphicsEffect = new SaturationEffect { Name = "Saturation", Saturation = 0.3f, Source = new TemperatureAndTintEffect { Name = "TempAndTint", Temperature = 0, Source = new CompositionEffectSourceParameter("Surface"), } }; // Create EffectFactory and EffectBrush CompositionEffectFactory effectFactory = compositor.CreateEffectFactory(graphicsEffect, new[] { "TempAndTint.Temperature" }); CompositionEffectBrush effectBrush = effectFactory.CreateBrush(); effectBrush.SetSourceParameter("Surface", _surfaceBrush); // Set EffectBrush to paint Xaml UIElement CompositionBrush = effectBrush; // Trivial looping animation to demonstrate animated effect ScalarKeyFrameAnimation tempAnim = compositor.CreateScalarKeyFrameAnimation(); tempAnim.InsertKeyFrame(0, 0); tempAnim.InsertKeyFrame(0.5f, 1f); tempAnim.InsertKeyFrame(1, 0); tempAnim.Duration = TimeSpan.FromSeconds(5); tempAnim.IterationBehavior = Windows.UI.Composition.AnimationIterationBehavior.Forever; effectBrush.Properties.StartAnimation("TempAndTint.Temperature", tempAnim); }
private void CreateBrush() { effectBrush = effectFactory.CreateBrush(); effectBrush.SetSourceParameter(EffectSource, surfaceBrush); effectBrush.Properties.InsertScalar(RedExponentEffectPath, 1f); effectBrush.Properties.InsertScalar(GreenExponentEffectPath, 1f); effectBrush.Properties.InsertScalar(BlueExponentEffectPath, 1f); }
public static async Task <AttachedAnimatableCompositionEffect <T> > AttachCompositionAnimatableInAppCustomAcrylicEffectAsync <TSource, T>( [NotNull] this TSource element, [NotNull] T target, float on, float off, bool initiallyVisible, Color color, float colorMix, [CanBeNull] CanvasControl canvas, [NotNull] Uri uri, int timeThreshold = 1000, bool reload = false, bool disposeOnUnload = false) where TSource : FrameworkElement where T : FrameworkElement { // Get the compositor Visual visual = await DispatcherHelper.GetFromUIThreadAsync(element.GetVisual); Compositor compositor = visual.Compositor; // Create the blur effect and the effect factory CompositionBackdropBrush backdropBrush = compositor.CreateBackdropBrush(); GaussianBlurEffect blurEffect = new GaussianBlurEffect { Name = "Blur", BlurAmount = 0f, BorderMode = EffectBorderMode.Hard, Optimization = EffectOptimization.Balanced, Source = new CompositionEffectSourceParameter(nameof(backdropBrush)) }; const String animationPropertyName = "Blur.BlurAmount"; // Prepare the dictionary with the parameters to add IDictionary <String, CompositionBrush> sourceParameters = new Dictionary <String, CompositionBrush> { { nameof(backdropBrush), backdropBrush } }; // Get the noise brush using Win2D IGraphicsEffect source = await AcrylicEffectHelper.ConcatenateEffectWithTintAndBorderAsync(compositor, blurEffect, sourceParameters, color, colorMix, canvas, uri, timeThreshold, reload); // Make sure the Win2D brush was loaded correctly CompositionEffectFactory effectFactory = compositor.CreateEffectFactory(source, new[] { animationPropertyName }); // Create the effect factory and apply the final effect CompositionEffectBrush effectBrush = effectFactory.CreateBrush(); foreach (KeyValuePair <String, CompositionBrush> pair in sourceParameters) { effectBrush.SetSourceParameter(pair.Key, pair.Value); } // Assign the effect to a brush and display it SpriteVisual sprite = compositor.CreateSpriteVisual(); sprite.Brush = effectBrush; await AddToTreeAndBindSizeAsync(target.GetVisual(), target, sprite); if (initiallyVisible) { await DispatcherHelper.RunOnUIThreadAsync(() => element.Opacity = 1); } return(new AttachedAnimatableCompositionEffect <T>(target, sprite, new CompositionAnimationParameters(animationPropertyName, on, off), disposeOnUnload)); }
public static async Task <AttachedCompositeAnimatableCompositionEffect <T> > AttachCompositionAnimatableBlurAndSaturationEffectAsync <T>( [NotNull] this T element, float onBlur, float offBlur, float onSaturation, float offSaturation, bool initiallyVisible, bool disposeOnUnload = false) where T : FrameworkElement { // Get the compositor Visual visual = await DispatcherHelper.GetFromUIThreadAsync(element.GetVisual); Compositor compositor = visual.Compositor; // Create the blur effect, the saturation effect and the effect factory GaussianBlurEffect blurEffect = new GaussianBlurEffect { Name = "Blur", BlurAmount = 0f, BorderMode = EffectBorderMode.Hard, Optimization = EffectOptimization.Balanced, Source = new CompositionEffectSourceParameter("source") }; SaturationEffect saturationEffect = new SaturationEffect { Name = "SEffect", Saturation = initiallyVisible ? offSaturation : onSaturation, Source = blurEffect }; const String blurParameter = "Blur.BlurAmount", saturationParameter = "SEffect.Saturation"; CompositionEffectFactory effectFactory = compositor.CreateEffectFactory(saturationEffect, new[] { blurParameter, saturationParameter }); // Setup the rest of the effect CompositionEffectBrush effectBrush = effectFactory.CreateBrush(); effectBrush.SetSourceParameter("source", compositor.CreateBackdropBrush()); // Assign the effect to a brush and display it SpriteVisual sprite = compositor.CreateSpriteVisual(); sprite.Brush = effectBrush; await AddToTreeAndBindSizeAsync(visual, element, sprite); if (initiallyVisible) { await DispatcherHelper.RunOnUIThreadAsync(() => element.Opacity = 1); } // Prepare and return the wrapped effect return(new AttachedCompositeAnimatableCompositionEffect <T>(element, sprite, new Dictionary <String, CompositionAnimationValueParameters> { { blurParameter, new CompositionAnimationValueParameters(onBlur, offBlur) }, { saturationParameter, new CompositionAnimationValueParameters(onSaturation, offSaturation) } }, disposeOnUnload)); }
protected override void OnConnected() { Compositor compositor = Window.Current.Compositor; // CompositionCapabilities: Are Effects supported? bool usingFallback = !CompositionCapabilities.GetForCurrentView().AreEffectsSupported(); if (usingFallback) { // If Effects are not supported, use Fallback Solid Color CompositionBrush = compositor.CreateColorBrush(FallbackColor); return; } // Define Effect graph var graphicsEffect = new BlendEffect { Mode = BlendEffectMode.LinearBurn, Background = new ColorSourceEffect() { Name = "Tint", Color = Windows.UI.Colors.Silver, }, Foreground = new GaussianBlurEffect() { Name = "Blur", Source = new CompositionEffectSourceParameter("Backdrop"), BlurAmount = 0, BorderMode = EffectBorderMode.Hard, } }; // Create EffectFactory and EffectBrush CompositionEffectFactory effectFactory = compositor.CreateEffectFactory(graphicsEffect, new[] { "Blur.BlurAmount" }); CompositionEffectBrush effectBrush = effectFactory.CreateBrush(); // Create BackdropBrush CompositionBackdropBrush backdrop = compositor.CreateBackdropBrush(); effectBrush.SetSourceParameter("backdrop", backdrop); // Trivial looping animation to demonstrate animated effects TimeSpan _duration = TimeSpan.FromSeconds(5); ScalarKeyFrameAnimation blurAnimation = compositor.CreateScalarKeyFrameAnimation(); blurAnimation.InsertKeyFrame(0, 0); blurAnimation.InsertKeyFrame(0.5f, 10f); blurAnimation.InsertKeyFrame(1, 0); blurAnimation.IterationBehavior = AnimationIterationBehavior.Forever; blurAnimation.Duration = _duration; effectBrush.Properties.StartAnimation("Blur.BlurAmount", blurAnimation); // Set EffectBrush to paint Xaml UIElement CompositionBrush = effectBrush; }
/// <summary> /// Returns the effect brush for this model. If a brush has not beeen created, one is created /// given CreateEffectFactory has been assigned. /// </summary> /// <returns>CompositionEffectBrush</returns> public CompositionEffectBrush GetEffectBrush() { if (_brush == null && CreateEffectFactory != null) { if (_factory == null) { _factory = CreateEffectFactory(); } _brush = _factory.CreateBrush(); } return(_brush); }
private void OnLayerChanged(object sender, string property) { try { IGraphicsEffect effectGraph = Layer.GenerateEffectGraph(true); CompositionEffectFactory effectFactory = _previewSprite.Compositor.CreateEffectFactory(effectGraph, null); _previewSprite.Brush = effectFactory.CreateBrush(); Layer.UpdateResourceBindings((CompositionEffectBrush)_previewSprite.Brush); } catch { _previewSprite.Brush = null; } LayerDescription.Text = Layer.Description; }
override protected void OnConnected() { Compositor compositor = Window.Current.Compositor; // CompositionCapabilities: Are HostBackdrop Effects supported? bool usingFallback = !CompositionCapabilities.GetForCurrentView().AreEffectsFast(); if (usingFallback) { // If Effects are not supported, use Fallback Solid Color CompositionBrush = compositor.CreateColorBrush(FallbackColor); return; } // Define Effect graph var graphicsEffect = new BlendEffect { Mode = BlendEffectMode.Overlay, Background = new CompositionEffectSourceParameter("Backdrop"), Foreground = new ColorSourceEffect() { Name = "OverlayColor", Color = OverlayColor, }, }; // Create EffectFactory and EffectBrush CompositionEffectFactory effectFactory = compositor.CreateEffectFactory(graphicsEffect, new[] { "OverlayColor.Color" }); CompositionEffectBrush effectBrush = effectFactory.CreateBrush(); // Create HostBackdropBrush, a kind of BackdropBrush that provides blurred backdrop content CompositionBackdropBrush hostBrush = compositor.CreateHostBackdropBrush(); effectBrush.SetSourceParameter("Backdrop", hostBrush); // Set EffectBrush as the brush that XamlCompBrushBase paints onto Xaml UIElement CompositionBrush = effectBrush; // When the Window loses focus, animate HostBackdrop to FallbackColor Window.Current.CoreWindow.Activated += CoreWindow_Activated; // Configure color animation to for state change _stateChangeAnimation = compositor.CreateColorKeyFrameAnimation(); _stateChangeAnimation.InsertKeyFrame(0, OverlayColor); _stateChangeAnimation.InsertKeyFrame(1, FallbackColor); _stateChangeAnimation.Duration = TimeSpan.FromSeconds(1); }
protected override void OnConnected() { Compositor compositor = Window.Current.Compositor; // CompositionCapabilities: Are Effects supported? bool usingFallback = !CompositionCapabilities.GetForCurrentView().AreEffectsSupported(); FallbackColor = Color.FromArgb(100, 100, 100, 100); if (usingFallback) { // If Effects are not supported, use Fallback Solid Color CompositionBrush = compositor.CreateColorBrush(FallbackColor); return; } // Define Effect graph var graphicsEffect = new BlendEffect { Mode = BlendEffectMode.SoftLight, Background = new ColorSourceEffect() { Name = "Tint", //Color = Color.FromArgb(180, 255, 255, 255), Color = Color.FromArgb(150, 255, 255, 255), }, Foreground = new GaussianBlurEffect() { Name = "Blur", Source = new CompositionEffectSourceParameter("Backdrop"), BlurAmount = 20, BorderMode = EffectBorderMode.Hard, } }; // Create EffectFactory and EffectBrush CompositionEffectFactory effectFactory = compositor.CreateEffectFactory(graphicsEffect); CompositionEffectBrush effectBrush = effectFactory.CreateBrush(); // Create BackdropBrush CompositionBackdropBrush backdrop = compositor.CreateBackdropBrush(); effectBrush.SetSourceParameter("Backdrop", backdrop); // Set EffectBrush as the brush that XamlCompBrushBase paints onto Xaml UIElement CompositionBrush = effectBrush; }
private static CompositionBrush CreateGrayscaleBrush() { Matrix5x4 grayscaleMatrix = CreateGrayscaleMatrix(); ColorMatrixEffect grayscaleMatrixEffect = new ColorMatrixEffect { ColorMatrix = grayscaleMatrix, Source = new CompositionEffectSourceParameter("source") }; CompositionEffectFactory grayscaleEffectFactory = _compositor.CreateEffectFactory(grayscaleMatrixEffect); var backdropBrush = grayscaleEffectFactory.CreateBrush(); backdropBrush.SetSourceParameter("source", _compositor.CreateBackdropBrush()); return(backdropBrush); }
private async void UpdateBrush() { if (_layerInvalidated) { // Clear the old brush _effectBrush = null; IGraphicsEffect effecGraph = _groupLayer.GenerateEffectGraph(false); if (effecGraph != null) { try { CompositionEffectFactory effectFactory = _compositor.CreateEffectFactory(effecGraph, null); _effectBrush = effectFactory.CreateBrush(); foreach (Layer layer in _groupLayer.Layers) { if (layer.Enabled) { layer.UpdateResourceBindings(_effectBrush); } } } catch (Exception e) { ContentDialog dialog = new ContentDialog() { Title = "Failed to create effect", Content = String.Format("The effect creation failed with the following error. Please simplify your material.\r\n\r\n\"{0}\"", e.Message.ToString().Replace("\r\n", " ")), PrimaryButtonText = "OK", IsSecondaryButtonEnabled = false, }; await dialog.ShowAsync(); // Clear out the old effect _effectBrush = null; } // Clear the flag _layerInvalidated = false; } _brushChangedHandler(this); } }
public async void animateBackGround(string img) { await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { blurredVisual.StartAnimation(nameof(Opacity), fadeOutAnimation); var image = imageFactory.CreateImageFromUri(new Uri(img)); var surfaceBrush = compositor.CreateSurfaceBrush(image.Surface); var effectBrush = effectFactory.CreateBrush(); effectBrush.SetSourceParameter("source", surfaceBrush); blurredVisual.Brush = effectBrush; blurredVisual.Size = getBackgroundSize(); blurredVisual.CenterPoint = new Vector3(getBackgroundSize().X / 2, getBackgroundSize().Y / 2, 0); ElementCompositionPreview.SetElementChildVisual(bgImage, blurredVisual); blurredVisual.StartAnimation(nameof(Opacity), fadeInAnimation); }); }
private void InitializeFrostedGlass(float width, float height, Color color, float blurAmout, byte alpha, float multiply, float backAmout, float frontAmout) { Visual hostedVisual = ElementCompositionPreview.GetElementVisual(glassGrid); Compositor compositor = hostedVisual.Compositor; GaussianBlurEffect blurEffect = new GaussianBlurEffect() { BlurAmount = blurAmout, BorderMode = EffectBorderMode.Hard, Source = new ArithmeticCompositeEffect() { MultiplyAmount = multiply, Source1Amount = backAmout, Source2Amount = frontAmout, Source1 = new CompositionEffectSourceParameter("BackBrush"), Source2 = new ColorSourceEffect() { Color = Color.FromArgb(alpha, color.R, color.G, color.B) } } }; CompositionEffectFactory factory = compositor.CreateEffectFactory(blurEffect); CompositionBackdropBrush backdropBrush; if (Hosted) { backdropBrush = compositor.CreateHostBackdropBrush(); } else { backdropBrush = compositor.CreateBackdropBrush(); } CompositionEffectBrush brush = factory.CreateBrush(); brush.SetSourceParameter("BackBrush", backdropBrush); SpriteVisual glassVisual = compositor.CreateSpriteVisual(); glassVisual.Size = new Vector2() { X = width, Y = height }; glassVisual.Brush = brush; ElementCompositionPreview.SetElementChildVisual(glassGrid, glassVisual); }
private void Create() { if (_effectFactory == null) { var color = new ColorSourceEffect { Name = "Colour", Color = this.TintColor }; var opacity = new OpacityEffect { Name = "Opacity", Opacity = 0f, Source = color }; var blurEffect = new GaussianBlurEffect { Name = "Blur", BlurAmount = 0, Optimization = EffectOptimization.Speed, BorderMode = EffectBorderMode.Hard, BufferPrecision = Microsoft.Graphics.Canvas.CanvasBufferPrecision.Precision16Float, Source = new CompositionEffectSourceParameter("Source") }; var blend = new BlendEffect { Background = blurEffect, Foreground = opacity, Mode = BlendEffectMode.SoftLight, }; _effectFactory = _compositor.CreateEffectFactory( blend, new string[] { "Blur.BlurAmount", "Colour.Color", "Opacity.Opacity" }); } var brush = _effectFactory.CreateBrush(); brush.SetSourceParameter("Source", _compositor.CreateHostBackdropBrush()); this.CompositionBrush = brush; UpdateBlur(); UpdateColor(); }
private SpriteVisual CreateExclusionBlendVisual() { SpriteVisual blendVisual = _compositor.CreateSpriteVisual(); blendVisual.Opacity = 1f; IGraphicsEffect exclusionBlendEffect = new Microsoft.Graphics.Canvas.Effects.BlendEffect { Mode = BlendEffectMode.Exclusion }; CompositionEffectFactory exclusionBlendFactory = _compositor.CreateEffectFactory(exclusionBlendEffect); CompositionEffectBrush exlcusionBrush = exclusionBlendFactory.CreateBrush(); blendVisual.Brush = exlcusionBrush; return(blendVisual); }
async Task CreateTintEffectBrushAsync(Uri uri) { if (Control == null || Element == null || Element.Width < 0 || Element.Height < 0) { return; } Debug.WriteLine("Creating Tint Effect Brush"); SetupCompositor(); spriteVisual = compositor.CreateSpriteVisual(); spriteVisual.Size = new Vector2((float)Element.Width, (float)Element.Height); imageSurface = await generator.CreateImageSurfaceAsync(uri, new Size(Element.Width, Element.Height), ImageSurfaceOptions.DefaultOptimized); CompositionSurfaceBrush surfaceBrush = compositor.CreateSurfaceBrush(imageSurface.Surface); Windows.UI.Color nativeColor = GetNativeColor(((TintedImage)Element).TintColor); IGraphicsEffect graphicsEffect = new CompositeEffect { Mode = CanvasComposite.DestinationIn, Sources = { new ColorSourceEffect { Name = "colorSource", Color = nativeColor }, new CompositionEffectSourceParameter("mask") } }; CompositionEffectFactory effectFactory = compositor.CreateEffectFactory(graphicsEffect, new[] { "colorSource.Color" }); effectBrush = effectFactory.CreateBrush(); effectBrush.SetSourceParameter("mask", surfaceBrush); SetTint(nativeColor); spriteVisual.Brush = effectBrush; ElementCompositionPreview.SetElementChildVisual(Control, spriteVisual); }
public CompositionEffectBrush CreateEffectBrush( EffectType effectType, string effectName, float propertyValue, IEnumerable <string> properties) { IGraphicsEffect effectDesc = null; switch (effectType) { case EffectType.Saturation: effectDesc = new SaturationEffect() { Name = effectName, Saturation = propertyValue, Source = new CompositionEffectSourceParameter("source") }; break; case EffectType.HueRotation: effectDesc = new HueRotationEffect() { Name = effectName, Angle = propertyValue, Source = new CompositionEffectSourceParameter("source") }; break; case EffectType.Sepia: effectDesc = new SepiaEffect() { Name = effectName, Intensity = propertyValue, Source = new CompositionEffectSourceParameter("source") }; break; } CompositionEffectFactory effectFactory = _compositor.CreateEffectFactory(effectDesc, properties); CompositionEffectBrush effectBrush = effectFactory.CreateBrush(); return(effectBrush); }
private void SetImageEffect(CompositionImage image) { // Create the effect brush and bind the normal map CompositionEffectBrush brush = _effectFactory.CreateBrush(); ComboBoxItem item = LightingSelection.SelectedValue as ComboBoxItem; switch ((LightingTypes)item.Tag) { case LightingTypes.SpotLightSpecular: case LightingTypes.PointSpecular: brush.StartAnimation("Light1.LightPosition", _lightPositionAnimation); brush.StartAnimation("Light1.LightColor", _lightColorAnimation); brush.StartAnimation("Light2.LightPosition", _lightPositionAnimation); brush.StartAnimation("Light2.LightColor", _lightColorAnimation); brush.SetSourceParameter("NormalMap", _circleNormalsBrush); break; case LightingTypes.DistantDiffuse: brush.SetSourceParameter("NormalMap", _circleNormalsBrush); brush.StartAnimation("Light1.Azimuth", _lightAzimuthAnimation); brush.StartAnimation("Light1.Elevation", _lightElevationAnimation); break; case LightingTypes.DistantSpecular: brush.SetSourceParameter("NormalMap", _circleNormalsBrush); brush.StartAnimation("Light1.Azimuth", _lightAzimuthAnimation); brush.StartAnimation("Light1.Elevation", _lightElevationAnimation); brush.StartAnimation("Light2.Azimuth", _lightAzimuthAnimation); brush.StartAnimation("Light2.Elevation", _lightElevationAnimation); break; default: brush.StartAnimation("Light1.LightPosition", _lightPositionAnimation); brush.StartAnimation("Light1.LightColor", _lightColorAnimation); brush.SetSourceParameter("NormalMap", _flatNormalsBrush); break; } // Update the CompositionImage to use the custom effect brush image.Brush = brush; }
private SpriteVisual CreateGaussianBlurVisual() { GaussianBlurEffect blurEffect = new GaussianBlurEffect() { Name = "Blur", BlurAmount = 20.0f, BorderMode = EffectBorderMode.Hard, Source = new CompositionEffectSourceParameter("BlurSource") }; CompositionEffectFactory blurEffectFactory = _compositor.CreateEffectFactory(blurEffect); CompositionEffectBrush blurBrush = blurEffectFactory.CreateBrush(); SpriteVisual blurSpriteVisual = _compositor.CreateSpriteVisual(); blurSpriteVisual.Brush = blurBrush; blurSpriteVisual.Opacity = 1f; return(blurSpriteVisual); }