private void SetGradientVector(SVGGraphicsPath graphicsPath) { Rect bound = graphicsPath.GetBound(); if (_linearGradElement.x1.unitType == SVGLengthType.Percentage) { _x1 = bound.x + (bound.width * _x1 / 100f); } if (_linearGradElement.y1.unitType == SVGLengthType.Percentage) { _y1 = bound.y + (bound.height * _y1 / 100f); } if (_linearGradElement.x2.unitType == SVGLengthType.Percentage) { _x2 = bound.x + (bound.width * _x2 / 100f); } if (_linearGradElement.y2.unitType == SVGLengthType.Percentage) { _y2 = bound.y + (bound.height * _y2 / 100f); } if (_linearGradElement.gradientUnits == SVGGradientUnit.ObjectBoundingBox) { Vector2 _point = graphicsPath.matrixTransform.Transform(new Vector2(_x1, _y1)); _x1 = _point.x; _y1 = _point.y; _point = graphicsPath.matrixTransform.Transform(new Vector2(_x2, _y2)); _x2 = _point.x; _y2 = _point.y; } }
//-------------------------------------------------------------------------------- //Method: Render //-------------------------------------------------------------------------------- public void Render(SVGGraphicsPath _graphicsPath) { Vector2 p; p = new Vector2(this._x, this._y); _graphicsPath.AddMoveTo(p); }
//-------------------------------------------------------------------------------- //Method: Render //-------------------------------------------------------------------------------- public void Render(SVGGraphicsPath _graphicsPath) { SVGPoint p, p1; p = currentPoint; p1 = controlPoint1; _graphicsPath.AddQuadraticCurveTo(p1, p); }
//-------------------------------------------------------------------------------- //Method: Render //-------------------------------------------------------------------------------- public void Render(SVGGraphicsPath _graphicsPath) { Vector2 p; p = currentPoint; _graphicsPath.AddLineTo(p); }
public SVGRadialGradientBrush(SVGRadialGradientElement radialGradElement, SVGGraphicsPath graphicsPath) { _radialGradElement = radialGradElement; Initialize(); SetGradientVector(graphicsPath); }
protected override void CreateGraphicsPath() { _graphicsPath = new SVGGraphicsPath(); _graphicsPath.Add(this); _graphicsPath.transformList = summaryTransformList; }
public bool Render(SVGGraphicsPath path, ISVGPathDraw pathDraw) { Profiler.BeginSample("SVGGMoveTo.Render"); pathDraw.MoveTo(path.matrixTransform.Transform(point)); Profiler.EndSample(); return(false); }
public SVGRadialGradientBrush(SVGRadialGradientElement radialGradElement, SVGGraphicsPath graphicsPath) { _radialGradElement = radialGradElement; Initialize(); SetGradientVector(graphicsPath); }
//-------------------------------------------------------------------------------- //Method: Render //-------------------------------------------------------------------------------- public void Render(SVGGraphicsPath _graphicsPath) { Vector2 p; p = currentPoint; _graphicsPath.AddArcTo(this._r1, this._r2, this._angle, this._largeArcFlag, this._sweepFlag, p); }
public bool Render(SVGGraphicsPath path, ISVGPathDraw pathDraw) { Profiler.BeginSample("SVGGMoveTo.Render"); pathDraw.MoveTo(path.matrixTransform.Transform(point)); Profiler.EndSample(); return false; }
public bool Render(SVGGraphicsPath path, ISVGPathDraw pathDraw) { Profiler.BeginSample("SVGGArcAbs.Render"); pathDraw.ArcTo(r1, r2, path.transformAngle + angle, largeArcFlag, sweepFlag, path.matrixTransform.Transform(point)); Profiler.EndSample(); return false; }
protected override void CreateGraphicsPath() { _graphicsPath = new SVGGraphicsPath(); _graphicsPath.Add(this); _graphicsPath.transformList = summaryTransformList; }
public bool Render(SVGGraphicsPath path, ISVGPathDraw pathDraw) { Profiler.BeginSample("SVGGArcAbs.Render"); pathDraw.ArcTo(r1, r2, path.transformAngle + angle, largeArcFlag, sweepFlag, path.matrixTransform.Transform(point)); Profiler.EndSample(); return(false); }
public void ExpandBounds(SVGGraphicsPath path) { path.ExpandBounds(x, y); path.ExpandBounds(x + width, y); path.ExpandBounds(x + width, y + height); path.ExpandBounds(x, y + height); }
private void CreateGraphicsPath() { this._graphicsPath = new SVGGraphicsPath(); this._graphicsPath.Add(this); this._graphicsPath.transformList = this.summaryTransformList; }
//Fill co Stroke trong do luon public void DrawPath(SVGGraphicsPath graphicsPath, float width) { _width = width; isUseWidth = true; graphicsPath.RenderPath(this, false); isUseWidth = false; }
public void ExpandBounds(SVGGraphicsPath path) { path.ExpandBounds(x, y); path.ExpandBounds(x + width, y); path.ExpandBounds(x + width, y + height); path.ExpandBounds(x, y + height); }
public SVGLinearGradientBrush(SVGLinearGradientElement linearGradElement, SVGGraphicsPath graphicsPath) { _linearGradElement = linearGradElement; Initialize(); SetGradientVector(graphicsPath); PreLocationProcess(); }
//-------------------------------------------------------------------------------- //Method: Render //-------------------------------------------------------------------------------- public void Render(SVGGraphicsPath _graphicsPath) { Vector2 p; p = currentPoint; _graphicsPath.AddArcTo(this._r1, this._r2, this._angle, this._largeArcFlag, this._sweepFlag, p); }
public SVGLinearGradientBrush(SVGLinearGradientElement linearGradElement, SVGGraphicsPath graphicsPath) { _linearGradElement = linearGradElement; Initialize(); SetGradientVector(graphicsPath); PreLocationProcess(); }
//-------------------------------------------------------------------------------- //Method: Render //-------------------------------------------------------------------------------- public void Render(SVGGraphicsPath _graphicsPath) { Vector2 p, p1; p = currentPoint; p1 = controlPoint1; _graphicsPath.AddQuadraticCurveTo(p1, p); }
//----- private void SetGradientVector(SVGGraphicsPath graphicsPath) { Rect bound = graphicsPath.GetBound(); if (_radialGradElement.cx.unitType == SVGLengthType.Percentage) { _cx = bound.x + (bound.width * _cx / 100f); } if (_radialGradElement.cy.unitType == SVGLengthType.Percentage) { _cy = bound.y + (bound.height * _cy / 100f); } if (_radialGradElement.r.unitType == SVGLengthType.Percentage) { Vector2 _p1 = new Vector2(bound.x, bound.y); Vector2 _p2 = new Vector2(bound.x + bound.width, bound.y + bound.height); _p1 = graphicsPath.matrixTransform.Transform(_p1); _p2 = graphicsPath.matrixTransform.Transform(_p2); float dd = (float)Math.Sqrt((_p2.x - _p1.x) * (_p2.x - _p1.x) + (_p2.y - _p1.y) * (_p2.y - _p1.y)); _r = (dd * _r / 100f); } if (_radialGradElement.fx.unitType == SVGLengthType.Percentage) { _fx = bound.x + (bound.width * _fx / 100f); } if (_radialGradElement.fy.unitType == SVGLengthType.Percentage) { _fy = bound.y + (bound.height * _fy / 100f); } if ((float)Math.Sqrt((_cx - _fx) * (_cx - _fx) + (_cy - _fy) * (_cy - _fy)) > _r) { Vector2 _cP = CrossPoint(_cx, _cy); _fx = _cP.x; _fy = _cP.y; } if (_radialGradElement.gradientUnits == SVGGradientUnit.ObjectBoundingBox) { Vector2 _point = new Vector2(_cx, _cy); _point = graphicsPath.matrixTransform.Transform(_point); _cx = _point.x; _cy = _point.y; _point = new Vector2(_fx, _fy); _point = graphicsPath.matrixTransform.Transform(_point); _fx = _point.x; _fy = _point.y; } }
//-------------------------------------------------------------------------------- //Method: Render //-------------------------------------------------------------------------------- public void Render(SVGGraphicsPath _graphicsPath) { Vector2 p, p1, p2; p1 = controlPoint1; p2 = controlPoint2; p = currentPoint; _graphicsPath.AddCubicCurveTo(p1, p2, p); }
//Fill khong co Stroke, va ve stroke sau public void DrawPath(SVGGraphicsPath graphicsPath, float width, SVGColor?strokePathColor) { if (strokePathColor == null) { return; } SetColor(strokePathColor.Value.color); graphicsStroke.DrawPath(graphicsPath, width); }
//----- public void CubicCurveTo(Vector2 p1, Vector2 p2, Vector2 p, float width) { Vector2 _point = new Vector2(0f, 0f); _point = this._basicDraw.currentPoint; Vector2 _p1 = new Vector2(0f, 0f); Vector2 _p2 = new Vector2(0f, 0f); Vector2 _p3 = new Vector2(0f, 0f); Vector2 _p4 = new Vector2(0f, 0f); bool temp; temp = this._graphics.GetThickLine(_point, p1, width, ref _p1, ref _p2, ref _p3, ref _p4); if (temp == false) { QuadraticCurveTo(p2, p, width); return; } Vector2 _p5 = new Vector2(0f, 0f); Vector2 _p6 = new Vector2(0f, 0f); Vector2 _p7 = new Vector2(0f, 0f); Vector2 _p8 = new Vector2(0f, 0f); this._graphics.GetThickLine(p1, p2, width, ref _p5, ref _p6, ref _p7, ref _p8); Vector2 _p9 = new Vector2(0f, 0f); Vector2 _p10 = new Vector2(0f, 0f); Vector2 _p11 = new Vector2(0f, 0f); Vector2 _p12 = new Vector2(0f, 0f); this._graphics.GetThickLine(p2, p, width, ref _p9, ref _p10, ref _p11, ref _p12); Vector2 _cp1, _cp2, _cp3, _cp4; _cp1 = this._graphics.GetCrossPoint(_p1, _p3, _p5, _p7); _cp2 = this._graphics.GetCrossPoint(_p2, _p4, _p6, _p8); _cp3 = this._graphics.GetCrossPoint(_p5, _p7, _p9, _p11); _cp4 = this._graphics.GetCrossPoint(_p6, _p8, _p10, _p12); this._basicDraw.MoveTo(_point); this._basicDraw.CubicCurveTo(p1, p2, p); SVGGraphicsPath _graphicsPath = new SVGGraphicsPath(); _graphicsPath.AddMoveTo(_p2); _graphicsPath.AddCubicCurveTo(_cp2, _cp4, _p12); _graphicsPath.AddLineTo(_p11); _graphicsPath.AddCubicCurveTo(_cp3, _cp1, _p1); _graphicsPath.AddLineTo(_p2); this._graphics.FillPath(_graphicsPath); MoveTo(p); }
private void CreateGraphicsPath() { _graphicsPath = new SVGGraphicsPath(); for(int i = 0; i < _segList.Count; i++) { ISVGDrawableSeg temp = _segList.GetItem(i) as ISVGDrawableSeg; if(temp != null) temp.Render(_graphicsPath); } _graphicsPath.transformList = summaryTransformList; }
public SVGRadialGradientBrush GetRadialGradientBrush(SVGGraphicsPath graphicsPath) { for (int i = 0; i < _radialGradList.Count; i++) { if (_radialGradList[i].id == _gradientID) { return(new SVGRadialGradientBrush(_radialGradList[i], graphicsPath)); } } return(null); }
public bool Render(SVGGraphicsPath path, ISVGPathDraw pathDraw) { int length = points.Count; pathDraw.MoveTo(path.matrixTransform.Transform(points[0])); for(int i = 1; i < length; i++) { Vector2 p = path.matrixTransform.Transform(points[i]); pathDraw.LineTo(p); } return false; }
//---------------------- public SVGLinearGradientBrush GetLinearGradientBrush(SVGGraphicsPath graphicsPath) { for (int i = 0; i < this._linearGradList.Count; i++) { if (this._linearGradList[i].id == this._gradientID) { return(new SVGLinearGradientBrush(this._linearGradList[i], graphicsPath)); } } return(null); }
public bool Render(SVGGraphicsPath path, ISVGPathDraw pathDraw) { int length = points.Count; Vector2[] tPoints = new Vector2[length]; for(int i = 0; i < length; i++) tPoints[i] = path.matrixTransform.Transform(points[i]); pathDraw.Polygon(tPoints); return true; }
private void CreateGraphicsPath() { _graphicsPath = new SVGGraphicsPath(); for (int i = 0; i < _segList.Count; i++) { ISVGDrawableSeg temp = _segList.GetItem(i) as ISVGDrawableSeg; if (temp != null) { temp.Render(_graphicsPath); } } _graphicsPath.transformList = summaryTransformList; }
public bool Render(SVGGraphicsPath path, ISVGPathDraw pathDraw) { int length = points.Count; pathDraw.MoveTo(path.matrixTransform.Transform(points[0])); for (int i = 1; i < length; i++) { Vector2 p = path.matrixTransform.Transform(points[i]); pathDraw.LineTo(p); } return(false); }
public void FillPath(SVGColor fillColor, SVGColor?strokePathColor, SVGGraphicsPath graphicsPath) { ResetSubBuffer(); graphicsPath.RenderPath(this, true); if (strokePathColor != null) { EndSubBuffer(strokePathColor); } else { EndSubBuffer(); } }
public void FillPath(SVGRadialGradientBrush radialGradientBrush, SVGColor?strokePathColor, SVGGraphicsPath graphicsPath) { ResetSubBuffer(); graphicsPath.RenderPath(this, true); if (strokePathColor != null) { EndSubBuffer(radialGradientBrush, strokePathColor); } else { EndSubBuffer(radialGradientBrush); } }
public bool Render(SVGGraphicsPath path, ISVGPathDraw pathDraw) { int length = points.Count; Vector2[] tPoints = new Vector2[length]; for (int i = 0; i < length; i++) { tPoints[i] = path.matrixTransform.Transform(points[i]); } pathDraw.Polygon(tPoints); return(true); }
public void Ellipse(Vector2 p, float rx, float ry, float angle, float width) { if ((int)width == 1) { Ellipse(p, rx, ry, angle); } else { int r1 = (int)(width / 2f); int r2 = (int)width - r1; //Vector2[] _points = new Vector2[1] { p }; SVGGraphicsPath _graphicsPath = new SVGGraphicsPath(); _graphicsPath.AddEllipseTo(p, rx + r1, ry + r1, angle); _graphicsPath.AddEllipseTo(p, rx - r2, ry - r2, angle); _graphics.FillPath(_graphicsPath, p); } }
//Fill khong co Stroke, va ve stroke sau public void FillPath(SVGColor fillColor, SVGColor?strokePathColor, float width, SVGGraphicsPath graphicsPath) { graphicsFill.FillPath(fillColor, strokePathColor, graphicsPath); if ((int)width == 1) { graphicsFill.FillPath(fillColor, strokePathColor, graphicsPath); } else { graphicsFill.FillPath(fillColor, graphicsPath); } if (strokePathColor == null) { return; } SetColor(strokePathColor.Value.color); }
public void Circle(Vector2 p, float r, float width) { if ((int)width == 1) { Circle(p, r); } else { int r1 = (int)(width / 2f); int r2 = (int)width - r1; //Vector2[] _points = new Vector2[1]; //_points[0] = new Vector2(p.x, p.y); SVGGraphicsPath _graphicsPath = new SVGGraphicsPath(); _graphicsPath.AddCircleTo(p, r + r1); _graphicsPath.AddCircleTo(p, r - r2); _graphics.FillPath(_graphicsPath, p); } }
public bool Render(SVGGraphicsPath path, ISVGPathDraw pathDraw) { Vector2 p1 = new Vector2(x, y), p2 = new Vector2(x + width, y), p3 = new Vector2(x + width, y + height), p4 = new Vector2(x, y + height); if (rx == 0.0f && ry == 0.0f) { p1 = path.matrixTransform.Transform(p1); p2 = path.matrixTransform.Transform(p2); p3 = path.matrixTransform.Transform(p3); p4 = path.matrixTransform.Transform(p4); pathDraw.Rect(p1, p2, p3, p4); } else { float t_rx = (rx == 0.0f) ? ry : rx; float t_ry = (ry == 0.0f) ? rx : ry; t_rx = (t_rx > (width * 0.5f - 2f)) ? (width * 0.5f - 2f) : t_rx; t_ry = (t_ry > (height * 0.5f - 2f)) ? (height * 0.5f - 2f) : t_ry; float angle = path.transformAngle; Vector2 t_p1 = path.matrixTransform.Transform(new Vector2(p1.x + t_rx, p1.y)); Vector2 t_p2 = path.matrixTransform.Transform(new Vector2(p2.x - t_rx, p2.y)); Vector2 t_p3 = path.matrixTransform.Transform(new Vector2(p2.x, p2.y + t_ry)); Vector2 t_p4 = path.matrixTransform.Transform(new Vector2(p3.x, p3.y - t_ry)); Vector2 t_p5 = path.matrixTransform.Transform(new Vector2(p3.x - t_rx, p3.y)); Vector2 t_p6 = path.matrixTransform.Transform(new Vector2(p4.x + t_rx, p4.y)); Vector2 t_p7 = path.matrixTransform.Transform(new Vector2(p4.x, p4.y - t_ry)); Vector2 t_p8 = path.matrixTransform.Transform(new Vector2(p1.x, p1.y + t_ry)); pathDraw.RoundedRect(t_p1, t_p2, t_p3, t_p4, t_p5, t_p6, t_p7, t_p8, t_rx, t_ry, angle); } return(true); }
//Fill khong co Stroke, va ve stroke sau public void FillPath(SVGLinearGradientBrush linearGradientBrush, SVGColor?strokePathColor, float width, SVGGraphicsPath graphicsPath) { graphicsFill.FillPath(linearGradientBrush, strokePathColor, graphicsPath); if ((int)width == 1) { graphicsFill.FillPath(linearGradientBrush, strokePathColor, graphicsPath); } else { graphicsFill.FillPath(linearGradientBrush, graphicsPath); } if (strokePathColor == null) { return; } SetColor(strokePathColor.Value.color); }
//Fill khong co Stroke, va ve stroke sau public void FillPath(SVGRadialGradientBrush radialGradientBrush, SVGColor?strokePathColor, float width, SVGGraphicsPath graphicsPath) { graphicsFill.FillPath(radialGradientBrush, strokePathColor, graphicsPath); if ((int)width == 1) { graphicsFill.FillPath(radialGradientBrush, strokePathColor, graphicsPath); } else { graphicsFill.FillPath(radialGradientBrush, graphicsPath); } if (strokePathColor == null) { return; } SetColor(strokePathColor.Value.color); //graphicsPath.RenderPath(this, width, false); }
public bool Render(SVGGraphicsPath path, ISVGPathDraw pathDraw) { Vector2 p1 = new Vector2(x, y), p2 = new Vector2(x + width, y), p3 = new Vector2(x + width, y + height), p4 = new Vector2(x, y + height); if(rx == 0.0f && ry == 0.0f) { p1 = path.matrixTransform.Transform(p1); p2 = path.matrixTransform.Transform(p2); p3 = path.matrixTransform.Transform(p3); p4 = path.matrixTransform.Transform(p4); pathDraw.Rect(p1, p2, p3, p4); } else { float t_rx = (rx == 0.0f) ? ry : rx; float t_ry = (ry == 0.0f) ? rx : ry; t_rx = (t_rx > (width * 0.5f - 2f)) ? (width * 0.5f - 2f) : t_rx; t_ry = (t_ry > (height * 0.5f - 2f)) ? (height * 0.5f - 2f) : t_ry; float angle = path.transformAngle; Vector2 t_p1 = path.matrixTransform.Transform(new Vector2(p1.x + t_rx, p1.y)); Vector2 t_p2 = path.matrixTransform.Transform(new Vector2(p2.x - t_rx, p2.y)); Vector2 t_p3 = path.matrixTransform.Transform(new Vector2(p2.x, p2.y + t_ry)); Vector2 t_p4 = path.matrixTransform.Transform(new Vector2(p3.x, p3.y - t_ry)); Vector2 t_p5 = path.matrixTransform.Transform(new Vector2(p3.x - t_rx, p3.y)); Vector2 t_p6 = path.matrixTransform.Transform(new Vector2(p4.x + t_rx, p4.y)); Vector2 t_p7 = path.matrixTransform.Transform(new Vector2(p4.x, p4.y - t_ry)); Vector2 t_p8 = path.matrixTransform.Transform(new Vector2(p1.x, p1.y + t_ry)); pathDraw.RoundedRect(t_p1, t_p2, t_p3, t_p4, t_p5, t_p6, t_p7, t_p8, t_rx, t_ry, angle); } return true; }
public void ExpandBounds(SVGGraphicsPath path) { int r = (int) r1 + (int) r2; path.ExpandBounds(point, r, r); }
//----- public void RoundedRect(Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, Vector2 p5, Vector2 p6, Vector2 p7, Vector2 p8, float r1, float r2, float angle, float width) { if ((int) width == 1) { RoundedRect(p1, p2, p3, p4, p5, p6, p7, p8, r1, r2, angle); return; } Line(p1, p2, width); Line(p3, p4, width); Line(p5, p6, width); Line(p7, p8, width); Vector2 _p1 = Vector2.zero; Vector2 _p2 = Vector2.zero; Vector2 _p3 = Vector2.zero; Vector2 _p4 = Vector2.zero; _graphics.GetThickLine(p1, p2, width, ref _p1, ref _p2, ref _p3, ref _p4); Vector2 _p5 = Vector2.zero; Vector2 _p6 = Vector2.zero; Vector2 _p7 = Vector2.zero; Vector2 _p8 = Vector2.zero; //------- _graphics.GetThickLine(p3, p4, width, ref _p5, ref _p6, ref _p7, ref _p8); SVGGraphicsPath _graphicsPath = new SVGGraphicsPath(); _graphicsPath.AddMoveTo(_p4); _graphicsPath.AddArcTo(r1 + (width/2f), r2 + (width/2f), angle, false, true, _p6); _graphicsPath.AddLineTo(_p5); _graphicsPath.AddArcTo(r1 - (width/2f), r2 - (width/2f), angle, false, false, _p3); _graphicsPath.AddLineTo(_p4); _graphics.FillPath(_graphicsPath); //------- _graphics.GetThickLine(p5, p6, width, ref _p1, ref _p2, ref _p3, ref _p4); _graphicsPath.Reset(); _graphicsPath.AddMoveTo(_p8); _graphicsPath.AddArcTo(r1 + (width/2f), r2 + (width/2f), angle, false, true, _p2); _graphicsPath.AddLineTo(_p1); _graphicsPath.AddArcTo(r1 - (width/2f), r2 - (width/2f), angle, false, false, _p7); _graphicsPath.AddLineTo(_p8); _graphics.FillPath(_graphicsPath); //---------- _graphics.GetThickLine(p7, p8, width, ref _p5, ref _p6, ref _p7, ref _p8); _graphicsPath.Reset(); _graphicsPath.AddMoveTo(_p4); _graphicsPath.AddArcTo(r1 + (width/2f), r2 + (width/2f), angle, false, true, _p6); _graphicsPath.AddLineTo(_p5); _graphicsPath.AddArcTo(r1 - (width/2f), r2 - (width/2f), angle, false, false, _p3); _graphicsPath.AddLineTo(_p4); _graphics.FillPath(_graphicsPath); //------- _graphics.GetThickLine(p1, p2, width, ref _p1, ref _p2, ref _p3, ref _p4); _graphicsPath.Reset(); _graphicsPath.AddMoveTo(_p8); _graphicsPath.AddArcTo(r1 + (width/2f), r2 + (width/2f), angle, false, true, _p2); _graphicsPath.AddLineTo(_p1); _graphicsPath.AddArcTo(r1 - (width/2f), r2 - (width/2f), angle, false, false, _p7); _graphicsPath.AddLineTo(_p8); _graphics.FillPath(_graphicsPath); }
//----- public void ArcTo(float r1, float r2, float angle, bool largeArcFlag, bool sweepFlag, Vector2 p, float width) { Profiler.BeginSample("SVGGraphicsStroke.ArcTo"); float rx = r1; float ry = r2; Vector2 p1 = _basicDraw.currentPoint; Vector2 p2 = p; float temp1, temp2; float _radian = (angle*Mathf.PI/180.0f); float _CosRadian = (float) Math.Cos(_radian); float _SinRadian = (float) Math.Sin(_radian); temp1 = (p1.x - p2.x)/2.0f; temp2 = (p1.y - p2.y)/2.0f; float tx = (_CosRadian*temp1) + (_SinRadian*temp2); float ty = (-_SinRadian*temp1) + (_CosRadian*temp2); double trx2 = rx*rx; double try2 = ry*ry; double tx2 = tx*tx; double ty2 = ty*ty; double radiiCheck = tx2/trx2 + ty2/try2; if (radiiCheck > 1) { rx = (float) Math.Sqrt((float) radiiCheck)*rx; ry = (float) Math.Sqrt((float) radiiCheck)*ry; trx2 = rx*rx; try2 = ry*ry; } double tm1 = (trx2*try2 - trx2*ty2 - try2*tx2)/(trx2*ty2 + try2*tx2); tm1 = (tm1 < 0) ? 0 : tm1; float tm2 = (largeArcFlag == sweepFlag) ? -(float) Math.Sqrt((float) tm1) : (float) Math.Sqrt((float) tm1); float tcx = tm2*((rx*ty)/ry); float tcy = tm2*(-(ry*tx)/rx); float cx = _CosRadian*tcx - _SinRadian*tcy + ((p1.x + p2.x)/2.0f); float cy = _SinRadian*tcx + _CosRadian*tcy + ((p1.y + p2.y)/2.0f); float ux = (tx - tcx)/rx; float uy = (ty - tcy)/ry; float vx = (-tx - tcx)/rx; float vy = (-ty - tcy)/ry; float tp, n; n = (float) Math.Sqrt((ux*ux) + (uy*uy)); tp = ux; float _angle = (uy < 0) ? -(float) Math.Acos(tp/n) : (float) Math.Acos(tp/n); _angle = _angle*180.0f/Mathf.PI; _angle %= 360f; n = (float) Math.Sqrt((ux*ux + uy*uy)*(vx*vx + vy*vy)); tp = ux*vx + uy*vy; float _delta = (ux*vy - uy*vx < 0) ? -(float) Math.Acos(tp/n) : (float) Math.Acos(tp/n); _delta = _delta*180.0f/Mathf.PI; if (!sweepFlag && _delta > 0) { _delta -= 360f; } else if (sweepFlag && _delta < 0) _delta += 360f; _delta %= 360f; int number = 50; float deltaT = _delta/number; //---Get Control Point Vector2 _controlPoint1 = Vector2.zero; Vector2 _controlPoint2 = Vector2.zero; for (int i = 0; i <= number; i++) { float t_angle = (deltaT*i + _angle)*Mathf.PI/180.0f; _controlPoint1.x = _CosRadian*rx*(float) Math.Cos(t_angle) - _SinRadian*ry*(float) Math.Sin(t_angle) + cx; _controlPoint1.y = _SinRadian*rx*(float) Math.Cos(t_angle) + _CosRadian*ry*(float) Math.Sin(t_angle) + cy; if ((_controlPoint1.x != p1.x) && (_controlPoint1.y != p1.y)) { i = number + 1; } } for (int i = number; i >= 0; i--) { float t_angle = (deltaT*i + _angle)*Mathf.PI/180.0f; _controlPoint2.x = _CosRadian*rx*(float) Math.Cos(t_angle) - _SinRadian*ry*(float) Math.Sin(t_angle) + cx; _controlPoint2.y = _SinRadian*rx*(float) Math.Cos(t_angle) + _CosRadian*ry*(float) Math.Sin(t_angle) + cy; if ((_controlPoint2.x != p2.x) && (_controlPoint2.y != p2.y)) { i = -1; } } //----- Vector2 _p1 = Vector2.zero; Vector2 _p2 = Vector2.zero; Vector2 _p3 = Vector2.zero; Vector2 _p4 = Vector2.zero; _graphics.GetThickLine(p1, _controlPoint1, width, ref _p1, ref _p2, ref _p3, ref _p4); Vector2 _p5 = Vector2.zero; Vector2 _p6 = Vector2.zero; Vector2 _p7 = Vector2.zero; Vector2 _p8 = Vector2.zero; _graphics.GetThickLine(_controlPoint2, p2, width, ref _p5, ref _p6, ref _p7, ref _p8); float _half = width/2f; float _ihalf1 = _half; float _ihalf2 = width - _ihalf1 + 0.5f; //----- float t_len1 = (_p1.x - cx)*(_p1.x - cx) + (_p1.y - cy)*(_p1.y - cy); float t_len2 = (_p2.x - cx)*(_p2.x - cx) + (_p2.y - cy)*(_p2.y - cy); Vector2 tempPoint; if (t_len1 > t_len2) { tempPoint = _p1; _p1 = _p2; _p2 = tempPoint; } t_len1 = (_p7.x - cx)*(_p7.x - cx) + (_p7.y - cy)*(_p7.y - cy); t_len2 = (_p8.x - cx)*(_p8.x - cx) + (_p8.y - cy)*(_p8.y - cy); if (t_len1 > t_len2) { tempPoint = _p7; _p7 = _p8; _p8 = tempPoint; } Profiler.BeginSample("SVGGraphicsStroke.ArcTo[CreateGraphicsPath]"); SVGGraphicsPath _graphicsPath = new SVGGraphicsPath(); _graphicsPath.AddMoveTo(_p2); _graphicsPath.AddArcTo(r1 + _ihalf1, r2 + _ihalf1, angle, largeArcFlag, sweepFlag, _p8); _graphicsPath.AddLineTo(_p7); _graphicsPath.AddArcTo(r1 - _ihalf2, r2 - _ihalf2, angle, largeArcFlag, !sweepFlag, _p1); _graphicsPath.AddLineTo(_p2); Profiler.EndSample(); Profiler.BeginSample("SVGGraphicsStroke.ArcTo[FillPath]"); _graphics.FillPath(_graphicsPath); Profiler.EndSample(); MoveTo(p); Profiler.EndSample(); }
//----- public void QuadraticCurveTo(Vector2 p1, Vector2 p, float width) { Vector2 _point = Vector2.zero; _point = _basicDraw.currentPoint; Vector2 _p1 = Vector2.zero; Vector2 _p2 = Vector2.zero; Vector2 _p3 = Vector2.zero; Vector2 _p4 = Vector2.zero; _graphics.GetThickLine(_point, p1, width, ref _p1, ref _p2, ref _p3, ref _p4); Vector2 _p5 = Vector2.zero; Vector2 _p6 = Vector2.zero; Vector2 _p7 = Vector2.zero; Vector2 _p8 = Vector2.zero; _graphics.GetThickLine(p1, p, width, ref _p5, ref _p6, ref _p7, ref _p8); Vector2 _cp1, _cp2; _cp1 = _graphics.GetCrossPoint(_p1, _p3, _p5, _p7); _cp2 = _graphics.GetCrossPoint(_p2, _p4, _p6, _p8); SVGGraphicsPath _graphicsPath = new SVGGraphicsPath(); _graphicsPath.AddMoveTo(_p2); _graphicsPath.AddQuadraticCurveTo(_cp2, _p8); _graphicsPath.AddLineTo(_p7); _graphicsPath.AddQuadraticCurveTo(_cp1, _p1); _graphicsPath.AddLineTo(_p2); _graphics.FillPath(_graphicsPath); MoveTo(p); }
//----- public void Ellipse(Vector2 p, float rx, float ry, float angle, float width) { if ((int) width == 1) { Ellipse(p, rx, ry, angle); } else { int r1 = (int) (width/2f); int r2 = (int) width - r1; //Vector2[] _points = new Vector2[1] { p }; SVGGraphicsPath _graphicsPath = new SVGGraphicsPath(); _graphicsPath.AddEllipseTo(p, rx + r1, ry + r1, angle); _graphicsPath.AddEllipseTo(p, rx - r2, ry - r2, angle); _graphics.FillPath(_graphicsPath, p); } }
//----- //Fill co Stroke trong do luon public void DrawPath(SVGGraphicsPath graphicsPath, float width) { _width = width; isUseWidth = true; graphicsPath.RenderPath(this, false); isUseWidth = false; }
//================================================================================ //-------------------------------------------------------------------------------- //Methods: DrawPath //-------------------------------------------------------------------------------- public void DrawPath(SVGGraphicsPath graphicsPath) { graphicsPath.RenderPath(this, false); }
public bool Render(SVGGraphicsPath path, ISVGPathDraw pathDraw) { pathDraw.QuadraticCurveTo(path.matrixTransform.Transform(p1), path.matrixTransform.Transform(p)); return false; }
public void ExpandBounds(SVGGraphicsPath path) { path.ExpandBounds(points); }
private void SetGradientVector(SVGGraphicsPath graphicsPath) { Rect bound = graphicsPath.GetBound(); if(_linearGradElement.x1.unitType == SVGLengthType.Percentage) _x1 = bound.x + (bound.width * _x1 / 100f); if(_linearGradElement.y1.unitType == SVGLengthType.Percentage) _y1 = bound.y + (bound.height * _y1 / 100f); if(_linearGradElement.x2.unitType == SVGLengthType.Percentage) _x2 = bound.x + (bound.width * _x2 / 100f); if(_linearGradElement.y2.unitType == SVGLengthType.Percentage) _y2 = bound.y + (bound.height * _y2 / 100f); if(_linearGradElement.gradientUnits == SVGGradientUnit.ObjectBoundingBox) { Vector2 _point = graphicsPath.matrixTransform.Transform(new Vector2(_x1, _y1)); _x1 = _point.x; _y1 = _point.y; _point = graphicsPath.matrixTransform.Transform(new Vector2(_x2, _y2)); _x2 = _point.x; _y2 = _point.y; } }
//-------------------------------------------------------------------------------- //Method: Render //-------------------------------------------------------------------------------- public void Render(SVGGraphicsPath _graphicsPath) { Vector2 p; p = currentPoint; _graphicsPath.AddLineTo(p); }
public void Render(SVGGraphicsPath _graphicsPath) { _graphicsPath.AddArcTo(this._r1, this._r2, this._angle, this._largeArcFlag, this._sweepFlag, currentPoint); }
public void Render(SVGGraphicsPath _graphicsPath) { _graphicsPath.AddCubicCurveTo(controlPoint1, controlPoint2, currentPoint); }
public void Render(SVGGraphicsPath _graphicsPath) { _graphicsPath.AddLineTo(currentPoint); }
//----- public void Circle(Vector2 p, float r, float width) { if ((int) width == 1) { Circle(p, r); } else { int r1 = (int) (width/2f); int r2 = (int) width - r1; //Vector2[] _points = new Vector2[1]; //_points[0] = new Vector2(p.x, p.y); SVGGraphicsPath _graphicsPath = new SVGGraphicsPath(); _graphicsPath.AddCircleTo(p, r + r1); _graphicsPath.AddCircleTo(p, r - r2); _graphics.FillPath(_graphicsPath, p); } }
//----- public void CubicCurveTo(Vector2 p1, Vector2 p2, Vector2 p, float width) { Vector2 _point = Vector2.zero; _point = _basicDraw.currentPoint; Vector2 _p1 = Vector2.zero; Vector2 _p2 = Vector2.zero; Vector2 _p3 = Vector2.zero; Vector2 _p4 = Vector2.zero; bool temp; temp = _graphics.GetThickLine(_point, p1, width, ref _p1, ref _p2, ref _p3, ref _p4); if (temp == false) { QuadraticCurveTo(p2, p, width); return; } Vector2 _p5 = Vector2.zero; Vector2 _p6 = Vector2.zero; Vector2 _p7 = Vector2.zero; Vector2 _p8 = Vector2.zero; _graphics.GetThickLine(p1, p2, width, ref _p5, ref _p6, ref _p7, ref _p8); Vector2 _p9 = Vector2.zero; Vector2 _p10 = Vector2.zero; Vector2 _p11 = Vector2.zero; Vector2 _p12 = Vector2.zero; _graphics.GetThickLine(p2, p, width, ref _p9, ref _p10, ref _p11, ref _p12); Vector2 _cp1, _cp2, _cp3, _cp4; _cp1 = _graphics.GetCrossPoint(_p1, _p3, _p5, _p7); _cp2 = _graphics.GetCrossPoint(_p2, _p4, _p6, _p8); _cp3 = _graphics.GetCrossPoint(_p5, _p7, _p9, _p11); _cp4 = _graphics.GetCrossPoint(_p6, _p8, _p10, _p12); _basicDraw.MoveTo(_point); _basicDraw.CubicCurveTo(p1, p2, p); SVGGraphicsPath _graphicsPath = new SVGGraphicsPath(); _graphicsPath.AddMoveTo(_p2); _graphicsPath.AddCubicCurveTo(_cp2, _cp4, _p12); _graphicsPath.AddLineTo(_p11); _graphicsPath.AddCubicCurveTo(_cp3, _cp1, _p1); _graphicsPath.AddLineTo(_p2); _graphics.FillPath(_graphicsPath); MoveTo(p); }
//---------------------- public SVGRadialGradientBrush GetRadialGradientBrush(SVGGraphicsPath graphicsPath) { for(int i=0; i < this._radialGradList.Count; i++) { if(this._radialGradList[i].id == this._gradientID) { return new SVGRadialGradientBrush(this._radialGradList[i], graphicsPath); } } return null; }
public void ExpandBounds(SVGGraphicsPath path) { path.ExpandBounds(p1); path.ExpandBounds(p); }