private static async Task <CompositionDrawingSurface> GetCompositionDrawingSurface(Compositor compositor, RenderTargetBitmap renderTargetBitmap)
{
IBuffer pixels = await renderTargetBitmap.GetPixelsAsync();
using (var canvasDevice = new CanvasDevice())
using (CompositionGraphicsDevice graphicsDevice = CanvasComposition.CreateCompositionGraphicsDevice(compositor, canvasDevice))
{
float dpi = DisplayInformation.GetForCurrentView().LogicalDpi;
using (var canvasBitmap = CanvasBitmap.CreateFromBytes(canvasDevice, pixels.ToArray(),
renderTargetBitmap.PixelWidth, renderTargetBitmap.PixelHeight,
DirectXPixelFormat.B8G8R8A8UIntNormalized, dpi))
{
CompositionDrawingSurface surface = graphicsDevice.CreateDrawingSurface(
new Size(renderTargetBitmap.PixelWidth, renderTargetBitmap.PixelHeight),
DirectXPixelFormat.B8G8R8A8UIntNormalized, DirectXAlphaMode.Premultiplied);
using (CanvasDrawingSession session = CanvasComposition.CreateDrawingSession(surface))
{
session.DrawImage(canvasBitmap, 0, 0,
new Rect(0, 0, canvasBitmap.Size.Width, canvasBitmap.Size.Height));
}
return(surface);
}
}
}
private void Setup()
{
_canvasDevice = new CanvasDevice();
var compositionGraphicsDevice = CanvasComposition.CreateCompositionGraphicsDevice(
Window.Current.Compositor,
_canvasDevice);
var compositor = Window.Current.Compositor;
_surface = compositionGraphicsDevice.CreateDrawingSurface(
new Size(1000, 600),
DirectXPixelFormat.B8G8R8A8UIntNormalized,
DirectXAlphaMode.Premultiplied);
// 现在只有这个参数能在 Composition 使用
var visual = compositor.CreateSpriteVisual();
visual.RelativeSizeAdjustment = Vector2.One;
var brush = compositor.CreateSurfaceBrush(_surface);
brush.Stretch = CompositionStretch.Uniform;
visual.Brush = brush;
ElementCompositionPreview.SetElementChildVisual(this, visual);
_compositionGraphicsDevice = compositionGraphicsDevice;
}
public void DrawTile(Rect rect, int tileRow, int tileColumn)
{
Color waterColor = Color.FromArgb(255, 172, 199, 242);
Action <CanvasBitmap> drawAction = (CanvasBitmap bitmap) =>
{
lock (sync)
{
using (var drawingSession = CanvasComposition.CreateDrawingSession(drawingSurface, rect))
{
drawingSession.Clear(waterColor);
if (bitmap != null)
{
drawingSession.DrawImage(bitmap);
}
}
}
};
if (TileCache.Tiles.ContainsKey(TileCache.GetTileKey(ZoomLevel, tileColumn, tileRow)))
{
drawAction(TileCache.Tiles[TileCache.GetTileKey(ZoomLevel, tileColumn, tileRow)]);
}
else
{
drawAction(null);
//TODO handle the error case where the load fails
CanvasBitmap.LoadAsync(CanvasDevice.GetSharedDevice(), TileCache.GetTileUri(ZoomLevel, tileColumn, tileRow), 96).AsTask().ContinueWith((bm) =>
{
TileCache.AddImage(ZoomLevel, tileColumn, tileRow, bm.Result);
//redraw the tile once we have the image downloaded
drawAction(bm.Result);
});
}
}
public CompositionMaskHelper(Compositor compositor)
{
_compositor = compositor;
_canvasDevice = new CanvasDevice();
_compositionDevice = CanvasComposition.CreateCompositionGraphicsDevice(_compositor, _canvasDevice);
_surfaceFactory = SurfaceFactory.CreateFromCompositor(_compositor);
}
/// <summary>
/// This method allows us to reuse a background image that has already been processed.
/// </summary>
/// <param name="pixels">The pixel buffer.</param>
/// <param name="bitmap">The output from RenderTargetBitmap.</param>
/// <param name="dpi">The view DPI where the background was rendered.</param>
/// <param name="areaToRender">The region of the background we wish to cut out.</param>
/// <returns>A <see cref="CompositionSurfaceBrush" /> containing the portion of the background we want.</returns>
private CompositionSurfaceBrush CreateBackgroundBrush(IBuffer pixels, RenderTargetBitmap bitmap, float dpi,
Rect areaToRender)
{
// load the pixels from RenderTargetBitmap onto a CompositionDrawingSurface
CompositionDrawingSurface uiElementBitmapSurface;
using (
// this is the entire background image
// Note we are using the display DPI here.
var canvasBitmap = CanvasBitmap.CreateFromBytes(
_canvasDevice, pixels.ToArray(),
bitmap.PixelWidth,
bitmap.PixelHeight,
DirectXPixelFormat.B8G8R8A8UIntNormalized,
dpi)
)
{
// we create a surface we can draw on in memory.
// note we are using the desired size of our overlay
uiElementBitmapSurface =
_compositionDevice.CreateDrawingSurface(
new Size(areaToRender.Width, areaToRender.Height),
DirectXPixelFormat.B8G8R8A8UIntNormalized, DirectXAlphaMode.Premultiplied);
using (var session = CanvasComposition.CreateDrawingSession(uiElementBitmapSurface))
{
// here we draw just the part of the background image we wish to use to overlay
session.DrawImage(canvasBitmap, 0, 0, areaToRender);
}
}
var backgroundBrush = _compositor.CreateSurfaceBrush(uiElementBitmapSurface);
backgroundBrush.Stretch = CompositionStretch.UniformToFill;
return(backgroundBrush);
}
public FrameServerHandler(MediaPlayer player, FrameworkElement container, string id, IPropertySet properties)
{
CanvasDevice = CanvasDevice.GetSharedDevice();
Container = container;
ID = id;
Player = player;
ContainerVisual = ElementCompositionPreview.GetElementVisual(container);
Compositor = ContainerVisual.Compositor;
CompositionDevice = CanvasComposition.CreateCompositionGraphicsDevice(Compositor, CanvasDevice);
SpriteVisual = Compositor.CreateSpriteVisual();
SurfaceBrush = Compositor.CreateSurfaceBrush();
SpriteVisual.Brush = SurfaceBrush;
SurfaceBrush.Stretch = CompositionStretch.Uniform;
ElementCompositionPreview.SetElementChildVisual(container, SpriteVisual);
var sizeAni = Compositor.CreateExpressionAnimation("Container.Size");
sizeAni.SetReferenceParameter("Container", ContainerVisual);
SpriteVisual.StartAnimation("Size", sizeAni);
CanvasDevice.DeviceLost += CanvasDevice_DeviceLost;
Container.SizeChanged += Container_SizeChanged;
player.IsVideoFrameServerEnabled = true;
player.VideoFrameAvailable += Player_VideoFrameAvailable;
player.MediaOpened += Player_MediaOpened;
//createDestinationTarget();
}
public void DrawString(string c)
{
sofar += c;
using (
var drawingSession = CanvasComposition.CreateDrawingSession(drawingSurface,
new Rect(0, 0, ActualWidth, ActualHeight)))
{
CanvasTextFormat tf = new CanvasTextFormat()
{
FontSize = 72
};
float xLoc = 100.0f;
float yLoc = 100.0f;
CanvasTextFormat format = new CanvasTextFormat
{
FontSize = 30.0f,
WordWrapping = CanvasWordWrapping.NoWrap
};
CanvasTextLayout textLayout = new CanvasTextLayout(drawingSession, sofar, format, 0.0f,
0.0f);
Rect theRectYouAreLookingFor = new Rect(xLoc + textLayout.DrawBounds.X,
yLoc + textLayout.DrawBounds.Y, textLayout.DrawBounds.Width, textLayout.DrawBounds.Height);
drawingSession.DrawRectangle(theRectYouAreLookingFor, Colors.Green, 1.0f);
drawingSession.DrawTextLayout(textLayout, xLoc, yLoc, Colors.Yellow);
drawingSession.DrawInk(list);
}
}
CompositionDrawingSurface ApplyBlurEffect(CanvasBitmap bitmap, Windows.UI.Composition.CompositionGraphicsDevice device, Size sizeTarget)
{
GaussianBlurEffect blurEffect = new GaussianBlurEffect()
{
Source = bitmap,
BlurAmount = 20.0f,
BorderMode = EffectBorderMode.Hard,
};
float fDownsample = .3f;
Size sizeSource = bitmap.Size;
if (sizeTarget == Size.Empty)
{
sizeTarget = sizeSource;
}
sizeTarget = new Size(sizeTarget.Width * fDownsample, sizeTarget.Height * fDownsample);
CompositionDrawingSurface blurSurface = device.CreateDrawingSurface(sizeTarget, DirectXPixelFormat.B8G8R8A8UIntNormalized, DirectXAlphaMode.Premultiplied);
using (var ds = CanvasComposition.CreateDrawingSession(blurSurface))
{
Rect destination = new Rect(0, 0, sizeTarget.Width, sizeTarget.Height);
ds.Clear(Windows.UI.Color.FromArgb(255, 255, 255, 255));
ds.DrawImage(blurEffect, destination, new Rect(0, 0, sizeSource.Width, sizeSource.Height));
}
return(blurSurface);
}
#pragma warning disable 1998
public async Task Draw(CompositionGraphicsDevice device, Object drawingLock, CompositionDrawingSurface surface, Size size)
{
using (var ds = CanvasComposition.CreateDrawingSession(surface)) {
ds.Clear(Colors.Transparent);
ds.FillCircle(new Vector2(_radius, _radius), _radius, _color);
}
}
private static async Task <CompositionDrawingSurface> LoadFromUri(CanvasDevice canvasDevice, CompositionGraphicsDevice compositionDevice, Uri uri, Size sizeTarget)
{
CanvasBitmap bitmap = await CanvasBitmap.LoadAsync(canvasDevice, uri);
Size sizeSource = bitmap.Size;
if (sizeTarget.IsEmpty)
{
sizeTarget = sizeSource;
}
var surface = compositionDevice.CreateDrawingSurface(
sizeTarget,
DirectXPixelFormat.B8G8R8A8UIntNormalized,
DirectXAlphaMode.Premultiplied);
using (var ds = CanvasComposition.CreateDrawingSession(surface))
{
ds.Clear(Color.FromArgb(0, 0, 0, 0));
ds.DrawImage(
bitmap,
new Rect(0, 0, sizeTarget.Width, sizeTarget.Height),
new Rect(0, 0, sizeSource.Width, sizeSource.Height),
1,
CanvasImageInterpolation.HighQualityCubic);
}
return(surface);
}
void RenderFrame()
{
if (destinationTarget != null)
{
lock (ResourceLock)
{
var args = new VideoEffectHandlerArgs()
{
InputFrame = sourceTarget,
OutputFrame = destinationTarget,
ID = ID,
Properties = Properties,
Device = CanvasDevice
};
bool effectsAdded = VideoEffectManager.ProcessFrame(args);
using (var ds = CanvasComposition.CreateDrawingSession(DrawingSurface))
{
ds.DrawImage(destinationTarget);
}
}
}
else
{
Container.RunOnUIThread(createDestinationTarget);
}
}
private CompositionDrawingSurface SampleImageColor(CanvasBitmap bitmap, CompositionGraphicsDevice device, Size sizeTarget)
{
// Extract the color to tint the blur with
Color predominantColor = ExtractPredominantColor(bitmap.GetPixelColors(), bitmap.Size);
Size sizeSource = bitmap.Size;
if (sizeTarget.IsEmpty)
{
sizeTarget = sizeSource;
}
// Create a heavily blurred version of the image
GaussianBlurEffect blurEffect = new GaussianBlurEffect()
{
Source = bitmap,
BlurAmount = 20.0f
};
CompositionDrawingSurface surface = device.CreateDrawingSurface(sizeTarget,
DirectXPixelFormat.B8G8R8A8UIntNormalized, DirectXAlphaMode.Premultiplied);
using (var ds = CanvasComposition.CreateDrawingSession(surface))
{
Rect destination = new Rect(0, 0, sizeTarget.Width, sizeTarget.Height);
ds.FillRectangle(destination, predominantColor);
ds.DrawImage(blurEffect, destination, new Rect(0, 0, sizeSource.Width, sizeSource.Height), .6f);
}
return(surface);
}
void DrawDrawingSurface()
{
++drawCount;
using (var ds = CanvasComposition.CreateDrawingSession(drawingSurface))
{
ds.Clear(Colors.Transparent);
var rect = new Rect(new Point(2, 2), (drawingSurface.Size.ToVector2() - new Vector2(4, 4)).ToSize());
ds.FillRoundedRectangle(rect, 15, 15, Colors.LightBlue);
ds.DrawRoundedRectangle(rect, 15, 15, Colors.Gray, 2);
ds.DrawText("This is a composition drawing surface", rect, Colors.Black, new CanvasTextFormat()
{
FontFamily = "Comic Sans MS",
FontSize = 32,
WordWrapping = CanvasWordWrapping.WholeWord,
VerticalAlignment = CanvasVerticalAlignment.Center,
HorizontalAlignment = CanvasHorizontalAlignment.Center
});
ds.DrawText("Draws: " + drawCount, rect, Colors.Black, new CanvasTextFormat()
{
FontSize = 10,
VerticalAlignment = CanvasVerticalAlignment.Bottom,
HorizontalAlignment = CanvasHorizontalAlignment.Center
});
}
}
private void Form1_Load(object sender, EventArgs e)
{
// This container visual is optional - content could go directly into the root
// containerVisual. This lets you overlay just the picture box, and you could add
// other container visuals to overlay other areas of the UI.
pictureOverlayVisual = compositor.CreateContainerVisual();
pictureOverlayVisual.Offset = new Vector3(pictureBox1.Bounds.Left, pictureBox1.Bounds.Top, 0);
pictureOverlayVisual.Size = new Vector2(pictureBox1.Width, pictureBox1.Height);
containerVisual.Children.InsertAtTop(pictureOverlayVisual);
rectWidth = pictureBox1.Width / 2;
rectHeight = pictureBox1.Height / 2;
// Get graphics device.
compositionGraphicsDevice = CanvasComposition.CreateCompositionGraphicsDevice(compositor, canvasDevice);
// Create surface.
var noiseDrawingSurface = compositionGraphicsDevice.CreateDrawingSurface(
new Windows.Foundation.Size(rectWidth, rectHeight),
DirectXPixelFormat.B8G8R8A8UIntNormalized,
DirectXAlphaMode.Premultiplied);
// Draw to surface and create surface brush.
var noiseFilePath = AppDomain.CurrentDomain.BaseDirectory + "Assets\\NoiseAsset_256X256.png";
LoadSurface(noiseDrawingSurface, noiseFilePath);
noiseSurfaceBrush = compositor.CreateSurfaceBrush(noiseDrawingSurface);
// Add composition content to tree.
AddCompositionContent();
}
/// <summary>
/// Redraws the mask surface with the given size and geometry
/// </summary>
/// <param name="surface">CompositionDrawingSurface</param>
/// <param name="size">Size ofthe Mask Surface</param>
/// <param name="geometry">Geometry of the Mask Surface</param>
/// <returns>Task</returns>
public Task RedrawMaskSurfaceAsync(CompositionDrawingSurface surface, Size size, CanvasGeometry geometry)
{
return(Task.Run(() =>
{
//
// Since the drawing is done asynchronously and multiple threads could
// be trying to get access to the device/surface at the same time, we need
// to do any device/surface work under a lock.
//
lock (_drawingLock)
{
// Render the mask to the surface
using (var session = CanvasComposition.CreateDrawingSession(surface))
{
// If the geometry is not null then fill the geometry area
// with white. The rest of the area on the surface will be transparent.
// When this mask is applied to a visual, only the area that is white
// will be visible.
if (geometry != null)
{
session.Clear(Colors.Transparent);
session.FillGeometry(geometry, Colors.White);
}
else
{
// If the geometry is null, then the entire mask should be filled white
// so that the masked visual can be seen completely.
session.Clear(Colors.White);
}
}
}
}));
}
void DrawText(CanvasTextLayout textLayout)
{
#region unused
// text drawer method 1 - no anti-aliasing feature
//var layout = new CanvasTextLayout(_device, Text, textformat, (float)Width, (float)Height);
//var geometry = CanvasGeometry.CreateText(layout);
//var compPath = new CompositionPath(geometry);
//var pathGeo = _compositor.CreatePathGeometry(compPath);
// set to container
//var w = _compositor.CreateSpriteShape(pathGeo);
//w.FillBrush = _compositor.CreateColorBrush(Color.FromArgb(0xd7, 0xff, 0xff, 0xff));
//_shape.Shapes.Add(w);
#endregion
// text drawer - with anti-aliasing feature
using var ds = CanvasComposition.CreateDrawingSession(_drawsurface);
ds.Antialiasing = CanvasAntialiasing.Antialiased;
//ds.DrawText(Text, rectext, Color.FromArgb(0xd7, 0xff, 0xff, 0xff), textformat);
ds.DrawTextLayout(textLayout, (float)Width / 2, (float)Height / 2, Color.FromArgb(0xd7, 0xff, 0xff, 0xff));
ds.Flush();
ds.Dispose();
// set to container
var brush = _compositor.CreateSurfaceBrush(_drawsurface);
var sprite = _compositor.CreateSpriteVisual();
sprite.Brush = brush;
sprite.Size = _size;
_shape.Children.InsertAtTop(sprite);
}
/// <summary>
/// Creates an instance of the ColorBloomTransitionHelper.
/// Any visuals to be later created and animated will be hosted within the specified UIElement.
/// </summary>
public ColorBloomTransitionHelper(UIElement hostForVisual)
{
this.hostForVisual = hostForVisual;
// we have an element in the XAML tree that will host our Visuals
var visual = ElementCompositionPreview.GetElementVisual(hostForVisual);
_compositor = visual.Compositor;
// create a container
// adding children to this container adds them to the live visual tree
_containerForVisuals = _compositor.CreateContainerVisual();
ElementCompositionPreview.SetElementChildVisual(hostForVisual, _containerForVisuals);
_canvasDevice = new CanvasDevice();
_graphicsDevice = CanvasComposition.CreateCompositionGraphicsDevice(_compositor, _canvasDevice);
// Create the circle mask
_circleMaskSurface = LoadCircle(200, Colors.White);
}
private void Setup()
{
_canvasDevice = new CanvasDevice();
_compositionGraphicsDevice = CanvasComposition.CreateCompositionGraphicsDevice(
Windows.UI.Xaml.Window.Current.Compositor,
_canvasDevice);
_compositor = Windows.UI.Xaml.Window.Current.Compositor;
_surface = _compositionGraphicsDevice.CreateDrawingSurface(
new Windows.Foundation.Size(400, 400),
DirectXPixelFormat.B8G8R8A8UIntNormalized,
DirectXAlphaMode.Premultiplied); // This is the only value that currently works with
// the composition APIs.
var visual = _compositor.CreateSpriteVisual();
visual.RelativeSizeAdjustment = Vector2.One;
var brush = _compositor.CreateSurfaceBrush(_surface);
brush.HorizontalAlignmentRatio = 0.5f;
brush.VerticalAlignmentRatio = 0.5f;
brush.Stretch = CompositionStretch.Uniform;
visual.Brush = brush;
ElementCompositionPreview.SetElementChildVisual(this, visual);
StartCaptureInternal(MainPage.targetcap);
}
public Screenshot()
{
_canvasDevice = new CanvasDevice();
_compositionGraphicsDevice = CanvasComposition.CreateCompositionGraphicsDevice(
Window.Current.Compositor,
_canvasDevice);
_compositor = Window.Current.Compositor;
_surface = _compositionGraphicsDevice.CreateDrawingSurface(
new Size(400, 400),
DirectXPixelFormat.B8G8R8A8UIntNormalized,
DirectXAlphaMode.Premultiplied); // This is the only value that currently works with
// the composition APIs.
//var visual = _compositor.CreateSpriteVisual();
//visual.RelativeSizeAdjustment = Vector2.One;
//var brush = _compositor.CreateSurfaceBrush(_surface);
//brush.HorizontalAlignmentRatio = 0.5f;
//brush.VerticalAlignmentRatio = 0.5f;
//brush.Stretch = CompositionStretch.Uniform;
//visual.Brush = brush;
//ElementCompositionPreview.SetElementChildVisual(this, visual);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="compositor">Compositor</param>
/// <param name="useSharedCanvasDevice">Whether to use a shared CanvasDevice or to create a new one.</param>
/// <param name="useSoftwareRenderer">Whether to use Software Renderer when creating a new CanvasDevice.</param>
public CompositionGenerator(Compositor compositor, bool useSharedCanvasDevice = true, bool useSoftwareRenderer = false)
{
if (compositor == null)
{
throw new ArgumentNullException(nameof(compositor), "Compositor cannot be null!");
}
// Compositor
_compositor = compositor;
// Disposing Lock
_disposingLock = new object();
// Canvas Device
_canvasDevice = useSharedCanvasDevice ?
CanvasDevice.GetSharedDevice() : new CanvasDevice(useSoftwareRenderer);
_isCanvasDeviceCreator = !useSharedCanvasDevice;
_canvasDevice.DeviceLost += DeviceLost;
// Composition Graphics Device
_graphicsDevice = CanvasComposition.CreateCompositionGraphicsDevice(_compositor, _canvasDevice);
_isGraphicsDeviceCreator = true;
_graphicsDevice.RenderingDeviceReplaced += RenderingDeviceReplaced;
if (!DesignMode.DesignModeEnabled)
{
DisplayInformation.DisplayContentsInvalidated += OnDisplayContentsInvalidated;
}
}
/// <summary>
/// Initializes the Composition Brush.
/// </summary>
protected override void OnConnected()
{
base.OnConnected();
// Delay creating composition resources until they're required.
if (CompositionBrush == null)
{
// Abort if effects aren't supported.
if (!CompositionCapabilities.GetForCurrentView().AreEffectsSupported())
{
return;
}
var size = new Vector2(SurfaceWidth, SurfaceHeight);
var device = CanvasDevice.GetSharedDevice();
var graphics = CanvasComposition.CreateCompositionGraphicsDevice(Window.Current.Compositor, device);
var surface = graphics.CreateDrawingSurface(size.ToSize(), DirectXPixelFormat.B8G8R8A8UIntNormalized, DirectXAlphaMode.Premultiplied);
using (var session = CanvasComposition.CreateDrawingSession(surface))
{
// Call Implementor to draw on session.
if (!OnDraw(device, session, size))
{
return;
}
}
_surfaceBrush = Window.Current.Compositor.CreateSurfaceBrush(surface);
_surfaceBrush.Stretch = CompositionStretch.Fill;
CompositionBrush = _surfaceBrush;
}
}
public async Task DrawSurface(CompositionDrawingSurface surface, Uri uri, Size size)
{
var canvasDevice = CanvasComposition.GetCanvasDevice(_graphicsDevice);
using (var canvasBitmap = await CanvasBitmap.LoadAsync(canvasDevice, uri))
{
var bitmapSize = canvasBitmap.Size;
//
// Because the drawing is done asynchronously and multiple threads could
// be trying to get access to the device/surface at the same time, we need
// to do any device/surface work under a lock.
//
lock (_drawingLock)
{
Size surfaceSize = size;
if (surfaceSize.IsEmpty)
{
// Resize the surface to the size of the image
CanvasComposition.Resize(surface, bitmapSize);
surfaceSize = bitmapSize;
}
// Draw the image to the surface
using (var session = CanvasComposition.CreateDrawingSession(surface))
{
session.Clear(Windows.UI.Color.FromArgb(0, 0, 0, 0));
session.DrawImage(canvasBitmap, new Rect(0, 0, surfaceSize.Width, surfaceSize.Height), new Rect(0, 0, bitmapSize.Width, bitmapSize.Height));
}
}
}
}
private void CompositionHostControl_Loaded(object sender, RoutedEventArgs e)
{
_currentDpi = WindowsMedia.VisualTreeHelper.GetDpi(this);
_rectWidth = CompositionHostElement.ActualWidth / 2;
_rectHeight = CompositionHostElement.ActualHeight / 2;
// Get graphics device.
_compositionGraphicsDevice = CanvasComposition.CreateCompositionGraphicsDevice(_compositor, _canvasDevice);
// Create surface.
var noiseDrawingSurface = _compositionGraphicsDevice.CreateDrawingSurface(
new Windows.Foundation.Size(_rectWidth, _rectHeight),
DirectXPixelFormat.B8G8R8A8UIntNormalized,
DirectXAlphaMode.Premultiplied);
// Draw to surface and create surface brush.
var noiseFilePath = AppDomain.CurrentDomain.BaseDirectory + "Assets\\NoiseAsset_256X256.png";
LoadSurface(noiseDrawingSurface, noiseFilePath);
_noiseSurfaceBrush = _compositor.CreateSurfaceBrush(noiseDrawingSurface);
// Add composition content to tree.
_compositionHost.SetChild(_containerVisual);
AddCompositionContent();
ToggleAcrylic();
}
internal void ReDraw(Rect viewPort, float zoom)
{
var toDraw = GetDrawingBoundaries(viewPort);
var scale = _screenScale * zoom;
var rect = ScaleRect(toDraw, scale);
var dpi = BaseCanvasDPI * (float)scale;
try
{
using (var drawingSession = CanvasComposition.CreateDrawingSession(_drawingSurface, rect, dpi))
{
drawingSession.Clear(Colors.White);
foreach (var drawable in _visibleList)
{
drawable.Draw(drawingSession, toDraw);
}
}
}
catch (ArgumentException)
{
/* CanvasComposition.CreateDrawingSession has an internal
* limit on the size of the updateRectInPixels parameter,
* which we don't know, so we can get an ArgumentException
* if there is a lot of extreme zooming and panning
* Therefore, the only solution is to silently catch the
* exception and allow the app to continue
*/
}
}
public async Task Draw(CompositionGraphicsDevice device, Object drawingLock, CompositionDrawingSurface surface, Size size)
{
using (var ds = CanvasComposition.CreateDrawingSession(surface)) {
ds.Clear(_backgroundColor);
ds.DrawText(_text, new Rect(0, 0, surface.Size.Width, surface.Size.Height), _textColor, _textFormat);
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="compositor">Compositor</param>
/// <param name="graphicsDevice">CompositionGraphicsDevice</param>
/// <param name="sharedLock">shared lock</param>
public CompositionMaskGenerator(Compositor compositor, CompositionGraphicsDevice graphicsDevice = null,
object sharedLock = null)
{
if (compositor == null)
{
throw new ArgumentNullException(nameof(compositor), "Compositor cannot be null!");
}
_compositor = compositor;
_drawingLock = sharedLock ?? new object();
if (_canvasDevice == null)
{
_canvasDevice = CanvasDevice.GetSharedDevice();
_canvasDevice.DeviceLost += DeviceLost;
}
if (graphicsDevice == null)
{
// Create the Composition Graphics Device
_graphicsDevice = CanvasComposition.CreateCompositionGraphicsDevice(_compositor, _canvasDevice);
_isDeviceCreator = true;
}
else
{
_graphicsDevice = graphicsDevice;
_isDeviceCreator = false;
}
// Subscribe to events
_graphicsDevice.RenderingDeviceReplaced += RenderingDeviceReplaced;
DisplayInformation.DisplayContentsInvalidated += OnDisplayContentsInvalidated;
}
public void InitializeComposition()
{
compositor = ElementCompositionPreview.GetElementVisual(this as UIElement).Compositor;
win2dDevice = CanvasDevice.GetSharedDevice();
comositionGraphicsDevice = CanvasComposition.CreateCompositionGraphicsDevice(compositor, win2dDevice);
myDrawingVisual = compositor.CreateSpriteVisual();
ElementCompositionPreview.SetElementChildVisual(virtualSurfaceHost, myDrawingVisual);
}
internal void InitializeComposition()
{
_compositor = ElementCompositionPreview.GetElementVisual(this).Compositor;
_win2DDevice = CanvasDevice.GetSharedDevice();
_comositionGraphicsDevice = CanvasComposition.CreateCompositionGraphicsDevice(_compositor, _win2DDevice);
_myDrawingVisual = _compositor.CreateSpriteVisual();
ElementCompositionPreview.SetElementChildVisual(this, _myDrawingVisual);
}
void DrawSoftwareBitmap(SoftwareBitmap softwareBitmap, Size renderSize)
{
using (var drawingSession = CanvasComposition.CreateDrawingSession(_drawingSurface))
using (var bitmap = CanvasBitmap.CreateFromSoftwareBitmap(drawingSession.Device, softwareBitmap))
{
drawingSession.DrawImage(bitmap,
new Rect(0, 0, renderSize.Width, renderSize.Height));
}
}
/// <summary>
/// Handles the DeviceLost event
/// </summary>
/// <param name="sender">CanvasDevice</param>
/// <param name="args">event arguments</param>
private void DeviceLost(CanvasDevice sender, object args)
{
sender.DeviceLost -= DeviceLost;
_canvasDevice = CanvasDevice.GetSharedDevice();
_canvasDevice.DeviceLost += DeviceLost;
CanvasComposition.SetCanvasDevice(_graphicsDevice, _canvasDevice);
}
