static void CreateStroke(SVGRectElement svgElement)
{
string name = svgElement.attrList.GetValue("id");
if (string.IsNullOrEmpty(name))
{
name = "Rectangle Stroke ";
}
List <List <Vector2> > stroke = SVGSimplePath.CreateStroke(SVGGraphics.position_buffer, svgElement.paintable, ClosePathRule.ALWAYS);
if (svgElement.paintable.clipPathList != null && svgElement.paintable.clipPathList.Count > 0)
{
stroke = SVGGeom.ClipPolygon(stroke, svgElement.paintable.clipPathList);
}
Mesh antialiasingMesh;
Mesh mesh = SVGLineUtils.TessellateStroke(stroke, SVGSimplePath.GetStrokeColor(svgElement.paintable), out antialiasingMesh);
if (mesh == null)
{
return;
}
mesh.name = name;
SVGGraphics.AddMesh(new SVGMesh(mesh, svgElement.paintable.svgFill, svgElement.paintable.opacity));
if (antialiasingMesh != null)
{
SVGFill svgFill = svgElement.paintable.svgFill.Clone();
svgFill.blend = FILL_BLEND.ALPHA_BLENDED;
SVGGraphics.AddMesh(new SVGMesh(antialiasingMesh, svgFill, svgElement.paintable.opacity));
}
}
/*
* public static Mesh CreateAntialiasing(List<List<Vector2>> paths, Color color, float antialiasingWidth, bool isStroke = false, ClosePathRule closePath = ClosePathRule.NEVER)
* {
* if(SVGAssetImport.antialiasingWidth <= 0f) return null;
* return SVGSimplePath.CreateAntialiasing(paths, color, antialiasingWidth, closePath);
* }
*/
private static void UpdateMesh(Mesh mesh, SVGFill svgFill)
{
if (svgFill.fillType == FILL_TYPE.GRADIENT && svgFill.gradientColors != null)
{
SVGMeshUtils.ChangeMeshUV2(mesh, new Vector2(svgFill.gradientColors.index, (int)svgFill.gradientType));
}
else
{
SVGMeshUtils.ChangeMeshColor(mesh, svgFill.color);
}
}
public SVGFill Clone()
{
SVGFill fill = new SVGFill(this.color, this.blend, this.fillType, this.gradientType);
fill.gradientId = this.gradientId;
fill.gradientTransform = this.gradientTransform;
if (gradientColors != null)
{
fill.gradientColors = gradientColors.Clone();
}
return(fill);
}
public SVGFill Clone()
{
SVGFill fill = new SVGFill(this.color, this.blend, this.fillType, this.gradientType);
fill.gradientId = this.gradientId;
fill.transform = this.transform;
fill.opacity = this.opacity;;
fill.viewport = this.viewport;
if (gradientColors != null)
{
fill.gradientColors = gradientColors.Clone();
}
return(fill);
}
protected static void WriteUVGradientIndexType(ref Vector2[] uv, int meshVertexCount, SVGPaintable svgPaintable)
{
SVGFill svgFill = svgPaintable.svgFill;
if (svgFill.fillType == FILL_TYPE.GRADIENT && svgFill.gradientColors != null)
{
Vector2 gradientUV = new Vector2(svgFill.gradientColors.index, (int)svgFill.gradientType);
uv = new Vector2[meshVertexCount];
for (int i = 0; i < meshVertexCount; i++)
{
uv [i].x = gradientUV.x;
uv [i].y = gradientUV.y;
}
}
}
private void CreateFill()
{
if (_alphaBlended)
{
_fill = new SVGFill(Color.white, FILL_BLEND.ALPHA_BLENDED, FILL_TYPE.GRADIENT, GRADIENT_TYPE.RADIAL);
}
else
{
_fill = new SVGFill(Color.white, FILL_BLEND.OPAQUE, FILL_TYPE.GRADIENT, GRADIENT_TYPE.RADIAL);
}
_fill.gradientTransform = _radialGradElement.gradientTransform.Consolidate().matrix;
_fill.transform = _transform;
_fill.gradientColors = SVGAssetImport.atlasData.AddGradient(ParseGradientColors());
_fill.gradientStartX = _cx;
_fill.gradientStartY = _cy;
_fill.gradientEndX = _r;
_fill.gradientEndY = _r;
}
static void CreateFill(SVGRectElement svgElement)
{
string name = svgElement.attrList.GetValue("id");
if (string.IsNullOrEmpty(name))
{
name = "Rectangle Fill";
}
List <List <Vector2> > path;
if (svgElement.paintable.clipPathList != null && svgElement.paintable.clipPathList.Count > 0)
{
path = SVGGeom.ClipPolygon(new List <List <Vector2> >()
{
SVGGraphics.position_buffer
}, svgElement.paintable.clipPathList);
}
else
{
path = new List <List <Vector2> >()
{
SVGGraphics.position_buffer
};
}
Mesh antialiasingMesh;
Mesh mesh = SVGSimplePath.CreatePolygon(path, svgElement.paintable, svgElement.transformMatrix, out antialiasingMesh);
if (mesh == null)
{
return;
}
mesh.name = name;
SVGGraphics.AddMesh(new SVGMesh(mesh, svgElement.paintable.svgFill, svgElement.paintable.opacity));
if (antialiasingMesh != null)
{
SVGFill svgFill = svgElement.paintable.svgFill.Clone();
svgFill.blend = FILL_BLEND.ALPHA_BLENDED;
SVGGraphics.AddMesh(new SVGMesh(antialiasingMesh, svgFill, svgElement.paintable.opacity));
}
}
private void CreateFill()
{
if (_alphaBlended)
{
_fill = new SVGFill(Color.white, FILL_BLEND.ALPHA_BLENDED, FILL_TYPE.GRADIENT, GRADIENT_TYPE.CONICAL);
}
else
{
_fill = new SVGFill(Color.white, FILL_BLEND.OPAQUE, FILL_TYPE.GRADIENT, GRADIENT_TYPE.CONICAL);
}
_fill.gradientTransform = _conicalGradElement.gradientTransform.Consolidate().matrix;
_fill.transform = _transform;
// _fill.bounds = bounds;
_fill.gradientColors = SVGAtlas.Instance.AddGradient(ParseGradientColors(), false);
_fill.gradientStartX = _cx;
_fill.gradientStartY = _cy;
_fill.gradientEndX = _r;
_fill.gradientEndY = _r;
}
private void CreateFill()
{
if (_alphaBlended)
{
_fill = new SVGFill(Color.white, FILL_BLEND.ALPHA_BLENDED, FILL_TYPE.GRADIENT, GRADIENT_TYPE.LINEAR);
}
else
{
_fill = new SVGFill(Color.white, FILL_BLEND.OPAQUE, FILL_TYPE.GRADIENT, GRADIENT_TYPE.LINEAR);
}
_gradientTransform = _linearGradElement.gradientTransform.Consolidate().matrix;
_fill.gradientColors = SVGAssetImport.atlasData.AddGradient(ParseGradientColors());
_fill.viewport = _viewport;
/*
* _fill.transform = _transform;
* _fill.gradientStartX = _x1;
* _fill.gradientStartY = _y1;
* _fill.gradientEndX = _x2;
* _fill.gradientEndY = _y2;
*/
}
protected static void WriteUVGradientCoordinates(ref Vector2[] uv, Vector3[] vertices, SVGPaintable svgPaintable, Rect bounds)
{
SVGFill svgFill = svgPaintable.svgFill;
if (svgFill.fillType == FILL_TYPE.GRADIENT)
{
int meshVertexCount = vertices.Length;
uv = new Vector2[meshVertexCount];
Vector2 uvPoint = Vector2.zero;
SVGMatrix svgFillTransform = GetFillTransform(svgPaintable, bounds);
Rect viewport = svgPaintable.viewport;
for (int i = 0; i < meshVertexCount; i++)
{
uvPoint.x = vertices [i].x;
uvPoint.y = vertices [i].y;
uvPoint = svgFillTransform.Transform(uvPoint);
uv [i].x = (uvPoint.x - viewport.x) / viewport.width;
uv [i].y = (uvPoint.y - viewport.y) / viewport.height;
}
}
}
//const float defaultViewportScale = 800f;
private static SVGMatrix GetFillTransform(SVGPaintable svgPaintable, Rect bounds)
{
SVGFill svgFill = svgPaintable.svgFill;
SVGMatrix transform = new SVGMatrix();
SVGMatrix gradientMatrix = svgFill.gradientTransform;
Rect viewport = svgPaintable.viewport;
if (svgFill.fillType == FILL_TYPE.GRADIENT)
{
switch (svgFill.gradientType)
{
case GRADIENT_TYPE.LINEAR:
{
Vector2 startPoint = GetGradientVector(svgFill.gradientStartX, svgFill.gradientStartY, bounds);
Vector2 endPoint = GetGradientVector(svgFill.gradientEndX, svgFill.gradientEndY, bounds);
Vector2 gradientVector = endPoint - startPoint;
Vector2 normalizedVector = Vector2.zero;
float angle = Mathf.Atan2(gradientVector.y, gradientVector.x) * Mathf.Rad2Deg;
Vector2 posDiff = Vector2.Lerp(startPoint, endPoint, 0.5f);
float magnitude = gradientVector.magnitude;
if (magnitude != 0f)
{
normalizedVector.x = viewport.width / magnitude;
normalizedVector.y = viewport.height / magnitude;
}
transform = transform.Translate(viewport.center);
transform = transform.ScaleNonUniform(normalizedVector.x, normalizedVector.y);
transform = transform.Rotate(-angle);
transform = transform.Translate(-posDiff);
transform = transform.Multiply(gradientMatrix.Inverse());
transform = transform.Multiply(svgFill.transform.Inverse());
break;
}
case GRADIENT_TYPE.RADIAL:
{
Vector2 point = GetGradientVector(svgFill.gradientStartX, svgFill.gradientStartY, bounds);
float radius = GetGradientVector(svgFill.gradientEndX, svgFill.gradientEndY, bounds).x;
if (svgFill.gradientEndX.unitType == SVGLengthType.Percentage)
{
radius *= 0.5f;
}
float radiusTimesTwo = radius * 2f;
Vector2 normalizedVector = Vector2.zero;
if (radiusTimesTwo != 0f)
{
normalizedVector.x = viewport.width / radiusTimesTwo;
normalizedVector.y = viewport.height / radiusTimesTwo;
}
transform = transform.Translate(viewport.center);
transform = transform.ScaleNonUniform(normalizedVector.x, normalizedVector.y);
transform = transform.Translate(-point);
transform = transform.Multiply(gradientMatrix.Inverse());
transform = transform.Multiply(svgFill.transform.Inverse());
break;
}
case GRADIENT_TYPE.CONICAL:
{
Vector2 point = GetGradientVector(svgFill.gradientStartX, svgFill.gradientStartY, bounds);
float radius = GetGradientVector(svgFill.gradientEndX, svgFill.gradientEndY, bounds).x;
if (svgFill.gradientEndX.unitType == SVGLengthType.Percentage)
{
radius *= 0.5f;
}
float radiusTimesTwo = radius * 2f;
Vector2 normalizedVector = Vector2.zero;
if (radiusTimesTwo != 0f)
{
normalizedVector.x = viewport.width / radiusTimesTwo;
normalizedVector.y = viewport.height / radiusTimesTwo;
}
transform = transform.Translate(viewport.center);
transform = transform.ScaleNonUniform(normalizedVector.x, normalizedVector.y);
transform = transform.Translate(-point);
transform = transform.Multiply(gradientMatrix.Inverse());
transform = transform.Multiply(svgFill.transform.Inverse());
break;
}
}
}
return(transform);
}
public SVGFill Clone()
{
SVGFill fill = new SVGFill(this.color, this.blend, this.fillType, this.gradientType);
fill.gradientId = this.gradientId;
fill.gradientTransform = this.gradientTransform;
if(gradientColors != null)
fill.gradientColors = gradientColors.Clone();
return fill;
}
private static void UpdateMesh(Mesh mesh, SVGFill svgFill)
{
if (svgFill.fillType == FILL_TYPE.GRADIENT && svgFill.gradientColors != null)
{
SVGMeshUtils.ChangeMeshUV2(mesh, new Vector2(svgFill.gradientColors.index, (int)svgFill.gradientType));
} else {
SVGMeshUtils.ChangeMeshColor(mesh, svgFill.color);
}
}
private void CreateFill()
{
if(_alphaBlended)
{
_fill = new SVGFill(Color.white, FILL_BLEND.ALPHA_BLENDED, FILL_TYPE.GRADIENT, GRADIENT_TYPE.RADIAL);
} else {
_fill = new SVGFill(Color.white, FILL_BLEND.OPAQUE, FILL_TYPE.GRADIENT, GRADIENT_TYPE.RADIAL);
}
_fill.gradientTransform = _radialGradElement.gradientTransform.Consolidate().matrix;
_fill.transform = _transform;
// _fill.bounds = bounds;
_fill.gradientColors = SVGAtlas.Instance.AddGradient(ParseGradientColors(), false);
_fill.gradientStartX = _cx;
_fill.gradientStartY = _cy;
_fill.gradientEndX = _r;
_fill.gradientEndY = _r;
}
public static Mesh CreatePolygon(List <List <Vector2> > inputShapes, SVGPaintable paintable, SVGMatrix matrix, out Mesh antialiasingMesh)
{
antialiasingMesh = null;
if (inputShapes == null || inputShapes.Count == 0)
{
return(null);
}
List <List <Vector2> > simplifiedShapes = new List <List <Vector2> >();
PolyFillType fillType = PolyFillType.pftNonZero;
if (paintable.fillRule == SVGFillRule.EvenOdd)
{
fillType = PolyFillType.pftEvenOdd;
}
simplifiedShapes = SVGGeom.SimplifyPolygons(inputShapes, fillType);
if (simplifiedShapes == null || simplifiedShapes.Count == 0)
{
return(null);
}
AddInputShape(simplifiedShapes);
Rect bounds = GetRect(simplifiedShapes);
switch (paintable.GetPaintType())
{
case SVGPaintMethod.SolidGradientFill:
{
Color color = Color.black;
SVGColorType colorType = paintable.fillColor.Value.colorType;
if (colorType == SVGColorType.Unknown || colorType == SVGColorType.None)
{
color.a *= paintable.fillOpacity;
paintable.svgFill = new SVGFill(color);
}
else
{
color = paintable.fillColor.Value.color;
color.a *= paintable.fillOpacity;
paintable.svgFill = new SVGFill(color);
}
paintable.svgFill.fillType = FILL_TYPE.SOLID;
if (color.a == 1)
{
paintable.svgFill.blend = FILL_BLEND.OPAQUE;
}
else
{
paintable.svgFill.blend = FILL_BLEND.ALPHA_BLENDED;
}
}
break;
case SVGPaintMethod.LinearGradientFill:
{
SVGLinearGradientBrush linearGradBrush = paintable.GetLinearGradientBrush(bounds, matrix);
paintable.svgFill = linearGradBrush.fill;
}
break;
case SVGPaintMethod.RadialGradientFill:
{
SVGRadialGradientBrush radialGradBrush = paintable.GetRadialGradientBrush(bounds, matrix);
paintable.svgFill = radialGradBrush.fill;
}
break;
case SVGPaintMethod.ConicalGradientFill:
{
SVGConicalGradientBrush conicalGradBrush = paintable.GetConicalGradientBrush(bounds, matrix);
paintable.svgFill = conicalGradBrush.fill;
}
break;
case SVGPaintMethod.PathDraw:
{
Color color = Color.black;
SVGColorType colorType = paintable.fillColor.Value.colorType;
if (colorType == SVGColorType.Unknown || colorType == SVGColorType.None)
{
color.a *= paintable.strokeOpacity;
paintable.svgFill = new SVGFill(color);
}
else
{
color = paintable.fillColor.Value.color;
color.a *= paintable.strokeOpacity;
paintable.svgFill = new SVGFill(color);
}
paintable.svgFill.fillType = FILL_TYPE.SOLID;
if (color.a == 1)
{
paintable.svgFill.blend = FILL_BLEND.OPAQUE;
}
else
{
paintable.svgFill.blend = FILL_BLEND.ALPHA_BLENDED;
}
}
break;
default:
break;
}
LibTessDotNet.Tess tesselation = new LibTessDotNet.Tess();
LibTessDotNet.ContourVertex[] path;
int pathLength;
for (int i = 0; i < simplifiedShapes.Count; i++)
{
if (simplifiedShapes[i] == null)
{
continue;
}
pathLength = simplifiedShapes[i].Count;
path = new LibTessDotNet.ContourVertex[pathLength];
Vector2 position;
for (int j = 0; j < pathLength; j++)
{
position = simplifiedShapes[i][j];
path[j].Position = new LibTessDotNet.Vec3 {
X = position.x, Y = position.y, Z = 0f
};
}
tesselation.AddContour(path);
}
tesselation.Tessellate(LibTessDotNet.WindingRule.EvenOdd, LibTessDotNet.ElementType.Polygons, 3);
Mesh mesh = new Mesh();
int meshVertexCount = tesselation.Vertices.Length;
Vector3[] vertices = new Vector3[meshVertexCount];
Vector2[] uv = null;
Vector2[] uv2 = null;
for (int i = 0; i < meshVertexCount; i++)
{
vertices[i] = new Vector3(tesselation.Vertices[i].Position.X, tesselation.Vertices[i].Position.Y, 0f);
}
int numTriangles = tesselation.ElementCount;
int[] triangles = new int[numTriangles * 3];
for (int i = 0; i < numTriangles; i++)
{
triangles[i * 3] = tesselation.Elements[i * 3];
triangles[i * 3 + 1] = tesselation.Elements[i * 3 + 1];
triangles[i * 3 + 2] = tesselation.Elements[i * 3 + 2];
}
SVGFill svgFill = paintable.svgFill;
Color32 fillColor = Color.white;
if (svgFill.fillType != FILL_TYPE.GRADIENT && svgFill.gradientColors == null)
{
fillColor = svgFill.color;
}
antialiasingMesh = CreateAntialiasing(simplifiedShapes, fillColor, -SVGAssetImport.antialiasingWidth, false, SVGImporter.Utils.ClosePathRule.ALWAYS);
Color32[] colors32 = new Color32[meshVertexCount];
for (int i = 0; i < meshVertexCount; i++)
{
colors32 [i].r = fillColor.r;
colors32 [i].g = fillColor.g;
colors32 [i].b = fillColor.b;
colors32 [i].a = fillColor.a;
}
if (antialiasingMesh != null)
{
Vector3[] antialiasingVertices = antialiasingMesh.vertices;
Vector2[] antialiasingUV = antialiasingMesh.uv;
Vector2[] antialiasingUV2 = antialiasingMesh.uv2;
WriteUVGradientCoordinates(ref antialiasingUV, antialiasingVertices, paintable, bounds);
WriteUVGradientIndexType(ref antialiasingUV2, antialiasingVertices.Length, paintable);
antialiasingMesh.uv = antialiasingUV;
antialiasingMesh.uv2 = antialiasingUV2;
}
WriteUVGradientCoordinates(ref uv, vertices, paintable, bounds);
WriteUVGradientIndexType(ref uv2, meshVertexCount, paintable);
mesh.vertices = vertices;
mesh.triangles = triangles;
if (colors32 != null)
{
mesh.colors32 = colors32;
}
if (uv != null)
{
mesh.uv = uv;
}
if (uv2 != null)
{
mesh.uv2 = uv2;
}
return(mesh);
}
//const float defaultViewportScale = 800f;
public static SVGMatrix GetFillTransform(SVGFill svgFill, Rect bounds, SVGLength[] gradientStart, SVGLength[] gradientEnd, SVGMatrix fillTransform, SVGMatrix gradientTransform)
{
SVGMatrix transform = SVGMatrix.identity;
SVGLength gradientStartX = gradientStart[0];
SVGLength gradientStartY = gradientStart[1];
SVGLength gradientEndX = gradientEnd[0];
SVGLength gradientEndY = gradientEnd[1];
Rect viewport = svgFill.viewport;
//Debug.Log(viewport);
if (svgFill.fillType == FILL_TYPE.GRADIENT)
{
switch (svgFill.gradientType)
{
case GRADIENT_TYPE.LINEAR:
{
Vector2 startPoint = GetGradientVector(gradientStartX, gradientStartY, bounds);
Vector2 endPoint = GetGradientVector(gradientEndX, gradientEndY, bounds);
Vector2 gradientVector = endPoint - startPoint;
Vector2 normalizedVector = Vector2.zero;
float angle = Mathf.Atan2(gradientVector.y, gradientVector.x) * Mathf.Rad2Deg;
Vector2 posDiff = Vector2.Lerp(startPoint, endPoint, 0.5f);
float magnitude = gradientVector.magnitude;
if (magnitude != 0f)
{
normalizedVector.x = viewport.width / magnitude;
normalizedVector.y = viewport.height / magnitude;
}
transform = transform.Translate(viewport.center);
transform = transform.Scale(normalizedVector.x, normalizedVector.y);
transform = transform.Rotate(-angle);
transform = transform.Translate(-posDiff);
transform = transform.Multiply(gradientTransform.Inverse());
transform = transform.Multiply(fillTransform.Inverse());
break;
}
case GRADIENT_TYPE.RADIAL:
{
Vector2 point = GetGradientVector(gradientStartX, gradientStartY, bounds);
float radius = GetGradientVector(gradientEndX, gradientEndY, bounds).x;
if (gradientEndX.unitType == SVGLengthType.Percentage)
{
radius *= 0.5f;
}
float radiusTimesTwo = radius * 2f;
Vector2 normalizedVector = Vector2.zero;
if (radiusTimesTwo != 0f)
{
normalizedVector.x = viewport.width / radiusTimesTwo;
normalizedVector.y = viewport.height / radiusTimesTwo;
}
transform = transform.Translate(viewport.center);
transform = transform.Scale(normalizedVector.x, normalizedVector.y);
transform = transform.Translate(-point);
transform = transform.Multiply(gradientTransform.Inverse());
transform = transform.Multiply(fillTransform.Inverse());
break;
}
case GRADIENT_TYPE.CONICAL:
{
Vector2 point = GetGradientVector(gradientStartX, gradientStartY, bounds);
float radius = GetGradientVector(gradientEndX, gradientEndY, bounds).x;
if (gradientEndX.unitType == SVGLengthType.Percentage)
{
radius *= 0.5f;
}
float radiusTimesTwo = radius * 2f;
Vector2 normalizedVector = Vector2.zero;
if (radiusTimesTwo != 0f)
{
normalizedVector.x = viewport.width / radiusTimesTwo;
normalizedVector.y = viewport.height / radiusTimesTwo;
}
transform = transform.Translate(viewport.center);
transform = transform.Scale(normalizedVector.x, normalizedVector.y);
transform = transform.Translate(-point);
transform = transform.Multiply(gradientTransform.Inverse());
transform = transform.Multiply(fillTransform.Inverse());
break;
}
}
}
return(transform);
}
private void CreateFill()
{
if(_alphaBlended)
{
_fill = new SVGFill(Color.white, FILL_BLEND.ALPHA_BLENDED, FILL_TYPE.GRADIENT, GRADIENT_TYPE.CONICAL);
} else {
_fill = new SVGFill(Color.white, FILL_BLEND.OPAQUE, FILL_TYPE.GRADIENT, GRADIENT_TYPE.CONICAL);
}
_fill.gradientTransform = _conicalGradElement.gradientTransform.Consolidate().matrix;
_fill.transform = _transform;
_fill.gradientColors = SVGAssetImport.atlasData.AddGradient(ParseGradientColors());
_fill.gradientStartX = _cx;
_fill.gradientStartY = _cy;
_fill.gradientEndX = _r;
_fill.gradientEndY = _r;
}
