/// <summary>
/// Initializes a new instance of the <see cref="TileBrushImpl"/> class.
/// </summary>
/// <param name="brush"></param>
/// <param name="target"></param>
/// <param name="targetSize"></param>
public TileBrushImpl(
TileBrush brush,
SharpDX.Direct2D1.RenderTarget target,
Size targetSize)
{
var helper = new TileBrushImplHelper(brush, targetSize);
if (!helper.IsValid)
{
return;
}
using (var intermediate = new BitmapRenderTarget(target, CompatibleRenderTargetOptions.None, helper.IntermediateSize.ToSharpDX()))
{
using (var ctx = new RenderTarget(intermediate).CreateDrawingContext())
{
intermediate.Clear(null);
helper.DrawIntermediate(ctx);
}
PlatformBrush = new BitmapBrush(
target,
intermediate.Bitmap,
GetBitmapBrushProperties(brush),
GetBrushProperties(brush, helper.DestinationRect));
}
}
private void Render(bool shouldRecompose, bool shouldRetry)
{
var interpolationMode = false ? BitmapInterpolationMode.Linear : BitmapInterpolationMode.NearestNeighbor;
_windowRenderTarget.BeginDraw();
if (BorderVisible)
{
CreateCompositeRenderTarget();
_compositeRenderTarget.BeginDraw();
_compositeRenderTarget.Clear(_clearColor);
_compositeRenderTarget.DrawBitmap(_screenRenderTarget.Bitmap, new RawRectangleF(48, 40, 48 + 160, 40 + 144), 1.0f, BitmapInterpolationMode.NearestNeighbor);
_compositeRenderTarget.DrawBitmap(_borderBitmap, 1.0f, BitmapInterpolationMode.NearestNeighbor);
_compositeRenderTarget.EndDraw();
_windowRenderTarget.DrawBitmap(_compositeRenderTarget.Bitmap, _drawRectangle, 1.0f, interpolationMode);
}
else
{
_windowRenderTarget.DrawBitmap(_screenRenderTarget.Bitmap, _drawRectangle, 1.0f, interpolationMode);
}
try { _windowRenderTarget.EndDraw(); }
catch (COMException)
{
// If needed, try to recreate the target.
ResetRendering();
// Try to render again, but only once. (We don't want to enter an infinite recursion… AKA Stack Overflow)
if (shouldRetry)
{
Render(true, false);
}
}
}
public VisualBrushImpl(
VisualBrush brush,
SharpDX.Direct2D1.RenderTarget target,
Size targetSize)
{
var visual = brush.Visual;
if (visual == null)
{
return;
}
var layoutable = visual as ILayoutable;
if (layoutable?.IsArrangeValid == false)
{
layoutable.Measure(Size.Infinity);
layoutable.Arrange(new Rect(layoutable.DesiredSize));
}
var tileMode = brush.TileMode;
var sourceRect = brush.SourceRect.ToPixels(layoutable.Bounds.Size);
var destinationRect = brush.DestinationRect.ToPixels(targetSize);
var scale = brush.Stretch.CalculateScaling(destinationRect.Size, sourceRect.Size);
var translate = CalculateTranslate(brush, sourceRect, destinationRect, scale);
var intermediateSize = CalculateIntermediateSize(tileMode, targetSize, destinationRect.Size);
var brtOpts = CompatibleRenderTargetOptions.None;
// TODO: There are times where we don't need to draw an intermediate bitmap. Identify
// them and directly use 'image' in those cases.
using (var intermediate = new BitmapRenderTarget(target, brtOpts, intermediateSize))
{
Rect drawRect;
var transform = CalculateIntermediateTransform(
tileMode,
sourceRect,
destinationRect,
scale,
translate,
out drawRect);
var renderer = new RenderTarget(intermediate);
using (var ctx = renderer.CreateDrawingContext())
using (ctx.PushClip(drawRect))
using (ctx.PushPostTransform(transform))
{
intermediate.Clear(new Color4(0));
ctx.Render(visual);
}
this.PlatformBrush = new BitmapBrush(
target,
intermediate.Bitmap,
GetBitmapBrushProperties(brush),
GetBrushProperties(brush, destinationRect));
}
}
private void DrawLayerOnBitmap()
{
bitmapRt.BeginDraw();
bitmapRt.Clear();
lock (Locker)
{
foreach (var e in elements)
{
e.Draw(bitmapRt);
}
}
bitmapRt.EndDraw();
}
protected override void Render(RenderTarget rt)
{
if (image == null)
{
base.Render(rt);
return;
}
rt.Clear(this.SceneColorBrush.Color);
rt.Transform = Matrix3x2.Identity;
Size2 imageSize = this.image.PixelSize;
double scale = Math.Min((double)(ClientSize.Width - ImagePadding) / imageSize.Width, (double)(ClientSize.Height - ImagePadding) / imageSize.Height);
int imageWidth = (int)(imageSize.Width * scale);
int imageHeight = (int)(imageSize.Height * scale);
var rcBounds = new RectangleF(0, 0, imageSize.Width, imageSize.Height);
var rcImage = new RectangleF((ClientSize.Width - imageWidth) / 2, (ClientSize.Height - imageHeight) / 2, imageWidth, imageHeight);
bool isBGRAImage = image.PixelFormat.Format == SharpDX.DXGI.Format.B8G8R8A8_UNorm;
if (!isBGRAImage)
{
var sz = new Size2F(imageSize.Width, imageSize.Height);
var rc = new RectangleF(0, 0, imageSize.Width, imageSize.Height);
if (bgraImageRenderer == null || bgraImageRenderer.Size != sz)
{
SharpDX.Utilities.Dispose(ref bgraImageRenderer);
bgraImageRenderer = new BitmapRenderTarget(RenderTarget2D, CompatibleRenderTargetOptions.None, sz);
}
bgraImageRenderer.BeginDraw();
bgraImageRenderer.Clear(Color.Black);
bgraImageRenderer.AntialiasMode = AntialiasMode.Aliased;
bgraImageRenderer.FillOpacityMask(this.image, whiteBrush, OpacityMaskContent.Graphics, rc, rc);
bgraImageRenderer.EndDraw();
}
rt.DrawBitmap(isBGRAImage ? image : bgraImageRenderer.Bitmap, rcImage, 1, BitmapInterpolationMode.NearestNeighbor, rcBounds);
if (ImagePadding != 0)
{
rt.DrawRectangle(rcImage, whiteBrush, 1);
}
}
void RenderD2DContentIntoSurface()
{
SizeF rtSize = renderTarget.Size;
renderTarget.BeginDraw();
if (!isOpacityRTPopulated)
{
opacityRenderTarget.BeginDraw();
opacityRenderTarget.Transform = Matrix3x2F.Identity;
opacityRenderTarget.Clear(new ColorF(GetColorValues(System.Windows.Media.Colors.Black), 0));
opacityRenderTarget.DrawText(
text,
textFormat,
new RectF(
0,
0,
rtSize.Width,
rtSize.Height
),
textBrush
);
opacityRenderTarget.EndDraw();
isOpacityRTPopulated = true;
}
renderTarget.Clear(new ColorF(GetColorValues(System.Windows.Media.Colors.Black)));
renderTarget.AntiAliasMode = AntiAliasMode.Aliased;
D2DBitmap spBitmap = opacityRenderTarget.Bitmap;
renderTarget.FillOpacityMask(
spBitmap,
textBrush,
OpacityMaskContent.TextNatural,
new RectF(0, 0, rtSize.Width, rtSize.Height),
new RectF(0, 0, rtSize.Width, rtSize.Height)
);
renderTarget.EndDraw();
}
/// <summary>
/// Creates a Direct2D brush wrapper for a Avalonia brush.
/// </summary>
/// <param name="brush">The avalonia brush.</param>
/// <param name="destinationSize">The size of the brush's target area.</param>
/// <returns>The Direct2D brush wrapper.</returns>
public BrushImpl CreateBrush(IBrush brush, Size destinationSize)
{
var solidColorBrush = brush as ISolidColorBrush;
var linearGradientBrush = brush as ILinearGradientBrush;
var radialGradientBrush = brush as IRadialGradientBrush;
var imageBrush = brush as IImageBrush;
var visualBrush = brush as IVisualBrush;
if (solidColorBrush != null)
{
return(new SolidColorBrushImpl(solidColorBrush, _deviceContext));
}
else if (linearGradientBrush != null)
{
return(new LinearGradientBrushImpl(linearGradientBrush, _deviceContext, destinationSize));
}
else if (radialGradientBrush != null)
{
return(new RadialGradientBrushImpl(radialGradientBrush, _deviceContext, destinationSize));
}
else if (imageBrush?.Source != null)
{
return(new ImageBrushImpl(
imageBrush,
_deviceContext,
(BitmapImpl)imageBrush.Source.PlatformImpl.Item,
destinationSize));
}
else if (visualBrush != null)
{
if (_visualBrushRenderer != null)
{
var intermediateSize = _visualBrushRenderer.GetRenderTargetSize(visualBrush);
if (intermediateSize.Width >= 1 && intermediateSize.Height >= 1)
{
// We need to ensure the size we're requesting is an integer pixel size, otherwise
// D2D alters the DPI of the render target, which messes stuff up. PixelSize.FromSize
// will do the rounding for us.
var dpi = new Vector(_deviceContext.DotsPerInch.Width, _deviceContext.DotsPerInch.Height);
var pixelSize = PixelSize.FromSizeWithDpi(intermediateSize, dpi);
using (var intermediate = new BitmapRenderTarget(
_deviceContext,
CompatibleRenderTargetOptions.None,
pixelSize.ToSizeWithDpi(dpi).ToSharpDX()))
{
using (var ctx = new RenderTarget(intermediate).CreateDrawingContext(_visualBrushRenderer))
{
intermediate.Clear(null);
_visualBrushRenderer.RenderVisualBrush(ctx, visualBrush);
}
return(new ImageBrushImpl(
visualBrush,
_deviceContext,
new D2DBitmapImpl(intermediate.Bitmap),
destinationSize));
}
}
}
else
{
throw new NotSupportedException("No IVisualBrushRenderer was supplied to DrawingContextImpl.");
}
}
return(new SolidColorBrushImpl(null, _deviceContext));
}
/// <summary>
/// Creates a Direct2D brush wrapper for a Avalonia brush.
/// </summary>
/// <param name="brush">The avalonia brush.</param>
/// <param name="destinationSize">The size of the brush's target area.</param>
/// <returns>The Direct2D brush wrapper.</returns>
public BrushImpl CreateBrush(IBrush brush, Size destinationSize)
{
var solidColorBrush = brush as ISolidColorBrush;
var linearGradientBrush = brush as ILinearGradientBrush;
var radialGradientBrush = brush as IRadialGradientBrush;
var imageBrush = brush as IImageBrush;
var visualBrush = brush as IVisualBrush;
if (solidColorBrush != null)
{
return(new SolidColorBrushImpl(solidColorBrush, _renderTarget));
}
else if (linearGradientBrush != null)
{
return(new LinearGradientBrushImpl(linearGradientBrush, _renderTarget, destinationSize));
}
else if (radialGradientBrush != null)
{
return(new RadialGradientBrushImpl(radialGradientBrush, _renderTarget, destinationSize));
}
else if (imageBrush != null)
{
return(new ImageBrushImpl(
imageBrush,
_renderTarget,
(BitmapImpl)imageBrush.Source.PlatformImpl,
destinationSize));
}
else if (visualBrush != null)
{
if (_visualBrushRenderer != null)
{
var intermediateSize = _visualBrushRenderer.GetRenderTargetSize(visualBrush);
if (intermediateSize.Width >= 1 && intermediateSize.Height >= 1)
{
using (var intermediate = new BitmapRenderTarget(
_renderTarget,
CompatibleRenderTargetOptions.None,
intermediateSize.ToSharpDX()))
{
using (var ctx = new RenderTarget(intermediate).CreateDrawingContext(_visualBrushRenderer))
{
intermediate.Clear(null);
_visualBrushRenderer.RenderVisualBrush(ctx, visualBrush);
}
return(new ImageBrushImpl(
visualBrush,
_renderTarget,
new D2DBitmapImpl(_imagingFactory, intermediate.Bitmap),
destinationSize));
}
}
}
else
{
throw new NotSupportedException("No IVisualBrushRenderer was supplied to DrawingContextImpl.");
}
}
return(new SolidColorBrushImpl(null, _renderTarget));
}
public BitmapBrush makeBitmapBrush(string imgName, RenderTarget renderTarget, bool blankImage = false)
{
//TODO : 여기 바꿔라!
string imageSrc = "";
if (blankImage)
{
SharpDX.Direct2D1.PixelFormat pf = new SharpDX.Direct2D1.PixelFormat()
{
AlphaMode = D3DHandler.ALPHA_MODE,
Format = D3DHandler.RENDER_FORMAT
};
BitmapRenderTarget pallete = new BitmapRenderTarget(renderTarget, CompatibleRenderTargetOptions.GdiCompatible, pf);
return(new BitmapBrush(renderTarget, pallete.Bitmap, new BitmapBrushProperties()
{
ExtendModeX = ExtendMode.Wrap, ExtendModeY = ExtendMode.Wrap
}));
}
if (resourceCore.getFile(imgName, out ResFile resFile))
{
ImagingFactory imagingFactory = new ImagingFactory();
/*NativeFileStream fileStream = new NativeFileStream(imageSrc,
* NativeFileMode.Open, NativeFileAccess.Read);*/
MemoryStream ms = new MemoryStream(resFile.rawData);
BitmapDecoder bitmapDecoder = new BitmapDecoder(imagingFactory, ms, DecodeOptions.CacheOnDemand);
BitmapFrameDecode frame = bitmapDecoder.GetFrame(0);
FormatConverter converter = new FormatConverter(imagingFactory);
converter.Initialize(frame, SharpDX.WIC.PixelFormat.Format32bppPRGBA);
Bitmap bitmap = Bitmap.FromWicBitmap(renderTarget, converter);
Utilities.Dispose(ref bitmapDecoder);
Utilities.Dispose(ref imagingFactory);
Utilities.Dispose(ref converter);
return(new BitmapBrush(renderTarget, bitmap, new BitmapBrushProperties()
{
ExtendModeX = ExtendMode.Wrap, ExtendModeY = ExtendMode.Wrap
}));
}
else
{
Console.WriteLine("{0} missing", imageSrc);
SharpDX.Direct2D1.PixelFormat pf = new SharpDX.Direct2D1.PixelFormat()
{
AlphaMode = D3DHandler.ALPHA_MODE,
Format = D3DHandler.RENDER_FORMAT
};
BitmapRenderTarget pallete = new BitmapRenderTarget(renderTarget, CompatibleRenderTargetOptions.GdiCompatible, new Size2F(30f, 30f), new Size2(1, 1), pf);
pallete.BeginDraw();
pallete.Clear(Color.Purple);
pallete.EndDraw();
return(new BitmapBrush(renderTarget, pallete.Bitmap, new BitmapBrushProperties()
{
ExtendModeX = ExtendMode.Wrap, ExtendModeY = ExtendMode.Wrap
}));
}
}
public static BitmapBrush makeBitmapBrush(RenderTarget renderTarget, string imgName, bool blankImage = false)
{
string imageSrc = Program.spriteFileDir + imgName;
if (blankImage)
{
var pf = new SharpDX.Direct2D1.PixelFormat()
{
AlphaMode = SharpDX.Direct2D1.AlphaMode.Premultiplied,
Format = Format.B8G8R8A8_UNorm
};
BitmapRenderTarget pallete = new BitmapRenderTarget(renderTarget, CompatibleRenderTargetOptions.GdiCompatible, pf);
return(new BitmapBrush(renderTarget, pallete.Bitmap, new BitmapBrushProperties()
{
ExtendModeX = ExtendMode.Wrap, ExtendModeY = ExtendMode.Wrap
}));
}
if (File.Exists(imageSrc))
{
ImagingFactory imagingFactory = new ImagingFactory();
NativeFileStream fileStream = new NativeFileStream(imageSrc,
NativeFileMode.Open, NativeFileAccess.Read);
BitmapDecoder bitmapDecoder = new BitmapDecoder(imagingFactory, fileStream, DecodeOptions.CacheOnDemand);
BitmapFrameDecode frame = bitmapDecoder.GetFrame(0);
FormatConverter converter = new FormatConverter(imagingFactory);
converter.Initialize(frame, SharpDX.WIC.PixelFormat.Format32bppPRGBA);
Bitmap bitmap = Bitmap.FromWicBitmap(renderTarget, converter);
Utilities.Dispose(ref bitmapDecoder);
Utilities.Dispose(ref fileStream);
Utilities.Dispose(ref imagingFactory);
Utilities.Dispose(ref converter);
return(new BitmapBrush(renderTarget, bitmap, new BitmapBrushProperties()
{
ExtendModeX = ExtendMode.Wrap, ExtendModeY = ExtendMode.Wrap
}));
}
else
{
Console.WriteLine("{0} missing", imageSrc);
var pf = new SharpDX.Direct2D1.PixelFormat()
{
AlphaMode = SharpDX.Direct2D1.AlphaMode.Premultiplied,
Format = Format.B8G8R8A8_UNorm
};
BitmapRenderTarget pallete = new BitmapRenderTarget(renderTarget, CompatibleRenderTargetOptions.GdiCompatible, new Size2F(30f, 30f), new Size2(1, 1), pf);
pallete.BeginDraw();
pallete.Clear(Color.Purple);
pallete.EndDraw();
return(new BitmapBrush(renderTarget, pallete.Bitmap, new BitmapBrushProperties()
{
ExtendModeX = ExtendMode.Wrap, ExtendModeY = ExtendMode.Wrap
}));
}
}
public static Brush GetPatternBrush(RenderTarget renderTarget, System.Drawing.Color fillColor, float opacity, xPFT.Charting.Base.FillPattern fillPattern, float patternSize = 10)
{
if (renderTarget != null)
{
BitmapRenderTarget brt = new BitmapRenderTarget(renderTarget, CompatibleRenderTargetOptions.None, new SharpDX.Size2F(patternSize, patternSize));
Brush tempBrush = new SolidColorBrush(brt, xPFT.DrawingBase.Convertor.ColorConvertor(fillColor, opacity));
if (fillPattern == xPFT.Charting.Base.FillPattern.Solid)
{
return(tempBrush);
}
brt.BeginDraw();
brt.Clear(Color.Transparent);
switch (fillPattern)
{
case xPFT.Charting.Base.FillPattern.Hachure_Double:
brt.DrawLine(new SharpDX.Vector2(0, 0), new SharpDX.Vector2(patternSize, patternSize), tempBrush, 1);
brt.DrawLine(new SharpDX.Vector2(patternSize, 0), new SharpDX.Vector2(0, patternSize), tempBrush, 1);
break;
case xPFT.Charting.Base.FillPattern.Hachure:
brt.DrawLine(new SharpDX.Vector2(patternSize, 0), new SharpDX.Vector2(0, patternSize), tempBrush, 0.5f);
break;
case xPFT.Charting.Base.FillPattern.Hashure_Back:
brt.DrawLine(new SharpDX.Vector2(0, 0), new SharpDX.Vector2(patternSize, patternSize), tempBrush, 0.5f);
break;
case xPFT.Charting.Base.FillPattern.Dash:
brt.DrawLine(new SharpDX.Vector2(0, patternSize / 4), new SharpDX.Vector2(patternSize / 4, patternSize / 4), tempBrush, 0.5f);
brt.DrawLine(new SharpDX.Vector2(patternSize * 3 / 4, patternSize / 4), new SharpDX.Vector2(patternSize, patternSize / 4), tempBrush, 0.5f);
brt.DrawLine(new SharpDX.Vector2(patternSize / 4, patternSize * 3 / 4), new SharpDX.Vector2(patternSize * 3 / 4, patternSize * 3 / 4), tempBrush, 0.5f);
break;
case xPFT.Charting.Base.FillPattern.Squre:
brt.DrawLine(new SharpDX.Vector2(0, patternSize / 2), new SharpDX.Vector2(patternSize, patternSize / 2), tempBrush, 0.5f);
brt.DrawLine(new SharpDX.Vector2(patternSize / 2, 0), new SharpDX.Vector2(patternSize / 2, patternSize), tempBrush, 0.5f);
break;
case xPFT.Charting.Base.FillPattern.Dot:
brt.FillEllipse(new SharpDX.Direct2D1.Ellipse(new SharpDX.Vector2(patternSize / 4, patternSize / 4), 1, 1), tempBrush);
brt.FillEllipse(new SharpDX.Direct2D1.Ellipse(new SharpDX.Vector2(patternSize / 4, patternSize * 3 / 4), 1, 1), tempBrush);
brt.FillEllipse(new SharpDX.Direct2D1.Ellipse(new SharpDX.Vector2(patternSize * 3 / 4, patternSize / 4), 1, 1), tempBrush);
brt.FillEllipse(new SharpDX.Direct2D1.Ellipse(new SharpDX.Vector2(patternSize * 3 / 4, patternSize * 3 / 4), 1, 1), tempBrush);
break;
case xPFT.Charting.Base.FillPattern.Zig_Zag_Horizontal:
brt.DrawLine(new SharpDX.Vector2(0, patternSize / 2), new SharpDX.Vector2(patternSize / 2, 0), tempBrush, 0.5f);
brt.DrawLine(new SharpDX.Vector2(patternSize, patternSize / 2), new SharpDX.Vector2(patternSize / 2, 0), tempBrush, 0.5f);
brt.DrawLine(new SharpDX.Vector2(0, patternSize), new SharpDX.Vector2(patternSize / 2, patternSize / 2), tempBrush, 0.5f);
brt.DrawLine(new SharpDX.Vector2(patternSize, patternSize), new SharpDX.Vector2(patternSize / 2, patternSize / 2), tempBrush, 0.5f);
break;
case xPFT.Charting.Base.FillPattern.Zig_Zag_Vertical:
brt.DrawLine(new SharpDX.Vector2(patternSize / 2, 0), new SharpDX.Vector2(0, patternSize / 2), tempBrush, 0.5f);
brt.DrawLine(new SharpDX.Vector2(patternSize / 2, patternSize), new SharpDX.Vector2(0, patternSize / 2), tempBrush, 0.5f);
brt.DrawLine(new SharpDX.Vector2(patternSize, 0), new SharpDX.Vector2(patternSize / 2, patternSize / 2), tempBrush, 0.5f);
brt.DrawLine(new SharpDX.Vector2(patternSize, patternSize), new SharpDX.Vector2(patternSize / 2, patternSize / 2), tempBrush, 0.5f);
break;
}
brt.EndDraw();
BitmapBrushProperties bmpbp = new BitmapBrushProperties();
bmpbp.ExtendModeX = ExtendMode.Wrap;
bmpbp.ExtendModeY = ExtendMode.Wrap;
bmpbp.InterpolationMode = BitmapInterpolationMode.Linear;
BitmapBrush br = new BitmapBrush(brt, brt.Bitmap, bmpbp);
tempBrush.Dispose();
brt.Dispose();
return(br);
}
else
{
return(null);
}
}
