/// <summary>
/// Gets a Direct2D bitmap to use on the specified render target.
/// </summary>
/// <param name="renderTarget">The render target.</param>
/// <returns>The Direct2D bitmap.</returns>
public override SharpDX.Direct2D1.Bitmap GetDirect2DBitmap(SharpDX.Direct2D1.RenderTarget renderTarget)
{
FormatConverter converter = new FormatConverter(_factory);
converter.Initialize(WicImpl, SharpDX.WIC.PixelFormat.Format32bppPBGRA);
return(SharpDX.Direct2D1.Bitmap.FromWicBitmap(renderTarget, converter));
}
/// <summary>
/// 指定したレンダーターゲットに対して描画処理を実行する。
/// </summary>
/// <remarks>
/// 描画処理は、レンダーターゲットの BeginDraw() と EndDraw() の間で行われることが保証される。
/// 描画処理中に例外が発生しても EndDraw() の呼び出しが確実に保証される。
/// </remarks>
/// <param name="rt">レンダリングターゲット。</param>
/// <param name="描画処理">BeginDraw() と EndDraw() の間で行う処理。</param>
public void D2DBatchDraw(SharpDX.Direct2D1.RenderTarget rt, Action 描画処理)
{
// リストになかったらこの rt を使うのは初回なので、BeginDraw/EndDraw() の呼び出しを行う。
// もしリストに登録されていたら、この rt は他の誰かが BeginDraw して EndDraw してない状態
// （D2DBatcDraw() の最中に D2DBatchDraw() が呼び出されている状態）なので、これらを呼び出してはならない。
bool BeginとEndを行う = !(this._Draw中のレンダーターゲットリスト.Contains(rt));
try
{
if (BeginとEndを行う)
{
this._Draw中のレンダーターゲットリスト.Add(rt); // Begin したらリストに追加。
rt.BeginDraw();
}
var trans = rt.Transform;
try
{
描画処理();
}
finally
{
// 描画が終わるたびに元に戻す。
rt.Transform = trans;
}
}
finally
{
if (BeginとEndを行う)
{
rt.EndDraw();
this._Draw中のレンダーターゲットリスト.Remove(rt); // End したらリストから削除。
}
}
}
/// <summary>
/// Creates device-based resources to store a constant buffer, cube
/// geometry, and vertex and pixel shaders. In some cases this will also
/// store a geometry shader.
/// </summary>
public void CreateDeviceDependentResources()
{
ReleaseDeviceDependentResources();
// Create a default sampler state, which will use point sampling.
pointSampler = ToDispose(new SamplerState(deviceResources.D3DDevice, new SamplerStateDescription()
{
AddressU = TextureAddressMode.Clamp,
AddressV = TextureAddressMode.Clamp,
AddressW = TextureAddressMode.Clamp,
BorderColor = new RawColor4(0, 0, 0, 0),
ComparisonFunction = Comparison.Never,
Filter = Filter.MinMagMipLinear,
MaximumAnisotropy = 16,
MaximumLod = float.MaxValue,
MinimumLod = 0,
MipLodBias = 0.0f
}));
// Create the texture that will be used as the offscreen render target.
var textureDesc = new Texture2DDescription
{
Format = SharpDX.DXGI.Format.B8G8R8A8_UNorm,
Width = textureWidth,
Height = textureHeight,
MipLevels = 1,
ArraySize = 1,
BindFlags = BindFlags.ShaderResource | BindFlags.RenderTarget,
SampleDescription = new SharpDX.DXGI.SampleDescription(1, 0),
OptionFlags = ResourceOptionFlags.None,
Usage = ResourceUsage.Default,
CpuAccessFlags = CpuAccessFlags.None
};
texture2D = new Texture2D(deviceResources.D3DDevice, textureDesc);
// Create read and write views for the offscreen render target.
shaderResourceView = new ShaderResourceView(deviceResources.D3DDevice, texture2D);
renderTargetView = new RenderTargetView(deviceResources.D3DDevice, texture2D);
// In this example, we are using D2D and DirectWrite; so, we need to create a D2D render target as well.
SharpDX.Direct2D1.RenderTargetProperties props = new SharpDX.Direct2D1.RenderTargetProperties(
SharpDX.Direct2D1.RenderTargetType.Default,
new SharpDX.Direct2D1.PixelFormat(SharpDX.DXGI.Format.Unknown, SharpDX.Direct2D1.AlphaMode.Premultiplied),
96, 96,
SharpDX.Direct2D1.RenderTargetUsage.None,
SharpDX.Direct2D1.FeatureLevel.Level_DEFAULT);
// The DXGI surface is used to create the render target.
SharpDX.DXGI.Surface dxgiSurface = texture2D.QueryInterface <SharpDX.DXGI.Surface>();
d2dRenderTarget = new SharpDX.Direct2D1.RenderTarget(deviceResources.D2DFactory, dxgiSurface, props);
// Create a solid color brush that will be used to render the text.
whiteBrush = new SharpDX.Direct2D1.SolidColorBrush(d2dRenderTarget, new RawColor4(1f, 1f, 1f, 1f));
// This is where we format the text that will be written on the render target.
textFormat = new SharpDX.DirectWrite.TextFormat(deviceResources.DWriteFactory, "Consolas", SharpDX.DirectWrite.FontWeight.Normal, SharpDX.DirectWrite.FontStyle.Normal, 64f);
textFormat.TextAlignment = SharpDX.DirectWrite.TextAlignment.Center;
textFormat.ParagraphAlignment = SharpDX.DirectWrite.ParagraphAlignment.Center;
}
internal static async Task Render(CompositionEngine compositionEngine, SharpDX.Direct2D1.RenderTarget renderTarget, FrameworkElement rootElement, Line line)
{
var rect = line.GetBoundingRect(rootElement).ToSharpDX();
//var fill = line.Fill.ToSharpDX(renderTarget, rect);
var stroke = await line.Stroke.ToSharpDX(renderTarget, rect);
if (stroke == null ||
line.StrokeThickness <= 0)
{
return;
}
//var layer = new Layer(renderTarget);
//var layerParameters = new LayerParameters();
//layerParameters.ContentBounds = rect;
//renderTarget.PushLayer(ref layerParameters, layer);
renderTarget.DrawLine(
new DrawingPointF(
rect.Left + (float)line.X1,
rect.Top + (float)line.Y1),
new DrawingPointF(
rect.Left + (float)line.X2,
rect.Top + (float)line.Y2),
stroke,
(float)line.StrokeThickness,
line.GetStrokeStyle(compositionEngine.D2DFactory));
//renderTarget.PopLayer();
}
private void CloseDx()
{
logger.Debug("GDICapture::CloseDx()");
if (renderTarget != null)
{
renderTarget.Dispose();
renderTarget = null;
}
if (renderTexture != null)
{
renderTexture.Dispose();
renderTexture = null;
}
if (SharedTexture != null)
{
SharedTexture.Dispose();
SharedTexture = null;
}
if (gdiTexture != null)
{
gdiTexture.Dispose();
gdiTexture = null;
}
if (device != null)
{
device.Dispose();
device = null;
}
}
/// <summary>
/// Gets a Direct2D bitmap to use on the specified render target.
/// </summary>
/// <param name="renderTarget">The render target.</param>
/// <returns>The Direct2D bitmap.</returns>
public override OptionalDispose <D2DBitmap> GetDirect2DBitmap(SharpDX.Direct2D1.RenderTarget renderTarget)
{
FormatConverter converter = new FormatConverter(Direct2D1Platform.ImagingFactory);
converter.Initialize(WicImpl, SharpDX.WIC.PixelFormat.Format32bppPBGRA);
return(new OptionalDispose <D2DBitmap>(D2DBitmap.FromWicBitmap(renderTarget, converter), true));
}
/// <summary>
/// 指定したレンダーターゲットに対して描画処理をバッチ実行する。
/// </summary>
/// <remarks>
/// 描画処理は、レンダーターゲットの BeginDraw() と EndDraw() の間で行われることが保証される。
/// 描画処理中に例外が発生しても EndDraw() の呼び出しが確実に保証される。
/// </remarks>
/// <param name="rt">レンダリングターゲット。</param>
/// <param name="描画処理">BeginDraw() と EndDraw() の間で行う処理。</param>
public void D2DBatchDraw(SharpDX.Direct2D1.RenderTarget rt, Action 描画処理)
{
// リストになかったらこの rt を使うのは初回なので、BeginDraw/EndDraw() の呼び出しを行う。
// もしリストに登録されていたら、この rt は他の誰かが BeginDraw して EndDraw してない状態
// （D2DBatcDraw() の最中に D2DBatchDraw() が呼び出されている状態）なので、これらを呼び出してはならない。
bool BeginとEndを行う = !(this._BatchDraw中のレンダーターゲットリスト.Contains(rt));
var pretrans = rt.Transform;
var preblend = (rt is SharpDX.Direct2D1.DeviceContext dc) ? dc.PrimitiveBlend : SharpDX.Direct2D1.PrimitiveBlend.SourceOver;
try
{
if (BeginとEndを行う)
{
this._BatchDraw中のレンダーターゲットリスト.Add(rt); // Begin したらリストに追加。
rt.BeginDraw();
}
描画処理();
}
finally
{
rt.Transform = pretrans;
if (rt is SharpDX.Direct2D1.DeviceContext dc2)
{
dc2.PrimitiveBlend = preblend;
}
if (BeginとEndを行う)
{
rt.EndDraw();
this._BatchDraw中のレンダーターゲットリスト.Remove(rt); // End したらリストから削除。
}
}
}
public RadialGradientBrushImpl(
Perspex.Media.RadialGradientBrush brush,
SharpDX.Direct2D1.RenderTarget target,
Size destinationSize)
{
var gradientStops = brush.GradientStops.Select(s => new SharpDX.Direct2D1.GradientStop {
Color = s.Color.ToDirect2D(), Position = (float)s.Offset
}).ToArray();
Point centerPoint = brush.Center.ToPixels(destinationSize);
Point GradientOriginOffset = brush.GradientOrigin.ToPixels(destinationSize);
// Note: Direct2D supports RadiusX and RadiusY but Cairo backend supports only Radius property
double radiusX = brush.Radius;
double radiusY = brush.Radius;
PlatformBrush = new SharpDX.Direct2D1.RadialGradientBrush(
target,
new SharpDX.Direct2D1.RadialGradientBrushProperties {
Center = centerPoint.ToSharpDX(), GradientOriginOffset = GradientOriginOffset.ToSharpDX(), RadiusX = (float)radiusX, RadiusY = (float)radiusY
},
new SharpDX.Direct2D1.BrushProperties {
Opacity = (float)brush.Opacity, Transform = target.Transform
},
new SharpDX.Direct2D1.GradientStopCollection(target, gradientStops, brush.SpreadMethod.ToDirect2D())
);
}
internal static async Task Render(CompositionEngine compositionEngine, SharpDX.Direct2D1.RenderTarget renderTarget, FrameworkElement rootElement, Line line)
{
var rect = line.GetBoundingRect(rootElement).ToSharpDX();
var stroke = await line.Stroke.ToSharpDX(renderTarget, rect);
if (stroke == null ||
line.StrokeThickness <= 0)
{
return;
}
var layer = line.CreateAndPushLayerIfNecessary(renderTarget, rootElement);
renderTarget.DrawLine(
new Vector2(
rect.Left + (float)line.X1,
rect.Top + (float)line.Y1),
new Vector2(
rect.Left + (float)line.X2,
rect.Top + (float)line.Y2),
stroke,
(float)line.StrokeThickness,
line.GetStrokeStyle(compositionEngine.D2DFactory));
if (layer != null)
{
renderTarget.PopLayer();
layer.Dispose();
}
}
public void LoadGraphics(SharpDX.Direct2D1.RenderTarget target)
{
up = new List <SharpDX.Direct2D1.Bitmap>();
down = new List <SharpDX.Direct2D1.Bitmap>();
left = new List <SharpDX.Direct2D1.Bitmap>();
right = new List <SharpDX.Direct2D1.Bitmap>();
death = new List <SharpDX.Direct2D1.Bitmap>();
Bitmap original = Properties.Resources.blue;
Bitmap sprite;
Rectangle srcRect;
// Init down
int i = 0;
for (; i < 3; ++i)
{
srcRect = new Rectangle(i * 48, 0, 48, 48);
sprite = original.Clone(srcRect, original.PixelFormat);
down.Add(sprite.CreateDirectX2D1Bitmap(target));
sprite.Dispose();
}
// Init right
for (; i < 6; ++i)
{
srcRect = new Rectangle(i * 48, 0, 48, 48);
sprite = original.Clone(srcRect, original.PixelFormat);
right.Add(sprite.CreateDirectX2D1Bitmap(target));
sprite.Dispose();
}
// Init left
for (; i < 9; ++i)
{
srcRect = new Rectangle(i * 48, 0, 48, 48);
sprite = original.Clone(srcRect, original.PixelFormat);
left.Add(sprite.CreateDirectX2D1Bitmap(target));
sprite.Dispose();
}
// Init up
for (; i < 12; ++i)
{
srcRect = new Rectangle(i * 48, 0, 48, 48);
sprite = original.Clone(srcRect, original.PixelFormat);
up.Add(sprite.CreateDirectX2D1Bitmap(target));
sprite.Dispose();
}
// Init death
for (; i < 20; ++i)
{
srcRect = new Rectangle(i * 48, 0, 48, 48);
sprite = original.Clone(srcRect, original.PixelFormat);
death.Add(sprite.CreateDirectX2D1Bitmap(target));
sprite.Dispose();
}
}
public void Draw(SharpDX.Direct2D1.RenderTarget target)
{
target.PushAxisAlignedClip(new SharpDX.Mathematics.Interop.RawRectangleF(this.bounds.Left, this.bounds.Top, this.bounds.Right, this.bounds.Bottom), SharpDX.Direct2D1.AntialiasMode.PerPrimitive);
Ground.Draw(target, this.bounds);
//this.containedObject?.Draw(target);
target.PopAxisAlignedClip();
IsChanged = false;
}
public override void Draw(SharpDX.Direct2D1.RenderTarget target)
{
if (this.spriteAnimation.CurrentFrame == null)
{
return;
}
var b = Tile.Bounds;
target.DrawBitmap(this.spriteAnimation.CurrentFrame, new SharpDX.Mathematics.Interop.RawRectangleF(b.Left, b.Top, b.Right, b.Bottom), 1, SharpDX.Direct2D1.BitmapInterpolationMode.Linear);
}
public D2DGraphics(D2DView.RenderTargetEventArgs e)
{
_renderTarget = e.RenderTarget;
_graphics = e.Graphics;
_renderTarget.Transform = SharpDX.Matrix3x2.Identity;
if (!_renderTargetCache.ContainsKey(_renderTarget))
_renderTargetCache[_renderTarget] = new RenderTargetCache();
}
/// <summary>
/// Gets a Direct2D bitmap to use on the specified render target.
/// </summary>
/// <param name="renderTarget">The render target.</param>
/// <returns>The Direct2D bitmap.</returns>
public SharpDX.Direct2D1.Bitmap GetDirect2DBitmap(SharpDX.Direct2D1.RenderTarget renderTarget)
{
if (_direct2D == null)
{
FormatConverter converter = new FormatConverter(_factory);
converter.Initialize(WicImpl, PixelFormat.Format32bppPBGRA);
_direct2D = SharpDX.Direct2D1.Bitmap.FromWicBitmap(renderTarget, converter);
}
return(_direct2D);
}
public SolidColorBrushImpl(ISolidColorBrush brush, SharpDX.Direct2D1.RenderTarget target)
{
PlatformBrush = new SharpDX.Direct2D1.SolidColorBrush(
target,
brush?.Color.ToDirect2D() ?? new SharpDX.Mathematics.Interop.RawColor4(),
new SharpDX.Direct2D1.BrushProperties
{
Opacity = brush != null ? (float)brush.Opacity : 1.0f,
Transform = target.Transform
}
);
}
private void DrawTexture(SharpDX.Direct2D1.RenderTarget renderTarget, Texture2D texture)
{
using (var surf = texture.QueryInterface <SharpDX.DXGI.Surface1>())
{
var prop = new SharpDX.Direct2D1.BitmapProperties(new SharpDX.Direct2D1.PixelFormat(SharpDX.DXGI.Format.B8G8R8A8_UNorm, SharpDX.Direct2D1.AlphaMode.Premultiplied));
SharpDX.Direct2D1.Bitmap screenBits = new SharpDX.Direct2D1.Bitmap(renderTarget, surf, prop);
try
{
var srcDecr = surf.Description;
float srcWidth = srcDecr.Width;
float srcHeight = srcDecr.Height;
float destX = 0;
float destY = 0;
float destWidth = DestSize.Width;
float destHeight = DestSize.Height;
float scaleX = destWidth / srcWidth;
float scaleY = destHeight / srcHeight;
if (AspectRatio)
{
if (scaleY < scaleX)
{
scaleX = scaleY;
destX = ((destWidth - srcWidth * scaleX) / 2);
}
else
{
scaleY = scaleX;
destY = ((destHeight - srcHeight * scaleY) / 2);
}
}
destWidth = srcWidth * scaleX;
destHeight = srcHeight * scaleY;
var destRect = new SharpDX.Mathematics.Interop.RawRectangleF
{
Left = destX,
Right = destX + destWidth,
Top = destY,
Bottom = destY + destHeight,
};
renderTarget.DrawBitmap(screenBits, destRect, 1.0f, SharpDX.Direct2D1.BitmapInterpolationMode.Linear);
}
finally
{
screenBits?.Dispose();
}
}
}
public void LoadGraphics(SharpDX.Direct2D1.RenderTarget target)
{
sprites = new Dictionary <FireType, IReadOnlyList <SharpDX.Direct2D1.Bitmap> > {
{ FireType.Left, BuildSpriteSequence(Properties.Resources.ExplosionLeft, target) },
{ FireType.Right, BuildSpriteSequence(Properties.Resources.ExplosionRight, target) },
{ FireType.Up, BuildSpriteSequence(Properties.Resources.ExplosionUp, target) },
{ FireType.Down, BuildSpriteSequence(Properties.Resources.ExplosionDown, target) },
{ FireType.Horizontal, BuildSpriteSequence(Properties.Resources.ExplosionHorizontal, target) },
{ FireType.Vertical, BuildSpriteSequence(Properties.Resources.ExplosionVertical, target) },
{ FireType.Center, BuildSpriteSequence(Properties.Resources.ExplosionCentre, target) },
};
}
private void CreateFromBitmap(SharpDX.Direct2D1.RenderTarget InRenderTarget, Bitmap InBitmap)
{
MemStream = new System.IO.MemoryStream();
InBitmap.Save(MemStream, System.Drawing.Imaging.ImageFormat.Png);
BitDecorder = new SharpDX.WIC.BitmapDecoder(Direct2DDrawingSystem.instance.ImagingFactory,
MemStream,
SharpDX.WIC.DecodeOptions.CacheOnDemand);
BFDecorde = BitDecorder.GetFrame(0);
fConverter = new SharpDX.WIC.FormatConverter(Direct2DDrawingSystem.instance.ImagingFactory);
fConverter.Initialize(BFDecorde, SharpDX.WIC.PixelFormat.Format32bppPBGRA, SharpDX.WIC.BitmapDitherType.None, null, 0, SharpDX.WIC.BitmapPaletteType.Custom);
Texture2D = SharpDX.Direct2D1.Bitmap.FromWicBitmap(InRenderTarget, fConverter);
}
public static Brush2D ToSharpDX(this Brush brush, RenderTarget2D target)
{
SolidColorBrush solidColorBrush = brush as SolidColorBrush;
if (solidColorBrush != null)
{
return(solidColorBrush.ToSharpDX(target));
}
else
{
throw new NotSupportedException();
}
}
private void InitializeDirectXResources()
{
var clientSize = ClientSize;
var backBufferDesc = new SharpDX.DXGI.ModeDescription(clientSize.Width, clientSize.Height,
new SharpDX.DXGI.Rational(60, 1), SharpDX.DXGI.Format.R8G8B8A8_UNorm);
var swapChainDesc = new SharpDX.DXGI.SwapChainDescription()
{
ModeDescription = backBufferDesc,
SampleDescription = new SharpDX.DXGI.SampleDescription(1, 0),
Usage = SharpDX.DXGI.Usage.RenderTargetOutput,
BufferCount = 1,
OutputHandle = Handle,
SwapEffect = SharpDX.DXGI.SwapEffect.Discard,
IsWindowed = false
};
SharpDX.Direct3D11.Device.CreateWithSwapChain(SharpDX.Direct3D.DriverType.Hardware, SharpDX.Direct3D11.DeviceCreationFlags.BgraSupport,
new[] { SharpDX.Direct3D.FeatureLevel.Level_10_0 }, swapChainDesc,
out _d3DDevice, out var swapChain);
_d3DDeviceContext = _d3DDevice.ImmediateContext;
_swapChain = new SharpDX.DXGI.SwapChain1(swapChain.NativePointer);
_d2DFactory = new SharpDX.Direct2D1.Factory();
using (var backBuffer = _swapChain.GetBackBuffer <SharpDX.Direct3D11.Texture2D>(0))
{
_renderTargetView = new SharpDX.Direct3D11.RenderTargetView(_d3DDevice, backBuffer);
_renderTarget = new SharpDX.Direct2D1.RenderTarget(_d2DFactory, backBuffer.QueryInterface <SharpDX.DXGI.Surface>(),
new SharpDX.Direct2D1.RenderTargetProperties(new SharpDX.Direct2D1.PixelFormat(SharpDX.DXGI.Format.Unknown, SharpDX.Direct2D1.AlphaMode.Premultiplied)))
{
TextAntialiasMode = SharpDX.Direct2D1.TextAntialiasMode.Cleartype
};
}
_solidColorBrush = new SharpDX.Direct2D1.SolidColorBrush(_renderTarget, Color.White);
_dwFactory = new SharpDX.DirectWrite.Factory(SharpDX.DirectWrite.FactoryType.Shared);
_textFormat = new SharpDX.DirectWrite.TextFormat(_dwFactory, "Arial", SharpDX.DirectWrite.FontWeight.Bold,
SharpDX.DirectWrite.FontStyle.Normal, SharpDX.DirectWrite.FontStretch.Normal, 84 * (float)GraphicsUtils.Scale)
{
TextAlignment = SharpDX.DirectWrite.TextAlignment.Center,
ParagraphAlignment = SharpDX.DirectWrite.ParagraphAlignment.Center
};
// var rectangleGeometry = new D2D1.RoundedRectangleGeometry(_d2DFactory,
// new D2D1.RoundedRectangle() { RadiusX = 32, RadiusY = 32, Rect = new RectangleF(128, 128, Width - 128 * 2, Height - 128 * 2) });
}
public RadialGradientBrushImpl(
IRadialGradientBrush brush,
SharpDX.Direct2D1.RenderTarget target,
Rect destinationRect)
{
if (brush.GradientStops.Count == 0)
{
return;
}
var gradientStops = brush.GradientStops.Select(s => new SharpDX.Direct2D1.GradientStop
{
Color = s.Color.ToDirect2D(),
Position = (float)s.Offset
}).ToArray();
var position = destinationRect.Position;
var centerPoint = position + brush.Center.ToPixels(destinationRect.Size);
var gradientOrigin = position + brush.GradientOrigin.ToPixels(destinationRect.Size) - centerPoint;
// Note: Direct2D supports RadiusX and RadiusY but Cairo backend supports only Radius property
var radiusX = brush.Radius * destinationRect.Width;
var radiusY = brush.Radius * destinationRect.Height;
using (var stops = new SharpDX.Direct2D1.GradientStopCollection(
target,
gradientStops,
brush.SpreadMethod.ToDirect2D()))
{
PlatformBrush = new SharpDX.Direct2D1.RadialGradientBrush(
target,
new SharpDX.Direct2D1.RadialGradientBrushProperties
{
Center = centerPoint.ToSharpDX(),
GradientOriginOffset = gradientOrigin.ToSharpDX(),
RadiusX = (float)radiusX,
RadiusY = (float)radiusY
},
new SharpDX.Direct2D1.BrushProperties
{
Opacity = (float)brush.Opacity,
Transform = PrimitiveExtensions.Matrix3x2Identity,
},
stops);
}
}
public IDrawingContextImpl CreateDrawingContext(IVisualBrushRenderer visualBrushRenderer)
{
_target = _target ?? _externalRenderTargetProvider.CreateRenderTarget();
_externalRenderTargetProvider.BeforeDrawing();
return(new DrawingContextImpl(visualBrushRenderer, _target, _dwFactory, null, () =>
{
try
{
_externalRenderTargetProvider.AfterDrawing();
}
catch (SharpDXException ex) when((uint)ex.HResult == 0x8899000C) // D2DERR_RECREATE_TARGET
{
_target?.Dispose();
_target = null;
}
}));
}
/// <summary>
/// Updates device dependent resources for when RenderTarget changes.
/// </summary>
/// <param name="renderTarget">The hosting NinjaScript's RenderTarget</param>
public void RenderTargetChange(SharpDX.Direct2D1.RenderTarget renderTarget)
{
if (renderTarget == null || renderTarget.IsDisposed)
{
return;
}
if (dxBrush != null)
{
dxBrush.Dispose();
}
if (mediaBrush != null)
{
dxBrush = mediaBrush.ToDxBrush(renderTarget);
}
}
public RadialGradientBrushImpl(
Perspex.Media.RadialGradientBrush brush,
SharpDX.Direct2D1.RenderTarget target,
Size destinationSize)
{
if (brush.GradientStops.Count == 0)
{
return;
}
var gradientStops = brush.GradientStops.Select(s => new SharpDX.Direct2D1.GradientStop
{
Color = s.Color.ToDirect2D(),
Position = (float)s.Offset
}).ToArray();
var centerPoint = brush.Center.ToPixels(destinationSize);
var GradientOriginOffset = brush.GradientOrigin.ToPixels(destinationSize);
// Note: Direct2D supports RadiusX and RadiusY but Cairo backend supports only Radius property
var radiusX = brush.Radius;
var radiusY = brush.Radius;
using (var stops = new SharpDX.Direct2D1.GradientStopCollection(
target,
gradientStops,
brush.SpreadMethod.ToDirect2D()))
{
PlatformBrush = new SharpDX.Direct2D1.RadialGradientBrush(
target,
new SharpDX.Direct2D1.RadialGradientBrushProperties
{
Center = centerPoint.ToSharpDX(),
GradientOriginOffset = GradientOriginOffset.ToSharpDX(),
RadiusX = (float)radiusX,
RadiusY = (float)radiusY
},
new SharpDX.Direct2D1.BrushProperties
{
Opacity = (float)brush.Opacity,
Transform = SharpDX.Matrix3x2.Identity,
},
stops);
}
}
public static Bitmap LoadBitmap(RenderTarget device, byte[] bytes)
{
if (device == null)
{
throw new ArgumentNullException(nameof(device));
}
if (bytes == null)
{
throw new ArgumentNullException(nameof(bytes));
}
if (bytes.Length == 0)
{
throw new ArgumentOutOfRangeException(nameof(bytes));
}
using MemoryStream stream = new MemoryStream(bytes);
using BitmapDecoder decoder = new BitmapDecoder(imageFactory, stream, DecodeOptions.CacheOnDemand);
return(Decode(device, decoder));
}
private void CreateRenderTarget(SharpDX.DXGI.Surface surface)
{
// Create a D2D render target which can draw into our offscreen D3D surface.
// D2D uses device independant units, like WPF, at 96/inch.
var properties = new SharpDX.Direct2D1.RenderTargetProperties();
properties.DpiX = 96;
properties.DpiY = 96;
properties.MinLevel = SharpDX.Direct2D1.FeatureLevel.Level_DEFAULT;
properties.PixelFormat = new SharpDX.Direct2D1.PixelFormat(Format.Unknown, SharpDX.Direct2D1.AlphaMode.Premultiplied);
properties.Usage = SharpDX.Direct2D1.RenderTargetUsage.None;
if (this.renderTarget != null)
{
this.renderTarget.Dispose();
}
renderTarget = new SharpDX.Direct2D1.RenderTarget(factory2D, surface, properties);
}
/// <summary>
/// Updates the Media Bursh and SharpDX Brush also changing opacity.
/// </summary>
/// <param name="owner">The hosting NinjaScript's RenderTarget</param>
/// <param name="owner">The new Media Brush to use</param>
/// <param name="owner">The new Opacity to use</param>
public void UpdateBrush(SharpDX.Direct2D1.RenderTarget renderTarget, Brush newMediaBrush, double newOpacity)
{
// Set Media Brush to brush passed
mediaBrush = newMediaBrush;
// Call SetOpacity() to clone, set opacity and freeze brush.
SetOpacity(newOpacity);
// Dispose DX Brushes and other Device Dependant resources
if (dxBrush != null)
{
dxBrush.Dispose();
}
// Recreate DX Brushes and other Device Dependant Resources here, making sure RenderTarget is not null or IsDisposed
if (renderTarget != null && !renderTarget.IsDisposed)
{
dxBrush = mediaBrush.ToDxBrush(renderTarget);
}
}
public LinearGradientBrushImpl(
Perspex.Media.LinearGradientBrush brush,
SharpDX.Direct2D1.RenderTarget target,
Size destinationSize)
{
if (brush != null)
{
var gradientStops = brush.GradientStops.Select(s => new SharpDX.Direct2D1.GradientStop {
Color = s.Color.ToDirect2D(), Position = (float)s.Offset
}).ToArray();
Point startPoint = new Point(0, 0);
Point endPoint = new Point(0, 0);
switch (brush.MappingMode)
{
case Perspex.Media.BrushMappingMode.Absolute:
// TODO:
break;
case Perspex.Media.BrushMappingMode.RelativeToBoundingBox:
startPoint = new Point(brush.StartPoint.X * destinationSize.Width, brush.StartPoint.Y * destinationSize.Height);
endPoint = new Point(brush.EndPoint.X * destinationSize.Width, brush.EndPoint.Y * destinationSize.Height);
break;
}
PlatformBrush = new SharpDX.Direct2D1.LinearGradientBrush(
target,
new SharpDX.Direct2D1.LinearGradientBrushProperties {
StartPoint = startPoint.ToSharpDX(), EndPoint = endPoint.ToSharpDX()
},
new SharpDX.Direct2D1.BrushProperties {
Opacity = (float)brush.Opacity, Transform = target.Transform
},
new SharpDX.Direct2D1.GradientStopCollection(target, gradientStops, brush.SpreadMethod.ToDirect2D())
);
}
}
public LinearGradientBrushImpl(
ILinearGradientBrush brush,
SharpDX.Direct2D1.RenderTarget target,
Rect destinationRect)
{
if (brush.GradientStops.Count == 0)
{
return;
}
var gradientStops = brush.GradientStops.Select(s => new SharpDX.Direct2D1.GradientStop
{
Color = s.Color.ToDirect2D(),
Position = (float)s.Offset
}).ToArray();
var position = destinationRect.Position;
var startPoint = position + brush.StartPoint.ToPixels(destinationRect.Size);
var endPoint = position + brush.EndPoint.ToPixels(destinationRect.Size);
using (var stops = new SharpDX.Direct2D1.GradientStopCollection(
target,
gradientStops,
brush.SpreadMethod.ToDirect2D()))
{
PlatformBrush = new SharpDX.Direct2D1.LinearGradientBrush(
target,
new SharpDX.Direct2D1.LinearGradientBrushProperties
{
StartPoint = startPoint.ToSharpDX(),
EndPoint = endPoint.ToSharpDX()
},
new SharpDX.Direct2D1.BrushProperties
{
Opacity = (float)brush.Opacity,
Transform = PrimitiveExtensions.Matrix3x2Identity,
},
stops);
}
}
private SharpDX.Direct2D1.Bitmap CreateFromBitmap(SharpDX.Direct2D1.RenderTarget InRenderTarget, Bitmap InBitmap)
{
using (System.IO.MemoryStream ms = new System.IO.MemoryStream())
{
InBitmap.Save(ms, System.Drawing.Imaging.ImageFormat.Png);
using (SharpDX.WIC.BitmapDecoder bitDecorder =
new SharpDX.WIC.BitmapDecoder(Direct2DDrawingSystem.instance.ImagingFactory,
ms,
SharpDX.WIC.DecodeOptions.CacheOnDemand)
)
{
using (SharpDX.WIC.BitmapFrameDecode bfDecode = bitDecorder.GetFrame(0))
{
using (SharpDX.WIC.FormatConverter fConverter = new SharpDX.WIC.FormatConverter(Direct2DDrawingSystem.instance.ImagingFactory))
{
fConverter.Initialize(bfDecode, SharpDX.WIC.PixelFormat.Format32bppPBGRA, SharpDX.WIC.BitmapDitherType.None, null, 0, SharpDX.WIC.BitmapPaletteType.Custom);
return(SharpDX.Direct2D1.Bitmap.FromWicBitmap(InRenderTarget, fConverter));
}
}
}
}
}
private static Bitmap Decode(RenderTarget device, BitmapDecoder decoder)
{
using (BitmapFrameDecode frame = decoder.GetFrame(0))
{
FormatConverter converter = new FormatConverter(imageFactory); // Converter get clobbered on failure so we're not wrapping this in a using.
foreach (Guid format in PixelFormatEnumerator)
{
try
{
converter.Initialize(frame, format);
return(Bitmap.FromWicBitmap(device, converter));
}
catch // Ignore error here, just try another format. We'll throw an error below if we exhaust all options.
{
converter?.Dispose();
converter = new FormatConverter(imageFactory);
}
}
converter?.Dispose();
}
throw new Exception("Unsupported Image Format!");
}
private void LoadPipeline(RenderForm form)
{
int width = form.ClientSize.Width;
int height = form.ClientSize.Height;
viewport.Width = width;
viewport.Height = height;
viewport.MaxDepth = 1.0f;
scissorRect.Right = width;
scissorRect.Bottom = height;
#if DEBUG
// Enable the D3D12 debug layer.
{
DebugInterface.Get().EnableDebugLayer();
}
#endif
device = new Device(null, SharpDX.Direct3D.FeatureLevel.Level_12_0);
using (var factory = new Factory4())
{
// Describe and create the command queue.
CommandQueueDescription queueDesc = new CommandQueueDescription(CommandListType.Direct);
commandQueue = device.CreateCommandQueue(queueDesc);
// Describe and create the swap chain.
SwapChainDescription swapChainDesc = new SwapChainDescription()
{
BufferCount = FrameCount,
ModeDescription = new ModeDescription(width, height, new Rational(60, 1), Format.R8G8B8A8_UNorm),
Usage = Usage.RenderTargetOutput,
SwapEffect = SwapEffect.FlipDiscard,
OutputHandle = form.Handle,
//Flags = SwapChainFlags.None,
SampleDescription = new SampleDescription(1, 0),
IsWindowed = true
};
SwapChain tempSwapChain = new SwapChain(factory, commandQueue, swapChainDesc);
swapChain = tempSwapChain.QueryInterface<SwapChain3>();
tempSwapChain.Dispose();
frameIndex = swapChain.CurrentBackBufferIndex;
}
// Create descriptor heaps.
// Describe and create a render target view (RTV) descriptor heap.
DescriptorHeapDescription rtvHeapDesc = new DescriptorHeapDescription()
{
DescriptorCount = FrameCount,
Flags = DescriptorHeapFlags.None,
Type = DescriptorHeapType.RenderTargetView
};
renderTargetViewHeap = device.CreateDescriptorHeap(rtvHeapDesc);
rtvDescriptorSize = device.GetDescriptorHandleIncrementSize(DescriptorHeapType.RenderTargetView);
//Init Direct3D11 device from Direct3D12 device
device11 = SharpDX.Direct3D11.Device.CreateFromDirect3D12(device, SharpDX.Direct3D11.DeviceCreationFlags.BgraSupport, null, null, commandQueue);
deviceContext11 = device11.ImmediateContext;
device11on12 = device11.QueryInterface<SharpDX.Direct3D11.ID3D11On12Device>();
var d2dFactory = new SharpDX.Direct2D1.Factory(SharpDX.Direct2D1.FactoryType.MultiThreaded);
// Create frame resources.
CpuDescriptorHandle rtvHandle = renderTargetViewHeap.CPUDescriptorHandleForHeapStart;
for (int n = 0; n < FrameCount; n++)
{
renderTargets[n] = swapChain.GetBackBuffer<Resource>(n);
device.CreateRenderTargetView(renderTargets[n], null, rtvHandle);
rtvHandle += rtvDescriptorSize;
//init Direct2D surfaces
SharpDX.Direct3D11.D3D11ResourceFlags format = new SharpDX.Direct3D11.D3D11ResourceFlags()
{
BindFlags = (int)SharpDX.Direct3D11.BindFlags.RenderTarget,
CPUAccessFlags = (int)SharpDX.Direct3D11.CpuAccessFlags.None
};
device11on12.CreateWrappedResource(
renderTargets[n], format,
(int)ResourceStates.Present,
(int)ResourceStates.RenderTarget,
typeof(SharpDX.Direct3D11.Resource).GUID,
out wrappedBackBuffers[n]);
//Init direct2D surface
var d2dSurface = wrappedBackBuffers[n].QueryInterface<Surface>();
direct2DRenderTarget[n] = new SharpDX.Direct2D1.RenderTarget(d2dFactory, d2dSurface, new SharpDX.Direct2D1.RenderTargetProperties(new SharpDX.Direct2D1.PixelFormat(Format.Unknown, SharpDX.Direct2D1.AlphaMode.Premultiplied)));
d2dSurface.Dispose();
}
commandAllocator = device.CreateCommandAllocator(CommandListType.Direct);
d2dFactory.Dispose();
//Init font
var directWriteFactory = new SharpDX.DirectWrite.Factory();
textFormat = new SharpDX.DirectWrite.TextFormat(directWriteFactory, "Arial", SharpDX.DirectWrite.FontWeight.Bold, SharpDX.DirectWrite.FontStyle.Normal, 48) { TextAlignment = SharpDX.DirectWrite.TextAlignment.Leading, ParagraphAlignment = SharpDX.DirectWrite.ParagraphAlignment.Near };
textBrush = new SharpDX.Direct2D1.SolidColorBrush(direct2DRenderTarget[0], Color.White);
directWriteFactory.Dispose();
}
public static Brush2D ToSharpDX(this Brush brush, RenderTarget2D target)
{
SolidColorBrush solidColorBrush = brush as SolidColorBrush;
if (solidColorBrush != null)
{
return solidColorBrush.ToSharpDX(target);
}
else
{
throw new NotSupportedException();
}
}
public static SolidColorBrush2D ToSharpDX(this SolidColorBrush brush, RenderTarget2D target)
{
return new SharpDX.Direct2D1.SolidColorBrush(target, brush.Color.ToSharpDX());
}
private void DirectXRender(List<UIElement> points)
{
if (points.Count <= 0)
return;
Line initLine = points[0] as Line;
Point
p1 = new Point
(
Math.Min(initLine.X1 - initLine.StrokeThickness / 2, initLine.X2 - initLine.StrokeThickness / 2),
Math.Min(initLine.Y1 - initLine.StrokeThickness / 2, initLine.Y2 - initLine.StrokeThickness / 2)
),
p2 = new Point
(
Math.Max(initLine.X1 + initLine.StrokeThickness / 2, initLine.X2 + initLine.StrokeThickness / 2),
Math.Max(initLine.Y1 + initLine.StrokeThickness / 2, initLine.Y2 + initLine.StrokeThickness / 2)
);
foreach (var child in points)
{
var line = child as Line;
if (line == null)
continue;
if (p1.X > line.X1 - line.StrokeThickness / 2)
p1.X = line.X1 - line.StrokeThickness / 2;
if (p1.X > line.X2 - line.StrokeThickness / 2)
p1.X = line.X2 - line.StrokeThickness / 2;
if (p2.X < line.X1 + line.StrokeThickness / 2)
p2.X = line.X1 + line.StrokeThickness / 2;
if (p2.X < line.X2 + line.StrokeThickness / 2)
p2.X = line.X2 + line.StrokeThickness / 2;
if (p1.Y > line.Y1 - line.StrokeThickness / 2)
p1.Y = line.Y1 - line.StrokeThickness / 2;
if (p1.Y > line.Y2 - line.StrokeThickness / 2)
p1.Y = line.Y2 - line.StrokeThickness / 2;
if (p2.Y < line.Y1 + line.StrokeThickness / 2)
p2.Y = line.Y1 + line.StrokeThickness / 2;
if (p2.Y < line.Y2 + line.StrokeThickness / 2)
p2.Y = line.Y2 + line.StrokeThickness / 2;
}
var bndRect = new Rect(p1, p2);
var dxTarget = new SurfaceImageSource
(
(int)(bndRect.Width * DisplayProperties.LogicalDpi / 96.0 + 1),
(int)(bndRect.Height * DisplayProperties.LogicalDpi / 96.0 + 1)
);
SharpDX.DXGI.ISurfaceImageSourceNative dxTargetNative = SharpDX.ComObject.As<SharpDX.DXGI.ISurfaceImageSourceNative>(dxTarget);
dxTargetNative.Device = d3dDevice.QueryInterface<SharpDX.DXGI.Device>();
/*
* Draw Logic
*/
SharpDX.DrawingPoint drawingPoint;
var surface = dxTargetNative.BeginDraw(new SharpDX.Rectangle(0, 0,
(int)(bndRect.Width * DisplayProperties.LogicalDpi / 96.0 + 1),
(int)(bndRect.Height * DisplayProperties.LogicalDpi / 96.0 + 1)),
out drawingPoint);
var dxRenderTarget = new SharpDX.Direct2D1.RenderTarget(d2dFactory, surface, new SharpDX.Direct2D1.RenderTargetProperties()
{
DpiX = DisplayProperties.LogicalDpi,
DpiY = DisplayProperties.LogicalDpi,
PixelFormat = new SharpDX.Direct2D1.PixelFormat(SharpDX.DXGI.Format.B8G8R8A8_UNorm, SharpDX.Direct2D1.AlphaMode.Premultiplied),
Type = SharpDX.Direct2D1.RenderTargetType.Default,
Usage = SharpDX.Direct2D1.RenderTargetUsage.None
});
dxRenderTarget.BeginDraw();
dxRenderTarget.Clear(SharpDX.Color.Transparent);
foreach (var child in points)
{
var line = child as Line;
if (line == null)
continue;
Color c = (line.Stroke as SolidColorBrush).Color;
var brush = new SharpDX.Direct2D1.SolidColorBrush(dxRenderTarget, new SharpDX.Color(c.R, c.G, c.B, c.A));
var style = new SharpDX.Direct2D1.StrokeStyleProperties();
style.LineJoin = SharpDX.Direct2D1.LineJoin.Round;
style.StartCap = SharpDX.Direct2D1.CapStyle.Round;
style.EndCap = SharpDX.Direct2D1.CapStyle.Round;
var stroke = new SharpDX.Direct2D1.StrokeStyle(d2dFactory, style);
dxRenderTarget.DrawLine(
new SharpDX.DrawingPointF((float)(line.X1 - bndRect.Left), (float)(line.Y1 - bndRect.Top)),
new SharpDX.DrawingPointF((float)(line.X2 - bndRect.Left), (float)(line.Y2 - bndRect.Top)),
brush, (float)line.StrokeThickness, stroke);
}
dxRenderTarget.EndDraw();
dxTargetNative.EndDraw();
var dxImage = new Image();
dxImage.Source = dxTarget;
canvas.Children.Add(dxImage);
Canvas.SetLeft(dxImage, bndRect.X);
Canvas.SetTop(dxImage, bndRect.Y);
}
private void CreateRenderTarget(SharpDX.DXGI.Surface surface)
{
// Create a D2D render target which can draw into our offscreen D3D surface.
// D2D uses device independant units, like WPF, at 96/inch.
var properties = new SharpDX.Direct2D1.RenderTargetProperties();
properties.DpiX = 96;
properties.DpiY = 96;
properties.MinLevel = SharpDX.Direct2D1.FeatureLevel.Level_DEFAULT;
properties.PixelFormat = new SharpDX.Direct2D1.PixelFormat(Format.Unknown, SharpDX.Direct2D1.AlphaMode.Premultiplied);
properties.Usage = SharpDX.Direct2D1.RenderTargetUsage.None;
if (this.renderTarget != null)
{
this.renderTarget.Dispose();
}
renderTarget = new SharpDX.Direct2D1.RenderTarget(factory2D, surface, properties);
}
