public void DrawTextLineTo(ICoreCanvas2D target, Matrix3x2 transform, string text, ColorStyle tintColor)
{
var offset = transform.Translation;
if (target is Backends.IBackendCanvas2D backendCanvas)
{
void _drawPath(ReadOnlySpan <Point2> points)
{
backendCanvas.DrawThinLines(points, 0.1f, tintColor);
}
foreach (var c in text)
{
_DrawGlyphAsLines(_drawPath, transform, ref offset, c);
}
}
else
{
void _drawPath(ReadOnlySpan <Point2> points)
{
target.DrawLines(points, 0.1f, tintColor);
}
foreach (var c in text)
{
_DrawGlyphAsLines(_drawPath, transform, ref offset, c);
}
}
}
/// <summary>
/// Sets the target <see cref="ICoreCanvas2D"/> to where the drawing calls will be redirected.
/// </summary>
/// <param name="target">The drawing target.</param>
protected void SetPassThroughTarget(ICoreCanvas2D target)
{
if (object.ReferenceEquals(target, this))
{
throw new ArgumentException($"{nameof(target)} must not reference itself to avod a circular dependency. Derive from {nameof(PassToSelf)} instead.");
}
_Target = target;
}
public void DrawTextLineTo(ICoreCanvas2D target, Matrix3x2 origin, string text, ColorStyle tintColor)
{
foreach (var(idx, xform) in _Font.GetGlyphLocations(origin, text))
{
var glyph = _Glyphs[idx];
target.DrawImage(xform, (glyph, tintColor));
}
}
/// <summary>
/// Sets the target <see cref="ICoreCanvas2D"/> to where the drawing calls will be redirected.
/// </summary>
/// <param name="target">The drawing target.</param>
protected void SetPassImageThroughTarget(ICoreCanvas2D target)
{
if (object.ReferenceEquals(target, this))
{
throw new ArgumentException($"{nameof(target)} must not reference itself to avod a circular dependency.");
}
_Target = target;
_Backend = target as Backends.IBackendCanvas2D;
}
public static Canvas2DTransform Create(ICoreCanvas2D target, Point2 physicalSize, RectangleF virtualBounds)
{
Point2 virtualOrig = virtualBounds.Location;
Point2 virtualSize = virtualBounds.Size;
var virtualCenter = virtualOrig + virtualSize * 0.5f;
var xform = Matrix3x2.CreateTranslation(virtualCenter);
return(Create(target, physicalSize, virtualSize, xform));
}
/// <summary>
/// Tries to create a virtual canvas from a physical canvas and a camera.
/// </summary>
/// <param name="physicalCanvas">This is typically a <see cref="ICanvas2D"/> backend. It must implement <see cref="IRenderTargetInfo"/>.</param>
/// <param name="camera">The current camera</param>
/// <param name="virtualCanvas">the resulting virtual canvas.</param>
/// <returns>true if it succeeded in creating the virtual canvas.</returns>
/// <remarks>
/// The method may fail if the <paramref name="physicalCanvas"/> does not implement <see cref="IRenderTargetInfo"/> at one point in the chain,
/// or if the <see cref="IRenderTargetInfo.PixelsWidth"/> or <see cref="IRenderTargetInfo.PixelsHeight"/> are zero or negative.
/// </remarks>
public static bool TryCreate(ICoreCanvas2D physicalCanvas, CameraTransform2D camera, out Canvas2DTransform virtualCanvas)
{
if (!camera.TryCreateFinalMatrix(physicalCanvas, out var finalMatrix))
{
virtualCanvas = default;
return(false);
}
virtualCanvas = Create(physicalCanvas, finalMatrix);
return(true);
}
/// <summary>
/// Tries to get the physical render target size and returns it converted to virtual space.
/// </summary>
/// <param name="dc"></param>
/// <param name="camera"></param>
/// <returns></returns>
public static bool TryGetOuterCamera(ICoreCanvas2D dc, out CameraTransform2D camera)
{
camera = default;
if (!TryGetRenderTargetInfo(dc, out var vinfo))
{
return(false);
}
if (vinfo == null)
{
return(false);
}
var w = vinfo.PixelsWidth;
var h = vinfo.PixelsHeight;
if (w <= 0 || h <= 0)
{
return(false);
}
// query for any in between transformations
if (dc is ITransformer2D xform)
{
// transform points from physical screen space to virtual space
Span <Point2> points = stackalloc Point2[3];
points[0] = (0, 0);
points[1] = (w, 0);
points[2] = (0, h);
xform.TransformInverse(points);
// create matrix from points
var dx = Point2.Normalize(points[1] - points[0], out var ww);
var dy = Point2.Normalize(points[2] - points[0], out var hh);
var m = new Matrix3x2(dx.X, dx.Y, dy.X, dy.Y, points[0].X, points[0].Y);
// create camera
camera = new CameraTransform2D(m, new Vector2(ww, hh), false);
}
else
{
camera = Create(Matrix3x2.Identity, new Vector2(w, h));
}
return(true);
}
public static Canvas2DTransform Create(ICoreCanvas2D target, Point2 physicalSize, Point2 virtualSize, Matrix3x2 virtualOffset)
{
var camera = CameraTransform2D.Create(virtualOffset, virtualSize);
return(Create(target, camera, physicalSize));
}
public static Canvas2DTransform Create(ICoreCanvas2D target, Matrix3x2 xform)
{
return(new Canvas2DTransform(target, xform));
}
public static ICoreCanvas2D CreateTransformed2D(this ICoreCanvas2D source, XFORM2 xform)
{
return(xform.IsIdentity ? source : Transforms.Canvas2DTransform.Create(source, xform));
}
public static bool DrawAsset <TAsset>(ICoreCanvas2D dc, in Matrix3x2 transform, TAsset asset)
public Decompose2D(ICoreCanvas2D renderTarget)
{
_RenderTarget = renderTarget;
}
