public void ApplyCompositor()
{
var container = compositor.CreateContainerVisual();
container.RotationAngle = 45;
ElementCompositionPreview.SetElementChildVisual(theGrid, container);
_LoadImageSurface = LoadedImageSurface.StartLoadFromUri(new Uri("ms-appx:///Assets/21.png"));
_LoadImageSurface.LoadCompleted += (sender, args) =>
{
if (args.Status == LoadedImageSourceLoadStatus.Success)
{
var brush = compositor.CreateSurfaceBrush(_LoadImageSurface);
brush.Stretch = CompositionStretch.Uniform;
var imageVisual = compositor.CreateSpriteVisual();
imageVisual.Size = new Vector2(300, 300);
imageVisual.Brush = brush;
//imageVisual.RotationAngle = 45;
container.Children.InsertAtTop(imageVisual);
}
;
};
//container.Compositor.CreateAmbientLight();
}
private void CreateAcrylicEffectBrush_Click(object sender, RoutedEventArgs e)
{
if (Overlay.Background == null)
{
var compositor = Window.Current.Compositor;
var noiseSurface = LoadedImageSurface.StartLoadFromUri(new Uri("ms-appx:///Microsoft.UI.Xaml/Assets/NoiseAsset_256X256_PNG.png"));
var acrylicFactory = System.Runtime.InteropServices.WindowsRuntime.WindowsRuntimeMarshal.GetActivationFactory(typeof(AcrylicBrush));
var privateApi = (IAcrylicBrushStaticsPrivate)acrylicFactory;
var acrylicEffectBrush = privateApi.CreateBackdropAcrylicEffectBrush(
compositor,
Color.FromArgb(0x44, 0x00, 0xFF, 0x00),
Colors.Transparent,
false);
var noiseBrush = compositor.CreateSurfaceBrush(noiseSurface);
noiseBrush.Stretch = CompositionStretch.None;
acrylicEffectBrush.SetSourceParameter("Noise", noiseBrush);
Overlay.Background = new WrapperEffectBrush(acrylicEffectBrush);
}
else
{
Overlay.Background = null;
}
}
private void LoadPlaceholderImage(Uri load)
{
_currentPosterUri = load;
Action setSurface = () =>
{
_posterVisual.Brush = Window.Current.Compositor.CreateSurfaceBrush(_surface);
if (PlayerService.Current.IsOpening || PlayerService.Current.IsClosed)
{
_posterVisual.Opacity = 1.0f;
}
};
if (_surface == null)
{
_surface = LoadedImageSurface.StartLoadFromUri(load);
_surface.LoadCompleted += (o, l) =>
{
setSurface();
};
}
else
{
setSurface();
}
}
public void LoadImageFromPath(string path)
{
var compositor = Window.Current.Compositor;
_surface = LoadedImageSurface.StartLoadFromUri(new Uri(path));
_surface.LoadCompleted += Load_Completed;
}
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 CompositionMaskBrush CreateMaskBrush(int width, int height, Windows.UI.Color rateColor)
{
var _maskBrush = compositor.CreateMaskBrush();
LoadedImageSurface loadedSurface = LoadedImageSurface.StartLoadFromUri(new Uri("ms-appx:///Assets/CircleMask.png"), new Windows.Foundation.Size(width, height));
_maskBrush.Source = compositor.CreateColorBrush(rateColor);
_maskBrush.Mask = compositor.CreateSurfaceBrush(loadedSurface);
return(_maskBrush);
}
private void MainPage_Loaded(object sender, RoutedEventArgs e)
{
var compositor = Window.Current.Compositor;
_surface = LoadedImageSurface.StartLoadFromUri(new Uri("ms-appx:///Assets/webster-pass.png"));
var backgroundBrush = compositor.CreateSurfaceBrush(_surface);
backgroundBrush.Stretch = CompositionStretch.UniformToFill;
var saturationEffect = new SaturationEffect
{
Saturation = 0.0f,
Source = new CompositionEffectSourceParameter("mySource")
};
var saturationEffectFactory = compositor.CreateEffectFactory(saturationEffect);
var bwEffect = saturationEffectFactory.CreateBrush();
bwEffect.SetSourceParameter("mySource", backgroundBrush);
_backgroundVisual = compositor.CreateSpriteVisual();
_backgroundVisual.Brush = bwEffect;
_backgroundVisual.Size = RootElement.RenderSize.ToVector2();
_containerVisual = compositor.CreateContainerVisual();
_containerVisual.Children.InsertAtBottom(_backgroundVisual);
ElementCompositionPreview.SetElementChildVisual(RootElement, _containerVisual);
// Text
_surfaceFactory = SurfaceFactory.GetSharedSurfaceFactoryForCompositor(compositor);
_textSurface = _surfaceFactory.CreateTextSurface("Weston Pass");
_textSurface.ForegroundColor = Color.FromArgb(50, 255, 255, 255);
_textSurface.FontSize = 150;
var textSurfaceBrush = compositor.CreateSurfaceBrush(_textSurface.Surface);
_textVisual = compositor.CreateSpriteVisual();
_textVisual.Size = _textSurface.Size.ToVector2();
_textVisual.RotationAngleInDegrees = 45f;
_textVisual.AnchorPoint = new Vector2(0.5f);
_textVisual.Brush = textSurfaceBrush;
_textVisual.StartAnimation(nameof(Visual.Offset), CreateTextOffsetAnimation(
new Vector3((float)RootElement.ActualWidth / 2, (float)RootElement.ActualWidth / 2, 0)));
_containerVisual.Children.InsertAtTop(_textVisual);
AddLighting();
StartLightingAnimationTimer();
}
private SpriteVisual CreateAcrylicNoiseVisual()
{
CompositionSurfaceBrush noiseBrush = _compositor.CreateSurfaceBrush();
LoadedImageSurface loadedSurface = LoadedImageSurface.StartLoadFromUri(new Uri("ms-appx:///Assets/acrylicNoise.png"));
noiseBrush.Surface = loadedSurface;
SpriteVisual noiseVisual = _compositor.CreateSpriteVisual();
return(noiseVisual);
}
private (CompositionBrush compositionBrush, CompositionSurfaceBrush compositionSurfaceBrush) CreateBrush(string imageName, Color color)
{
var compositor = Window.Current.Compositor;
var loadedSurface = LoadedImageSurface.StartLoadFromUri(new Uri("ms-appx:///Assets/Images/" + imageName));
var compositionSurfaceBrush = compositor.CreateSurfaceBrush();
compositionSurfaceBrush.Surface = loadedSurface;
var compositionBrush = CreateBrush(compositionSurfaceBrush, compositor.CreateColorBrush(color), BlendEffectMode.Lighten);
return(compositionBrush, compositionSurfaceBrush);
}
public void ValuesChanged(InteractionTracker sender, InteractionTrackerValuesChangedArgs args)
{
if (_indicator == null && ApiInfo.CanUseDirectComposition && (_tracker.Position.X > 0.0001f || _tracker.Position.X < -0.0001f) /*&& Math.Abs(e.Cumulative.Translation.X) >= 45*/)
{
var sprite = _visual.Compositor.CreateSpriteVisual();
sprite.Size = new Vector2(30, 30);
sprite.CenterPoint = new Vector3(15);
var surface = LoadedImageSurface.StartLoadFromUri(new Uri("ms-appx:///Assets/Images/Reply.png"));
surface.LoadCompleted += (s, e) =>
{
sprite.Brush = _visual.Compositor.CreateSurfaceBrush(s);
};
var ellipse = _visual.Compositor.CreateEllipseGeometry();
ellipse.Radius = new Vector2(15);
var ellipseShape = _visual.Compositor.CreateSpriteShape(ellipse);
ellipseShape.FillBrush = _visual.Compositor.CreateColorBrush((Windows.UI.Color)App.Current.Resources["MessageServiceBackgroundColor"]);
ellipseShape.Offset = new Vector2(15);
var shape = _visual.Compositor.CreateShapeVisual();
shape.Shapes.Add(ellipseShape);
shape.Size = new Vector2(30, 30);
_indicator = _visual.Compositor.CreateContainerVisual();
_indicator.Children.InsertAtBottom(shape);
_indicator.Children.InsertAtTop(sprite);
_indicator.Size = new Vector2(30, 30);
_indicator.CenterPoint = new Vector3(15);
_indicator.Scale = new Vector3();
_container.Children.InsertAtTop(_indicator);
//ElementCompositionPreview.SetElementChildVisual(this, _indicator);
//ElementCompositionPreview.SetElementChildVisual(this, _container);
}
var offset = (_tracker.Position.X > 0 && !_reply) || (_tracker.Position.X <= 0 && !_forward) ? 0 : Math.Max(0, Math.Min(72, Math.Abs(_tracker.Position.X)));
var abs = Math.Abs(offset);
var percent = abs / 72f;
var width = (float)ActualWidth;
var height = (float)ActualHeight;
if (_indicator != null)
{
_indicator.Offset = new Vector3(_tracker.Position.X > 0 ? width - percent * 60 : -30 + percent * 55, (height - 30) / 2, 0);
_indicator.Scale = new Vector3(_tracker.Position.X > 0 ? 0.8f + percent * 0.2f : -(0.8f + percent * 0.2f), 0.8f + percent * 0.2f, 1);
_indicator.Opacity = percent;
}
}
private static void OnImageUriStringChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
var brush = (ImageEffectBrush)d;
// Unbox and update surface if CompositionBrush exists
if (brush._surfaceBrush != null)
{
var newSurface = LoadedImageSurface.StartLoadFromUri(new Uri((String)e.NewValue));
brush._surface = newSurface;
brush._surfaceBrush.Surface = newSurface;
}
}
public static LayerTranslator CreateImageLayerTranslator(ImageLayerContext context)
{
if (!Transforms.TryCreateContainerVisualTransformChain(context, out var containerVisualRootNode, out var containerVisualContentNode))
{
// The layer is never visible.
return(null);
}
var imageAsset = GetImageAsset(context);
if (imageAsset is null)
{
return(null);
}
var content = context.ObjectFactory.CreateSpriteVisual();
containerVisualContentNode.Children.Add(content);
content.Size = new Sn.Vector2((float)imageAsset.Width, (float)imageAsset.Height);
LoadedImageSurface surface;
var imageSize = $"{imageAsset.Width}x{imageAsset.Height}";
switch (imageAsset.ImageType)
{
case ImageAsset.ImageAssetType.Embedded:
var embeddedImageAsset = (EmbeddedImageAsset)imageAsset;
surface = LoadedImageSurface.StartLoadFromStream(embeddedImageAsset.Bytes);
surface.SetName(imageAsset.Id);
surface.SetDescription(context, $"Image: \"{embeddedImageAsset.Id}\" {embeddedImageAsset.Format} {imageSize}.");
break;
case ImageAsset.ImageAssetType.External:
var externalImageAsset = (ExternalImageAsset)imageAsset;
surface = LoadedImageSurface.StartLoadFromUri(new Uri($"file://localhost/{externalImageAsset.Path}{externalImageAsset.FileName}"));
surface.SetName(externalImageAsset.FileName);
var path = externalImageAsset.Path + externalImageAsset.FileName;
surface.SetDescription(context, $"\"{path}\" {imageSize}.");
context.Issues.ImageFileRequired(path);
break;
default:
throw new InvalidOperationException();
}
var imageBrush = context.ObjectFactory.CreateSurfaceBrush(surface);
content.Brush = imageBrush;
return(new LayerTranslator.FromVisual(containerVisualRootNode));
}
private void ApplyComposition()
{
var compositor = Window.Current.Compositor;
var backVisual = ElementCompositionPreview.GetElementVisual(FancyGrid);
//backVisual.Offset = new Vector3(100, 100, 0);
ElementCompositionPreview.SetIsTranslationEnabled(FancyGrid, true);
var fancyGridPropertySet = backVisual.Properties;
fancyGridPropertySet.InsertVector3("Translation", new Vector3(100, 100, 0));
backVisual.RotationAngleInDegrees = 45;
backVisual.CenterPoint = new Vector3((float)FancyGrid.ActualWidth / 2.0f, (float)FancyGrid.ActualHeight / 2.0f, 0);
var sprite1 = compositor.CreateSpriteVisual();
sprite1.Size = new Vector2(50, 50);
sprite1.Offset = new Vector3(50, 50, 0);
sprite1.Brush = compositor.CreateColorBrush(Colors.Green);
var sprite2 = compositor.CreateSpriteVisual();
sprite2.Size = new Vector2(50, 50);
sprite2.Offset = new Vector3(25, 25, 0);
sprite2.Brush = compositor.CreateColorBrush(Colors.Purple);
var container = compositor.CreateContainerVisual();
container.Children.InsertAtTop(sprite1);
container.Children.InsertAtBottom(sprite2);
ElementCompositionPreview.SetElementChildVisual(FancyGrid, container);
_loadedImageSurface = LoadedImageSurface.StartLoadFromUri(new Uri("ms-appx:///Assets/JustEnoughBikes.jpg"));
_loadedImageSurface.LoadCompleted += (sender, args) =>
{
if (args.Status == LoadedImageSourceLoadStatus.Success)
{
var brush = compositor.CreateSurfaceBrush(_loadedImageSurface);
brush.Stretch = CompositionStretch.UniformToFill;
var imageVisual = compositor.CreateSpriteVisual();
imageVisual.Size = new Vector2(400, 400);
imageVisual.Brush = brush;
container.Children.InsertAtTop(imageVisual);
}
};
}
private Task <LoadedImageSurface> LoadImage(Uri uri, Size?size, CoreDispatcher dispatcher = null)
{
TaskCompletionSource <LoadedImageSurface> completionSource = new TaskCompletionSource <LoadedImageSurface>();
LoadedImageSurface result = null;
if (size.HasValue)
{
result = LoadedImageSurface.StartLoadFromUri(uri, size.Value);
}
else
{
result = LoadedImageSurface.StartLoadFromUri(uri);
}
TypedEventHandler <LoadedImageSurface, LoadedImageSourceLoadCompletedEventArgs> loadCompleteHandler = null;
loadCompleteHandler = new TypedEventHandler <LoadedImageSurface, LoadedImageSourceLoadCompletedEventArgs>((sender, args) =>
{
sender.LoadCompleted -= loadCompleteHandler;
if (dispatcher != null)
{
_ = dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
if (args.Status == LoadedImageSourceLoadStatus.Success)
{
completionSource.SetResult(result);
}
else
{
completionSource.SetResult(null);
}
});
}
else
{
if (args.Status == LoadedImageSourceLoadStatus.Success)
{
completionSource.SetResult(result);
}
else
{
completionSource.SetResult(null);
}
}
});
result.LoadCompleted += loadCompleteHandler;
return(completionSource.Task);
}
public static LoadedImageSurface GetImageSurface(string assetName, Size imageSize)
{
Uri getImageUri()
{
if (SharedHelpers.IsInFrameworkPackage())
{
return(new Uri("ms-resource://" + MUXCONTROLS_PACKAGE_NAME + "/Files/Microsoft.UI.Xaml/Assets/" + assetName + ".png"));
}
else
{
return(new Uri("ms-resource:///Files/Microsoft.UI.Xaml/Assets/" + assetName + ".png"));
}
}
return(LoadedImageSurface.StartLoadFromUri(getImageUri(), imageSize));
}
/// <summary>
/// Show Compositon effects on image
/// </summary>
/// <param name="imageURL">Image to effect</param>
private void SetupComposition(Uri imageURL)
{
try
{
CompositionSurfaceBrush _imageBrush;
Compositor _compositor = Window.Current.Compositor;
_imageBrush = _compositor.CreateSurfaceBrush();
_imageBrush.Stretch = CompositionStretch.UniformToFill;
LoadedImageSurface _loadedSurface = LoadedImageSurface.StartLoadFromUri(imageURL);
_loadedSurface.LoadCompleted += _loadedSurface_LoadCompleted;
_imageBrush.Surface = _loadedSurface;
// Saturate
var saturationEffect = new SaturationEffect
{
Saturation = 1,
Source = new CompositionEffectSourceParameter("image")
};
var effectFactory = _compositor.CreateEffectFactory(saturationEffect);
var effectBrush = effectFactory.CreateBrush();
effectBrush.SetSourceParameter("image", _imageBrush);
// Blur
var blurEffect = new GaussianBlurEffect
{
BlurAmount = 8,
Source = new CompositionEffectSourceParameter("image")
};
var effectFactory2 = _compositor.CreateEffectFactory(blurEffect);
var effectBrush2 = effectFactory2.CreateBrush();
effectBrush2.SetSourceParameter("image", effectBrush);
_imageVisual = _compositor.CreateSpriteVisual();
_imageVisual.Brush = effectBrush2;
_imageVisual.Size = new Vector2(Convert.ToSingle(BackgroundContainer.ActualWidth), Convert.ToSingle(BackgroundContainer.ActualHeight));
ElementCompositionPreview.SetElementChildVisual(BackgroundContainer, _imageVisual);
}
catch
{
// I guess it'll just look meh
}
}
/// <summary>
/// </summary>
protected override void OnConnected()
{
var compositor = Window.Current.Compositor;
// Load milky way image
_surface = LoadedImageSurface.StartLoadFromUri(new Uri(App.PhotoCollection.ElementAt(4).Path));
_surface.LoadCompleted += (s, startArgs) =>
{
if (startArgs.Status == LoadedImageSourceLoadStatus.Success)
{
// Create blur effect
var brush = compositor.CreateSurfaceBrush(_surface);
brush.Stretch = CompositionStretch.UniformToFill;
IGraphicsEffect graphicsEffect = new GaussianBlurEffect
{
Name = "Blur",
BlurAmount = 0,
Source = new CompositionEffectSourceParameter("image")
};
var effectFactory = compositor.CreateEffectFactory(graphicsEffect, new[] { "Blur.BlurAmount" });
var effectBrush = effectFactory.CreateBrush();
effectBrush.SetSourceParameter("image", brush);
// Composition Brush is what is being applied to the UI Element.
CompositionBrush = effectBrush;
PropertySet = effectBrush.Properties;
// Animate the blur
var blurAnimation = compositor.CreateScalarKeyFrameAnimation();
blurAnimation.InsertKeyFrame(0, 0f);
blurAnimation.InsertKeyFrame(0.5f, 10.0f);
blurAnimation.InsertKeyFrame(1, 0);
blurAnimation.Duration = TimeSpan.FromSeconds(4);
blurAnimation.IterationBehavior = AnimationIterationBehavior.Forever;
effectBrush.Properties.StartAnimation("Blur.BlurAmount", blurAnimation);
}
};
}
private void LoadMazeRunnerVisual()
{
if (_mazeRunnerVisual != null)
{
_mazeRunnerVisual.Dispose();
}
_mazeRunnerVisual = _compositor.CreateSpriteVisual();
_mazeRunnerVisual.Size = new Vector2(_cellSize, _cellSize);
LoadedImageSurface loadedSurface = LoadedImageSurface.StartLoadFromUri(new Uri("ms-appx:///Assets/luna.png"), new Size(_cellSize, _cellSize));
CompositionSurfaceBrush surfaceBrush = _compositor.CreateSurfaceBrush();
surfaceBrush.Surface = loadedSurface;
_mazeRunnerVisual.Brush = surfaceBrush;
ElementCompositionPreview.SetElementChildVisual(MazeGrid, _mazeRunnerVisual);
_mazeRunnerVisual.IsVisible = true;
_mazeRunnerVisual.Opacity = 1;
}
/// <summary>
/// Initializes the Composition Brush.
/// </summary>
protected override void OnConnected()
{
// Delay creating composition resources until they're required.
if (CompositionBrush == null && Source != null && Source is BitmapImage bitmap)
{
// Use LoadedImageSurface API to get ICompositionSurface from image uri provided
// If UriSource is invalid, StartLoadFromUri will return a blank texture.
_surface = LoadedImageSurface.StartLoadFromUri(bitmap.UriSource);
// Load Surface onto SurfaceBrush
_surfaceBrush = Window.Current.Compositor.CreateSurfaceBrush(_surface);
_surfaceBrush.Stretch = CompositionStretchFromStretch(Stretch);
// Abort if effects aren't supported.
if (!CompositionCapabilities.GetForCurrentView().AreEffectsSupported())
{
// Just use image straight-up, if we don't support effects.
CompositionBrush = _surfaceBrush;
return;
}
var backdrop = Window.Current.Compositor.CreateBackdropBrush();
// Use a Win2D invert affect applied to a CompositionBackdropBrush.
var graphicsEffect = new BlendEffect
{
Name = "Invert",
Mode = (BlendEffectMode)(int)Mode,
Background = new CompositionEffectSourceParameter("backdrop"),
Foreground = new CompositionEffectSourceParameter("image")
};
var effectFactory = Window.Current.Compositor.CreateEffectFactory(graphicsEffect);
var effectBrush = effectFactory.CreateBrush();
effectBrush.SetSourceParameter("backdrop", backdrop);
effectBrush.SetSourceParameter("image", _surfaceBrush);
CompositionBrush = effectBrush;
}
}
private (CompositionBrush, CompositionSurfaceBrush) CreateMaskedBrush(CompositionBrush source)
{
var compositor = Window.Current.Compositor;
var effect = new AlphaMaskEffect()
{
Source = new CompositionEffectSourceParameter("Source"),
AlphaMask = new CompositionEffectSourceParameter("Mask"),
};
var opacityMaskSurface = LoadedImageSurface.StartLoadFromUri(new Uri("ms-appx:///Assets/Images/mask.Png"));
var opacityBrush = Compositor.CreateSurfaceBrush(opacityMaskSurface);
opacityBrush.Stretch = CompositionStretch.UniformToFill;
var effectFactory = compositor.CreateEffectFactory(effect);
var compositionBrush = effectFactory.CreateBrush();
compositionBrush.SetSourceParameter("Source", source);
compositionBrush.SetSourceParameter("Mask", opacityBrush);
return(compositionBrush, opacityBrush);
}
private static void OnImageSourceChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
var brush = (ImageBlendBrush)d;
// Unbox and update surface if CompositionBrush exists
if (brush._surfaceBrush != null)
{
// If UriSource is invalid, StartLoadFromUri will return a blank texture.
var uri = (e.NewValue as BitmapImage)?.UriSource ?? new Uri("ms-appx:///");
var newSurface = LoadedImageSurface.StartLoadFromUri(uri);
brush._surface = newSurface;
brush._surfaceBrush.Surface = newSurface;
}
else
{
// If we didn't initially have a valid surface, we need to recreate our effect now.
brush.OnDisconnected();
brush.OnConnected();
}
}
protected override void OnConnected()
{
if (CompositionBrush == null)
{
var surface = LoadedImageSurface.StartLoadFromUri(Source, new Size(480, 750));
var surfaceBrush = Window.Current.Compositor.CreateSurfaceBrush(surface);
surfaceBrush.Stretch = CompositionStretch.None;
var borderEffect = new BorderEffect()
{
Source = new CompositionEffectSourceParameter("source"),
ExtendX = Microsoft.Graphics.Canvas.CanvasEdgeBehavior.Wrap,
ExtendY = Microsoft.Graphics.Canvas.CanvasEdgeBehavior.Wrap
};
var borderEffectFactory = Window.Current.Compositor.CreateEffectFactory(borderEffect);
var borderEffectBrush = borderEffectFactory.CreateBrush();
borderEffectBrush.SetSourceParameter("source", surfaceBrush);
CompositionBrush = borderEffectBrush;
}
}
public void LoadImage(Uri uri, Size?size = null)
{
lock (_lock)
{
if (_surface != null)
{
_surface.LoadCompleted -= _surface_LoadCompleted;
_surface.Dispose();
_surface = null;
}
_loaded = false;
if (size.HasValue)
{
_surface = LoadedImageSurface.StartLoadFromUri(uri, size.Value);
}
else
{
_surface = LoadedImageSurface.StartLoadFromUri(uri);
}
_surface.LoadCompleted += _surface_LoadCompleted;
}
}
protected override void OnConnected()
{
Compositor compositor = Window.Current.Compositor;
// CompositionCapabilities: Are Effects supported?
bool usingFallback = !CompositionCapabilities.GetForCurrentView().AreEffectsSupported();
FallbackColor = Color.FromArgb(100, 60, 60, 60);
if (usingFallback)
{
// If Effects are not supported, use Fallback Solid Color
CompositionBrush = compositor.CreateColorBrush(FallbackColor);
return;
}
// Load NormalMap onto an ICompositionSurface using LoadedImageSurface
_surface = LoadedImageSurface.StartLoadFromUri(new Uri("ms-appx:///Assets/Damaged_NormalMap.jpg"), new Size(400, 400));
// Load Surface onto SurfaceBrush
CompositionSurfaceBrush normalMap = compositor.CreateSurfaceBrush(_surface);
normalMap.Stretch = CompositionStretch.Uniform;
// Define Effect graph
const float glassLightAmount = 0.5f;
const float glassBlurAmount = 0.95f;
Color tintColor = Color.FromArgb(255, 128, 128, 128);
var graphicsEffect = new ArithmeticCompositeEffect()
{
Name = "LightComposite",
Source1Amount = 1,
Source2Amount = glassLightAmount,
MultiplyAmount = 0,
Source1 = new ArithmeticCompositeEffect()
{
Name = "BlurComposite",
Source1Amount = 1 - glassBlurAmount,
Source2Amount = glassBlurAmount,
MultiplyAmount = 0,
Source1 = new ColorSourceEffect()
{
Name = "Tint",
Color = tintColor,
},
Source2 = new GaussianBlurEffect()
{
BlurAmount = 20,
Source = new CompositionEffectSourceParameter("Backdrop"),
Optimization = EffectOptimization.Balanced,
BorderMode = EffectBorderMode.Hard,
},
},
Source2 = new SceneLightingEffect()
{
AmbientAmount = 0.15f,
DiffuseAmount = 1,
SpecularAmount = 0.1f,
NormalMapSource = new CompositionEffectSourceParameter("NormalMap")
},
};
// Create EffectFactory and EffectBrush
CompositionEffectFactory effectFactory = compositor.CreateEffectFactory(graphicsEffect);
CompositionEffectBrush effectBrush = effectFactory.CreateBrush();
// Create BackdropBrush
CompositionBackdropBrush backdrop = compositor.CreateBackdropBrush();
// Set Sources to Effect
effectBrush.SetSourceParameter("NormalMap", normalMap);
effectBrush.SetSourceParameter("Backdrop", backdrop);
// Set EffectBrush as the brush that XamlCompBrushBase paints onto Xaml UIElement
CompositionBrush = effectBrush;
}
/// <summary>
/// Load the image and transform it to a composition brush or a XAML brush (depends of the UIStrategy)
/// </summary>
/// <param name="uri">the uri of the image to load</param>
/// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
private async Task <bool> LoadImageBrushAsync(Uri uri)
{
if (DesignTimeHelpers.IsRunningInLegacyDesignerMode)
{
return(false);
}
if (_containerVisual == null || uri == null)
{
return(false);
}
await _flag.WaitAsync();
try
{
bool isAnimated = IsAnimated;
IsAnimated = false;
if (_isImageSourceLoaded)
{
for (int i = 0; i < _compositionChildren.Count; i++)
{
_compositionChildren[i].Brush = null;
}
_brushVisual?.Dispose();
_brushVisual = null;
_imageSurface?.Dispose();
_imageSurface = null;
}
_isImageSourceLoaded = false;
var compositor = _containerVisual.Compositor;
_imageSurface = LoadedImageSurface.StartLoadFromUri(uri);
var loadCompletedSource = new TaskCompletionSource <bool>();
_brushVisual = compositor.CreateSurfaceBrush(_imageSurface);
_imageSurface.LoadCompleted += (s, e) =>
{
if (e.Status == LoadedImageSourceLoadStatus.Success)
{
loadCompletedSource.SetResult(true);
}
else
{
loadCompletedSource.SetException(new ArgumentException("Image loading failed."));
}
};
await loadCompletedSource.Task;
_imageSize = _imageSurface.DecodedPhysicalSize;
_isImageSourceLoaded = true;
RefreshContainerTile();
RefreshImageSize(_imageSize.Width, _imageSize.Height);
if (isAnimated)
{
IsAnimated = true;
}
}
finally
{
_flag.Release();
}
ImageLoaded?.Invoke(this, EventArgs.Empty);
return(true);
}
private void ConnectAcrylicBrush(bool useFallback)
{
DisconnectAcryilicBrush();
bool isWindowed = BackgroundSource == CustomAcrylicBackgroundSource.Hostbackdrop;
if (useFallback == false && PowerManager.EnergySaverStatus != EnergySaverStatus.On && !(UIViewSettings.GetForCurrentView().UserInteractionMode == UserInteractionMode.Touch && isWindowed))
{
ArithmeticCompositeEffect crossFadeEffect = new ArithmeticCompositeEffect
{
MultiplyAmount = 0f,
Source1Amount = 0.6f,
Source2Amount = 0.4f,
Source1 = new ColorSourceEffect
{
Color = TintColor
},
Source2 = new ArithmeticCompositeEffect
{
MultiplyAmount = 0f,
Source1Amount = sc_noiseOpacity,
Source2Amount = 0.98f,
Source1 = new BorderEffect
{
Source = new CompositionEffectSourceParameter("image"),
ExtendX = CanvasEdgeBehavior.Wrap,
ExtendY = CanvasEdgeBehavior.Wrap,
},
Source2 = new BlendEffect
{
Mode = BlendEffectMode.Exclusion,
Foreground = new ColorSourceEffect
{
Color = Sc_exclusionColor
},
Background = new SaturationEffect
{
Saturation = sc_saturation,
Source = new GaussianBlurEffect
{
BlurAmount = sc_blurRadius,
BorderMode = EffectBorderMode.Hard,
Name = "Blur",
Optimization = EffectOptimization.Balanced,
Source = new CompositionEffectSourceParameter("source")
}
}
}
}
};
CompositionEffectFactory effectFactory = compositor.CreateEffectFactory(crossFadeEffect);
effectBrush = effectFactory.CreateBrush();
LoadedImageSurface imagesurface = LoadedImageSurface.StartLoadFromUri(new Uri("ms-appx:///UnitedCodebase/Assets/NoiseAsset_256X256_PNG.png"));
CompositionSurfaceBrush imagebrush = compositor.CreateSurfaceBrush(imagesurface);
imagebrush.Stretch = CompositionStretch.None;
effectBrush.SetSourceParameter("image", imagebrush);
if (BackgroundSource == CustomAcrylicBackgroundSource.Hostbackdrop)
{
backdropBrush = compositor.CreateHostBackdropBrush();
effectBrush.SetSourceParameter("source", backdropBrush);
}
else
{
backdropBrush = compositor.CreateBackdropBrush();
effectBrush.SetSourceParameter("source", backdropBrush);
}
CompositionBrush = effectBrush;
}
else
{
CompositionBrush = compositor.CreateColorBrush(FallbackColor);
}
}
private void OnLoaded(object sender, RoutedEventArgs routedEventArgs)
{
// Compositor
_compositor = Window.Current.Compositor;
// Load Image
_imageSurface = LoadedImageSurface.StartLoadFromUri(new Uri("ms-appx:///Assets/webster-pass.png"));
var backgroundBrush = _compositor.CreateSurfaceBrush(_imageSurface);
backgroundBrush.Stretch = CompositionStretch.UniformToFill;
// Apply Saturation Effect (Win2D)
var saturationEffect = new SaturationEffect
{
Saturation = 0,
Source = new CompositionEffectSourceParameter("background")
};
var saturationEffectFactory = _compositor.CreateEffectFactory(saturationEffect);
var saturationBrush = saturationEffectFactory.CreateBrush();
saturationBrush.SetSourceParameter("background", backgroundBrush);
// Add background to visual tree
_backgroundVisual = _compositor.CreateSpriteVisual();
_backgroundVisual.Brush = saturationBrush;
_backgroundVisual.Size = RootElement.RenderSize.ToVector2();
_containerVisual = _compositor.CreateContainerVisual();
_containerVisual.Children.InsertAtBottom(_backgroundVisual);
ElementCompositionPreview.SetElementChildVisual(RootElement, _containerVisual);
// Add Lighting
_ambientLight = _compositor.CreateAmbientLight();
_ambientLight.Intensity = 1.5f;
_ambientLight.Color = Colors.Purple;
_ambientLight.Targets.Add(_backgroundVisual);
_pointLight1 = _compositor.CreatePointLight();
_pointLight1.Color = Colors.Yellow;
_pointLight1.CoordinateSpace = _containerVisual;
_pointLight1.Targets.Add(_backgroundVisual);
_pointLight1.Offset = new Vector3((float)RootElement.ActualWidth, (float)RootElement.ActualHeight * 0.25f, 300);
_pointLight2 = _compositor.CreatePointLight();
_pointLight2.Color = Colors.Green;
_pointLight2.Intensity = 2f;
_pointLight2.CoordinateSpace = _containerVisual;
_pointLight2.Targets.Add(_backgroundVisual);
_pointLight2.Offset = new Vector3(0, (float)RootElement.ActualHeight * 0.75f, 300);
// Animate Lights - Create expression template
var offsetAnimation = Window.Current.Compositor.CreateVector3KeyFrameAnimation();
offsetAnimation.Target = nameof(PointLight.Offset);
offsetAnimation.InsertExpressionKeyFrame(1.0f, "this.FinalValue");
offsetAnimation.Duration = TimeSpan.FromSeconds(10);
// Animate Lights - create implicit animations
_implicitOffsetAnimation = _compositor.CreateImplicitAnimationCollection();
_implicitOffsetAnimation[nameof(Visual.Offset)] = offsetAnimation;
_pointLight1.ImplicitAnimations = _implicitOffsetAnimation;
_pointLight2.ImplicitAnimations = _implicitOffsetAnimation;
// Animate Lights - create timer
_lightTimer = new DispatcherTimer();
_lightTimer.Interval = TimeSpan.FromSeconds(10);
_lightTimer.Tick += LightTimerOnTick;
_lightTimer.Start();
// AnimateLights - initial move
MoveLights();
// Add Text (RobMikh.SurfaceFactory) Ø
_surfaceFactory = SurfaceFactory.GetSharedSurfaceFactoryForCompositor(_compositor);
_textSurface = _surfaceFactory.CreateTextSurface("Hello Øredev!");
_textSurface.ForegroundColor = Color.FromArgb(50, 255, 255, 255);
_textSurface.FontSize = 150;
var textBrush = _compositor.CreateSurfaceBrush(_textSurface.Surface);
_textVisual = _compositor.CreateSpriteVisual();
_textVisual.Size = _textSurface.Size.ToVector2();
_textVisual.RotationAngleInDegrees = 45f;
_textVisual.AnchorPoint = new Vector2(0.5f);
_textVisual.Brush = textBrush;
_textVisual.StartAnimation(nameof(Visual.Offset), CreateTextAnimation());
_containerVisual.Children.InsertAtTop(_textVisual);
}
private void SetAllBitmaps(string topPath, Size?topSize, float?haloOffset, Size?haloSize, string middlePath, Size?middleSize, string bottomPath, Size?bottomSize)
{
if (!_isCompInitialized)
{
return;
}
LoadedImageSurface topSurface = null;
LoadedImageSurface topNormalSurface = null;
LoadedImageSurface haloSurface = null;
LoadedImageSurface middleSurface = null;
LoadedImageSurface middleNormalSurface = null;
LoadedImageSurface bottomSurface = null;
LoadedImageSurface bottomNormalSurface = null;
if (topPath != null)
{
string topNormalPath = topPath.Replace("_Color.png", "_Normal.png");
string topHaloPath = topPath.Replace("_Color.png", "_Halo.png");
if (topSize.HasValue)
{
_topVisual.Size = topSize.Value.ToVector2();
topSurface = LoadedImageSurface.StartLoadFromUri(new Uri(topPath), topSize.Value);
topNormalSurface = LoadedImageSurface.StartLoadFromUri(new Uri(topNormalPath), topSize.Value);
}
else
{
topSurface = LoadedImageSurface.StartLoadFromUri(new Uri(topPath));
topNormalSurface = LoadedImageSurface.StartLoadFromUri(new Uri(topNormalPath));
}
if (haloSize.HasValue)
{
_haloVisual.Size = haloSize.Value.ToVector2();
haloSurface = LoadedImageSurface.StartLoadFromUri(new Uri(topHaloPath), haloSize.Value);
}
else
{
haloSurface = LoadedImageSurface.StartLoadFromUri(new Uri(topHaloPath));
}
if (!_isCompInitialized)
{
return;
}
}
if (middlePath != null)
{
string middleNormalPath = middlePath.Replace("_Color.png", "_Normal.png");
if (middleSize.HasValue)
{
_middleVisual.Size = middleSize.Value.ToVector2();
middleSurface = LoadedImageSurface.StartLoadFromUri(new Uri(middlePath), middleSize.Value);
middleNormalSurface = LoadedImageSurface.StartLoadFromUri(new Uri(middleNormalPath), middleSize.Value);
}
else
{
middleSurface = LoadedImageSurface.StartLoadFromUri(new Uri(middlePath));
middleNormalSurface = LoadedImageSurface.StartLoadFromUri(new Uri(middleNormalPath));
}
if (!_isCompInitialized)
{
return;
}
}
if (bottomPath != null)
{
string bottomNormalPath = bottomPath.Replace("_Color.png", "_Normal.png");
if (bottomSize.HasValue)
{
_bottomVisual.Size = bottomSize.Value.ToVector2();
bottomSurface = LoadedImageSurface.StartLoadFromUri(new Uri(bottomPath), bottomSize.Value);
bottomNormalSurface = LoadedImageSurface.StartLoadFromUri(new Uri(bottomNormalPath), bottomSize.Value);
}
else
{
bottomSurface = LoadedImageSurface.StartLoadFromUri(new Uri(bottomPath));
bottomNormalSurface = LoadedImageSurface.StartLoadFromUri(new Uri(bottomNormalPath));
}
if (!_isCompInitialized)
{
return;
}
}
var compositor = Window.Current.Compositor;
if (topSurface != null && topNormalSurface != null)
{
_topColorImage = topSurface;
_topNormalImage = topNormalSurface;
_topVisual.Brush = CreateNormalMapBrush(compositor, _topNormalImage, _topColorImage);
}
if (haloSurface != null)
{
_haloColorImage = haloSurface;
// The halo color image being its own normal image is deliberate
_haloVisual.Brush = CreateNormalMapBrush(compositor, _haloColorImage, _haloColorImage);
}
if (middleSurface != null && middleNormalSurface != null)
{
_middleColorImage = middleSurface;
_middleNormalImage = middleNormalSurface;
_middleVisual.Brush = CreateNormalMapBrush(compositor, _middleNormalImage, _middleColorImage);
}
if (bottomSurface != null && bottomNormalSurface != null)
{
_bottomColorImage = bottomSurface;
_bottomNormalImage = bottomNormalSurface;
_bottomVisual.Brush = CreateNormalMapBrush(compositor, _bottomNormalImage, _bottomColorImage);
}
if (haloOffset.HasValue)
{
_haloOffset = haloOffset.Value;
}
LayoutVisuals(_assetsLoaded);
}
public MainPage()
{
this.InitializeComponent();
ApplicationView.PreferredLaunchWindowingMode = ApplicationViewWindowingMode.FullScreen;
VersionTextBlock.Text = GetAppVersion();
GazeInput.DwellFeedbackCompleteBrush = new SolidColorBrush(Colors.Transparent);
_compositor = ElementCompositionPreview.GetElementVisual(this).Compositor;
LoadedImageSurface loadedSurface = LoadedImageSurface.StartLoadFromUri(new Uri("ms-appx:///Assets/BorderDot.png"), new Size(_cellSize, _cellSize));
_breadCrumbBrush = _compositor.CreateSurfaceBrush();
_breadCrumbBrush.Surface = loadedSurface;
_numRows = MIN_ROWS;
_mazeRunner = new Image
{
Source = new BitmapImage(new Uri(this.BaseUri, "/Assets/luna.png")),
VerticalAlignment = VerticalAlignment.Center
};
_mazeEnd = new Image
{
Source = new BitmapImage(new Uri(this.BaseUri, "/Assets/doghouse.png")),
VerticalAlignment = VerticalAlignment.Center
};
_mazeComplete = new Image
{
Source = new BitmapImage(new Uri(this.BaseUri, "/Assets/dogInHouse.png")),
VerticalAlignment = VerticalAlignment.Center
};
_newSolidBorderThickness = new Thickness(_borderThickness);
_newButtonStyle = (Style)this.Resources["MazeCellStyle"];
_mazeCreator = Creator.GetCreator();
_solutionTimer = new DispatcherTimer();
_solutionTimer.Interval = TimeSpan.FromSeconds(0.1);
_solutionTimer.Tick += OnSolutionTimerTick;
_cellCreationTimer = new DispatcherTimer();
_cellCreationTimer.Interval = TimeSpan.FromMilliseconds(50);
_cellCreationTimer.Tick += OnCellCreationTimer_Tick;
_openCellTimer = new DispatcherTimer();
_openCellTimer.Interval = TimeSpan.FromMilliseconds(50);
_openCellTimer.Tick += OnOpenCellTimer_Tick;
_mazeCells = new List <Point>();
_breadCrumbs = new List <Point>();
Loaded += MainPage_Loaded;
CoreWindow.GetForCurrentThread().KeyDown += new Windows.Foundation.TypedEventHandler <CoreWindow, KeyEventArgs>(delegate(CoreWindow sender, KeyEventArgs args) {
GazeInput.GetGazePointer(this).Click();
});
var sharedSettings = new ValueSet();
GazeSettingsHelper.RetrieveSharedSettings(sharedSettings).Completed = new AsyncActionCompletedHandler((asyncInfo, asyncStatus) =>
{
GazeInput.LoadSettings(sharedSettings);
});
}
protected override void OnConnected()
{
if (DesignMode.DesignModeEnabled)
{
return;
}
compositor = ElementCompositionPreview.GetElementVisual(Window.Current.Content as UIElement).Compositor;
var tintOpacity = Convert.ToSingle(TintOpacity);
if (tintOpacity < 0f)
{
tintOpacity = 0f;
}
if (tintOpacity > 1f)
{
tintOpacity = 1f;
}
var arithmeticEffect = new ArithmeticCompositeEffect()
{
Name = "arithmetic",
MultiplyAmount = 0,
Source1Amount = 1f - tintOpacity,
Source2Amount = tintOpacity,
Source1 = new ArithmeticCompositeEffect()
{
MultiplyAmount = 0f,
Source1Amount = 0.95f,
Source2Amount = 0.05f,
Source1 = new GaussianBlurEffect()
{
Name = "blur",
BlurAmount = Convert.ToSingle(BlurAmount),
BorderMode = EffectBorderMode.Hard,
Optimization = EffectOptimization.Balanced,
Source = new CompositionEffectSourceParameter("source"),
},
Source2 = new BorderEffect()
{
Source = new CompositionEffectSourceParameter("image"),
ExtendX = CanvasEdgeBehavior.Wrap,
ExtendY = CanvasEdgeBehavior.Wrap,
}
},
Source2 = new ColorSourceEffect()
{
Name = "tintcolor",
Color = TintColor
}
};
Brush = compositor.CreateEffectFactory(arithmeticEffect, new[] { "arithmetic.Source1Amount", "arithmetic.Source2Amount", "tintcolor.Color" }).CreateBrush();
var imagesurface = LoadedImageSurface.StartLoadFromUri(new Uri("ms-appx:///FluentDesignSystem/Sketch/SketchTexture.jpg"));
var imagebrush = compositor.CreateSurfaceBrush(imagesurface);
imagebrush.Stretch = CompositionStretch.None;
Brush.SetSourceParameter("image", imagebrush);
switch (BackgroundSource)
{
case AcrylicBackgroundSource.Backdrop:
Brush.SetSourceParameter("source", compositor.CreateBackdropBrush());
break;
case AcrylicBackgroundSource.Hostbackdrop:
Brush.SetSourceParameter("source", compositor.CreateHostBackdropBrush());
break;
}
CompositionBrush = Brush;
var line = compositor.CreateLinearEasingFunction();
TintOpacityFillAnimation = compositor.CreateScalarKeyFrameAnimation();
TintOpacityFillAnimation.InsertExpressionKeyFrame(0f, "TintOpacity", line);
TintOpacityFillAnimation.InsertKeyFrame(1f, 1f, line);
TintOpacityFillAnimation.Duration = TimeSpan.FromSeconds(0.1d);
TintOpacityFillAnimation.Target = "arithmetic.Source2Amount";
HostOpacityZeroAnimation = compositor.CreateScalarKeyFrameAnimation();
HostOpacityZeroAnimation.InsertExpressionKeyFrame(0f, "1f - TintOpacity", line);
HostOpacityZeroAnimation.InsertKeyFrame(1f, 0f, line);
HostOpacityZeroAnimation.Duration = TimeSpan.FromSeconds(0.1d);
HostOpacityZeroAnimation.Target = "arithmetic.Source1Amount";
TintToFallBackAnimation = compositor.CreateColorKeyFrameAnimation();
TintToFallBackAnimation.InsertKeyFrame(0f, TintColor, line);
TintToFallBackAnimation.InsertKeyFrame(1f, FallbackColor, line);
TintToFallBackAnimation.Duration = TimeSpan.FromSeconds(0.1d);
TintToFallBackAnimation.Target = "tintcolor.Color";
//Window.Current.Activated += Current_Activated;
//Window.Current.VisibilityChanged += Current_VisibilityChanged;
CoreWindow.GetForCurrentThread().Activated += AcrylicBrush_Activated;
CoreWindow.GetForCurrentThread().VisibilityChanged += AcrylicBrush_VisibilityChanged;
}