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); }