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();
sink.Dispose();
this.AddGeometry(tg);
return(Result.Ok);
}
private void RenderingDrawMultiLine(List <float[]> points, int[] color, int thickness, bool drawWorldMap)
{
RawVector2[] pts = new RawVector2[points.Count + 1];
for (int i = 0; i < points.Count; i++)
{
int[] screen;
Helpers.ViewTransform.ToScreen.WorldToScreen(points[i], out screen, drawWorldMap);
pts[i] = new RawVector2(screen[0], screen[1]);
}
pts[pts.Length - 1] = pts[0];
pathGeometry = new PathGeometry(factory);
geometrySink = pathGeometry.Open();
geometrySink.BeginFigure(pts[0], new FigureBegin());
geometrySink.AddLines(pts);
geometrySink.EndFigure(new FigureEnd());
geometrySink.Close();
ChangeColor(color);
device.DrawGeometry(pathGeometry, solidColorBrush);
pathGeometry.Dispose();
geometrySink.Dispose();
}
protected override void SetSink(GeometrySink sink)
{
sink.SetFillMode(FillMode.Winding);
sink.BeginFigure(new RawVector2(-35, 85), FigureBegin.Filled);
sink.AddLine(new RawVector2(60, 85));
sink.AddBezier(new BezierSegment {
Point3 = new RawVector2(72, 58), Point1 = new RawVector2(80, 85), Point2 = new RawVector2(82, 58)
});
sink.AddBezier(new BezierSegment {
Point3 = new RawVector2(85, 30), Point1 = new RawVector2(100, 58), Point2 = new RawVector2(95, 30)
});
sink.AddBezier(new BezierSegment {
Point3 = new RawVector2(90, -5), Point1 = new RawVector2(115, 30), Point2 = new RawVector2(115, -5)
});
sink.AddBezier(new BezierSegment {
Point3 = new RawVector2(85, -39), Point1 = new RawVector2(110, -5), Point2 = new RawVector2(105, -39)
});
sink.AddLine(new RawVector2(25, -39));
sink.AddBezier(new BezierSegment {
Point3 = new RawVector2(-10, -98), Point1 = new RawVector2(35, -105), Point2 = new RawVector2(0, -105)
});
sink.AddLine(new RawVector2(-10, -60));
sink.AddLine(new RawVector2(-35, -16));
sink.EndFigure(FigureEnd.Closed);
sink.BeginFigure(new RawVector2(-90, 100), FigureBegin.Filled);
sink.AddLine(new RawVector2(-48, 100));
sink.AddLine(new RawVector2(-48, -20));
sink.AddLine(new RawVector2(-90, -20));
sink.EndFigure(FigureEnd.Closed);
}
private void drawUGlyph(float wingLength, float x, float y, float lat, float lng, float width, Brush brush)
{
float rotationAngle = (float)Math.Atan((lng - lat) / width) * div;
//rotationAngle += rotationAngle < 0 ? 90f : 45f;
this.RenderTarget.Transform = Matrix3x2F.Rotation(rotationAngle, new D2D.Point2F(x, y));
float hw = WINGLENGTH / 2;
PathGeometry pLinesGeometry = this.Factory.CreatePathGeometry();
GeometrySink gs = pLinesGeometry.Open();
gs.SetFillMode(FillMode.Winding);
gs.BeginFigure(new D2D.Point2F(x, y), FigureBegin.Filled);
gs.AddLine(new D2D.Point2F(x + hw, y + hw));
gs.AddLine(new D2D.Point2F(x + hw, y - wingLength));
gs.AddLine(new D2D.Point2F(x, y));
gs.AddLine(new D2D.Point2F(x - hw, y + hw));
gs.AddLine(new D2D.Point2F(x - hw, y - wingLength));
gs.EndFigure(FigureEnd.Closed);
gs.Close();
brush.Opacity = 0.2f;
this.RenderTarget.FillGeometry(pLinesGeometry, brush);
brush.Opacity = 0.8f;
this.RenderTarget.DrawGeometry(pLinesGeometry, brush, 0.8f);
//this.RenderTarget.DrawRectangle(new D2D.RectF(x - RECTSIZE, y - RECTSIZE, x + RECTSIZE, y + RECTSIZE), brush, 0.8f);
this.RenderTarget.Transform = Matrix3x2F.Identity;
}
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();
}
/// <summary>
/// Draw polygon on layer with layerIndex Index.
/// </summary>
/// <param name="layerIndex"></param>
/// <param name="points"></param>
/// <param name="borderColor"></param>
/// <param name="fillColor"></param>
/// <param name="opacity"></param>
/// <param name="fillPattern"></param>
/// <param name="patternSize"></param>
public void Draw(int layerIndex, System.Drawing.PointF[] points, System.Drawing.Color?borderColor, System.Drawing.Color?fillColor, float opacity, xPFT.Charting.Base.FillPattern fillPattern, float patternSize)
{
if (layerIndex < device.layers.Count)
{
var tmpGeo = new PathGeometry(device.factory);
GeometrySink sink1 = tmpGeo.Open();
Vector2[] tmpPointList = DrawingBase.Convertor.ToVector2(points);
sink1.BeginFigure(tmpPointList[0], new FigureBegin());
sink1.AddLines(tmpPointList);
sink1.EndFigure(new FigureEnd());
sink1.Close();
if (fillColor != null)
{
if (device.renderTarget != prevRenderTarget || fillColor != prevFillColor || fillPattern != prevFillPattern || opacity != prevOpacity)
{
fillBrush = BrushMaker.GetPatternBrush(device.renderTarget, (System.Drawing.Color)fillColor, opacity, fillPattern, patternSize);
prevFillColor = (System.Drawing.Color)fillColor;
prevFillPattern = fillPattern;
prevOpacity = opacity;
prevRenderTarget = device.renderTarget;
}
device.layers[layerIndex].FillGeometry(tmpGeo, fillBrush);
}
if (borderColor != null)
{
device.layers[layerIndex].DrawGeometry(tmpGeo, new SharpDX.Direct2D1.SolidColorBrush(device.renderTarget, xPFT.DrawingBase.Convertor.ColorConvertor((System.Drawing.Color)borderColor, opacity)), lineWidth);
}
}
}
public override Result DrawUnderline(object clientDrawingContext, float baselineOriginX, float baselineOriginY, ref Underline underline, ComObject clientDrawingEffect)
{
using (PathGeometry pg = new PathGeometry(this.factory))
{
using (GeometrySink sink = pg.Open())
{
Vector2 topLeft = new Vector2(0.0f, underline.Offset);
sink.BeginFigure(topLeft, FigureBegin.Filled);
topLeft.X += underline.Width;
sink.AddLine(topLeft);
topLeft.Y += underline.Thickness;
sink.AddLine(topLeft);
topLeft.X -= underline.Width;
sink.AddLine(topLeft);
sink.EndFigure(FigureEnd.Closed);
sink.Close();
Matrix3x2 mat = Matrix3x2.Translation(baselineOriginX, baselineOriginY) * Matrix3x2.Scaling(1.0f, -1.0f);
TransformedGeometry tg = new TransformedGeometry(this.factory, pg, *(RawMat *)&mat);
this.AddGeometry(tg);
return(Result.Ok);
}
}
}
private static void DrawRestDotPart(RenderTarget renderTarget, RawVector2 pos, Color color)
{
PointF[] pathPoints;
using (GraphicsPath path = new GraphicsPath())
{
path.AddBezier(pos.X, pos.Y + 3f, pos.X - 2f, pos.Y + 6f, pos.X - 8f, pos.Y + 8f, pos.X - 12f, pos.Y + 2f);
path.AddBezier((float)(pos.X - 12f), (float)(pos.Y + 2f), (float)(pos.X - 8f), (float)(pos.Y + 6.5f), (float)(pos.X - 2f), (float)(pos.Y + 5f), (float)(pos.X + 1f), (float)(pos.Y - 1f));
path.Flatten();
pathPoints = path.PathPoints;
path.Dispose();
}
using (SharpDX.Direct2D1.Factory factory = renderTarget.Factory)
{
PathGeometry geometry = new PathGeometry(factory);
if (pathPoints.Length > 1)
{
GeometrySink sink = geometry.Open();
sink.SetSegmentFlags(PathSegment.ForceRoundLineJoin);
sink.BeginFigure(new RawVector2(pathPoints[0].X, pathPoints[0].Y), FigureBegin.Filled);
for (int i = 1; i < pathPoints.Length; i++)
{
sink.AddLine(new RawVector2(pathPoints[i].X, pathPoints[i].Y));
}
sink.EndFigure(FigureEnd.Closed);
sink.Close();
sink.Dispose();
}
SolidColorBrush brush = new SolidColorBrush(renderTarget, color.ToRawColor4(1f));
renderTarget.FillGeometry(geometry, brush);
brush.Dispose();
geometry.Dispose();
}
renderTarget.FillCircle(new RawVector2(pos.X - 8f, pos.Y + 2f), 3f, color);
}
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);
PointF p0 = new PointF(xCanvas, yCanvas);
sink.BeginFigure(p0, FigureBegin.Hollow);
for (int i = 1; i < x.Length; ++i)
{
if (includeLinePoint[i])
{
xCanvas = (float)(xTransformed[i] * xScale + xOffset);
yCanvas = (float)(yTransformed[i] * yScale + yOffset);
sink.AddLine(new PointF(xCanvas, yCanvas));
}
}
sink.EndFigure(FigureEnd.Open);
sink.Close();
}
return(geometry);
}
public void DrawGlyphRun(float baselineOriginX, float baselineOriginY, Graphics.Direct2D.MeasuringMode measuringMode, GlyphRun glyphRun, GlyphRunDescription glyphRunDescription, ClientDrawingEffect clientDrawingEffect)
{
using (PathGeometry pathGeometry = _factory.CreatePathGeometry())
{
using (GeometrySink sink = pathGeometry.Open())
{
glyphRun.FontFace.GetGlyphRunOutline(
glyphRun.EmSize,
glyphRun.GlyphIndices,
glyphRun.GlyphAdvances,
glyphRun.GlyphOffsets,
glyphRun.IsSideways,
glyphRun.BidiLevel != 0,
sink);
sink.Close();
}
CustomGeometrySink customSink = new CustomGeometrySink();
pathGeometry.Stream(customSink);
customSink.Close();
System.Diagnostics.Debug.WriteLine(customSink.ToString());
Matrix3x2 matrix = new Matrix3x2(1, 0, 0, 1, baselineOriginX, baselineOriginY);
using (TransformedGeometry transformedGeometry = _factory.CreateTransformedGeometry(pathGeometry, matrix))
{
_renderTarget.DrawGeometry(_outlineBrush, 5, transformedGeometry);
_renderTarget.FillGeometry(_fillBrush, transformedGeometry);
}
}
}
protected void CalculateGeometry(Factory d2dFactory, System.Windows.Rect rect)
{
Func <bool, bool, System.Windows.Media.Color, GeometryGroup> buildGeometry = (isFilled, isOk, color) => {
List <Geometry> geometry = new List <Geometry>();
if (isOk && Points.Count > 0 && color != System.Windows.Media.Colors.Transparent)
{
var childGeometry = new PathGeometry(d2dFactory);
using (GeometrySink ctx = childGeometry.Open()) {
for (int pointIndex = 0; pointIndex < Points.Count; pointIndex += 2)
{
ctx.BeginFigure(Points[pointIndex].ToD2D(), isFilled ? FigureBegin.Filled : FigureBegin.Hollow);
ctx.AddLine(Points[pointIndex + 1].ToD2D());
ctx.EndFigure(isFilled ? FigureEnd.Closed : FigureEnd.Open);
}
// ctx.BeginFigure(Points.First().ToD2D(), isFilled ? FigureBegin.Filled : FigureBegin.Hollow);
//foreach (Point point in Points.Skip(1)) {
// ctx.AddLine(point.ToD2D());
//}
//ctx.EndFigure(isFilled ? FigureEnd.Closed : FigureEnd.Open);
ctx.Close();
}
geometry.Add(childGeometry);
return(new GeometryGroup(d2dFactory, FillMode.Winding, geometry.ToArray()));
}
return(null);
};
_geometryByFactory[d2dFactory.NativePointer] = new GeometryAndFlag(
buildGeometry(false, LineThickness > 0, LineColor),
buildGeometry(true, true, LineColor), rect);
}
/// <summary>
/// Draws a Polygon.
/// </summary>
/// <param name="pen">The Pen.</param>
/// <param name="polygon">The Polygon.</param>
public void DrawPolygon(Pen pen, Polygon polygon)
{
var dxPen = pen.Instance as DirectXPen;
if (dxPen == null)
{
throw new ArgumentException("DirectX10 expects a DirectXPen as resource.");
}
var geometry = new PathGeometry(DirectXHelper.Direct2DFactory);
using (GeometrySink sink = geometry.Open())
{
sink.BeginFigure(DirectXHelper.ConvertVector(polygon.Points[0]), FigureBegin.Hollow);
for (int i = 1; i < polygon.Points.Length; i++)
{
sink.AddLine(DirectXHelper.ConvertVector(polygon.Points[i]));
}
sink.EndFigure(FigureEnd.Closed);
sink.Close();
_renderTarget.DrawGeometry(geometry, dxPen.GetPen(), dxPen.Width);
}
geometry.Dispose();
}
public static void FillSector(this RenderTarget renderTarget, RawVector2 pos, float radius, Color color, float angleStart, float angleEnd)
{
PointF[] pathPoints;
using (GraphicsPath path = new GraphicsPath())
{
radius *= 2f;
path.AddPie(pos.X - (radius / 2f), pos.Y - (radius / 2f), radius, radius, angleStart, angleEnd);
path.Flatten();
pathPoints = path.PathPoints;
path.Dispose();
}
using (SharpDX.Direct2D1.Factory factory = renderTarget.Factory)
{
PathGeometry geometry = new PathGeometry(factory);
if (pathPoints.Length > 1)
{
GeometrySink sink = geometry.Open();
sink.SetSegmentFlags(PathSegment.ForceRoundLineJoin);
sink.BeginFigure(new RawVector2(pathPoints[0].X, pathPoints[0].Y), FigureBegin.Filled);
for (int i = 1; i < pathPoints.Length; i++)
{
sink.AddLine(new RawVector2(pathPoints[i].X, pathPoints[i].Y));
}
sink.EndFigure(FigureEnd.Closed);
sink.Close();
sink.Dispose();
}
SolidColorBrush brush = new SolidColorBrush(renderTarget, color.ToRawColor4(1f));
renderTarget.FillGeometry(geometry, brush);
brush.Dispose();
geometry.Dispose();
}
}
private static void DrawArrow(
GeometrySink sink,
ReadOnlySpan <ImmutableVec2_float> bezier,
float arrowSize)
{
var b1X = BiaNodeEditorHelper.Bezier(bezier[0].X, bezier[1].X, bezier[2].X, bezier[3].X, 0.5001f);
var b1Y = BiaNodeEditorHelper.Bezier(bezier[0].Y, bezier[1].Y, bezier[2].Y, bezier[3].Y, 0.5001f);
var b2X = BiaNodeEditorHelper.Bezier(bezier[0].X, bezier[1].X, bezier[2].X, bezier[3].X, 0.5f);
var b2Y = BiaNodeEditorHelper.Bezier(bezier[0].Y, bezier[1].Y, bezier[2].Y, bezier[3].Y, 0.5f);
var sx = b1X - b2X;
var sy = b1Y - b2Y;
var r = MathF.Atan2(sy, sx) + MathF.PI * 0.5f;
var m = (MathF.Sin(r), MathF.Cos(r));
var l1 = new ImmutableVec2_float(arrowSize / 1.732f, arrowSize / 1.732f * 2.0f);
var l2 = new ImmutableVec2_float(-arrowSize / 1.732f, arrowSize / 1.732f * 2.0f);
var t1X = (bezier[0].X + bezier[3].X) * 0.5f;
var t1Y = (bezier[0].Y + bezier[3].Y) * 0.5f;
var t2 = Rotate(m, l1);
var t3 = Rotate(m, l2);
sink.BeginFigure(new RawVector2(t1X, t1Y), FigureBegin.Filled);
sink.AddLine(new RawVector2(t2.X + t1X, t2.Y + t1Y));
sink.AddLine(new RawVector2(t3.X + t1X, t3.Y + t1Y));
sink.EndFigure(FigureEnd.Closed);
}
/// <summary>
/// In a derived class, implements logic to initialize the sample.
/// </summary>
protected override void OnInitialize()
{
DeviceSettings2D settings = new DeviceSettings2D {
Width = WindowWidth,
Height = WindowHeight
};
InitializeDevice(settings);
geometry = new PathGeometry(Context2D.RenderTarget.Factory);
using (GeometrySink sink = geometry.Open()) {
PointF p0 = new PointF(0.50f * WindowWidth, 0.25f * WindowHeight);
PointF p1 = new PointF(0.75f * WindowWidth, 0.75f * WindowHeight);
PointF p2 = new PointF(0.25f * WindowWidth, 0.75f * WindowHeight);
sink.BeginFigure(p0, FigureBegin.Filled);
sink.AddLine(p1);
sink.AddLine(p2);
sink.EndFigure(FigureEnd.Closed);
// Note that Close() and Dispose() are not equivalent like they are for
// some other IDisposable() objects.
sink.Close();
}
brush = new SolidColorBrush(Context2D.RenderTarget, new Color4(0.93f, 0.40f, 0.08f));
}
static void addClockwise(RectangleF r, double start, double stop, GeometrySink sink)
{
var rx = r.Width / 2;
var ry = r.Height / 2;
var angle = start;
// the quality of Direct2D arcs are lousy, so we render them in 16 segments per circle
const int MaxSegments = 16;
const double SegmentAngle = Math.PI * 2 / MaxSegments;
for (var segment = 0; angle < stop && segment != MaxSegments; ++segment)
{
var angleLeft = stop - angle;
var angleNow = Math.Min(SegmentAngle, angleLeft);
var nextAngle = angle + angleNow;
var nextPoint = pointOn(r, nextAngle);
sink.AddArc(new ArcSegment
{
ArcSize = ArcSize.Small,
Size = new DrawingSizeF(rx, ry),
Point = nextPoint,
RotationAngle = angleNow.import(),
SweepDirection = SweepDirection.Clockwise
});
angle = nextAngle;
}
}
/// <summary>
/// Does a one off calculation of the geometry to be rendered
/// </summary>
protected void CalculateGeometry(Factory d2dFactory, System.Windows.Rect rect)
{
Func <bool, int, PathGeometry> buildGeometry = (bool isFilled, int pointIndex) => {
PathGeometry childGeometry = new PathGeometry(d2dFactory);
using (GeometrySink ctx = childGeometry.Open()) {
// Break up into groups of 4
ctx.BeginFigure(Points[pointIndex].ToD2D(), isFilled ? FigureBegin.Filled : FigureBegin.Hollow);
for (int j = 1; j < 4; ++j)
{
ctx.AddLine(Points[pointIndex + j].ToD2D());
}
ctx.AddLine(Points[pointIndex].ToD2D());
ctx.EndFigure(isFilled ? FigureEnd.Closed : FigureEnd.Open);
ctx.Close();
}
return(childGeometry);
};
List <Geometry> filledGeometry = new List <Geometry>();
List <Geometry> unfilledGeometry = new List <Geometry>();
if (Points.Count > 0)
{
for (int pointIndex = 0, colorIndex = 0; pointIndex < (Points.Count - 3); pointIndex += 4, colorIndex += 1)
{
unfilledGeometry.Add(buildGeometry(false, pointIndex));
filledGeometry.Add(buildGeometry(true, pointIndex));
}
}
_geometryByFactory[d2dFactory.NativePointer] = new GeometryAndFlag(unfilledGeometry, filledGeometry, rect);
}
protected GeometrySink CreateSectionSweepGeometry()
{
//扇形的X轴Y轴半径是矩形框width的一半
SizeF size = new SizeF(displayer.coordinateSystem.CoordinateArea.Width / 2, height: displayer.coordinateSystem.CoordinateArea.Height / 2);
_pie = displayer.Factory.CreatePathGeometry(); //扇形区域
//开始合成扇形
GeometrySink gs = _pie.Open();
gs.BeginFigure(displayer.coordinateSystem.OriginalPoint, FigureBegin.Filled);
//添加第一条线
gs.AddLine(BeginLinePoint); //原始代码
//添加弧线
ArcSegment arc = new ArcSegment(EndLinePoint, size, 0, SweepDirection.Clockwise, ArcSize.Small);
gs.AddArc(arc);
//添加第二条线
gs.AddLine(displayer.coordinateSystem.OriginalPoint);
gs.EndFigure(FigureEnd.Closed);
gs.Close();
return(gs);
}
public override Result DrawGlyphRun(object clientDrawingContext, float baselineOriginX, float baselineOriginY, MeasuringMode measuringMode, GlyphRun glyphRun, GlyphRunDescription glyphRunDescription, ComObject clientDrawingEffect)
{
using (PathGeometry path = new PathGeometry(renderer.factory2d))
{
using (GeometrySink sink = path.Open())
{
glyphRun.FontFace.GetGlyphRunOutline(glyphRun.FontSize, glyphRun.Indices, glyphRun.Advances, glyphRun.Offsets, glyphRun.Advances.Length, glyphRun.IsSideways, (glyphRun.BidiLevel % 2) > 0, sink);
sink.Close();
}
var matrix = new Matrix3x2()
{
M11 = 1,
M12 = 0,
M21 = 0,
M22 = 1,
M31 = baselineOriginX,
M32 = baselineOriginY
};
TransformedGeometry transformedGeometry = new TransformedGeometry(renderer.factory2d, path, matrix);
renderer.rtv2d.DrawGeometry(transformedGeometry, renderer.brush2dOutline);
Utilities.Dispose(ref transformedGeometry);
}
return(new Result());
}
Geometry CreateCheckGeometry0(D2DGraphics g)
{
RectangleF rect = new RectangleF(0, Height, Width, Height);
float w = rect.Width / 2;
float h = rect.Height / 4;
PathGeometry pathGeometry = new PathGeometry(D2DGraphics.d2dFactory);
GeometrySink pSink = null;
pSink = pathGeometry.Open();
pSink.SetFillMode(SharpDX.Direct2D1.FillMode.Winding);
pSink.BeginFigure(new RawVector2(rect.Left, rect.Top), FigureBegin.Filled);
RawVector2[] points =
{
new RawVector2(rect.Left + w, rect.Top + h * 2),
new RawVector2(rect.Right + w, rect.Top - h * 2),
new RawVector2(rect.Left + w, rect.Bottom),
};
pSink.AddLines(points);
pSink.EndFigure(FigureEnd.Closed);
pSink.Close();
pSink.Dispose();
return(pathGeometry);
}
Geometry CreateCheckGeometry1(D2DGraphics g)
{
RectangleF rect = new RectangleF(FillMargin.left, FillMargin.top, Width - FillMargin.right - FillMargin.left, Height - FillMargin.bottom - FillMargin.top);
float w = rect.Width / 2;
float h2 = rect.Height / 2;
float h4 = rect.Height / 4f;
PathGeometry pathGeometry = new PathGeometry(D2DGraphics.d2dFactory);
GeometrySink pSink = null;
pSink = pathGeometry.Open();
pSink.SetFillMode(SharpDX.Direct2D1.FillMode.Winding);
pSink.BeginFigure(new RawVector2(rect.Left, rect.Top + h2), FigureBegin.Filled);
RawVector2[] points =
{
new RawVector2(rect.Left + w - w / 10, rect.Top + h4 * 2.7f),
new RawVector2(rect.Right, rect.Top),
new RawVector2(rect.Left + w, rect.Bottom),
};
pSink.AddLines(points);
pSink.EndFigure(FigureEnd.Closed);
pSink.Close();
pSink.Dispose();
return(pathGeometry);
}
public void DrawShip(RenderTarget D2DRT, SolidColorBrush scb, Factory d2dFactory)
{
PathGeometry shape = new PathGeometry(d2dFactory);
GeometrySink sink = shape.Open();
//Ship Front
sink.BeginFigure(new Vector2((float)X + direction.X * 20, (float)Y - direction.Y * 20), FigureBegin.Hollow);
//Calculating Ship Right Wing by rotating unit vector 90 degrees
float rwX = (float)(direction.X * 0 - direction.Y * -1);
float rwY = (float)(direction.X * 1 + direction.Y * 0);
sink.AddLine(new Vector2(X + rwX * 7, Y + rwY * 7));
//Calculating Ship Left Wing by rotating unit vector 270 degrees
float lwX = (float)(direction.X * 0 - direction.Y * 1);
float lwY = (float)(direction.X * -1 + direction.Y * 0);
sink.AddLine(new Vector2(X + lwX * 7, Y - rwY * 7));
sink.EndFigure(FigureEnd.Closed);
sink.Close();
D2DRT.DrawGeometry(shape, scb, 1f);
//draw a line that is 10 times the length of the unit vector ship.direction
D2DRT.DrawLine(new Vector2(X, Y), new Vector2(X + direction.X * 10, Y - direction.Y * 10), scb);
edgePoints = new List <Vector2>();
edgePoints.Add(new Vector2((float)X + direction.X * 20, (float)(Y - direction.Y * 20)));
edgePoints.Add(new Vector2(X + lwX * 7, Y - rwY * 7));
edgePoints.Add(new Vector2(X + lwX * 7, Y - rwY * 7));
shape.Dispose();
sink.Dispose();
}
/// <summary>
/// 根据当前的路径生成几何组。
/// </summary>
/// <param name="factory">Direct2D 工厂。</param>
/// <returns>生成的几何组。</returns>
public GeometryGroup GetGeometryGroup(Factory factory)
{
Geometry[] geometries = new Geometry[this.figureCount];
PathGeometry path = new PathGeometry(factory);
GeometrySink sink = path.Open();
sink.SetFillMode(FillMode.Winding);
sink.BeginFigure(this.StartPoint, FigureBegin.Filled);
int cnt = this.Count;
int idx = 0;
for (int i = 0; i < cnt; i++)
{
EndFigureSegment end = this[i] as EndFigureSegment;
if (end == null)
{
this[i].FillGeometry(sink);
}
else
{
sink.EndFigure(FigureEnd.Closed);
sink.Close();
geometries[idx++] = path;
path = new PathGeometry(factory);
sink = path.Open();
sink.SetFillMode(FillMode.Winding);
sink.BeginFigure(end.EndPoint, FigureBegin.Filled);
}
}
sink.EndFigure(FigureEnd.Closed);
sink.Close();
geometries[idx++] = path;
return(new GeometryGroup(factory, FillMode.Winding, geometries));
}
protected override void SetSink(GeometrySink sink)
{
sink.SetFillMode(FillMode.Winding);
sink.BeginFigure(new RawVector2(0, 100), FigureBegin.Filled);
sink.AddBeziers(new[] {
new BezierSegment {
Point3 = new RawVector2(100, -40), Point1 = new RawVector2(0, 100), Point2 = new RawVector2(100, 20)
},
new BezierSegment {
Point3 = new RawVector2(50, -100), Point1 = new RawVector2(100, -75), Point2 = new RawVector2(75, -100)
},
new BezierSegment {
Point3 = new RawVector2(0, -50), Point1 = new RawVector2(25, -100), Point2 = new RawVector2(0, -75)
},
new BezierSegment {
Point3 = new RawVector2(-50, -100), Point1 = new RawVector2(0, -75), Point2 = new RawVector2(-25, -100)
},
new BezierSegment {
Point3 = new RawVector2(-100, -40), Point1 = new RawVector2(-75, -100), Point2 = new RawVector2(-100, -75)
},
new BezierSegment {
Point3 = new RawVector2(0, 100), Point1 = new RawVector2(-100, 20), Point2 = new RawVector2(0, 100)
}
});
sink.EndFigure(FigureEnd.Closed);
}
protected override Geometry CreateHitGeometryByD2D(D2DGraphics g)
{
RectangleF rect = new RectangleF(0, 0, Width, Height);
PathGeometry pathGeometry = new PathGeometry(D2DGraphics.d2dFactory);
GeometrySink pSink = null;
pSink = pathGeometry.Open();
pSink.SetFillMode(SharpDX.Direct2D1.FillMode.Winding);
pSink.BeginFigure(new RawVector2(rect.Left, rect.Bottom), FigureBegin.Filled);
float len = gradientSize;
RawVector2[] points =
{
new RawVector2(rect.Left + len, rect.Top),
new RawVector2(rect.Right - len, rect.Top),
new RawVector2(rect.Right, rect.Bottom),
};
pSink.AddLines(points);
pSink.EndFigure(FigureEnd.Closed);
pSink.Close();
pSink.Dispose();
return(pathGeometry);
}
void FillItemGeometry(D2DGraphics g)
{
RectangleF rect = new RectangleF(0, 0, Width, Height);
PathGeometry pathGeometry = new PathGeometry(D2DGraphics.d2dFactory);
GeometrySink pSink = null;
pSink = pathGeometry.Open();
pSink.SetFillMode(SharpDX.Direct2D1.FillMode.Winding);
pSink.BeginFigure(new RawVector2(rect.Left, rect.Bottom), FigureBegin.Filled);
float len = gradientSize;
RawVector2[] points =
{
new RawVector2(rect.Left + len, rect.Top),
new RawVector2(rect.Right - len, rect.Top),
new RawVector2(rect.Right, rect.Bottom),
};
pSink.AddLines(points);
pSink.EndFigure(FigureEnd.Closed);
pSink.Close();
pSink.Dispose();
RawColor4 rawColor = GDIDataD2DUtils.TransToRawColor4(color);
SolidColorBrush brush = new SolidColorBrush(g.RenderTarget, rawColor);
g.RenderTarget.FillGeometry(pathGeometry, brush);
}
public override Result DrawGlyphRun(object clientDrawingContext, float baselineOriginX, float baselineOriginY, MeasuringMode measuringMode, GlyphRun glyphRun, GlyphRunDescription glyphRunDescription, ComObject clientDrawingEffect)
{
using (PathGeometry path = new PathGeometry(_factory))
using (GeometrySink sink = path.Open())
{
glyphRun.FontFace.GetGlyphRunOutline(glyphRun.FontSize, glyphRun.Indices, glyphRun.Advances, glyphRun.Offsets, glyphRun.IsSideways, false, sink);
sink.Close();
var translation = Matrix3x2.Translation(baselineOriginX, baselineOriginY);
var outline = new TransformedGeometry(_factory, path, translation);
using (var strokeStyle = new StrokeStyle(_factory, new StrokeStyleProperties {
LineJoin = LineJoin.Round
}))
{
for (int i = 1; i < 8; i++)
{
var color = Color.White;
color.A /= (byte)Math.Ceiling(i / 1.5);
using (var brush = new SolidColorBrush(_surface, color))
{
_surface.DrawGeometry(outline, brush, i, strokeStyle);
}
}
}
}
return(new Result());
}
private void DrawFDEBBeziers(float width, float height)
{
float[] t;
for (int i = 0, j = _pt.GetLength(1); i < _pt.GetLength(0); i++)
{
PathGeometry pLinesGeometry = this.Factory.CreatePathGeometry();
GeometrySink gs = pLinesGeometry.Open();
gs.SetFillMode(FillMode.Winding);
gs.BeginFigure(new D2D.Point2F(_pt[i, 0, 0], _pt[i, 0, 1]), FigureBegin.Hollow);
gs.AddBezier(
new BezierSegment(
new Point2F(_pt[i, (int)((j - 1) * 0.33), 0], _pt[i, (int)((j - 1) * .33), 1]),
new Point2F(_pt[i, (int)((j - 1) * 0.66), 0], _pt[i, (int)((j - 1) * .66), 1]),
new Point2F(_pt[i, (int)(j - 1), 0], _pt[i, (int)(j - 1), 1])
)
);
gs.EndFigure(FigureEnd.Open);
gs.Close();
this.RenderTarget.DrawGeometry(pLinesGeometry, neutralBrush, 1f);
foreach (Story s in _st)
{
t = s.GetLocationLines();
if ((int)_pt[i, 0, 1] == (int)t[0] && (int)_pt[i, (int)(j - 1), 1] == (int)t[1])
{
PointAndTangent pt = pLinesGeometry.ComputePointAtLength(s.GetEventLocation()[0]);
RectangleGeometry pEventsGeometry = this.Factory.CreateRectangleGeometry(
new D2D.RectF(pt.Point.X - RECTSIZE, pt.Point.Y - RECTSIZE, pt.Point.X + RECTSIZE, pt.Point.Y + RECTSIZE)
);
this.RenderTarget.DrawGeometry(pEventsGeometry, brushes[s.GetLabel()], 0.8f);
}
}
}
}
protected void CalculateGeometry(Factory d2dFactory, System.Windows.Rect rect)
{
if (_strokeStyle == null)
{
StrokeStyleProperties porps = new StrokeStyleProperties();
porps.LineJoin = LineJoin.Bevel;
_strokeStyle = new StrokeStyle(d2dFactory, porps);
}
Func <bool, bool, System.Windows.Media.Color, GeometryGroup> buildGeometry = (isFilled, isOk, color) => {
List <Geometry> geometry = new List <Geometry>();
if (isOk && Points.Count > 0 && color != System.Windows.Media.Colors.Transparent)
{
var childGeometry = new PathGeometry(d2dFactory);
using (GeometrySink ctx = childGeometry.Open()) {
ctx.BeginFigure(Points.First().ToD2D(), isFilled ? FigureBegin.Filled : FigureBegin.Hollow);
foreach (Point point in Points.Skip(1))
{
ctx.AddLine(point.ToD2D());
}
ctx.EndFigure(isFilled ? FigureEnd.Closed : FigureEnd.Open);
ctx.Close();
}
geometry.Add(childGeometry);
return(new GeometryGroup(d2dFactory, FillMode.Winding, geometry.ToArray()));
}
return(null);
};
_geometryByFactory[d2dFactory.NativePointer] = new GeometryAndFlag(
buildGeometry(false, LineThickness > 0, LineColor),
buildGeometry(true, true, FillColor), rect);
}
static void AddRect(GeometrySink pSink, RawRectangleF rect, float r)
{
ArcSegment arcSeg = new ArcSegment();
arcSeg.ArcSize = ArcSize.Small;
arcSeg.Point = new RawVector2(rect.Left + r, rect.Top);
arcSeg.RotationAngle = 90;
arcSeg.Size = new Size2F(r, r);
arcSeg.SweepDirection = SweepDirection.Clockwise;
pSink.AddArc(arcSeg);
pSink.AddLine(new RawVector2(rect.Right - r, rect.Top));
//
arcSeg.Point = new RawVector2(rect.Right, rect.Top + r);
pSink.AddArc(arcSeg);
pSink.AddLine(new RawVector2(rect.Right, rect.Bottom - r));
//
arcSeg.Point = new RawVector2(rect.Right - r, rect.Bottom);
pSink.AddArc(arcSeg);
pSink.AddLine(new RawVector2(rect.Left + r, rect.Bottom));
arcSeg.Point = new RawVector2(rect.Left, rect.Bottom - r);
pSink.AddArc(arcSeg);
pSink.AddLine(new RawVector2(rect.Left, rect.Top + r));
}
public void BeginModify(FillMode fillmode)
{
if(m_geometryFilled)
CreatePathGeometry();
m_geometrySink = m_pathGeometry.Open();
m_geometrySink.SetFillMode((SlimDX.Direct2D.FillMode)fillmode);
}
protected override void Dispose(bool disposing)
{
if (disposing && m_sink != null)
{
m_sink.Dispose();
m_sink = null;
}
base.Dispose(disposing);
}
/// <summary>
/// 使用当前的路径填充指定的路径几何。
/// </summary>
/// <param name="sink">要填充的路径几何。</param>
public override void FillGeometry(GeometrySink sink)
{
D2D1.BezierSegment bezier = new D2D1.BezierSegment()
{
Point1 = this.Point1,
Point2 = this.Point2,
Point3 = this.EndPoint
};
sink.AddBezier(bezier);
}
/// <summary>
/// 使用当前的路径填充指定的路径几何。
/// </summary>
/// <param name="sink">要填充的路径几何。</param>
public override void FillGeometry(GeometrySink sink)
{
D2D1.ArcSegment arc = new D2D1.ArcSegment()
{
Point = EndPoint,
Size = Size,
RotationAngle = RotationAngle,
SweepDirection = SweepDirection,
ArcSize = ArcSize
};
sink.AddArc(arc);
}
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;
}
}
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();
}
/// <summary>
/// 使用当前的路径填充指定的路径几何。
/// </summary>
/// <param name="sink">要填充的路径几何。</param>
public override void FillGeometry(GeometrySink sink)
{
sink.EndFigure(FigureEnd.Closed);
sink.BeginFigure(EndPoint, FigureBegin.Filled);
}
char _token; // Non whitespace character returned by ReadToken
public PathGeometry parse(string path, Factory1 d2dfactory)
{
_factory = d2dfactory;
_pathGeometry = new PathGeometry(d2dfactory);
_figure = _pathGeometry.Open();
//GeometrySink _sink = _pathGeometry.Open();
_formatProvider = CultureInfo.InvariantCulture;
_pathString = path;
_pathLength = path.Length;
_curIndex = 0;
_secondLastPoint = new Point(0, 0);
_lastPoint = new Point(0, 0);
_lastStart = new Point(0, 0);
_figureStarted = false;
bool first = true;
char last_cmd = ' ';
while (ReadToken()) // Empty path is allowed in XAML
{
char cmd = _token;
if (first)
{
if ((cmd != 'M') && (cmd != 'm')) // Path starts with M|m
{
ThrowBadToken();
}
first = false;
}
switch (cmd)
{
case 'm':
case 'M':
// XAML allows multiple points after M/m
_lastPoint = ReadPoint(cmd, !AllowComma);
_figure.BeginFigure(new SharpDX.Vector2((float)_lastPoint.X, (float)_lastPoint.Y), IsFilled ? FigureBegin.Filled : FigureBegin.Hollow);
//_figure.StartPoint = _lastPoint;
//_figure.IsFilled = IsFilled;
//if (!IsClosed) _figure.Close();
//_figure.IsClosed = !IsClosed;
//context.BeginFigure(_lastPoint, IsFilled, !IsClosed);
_figureStarted = true;
_lastStart = _lastPoint;
last_cmd = 'M';
while (IsNumber(AllowComma))
{
_lastPoint = ReadPoint(cmd, !AllowComma);
//LineSegment _lineSegment = new LineSegment();
//_lineSegment.Point = _lastPoint;
_figure.AddLine(new SharpDX.Vector2((float)_lastPoint.X, (float)_lastPoint.Y));
//_figure.Segments.Add(_lineSegment);
//context.LineTo(_lastPoint, IsStroked, !IsSmoothJoin);
last_cmd = 'L';
}
break;
case 'l':
case 'L':
case 'h':
case 'H':
case 'v':
case 'V':
EnsureFigure();
do
{
switch (cmd)
{
case 'l': _lastPoint = ReadPoint(cmd, !AllowComma); break;
case 'L': _lastPoint = ReadPoint(cmd, !AllowComma); break;
case 'h': _lastPoint.X += ReadNumber(!AllowComma); break;
case 'H': _lastPoint.X = ReadNumber(!AllowComma); break;
case 'v': _lastPoint.Y += ReadNumber(!AllowComma); break;
case 'V': _lastPoint.Y = ReadNumber(!AllowComma); break;
}
//LineSegment _lineSegment = new LineSegment();
//_lineSegment.Point = _lastPoint;
//_figure.Segments.Add(_lineSegment);
_figure.AddLine(new SharpDX.Vector2((float)_lastPoint.X, (float)_lastPoint.Y));
//context.LineTo(_lastPoint, IsStroked, !IsSmoothJoin);
}
while (IsNumber(AllowComma));
last_cmd = 'L';
break;
case 'c':
case 'C': // cubic Bezier
case 's':
case 'S': // smooth cublic Bezier
EnsureFigure();
do
{
Point p;
if ((cmd == 's') || (cmd == 'S'))
{
if (last_cmd == 'C')
{
p = Reflect();
}
else
{
p = _lastPoint;
}
_secondLastPoint = ReadPoint(cmd, !AllowComma);
}
else
{
p = ReadPoint(cmd, !AllowComma);
_secondLastPoint = ReadPoint(cmd, AllowComma);
}
_lastPoint = ReadPoint(cmd, AllowComma);
//BezierSegment _bizierSegment = new BezierSegment();
//_bizierSegment.Point1 = p;
//_bizierSegment.Point2 = _secondLastPoint;
//_bizierSegment.Point3 = _lastPoint;
//_figure.Segments.Add(_bizierSegment);
_figure.AddBezier(new BezierSegment()
{
Point1 = new SharpDX.Vector2((float)p.X, (float)p.Y),
Point2 = new SharpDX.Vector2((float)_secondLastPoint.X, (float)_secondLastPoint.Y),
Point3 = new SharpDX.Vector2((float)_lastPoint.X, (float)_lastPoint.Y)
});
//context.BezierTo(p, _secondLastPoint, _lastPoint, IsStroked, !IsSmoothJoin);
last_cmd = 'C';
}
while (IsNumber(AllowComma));
break;
case 'q':
case 'Q': // quadratic Bezier
case 't':
case 'T': // smooth quadratic Bezier
EnsureFigure();
do
{
if ((cmd == 't') || (cmd == 'T'))
{
if (last_cmd == 'Q')
{
_secondLastPoint = Reflect();
}
else
{
_secondLastPoint = _lastPoint;
}
_lastPoint = ReadPoint(cmd, !AllowComma);
}
else
{
_secondLastPoint = ReadPoint(cmd, !AllowComma);
_lastPoint = ReadPoint(cmd, AllowComma);
}
//QuadraticBezierSegment _quadraticBezierSegment = new QuadraticBezierSegment();
//_quadraticBezierSegment.Point1 = _secondLastPoint;
//_quadraticBezierSegment.Point2 = _lastPoint;
//_figure.Segments.Add(_quadraticBezierSegment);
_figure.AddQuadraticBezier(new QuadraticBezierSegment()
{
Point1 = new SharpDX.Vector2((float)_secondLastPoint.X, (float)_secondLastPoint.Y),
Point2 = new SharpDX.Vector2((float)_lastPoint.X, (float)_lastPoint.Y)
});
//context.QuadraticBezierTo(_secondLastPoint, _lastPoint, IsStroked, !IsSmoothJoin);
last_cmd = 'Q';
}
while (IsNumber(AllowComma));
break;
case 'a':
case 'A':
EnsureFigure();
do
{
// A 3,4 5, 0, 0, 6,7
double w = ReadNumber(!AllowComma);
double h = ReadNumber(AllowComma);
double rotation = ReadNumber(AllowComma);
bool large = ReadBool();
bool sweep = ReadBool();
_lastPoint = ReadPoint(cmd, AllowComma);
//ArcSegment _arcSegment = new ArcSegment();
//_arcSegment.Point = _lastPoint;
//_arcSegment.Size = new Size(w, h);
//_arcSegment.RotationAngle = rotation;
//_arcSegment.IsLargeArc = large;
//_arcSegment.SweepDirection = sweep ? SweepDirection.Clockwise : SweepDirection.Counterclockwise;
//_figure.Segments.Add(_arcSegment);
_figure.AddArc(new ArcSegment()
{
Point = new SharpDX.Vector2((float)_lastPoint.X, (float)_lastPoint.Y),
Size = new SharpDX.Size2F((float)w, (float)h),
RotationAngle = (float)rotation,
ArcSize = large ? ArcSize.Large : ArcSize.Small,
SweepDirection = sweep ? SweepDirection.Clockwise : SweepDirection.CounterClockwise
});
//context.ArcTo(
// _lastPoint,
// new Size(w, h),
// rotation,
// large,
// sweep ? SweepDirection.Clockwise : SweepDirection.Counterclockwise,
// IsStroked,
// !IsSmoothJoin
// );
}
while (IsNumber(AllowComma));
last_cmd = 'A';
break;
case 'z':
case 'Z':
EnsureFigure();
//_figure.IsClosed = IsClosed;
//context.SetClosedState(IsClosed);
_figure.EndFigure(IsClosed ? FigureEnd.Closed : FigureEnd.Open);
_figureStarted = false;
last_cmd = 'Z';
_lastPoint = _lastStart; // Set reference point to be first point of current figure
break;
default:
ThrowBadToken();
break;
}
}
//if (null != _figure)
//{
// _pathGeometry = new PathGeometry(d2dfactory);
// _pathGeometry.Figures.Add(_figure);
//}
_figure.Close();
//_sink.Close();
return _pathGeometry;
}
public GeometrySinkFigureTarget(GeometrySink sink)
{
_sink = sink;
}
/// <summary>
/// Combines this geometry with the specified geometry and stores the result in an <see cref="SharpDX.Direct2D1.SimplifiedGeometrySink"/>.
/// </summary>
/// <param name="inputGeometry">The geometry to combine with this instance.</param>
/// <param name="combineMode">The type of combine operation to perform.</param>
/// <param name="flatteningTolerance">The maximum bounds on the distance between points in the polygonal approximation of the geometries. Smaller values produce more accurate results but cause slower execution. </param>
/// <param name="geometrySink">The result of the combine operation.</param>
/// <returns>If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code.</returns>
/// <unmanaged>HRESULT CombineWithGeometry([In] ID2D1Geometry* inputGeometry,[None] D2D1_COMBINE_MODE combineMode,[In, Optional] const D2D1_MATRIX_3X2_F* inputGeometryTransform,[None] FLOAT flatteningTolerance,[In] ID2D1SimplifiedGeometrySink* geometrySink)</unmanaged>
public void Combine(SharpDX.Direct2D1.Geometry inputGeometry, SharpDX.Direct2D1.CombineMode combineMode, float flatteningTolerance, GeometrySink geometrySink)
{
this.Combine(inputGeometry, combineMode, null, flatteningTolerance, geometrySink);
}
/// <summary>
/// Widens the geometry by the specified stroke and writes the result to an <see cref="SharpDX.Direct2D1.SimplifiedGeometrySink"/> after it has been transformed by the specified matrix and flattened using the specified tolerance.
/// </summary>
/// <param name="strokeWidth">The amount by which to widen the geometry.</param>
/// <param name="strokeStyle">The style of stroke to apply to the geometry, or NULL.</param>
/// <param name="flatteningTolerance">The maximum bounds on the distance between points in the polygonal approximation of the geometry. Smaller values produce more accurate results but cause slower execution.</param>
/// <param name="geometrySink">The <see cref="SharpDX.Direct2D1.SimplifiedGeometrySink"/> to which the widened geometry is appended.</param>
/// <returns>If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code.</returns>
/// <unmanaged>HRESULT Widen([None] FLOAT strokeWidth,[In, Optional] ID2D1StrokeStyle* strokeStyle,[In, Optional] const D2D1_MATRIX_3X2_F* worldTransform,[None] FLOAT flatteningTolerance,[In] ID2D1SimplifiedGeometrySink* geometrySink)</unmanaged>
public void Widen(float strokeWidth, SharpDX.Direct2D1.StrokeStyle strokeStyle, float flatteningTolerance, GeometrySink geometrySink)
{
this.Widen(strokeWidth, strokeStyle, null, flatteningTolerance, geometrySink);
}
/// <summary>
/// Computes the outline of the geometry and writes the result to an <see cref="SharpDX.Direct2D1.SimplifiedGeometrySink"/>.
/// </summary>
/// <remarks>
/// The {{Outline}} method allows the caller to produce a geometry with an equivalent fill to the input geometry, with the following additional properties: The output geometry contains no transverse intersections; that is, segments may touch, but they never cross.The outermost figures in the output geometry are all oriented counterclockwise. The output geometry is fill-mode invariant; that is, the fill of the geometry does not depend on the choice of the fill mode. For more information about the fill mode, see <see cref="SharpDX.Direct2D1.FillMode"/>.Additionally, the {{Outline}} method can be useful in removing redundant portions of said geometries to simplify complex geometries. It can also be useful in combination with <see cref="SharpDX.Direct2D1.GeometryGroup"/> to create unions among several geometries simultaneously.
/// </remarks>
/// <param name="worldTransform">The transform to apply to the geometry outline, or NULL.</param>
/// <param name="flatteningTolerance">The maximum bounds on the distance between points in the polygonal approximation of the geometry. Smaller values produce more accurate results but cause slower execution. </param>
/// <param name="geometrySink">The <see cref="SharpDX.Direct2D1.SimplifiedGeometrySink"/> to which the geometry's transformed outline is appended. </param>
/// <returns>If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code.</returns>
/// <unmanaged>HRESULT Outline([In, Optional] const D2D1_MATRIX_3X2_F* worldTransform,[None] FLOAT flatteningTolerance,[In] ID2D1SimplifiedGeometrySink* geometrySink)</unmanaged>
public void Outline(RawMatrix3x2? worldTransform, float flatteningTolerance, GeometrySink geometrySink)
{
this.Outline_(worldTransform, flatteningTolerance, GeometrySinkShadow.ToIntPtr(geometrySink));
}
/// <summary>
/// Computes the outline of the geometry and writes the result to an <see cref="SharpDX.Direct2D1.SimplifiedGeometrySink"/>.
/// </summary>
/// <remarks>
/// The {{Outline}} method allows the caller to produce a geometry with an equivalent fill to the input geometry, with the following additional properties: The output geometry contains no transverse intersections; that is, segments may touch, but they never cross.The outermost figures in the output geometry are all oriented counterclockwise. The output geometry is fill-mode invariant; that is, the fill of the geometry does not depend on the choice of the fill mode. For more information about the fill mode, see <see cref="SharpDX.Direct2D1.FillMode"/>.Additionally, the {{Outline}} method can be useful in removing redundant portions of said geometries to simplify complex geometries. It can also be useful in combination with <see cref="SharpDX.Direct2D1.GeometryGroup"/> to create unions among several geometries simultaneously.
/// </remarks>
/// <param name="geometrySink">The <see cref="SharpDX.Direct2D1.SimplifiedGeometrySink"/> to which the geometry's transformed outline is appended. </param>
/// <returns>If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code.</returns>
/// <unmanaged>HRESULT Outline([In, Optional] const D2D1_MATRIX_3X2_F* worldTransform,[None] FLOAT flatteningTolerance,[In] ID2D1SimplifiedGeometrySink* geometrySink)</unmanaged>
public void Outline(GeometrySink geometrySink)
{
this.Outline(null, FlatteningTolerance, geometrySink);
}
public void Run()
{
var form = new RenderForm("2d and 3d combined...it's like magic");
form.KeyDown += (sender, args) => { if (args.KeyCode == Keys.Escape) form.Close(); };
// DirectX DXGI 1.1 factory
var factory1 = new Factory1();
// The 1st graphics adapter
var adapter1 = factory1.GetAdapter1(0);
// ---------------------------------------------------------------------------------------------
// Setup direct 3d version 11. It's context will be used to combine the two elements
// ---------------------------------------------------------------------------------------------
var description = new SwapChainDescription
{
BufferCount = 1,
ModeDescription = new ModeDescription(0, 0, new Rational(60, 1), Format.R8G8B8A8_UNorm),
IsWindowed = true,
OutputHandle = form.Handle,
SampleDescription = new SampleDescription(1, 0),
SwapEffect = SwapEffect.Discard,
Usage = Usage.RenderTargetOutput,
Flags = SwapChainFlags.AllowModeSwitch
};
Device11 device11;
SwapChain swapChain;
Device11.CreateWithSwapChain(adapter1, DeviceCreationFlags.None, description, out device11, out swapChain);
// create a view of our render target, which is the backbuffer of the swap chain we just created
RenderTargetView renderTargetView;
using (var resource = Resource.FromSwapChain<Texture2D>(swapChain, 0))
renderTargetView = new RenderTargetView(device11, resource);
// setting a viewport is required if you want to actually see anything
var context = device11.ImmediateContext;
var viewport = new Viewport(0.0f, 0.0f, form.ClientSize.Width, form.ClientSize.Height);
context.OutputMerger.SetTargets(renderTargetView);
context.Rasterizer.SetViewports(viewport);
//
// Create the DirectX11 texture2D. This texture will be shared with the DirectX10 device.
//
// The DirectX10 device will be used to render text onto this texture.
// DirectX11 will then draw this texture (blended) onto the screen.
// The KeyedMutex flag is required in order to share this resource between the two devices.
var textureD3D11 = new Texture2D(device11, new Texture2DDescription
{
Width = form.ClientSize.Width,
Height = form.ClientSize.Height,
MipLevels = 1,
ArraySize = 1,
Format = Format.B8G8R8A8_UNorm,
SampleDescription = new SampleDescription(1, 0),
Usage = ResourceUsage.Default,
BindFlags = BindFlags.RenderTarget | BindFlags.ShaderResource,
CpuAccessFlags = CpuAccessFlags.None,
OptionFlags = ResourceOptionFlags.SharedKeyedmutex
});
// ---------------------------------------------------------------------------------------------
// Setup a direct 3d version 10.1 adapter
// ---------------------------------------------------------------------------------------------
var device10 = new Device10(adapter1, SharpDX.Direct3D10.DeviceCreationFlags.BgraSupport, FeatureLevel.Level_10_0);
// ---------------------------------------------------------------------------------------------
// Setup Direct 2d
// ---------------------------------------------------------------------------------------------
// Direct2D Factory
var factory2D = new SharpDX.Direct2D1.Factory(FactoryType.SingleThreaded, DebugLevel.Information);
// Here we bind the texture we've created on our direct3d11 device through the direct3d10
// to the direct 2d render target....
var sharedResource = textureD3D11.QueryInterface<SharpDX.DXGI.Resource>();
var textureD3D10 = device10.OpenSharedResource<SharpDX.Direct3D10.Texture2D>(sharedResource.SharedHandle);
var surface = textureD3D10.AsSurface();
var rtp = new RenderTargetProperties
{
MinLevel = SharpDX.Direct2D1.FeatureLevel.Level_10,
Type = RenderTargetType.Hardware,
PixelFormat = new PixelFormat(Format.Unknown, AlphaMode.Premultiplied)
};
var renderTarget2D = new RenderTarget(factory2D, surface, rtp);
var solidColorBrush = new SolidColorBrush(renderTarget2D, Colors.Red);
// ---------------------------------------------------------------------------------------------------
// Setup the rendering data
// ---------------------------------------------------------------------------------------------------
// Load Effect. This includes both the vertex and pixel shaders.
// Also can include more than one technique.
ShaderBytecode shaderByteCode = ShaderBytecode.CompileFromFile(
"effectDx11.fx",
"fx_5_0",
ShaderFlags.EnableStrictness);
var effect = new Effect(device11, shaderByteCode);
// create triangle vertex data, making sure to rewind the stream afterward
var verticesTriangle = new DataStream(VertexPositionColor.SizeInBytes * 3, true, true);
verticesTriangle.Write(new VertexPositionColor(new Vector3(0.0f, 0.5f, 0.5f),new Color4(1.0f, 0.0f, 0.0f, 1.0f)));
verticesTriangle.Write(new VertexPositionColor(new Vector3(0.5f, -0.5f, 0.5f),new Color4(0.0f, 1.0f, 0.0f, 1.0f)));
verticesTriangle.Write(new VertexPositionColor(new Vector3(-0.5f, -0.5f, 0.5f),new Color4(0.0f, 0.0f, 1.0f, 1.0f)));
verticesTriangle.Position = 0;
// create the triangle vertex layout and buffer
var layoutColor = new InputLayout(device11, effect.GetTechniqueByName("Color").GetPassByIndex(0).Description.Signature, VertexPositionColor.inputElements);
var vertexBufferColor = new Buffer(device11, verticesTriangle, (int)verticesTriangle.Length, ResourceUsage.Default, BindFlags.VertexBuffer, CpuAccessFlags.None, ResourceOptionFlags.None, 0);
verticesTriangle.Close();
// create overlay vertex data, making sure to rewind the stream afterward
// Top Left of screen is -1, +1
// Bottom Right of screen is +1, -1
var verticesText = new DataStream(VertexPositionTexture.SizeInBytes * 4, true, true);
verticesText.Write(new VertexPositionTexture(new Vector3(-1, 1, 0),new Vector2(0, 0f)));
verticesText.Write(new VertexPositionTexture(new Vector3(1, 1, 0),new Vector2(1, 0)));
verticesText.Write(new VertexPositionTexture(new Vector3(-1, -1, 0),new Vector2(0, 1)));
verticesText.Write(new VertexPositionTexture(new Vector3(1, -1, 0),new Vector2(1, 1)));
verticesText.Position = 0;
// create the overlay vertex layout and buffer
var layoutOverlay = new InputLayout(device11, effect.GetTechniqueByName("Overlay").GetPassByIndex(0).Description.Signature, VertexPositionTexture.inputElements);
var vertexBufferOverlay = new Buffer(device11, verticesText, (int)verticesText.Length, ResourceUsage.Default, BindFlags.VertexBuffer, CpuAccessFlags.None, ResourceOptionFlags.None, 0);
verticesText.Close();
// Think of the shared textureD3D10 as an overlay.
// The overlay needs to show the 2d content but let the underlying triangle (or whatever)
// show thru, which is accomplished by blending.
var bsd = new BlendStateDescription();
bsd.RenderTarget[0].IsBlendEnabled = true;
bsd.RenderTarget[0].SourceBlend = BlendOption.SourceColor;
bsd.RenderTarget[0].DestinationBlend = BlendOption.BlendFactor;
bsd.RenderTarget[0].BlendOperation = BlendOperation.Add;
bsd.RenderTarget[0].SourceAlphaBlend = BlendOption.One;
bsd.RenderTarget[0].DestinationAlphaBlend = BlendOption.Zero;
bsd.RenderTarget[0].AlphaBlendOperation = BlendOperation.Add;
bsd.RenderTarget[0].RenderTargetWriteMask = ColorWriteMaskFlags.All;
var blendStateTransparent = new BlendState(device11, bsd);
// ---------------------------------------------------------------------------------------------------
// Create and tesselate an ellipse
// ---------------------------------------------------------------------------------------------------
var center = new DrawingPointF(form.ClientSize.Width/2.0f, form.ClientSize.Height/2.0f);
var ellipse = new EllipseGeometry(factory2D, new Ellipse(center, form.ClientSize.Width / 2.0f, form.ClientSize.Height / 2.0f));
// Populate a PathGeometry from Ellipse tessellation
var 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);
_geometrySink.Close();
// ---------------------------------------------------------------------------------------------------
// Acquire the mutexes. These are needed to assure the device in use has exclusive access to the surface
// ---------------------------------------------------------------------------------------------------
var device10Mutex = textureD3D10.QueryInterface<KeyedMutex>();
var device11Mutex = textureD3D11.QueryInterface<KeyedMutex>();
// ---------------------------------------------------------------------------------------------------
// Main rendering loop
// ---------------------------------------------------------------------------------------------------
bool first = true;
RenderLoop
.Run(form,
() =>
{
if(first)
{
form.Activate();
first = false;
}
// clear the render target to black
context.ClearRenderTargetView(renderTargetView, Colors.DarkSlateGray);
// Draw the triangle
context.InputAssembler.InputLayout = layoutColor;
context.InputAssembler.PrimitiveTopology = PrimitiveTopology.TriangleList;
context.InputAssembler.SetVertexBuffers(0, new VertexBufferBinding(vertexBufferColor, VertexPositionColor.SizeInBytes, 0));
context.OutputMerger.BlendState = null;
var currentTechnique = effect.GetTechniqueByName("Color");
for (var pass = 0; pass < currentTechnique.Description.PassCount; ++pass)
{
using (var effectPass = currentTechnique.GetPassByIndex(pass))
{
System.Diagnostics.Debug.Assert(effectPass.IsValid, "Invalid EffectPass");
effectPass.Apply(context);
}
context.Draw(3, 0);
};
// Draw Ellipse on the shared Texture2D
device10Mutex.Acquire(0, 100);
renderTarget2D.BeginDraw();
renderTarget2D.Clear(Colors.Black);
renderTarget2D.DrawGeometry(tesselatedGeometry, solidColorBrush);
renderTarget2D.DrawEllipse(new Ellipse(center, 200, 200), solidColorBrush, 20, null);
renderTarget2D.EndDraw();
device10Mutex.Release(0);
// Draw the shared texture2D onto the screen, blending the 2d content in
device11Mutex.Acquire(0, 100);
var srv = new ShaderResourceView(device11, textureD3D11);
effect.GetVariableByName("g_Overlay").AsShaderResource().SetResource(srv);
context.InputAssembler.InputLayout = layoutOverlay;
context.InputAssembler.PrimitiveTopology = PrimitiveTopology.TriangleStrip;
context.InputAssembler.SetVertexBuffers(0, new VertexBufferBinding(vertexBufferOverlay, VertexPositionTexture.SizeInBytes, 0));
context.OutputMerger.BlendState = blendStateTransparent;
currentTechnique = effect.GetTechniqueByName("Overlay");
for (var pass = 0; pass < currentTechnique.Description.PassCount; ++pass)
{
using (var effectPass = currentTechnique.GetPassByIndex(pass))
{
System.Diagnostics.Debug.Assert(effectPass.IsValid, "Invalid EffectPass");
effectPass.Apply(context);
}
context.Draw(4, 0);
}
srv.Dispose();
device11Mutex.Release(0);
swapChain.Present(0, PresentFlags.None);
});
// dispose everything
vertexBufferColor.Dispose();
vertexBufferOverlay.Dispose();
layoutColor.Dispose();
layoutOverlay.Dispose();
effect.Dispose();
shaderByteCode.Dispose();
renderTarget2D.Dispose();
swapChain.Dispose();
device11.Dispose();
device10.Dispose();
textureD3D10.Dispose();
textureD3D11.Dispose();
factory1.Dispose();
adapter1.Dispose();
sharedResource.Dispose();
factory2D.Dispose();
surface.Dispose();
solidColorBrush.Dispose();
blendStateTransparent.Dispose();
device10Mutex.Dispose();
device11Mutex.Dispose();
}
/// <summary>
/// Get a native callback pointer from a managed callback.
/// </summary>
/// <param name="geometrySink">The geometry sink.</param>
/// <returns>A pointer to the unmanaged geometry sink counterpart</returns>
public static IntPtr ToIntPtr(GeometrySink geometrySink)
{
return ToCallbackPtr<GeometrySink>(geometrySink);
}
/// <summary>
/// Copies the contents of the path geometry to the specified <see cref="SharpDX.Direct2D1.GeometrySink"/>.
/// </summary>
/// <param name="geometrySink">The sink to which the path geometry's contents are copied. Modifying this sink does not change the contents of this path geometry.</param>
/// <returns>If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code.</returns>
/// <unmanaged>HRESULT Stream([In] ID2D1GeometrySink* geometrySink)</unmanaged>
public void Stream(GeometrySink geometrySink)
{
this.Stream_(GeometrySinkShadow.ToIntPtr(geometrySink));
}
public override void Load( CanvasRenderArguments args )
{
// dispose the prev geometry
if ( meshGeo != null )
meshGeo.Dispose();
if (meshGeo_Color != null)
meshGeo_Color.Dispose();
if (lineBrush_Color != null)
lineBrush_Color.Dispose();
if (lineBrush != null)
lineBrush.Dispose();
// init the lines brushs
lineBrush = new SolidColorBrush(args.renderTarget, LineColor);
// init the lines brushs
lineBrush_Color = new SolidColorBrush(args.renderTarget, new Color4(0.98f, 0.99f, 0.09f, 1.0f));
// init the geometryes
meshGeo = new PathGeometry( args.factory );
// fill the mesh geo
meshGeo_Sink = meshGeo.Open();
// init the geometryes
meshGeo_Color = new PathGeometry(args.factory);
// fill the mesh geo
meshGeo_Sink_Color = meshGeo_Color.Open();
// draw all the faces
mesh.FaceFunctionExec(new FaceFunction(DrawFace));
// close the geo
meshGeo_Sink.Close();
// free the memory for the sink
meshGeo_Sink.Dispose();
// close the geo
meshGeo_Sink_Color.Close();
// free the memory for the sink
meshGeo_Sink_Color.Dispose();
IsGeomrtryDirty = false;
}
internal D2dGeometrySink(GeometrySink sink)
{
m_sink = sink;
}
/// <summary> /// 使用当前的路径填充指定的路径几何。 /// </summary> /// <param name="sink">要填充的路径几何。</param> public abstract void FillGeometry(GeometrySink sink);
/// <summary>
/// Creates a simplified version of the geometry that contains only lines and (optionally) cubic Bezier curves and writes the result to an <see cref="SharpDX.Direct2D1.SimplifiedGeometrySink"/>.
/// </summary>
/// <param name="simplificationOption">A value that specifies whether the simplified geometry should contain curves.</param>
/// <param name="flatteningTolerance">The maximum bounds on the distance between points in the polygonal approximation of the geometry. Smaller values produce more accurate results but cause slower execution. </param>
/// <param name="geometrySink"> The <see cref="SharpDX.Direct2D1.SimplifiedGeometrySink"/> to which the simplified geometry is appended. </param>
/// <returns>If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code.</returns>
/// <unmanaged>HRESULT Simplify([None] D2D1_GEOMETRY_SIMPLIFICATION_OPTION simplificationOption,[In, Optional] const D2D1_MATRIX_3X2_F* worldTransform,[None] FLOAT flatteningTolerance,[In] ID2D1SimplifiedGeometrySink* geometrySink)</unmanaged>
public void Simplify(SharpDX.Direct2D1.GeometrySimplificationOption simplificationOption, float flatteningTolerance, GeometrySink geometrySink)
{
Simplify(simplificationOption, null, flatteningTolerance, geometrySink);
}
/// <summary>
/// Creates a simplified version of the geometry that contains only lines and (optionally) cubic Bezier curves and writes the result to an <see cref="SharpDX.Direct2D1.SimplifiedGeometrySink"/>.
/// </summary>
/// <param name="simplificationOption">A value that specifies whether the simplified geometry should contain curves.</param>
/// <param name="worldTransform">The transform to apply to the simplified geometry, or NULL.</param>
/// <param name="flatteningTolerance">The maximum bounds on the distance between points in the polygonal approximation of the geometry. Smaller values produce more accurate results but cause slower execution. </param>
/// <param name="geometrySink"> The <see cref="SharpDX.Direct2D1.SimplifiedGeometrySink"/> to which the simplified geometry is appended. </param>
/// <returns>If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code.</returns>
/// <unmanaged>HRESULT Simplify([None] D2D1_GEOMETRY_SIMPLIFICATION_OPTION simplificationOption,[In, Optional] const D2D1_MATRIX_3X2_F* worldTransform,[None] FLOAT flatteningTolerance,[In] ID2D1SimplifiedGeometrySink* geometrySink)</unmanaged>
public void Simplify(SharpDX.Direct2D1.GeometrySimplificationOption simplificationOption, SharpDX.Matrix3x2? worldTransform, float flatteningTolerance, GeometrySink geometrySink)
{
this.Simplify_(simplificationOption, worldTransform, flatteningTolerance, GeometrySinkShadow.ToIntPtr(geometrySink));
}
void IGeometrySink.Begin()
{
Contract.Assert(_Path == null);
_Path = new PathGeometry(_Factory2D);
_IsSinkInFigure = false;
Contract.Assert(_PathSink == null);
_PathSink = _Path.Open();
}
/// <summary>
/// Computes the outline of the geometry and writes the result to an <see cref="SharpDX.Direct2D1.SimplifiedGeometrySink"/>.
/// </summary>
/// <remarks>
/// The {{Outline}} method allows the caller to produce a geometry with an equivalent fill to the input geometry, with the following additional properties: The output geometry contains no transverse intersections; that is, segments may touch, but they never cross.The outermost figures in the output geometry are all oriented counterclockwise. The output geometry is fill-mode invariant; that is, the fill of the geometry does not depend on the choice of the fill mode. For more information about the fill mode, see <see cref="SharpDX.Direct2D1.FillMode"/>.Additionally, the {{Outline}} method can be useful in removing redundant portions of said geometries to simplify complex geometries. It can also be useful in combination with <see cref="SharpDX.Direct2D1.GeometryGroup"/> to create unions among several geometries simultaneously.
/// </remarks>
/// <param name="flatteningTolerance">The maximum bounds on the distance between points in the polygonal approximation of the geometry. Smaller values produce more accurate results but cause slower execution. </param>
/// <param name="geometrySink">The <see cref="SharpDX.Direct2D1.SimplifiedGeometrySink"/> to which the geometry's transformed outline is appended. </param>
/// <returns>If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code.</returns>
/// <unmanaged>HRESULT Outline([In, Optional] const D2D1_MATRIX_3X2_F* worldTransform,[None] FLOAT flatteningTolerance,[In] ID2D1SimplifiedGeometrySink* geometrySink)</unmanaged>
public void Outline(float flatteningTolerance, GeometrySink geometrySink)
{
this.Outline(null, flatteningTolerance, geometrySink);
}
public Direct2D1StreamGeometryContext(GeometrySink geometrySink)
{
this.sink = geometrySink;
}
/// <summary>
/// Widens the geometry by the specified stroke and writes the result to an <see cref="SharpDX.Direct2D1.SimplifiedGeometrySink"/> after it has been transformed by the specified matrix and flattened using the specified tolerance.
/// </summary>
/// <param name="strokeWidth">The amount by which to widen the geometry.</param>
/// <param name="flatteningTolerance">The maximum bounds on the distance between points in the polygonal approximation of the geometry. Smaller values produce more accurate results but cause slower execution.</param>
/// <param name="geometrySink">The <see cref="SharpDX.Direct2D1.SimplifiedGeometrySink"/> to which the widened geometry is appended.</param>
/// <returns>If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code.</returns>
/// <unmanaged>HRESULT Widen([None] FLOAT strokeWidth,[In, Optional] ID2D1StrokeStyle* strokeStyle,[In, Optional] const D2D1_MATRIX_3X2_F* worldTransform,[None] FLOAT flatteningTolerance,[In] ID2D1SimplifiedGeometrySink* geometrySink)</unmanaged>
public void Widen(float strokeWidth, float flatteningTolerance, GeometrySink geometrySink)
{
this.Widen(strokeWidth, null, null, flatteningTolerance, geometrySink);
}
private void EnsureFigure()
{
if (!_figureStarted)
{
_figure = _pathGeometry.Open();
//_figure = new PathFigure();
//_figure.StartPoint = _lastStart;
_figure.BeginFigure(new SharpDX.Vector2((float)_lastStart.X, (float)_lastStart.Y), FigureBegin.Hollow);
//_context.BeginFigure(_lastStart, IsFilled, !IsClosed);
_figureStarted = true;
}
}
/// <summary>
/// Widens the geometry by the specified stroke and writes the result to an <see cref="SharpDX.Direct2D1.SimplifiedGeometrySink"/> after it has been transformed by the specified matrix and flattened using the specified tolerance.
/// </summary>
/// <param name="strokeWidth">The amount by which to widen the geometry.</param>
/// <param name="strokeStyle">The style of stroke to apply to the geometry, or NULL.</param>
/// <param name="worldTransform">The transform to apply to the geometry after widening it, or NULL.</param>
/// <param name="flatteningTolerance">The maximum bounds on the distance between points in the polygonal approximation of the geometry. Smaller values produce more accurate results but cause slower execution.</param>
/// <param name="geometrySink">The <see cref="SharpDX.Direct2D1.SimplifiedGeometrySink"/> to which the widened geometry is appended.</param>
/// <returns>If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code.</returns>
/// <unmanaged>HRESULT Widen([None] FLOAT strokeWidth,[In, Optional] ID2D1StrokeStyle* strokeStyle,[In, Optional] const D2D1_MATRIX_3X2_F* worldTransform,[None] FLOAT flatteningTolerance,[In] ID2D1SimplifiedGeometrySink* geometrySink)</unmanaged>
public void Widen(float strokeWidth, SharpDX.Direct2D1.StrokeStyle strokeStyle, RawMatrix3x2? worldTransform, float flatteningTolerance, GeometrySink geometrySink)
{
this.Widen_(strokeWidth, strokeStyle, worldTransform, flatteningTolerance, GeometrySinkShadow.ToIntPtr(geometrySink));
}
public StreamGeometryContextImpl(GeometrySink sink)
{
_sink = sink;
}
/// <summary>
/// Combines this geometry with the specified geometry and stores the result in an <see cref="SharpDX.Direct2D1.SimplifiedGeometrySink"/>.
/// </summary>
/// <param name="inputGeometry">The geometry to combine with this instance.</param>
/// <param name="combineMode">The type of combine operation to perform.</param>
/// <param name="inputGeometryTransform">The transform to apply to inputGeometry before combining, or NULL.</param>
/// <param name="flatteningTolerance">The maximum bounds on the distance between points in the polygonal approximation of the geometries. Smaller values produce more accurate results but cause slower execution. </param>
/// <param name="geometrySink">The result of the combine operation.</param>
/// <returns>If the method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code.</returns>
/// <unmanaged>HRESULT CombineWithGeometry([In] ID2D1Geometry* inputGeometry,[None] D2D1_COMBINE_MODE combineMode,[In, Optional] const D2D1_MATRIX_3X2_F* inputGeometryTransform,[None] FLOAT flatteningTolerance,[In] ID2D1SimplifiedGeometrySink* geometrySink)</unmanaged>
public void Combine(SharpDX.Direct2D1.Geometry inputGeometry, SharpDX.Direct2D1.CombineMode combineMode, RawMatrix3x2? inputGeometryTransform, float flatteningTolerance, GeometrySink geometrySink)
{
this.Combine_(inputGeometry, combineMode, inputGeometryTransform, flatteningTolerance, GeometrySinkShadow.ToIntPtr(geometrySink));
}
public GeometryTarget(Factory factory, GeometrySink sink)
{
_factory = factory;
_sink = sink;
}
