public PathGeometry ToDirect2DPathGeometry(Factory factory, System.Windows.Media.MatrixTransform graphToCanvas)
{
double xScale, xOffset, yScale, yOffset;
xScale = graphToCanvas.Matrix.M11;
xOffset = graphToCanvas.Matrix.OffsetX;
yScale = graphToCanvas.Matrix.M22;
yOffset = graphToCanvas.Matrix.OffsetY;
PathGeometry geometry = new PathGeometry(factory);
using (GeometrySink sink = geometry.Open())
{
float xCanvas = (float)(xTransformed[0] * xScale + xOffset);
float yCanvas = (float)(yTransformed[0] * yScale + yOffset);
Vector2 p0 = new Vector2(xCanvas, yCanvas);
sink.BeginFigure(p0, FigureBegin.Hollow);
for (int i = 1; i < x.Count(); ++i)
{
if (includeLinePoint[i])
{
xCanvas = (float)(xTransformed[i] * xScale + xOffset);
yCanvas = (float)(yTransformed[i] * yScale + yOffset);
sink.AddLine(new Vector2(xCanvas, yCanvas));
}
}
sink.EndFigure(FigureEnd.Open);
sink.Close();
}
return geometry;
}
public override void OnRender(ChartControl chartControl, ChartScale chartScale, ChartBars chartBars)
{
Bars bars = chartBars.Bars;
if (chartBars.FromIndex > 0)
{
chartBars.FromIndex--;
}
SharpDX.Direct2D1.PathGeometry lineGeometry = new SharpDX.Direct2D1.PathGeometry(Core.Globals.D2DFactory);
GeometrySink sink = lineGeometry.Open();
sink.BeginFigure(new Vector2(chartControl.GetXByBarIndex(chartBars, chartBars.FromIndex > -1 ? chartBars.FromIndex : 0), chartScale.GetYByValue(bars.GetClose(chartBars.FromIndex > -1 ? chartBars.FromIndex : 0))), FigureBegin.Filled);
for (int idx = chartBars.FromIndex + 1; idx <= chartBars.ToIndex; idx++)
{
double closeValue = bars.GetClose(idx);
float close = chartScale.GetYByValue(closeValue);
float x = chartControl.GetXByBarIndex(chartBars, idx);
sink.AddLine(new Vector2(x, close));
}
sink.EndFigure(FigureEnd.Open);
sink.Close();
AntialiasMode oldAliasMode = RenderTarget.AntialiasMode;
RenderTarget.AntialiasMode = AntialiasMode.PerPrimitive;
RenderTarget.DrawGeometry(lineGeometry, UpBrushDX, (float)Math.Max(1, chartBars.Properties.ChartStyle.BarWidth));
RenderTarget.AntialiasMode = oldAliasMode;
lineGeometry.Dispose();
}
public IPath Clone()
{
var result = new D2D.PathGeometry(_path.Factory);
var sink = result.Open();
_path.Stream(sink);
sink.Close();
return new Path(result);
}
protected Path(D2D.PathGeometry geometry)
{
if(geometry ==null)
{
throw new ArgumentNullException();
}
_path = geometry;
}
protected Path(D2D.PathGeometry geometry)
{
if (geometry == null)
{
throw new ArgumentNullException();
}
_path = geometry;
}
public Path(D2D.Factory factory)
{
if (factory == null)
{
throw new ArgumentNullException();
}
_path = new D2D.PathGeometry(factory);
}
public Path(D2D.Factory factory)
{
if(factory==null)
{
throw new ArgumentNullException();
}
_path = new D2D.PathGeometry(factory);
}
/// <summary>
/// Disposes of resources</summary>
/// <param name="disposing">True to release both managed and unmanaged resources;
/// false to release only unmanaged resources</param>
protected override void Dispose(bool disposing)
{
if (disposing && m_geometry != null)
{
m_geometry.Dispose();
m_geometry = null;
}
base.Dispose(disposing);
}
public IStreamGeometryImpl Clone()
{
Factory factory = Locator.Current.GetService<Factory>();
var result = new PathGeometry(factory);
var sink = result.Open();
this.path.Stream(sink);
sink.Close();
return new StreamGeometryImpl(result);
}
public IPath Clone()
{
var result = new D2D.PathGeometry(_path.Factory);
var sink = result.Open();
_path.Stream(sink);
sink.Close();
return(new Path(result));
}
public void DrawCircle(Renderer renderer, Vector2 center, float radius, float step, double a, double b, ref D2D1.PathGeometry outline, int col, float txt)
{
D2D1.PathGeometry path = new D2D1.PathGeometry(renderer.D2DFactory);
D2D1.GeometrySink s = path.Open();
s.SetFillMode(D2D1.FillMode.Winding);
s.BeginFigure(center + new Vector2((float)Math.Cos(a) * radius, (float)Math.Sin(a) * radius), D2D1.FigureBegin.Filled);
for (double i = a; i <= b; i += Math.PI * .05)
{
s.AddLine(center + new Vector2((float)Math.Cos(i) * radius, (float)Math.Sin(i) * radius));
}
s.AddLine(center + new Vector2((float)Math.Cos(b) * radius, (float)Math.Sin(b) * radius));
s.AddLine(center);
s.EndFigure(D2D1.FigureEnd.Closed);
s.Close();
s.Dispose();
renderer.D2DContext.FillGeometry(path, renderer.Brushes[Colors[col % Colors.Length]]);
if (path.FillContainsPoint(Input.MousePos, 1))
{
if (txt == 0)
{
txt = radius + 50;
}
RawRectangleF r = new RawRectangleF(center.X - 100, center.Y - txt, center.X + 100, center.Y - txt + 16);
renderer.D2DContext.FillRectangle(r, renderer.Brushes["TransparentBlack"]);
renderer.Consolas14.TextAlignment = DWrite.TextAlignment.Leading;
renderer.D2DContext.DrawText(
Name + " (" + Stopwatch.Elapsed.TotalMilliseconds.ToString("F1") + "ms)",
renderer.Consolas14, r, renderer.Brushes[Colors[col % Colors.Length]], D2D1.DrawTextOptions.None, D2D1.MeasuringMode.GdiNatural);
txt += 16;
outline = path;
}
else
{
path.Dispose();
}
double t = 0;
foreach (Profiler p in Children)
{
col++;
//if (p.ParentTickOffset > 0)
// t += (p.ParentTickOffset / (double)Stopwatch.Elapsed.Ticks) * (b - a);
double f = (p.Stopwatch.Elapsed.Ticks / (double)Stopwatch.Elapsed.Ticks) * (b - a);
p.DrawCircle(renderer, center, radius - step, step, a + t, a + t + f, ref outline, col, txt);
t += f;
}
}
public void DrawCircle(Renderer renderer, Vector2 center, float radius)
{
D2D1.PathGeometry outline = null;
DrawCircle(renderer, center, radius, radius * .05f, 0, Math.PI * 2, ref outline, 0, 0);
if (outline != null)
{
renderer.D2DContext.DrawGeometry(outline, renderer.Brushes["Black"], 2);
outline.Dispose();
}
}
public static D2D.Geometry ToSharpDX(this Geometry geometry, D2D.Factory factory, RectangleF rect)
{
var d2dGeometry = new D2D.PathGeometry(factory);
var sink = d2dGeometry.Open();
sink.AddGeometry(geometry, rect);
sink.Close();
return d2dGeometry;
}
public static D2D.Geometry ToSharpDX(this Geometry geometry, D2D.Factory factory, RectangleF rect)
{
var d2dGeometry = new D2D.PathGeometry(factory);
var sink = d2dGeometry.Open();
sink.AddGeometry(geometry, rect);
sink.Close();
return(d2dGeometry);
}
private D2DGeometry FlattenGeometry(D2DGeometry geometry, float tolerance)
{
PathGeometry path = new PathGeometry(this.factory);
GeometrySink sink = path.Open();
geometry.Simplify(GeometrySimplificationOption.Lines, tolerance, sink);
sink.Close();
return path;
}
public static PathGeometry Geometry(Factory factory, Action<GeometrySink> figureBuilder)
{
var pg = new PathGeometry(factory);
using (var sink = pg.Open())
{
figureBuilder(sink);
sink.Close();
}
return pg;
}
public D2D.GeometryRealization CreateSymbol(ShowSymbol sym, DW.TextFormat format)
{
D2D.GeometryRealization cached_geo = null;
bool result = symbol_cache.TryGetValue(sym, out cached_geo);
if (!result)
{
const int margin = 2;
D2D.Geometry geo = null;
DW.TextLayout layout = null;
D2D.PathGeometry path = null;
DW.TextMetrics metrics;
D2D.StrokeStyle stroke = null;
switch (sym)
{
case ShowSymbol.FullSpace:
layout = new DW.TextLayout(this._DWFactory, " ", format, float.MaxValue, float.MaxValue);
metrics = layout.Metrics;
Rectangle rect = new Rectangle(margin, margin, Math.Max(1, metrics.WidthIncludingTrailingWhitespace - margin * 2), Math.Max(1, metrics.Height - margin * 2));
geo = new D2D.RectangleGeometry(this.Factory, rect);
stroke = this.GetStroke(HilightType.Dash);
break;
case ShowSymbol.HalfSpace:
layout = new DW.TextLayout(this._DWFactory, " ", format, float.MaxValue, float.MaxValue);
metrics = layout.Metrics;
rect = new Rectangle(margin, margin, Math.Max(1, metrics.WidthIncludingTrailingWhitespace - margin * 2), Math.Max(1, metrics.Height - margin * 2));
geo = new D2D.RectangleGeometry(this.Factory, rect);
stroke = this.GetStroke(HilightType.Sold);
break;
case ShowSymbol.Tab:
layout = new DW.TextLayout(this._DWFactory, "0", format, float.MaxValue, float.MaxValue);
metrics = layout.Metrics;
path = new D2D.PathGeometry(this.Factory);
var sink = path.Open();
sink.BeginFigure(new SharpDX.Mathematics.Interop.RawVector2(1, 1), D2D.FigureBegin.Filled); //少し隙間を開けないと描写されない
sink.AddLine(new SharpDX.Mathematics.Interop.RawVector2((float)1, (float)metrics.Height));
sink.EndFigure(D2D.FigureEnd.Closed);
sink.Close();
geo = path;
stroke = this.GetStroke(HilightType.Sold);
break;
}
cached_geo = new D2D.GeometryRealization(this.Device, geo, 1.0f, 1.0f, stroke);
this.symbol_cache.Add(sym, cached_geo);
}
return(cached_geo);
}
public override Result DrawGlyphRun(object clientDrawingContext, float baselineOriginX, float baselineOriginY,
D2D1.MeasuringMode measuringMode, DW.GlyphRun glyphRun, DW.GlyphRunDescription glyphRunDescription,
ComObject clientDrawingEffect)
{
using (var pathGeometry = new D2D1.PathGeometry(_renderTarget.Factory))
{
using (var geometrySink = pathGeometry.Open())
using (var fontFace = glyphRun.FontFace)
{
if (glyphRun.Indices.Length > 0)
{
fontFace.GetGlyphRunOutline(
glyphRun.FontSize,
glyphRun.Indices,
glyphRun.Advances,
glyphRun.Offsets,
glyphRun.Indices.Length,
glyphRun.IsSideways,
glyphRun.BidiLevel % 2 != 0,
geometrySink
);
}
geometrySink.Close();
}
var matrix = new Matrix3x2()
{
M11 = 1,
M12 = 0,
M21 = 0,
M22 = 1,
M31 = baselineOriginX,
M32 = baselineOriginY
};
var sw = _renderTarget.StrokeWidth;
using (var transformedGeometry =
new D2D1.TransformedGeometry(_renderTarget.Factory, pathGeometry, matrix))
{
_renderTarget.StrokeWidth = _strokeWidth;
_renderTarget.DrawGeometry(transformedGeometry, _strokeBrush);
_renderTarget.FillGeometry(transformedGeometry, _fillBrush);
}
_renderTarget.StrokeWidth = sw;
}
return(SharpDX.Result.Ok);
}
public void DrawArc(Pen pen, float x, float y, float width, float height, float startAngle, float sweepAngle)
{
PointF start;
var arc = CreateArc(x + offset, y + offset, width, height, startAngle, sweepAngle, out start);
var path = new sd.PathGeometry(SDFactory.D2D1Factory);
var sink = path.Open();
sink.BeginFigure(start.ToDx(), sd.FigureBegin.Hollow);
sink.AddArc(arc);
sink.EndFigure(sd.FigureEnd.Open);
sink.Close();
sink.Dispose();
var pd = pen.ToPenData();
Control.DrawGeometry(path, pd.GetBrush(Control), pd.Width, pd.StrokeStyle);
}
public static void DrawPolygon(D2D1.RenderTarget renderTarget, D2D1.Factory factory, IPolygon pol, D2D1.Brush brush, D2D1.Brush pen, float penWidth, D2D1.StrokeStyle penStrokeStyle, bool clip, Map map)
{
if (pol.ExteriorRing == null)
{
return;
}
Vector2[] points;
var startPoint = TransformToImage(pol.ExteriorRing, map, out points);
if (points.Length > 1)
{
using (var geom = new D2D1.PathGeometry(factory))
{
using (var gs = geom.Open())
{
gs.SetFillMode(D2D1.FillMode.Alternate);
gs.BeginFigure(startPoint, D2D1.FigureBegin.Filled);
gs.AddLines(points);
gs.EndFigure(D2D1.FigureEnd.Closed);
for (var i = 0; i < pol.NumInteriorRings; i++)
{
startPoint = TransformToImage(pol.GetInteriorRingN(i), map, out points);
if (points.Length > 1)
{
gs.BeginFigure(startPoint, D2D1.FigureBegin.Filled);
gs.AddLines(points);
gs.EndFigure(D2D1.FigureEnd.Closed);
}
}
gs.Close();
}
if (brush != null)
{
renderTarget.FillGeometry(geom, brush);
}
if (pen != null)
{
renderTarget.DrawGeometry(geom, pen, penWidth, penStrokeStyle);
}
}
}
}
public void Build(Shape shape, out DxGeometry result)
{
Contract.Requires(shape != null);
Contract.Ensures(Contract.ValueAtReturn(out result) != null);
try
{
shape.ExtractTo(this);
}
finally
{
result = _Path;
_PathSink = null;
_Path = null;
}
}
public void FillPie(Brush brush, float x, float y, float width, float height, float startAngle, float sweepAngle)
{
SetOffset(true);
PointF start;
var arc = CreateArc(x, y, width, height, startAngle, sweepAngle, out start);
var path = new sd.PathGeometry(SDFactory.D2D1Factory);
var sink = path.Open();
var center = new s.Vector2(x + width / 2, y + height / 2);
sink.BeginFigure(center, sd.FigureBegin.Filled);
sink.AddLine(start.ToDx());
sink.AddArc(arc);
sink.AddLine(center);
sink.EndFigure(sd.FigureEnd.Open);
sink.Close();
sink.Dispose();
Control.FillGeometry(path, brush.ToDx(Control));
}
public static Geometry MarkerGeometry(MarkersType markersType, Factory factory, float width, float height)
{
Geometry geometry = null;
switch (markersType)
{
case MarkersType.None:
break;
case MarkersType.Square:
geometry = new RectangleGeometry(factory, new SharpDX.RectangleF()
{
X = 0,
Y = 0,
Width = width,
Height = height
});
break;
case MarkersType.Circle:
geometry = new EllipseGeometry(factory, new Ellipse()
{
Point = new Vector2(0, 0),
RadiusX = width / 2,
RadiusY = height / 2,
});
break;
default:
GenericMarker markerSpecification = MarkerGeometries.GenericMarkerLookup[markersType];
geometry = new PathGeometry(factory);
using (GeometrySink sink = (geometry as PathGeometry).Open())
{
Vector2 p0 = new Vector2((float)markerSpecification.X[0] * width, (float)markerSpecification.Y[0] * height);
sink.BeginFigure(p0, FigureBegin.Hollow);
int n = markerSpecification.X.Length;
for (int i = 1; i < n; ++i)
{
sink.AddLine(new Vector2((float)markerSpecification.X[i] * width, (float)markerSpecification.Y[i] * height));
}
sink.EndFigure(FigureEnd.Closed);
sink.Close();
}
break;
}
return geometry;
}
/// <summary>
/// Renders a LineString to the map.
/// </summary>
/// <param name="renderTarget">The render target</param>
/// <param name="factory">The factory to create shapes</param>
/// <param name="line">LineString to render</param>
/// <param name="pen">Pen style used for rendering</param>
/// <param name="map">Map reference</param>
/// <param name="offset">Offset by which line will be moved to right</param>
public static void DrawLineString(D2D1.RenderTarget renderTarget, D2D1.Factory factory, ILineString line, D2D1.Brush pen, float penWidth, D2D1.StrokeStyle penStrokeStyle, Map map, float offset)
{
var points = TransformToImage(line, map);
if (points.Length > 1)
{
using (var geom = new D2D1.PathGeometry(factory))
{
using (var gs = geom.Open())
{
gs.BeginFigure(points[0], D2D1.FigureBegin.Filled);
gs.AddLines(points);
gs.EndFigure(D2D1.FigureEnd.Open);
gs.Close();
}
renderTarget.DrawGeometry(geom, pen, penWidth, penStrokeStyle);
}
}
}
protected override void Initialize(DemoConfiguration demoConfiguration)
{
base.Initialize(demoConfiguration);
// Create an ellipse
Ellipse = new EllipseGeometry(Factory2D,
new Ellipse(new Vector2(demoConfiguration.Width/2, demoConfiguration.Height/2), demoConfiguration.Width/2 - 100,
demoConfiguration.Height/2 - 100));
// Populate a PathGeometry from Ellipse tessellation
TesselatedGeometry = new PathGeometry(Factory2D);
GeometrySink = TesselatedGeometry.Open();
// Force RoundLineJoin otherwise the tesselated looks buggy at line joins
GeometrySink.SetSegmentFlags(PathSegment.ForceRoundLineJoin);
// Tesselate the ellipse to our TessellationSink
Ellipse.Tessellate(1, this);
// Close the GeometrySink
GeometrySink.Close();
}
public Result DrawGlyphRun(object clientDrawingContext, float baselineOriginX, float baselineOriginY, MeasuringMode measuringMode, GlyphRun glyphRun, GlyphRunDescription glyphRunDescription, ComObject clientDrawingEffect)
{
var pathGeometry = new PathGeometry(_d2DFactory);
var geometrySink = pathGeometry.Open();
var fontFace = glyphRun.FontFace;
if (glyphRun.Indices.Length > 0)
fontFace.GetGlyphRunOutline(glyphRun.FontSize, glyphRun.Indices, glyphRun.Advances, glyphRun.Offsets, glyphRun.IsSideways, glyphRun.BidiLevel % 2 != 0, geometrySink);
geometrySink.Close();
geometrySink.Dispose();
fontFace.Dispose();
var matrix = new Matrix3x2()
{
M11 = 1,
M12 = 0,
M21 = 0,
M22 = 1,
M31 = baselineOriginX,
M32 = baselineOriginY
};
var transformedGeometry = new TransformedGeometry(_d2DFactory, pathGeometry, matrix);
var brushColor = (Color4)Color.Black;
if (clientDrawingEffect != null && clientDrawingEffect is ColorDrawingEffect)
brushColor = (clientDrawingEffect as ColorDrawingEffect).Color;
var brush = new SolidColorBrush(_renderTarget, brushColor);
_renderTarget.DrawGeometry(transformedGeometry, brush);
_renderTarget.FillGeometry(transformedGeometry, brush);
pathGeometry.Dispose();
transformedGeometry.Dispose();
brush.Dispose();
return SharpDX.Result.Ok;
}
public void DrawPolyline(
IElement element,
IFrameContext context,
PxPoint[] xpoints,
Fill fill,
Stroke strokeStyle
)
{
if (xpoints == null || xpoints.Length == 0)
{
return;
}
var points = xpoints
.Select(s => new DXM.RawVector2(s.X, s.Y))
.ToList();
using (var geometry = new D2D1.PathGeometry(_dc.Factory))
using (var sink = geometry.Open())
{
sink.BeginFigure(points[0], D2D1.FigureBegin.Filled);
sink.AddLines(points.Skip(1).ToArray());
sink.EndFigure(D2D1.FigureEnd.Open);
sink.Close();
var fillBrush = CreateBrush(element, context, fill.Brush, fill.Opacity);
var strokeBrush = strokeStyle.Width > 0
? CreateBrush(element, context, strokeStyle.Brush, strokeStyle.Opacity)
: null;
if (fillBrush != null)
{
Target.FillGeometry(geometry, fillBrush);
}
if (strokeBrush != null)
{
Target.DrawGeometry(geometry, strokeBrush, strokeStyle.Width, GetStrokeStyle(strokeStyle));
}
}
}
public override Result DrawStrikethrough(object clientDrawingContext, float baselineOriginX, float baselineOriginY, ref Strikethrough strikethrough, ComObject clientDrawingEffect)
{
PathGeometry pg = new PathGeometry(this.factory);
GeometrySink sink = pg.Open();
Vector2 topLeft = new Vector2(0.0f, strikethrough.Offset);
sink.BeginFigure(topLeft, FigureBegin.Filled);
topLeft.X += strikethrough.Width;
sink.AddLine(topLeft);
topLeft.Y += strikethrough.Thickness;
sink.AddLine(topLeft);
topLeft.X -= strikethrough.Width;
sink.AddLine(topLeft);
sink.EndFigure(FigureEnd.Closed);
sink.Close();
TransformedGeometry tg = new TransformedGeometry(this.factory, pg, Matrix3x2.Translation(baselineOriginX, baselineOriginY) * Matrix3x2.Scaling(1.0f, -1.0f));
pg.Dispose();
this.AddGeometry(tg);
return Result.Ok;
}
//---------------------------------------------------------------------------------------------------------
/// <summary>
/// Обновление данных арки
/// </summary>
//---------------------------------------------------------------------------------------------------------
public override void Update()
{
XDisposer.SafeDispose(ref mD2DGeometry);
mD2DGeometry = new Direct2D.PathGeometry(XDirect2DManager.D2DFactory);
mD2DGeometrySink = mD2DGeometry.Open();
mD2DGeometrySink.BeginFigure(mStartPoint.ToRawVector2(), mIsFilled ? Direct2D.FigureBegin.Filled : Direct2D.FigureBegin.Hollow);
Direct2D.ArcSegment arc_segment = new Direct2D.ArcSegment();
arc_segment.ArcSize = mIsLargeArc ? Direct2D.ArcSize.Large : Direct2D.ArcSize.Small;
arc_segment.Point = mEndPoint.ToRawVector2();
arc_segment.RotationAngle = mRotationAngle;
arc_segment.Size = new SharpDX.Size2F(mRadiusX, mRadiusY);
arc_segment.SweepDirection = mIsClockwiseDirection ? Direct2D.SweepDirection.Clockwise : Direct2D.SweepDirection.CounterClockwise;
mD2DGeometrySink.AddArc(arc_segment);
mD2DGeometrySink.EndFigure(mIsClosed ? Direct2D.FigureEnd.Closed : Direct2D.FigureEnd.Open);
mD2DGeometrySink.Close();
XDisposer.SafeDispose(ref mD2DGeometrySink);
mBoundsRect = mD2DGeometry.GetWidenedBounds(2).ToRect();
}
private void Update(bool forceUpdate = false)
{
if (isUpdated || forceUpdate)
{
isUpdated = false;
geometry?.Dispose();
geometry = new d2.PathGeometry(Renderer.Factory);
var s = geometry.Open();
s.BeginFigure(Points[0], d2.FigureBegin.Filled);
s.AddLines(Points.Select(v2 => new mi.RawVector2(v2.X, v2.Y)).ToArray());
s.EndFigure(d2.FigureEnd.Closed);
s.Close();
strokeBrush?.Dispose();
strokeBrush = new d2.SolidColorBrush(Renderer.Device, _stroke.ToColor4());
fillBrush?.Dispose();
fillBrush = new d2.SolidColorBrush(Renderer.Device, _fill.ToColor4());
}
}
public static D2D1.Geometry Create(D2D1.RenderTarget target, Paths.Path path,
D2D1.FillMode fillMode = D2D1.FillMode.Winding)
{
var segments = path.Segments;
var length = segments.Length;
var geometries = length > 1 ? new D2D1.Geometry[segments.Length] : null;
var i = 0;
foreach (var segment in path.Segments)
{
var geometry = new D2D1.PathGeometry(target.Factory);
using (var sink = geometry.Open())
{
sink.SetSegmentFlags(D2D1.PathSegment.None);
foreach (var x in segment.Commands)
{
x.Visit(sink, Visitor);
}
sink.Close();
}
if (length == 1)
{
return(geometry);
}
geometries[i++] = geometry;
}
try
{
return(new D2D1.GeometryGroup(target.Factory, fillMode, geometries));
}
catch (Exception ex)
{
throw ex;
}
}
public override SharpDX.Result DrawGlyphRun(object clientDrawingContext, float baselineOriginX, float baselineOriginY, MeasuringMode measuringMode, GlyphRun glyphRun, GlyphRunDescription glyphRunDescription, SharpDX.ComObject clientDrawingEffect)
{
Color4 c = Color4.White;
if (clientDrawingEffect != null)
{
if (clientDrawingEffect is SharpDX.Direct2D1.SolidColorBrush)
{
var sb = (SharpDX.Direct2D1.SolidColorBrush)clientDrawingEffect;
c = sb.Color;
}
}
if (glyphRun.Indices.Length > 0)
{
PathGeometry pg = new PathGeometry(this.factory);
GeometrySink sink = pg.Open();
glyphRun.FontFace.GetGlyphRunOutline(glyphRun.FontSize, glyphRun.Indices, glyphRun.Advances, glyphRun.Offsets, glyphRun.IsSideways, glyphRun.BidiLevel % 2 == 1, sink as SimplifiedGeometrySink);
sink.Close();
TransformedGeometry tg = new TransformedGeometry(this.factory, pg, Matrix3x2.Translation(baselineOriginX, baselineOriginY) * Matrix3x2.Scaling(1.0f, -1.0f));
pg.Dispose();
//Transform from baseline
this.AddGeometry(tg);
return SharpDX.Result.Ok;
}
else
{
return SharpDX.Result.Ok;
}
}
/// <summary>
/// Draws a series of line segments that connect an array of System.Drawing.PointF</summary>
/// <param name="points">Array of PointF that represent the points to connect</param>
/// <param name="brush">The brush used to paint the line's stroke</param>
/// <param name="strokeWidth">A value greater than or equal to 0.0f that specifies the width of the stroke</param>
/// <param name="strokeStyle">The style of stroke to paint, or NULL to paint a solid line</param>
public void DrawLines(IEnumerable<PointF> points, D2dBrush brush, float strokeWidth = 1.0f, D2dStrokeStyle strokeStyle = null)
{
var iter = points.GetEnumerator();
if (!iter.MoveNext()) return;
var transparent = brush.Opacity < 1.0f;
if (!transparent)
{
var sbrush = brush as D2dSolidColorBrush;
if (sbrush != null)
transparent = sbrush.Color.A < 255;
}
var nstroke = (strokeStyle ?? s_strokeStyle).NativeStrokeStyle;
if (transparent)
{
using (var geom = new PathGeometry(D2dFactory.NativeFactory))
{
var sink = geom.Open();
var pt1 = iter.Current;
sink.BeginFigure(pt1.ToSharpDX(), FigureBegin.Hollow);
while (iter.MoveNext())
{
sink.AddLine(iter.Current.ToSharpDX());
}
sink.EndFigure(FigureEnd.Open);
sink.Close();
sink.Dispose();
m_renderTarget.DrawGeometry(geom, brush.NativeBrush, strokeWidth, nstroke);
}
}
else
{
var nbrush = brush.NativeBrush;
var pt1 = iter.Current;
while (iter.MoveNext())
{
var pt2 = iter.Current;
m_renderTarget.DrawLine(pt1.ToSharpDX(), pt2.ToSharpDX(), nbrush,
strokeWidth, nstroke);
pt1 = pt2;
}
}
}
/// <summary>
/// Draws a Bézier spline defined by four System.Drawing.PointF structures</summary>
/// <param name="pt1">Represents the starting point of the curve</param>
/// <param name="pt2">Represents the first control point for the curve</param>
/// <param name="pt3">Represents the second control point for the curve</param>
/// <param name="pt4">Represents the ending point of the curve</param>
/// <param name="brush">The brush used to paint the curve's stroke</param>
/// <param name="strokeWidth">The thickness of the geometry's stroke. The stroke is centered on the geometry's outline.</param>
/// <param name="strokeStyle">The style of stroke to apply to the geometry's outline or null to draw a solid line</param>
public void DrawBezier(PointF pt1, PointF pt2, PointF pt3, PointF pt4, D2dBrush brush, float strokeWidth = 1.0f, D2dStrokeStyle strokeStyle = null)
{
using (var geom = new PathGeometry(D2dFactory.NativeFactory))
{
var sink = geom.Open();
sink.BeginFigure(pt1.ToSharpDX(), FigureBegin.Hollow);
var seg = new BezierSegment
{
Point1 = pt2.ToSharpDX(),
Point2 = pt3.ToSharpDX(),
Point3 = pt4.ToSharpDX()
};
sink.AddBezier(seg);
sink.EndFigure(FigureEnd.Open);
sink.Close();
sink.Dispose();
var stroke = strokeStyle == null ? null : strokeStyle.NativeStrokeStyle;
m_renderTarget.DrawGeometry(geom, brush.NativeBrush, strokeWidth, stroke);
}
}
private static D2D.PathGeometry GetBorderFillGeometry(
CompositionEngine compositionEngine, Border border, RectangleF rect)
{
var topLeftCornerSize = new DrawingSizeF(
(float)border.CornerRadius.TopLeft,
(float)border.CornerRadius.TopLeft);
var topRightCornerSize = new DrawingSizeF(
(float)border.CornerRadius.TopRight,
(float)border.CornerRadius.TopRight);
var bottomLeftCornerSize = new DrawingSizeF(
(float)border.CornerRadius.BottomLeft,
(float)border.CornerRadius.BottomLeft);
var bottomRightCornerSize = new DrawingSizeF(
(float)border.CornerRadius.BottomRight,
(float)border.CornerRadius.BottomRight);
var topCornersWidth = topLeftCornerSize.Width + topRightCornerSize.Width;
if (topCornersWidth > rect.Width)
{
var scale = rect.Width / topCornersWidth;
topLeftCornerSize.Width *= scale;
topRightCornerSize.Width *= scale;
}
var bottomCornersWidth = bottomLeftCornerSize.Width + bottomRightCornerSize.Width;
if (bottomCornersWidth > rect.Width)
{
var scale = rect.Width / bottomCornersWidth;
bottomLeftCornerSize.Width *= scale;
bottomRightCornerSize.Width *= scale;
}
var leftCornersHeight = topLeftCornerSize.Height + bottomLeftCornerSize.Height;
if (leftCornersHeight > rect.Height)
{
var scale = rect.Height / leftCornersHeight;
topLeftCornerSize.Height *= scale;
bottomLeftCornerSize.Height *= scale;
}
var rightCornersHeight = topRightCornerSize.Height + bottomRightCornerSize.Height;
if (rightCornersHeight > rect.Height)
{
var scale = rect.Height / rightCornersHeight;
topRightCornerSize.Height *= scale;
bottomRightCornerSize.Height *= scale;
}
var geometry = new D2D.PathGeometry(compositionEngine.D2DFactory);
// Create the geometry of the irregular rounded rectangle.
var geometrySink = geometry.Open();
// Start to the right of the topleft corner.
geometrySink.BeginFigure(
new DrawingPointF(
rect.Left + topLeftCornerSize.Width,
rect.Top + 0),
D2D.FigureBegin.Filled);
//if (topCornersWidth < rect.Width)
{
// Top edge
geometrySink.AddLine(
new DrawingPointF(
rect.Left + rect.Width - topRightCornerSize.Width,
rect.Top + 0));
}
//if (topRightCornerSize.Width > 0)
// Top-right corner
geometrySink.AddArc(
new D2D.ArcSegment
{
Point = new DrawingPointF(
rect.Left + rect.Width,
rect.Top + topRightCornerSize.Height),
Size = topRightCornerSize,
RotationAngle = 0,
SweepDirection = D2D.SweepDirection.Clockwise,
ArcSize = D2D.ArcSize.Small
});
// Right edge
geometrySink.AddLine(
new DrawingPointF(
rect.Left + rect.Width,
rect.Top + rect.Height - bottomRightCornerSize.Height));
// Bottom-right corner
geometrySink.AddArc(
new D2D.ArcSegment
{
Point = new DrawingPointF(
rect.Left + rect.Width - bottomRightCornerSize.Width,
rect.Top + rect.Height),
Size = bottomRightCornerSize,
RotationAngle = 0,
SweepDirection = D2D.SweepDirection.Clockwise,
ArcSize = D2D.ArcSize.Small
});
// Bottom edge
geometrySink.AddLine(
new DrawingPointF(
rect.Left + bottomLeftCornerSize.Width,
rect.Top + rect.Height));
// Bottom-left corner
geometrySink.AddArc(
new D2D.ArcSegment
{
Point = new DrawingPointF(
rect.Left + 0,
rect.Top + rect.Height - bottomLeftCornerSize.Height),
Size = bottomLeftCornerSize,
RotationAngle = 0,
SweepDirection = D2D.SweepDirection.Clockwise,
ArcSize = D2D.ArcSize.Small
});
// Left edge
geometrySink.AddLine(
new DrawingPointF(
rect.Left + 0,
rect.Top + topLeftCornerSize.Height));
// Top-left corner
geometrySink.AddArc(
new D2D.ArcSegment
{
Point = new DrawingPointF(
rect.Left + topLeftCornerSize.Width,
rect.Top + 0),
Size = topLeftCornerSize,
RotationAngle = 0,
SweepDirection = D2D.SweepDirection.Clockwise,
ArcSize = D2D.ArcSize.Small
});
geometrySink.EndFigure(D2D.FigureEnd.Closed);
geometrySink.Close();
return(geometry);
}
public IGeometry Geometry(IRecorder<IGeometryTarget> records)
{
var path = new PathGeometry(Factory);
try
{
using (var sink = path.Open())
{
var target = new GeometryTarget(Factory, sink);
records.Replay(target);
target.endOpenFigure();
sink.Close();
}
return new GeometryImplementation(path);
}
catch
{
path.Dispose();
throw;
}
}
public void DrawPath(IEnumerable<PathOp> ops, Pen pen = null, Brush brush = null)
{
var bb = new BoundingBoxBuilder ();
var s = new D2D1.PathGeometry (factories.D2DFactory);
var figureDepth = 0;
using (var sink = s.Open ()) {
foreach (var op in ops) {
if (op is MoveTo) {
while (figureDepth > 0) {
sink.EndFigure (D2D1.FigureEnd.Open);
figureDepth--;
}
var mt = ((MoveTo)op);
sink.BeginFigure (Conversions.ToVector2 (mt.Point), D2D1.FigureBegin.Filled);
figureDepth++;
bb.Add (mt.Point);
}
else if (op is LineTo) {
var lt = ((LineTo)op);
sink.AddLine (Conversions.ToVector2 (lt.Point));
bb.Add (lt.Point);
}
else if (op is ArcTo) {
var ar = ((ArcTo)op);
// TODO: Direct2D Arcs
//sink.AddArc (new D2D1.ArcSegment {
// Size = Conversions.ToSize2F (ar.Radius),
// Point = Conversions.ToVector2 (ar.Point),
// SweepDirection = ar.SweepClockwise ? D2D1.SweepDirection.Clockwise : D2D1.SweepDirection.CounterClockwise,
//});
sink.AddLine (Conversions.ToVector2 (ar.Point));
bb.Add (ar.Point);
}
else if (op is CurveTo) {
var ct = ((CurveTo)op);
sink.AddBezier (new D2D1.BezierSegment {
Point1 = Conversions.ToVector2 (ct.Control1),
Point2 = Conversions.ToVector2 (ct.Control2),
Point3 = Conversions.ToVector2 (ct.Point),
});
bb.Add (ct.Point);
bb.Add (ct.Control1);
bb.Add (ct.Control2);
}
else if (op is ClosePath) {
sink.EndFigure (D2D1.FigureEnd.Closed);
figureDepth--;
}
else {
// TODO: More path operations
}
}
while (figureDepth > 0) {
sink.EndFigure (D2D1.FigureEnd.Open);
figureDepth--;
}
sink.Close ();
}
var p = GetBrush (pen);
var b = GetBrush (bb.BoundingBox, brush);
if (b != null) {
renderTarget.FillGeometry (s, b);
}
if (p != null) {
renderTarget.DrawGeometry (s, p, (float)pen.Width, GetStrokeStyle (pen));
}
}
private void DrawCurves(DeviceContext target, bool isDrawArrow, float lineWidth)
{
if (_parent.LinksSource is null)
{
return;
}
var arrowSize = BaseArrowSize / (float)_parent.ScaleTransform.ScaleX;
var inflate = arrowSize;
var viewport = _parent.TransformRect(ActualWidth, ActualHeight);
var lineCullingRect = new ImmutableRect_float(
(float)viewport.X - inflate,
(float)viewport.Y - inflate,
(float)viewport.Width + inflate * 2f,
(float)viewport.Height + inflate * 2f
);
var hasHighlightCurves = false;
var borderKey = HashCodeMaker.To32(ByteColor.Black.HashCode);
if (ResourceCache.TryGetValue(borderKey, out var borderBrushObj) == false)
{
borderBrushObj = ResourceCache.Add(borderKey, t => ColorToBrushConv(t, ByteColor.Black));
}
var borderBrush = borderBrushObj as Brush;
Span <ImmutableVec2_float> bezier = stackalloc ImmutableVec2_float[4];
using var curves = new TempBuffer <(PathGeometry Geom, GeometrySink Sink, IBiaNodeLink Link)>(256);
foreach (IBiaNodeLink?link in _parent.LinksSource)
{
if (link is null)
{
continue;
}
if (link.IsVisible == false)
{
continue;
}
if (link.IsLinked() == false)
{
continue;
}
var isHighlight = link.IsHighlight();
if (isHighlight)
{
hasHighlightCurves = true;
}
// ハイライトがあれば、非ハイライトを表示しない
if (hasHighlightCurves && isHighlight == false)
{
continue;
}
link.MakeBezierCurve(bezier);
var keyBezier = MakeHashCode(bezier);
if (_boundingBoxCache.TryGetValue(keyBezier, out var bb) == false)
{
bb = BiaNodeEditorHelper.MakeBoundingBox(bezier);
_boundingBoxCache.Add(keyBezier, bb);
}
if (bb.IntersectsWith(lineCullingRect) == false)
{
continue;
}
var curveGeom = new PathGeometry(target.Factory);
var curveSink = curveGeom.Open();
curveSink.SetFillMode(FillMode.Winding);
curveSink.BeginFigure(Unsafe.As <ImmutableVec2_float, RawVector2>(ref bezier[0]), FigureBegin.Hollow);
curveSink.AddBezier(Unsafe.As <ImmutableVec2_float, BezierSegment>(ref bezier[1]));
curveSink.EndFigure(FigureEnd.Open);
if (isDrawArrow)
{
DrawArrow(curveSink, bezier, arrowSize);
}
curveSink.Close();
// ReSharper disable once PossiblyImpureMethodCallOnReadonlyVariable
curves.Add((curveGeom, curveSink, link));
}
foreach (var(geom, sink, link) in curves.Buffer)
{
var isHighlight = link.IsHighlight();
if (hasHighlightCurves == false || isHighlight)
{
var key = HashCodeMaker.Make(link.Color, isHighlight);
var resKey = HashCodeMaker.To32(key);
if (ResourceCache.TryGetValue(resKey, out var brush) == false)
{
brush = ResourceCache.Add(resKey, t => ColorToBrushConv(t, link.Color));
}
target.DrawGeometry(geom, borderBrush, lineWidth * 2f);
target.DrawGeometry(geom, brush as Brush, lineWidth);
target.FillGeometry(geom, brush as Brush);
}
sink.Dispose();
geom.Dispose();
}
}
private D2DGeometry OutlineGeometry(D2DGeometry geometry)
{
PathGeometry path = new PathGeometry(this.factory);
GeometrySink sink = path.Open();
geometry.Outline(sink);
sink.Close();
return path;
}
protected StreamGeometryImpl(PathGeometry geometry)
{
this.path = geometry;
}
//---------------------------------------------------------------------------------------------------------
/// <summary>
/// Обновление данных геометрии
/// </summary>
//---------------------------------------------------------------------------------------------------------
public override void Update()
{
XDisposer.SafeDispose(ref mD2DGeometry);
mD2DGeometry = new Direct2D.PathGeometry(XDirect2DManager.D2DFactory);
mD2DGeometrySink = mD2DGeometry.Open();
CCadSegment current_figure = mSegments[0];
mD2DGeometrySink.BeginFigure(current_figure.BasePoint.ToRawVector2(), current_figure.IsFilled ? Direct2D.FigureBegin.Filled :
Direct2D.FigureBegin.Hollow);
Int32 current_new_figure = 0;
for (Int32 i = 0; i < mSegments.Count; i++)
{
CCadSegment current_segment = mSegments[i];
// Если новая фигура
if (current_segment.IsNewFigure && current_new_figure != i)
{
// Закрывает текущую фигуру
mD2DGeometrySink.EndFigure(current_figure.IsClosed ? Direct2D.FigureEnd.Closed : Direct2D.FigureEnd.Open);
// Открываем новую фигуру
mD2DGeometrySink.BeginFigure(current_segment.BasePoint.ToRawVector2(),
current_segment.IsFilled ? Direct2D.FigureBegin.Filled : Direct2D.FigureBegin.Hollow);
current_figure = current_segment;
current_new_figure = i;
}
switch (current_segment.SegmentType)
{
case TCadSegmentType.Points:
{
CCadSegmentPoints points = current_segment as CCadSegmentPoints;
mD2DGeometrySink.AddLines(points.Points.ConvertToDirect2DRawVectors());
}
break;
case TCadSegmentType.Line:
{
CCadSegmentLine line = current_segment as CCadSegmentLine;
mD2DGeometrySink.AddLine(line.EndPoint.ToRawVector2());
}
break;
case TCadSegmentType.Arc:
{
CCadSegmentArc arc = current_segment as CCadSegmentArc;
Direct2D.ArcSegment arc_segment = new Direct2D.ArcSegment();
arc_segment.ArcSize = arc.mIsLargeArc ? Direct2D.ArcSize.Large : Direct2D.ArcSize.Small;
arc_segment.Point = arc.mEndPoint.ToRawVector2();
arc_segment.RotationAngle = arc.mRotationAngle;
arc_segment.Size = new Size2F(arc.mRadiusX, arc.mRadiusY);
arc_segment.SweepDirection = arc.mIsClockwiseDirection ? Direct2D.SweepDirection.Clockwise : Direct2D.SweepDirection.CounterClockwise;
mD2DGeometrySink.AddArc(arc_segment);
}
break;
case TCadSegmentType.Bezier:
break;
default:
break;
}
}
// Закрывает текущую фигуру
mD2DGeometrySink.EndFigure(current_figure.IsClosed ? Direct2D.FigureEnd.Closed : Direct2D.FigureEnd.Open);
mD2DGeometrySink.Close();
XDisposer.SafeDispose(ref mD2DGeometrySink);
mBoundsRect = mD2DGeometry.GetWidenedBounds(2).ToRect();
}
/// <summary>
/// Draws a path defined by an enumeration of EdgeStyleData structures</summary>
/// <param name="path">The enumeration of drawing primitives that describes the contents of the path</param>
/// <param name="brush">The brush used to paint the path's stroke</param>
/// <param name="strokeWidth">A value greater than or equal to 0.0f that specifies the width of the stroke</param>
/// <remarks>Assume the end point of one primitive be coincident with the start point of the following primitive in a path</remarks>
/// <param name="strokeStyle">The style of the rounded rectangle's stroke, or null to paint a solid stroke</param>
public void DrawPath(IEnumerable<EdgeStyleData> path, D2dBrush brush, float strokeWidth = 1.0f, D2dStrokeStyle strokeStyle = null)
{
using (var geom = new PathGeometry(D2dFactory.NativeFactory))
{
var sink = geom.Open();
var firstPoint = true;
foreach (var edge in path)
{
if (edge.ShapeType == EdgeStyleData.EdgeShape.Line)
{
var line = edge.EdgeData.As<PointF[]>();
if (firstPoint)
{
sink.BeginFigure(line[0].ToSharpDX(), FigureBegin.Hollow);
firstPoint = false;
}
for (var i = 1; i < line.Length; ++i)
sink.AddLine(line[i].ToSharpDX());
}
else if (edge.ShapeType == EdgeStyleData.EdgeShape.Bezier)
{
var curve = edge.EdgeData.As<BezierCurve2F>();
if (firstPoint)
{
sink.BeginFigure(curve.P1.ToSharpDX(), FigureBegin.Hollow);
firstPoint = false;
}
var seg = new BezierSegment
{
Point1 = curve.P2.ToSharpDX(),
Point2 = curve.P3.ToSharpDX(),
Point3 = curve.P4.ToSharpDX()
};
sink.AddBezier(seg);
}
}
sink.EndFigure(FigureEnd.Open);
sink.Close();
sink.Dispose();
m_renderTarget.DrawGeometry(geom, brush.NativeBrush, strokeWidth,
strokeStyle != null ? strokeStyle.NativeStrokeStyle : null);
}
}
public static void Draw2D(Renderer renderer)
{
if (!DrawDebug)
{
return;
}
Profiler.Begin("Debug 2d Draw");
renderer.Consolas14.TextAlignment = DWrite.TextAlignment.Leading;
renderer.Consolas14.ParagraphAlignment = DWrite.ParagraphAlignment.Center;
float line = 1;
renderer.D2DContext.DrawText(
string.Format("{0} triangles, {1} nodes, {2} trees/{3} imposters [{4} waiting / {5} generating]",
TrianglesDrawn.ToString("N0"), NodesDrawn.ToString("N0"), TreesDrawn.ToString("N0"), ImposterDrawn.ToString("N0"), QuadNode.GenerateQueue.Count, QuadNode.Generating.Count),
renderer.Consolas14, new RawRectangleF(10, renderer.Viewport.Height - line * 25, 300, renderer.Viewport.Height - (line - 1) * 25), renderer.Brushes["White"]);
line++;
renderer.D2DContext.DrawText(
string.Format("[{0}, {1}]",
Planet.min, Planet.max),
renderer.Consolas14, new RawRectangleF(10, renderer.Viewport.Height - line * 25, 300, renderer.Viewport.Height - (line - 1) * 25), renderer.Brushes["White"]);
line++;
#region logs
renderer.Consolas14.TextAlignment = DWrite.TextAlignment.Leading;
renderer.Consolas14.WordWrapping = DWrite.WordWrapping.NoWrap;
renderer.Consolas14.ParagraphAlignment = DWrite.ParagraphAlignment.Center;
float lh = 10;
float ly = 10;
for (int i = 0; i < logs.Count; i++)
{
renderer.D2DContext.DrawText(logs[i].ToString(), renderer.Consolas14,
new RawRectangleF(7, ly - 3, 7 + 200, ly - 3 + lh), renderer.Brushes["White"]);
ly += lh + 5;
}
ly = renderer.ResolutionY - 10 - lh;
foreach (KeyValuePair <string, string> l in tracks)
{
renderer.D2DContext.DrawText(l.Value, renderer.Consolas14,
new RawRectangleF(renderer.ResolutionX * .75f - 200 - 3, ly - 3, renderer.ResolutionX * .75f + 200 + 3, ly + lh + 3),
renderer.Brushes["White"]);
ly -= lh + 5;
}
ly = renderer.ResolutionY - 10 - lh;
foreach (KeyValuePair <string, string> l in immediateTrack)
{
renderer.D2DContext.DrawText(l.Value, renderer.Consolas14,
new RawRectangleF(renderer.ResolutionX * .75f - 200 - 3 - 50, ly - 3, renderer.ResolutionX * .75f + 200 + 3 - 50, ly + lh + 3),
renderer.Brushes["White"]);
ly -= lh + 5;
}
#endregion
#region graph
float min = frameGraph[0].FrameTimeMS;
float max = frameGraph[0].FrameTimeMS;
for (int i = 0; i < frameGraph.Count; i++)
{
min = Math.Min(min, frameGraph[i].FrameTimeMS);
max = Math.Max(max, frameGraph[i].FrameTimeMS);
}
float step = Math.Max((int)((max - min) / 10 / .5f) * .5f, .5f);
min = (int)Math.Floor(min / step) * step;
max = (int)Math.Ceiling(max / step) * step;
RawRectangleF grect = new RawRectangleF(renderer.ResolutionX - 360, 10, renderer.ResolutionX - 10, 360);
float xScale = (grect.Right - grect.Left - 30) / frameGraphSize;
float ppf = (grect.Bottom - grect.Top - 20) / (max - min); // pixels per ms
RawVector2[] pts = new RawVector2[frameGraph.Count];
List <RawVector2> marks = new List <RawVector2>();
for (int i = 0; i < frameGraph.Count; i++)
{
pts[i] = new RawVector2(grect.Left + 30 + i * xScale, MathUtil.Clamp(grect.Bottom - 20 - (frameGraph[i].FrameTimeMS - min) * ppf, grect.Top, grect.Bottom - 20));
}
D2D1.PathGeometry graphline = new D2D1.PathGeometry(renderer.D2DFactory);
D2D1.GeometrySink graphsink = graphline.Open();
graphsink.SetFillMode(D2D1.FillMode.Winding);
graphsink.BeginFigure(pts[0], D2D1.FigureBegin.Hollow);
graphsink.AddLines(pts);
graphsink.EndFigure(D2D1.FigureEnd.Open);
graphsink.Close();
renderer.D2DContext.FillRectangle(grect, renderer.Brushes["TransparentBlack"]);
renderer.D2DContext.DrawLine( // y axis
new RawVector2(grect.Left + 30, grect.Bottom - (max - min) * ppf - 20),
new RawVector2(grect.Left + 30, grect.Bottom - 20), renderer.Brushes["White"], 2);
renderer.D2DContext.DrawLine(
new RawVector2(grect.Left + 30, grect.Bottom - 20),
new RawVector2(grect.Right, grect.Bottom - 20), renderer.Brushes["White"], 2); // x axis
renderer.Consolas14.TextAlignment = DWrite.TextAlignment.Trailing;
renderer.Consolas14.ParagraphAlignment = DWrite.ParagraphAlignment.Center;
for (float ms = min; ms <= max; ms += step)
{
float y = grect.Bottom - 20 - (ms - min) * ppf;
// y axis numbers
if (ms.ToString().Length <= 3)
{
renderer.D2DContext.DrawText(ms.ToString(), renderer.Consolas14,
new RawRectangleF(grect.Left, y, grect.Left + 25, y), renderer.Brushes["White"]);
}
if (ms > min)
{
renderer.D2DContext.DrawLine(new RawVector2(grect.Left + 28, y), new RawVector2(grect.Right, y), renderer.Brushes["White"], .25f);
}
}
renderer.D2DContext.DrawGeometry(graphline, renderer.Brushes["CornflowerBlue"]); // graph line
// x axis label
renderer.Consolas14.TextAlignment = DWrite.TextAlignment.Trailing;
renderer.Consolas14.ParagraphAlignment = DWrite.ParagraphAlignment.Far;
renderer.D2DContext.DrawText(frameGraphSize + " frames", renderer.Consolas14,
new RawRectangleF(grect.Right, grect.Bottom, grect.Right, grect.Bottom), renderer.Brushes["White"]);
// y axis label
renderer.Consolas14.TextAlignment = DWrite.TextAlignment.Center;
renderer.Consolas14.ParagraphAlignment = DWrite.ParagraphAlignment.Near;
renderer.D2DContext.DrawText("Draw+Update Time (ms)", renderer.Consolas14, // y axis label
new RawRectangleF(grect.Left + 30, grect.Top, grect.Right, grect.Top), renderer.Brushes["White"]);
#endregion
Profiler.End();
}
public void Render2D(RenderTarget renderTarget, Brush brush)
{
#region Update Color Brush
// if the brush is dirty renew it
if (m_isLineColorBrushDirty && !m_useDefaultColor)
{
// clean the color brush
if (m_lineColorBrush != null)
m_lineColorBrush.Dispose();
// allocate a new one
m_lineColorBrush = new SolidColorBrush(renderTarget, m_lineColor);
// clean the flag
m_isLineColorBrushDirty = false;
}
#endregion
if (m_path.Count > 0)
{
// Update geometry
if (isGeometryDirty)
{
if (m_sharpGeometry != null)
m_sharpGeometry.Dispose();
m_sharpGeometry = new PathGeometry(renderTarget.Factory);
using (GeometrySink Geo_Sink = m_sharpGeometry.Open())
{
int count = m_path.Count;
// create the path
Geo_Sink.BeginFigure(m_path[0].GetVector2(), FigureBegin.Filled);
for (int i = 1; i < count; i++)
{
Geo_Sink.AddLine(m_path[i].GetVector2());
}
Geo_Sink.EndFigure(FigureEnd.Open);
Geo_Sink.Close();
}
isGeometryDirty = false;
}
// check if we use other color
if (m_useDefaultColor || m_lineColorBrush == null)
{
renderTarget.DrawGeometry(m_sharpGeometry, brush, m_lineWidth);
}
else
{
renderTarget.DrawGeometry(m_sharpGeometry, m_lineColorBrush, m_lineWidth);
}
}
}
private static D2D1.Geometry CreateGeometryInternal(D2D1.RenderTarget target, FontManager fontManager, IElement element, IFrameContext context, ClipPathUnits clipPathUnits, IElement targetElement)
{
if (clipPathUnits == ClipPathUnits.UserSpaceOnUse)
{
switch (element.ElementType)
{
case "rect":
return(new D2D1.RectangleGeometry(target.Factory, element.GetBounds(context).ToDx()));
case "circle":
var r = element.GetRadius(context);
return(new D2D1.EllipseGeometry(target.Factory, new D2D1.Ellipse()
{
Point = element.GetCxCy(context).ToDx(),
RadiusX = r,
RadiusY = r
}));
case "path":
return(PathBuilder.Create(target, element.GetPath(), D2D1.FillMode.Alternate));
case "text":
var geom = new D2D1.PathGeometry(target.Factory);
using (var sink = geom.Open())
{
var font = element.GetFont(context);
var fontFace = fontManager.GetFontFace(font);
var glyphIndices = fontFace.GetGlyphIndices("Clip Test");
var xx = new[] { 35f, 50f, 55f, 65f, 45f, 48f, 52f, 32f, 61f };
fontFace.GetGlyphRunOutline(
font.Size,
glyphIndices,
xx,
null,
glyphIndices.Length,
false,
false,
sink);
sink.Close();
return(new D2D1.TransformedGeometry(
target.Factory,
geom,
Matrix3x2.Translation(0, font.Size)
));
//return geom;
}
default:
return(null);
}
}
else
{
var targetBounds = GetBounds(targetElement, context);
switch (element.ElementType)
{
case "rect":
var rectBounds = element.GetBounds(context);
var w = targetBounds.Width * rectBounds.Width;
var h = targetBounds.Height * rectBounds.Height;
var x = targetBounds.X + (targetBounds.Width * rectBounds.X);
var y = targetBounds.Y + (targetBounds.Height * rectBounds.Y);
return(new D2D1.RectangleGeometry(
target.Factory,
new RawRectangleF(x, y, x + w, y + h)
));
case "circle":
var r = element.GetRadius(context);
var cxCy = element.GetCxCy(context);
return(new D2D1.EllipseGeometry(target.Factory, new D2D1.Ellipse()
{
Point = new RawVector2(targetBounds.X + (cxCy.X * targetBounds.Width), targetBounds.Y + (cxCy.Y * targetBounds.Height)),
RadiusX = r * targetBounds.Width,
RadiusY = r * targetBounds.Width
}));
case "path":
return(PathBuilder.Create(target, element.GetPath(), D2D1.FillMode.Alternate));
default:
return(null);
}
}
}
/// <summary>
/// Draws a polygon defined by an array of PointF structures</summary>
/// <param name="points">Array of System.Drawing.PointF structures
/// that represent the vertices of the polygon</param>
/// <param name="brush">The brush used to paint the polygon's stroke</param>
/// <param name="strokeWidth">A value greater than or equal to 0.0f that specifies the width of the stroke</param>
/// <param name="strokeStyle">The style of stroke to paint, or NULL to paint a solid line</param>
public void DrawPolygon(IEnumerable<PointF> points, D2dBrush brush, float strokeWidth = 1.0f, D2dStrokeStyle strokeStyle = null)
{
var iter = points.GetEnumerator();
if (!iter.MoveNext()) return;
using (var geom = new PathGeometry(D2dFactory.NativeFactory))
{
var sink = geom.Open();
var pt1 = iter.Current;
sink.BeginFigure(pt1.ToSharpDX(), FigureBegin.Hollow);
while (iter.MoveNext())
{
sink.AddLine(iter.Current.ToSharpDX());
}
sink.EndFigure(FigureEnd.Closed);
sink.Close();
sink.Dispose();
m_renderTarget.DrawGeometry(geom, brush.NativeBrush, strokeWidth,
strokeStyle != null ? strokeStyle.NativeStrokeStyle : null);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="PolygonGeometryResource"/> class.
/// </summary>
public PolygonGeometryResource()
{
m_d2dGeometry = new D2D.PathGeometry(
GraphicsCore.Current.FactoryD2D);
}
/// <summary>
/// Fills the interior of a polygon defined by given points</summary>
/// <param name="points">Array of PointF structures that represent the vertices of
/// the polygon to fill</param>
/// <param name="brush">Brush that determines the characteristics of the fill</param>
public void FillPolygon(IEnumerable<PointF> points, D2dBrush brush)
{
var iter = points.GetEnumerator();
if (!iter.MoveNext()) return;
using (var geom = new PathGeometry(D2dFactory.NativeFactory))
{
var sink = geom.Open();
var pt1 = iter.Current;
sink.BeginFigure(pt1.ToSharpDX(), FigureBegin.Filled);
while (iter.MoveNext())
{
sink.AddLine(iter.Current.ToSharpDX());
}
sink.EndFigure(FigureEnd.Closed);
sink.Close();
sink.Dispose();
m_renderTarget.FillGeometry(geom, brush.NativeBrush);
}
}
static void Main(string[] args)
{
XmlDocument doc = new XmlDocument();
doc.Load(@"c:\users\ken\desktop\drawing.svg");
XmlNamespaceManager nsmgr = new XmlNamespaceManager(doc.NameTable);
nsmgr.AddNamespace("svg", "http://www.w3.org/2000/svg");
XmlNodeList selection = doc.SelectNodes("//svg:path", nsmgr);
Factory factory = new Factory(FactoryType.SingleThreaded);
PathGeometry pathGeometry = new PathGeometry(factory);
GeometrySink sink = pathGeometry.Open();
sink.SetSegmentFlags(PathSegment.ForceRoundLineJoin);
sink.SetFillMode(FillMode.Winding);
PointF currentPoint = new PointF(0, 0);
foreach (XmlNode n in selection)
{
XmlAttribute attribute = n.Attributes["d"];
string d = attribute.Value;
string[] data = d.Split(' ');
Command command = Command.MoveTo;
PointF relativePoint = currentPoint;
bool isBegun = false;
FigureEnd figureEndStyle = FigureEnd.Open;
for (int i = 0; i < data.Length; i++)
{
string arg = data[i];
switch (arg.ToUpper())
{
case "M":
command = Command.MoveTo;
relativePoint = arg.ToUpper() == arg ? new PointF(0, 0) : currentPoint;
break;
case "C":
command = Command.CurveTo;
relativePoint = arg.ToUpper() == arg ? new PointF(0, 0) : currentPoint;
break;
case "L":
command = Command.LineTo;
relativePoint = arg.ToUpper() == arg ? new PointF(0, 0) : currentPoint;
break;
case "V":
case "H":
break;
case "Z":
figureEndStyle = FigureEnd.Closed;
break;
default:
currentPoint = CoordinateToPointF(arg, relativePoint);
switch (command)
{
case Command.MoveTo:
if (isBegun)
{
sink.EndFigure(figureEndStyle);
}
sink.BeginFigure(currentPoint, FigureBegin.Filled);
isBegun = true;
break;
case Command.LineTo:
sink.AddLine(currentPoint);
break;
case Command.CurveTo:
BezierSegment bezier = new BezierSegment();
bezier.Point1 = currentPoint;
bezier.Point2 = CoordinateToPointF(data[i + 1], relativePoint);
bezier.Point3 = CoordinateToPointF(data[i + 2], relativePoint);
i += 2;
sink.AddBezier(bezier);
break;
}
break;
}
}
sink.EndFigure(figureEndStyle);
sink.Close();
var pathGeometryNew = new PathGeometry(factory);
var newSink = pathGeometryNew.Open();
pathGeometry.Widen(4, newSink);
newSink.Close();
// Now do Tessellation
using (FileStream fs = File.OpenWrite(@"c:\Users\ken\desktop\my.triangles"))
{
MyTessellationSink tessellationSink = new MyTessellationSink(fs);
var result = pathGeometryNew.Tessellate(tessellationSink);
}
}
Console.ReadKey();
}
public GraphicsPathHandler()
{
this.Control = new sd.PathGeometry(SDFactory.Instance);
this.sink = this.Control.Open();
}
public void Clear(SolidBrush brush)
{
if (Control != null)
{
var color = brush != null ? brush.Color : Colors.Transparent;
// drawing to an image, so we can clear to transparent
if (image != null)
{
if (clipParams != null)
{
// can't clear the current layer otherwise it will not be applied to main layer
// This creates a copy of the current context, inverses the current clip, and draws the image back clipping
// the cleared path.
// end clip layer and current drawing session
Control.PopLayer();
Control.EndDraw();
// create a copy of the current state
var copy = image.Clone();
var bmp = copy.ToDx(Control);
Control.BeginDraw();
// clear existing contents
Control.Clear(null);
var size = Control.Size;
// create an inverse geometry
var inverse = new sd.PathGeometry(SDFactory.D2D1Factory);
var sink = inverse.Open();
var bounds = new s.RectangleF(0, 0, size.Width, size.Height);
var geom = new sd.RectangleGeometry(SDFactory.D2D1Factory, bounds);
geom.Combine(clipGeometry, sd.CombineMode.Exclude, sink);
sink.Close();
// create a new mask layer with inverse geometry
var parameters = new sd.LayerParameters
{
ContentBounds = bounds,
GeometricMask = inverse,
MaskAntialiasMode = Control.AntialiasMode,
MaskTransform = s.Matrix3x2.Identity,
Opacity = 1f
};
Control.PushLayer(ref parameters, HelperLayer);
// draw bitmap of contents back, clipping to the inverse of the clip region
Control.DrawBitmap(bmp, 1f, sd.BitmapInterpolationMode.NearestNeighbor);
Control.PopLayer();
// restore our clip path
parameters = clipParams.Value;
Control.PushLayer(ref parameters, HelperLayer);
copy.Dispose();
}
}
else
{
// alpha is not supported on a drawable, so blend with black as the base color.
color = Color.Blend(Colors.Black, color);
}
Control.Clear(color.ToDx());
}
}
public StreamGeometryImpl()
{
Factory factory = Locator.Current.GetService<Factory>();
this.path = new PathGeometry(factory);
}
void IGeometrySink.Begin()
{
Contract.Assert(_Path == null);
_Path = new PathGeometry(_Factory2D);
_IsSinkInFigure = false;
Contract.Assert(_PathSink == null);
_PathSink = _Path.Open();
}
public override void OnRender(ChartControl chartControl, ChartScale chartScale, ChartBars chartBars)
{
Bars bars = chartBars.Bars;
if (chartBars.FromIndex > 0)
{
chartBars.FromIndex--;
}
SharpDX.Direct2D1.PathGeometry lineGeometry = new SharpDX.Direct2D1.PathGeometry(Core.Globals.D2DFactory);
AntialiasMode oldAliasMode = RenderTarget.AntialiasMode;
GeometrySink sink = lineGeometry.Open();
sink.BeginFigure(new Vector2(chartControl.GetXByBarIndex(chartBars, chartBars.FromIndex > -1 ? chartBars.FromIndex : 0), chartScale.GetYByValue(bars.GetClose(chartBars.FromIndex > -1 ? chartBars.FromIndex : 0))), FigureBegin.Filled);
for (int idx = chartBars.FromIndex + 1; idx <= chartBars.ToIndex; idx++)
{
double closeValue = bars.GetClose(idx);
float close = chartScale.GetYByValue(closeValue);
float x = chartControl.GetXByBarIndex(chartBars, idx);
sink.AddLine(new Vector2(x, close));
}
sink.EndFigure(FigureEnd.Open);
sink.Close();
RenderTarget.AntialiasMode = AntialiasMode.PerPrimitive;
RenderTarget.DrawGeometry(lineGeometry, UpBrushDX, (float)Math.Max(1, chartBars.Properties.ChartStyle.BarWidth));
lineGeometry.Dispose();
SharpDX.Direct2D1.SolidColorBrush fillOutline = new SharpDX.Direct2D1.SolidColorBrush(RenderTarget, SharpDX.Color.Transparent);
SharpDX.Direct2D1.PathGeometry fillGeometry = new SharpDX.Direct2D1.PathGeometry(Core.Globals.D2DFactory);
GeometrySink fillSink = fillGeometry.Open();
fillSink.BeginFigure(new Vector2(chartControl.GetXByBarIndex(chartBars, chartBars.FromIndex > -1 ? chartBars.FromIndex : 0), chartScale.GetYByValue(chartScale.MinValue)), FigureBegin.Filled);
float fillx = float.NaN;
for (int idx = chartBars.FromIndex; idx <= chartBars.ToIndex; idx++)
{
double closeValue = bars.GetClose(idx);
float close = chartScale.GetYByValue(closeValue);
fillx = chartControl.GetXByBarIndex(chartBars, idx);
fillSink.AddLine(new Vector2(fillx, close));
}
if (!double.IsNaN(fillx))
{
fillSink.AddLine(new Vector2(fillx, chartScale.GetYByValue(chartScale.MinValue)));
}
fillSink.EndFigure(FigureEnd.Open);
fillSink.Close();
DownBrushDX.Opacity = Opacity / 100f;
if (!(DownBrushDX is SharpDX.Direct2D1.SolidColorBrush))
{
TransformBrush(DownBrushDX, new RectangleF(0, 0, (float)chartScale.Width, (float)chartScale.Height));
}
RenderTarget.FillGeometry(fillGeometry, DownBrushDX);
RenderTarget.DrawGeometry(fillGeometry, fillOutline, (float)chartBars.Properties.ChartStyle.BarWidth);
fillOutline.Dispose();
RenderTarget.AntialiasMode = oldAliasMode;
fillGeometry.Dispose();
}
public void DrawPath(IEnumerable <PathOp> ops, Pen pen = null, Brush brush = null)
{
var bb = new BoundingBoxBuilder();
var s = new D2D1.PathGeometry(factories.D2DFactory);
var figureDepth = 0;
using (var sink = s.Open()) {
foreach (var op in ops)
{
if (op is MoveTo)
{
while (figureDepth > 0)
{
sink.EndFigure(D2D1.FigureEnd.Open);
figureDepth--;
}
var mt = ((MoveTo)op);
sink.BeginFigure(Conversions.ToVector2(mt.Point), D2D1.FigureBegin.Filled);
figureDepth++;
bb.Add(mt.Point);
}
else if (op is LineTo)
{
var lt = ((LineTo)op);
sink.AddLine(Conversions.ToVector2(lt.Point));
bb.Add(lt.Point);
}
else if (op is ArcTo)
{
var ar = ((ArcTo)op);
// TODO: Direct2D Arcs
//sink.AddArc (new D2D1.ArcSegment {
// Size = Conversions.ToSize2F (ar.Radius),
// Point = Conversions.ToVector2 (ar.Point),
// SweepDirection = ar.SweepClockwise ? D2D1.SweepDirection.Clockwise : D2D1.SweepDirection.CounterClockwise,
//});
sink.AddLine(Conversions.ToVector2(ar.Point));
bb.Add(ar.Point);
}
else if (op is CurveTo)
{
var ct = ((CurveTo)op);
sink.AddBezier(new D2D1.BezierSegment {
Point1 = Conversions.ToVector2(ct.Control1),
Point2 = Conversions.ToVector2(ct.Control2),
Point3 = Conversions.ToVector2(ct.Point),
});
bb.Add(ct.Point);
bb.Add(ct.Control1);
bb.Add(ct.Control2);
}
else if (op is ClosePath)
{
sink.EndFigure(D2D1.FigureEnd.Closed);
figureDepth--;
}
else
{
// TODO: More path operations
}
}
while (figureDepth > 0)
{
sink.EndFigure(D2D1.FigureEnd.Open);
figureDepth--;
}
sink.Close();
}
var p = GetBrush(pen);
var b = GetBrush(bb.BoundingBox, brush);
if (b != null)
{
renderTarget.FillGeometry(s, b);
}
if (p != null)
{
renderTarget.DrawGeometry(s, p, (float)pen.Width, GetStrokeStyle(pen));
}
}
/// <summary>
/// render the circle to specific render target of Direct2D1
/// </summary>
/// <param name="renderTarget"></param>
public void Render2D(RenderTarget renderTarget, SharpDX.Direct2D1.Brush brush)
{
// check if the geometry is dirty
if (isGeometryDirty)
{
// dispose the old geometry
if (TriangleGeometry != null)
{
TriangleGeometry.Dispose();
}
// create a new one
TriangleGeometry = new PathGeometry(renderTarget.Factory);
// fill the geometry struct
using (GeometrySink Geo_Sink = TriangleGeometry.Open())
{
// create the figure
Geo_Sink.BeginFigure(mp_P1, FigureBegin.Filled);
Geo_Sink.AddLine(mp_P2);
Geo_Sink.AddLine(mp_P3);
Geo_Sink.EndFigure(FigureEnd.Closed);
// close the mesh
Geo_Sink.Close();
}
// set the geometry that is the final
isGeometryDirty = false;
}
// draw the wireframe of the triangle
renderTarget.DrawGeometry(TriangleGeometry, brush, _LineWidth);
if (fillTheTriangle)
{
// check if we must renew the brush
if (fillColorDirty)
{
// dispose the old brush
if (fillColorBrush != null)
fillColorBrush.Dispose();
// create the new one
fillColorBrush = new SolidColorBrush(renderTarget, fillColor);
// set that the color is the correct
fillColorDirty = false;
}
// fill the triangle
renderTarget.FillGeometry(TriangleGeometry, fillColorBrush);
}
}
/// <summary>
/// Constructor, creating PathGeometry object</summary>
public D2dGeometry()
{
m_geometry = new PathGeometry(D2dFactory.NativeFactory);
}
