| public FillPath ( SVGColor, fillColor, SVGColor, strokePathColor, SVGGraphicsPath, graphicsPath ) : void | ||
| fillColor | SVGColor, | |
| strokePathColor | SVGColor, | |
| graphicsPath | SVGGraphicsPath, | |
| return | void | |
public void Render()
{
CreateGraphicsPath();
_render.SetStrokeLineCap(_paintable.strokeLineCap);
_render.SetStrokeLineJoin(_paintable.strokeLineJoin);
switch (_paintable.GetPaintType())
{
case SVGPaintMethod.SolidGradientFill:
{
_render.FillPath(_paintable.fillColor.Value, _graphicsPath);
Draw();
break;
}
case SVGPaintMethod.LinearGradientFill:
{
SVGLinearGradientBrush _linearGradBrush =
_paintable.GetLinearGradientBrush(_graphicsPath);
if (_linearGradBrush != null)
{
_render.FillPath(_linearGradBrush, _graphicsPath);
}
Draw();
break;
}
case SVGPaintMethod.RadialGradientFill:
{
SVGRadialGradientBrush _radialGradBrush =
_paintable.GetRadialGradientBrush(_graphicsPath);
if (_radialGradBrush != null)
{
_render.FillPath(_radialGradBrush, _graphicsPath);
}
Draw();
break;
}
case SVGPaintMethod.PathDraw:
{
Draw();
break;
}
}
}
public void ArcTo(float r1, float r2, float angle, bool largeArcFlag, bool sweepFlag, Vector2 p, float width)
{
Profiler.BeginSample("SVGGraphicsStroke.ArcTo");
float rx = r1, ry = r2;
Vector2 p1 = _basicDraw.currentPoint, p2 = p;
float _radian = (angle * Mathf.PI / 180.0f);
// TODO: Do we have single-precision methods we can use here? How's the performance?
float _CosRadian = (float)Math.Cos(_radian);
float _SinRadian = (float)Math.Sin(_radian);
float temp1 = (p1.x - p2.x) / 2.0f;
float 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();
}
