/// <summary>
/// Draw the layer.
/// </summary>
/// <param name="renderTime">Time since last render.</param>
/// <remarks>include base.Render(renderTime); in overloads to preserve updating RenderTime field.</remarks>
public override void Render(RenderTime renderTime)
{
// if we don't have a data provider, don't render
if (DataProvider == null || _kdProxy == null || MM_Repository.OverallDisplay.Contour == MM_Display.MM_Contour_Enum.None)
{
return;
}
base.Render(renderTime);
var displayView = Surface.Coordinates.GetViewXY();
var displayRect = Surface.DisplayRectangle;
var size = Surface.RenderTarget2D.PixelSize;
bool resized = _displayRect != displayRect;
bool viewSizeMatchesDisplaySize = displayView.Width == displayRect.Width && displayView.Height == displayRect.Height;
if ((displayView != _displayView || _bmp == null || _bmp.IsDisposed || resized) && !((MM_Network_Map_DX)Surface).HandlingMouse && viewSizeMatchesDisplaySize && !isRendering)
{
_displayRect = displayRect;
_displayView = displayView;
_size = size;
DrawBitmap(Surface.RenderTarget2D.PixelSize.Height / 10,
Surface.RenderTarget2D.PixelSize.Width / 10,
(float)MM_Coordinates.GConstants[_zoomLevel][1] * _zoomLevel * _zoomLevel, _displayView);
}
if (_bmp != null && Surface.RenderTarget2D != null && !((MM_Network_Map_DX)Surface).HandlingMouse)
{
var stateLayer = Surface.GetLayers <StateRegionsLayer>().FirstOrDefault();
var tx = Surface.RenderTarget2D.Transform;
Surface.RenderTarget2D.Transform = Matrix3x2.Translation(-Surface.Coordinates.TopLeftXY.X, -Surface.Coordinates.TopLeftXY.Y);
var dest = new SharpDX.RectangleF(-Surface.RenderTarget2D.Transform.M31, -Surface.RenderTarget2D.Transform.M32, Surface.RenderTarget2D.Size.Width, Surface.RenderTarget2D.Size.Height);
if (MM_Repository.OverallDisplay.ClipContours && stateLayer != null && stateLayer.State != null && stateLayer.State.Geometry != null && !(DataProvider is LineLoadingPercentageContourData))
{
var layerParameters = new LayerParameters()
{
ContentBounds = RectangleF.Infinite,
GeometricMask = stateLayer.State.Geometry,
Opacity = 1,
MaskTransform = tx
};
using (var layer = new Layer(Surface.RenderTarget2D, Surface.RenderTarget2D.Size))
{
Surface.RenderTarget2D.PushLayer(ref layerParameters, layer);
Surface.RenderTarget2D.DrawBitmap(_bmp, dest, 0.5f, BitmapInterpolationMode.Linear);
Surface.RenderTarget2D.PopLayer();
}
}
else
{
Surface.RenderTarget2D.DrawBitmap(_bmp, dest, 0.5f, BitmapInterpolationMode.Linear);
}
Surface.RenderTarget2D.Transform = tx;
}
}
public Disposable PushMask(RectangleF rect, float alpha, Path path = null)
{
if (alpha >= 1 && path == null)
{
CurrentRenderTarget.PushAxisAlignedClip(rect.ToRaw(), CurrentRenderTarget.AntialiasMode);
return(new Disposable(() => { CurrentRenderTarget.PopAxisAlignedClip(); }));
}
else
{
var geometery = path?.GetGeometry(CurrentRenderTarget.Factory);
var parameters = new LayerParameters
{
ContentBounds = rect.ToRaw(),
Opacity = alpha,
MaskTransform = GetCurrentTransform(),
GeometricMask = geometery
};
var layer = new Layer(CurrentRenderTarget);
CurrentRenderTarget.PushLayer(ref parameters, layer);
return(new Disposable(() =>
{
this.CurrentRenderTarget.PopLayer();
layer.Dispose();
geometery?.Dispose();
}));
}
}
/// <summary>
/// Pushes an opacity value.
/// </summary>
/// <param name="opacity">The opacity.</param>
/// <returns>A disposable used to undo the opacity.</returns>
public IDisposable PushOpacity(double opacity)
{
if (opacity < 1)
{
var parameters = new LayerParameters
{
ContentBounds = RectangleF.Infinite,
MaskTransform = Matrix3x2.Identity,
Opacity = (float)opacity,
};
var layer = new Layer(_renderTarget);
_renderTarget.PushLayer(ref parameters, layer);
return(Disposable.Create(() =>
{
_renderTarget.PopLayer();
layer.Dispose();
}));
}
else
{
return(Disposable.Empty);
}
}
internal override void _window_DrawGraphics(object sender, DrawGraphicsEventArgs e)
{
if (!Loaded)
{
return;
}
if (!_windowLoaded)
{
return;
}
e.Graphics.ClearScene();
var layerUsed = false;
if (!CurrentOpacity.CloseTo(1f))
{
var lp = new LayerParameters()
{
ContentBounds = new RawRectangleF(0, 0, Window.Width, Window.Height), Opacity = CurrentOpacity
};
e.Graphics.LayerHelper.AddOpacity(lp);
layerUsed = true;
}
DxWindow.Draw(e.Graphics);
OnDraw?.Invoke(sender, e);
if (layerUsed)
{
e.Graphics.LayerHelper.RemoveOpacity();
}
}
public override void PushOpacity(double opacity)
{
Layer layer = new Layer(this.target);
LayerParameters p = new LayerParameters();
p.Opacity = (float)opacity;
this.target.PushLayer(ref p, layer);
this.stack.Push(layer);
}
internal void EvaluateRanges(out LayerParameters parameters)
{
Vector4 layerInputEnd;
EvaluateInputRange(out parameters.LayerInputStart, out layerInputEnd);
parameters.LayerInputExtent = layerInputEnd - parameters.LayerInputStart;
EvaluateOutputRange(out parameters.LayerOutputStart, out parameters.LayerOutputEnd);
}
public FadeTransitionScene(LoadingOverlay overlay, GameContainer container, TimeSpan fadeTime)
{
Container = container;
Overlay = overlay;
FadingAnimation = new Animation(container);
FadeTime = fadeTime;
parameter = new LayerParameters()
{
ContentBounds = RectangleF.Infinite,
};
}
/// <summary>
/// Push a geometry clip change info.
/// </summary>
/// <param name="clip"></param>
public void PushGeometryClip(Avalonia.Media.Geometry clip)
{
var parameters = new LayerParameters
{
ContentBounds = PrimitiveExtensions.RectangleInfinite,
MaskTransform = PrimitiveExtensions.Matrix3x2Identity,
Opacity = 1,
GeometricMask = ((GeometryImpl)clip.PlatformImpl).Geometry
};
var layer = _layerPool.Count != 0 ? _layerPool.Pop() : new Layer(_renderTarget);
_renderTarget.PushLayer(ref parameters, layer);
_layers.Push(layer);
}
private void RenderWithLayer(WindowRenderTarget renderTarget)
{
using (Layer layer = renderTarget.CreateLayer())
{
renderTarget.Transform = Matrix3x2.Translation(350, 50);
LayerParameters layerParameters = new LayerParameters {
Bounds = RectF.Infinite, Mask = this._pathGeometry
};
renderTarget.PushLayer(layerParameters, layer);
RenderScene(renderTarget);
renderTarget.PopLayer();
}
}
public void PushGeometryClip(IGeometryImpl clip)
{
var parameters = new LayerParameters
{
ContentBounds = PrimitiveExtensions.RectangleInfinite,
MaskTransform = PrimitiveExtensions.Matrix3x2Identity,
Opacity = 1,
GeometricMask = ((GeometryImpl)clip).Geometry
};
var layer = _layerPool.Count != 0 ? _layerPool.Pop() : new Layer(_deviceContext);
_deviceContext.PushLayer(ref parameters, layer);
_layers.Push(layer);
}
public void PushOpacityMask(IBrush mask, Rect bounds)
{
var parameters = new LayerParameters
{
ContentBounds = PrimitiveExtensions.RectangleInfinite,
MaskTransform = PrimitiveExtensions.Matrix3x2Identity,
Opacity = 1,
OpacityBrush = CreateBrush(mask, bounds.Size).PlatformBrush
};
var layer = _layerPool.Count != 0 ? _layerPool.Pop() : new Layer(_deviceContext);
_deviceContext.PushLayer(ref parameters, layer);
_layers.Push(layer);
}
public LoadingOverlay(GameContainer container)
{
Resource.AddResource("Fore", new SolidColorBrushResource(new RawColor4(1, 0.64705882352941176470588235294118f, 0, 1)));
Resource.AddResource("Back", new SolidColorBrushResource(new RawColor4(1, 1, 1, .3f)));
format = new TextFormat(container.DWFactory, "Consolas", 32);
Container = container;
LoopAnimation = new Animation(Container);
FadeAnimation = new Animation(Container);
parameter = new LayerParameters()
{
ContentBounds = RectangleF.Infinite,
};
}
public Layer PushLayer(D2DGraphics g, ScLayer sclayer)
{
Layer d2dLayer = new Layer(g.RenderTarget);
LayerParameters layerParameters = new LayerParameters();
layerParameters.ContentBounds = GDIDataD2DUtils.TransToRawRectF(sclayer.DrawBox);
layerParameters.LayerOptions = LayerOptions.InitializeForCleartype;
layerParameters.MaskAntialiasMode = AntialiasMode.PerPrimitive;
//应用到GeometricMask上的变换，这个变换可能已经在计算布局的时候已经计算到了sclayer.TransLastHitPathGeometry上
//所以不需要应用变换
layerParameters.MaskTransform = identityMatrix;
layerParameters.Opacity = sclayer.Opacity;
layerParameters.GeometricMask = sclayer.TransLastHitPathGeometry;
g.RenderTarget.PushLayer(ref layerParameters, d2dLayer);
return(d2dLayer);
}
public IDisposable SetRectangleClipping(int x, int y, int w, int h)
{
DisposableObject disposableObject = new DisposableObject();
AddDrawRequest((target) =>
{
LayerParameters parm = new LayerParameters();
Layer layer = new Layer(target);
RawRectangleF rect = new RawRectangleF(x, y, x + w, y + h);
RectangleGeometry elli = new RectangleGeometry(target.Factory, rect);
disposableObject.OnDisposed += (s, e) =>
{
target.PopLayer();
layer.Dispose();
elli.Dispose();
};
parm.GeometricMask = elli;
target.PushLayer(ref parm, layer);
});
return(disposableObject);
}
public IDisposable SetCircleClipping(System.Drawing.Point center, int radius)
{
DisposableObject disposableObject = new DisposableObject();
AddDrawRequest((target) =>
{
LayerParameters parm = new LayerParameters();
Layer layer = new Layer(target);
Ellipse circle = new Ellipse(Vector2FromGDIPoint(center), radius, radius);
EllipseGeometry elli = new EllipseGeometry(target.Factory, circle);
disposableObject.OnDisposed += (s, e) =>
{
target.PopLayer();
layer.Dispose();
elli.Dispose();
};
parm.GeometricMask = elli;
target.PushLayer(ref parm, layer);
});
return(disposableObject);
}
/// <summary>
/// Pushes an opacity value.
/// </summary>
/// <param name="opacity">The opacity.</param>
/// <returns>A disposable used to undo the opacity.</returns>
public void PushOpacity(double opacity)
{
if (opacity < 1)
{
var parameters = new LayerParameters
{
ContentBounds = RectangleF.Infinite,
MaskTransform = Matrix3x2.Identity,
Opacity = (float)opacity,
};
var layer = _layerPool.Count != 0 ? _layerPool.Pop() : new Layer(_renderTarget);
_renderTarget.PushLayer(ref parameters, layer);
_layers.Push(layer);
}
else
{
_layers.Push(null);
}
}
/// <summary>
/// Pushes an opacity value.
/// </summary>
/// <param name="opacity">The opacity.</param>
/// <returns>A disposable used to undo the opacity.</returns>
public void PushOpacity(double opacity)
{
if (opacity < 1)
{
var parameters = new LayerParameters
{
ContentBounds = PrimitiveExtensions.RectangleInfinite,
MaskTransform = PrimitiveExtensions.Matrix3x2Identity,
Opacity = (float)opacity,
};
var layer = _layerPool.Count != 0 ? _layerPool.Pop() : new Layer(_deviceContext);
_deviceContext.PushLayer(ref parameters, layer);
_layers.Push(layer);
}
else
{
_layers.Push(null);
}
}
public LayerShape(RenderTarget initialRenderTarget, Random random, D2DFactory d2DFactory, D2DBitmap bitmap, int count)
: base(initialRenderTarget, random, d2DFactory, bitmap)
{
Parameters = new LayerParameters();
parameters.ContentBounds = CoinFlip ? RandomRect(CanvasWidth, CanvasHeight) : new RectF(0, 0, CanvasWidth, CanvasHeight);
if (CoinFlip)
{
GeometricMaskShape = new GeometryShape(initialRenderTarget, random, d2DFactory, Bitmap);
parameters.GeometricMask = GeometricMaskShape.Geometry;
}
parameters.MaskAntialiasMode = CoinFlip ? AntialiasMode.Aliased : AntialiasMode.PerPrimitive;
parameters.MaskTransform = RandomMatrix3x2();
parameters.Opacity = RandomOpacity();
if (CoinFlip)
parameters.OpacityBrush = RandomOpacityBrush();
parameters.Options = CoinFlip ? LayerOptions.InitializeForClearType : LayerOptions.None;
for(int i = 0; i < count; i++)
{
shapes.Add(RandomShape());
}
}
internal static void Render(CompositionEngine compositionEngine, RenderTarget renderTarget, FrameworkElement rootElement, TextBlock textBlock)
{
var textFormat = new TextFormat(
compositionEngine.DWriteFactory,
textBlock.FontFamily.Source,
(float)textBlock.FontSize)
{
TextAlignment = textBlock.TextAlignment.ToSharpDX(),
ParagraphAlignment = ParagraphAlignment.Near
};
var rect = textBlock.GetBoundingRect(rootElement).ToSharpDX();
// For some reason we need a bigger rect for the TextBlock rendering to fit in the same boundaries
rect.Right++;
rect.Bottom++;
var textBrush = textBlock.Foreground.ToSharpDX(renderTarget, rect);
var layer = new Layer(renderTarget);
var layerParameters = new LayerParameters();
layerParameters.ContentBounds = rect;
//renderTarget.PushLayer(ref layerParameters, layer);
// You can render the bounding rectangle to debug composition
//renderTarget.DrawRectangle(
// rect,
// textBrush);
renderTarget.DrawText(
textBlock.Text,
textFormat,
rect,
textBrush);
//renderTarget.PopLayer();
}
public LayerShape(RenderTarget initialRenderTarget, Random random, D2DFactory d2DFactory, D2DBitmap bitmap, int count)
: base(initialRenderTarget, random, d2DFactory, bitmap)
{
Parameters = new LayerParameters();
parameters.ContentBounds = CoinFlip ? RandomRect(CanvasWidth, CanvasHeight) : new RectF(0, 0, CanvasWidth, CanvasHeight);
if (CoinFlip)
{
GeometricMaskShape = new GeometryShape(initialRenderTarget, random, d2DFactory, Bitmap);
parameters.GeometricMask = GeometricMaskShape.Geometry;
}
parameters.MaskAntiAliasMode = CoinFlip ? AntiAliasMode.Aliased : AntiAliasMode.PerPrimitive;
parameters.MaskTransform = RandomMatrix3x2();
parameters.Opacity = RandomOpacity();
if (CoinFlip)
{
parameters.OpacityBrush = RandomOpacityBrush();
}
parameters.Options = CoinFlip ? LayerOptions.InitializeForClearType : LayerOptions.None;
for (int i = 0; i < count; i++)
{
shapes.Add(RandomShape());
}
}
protected override void OnDrawBuffer(GameTime gameTime, RenderContext context)
{
base.OnDrawBuffer(gameTime, context);
if (Opacity <= 0)
{
return;
}
var avatarRectangles = _avatarRectangles;
context.Begin2D();
var d2dContext = context.RenderTarget.DeviceContext2D;
var d2dFactory = d2dContext.Factory;
using (var geometry = new PathGeometry(d2dFactory)) {
using (var sink = geometry.Open()) {
foreach (var rect in avatarRectangles)
{
sink.BeginFigure(new Vector2(rect.X + rect.Width / 2, rect.Y), FigureBegin.Filled);
sink.AddArc(new ArcSegment {
ArcSize = ArcSize.Small,
Point = new Vector2(rect.X + rect.Width / 2, rect.Y + rect.Height),
Size = new Size2F(rect.Width / 2, rect.Height / 2),
SweepDirection = SweepDirection.CounterClockwise
});
sink.AddArc(new ArcSegment {
ArcSize = ArcSize.Small,
Point = new Vector2(rect.X + rect.Width / 2, rect.Y),
Size = new Size2F(rect.Width / 2, rect.Height / 2),
SweepDirection = SweepDirection.CounterClockwise
});
sink.EndFigure(FigureEnd.Closed);
}
sink.Close();
}
var originalAntiAliasMode = d2dContext.AntialiasMode;
// https://msdn.microsoft.com/en-us/library/windows/desktop/hh847947.aspx
var layerParams = new LayerParameters {
GeometricMask = geometry,
ContentBounds = RectangleF.Infinite,
MaskTransform = Matrix3x2.Identity,
MaskAntialiasMode = AntialiasMode.PerPrimitive,
Opacity = 1,
LayerOptions = LayerOptions.None
};
d2dContext.AntialiasMode = AntialiasMode.PerPrimitive;
using (var layer = new Layer(d2dContext)) {
d2dContext.PushLayer(ref layerParams, layer);
var avatarImages = _avatarImages;
for (var i = 0; i < avatarImages.Length; ++i)
{
var image = avatarImages[i];
if (image == null)
{
continue;
}
var rect = avatarRectangles[i];
context.DrawBitmap(image, rect.X, rect.Y, rect.Width, rect.Height);
}
d2dContext.PopLayer();
}
d2dContext.AntialiasMode = originalAntiAliasMode;
}
context.End2D();
context.Begin2D();
foreach (var rect in avatarRectangles)
{
context.DrawEllipse(_borderPen, rect.X, rect.Y, rect.Width, rect.Height);
}
context.End2D();
}
private void RenderWithLayer(WindowRenderTarget renderTarget)
{
using (Layer layer = renderTarget.CreateLayer())
{
renderTarget.Transform = Matrix3x2.Translation(350, 50);
LayerParameters layerParameters = new LayerParameters { Bounds = RectF.Infinite, Mask = this._pathGeometry };
renderTarget.PushLayer(layerParameters, layer);
RenderScene(renderTarget);
renderTarget.PopLayer();
}
}
public void PushLayer(ILayer layer, LayerParameters layerParameters)
{
base.innerRefT.PushLayer(layer, layerParameters);
}
private void _window_DrawGraphics(object sender, DrawGraphicsEventArgs e)
{
var gfx = e.Graphics;
gfx.ClearScene(_brushes["background"]);
gfx.DrawText(_fonts["arial"], 22, _brushes["white"], 20, 20, $"FPS: {gfx.FPS}");
var device = gfx.GetRenderTarget() as WindowRenderTarget;
var factory = gfx.GetFactory();
//var region = new SharpDX.Direct2D1.RoundedRectangle()
//{
// RadiusX = 16.0f,
// RadiusY = 16.0f,
// Rect = new SharpDX.Mathematics.Interop.RawRectangleF(200, 200, 300, 300)
//};
var geometry = new PathGeometry(factory);
var sink = geometry.Open();
sink.SetFillMode(FillMode.Winding);
sink.BeginFigure(new SharpDX.Mathematics.Interop.RawVector2(200, 200), FigureBegin.Filled);
sink.AddLine(new SharpDX.Mathematics.Interop.RawVector2(300, 200));
sink.AddArc(new ArcSegment()
{
ArcSize = ArcSize.Small,
Point = new SharpDX.Mathematics.Interop.RawVector2(300, 300),
RotationAngle = 0.0f,
Size = new SharpDX.Size2F(16.0f, 16.0f),
SweepDirection = SweepDirection.Clockwise
});
sink.AddLine(new SharpDX.Mathematics.Interop.RawVector2(200, 300));
sink.AddArc(new ArcSegment()
{
ArcSize = ArcSize.Small,
Point = new SharpDX.Mathematics.Interop.RawVector2(200, 200),
RotationAngle = 0.0f,
Size = new SharpDX.Size2F(16.0f, 16.0f),
SweepDirection = SweepDirection.Clockwise
});
sink.EndFigure(FigureEnd.Open);
sink.Close();
sink.Dispose();
// device.FillGeometry(geometry, _brushes["white"]);
var options = new LayerParameters()
{
//ContentBounds = new SharpDX.Mathematics.Interop.RawRectangleF(float.NegativeInfinity, float.NegativeInfinity, float.PositiveInfinity, float.PositiveInfinity),
GeometricMask = geometry,
//Opacity = 1.0f
};
var layer = new Layer(device, new SharpDX.Size2F(gfx.Width, gfx.Height));
device.PushLayer(ref options, layer);
gfx.FillRectangle(_brushes["white"], 100, 100, 400, 400);
device.PopLayer();
layer.Dispose();
geometry.Dispose();
}
