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);
}
