void DebugPoints(SVGLayer svgLayer, SVGAsset svgAsset)
{
if (Event.current.type == EventType.Repaint)
{
SVGDebugLayers go = target as SVGDebugLayers;
Matrix4x4 handlesMatrix = Handles.matrix;
Handles.matrix = go.transform.localToWorldMatrix;
if (svgLayer.shapes == null || svgLayer.shapes.Length == 0)
{
return;
}
for (int i = 0; i < svgLayer.shapes.Length; i++)
{
Vector3 lastPosition = svgLayer.shapes[i].vertices[0];
Vector3 currentPosition;
for (int j = 1; j < svgLayer.shapes[i].vertexCount; j++)
{
currentPosition = svgLayer.shapes[i].vertices[j];
Handles.DrawLine(lastPosition, currentPosition);
lastPosition = currentPosition;
}
}
Handles.matrix = handlesMatrix;
}
}
public void CreateLayer()
{
_layer = new SVGLayer();
_layer.name = name;
_layer.shapes = new SVGShape[0];
SVGGraphics.currentGroup = this;
}
public static void HilightLayer(SVGLayer layer)
{
if (layer.shapes == null)
{
return;
}
int shapesLength = layer.shapes.Length;
for (int i = 0; i < shapesLength; i++)
{
HilightShape(layer.shapes[i]);
}
}
public static bool CreatePolygon(List <Vector2> inputShape, SVGPaintable paintable, SVGMatrix matrix, out SVGLayer layer, bool isStroke = false)
{
if (inputShape == null || inputShape.Count == 0)
{
layer = new SVGLayer();
return(false);
}
return(CreatePolygon(new List <List <Vector2> >()
{
inputShape
}, paintable, matrix, out layer, isStroke));
}
public override void OnInspectorGUI()
{
SVGDebugLayers go = target as SVGDebugLayers;
SVGRenderer svgrenderer = go.GetComponent <SVGRenderer>();
if (svgrenderer == null || svgrenderer.vectorGraphics == null)
{
return;
}
currentAsset = svgrenderer.vectorGraphics;
SVGLayer[] svgLayers = currentAsset.layers;
if (svgLayers == null)
{
return;
}
for (int i = 0; i < svgLayers.Length; i++)
{
string layerName = svgLayers[i].name;
GUILayout.Label(layerName, SVGGUI.helpBox);
Rect lastRect = GUILayoutUtility.GetLastRect();
if (lastRect.Contains(Event.current.mousePosition))
{
hilightedLayer = svgLayers[i];
SceneView.RepaintAll();
}
if (svgLayers[i].shapes != null)
{
for (int j = 0; j < svgLayers[i].shapes.Length; j++)
{
GUILayout.Label(" "+ layerName + " " + svgLayers[i].shapes[j].type.ToString(), SVGGUI.helpBox);
lastRect = GUILayoutUtility.GetLastRect();
if (lastRect.Contains(Event.current.mousePosition))
{
hilightedShape = svgLayers[i].shapes[j];
SceneView.RepaintAll();
}
}
}
}
}
public static Mesh CombineMeshes(List <SVGMesh> meshes, out SVGLayer[] layers, out Shader[] shaders, SVGUseGradients useGradients = SVGUseGradients.Always, SVGAssetFormat format = SVGAssetFormat.Transparent, bool compressDepth = true)
{
layers = new SVGLayer[0];
shaders = new Shader[0];
//if(SVGAssetImport.sliceMesh) Create9Slice();
SVGFill fill;
bool useOpaqueShader = false;
bool useTransparentShader = false;
bool hasGradients = (useGradients == SVGUseGradients.Always);
int totalMeshes = meshes.Count, totalTriangles = 0, opaqueTriangles = 0, transparentTriangles = 0;
// Z Sort meshes
if (format == SVGAssetFormat.Opaque)
{
if (compressDepth)
{
SVGBounds meshBounds = SVGBounds.InfiniteInverse;
for (int i = 0; i < totalMeshes; i++)
{
if (meshes [i] == null)
{
continue;
}
meshBounds.Encapsulate(meshes [i].bounds);
}
if (!meshBounds.isInfiniteInverse)
{
SVGGraphics.depthTree.Clear();
SVGGraphics.depthTree = new SVGDepthTree(meshBounds);
for (int i = 0; i < totalMeshes; i++)
{
fill = meshes [i]._fill;
SVGMesh[] nodes = SVGGraphics.depthTree.TestDepthAdd(meshes [i], new SVGBounds(meshes [i]._bounds));
int nodesLength = 0;
if (nodes == null || nodes.Length == 0)
{
meshes [i]._depth = 0;
}
else
{
nodesLength = nodes.Length;
int highestDepth = 0;
SVGMesh highestMesh = null;
for (int j = 0; j < nodesLength; j++)
{
if (nodes[j].depth > highestDepth)
{
highestDepth = nodes[j].depth;
highestMesh = nodes[j];
}
}
if (fill.blend == FILL_BLEND.OPAQUE)
{
meshes [i]._depth = highestDepth + 1;
}
else
{
if (highestMesh != null && highestMesh.fill.blend == FILL_BLEND.OPAQUE)
{
meshes [i]._depth = highestDepth + 1;
}
else
{
meshes [i]._depth = highestDepth;
}
}
}
meshes [i].UpdateDepth();
}
}
}
else
{
int highestDepth = 0;
for (int i = 0; i < totalMeshes; i++)
{
fill = meshes [i]._fill;
if (fill.blend == FILL_BLEND.OPAQUE || lastBlendType == FILL_BLEND.OPAQUE)
{
meshes[i]._depth = ++highestDepth;
}
else
{
meshes[i]._depth = highestDepth;
}
lastBlendType = fill.blend;
meshes[i].UpdateDepth();
}
}
}
layers = new SVGLayer[totalMeshes];
int totalVertices = 0, vertexCount, vertexStart, currentVertex;
for (int i = 0; i < totalMeshes; i++)
{
fill = meshes[i]._fill;
if (fill.blend == FILL_BLEND.OPAQUE)
{
opaqueTriangles += meshes[i]._triangles.Length;
useOpaqueShader = true;
}
else if (fill.blend == FILL_BLEND.ALPHA_BLENDED)
{
transparentTriangles += meshes[i]._triangles.Length;
useTransparentShader = true;
}
if (fill.fillType == FILL_TYPE.GRADIENT)
{
hasGradients = true;
}
vertexCount = meshes[i]._vertices.Length;
Bounds bounds = meshes[i]._bounds;
layers[i] = new SVGLayer(meshes[i]._name, totalVertices, vertexCount, bounds.center, bounds.size);
totalVertices += vertexCount;
}
totalTriangles = opaqueTriangles + transparentTriangles;
if (useGradients == SVGUseGradients.Never)
{
hasGradients = false;
}
if (format != SVGAssetFormat.Opaque)
{
useOpaqueShader = false;
useTransparentShader = true;
}
Vector3[] vertices = new Vector3[totalVertices];
Color32[] colors32 = new Color32[totalVertices];
Vector2[] uv = null;
Vector2[] uv2 = null;
int[][] triangles = null;
for (int i = 0; i < totalMeshes; i++)
{
vertexStart = layers[i].vertexStart;
vertexCount = layers[i].vertexCount;
for (int j = 0; j < vertexCount; j++)
{
currentVertex = vertexStart + j;
vertices[currentVertex] = meshes[i]._vertices[j];
colors32[currentVertex] = meshes[i]._colors[j];
}
}
List <Shader> outputShaders = new List <Shader>();
// Debug.Log("hasGradients: "+hasGradients);
if (hasGradients)
{
uv = new Vector2[totalVertices];
uv2 = new Vector2[totalVertices];
for (int i = 0; i < totalMeshes; i++)
{
vertexStart = layers[i].vertexStart;
vertexCount = layers[i].vertexCount;
for (int j = 0; j < vertexCount; j++)
{
currentVertex = vertexStart + j;
uv[currentVertex] = meshes[i]._uvs[j];
uv2[currentVertex] = meshes[i]._uvs2[j];
}
}
if (useOpaqueShader)
{
outputShaders.Add(SVGShader.GradientColorOpaque);
}
if (useTransparentShader)
{
outputShaders.Add(SVGShader.GradientColorAlphaBlended);
}
}
else
{
if (useOpaqueShader)
{
outputShaders.Add(SVGShader.SolidColorOpaque);
}
if (useTransparentShader)
{
outputShaders.Add(SVGShader.SolidColorAlphaBlended);
}
}
if (useOpaqueShader && useTransparentShader)
{
triangles = new int[2][] { new int[opaqueTriangles], new int[transparentTriangles] };
int lastVertexIndex = 0;
int triangleCount;
int lastOpauqeTriangleIndex = 0;
int lastTransparentTriangleIndex = 0;
for (int i = 0; i < totalMeshes; i++)
{
triangleCount = meshes[i]._triangles.Length;
if (meshes[i]._fill.blend == FILL_BLEND.OPAQUE)
{
for (int j = 0; j < triangleCount; j++)
{
triangles[0][lastOpauqeTriangleIndex++] = lastVertexIndex + meshes[i]._triangles[j];
}
}
else
{
for (int j = 0; j < triangleCount; j++)
{
triangles[1][lastTransparentTriangleIndex++] = lastVertexIndex + meshes[i]._triangles[j];
}
}
lastVertexIndex += layers[i].vertexCount;
}
}
else
{
triangles = new int[1][] { new int[totalTriangles] };
int lastVertexIndex = 0;
int triangleCount;
int lastTriangleIndex = 0;
for (int i = 0; i < totalMeshes; i++)
{
triangleCount = meshes[i]._triangles.Length;
for (int j = 0; j < triangleCount; j++)
{
triangles[0][lastTriangleIndex++] = lastVertexIndex + meshes[i]._triangles[j];
}
lastVertexIndex += layers[i].vertexCount;
}
}
if (outputShaders.Count != 0)
{
shaders = outputShaders.ToArray();
}
Mesh output = new Mesh();
output.vertices = vertices;
output.colors32 = colors32;
if (hasGradients)
{
output.uv = uv;
output.uv2 = uv2;
}
if (triangles.Length == 1)
{
output.triangles = triangles[0];
}
else
{
output.subMeshCount = triangles.Length;
for (int i = 0; i < triangles.Length; i++)
{
output.SetTriangles(triangles[i], i);
}
}
return(output);
}
public static void Create(ISVGElement svgElement, string defaultName = null, ClosePathRule closePathRule = ClosePathRule.ALWAYS)
{
if (svgElement == null)
{
return;
}
if (svgElement.paintable.visibility != SVGVisibility.Visible || svgElement.paintable.display == SVGDisplay.None)
{
return;
}
List <SVGShape> shapes = new List <SVGShape>();
List <List <Vector2> > inputPaths = svgElement.GetPath();
if (inputPaths.Count == 1)
{
if (svgElement.paintable.IsFill())
{
List <List <Vector2> > path = inputPaths;
if (svgElement.paintable.clipPathList != null && svgElement.paintable.clipPathList.Count > 0)
{
path = SVGGeom.ClipPolygon(new List <List <Vector2> >()
{
inputPaths[0]
}, svgElement.paintable.clipPathList);
}
SVGShape[] addShapes = SVGGraphics.GetShapes(path, svgElement.paintable, svgElement.transformMatrix);
if (addShapes != null && addShapes.Length > 0)
{
shapes.AddRange(addShapes);
}
}
if (svgElement.paintable.IsStroke())
{
List <List <Vector2> > path = SVGSimplePath.CreateStroke(inputPaths[0], svgElement.paintable, closePathRule);
if (svgElement.paintable.clipPathList != null && svgElement.paintable.clipPathList.Count > 0)
{
path = SVGGeom.ClipPolygon(path, svgElement.paintable.clipPathList);
}
SVGShape[] addShapes = SVGGraphics.GetShapes(path, svgElement.paintable, svgElement.transformMatrix, true);
if (addShapes != null && addShapes.Length > 0)
{
shapes.AddRange(addShapes);
}
}
}
else
{
if (svgElement.paintable.IsFill())
{
List <List <Vector2> > fillPaths = inputPaths;
if (svgElement.paintable.clipPathList != null && svgElement.paintable.clipPathList.Count > 0)
{
fillPaths = SVGGeom.ClipPolygon(inputPaths, svgElement.paintable.clipPathList);
}
SVGShape[] addShapes = SVGGraphics.GetShapes(fillPaths, svgElement.paintable, svgElement.transformMatrix);
if (addShapes != null && addShapes.Length > 0)
{
shapes.AddRange(addShapes);
}
}
if (svgElement.paintable.IsStroke())
{
List <List <Vector2> > strokePath = SVGSimplePath.CreateStroke(inputPaths, svgElement.paintable, closePathRule);
if (svgElement.paintable.clipPathList != null && svgElement.paintable.clipPathList.Count > 0)
{
strokePath = SVGGeom.ClipPolygon(strokePath, svgElement.paintable.clipPathList);
}
SVGShape[] addShapes = SVGGraphics.GetShapes(strokePath, svgElement.paintable, svgElement.transformMatrix, true);
if (addShapes != null && addShapes.Length > 0)
{
shapes.AddRange(addShapes);
}
}
}
if (shapes.Count > 0)
{
string name = svgElement.attrList.GetValue("id");
if (string.IsNullOrEmpty(name))
{
name = defaultName;
}
SVGLayer layer = new SVGLayer();
layer.shapes = shapes.ToArray();
layer.name = name;
SVGGraphics.AddLayer(layer);
}
}
public static void AddLayer(SVGLayer layer)
{
layers.Add(layer);
}
public static Mesh CombineMeshes(List<SVGMesh> meshes, out SVGLayer[] layers, out Shader[] shaders, SVGUseGradients useGradients = SVGUseGradients.Always, SVGAssetFormat format = SVGAssetFormat.Transparent, bool compressDepth = true)
{
layers = new SVGLayer[0];
shaders = new Shader[0];
//if(SVGAssetImport.sliceMesh) Create9Slice();
SVGFill fill;
bool useOpaqueShader = false;
bool useTransparentShader = false;
bool hasGradients = (useGradients == SVGUseGradients.Always);
int totalMeshes = meshes.Count, totalTriangles = 0, opaqueTriangles = 0, transparentTriangles = 0;
// Z Sort meshes
if(format == SVGAssetFormat.Opaque)
{
if(compressDepth)
{
SVGBounds meshBounds = SVGBounds.InfiniteInverse;
for (int i = 0; i < totalMeshes; i++)
{
if (meshes [i] == null) continue;
meshBounds.Encapsulate(meshes [i].bounds);
}
if(!meshBounds.isInfiniteInverse)
{
SVGGraphics.depthTree.Clear();
SVGGraphics.depthTree = new SVGDepthTree(meshBounds);
for (int i = 0; i < totalMeshes; i++)
{
fill = meshes [i]._fill;
SVGMesh[] nodes = SVGGraphics.depthTree.TestDepthAdd(meshes [i], new SVGBounds(meshes [i]._bounds));
int nodesLength = 0;
if(nodes == null || nodes.Length == 0)
{
meshes [i]._depth = 0;
} else {
nodesLength = nodes.Length;
int highestDepth = 0;
SVGMesh highestMesh = null;
for(int j = 0; j < nodesLength; j++)
{
if(nodes[j].depth > highestDepth)
{
highestDepth = nodes[j].depth;
highestMesh = nodes[j];
}
}
if(fill.blend == FILL_BLEND.OPAQUE)
{
meshes [i]._depth = highestDepth + 1;
} else {
if(highestMesh != null && highestMesh.fill.blend == FILL_BLEND.OPAQUE)
{
meshes [i]._depth = highestDepth + 1;
} else {
meshes [i]._depth = highestDepth;
}
}
}
meshes [i].UpdateDepth();
}
}
} else {
int highestDepth = 0;
for (int i = 0; i < totalMeshes; i++)
{
fill = meshes [i]._fill;
if (fill.blend == FILL_BLEND.OPAQUE || lastBlendType == FILL_BLEND.OPAQUE)
{
meshes[i]._depth = ++highestDepth;
} else
{
meshes[i]._depth = highestDepth;
}
lastBlendType = fill.blend;
meshes[i].UpdateDepth();
}
}
}
layers = new SVGLayer[totalMeshes];
int totalVertices = 0, vertexCount, vertexStart, currentVertex;
for(int i = 0; i < totalMeshes; i++)
{
fill = meshes[i]._fill;
if(fill.blend == FILL_BLEND.OPAQUE) {
opaqueTriangles += meshes[i]._triangles.Length;
useOpaqueShader = true;
}
else if(fill.blend == FILL_BLEND.ALPHA_BLENDED) {
transparentTriangles += meshes[i]._triangles.Length;
useTransparentShader = true;
}
if(fill.fillType == FILL_TYPE.GRADIENT) hasGradients = true;
vertexCount = meshes[i]._vertices.Length;
Bounds bounds = meshes[i]._bounds;
layers[i] = new SVGLayer(meshes[i]._name, totalVertices, vertexCount, bounds.center, bounds.size);
totalVertices += vertexCount;
}
totalTriangles = opaqueTriangles + transparentTriangles;
if(useGradients == SVGUseGradients.Never) hasGradients = false;
if(format != SVGAssetFormat.Opaque)
{
useOpaqueShader = false;
useTransparentShader = true;
}
Vector3[] vertices = new Vector3[totalVertices];
Color32[] colors32 = new Color32[totalVertices];
Vector2[] uv = null;
Vector2[] uv2 = null;
int[][] triangles = null;
for(int i = 0; i < totalMeshes; i++)
{
vertexStart = layers[i].vertexStart;
vertexCount = layers[i].vertexCount;
for(int j = 0; j < vertexCount; j++)
{
currentVertex = vertexStart + j;
vertices[currentVertex] = meshes[i]._vertices[j];
colors32[currentVertex] = meshes[i]._colors[j];
}
}
List<Shader> outputShaders = new List<Shader>();
// Debug.Log("hasGradients: "+hasGradients);
if(hasGradients)
{
uv = new Vector2[totalVertices];
uv2 = new Vector2[totalVertices];
for(int i = 0; i < totalMeshes; i++)
{
vertexStart = layers[i].vertexStart;
vertexCount = layers[i].vertexCount;
for(int j = 0; j < vertexCount; j++)
{
currentVertex = vertexStart + j;
uv[currentVertex] = meshes[i]._uvs[j];
uv2[currentVertex] = meshes[i]._uvs2[j];
}
}
if(useOpaqueShader)
{
outputShaders.Add(SVGShader.GradientColorOpaque);
}
if(useTransparentShader)
{
outputShaders.Add(SVGShader.GradientColorAlphaBlended);
}
} else {
if(useOpaqueShader)
{
outputShaders.Add(SVGShader.SolidColorOpaque);
}
if(useTransparentShader)
{
outputShaders.Add(SVGShader.SolidColorAlphaBlended);
}
}
if(useOpaqueShader && useTransparentShader)
{
triangles = new int[2][]{new int[opaqueTriangles], new int[transparentTriangles]};
int lastVertexIndex = 0;
int triangleCount;
int lastOpauqeTriangleIndex = 0;
int lastTransparentTriangleIndex = 0;
for(int i = 0; i < totalMeshes; i++)
{
triangleCount = meshes[i]._triangles.Length;
if(meshes[i]._fill.blend == FILL_BLEND.OPAQUE)
{
for(int j = 0; j < triangleCount; j++)
{
triangles[0][lastOpauqeTriangleIndex++] = lastVertexIndex + meshes[i]._triangles[j];
}
} else {
for(int j = 0; j < triangleCount; j++)
{
triangles[1][lastTransparentTriangleIndex++] = lastVertexIndex + meshes[i]._triangles[j];
}
}
lastVertexIndex += layers[i].vertexCount;
}
} else {
triangles = new int[1][]{new int[totalTriangles]};
int lastVertexIndex = 0;
int triangleCount;
int lastTriangleIndex = 0;
for(int i = 0; i < totalMeshes; i++)
{
triangleCount = meshes[i]._triangles.Length;
for(int j = 0; j < triangleCount; j++)
{
triangles[0][lastTriangleIndex++] = lastVertexIndex + meshes[i]._triangles[j];
}
lastVertexIndex += layers[i].vertexCount;
}
}
if(outputShaders.Count != 0) shaders = outputShaders.ToArray();
Mesh output = new Mesh();
output.vertices = vertices;
output.colors32 = colors32;
if(hasGradients)
{
output.uv = uv;
output.uv2 = uv2;
}
if(triangles.Length == 1)
{
output.triangles = triangles[0];
} else {
output.subMeshCount = triangles.Length;
for(int i = 0; i < triangles.Length; i++)
{
output.SetTriangles(triangles[i], i);
}
}
return output;
}
public static bool CreatePolygon(List <List <Vector2> > inputShapes, SVGPaintable paintable, SVGMatrix matrix, out SVGLayer layer, bool isStroke = false)
{
layer = new SVGLayer();
if (inputShapes == null || inputShapes.Count == 0)
{
return(false);
}
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(false);
}
AddInputShape(simplifiedShapes);
Rect bounds = GetRect(simplifiedShapes);
Rect viewport = paintable.viewport;
if (!isStroke)
{
switch (paintable.GetPaintType())
{
case SVGPaintMethod.SolidFill:
{
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, viewport);
paintable.svgFill = linearGradBrush.fill;
}
break;
case SVGPaintMethod.RadialGradientFill:
{
SVGRadialGradientBrush radialGradBrush = paintable.GetRadialGradientBrush(bounds, matrix, viewport);
paintable.svgFill = radialGradBrush.fill;
}
break;
case SVGPaintMethod.ConicalGradientFill:
{
SVGConicalGradientBrush conicalGradBrush = paintable.GetConicalGradientBrush(bounds, matrix, viewport);
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;
}
}
else
{
Color color = paintable.strokeColor.Value.color;
color.a *= paintable.strokeOpacity;
paintable.svgFill = new SVGFill(color, FILL_BLEND.OPAQUE, FILL_TYPE.SOLID);
if (color.a != 1f)
{
paintable.svgFill.blend = FILL_BLEND.ALPHA_BLENDED;
}
paintable.svgFill.color = color;
}
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, SVGImporter.LibTessDotNet.ContourOrientation.Clockwise);
}
tesselation.Tessellate(LibTessDotNet.WindingRule.EvenOdd, LibTessDotNet.ElementType.Polygons, 3);
int meshVertexCount = tesselation.Vertices.Length;
layer.vertices = new Vector2[meshVertexCount];
for (int i = 0; i < meshVertexCount; i++)
{
layer.vertices[i] = new Vector2(tesselation.Vertices[i].Position.X, tesselation.Vertices[i].Position.Y) * SVGAssetImport.meshScale;
}
int numTriangles = tesselation.ElementCount;
layer.triangles = new int[numTriangles * 3];
for (int i = 0; i < numTriangles; i++)
{
layer.triangles[i * 3] = tesselation.Elements[i * 3];
layer.triangles[i * 3 + 1] = tesselation.Elements[i * 3 + 1];
layer.triangles[i * 3 + 2] = tesselation.Elements[i * 3 + 2];
}
layer.fill = paintable.svgFill;
layer.fill.opacity = paintable.opacity;
if (layer.fill.opacity < 1f && layer.fill.blend == FILL_BLEND.OPAQUE)
{
layer.fill.blend = FILL_BLEND.ALPHA_BLENDED;
}
if (layer.fill.fillType == FILL_TYPE.GRADIENT && layer.fill.gradientColors != null)
{
layer.fill.color = Color.white;
}
else if (layer.fill.fillType == FILL_TYPE.TEXTURE)
{
layer.fill.color = Color.white;
}
viewport.x *= SVGAssetImport.meshScale;
viewport.y *= SVGAssetImport.meshScale;
viewport.size *= SVGAssetImport.meshScale;
layer.fill.viewport = viewport;
if (layer.fill.transform != null)
{
SVGMatrix scaleMatrix = SVGMatrix.Identity().Scale(SVGAssetImport.meshScale);
layer.fill.transform = scaleMatrix.Multiply(layer.fill.transform);
layer.fill.transform = layer.fill.transform.Multiply(scaleMatrix.Inverse());
}
Vector2 boundsMin = bounds.min * SVGAssetImport.meshScale;
Vector2 boundsMax = bounds.max * SVGAssetImport.meshScale;
layer.bounds = new Rect(boundsMin.x,
boundsMin.y,
boundsMax.x - boundsMin.x,
boundsMax.y - boundsMin.y);
return(true);
}
