private async void ApplyEffect(CompositionImage image) { Task <CompositionDrawingSurface> task = null; // If we've requested a load time effect input, kick it off now if (_currentTechnique.LoadTimeEffectHandler != null) { task = SurfaceLoader.LoadFromUri(image.Source, Size.Empty, _currentTechnique.LoadTimeEffectHandler); } // Create the new brush, set the inputs and set it on the image CompositionEffectBrush brush = _currentTechnique.CreateBrush(); brush.SetSourceParameter("ImageSource", image.SurfaceBrush); image.Brush = brush; // If we've got an active task, wait for it to finish if (task != null) { CompositionDrawingSurface effectSurface = await task; // Set the effect surface as input brush.SetSourceParameter("EffectSource", _compositor.CreateSurfaceBrush(effectSurface)); } }
/// <summary> /// Initializes new instance of the <see cref="BaseBackDrop"/> class. /// </summary> /// <param name="useHostBackdrop">Enables host backdrop is platform supports it.</param> public BaseBackDrop(bool useHostBackdrop = false) { m_rootVisual = ElementCompositionPreview.GetElementVisual(this as UIElement); Compositor = m_rootVisual.Compositor; m_blurVisual = Compositor.CreateSpriteVisual(); m_noiseBrush = Compositor.CreateSurfaceBrush(); CompositionEffectBrush brush = BuildBlurBrush(); if (useHostBackdrop && IsHostBackDropSupported) { brush.SetSourceParameter("source", m_compositor.CreateHostBackdropBrush()); } else { brush.SetSourceParameter("source", m_compositor.CreateBackdropBrush()); } m_blurBrush = brush; m_blurVisual.Brush = m_blurBrush; BlurAmount = 9; //TintColor = Colors.Transparent; ElementCompositionPreview.SetElementChildVisual(this as UIElement, m_blurVisual); this.Loading += OnLoading; this.Unloaded += OnUnloaded; }
public HostBackDrop() { m_rootVisual = ElementCompositionPreview.GetElementVisual(this as UIElement); Compositor = m_rootVisual.Compositor; m_blurVisual = Compositor.CreateSpriteVisual(); #if SDKVERSION_14393 CompositionEffectBrush brush = BuildBlurBrush(); try { brush.SetSourceParameter("source", m_compositor.CreateHostBackdropBrush()); } catch { 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.Transparent); m_blurVisual.Brush = m_blurBrush; #endif ElementCompositionPreview.SetElementChildVisual(this as UIElement, m_blurVisual); this.Loading += OnLoading; this.Unloaded += OnUnloaded; }
//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; }
private async void OnUriChanged() { if (_uri == null) { ReleaseContent(); return; } _surface = await SurfaceLoader.LoadFromUri(_uri); if (_loadEffectDelegate != null) { _effectSurface = await SurfaceLoader.LoadFromUri(_uri, Size.Empty, _loadEffectDelegate); } // Async operations may take a while. If we've unloaded, return now. if (_unloaded) { ReleaseContent(); return; } // Apply stretching policy ApplyStretchingPolicy(new Size(ActualWidth, ActualHeight)); if (_effectBrush == null) { CompositionSurfaceBrush brush = (CompositionSurfaceBrush)_sprite.Brush; if (brush != null) { brush.Surface = _surface; } else { _sprite.Brush = _compositor.CreateSurfaceBrush(_surface); } } else { _effectBrush.SetSourceParameter("ImageSource", _compositor.CreateSurfaceBrush(_surface)); if (_effectSurface != null) { _effectBrush.SetSourceParameter("EffectSource", _compositor.CreateSurfaceBrush(_effectSurface)); } _sprite.Brush = _effectBrush; } }
public async void SetEffectBrush(CompositionEffectBrush brush) { // Release previous brush if set if (_effectBrush != null) { _effectBrush.Dispose(); _effectBrush = null; } if (_effectSurface != null) { _effectSurface.Dispose(); _effectSurface = null; } _effectBrush = brush; // Set the new brush if (_sprite != null) { // Release current brush if (_sprite.Brush != null) { _sprite.Brush.Dispose(); } if (_surface != null) { // If the effect brush is cleared, create a surface brush if (_effectBrush == null) { _sprite.Brush = _compositor.CreateSurfaceBrush(_surface); } else { _effectBrush.SetSourceParameter("ImageSource", _compositor.CreateSurfaceBrush(_surface)); if (_loadEffectDelegate != null) { _effectSurface = await SurfaceLoader.LoadFromUri(_uri, Size.Empty, _loadEffectDelegate); _effectBrush.SetSourceParameter("EffectSource", _compositor.CreateSurfaceBrush(_effectSurface)); } _sprite.Brush = _effectBrush; } } } }
public BackDrop() { if (ApiInformation.IsMethodPresent("Windows.UI.Composition.Compositor", "CreateBackdropBrush")) { m_rootVisual = ElementCompositionPreview.GetElementVisual(this as UIElement); Compositor = m_rootVisual.Compositor; m_blurBrush = BuildBlurBrush(); m_blurBrush.SetSourceParameter("source", m_compositor.CreateBackdropBrush()); m_blurVisual = Compositor.CreateSpriteVisual(); m_blurVisual.Brush = m_blurBrush; BlurAmount = 9; TintColor = Colors.Transparent; ElementCompositionPreview.SetElementChildVisual(this as UIElement, m_blurVisual); this.Loading += OnLoading; this.Unloaded += OnUnloaded; } else { } }
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 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 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); }
private void Load_Completed(LoadedImageSurface sender, LoadedImageSourceLoadCompletedEventArgs e) { IsImageLoading = false; if (e.Status == LoadedImageSourceLoadStatus.Success) { var compositor = Window.Current.Compositor; var brush = compositor.CreateSurfaceBrush(_surface); brush.Stretch = CompositionStretch.UniformToFill; // Create effects chain. saturationEffect = new SaturationEffect() { Name = "SaturationEffect", Saturation = (float)SaturationAmount, Source = new CompositionEffectSourceParameter("image") }; contrastEffect = new ContrastEffect() { Name = "ContrastEffect", Contrast = (float)ContrastAmount, Source = saturationEffect }; exposureEffect = new ExposureEffect() { Name = "ExposureEffect", Source = contrastEffect, Exposure = (float)ExposureAmount, }; temperatureAndTintEffect = new TemperatureAndTintEffect() { Name = "TemperatureAndTintEffect", Source = exposureEffect, Temperature = (float)TemperatureAmount, Tint = (float)TintAmount }; graphicsEffect = new GaussianBlurEffect() { Name = "Blur", Source = temperatureAndTintEffect, BlurAmount = (float)BlurAmount, BorderMode = EffectBorderMode.Hard, }; var graphicsEffectFactory = compositor.CreateEffectFactory(graphicsEffect, new[] { "SaturationEffect.Saturation", "ExposureEffect.Exposure", "Blur.BlurAmount", "TemperatureAndTintEffect.Temperature", "TemperatureAndTintEffect.Tint", "ContrastEffect.Contrast" }); combinedBrush = graphicsEffectFactory.CreateBrush(); combinedBrush.SetSourceParameter("image", brush); // Composition Brush is what is being applied to the UI Element. CompositionBrush = combinedBrush; } else { LoadImageFromPath("ms-appx:///Assets/StoreLogo.png"); } }
private void CreateBrush() { effectBrush = effectFactory.CreateBrush(); effectBrush.SetSourceParameter(EffectSource, surfaceBrush); effectBrush.Properties.InsertScalar(TemperatureEffectPath, 0f); effectBrush.Properties.InsertScalar(TintEffectPath, 0f); }
public BackDrop() { if (DesignMode.DesignModeEnabled) { return; } m_rootVisual = ElementCompositionPreview.GetElementVisual(this as UIElement); Compositor = m_rootVisual.Compositor; m_blurVisual = Compositor.CreateSpriteVisual(); #if SDKVERSION_14393 m_noiseBrush = Compositor.CreateSurfaceBrush(); 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; }
private void InitializeBrushes() { if (this.DataContext is ViewImageEditorMetadata) { var viewImageEditorMetadata = (ViewImageEditorMetadata)this.DataContext; // noeffect brush Size imageSize; //m_noEffectBrush = CreateBrushFromAsset("xxxxx.jpg", out imageSize); m_noEffectBrush = CreateBrushFromAsset(viewImageEditorMetadata.Bitmap, out imageSize); m_imageAspectRatio = (imageSize.Width == 0 && imageSize.Height == 0) ? 1 : imageSize.Width / imageSize.Height; renderSurface.UpdateLayout(); ResizeImage(new Size(renderSurface.ActualWidth, renderSurface.ActualHeight)); // Exposure var exposureEffectDesc = new ExposureEffect { Name = "effect", Source = new CompositionEffectSourceParameter("Image") }; m_exposureEffectBrush = m_compositor.CreateEffectFactory(exposureEffectDesc, new[] { "effect.Exposure" }).CreateBrush(); ChangeExposureValue(0.5f); m_exposureEffectBrush.SetSourceParameter("Image", m_noEffectBrush); // monochromatic gray var grayscaleEffectDesc = new GrayscaleEffect { Name = "effect", Source = new CompositionEffectSourceParameter("Image") }; m_grayscaleEffectBrush = m_compositor.CreateEffectFactory(grayscaleEffectDesc).CreateBrush(); m_grayscaleEffectBrush.SetSourceParameter("Image", m_noEffectBrush); } }
public void CreateAnimation() { _compositor = ElementCompositionPreview.GetElementVisual(this).Compositor; var blurEffect = new GaussianBlurEffect { Name = "Blur", BlurAmount = 5, BorderMode = EffectBorderMode.Hard, Source = new CompositionEffectSourceParameter("backdropBrush") }; var animation = _compositor.CreateScalarKeyFrameAnimation(); animation.InsertKeyFrame(0.0f, 0.0f); animation.InsertKeyFrame(1.0f, 100.0f); animation.Duration = TimeSpan.FromSeconds(4); var effectFactory = _compositor.CreateEffectFactory(blurEffect, new[] { "Blur.BlurAmount" }); _effectBrush = effectFactory.CreateBrush(); var backdropBrush = _compositor.CreateBackdropBrush(); _effectBrush.SetSourceParameter("backdropBrush", backdropBrush); var spriteVisual = _compositor.CreateSpriteVisual(); spriteVisual.Size = new System.Numerics.Vector2((float)Err_Image.ActualWidth, (float)Err_Image.ActualHeight); spriteVisual.Brush = _effectBrush; ElementCompositionPreview.SetElementChildVisual(Err_Image, spriteVisual); spriteVisual.Brush.StartAnimation("Blur.BlurAmount", animation); }
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; }
public BackDrop() { var myBackingVisual = ElementCompositionPreview.GetElementVisual(this as UIElement); m_compositor = myBackingVisual.Compositor; m_blurBrush = BuildColoredBlurMixerBrush(); m_blurBrush.SetSourceParameter("source", m_compositor.CreateBackdropBrush()); m_blurVisual = m_compositor.CreateSpriteVisual(); m_blurVisual.Brush = m_blurBrush; m_blurVisual.Properties.InsertScalar("BlurValue", 10.0f); m_blurVisual.Properties.InsertScalar("FadeValue", 1.0f); SetupPropertySetExpression(); m_container = m_compositor.CreateContainerVisual(); m_container.Children.InsertAtTop(m_blurVisual); //CreateDropshadow(); ElementCompositionPreview.SetElementChildVisual(this as UIElement, m_container); this.Loading += OnLoading; this.Unloaded += OnUnloaded; }
private void InitializeCompositor() { compositor = ElementCompositionPreview.GetElementVisual(this).Compositor; InitializeEffects(); MainImage.Source = item.ImageSource; MainImage.InvalidateArrange(); var destinationBrush = compositor.CreateBackdropBrush(); var graphicsEffectFactory = compositor.CreateEffectFactory(graphicsEffect, new[] { "SaturationEffect.Saturation", "ExposureEffect.Exposure", "Blur.BlurAmount", "TemperatureAndTintEffect.Temperature", "TemperatureAndTintEffect.Tint", "ContrastEffect.Contrast" }); combinedBrush = graphicsEffectFactory.CreateBrush(); combinedBrush.SetSourceParameter("Backdrop", destinationBrush); var effectSprite = compositor.CreateSpriteVisual(); effectSprite.Size = new Vector2((float)item.ImageSource.PixelWidth, (float)item.ImageSource.PixelHeight); effectSprite.Brush = combinedBrush; ElementCompositionPreview.SetElementChildVisual(MainImage, effectSprite); editingInitialized = true; }
public void Do() { Visual hostVisual = ElementCompositionPreview.GetElementVisual(Err_Image); comp = ElementCompositionPreview.GetElementVisual(this).Compositor; var blurEffect = new GaussianBlurEffect { Name = "Blur", BlurAmount = (float)blur_Slider.Value, BorderMode = EffectBorderMode.Hard, Source = new CompositionEffectSourceParameter("backdropBrush") //Source = new ArithmeticCompositeEffect //{ // MultiplyAmount = 0, // Source1Amount = 0.5f, // Source2Amount = 0.5f, // Source1 = new CompositionEffectSourceParameter("backdropBrush"), // Source2 = new ColorSourceEffect // { // Color = Color.FromArgb(255,255,255,255) // } //} }; var effectFactory = comp.CreateEffectFactory(blurEffect, new[] { "Blur.BlurAmount" }); _effectBrush = effectFactory.CreateBrush(); var backdropBrush = comp.CreateBackdropBrush(); _effectBrush.SetSourceParameter("backdropBrush", backdropBrush); var blurVisual = comp.CreateSpriteVisual(); blurVisual.Size = new System.Numerics.Vector2((float)Err_Image.ActualWidth, (float)Err_Image.ActualHeight); blurVisual.Brush = _effectBrush; ElementCompositionPreview.SetElementChildVisual(Err_Image, blurVisual); }
public MainPage() { this.InitializeComponent(); MainGrid.SizeChanged += OnMainGridSizeChanged; compositor = ElementCompositionPreview.GetElementVisual(MainGrid).Compositor; // we create the effect. // Notice the Source parameter definition. Here we tell the effect that the source will come from another element/object var blurEffect = new GaussianBlurEffect { Name = "Blur", Source = new CompositionEffectSourceParameter("background"), BlurAmount = 100f, BorderMode = EffectBorderMode.Hard, }; // we convert the effect to a blur that can be used to paint the visual layer var blurEffectFactory = compositor.CreateEffectFactory(blurEffect); brush = blurEffectFactory.CreateBrush(); // We create a special brush to get the image output of the previous layer. // we are basically chaining the layer (xaml grid -> rendered bitmap of the grid -> blur effect -> screen) var destinationBrush = compositor.CreateBackdropBrush(); brush.SetSourceParameter("background", destinationBrush); // we create the visual sprite that will hold our generated bitmap (the blurred grid) // Visual Sprite are "raw" elements so there is no automatic layouting. You have to specify the size yourself var blurSprite = compositor.CreateSpriteVisual(); blurSprite.Size = new Vector2((float)MainGrid.ActualWidth, (float)MainGrid.ActualHeight); blurSprite.Brush = brush; // we add our sprite to the rendering pipeline ElementCompositionPreview.SetElementChildVisual(MainGrid, blurSprite); }
public override void UpdateResourceBindings(CompositionEffectBrush brush) { if (_surface != null) { _brush.Surface = _surface.Surface; if (EdgeMode == EdgeMode.Ninegrid) { _nineGrid.Source = _brush; brush.SetSourceParameter(_id + "Image", _nineGrid); } else { brush.SetSourceParameter(_id + "Image", _brush); } } }
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); }
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); }
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 override CompositionEffectBrush CreateBrush() { CompositionEffectBrush brush = base.CreateBrush(); brush.SetSourceParameter("LightMap", _lightMap.Brush); return(brush); }
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)); }
protected override CompositionBrush CreateBrush() { _compositor = Window.Current.Compositor; _foregroundBrush = _compositor.CreateLinearGradientBrush(); _foregroundBrush.StartPoint = Vector2.Zero; _foregroundBrush.EndPoint = new Vector2(1.0f); _bottomRightGradientStop = _compositor.CreateColorGradientStop(); _bottomRightGradientStop.Offset = 0.5f; _bottomRightGradientStop.Color = Green; _topLeftradientStop = _compositor.CreateColorGradientStop(); _topLeftradientStop.Offset = 0.5f; _topLeftradientStop.Color = Blue; _foregroundBrush.ColorStops.Add(_bottomRightGradientStop); _foregroundBrush.ColorStops.Add(_topLeftradientStop); _backgroundBrush = _compositor.CreateLinearGradientBrush(); _backgroundBrush.StartPoint = new Vector2(1.0f, 0); _backgroundBrush.EndPoint = new Vector2(0, 1.0f); _topRightGradientStop = _compositor.CreateColorGradientStop(); _topRightGradientStop.Offset = 0.25f; _topRightGradientStop.Color = Black; _bottomLeftGradientStop = _compositor.CreateColorGradientStop(); _bottomLeftGradientStop.Offset = 1.0f; _bottomLeftGradientStop.Color = Black; _backgroundBrush.ColorStops.Add(_topRightGradientStop); _backgroundBrush.ColorStops.Add(_bottomLeftGradientStop); var graphicsEffect = new BlendEffect() { Mode = BlendEffectMode.Screen, Foreground = new CompositionEffectSourceParameter("Main"), Background = new CompositionEffectSourceParameter("Tint"), }; var effectFactory = _compositor.CreateEffectFactory(graphicsEffect); _brush = effectFactory.CreateBrush(); _brush.SetSourceParameter("Main", _foregroundBrush); _brush.SetSourceParameter("Tint", _backgroundBrush); return(_brush); }
public CompositionBrush Build( Color luminosityColor) { var adjustedTintOpacity = Math.Clamp(TintOpacity, 0, 1); adjustedTintOpacity = 0.3f + 0.7f * adjustedTintOpacity; IGraphicsEffectSource backDropEffectSource = new CompositionEffectSourceParameter("Backdrop"); var luminosityColorEffect = new ColorSourceEffect() { Name = "LuminosityColor", Color = luminosityColor }; var graphicsEffect = new ArithmeticCompositeEffect { Source1 = backDropEffectSource, Source2 = luminosityColorEffect, MultiplyAmount = 0, Source1Amount = 1 - adjustedTintOpacity, Source2Amount = adjustedTintOpacity, Offset = 0 }; //IGraphicsEffectSource noiseEffectSource = new CompositionEffectSourceParameter("Noise"); //var noiseBorderEffect = new BorderEffect() //{ // ExtendX = CanvasEdgeBehavior.Wrap, // ExtendY = CanvasEdgeBehavior.Wrap, // Source = noiseEffectSource, //}; //var noiseOpacityEffect = new OpacityEffect() //{ // Name = "NoiseOpacity", // Opacity = 0.5f, // Source = noiseBorderEffect, //}; //var finalEffect = new CrossFadeEffect() //{ // Name = "FadeInOut", // Source1 = graphicsEffect, // Source2 = noiseOpacityEffect //}; var effectFactory = Window.Current.Compositor.CreateEffectFactory(graphicsEffect); CompositionEffectBrush brush = effectFactory.CreateBrush(); var hostBackdropBrush = Window.Current.Compositor.CreateHostBackdropBrush(); brush.SetSourceParameter("Backdrop", hostBackdropBrush); return(brush); }
private void BuildBackground() { _backgroundBrush = _compositor.CreateSurfaceBrush(_uriSurface.Surface); _backgroundBrush.Stretch = CompositionStretch.Fill; _blurBrush.SetSourceParameter("source", _backgroundBrush); BackgroundVisual.Brush = _blurBrush; BackgroundVisual.Size = new Vector2((float)ActualWidth, (float)ActualHeight); BackgroundVisual.Opacity = ShowBlurredBackground ? 1.0f : 0; }
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; }
private void SetupBlur() { compositor = ElementCompositionPreview.GetElementVisual(this).Compositor; var blur = new GaussianBlurEffect { Name = "Blur", Source = new CompositionEffectSourceParameter("Backdrop"), BlurAmount = 0.0f, BorderMode = EffectBorderMode.Hard }; var blend = new BlendEffect { Name = "Blend", Foreground = new ColorSourceEffect { Color = Color.FromArgb(128, 30, 30, 220), Name = "ColorSource" }, Background = blur, Mode = BlendEffectMode.Overlay }; var effectFactory = compositor.CreateEffectFactory(blend, new[] {"Blur.BlurAmount"}); brush = effectFactory.CreateBrush(); var backdrop = compositor.CreateBackdropBrush(); brush.SetSourceParameter("Backdrop", backdrop); var sprite = compositor.CreateSpriteVisual(); sprite.Brush = brush; sprite.Size = new Vector2((float) TargetImage.ActualWidth, (float) TargetImage.ActualHeight); ElementCompositionPreview.SetElementChildVisual(TargetImage, sprite); }
private void BlendSelection_SelectionChanged(object sender, SelectionChangedEventArgs e) { ComboBoxItem item = BlendSelection.SelectedValue as ComboBoxItem; BlendEffectMode blendmode = (BlendEffectMode)item.Tag; // Create a chained effect graph using a BlendEffect, blending color and blur var graphicsEffect = new BlendEffect { Mode = blendmode, Background = new ColorSourceEffect() { Name = "Tint", Color = Tint.Color, }, Foreground = new GaussianBlurEffect() { Name = "Blur", Source = new CompositionEffectSourceParameter("Backdrop"), BlurAmount = (float)BlurAmount.Value, BorderMode = EffectBorderMode.Hard, } }; var blurEffectFactory = _compositor.CreateEffectFactory(graphicsEffect, new[] { "Blur.BlurAmount", "Tint.Color"}); // Create EffectBrush, BackdropBrush and SpriteVisual _brush = blurEffectFactory.CreateBrush(); // If the animation is running, restart it on the new brush if (AnimateToggle.IsOn) { StartBlurAnimation(); } var destinationBrush = _compositor.CreateBackdropBrush(); _brush.SetSourceParameter("Backdrop", destinationBrush); var blurSprite = _compositor.CreateSpriteVisual(); blurSprite.Size = new Vector2((float)BackgroundImage.ActualWidth, (float)BackgroundImage.ActualHeight); blurSprite.Brush = _brush; ElementCompositionPreview.SetElementChildVisual(BackgroundImage, blurSprite); }
/// <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 CreateBrush() { effectBrush = effectFactory.CreateBrush(); effectBrush.SetSourceParameter(EffectSource, surfaceBrush); effectBrush.Properties.InsertScalar(RedExponentEffectPath, 1f); effectBrush.Properties.InsertScalar(GreenExponentEffectPath, 1f); effectBrush.Properties.InsertScalar(BlueExponentEffectPath, 1f); }
private void CreateBrush() { effectBrush = effectFactory.CreateBrush(); effectBrush.SetSourceParameter(EffectSource, surfaceBrush); effectBrush.Properties.InsertScalar(SaturationEffectPath, 0f); }
private void CreateBrush() { effectBrush = effectFactory.CreateBrush(); effectBrush.SetSourceParameter(EffectSource, surfaceBrush); effectBrush.Properties.InsertScalar(IntensityEffectPath, 0.5f); }
private void CreateBrush() { effectBrush = effectFactory.CreateBrush(); effectBrush.SetSourceParameter(EffectSource, surfaceBrush); }
public async void SetEffectBrush(CompositionEffectBrush brush) { // Release previous brush if set if (_effectBrush != null) { _effectBrush.Dispose(); _effectBrush = null; } if (_effectSurface != null) { _effectSurface.Dispose(); _effectSurface = null; } _effectBrush = brush; // Set the new brush if (_sprite != null) { // Release current brush if (_sprite.Brush != null) { _sprite.Brush.Dispose(); } if (_surface != null) { // If the effect brush is cleared, create a surface brush if (_effectBrush == null) { _sprite.Brush = _compositor.CreateSurfaceBrush(_surface); } else { _effectBrush.SetSourceParameter("ImageSource", _compositor.CreateSurfaceBrush(_surface)); if (_loadEffectDelegate != null) { _effectSurface = await SurfaceLoader.LoadFromUri(_uri, Size.Empty, _loadEffectDelegate); _effectBrush.SetSourceParameter("EffectSource", _compositor.CreateSurfaceBrush(_effectSurface)); } _sprite.Brush = _effectBrush; } } } }