Exemple #1
0
 public void Apply(SVGAssetSnapshot snapshot)
 {
     this.format = snapshot.format;
     this.useGradients = snapshot.useGradients;
     this.antialiasing = snapshot.antialiasing;
     this.meshCompression = snapshot.meshCompression;
     this.scale = snapshot.scale;
     this.vpm = snapshot.vpm;
     this.depthOffset = snapshot.depthOffset;
     this.compressDepth = snapshot.compressDepth;
     this.customPivotPoint = snapshot.customPivotPoint;
     this.pivotPoint = snapshot.pivotPoint;
     this.border = snapshot.border;
     this.sliceMesh = snapshot.sliceMesh;
     this.generateCollider = snapshot.generateCollider;
     this.keepSVGFile = snapshot.keepSVGFile;
     this.useLayers = snapshot.useLayers;
     this.ignoreSVGCanvas = snapshot.ignoreSVGCanvas;
     this.optimizeMesh = snapshot.optimizeMesh;
     this.generateNormals = snapshot.generateNormals;
     this.generateTangents = snapshot.generateTangents;
 }
Exemple #2
0
 public void Apply(SerializedObject serializedObject)
 {
     this.format = (SVGAssetFormat)serializedObject.FindProperty("_format").enumValueIndex;
     this.useGradients = (SVGUseGradients)serializedObject.FindProperty("_useGradients").enumValueIndex;
     this.antialiasing = serializedObject.FindProperty("_antialiasing").boolValue;
     this.meshCompression = (SVGMeshCompression)serializedObject.FindProperty("_meshCompression").enumValueIndex;
     this.scale = serializedObject.FindProperty("_scale").floatValue;
     this.vpm = serializedObject.FindProperty("_vpm").floatValue;
     this.depthOffset = serializedObject.FindProperty("_depthOffset").floatValue;
     this.compressDepth = serializedObject.FindProperty("_compressDepth").boolValue;
     this.customPivotPoint = serializedObject.FindProperty("_customPivotPoint").boolValue;
     this.pivotPoint = serializedObject.FindProperty("_pivotPoint").vector2Value;
     this.border = serializedObject.FindProperty("_border").vector4Value;
     this.sliceMesh = serializedObject.FindProperty("_sliceMesh").boolValue;
     this.generateCollider = serializedObject.FindProperty("_generateCollider").boolValue;
     this.keepSVGFile = serializedObject.FindProperty("_keepSVGFile").boolValue;
     this.useLayers = serializedObject.FindProperty("_useLayers").boolValue;
     this.ignoreSVGCanvas = serializedObject.FindProperty("_ignoreSVGCanvas").boolValue;
     this.optimizeMesh = serializedObject.FindProperty("_optimizeMesh").boolValue;
     this.generateNormals = serializedObject.FindProperty("_generateNormals").boolValue;
     this.generateTangents = serializedObject.FindProperty("_generateTangents").boolValue;
 }
		public void Apply(SVGAsset svgAsset)
		{
			this.format = svgAsset.format;
            this.useGradients = svgAsset.useGradients;
            this.antialiasing = svgAsset.antialiasing;
            this.antialiasingWidth = svgAsset.antialiasingWidth;
			this.meshCompression = svgAsset.meshCompression;
			this.scale = svgAsset.scale;
			this.vpm = svgAsset.vpm;
			this.depthOffset = svgAsset.depthOffset;
			this.compressDepth = svgAsset.compressDepth;
			this.customPivotPoint = svgAsset.customPivotPoint;
			this.pivotPoint = svgAsset.pivotPoint;
            this.border = svgAsset.border;
            this.sliceMesh = svgAsset.sliceMesh;
            this.generateCollider = svgAsset.generateCollider;
			this.keepSVGFile = svgAsset.keepSVGFile;
            this.ignoreSVGCanvas = svgAsset.ignoreSVGCanvas;
            this.optimizeMesh = svgAsset.optimizeMesh;
            this.generateNormals = svgAsset.generateNormals;
            this.generateTangents = svgAsset.generateTangents;
		}
Exemple #4
0
        public static Mesh CombineMeshes(List <SVGLayer> layers, out Shader[] shaders, SVGUseGradients useGradients = SVGUseGradients.Always, SVGAssetFormat format = SVGAssetFormat.Transparent, bool compressDepth = true)
        {
            #if DEBUG_IMPORT
            long timeStart = System.DateTime.Now.Ticks;
            #endif

            shaders = new Shader[0];

            //if(SVGAssetImport.sliceMesh) Create9Slice();

            SVGFill fill;
            bool    useOpaqueShader      = false;
            bool    useTransparentShader = false;
            bool    hasGradients         = (useGradients == SVGUseGradients.Always);

            int        totalLayers = layers.Count, totalTriangles = 0, opaqueTriangles = 0, transparentTriangles = 0;
            FILL_BLEND lastBlendType = FILL_BLEND.ALPHA_BLENDED;

            // Z Sort meshes
            if (format == SVGAssetFormat.Opaque)
            {
                SVGLayer layer;
                if (compressDepth)
                {
                    SVGBounds quadTreeBounds = SVGBounds.InfiniteInverse;
                    for (int i = 0; i < totalLayers; i++)
                    {
                        layer = layers[i];
                        if (layer.bounds.size.sqrMagnitude == 0f)
                        {
                            continue;
                        }
                        quadTreeBounds.Encapsulate(layer.bounds.center, layer.bounds.size);
                    }

                    quadTreeBounds.size *= 1.2f;

                    if (!quadTreeBounds.isInfiniteInverse)
                    {
                        SVGDepthTree depthTree = new SVGDepthTree(quadTreeBounds);

                        for (int i = 0; i < totalLayers; i++)
                        {
                            layer = layers[i];
                            int[] nodes = depthTree.TestDepthAdd(i, new SVGBounds(layer.bounds.center, layer.bounds.size));

                            int nodesLength = 0;
                            if (nodes == null || nodes.Length == 0)
                            {
                                layer.depth = 0;
                            }
                            else
                            {
                                nodesLength = nodes.Length;
                                int highestDepth = 0;
                                int highestLayer = -1;

                                for (int j = 0; j < nodesLength; j++)
                                {
                                    if (layers[nodes[j]].depth > highestDepth)
                                    {
                                        highestDepth = layers[nodes[j]].depth;
                                        highestLayer = nodes[j];
                                    }
                                }

                                if (layers[i].fill.blend == FILL_BLEND.OPAQUE)
                                {
                                    layer.depth = highestDepth + 1;
                                }
                                else
                                {
                                    if (highestDepth != -1 && layers[highestLayer].fill.blend == FILL_BLEND.OPAQUE)
                                    {
                                        layer.depth = highestDepth + 1;
                                    }
                                    else
                                    {
                                        layer.depth = highestDepth;
                                    }
                                }
                            }

                            layers[i] = layer;
                        }
                    }
                }
                else
                {
                    int highestDepth = 0;
                    for (int i = 0; i < totalLayers; i++)
                    {
                        layer = layers[i];
                        fill  = layer.fill;
                        if (fill.blend == FILL_BLEND.OPAQUE || lastBlendType == FILL_BLEND.OPAQUE)
                        {
                            layer.depth = ++highestDepth;
                        }
                        else
                        {
                            layer.depth = highestDepth;
                        }

                        lastBlendType = fill.blend;
                        layers[i]     = layer;
                    }
                }
            }

            int totalVertices = 0, vertexCount, vertexStart = 0, currentVertex;
            for (int i = 0; i < totalLayers; i++)
            {
                fill = layers[i].fill;
                if (fill.blend == FILL_BLEND.OPAQUE)
                {
                    opaqueTriangles += layers[i].triangles.Length;
                    useOpaqueShader  = true;
                }
                else if (fill.blend == FILL_BLEND.ALPHA_BLENDED)
                {
                    transparentTriangles += layers[i].triangles.Length;
                    useTransparentShader  = true;
                }
                if (fill.fillType == FILL_TYPE.GRADIENT)
                {
                    hasGradients = true;
                }
                vertexCount    = layers[i].vertices.Length;
                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;
            List <Shader> outputShaders = new List <Shader>();

            if (hasGradients)
            {
                uv  = new Vector2[totalVertices];
                uv2 = new Vector2[totalVertices];

                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);
                }
            }

            for (int i = 0; i < totalLayers; i++)
            {
                vertexCount = layers[i].vertices.Length;
//                Debug.Log("Layer: "+i+", depth: "+layers[i].depth);
                for (int j = 0; j < vertexCount; j++)
                {
                    currentVertex             = vertexStart + j;
                    vertices[currentVertex]   = layers[i].vertices[j];
                    vertices[currentVertex].z = layers[i].depth * -SVGAssetImport.minDepthOffset;
                    colors32[currentVertex]   = layers[i].fill.finalColor;
                }

                if (hasGradients && layers[i].fill.fillType == FILL_TYPE.GRADIENT && layers[i].fill.gradientColors != null)
                {
                    SVGMatrix svgFillTransform = layers[i].fill.transform;
                    Rect      viewport         = layers[i].fill.viewport;

                    Vector2 uvPoint  = Vector2.zero;
                    Vector2 uv2Value = new Vector2(layers[i].fill.gradientColors.index, (int)layers[i].fill.gradientType);

                    for (int j = 0; j < vertexCount; j++)
                    {
                        currentVertex       = vertexStart + j;
                        uvPoint.x           = vertices [currentVertex].x;
                        uvPoint.y           = vertices [currentVertex].y;
                        uvPoint             = svgFillTransform.Transform(uvPoint);
                        uv[currentVertex].x = (uvPoint.x - viewport.x) / viewport.width;
                        uv[currentVertex].y = (uvPoint.y - viewport.y) / viewport.height;
                        uv2[currentVertex]  = uv2Value;
                    }
                }

                vertexStart += vertexCount;
            }

            /*
             * for(int i = 0; i < totalVertices; i++)
             * {
             *  vertices[i] *= SVGAssetImport.meshScale;
             * }
             */
            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 < totalLayers; i++)
                {
                    triangleCount = layers[i].triangles.Length;
                    if (layers[i].fill.blend == FILL_BLEND.OPAQUE)
                    {
                        for (int j = 0; j < triangleCount; j++)
                        {
                            triangles[0][lastOpauqeTriangleIndex++] = lastVertexIndex + layers[i].triangles[j];
                        }
                    }
                    else
                    {
                        for (int j = 0; j < triangleCount; j++)
                        {
                            triangles[1][lastTransparentTriangleIndex++] = lastVertexIndex + layers[i].triangles[j];
                        }
                    }

                    lastVertexIndex += layers[i].vertices.Length;
                }
            }
            else
            {
                triangles = new int[1][] { new int[totalTriangles] };

                int lastVertexIndex = 0;
                int triangleCount;
                int lastTriangleIndex = 0;

                for (int i = 0; i < totalLayers; i++)
                {
                    triangleCount = layers[i].triangles.Length;
                    for (int j = 0; j < triangleCount; j++)
                    {
                        triangles[0][lastTriangleIndex++] = lastVertexIndex + layers[i].triangles[j];
                    }
                    lastVertexIndex += layers[i].vertices.Length;
                }
            }

            if (outputShaders.Count != 0)
            {
                shaders = outputShaders.ToArray();
            }

            /* * * * * * * * * * * * * * * * * * * * * * * *
            *                                             *
            *      Mesh Creation                          *
            *                                             *
            * * * * * * * * * * * * * * * * * * * * * * * */

            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);
                }
            }

            #if DEBUG_IMPORT
            System.TimeSpan timeSpan = new System.TimeSpan(System.DateTime.Now.Ticks - timeStart);
            Debug.Log("Mesh combination took: " + timeSpan.TotalSeconds + "s");
            #endif

            return(output);
        }
Exemple #5
0
        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 void Apply(SerializedObject serializedObject)
		{
			this.format = (SVGAssetFormat)serializedObject.FindProperty("_format").enumValueIndex;
            this.useGradients = (SVGUseGradients)serializedObject.FindProperty("_useGradients").enumValueIndex;
            this.antialiasing = serializedObject.FindProperty("_antialiasing").boolValue;
            this.antialiasingWidth = serializedObject.FindProperty("_antialiasingWidth").floatValue;
			this.meshCompression = (SVGMeshCompression)serializedObject.FindProperty("_meshCompression").enumValueIndex;
			this.scale = serializedObject.FindProperty("_scale").floatValue;
			this.vpm = serializedObject.FindProperty("_vpm").floatValue;
			this.depthOffset = serializedObject.FindProperty("_depthOffset").floatValue;
			this.compressDepth = serializedObject.FindProperty("_compressDepth").boolValue;
			this.customPivotPoint = serializedObject.FindProperty("_customPivotPoint").boolValue;
			this.pivotPoint = serializedObject.FindProperty("_pivotPoint").vector2Value;
            this.border = serializedObject.FindProperty("_border").vector4Value;
            this.sliceMesh = serializedObject.FindProperty("_sliceMesh").boolValue;
            this.generateCollider = serializedObject.FindProperty("_generateCollider").boolValue;
			this.keepSVGFile = serializedObject.FindProperty("_keepSVGFile").boolValue;
            this.ignoreSVGCanvas = serializedObject.FindProperty("_ignoreSVGCanvas").boolValue;
            this.optimizeMesh = serializedObject.FindProperty("_optimizeMesh").boolValue;
            this.generateNormals = serializedObject.FindProperty("_generateNormals").boolValue;
            this.generateTangents = serializedObject.FindProperty("_generateTangents").boolValue;
		}
Exemple #7
0
        public static bool CombineMeshes(SVGLayer[] layers, Mesh mesh, out Shader[] shaders, SVGUseGradients useGradients = SVGUseGradients.Always, SVGAssetFormat format = SVGAssetFormat.Transparent, bool compressDepth = true, bool antialiased = false)
        {
            #if DEBUG_IMPORT
            long timeStart = System.DateTime.Now.Ticks;
            #endif

            shaders = new Shader[0];

            //if(SVGAssetImport.sliceMesh) Create9Slice();

            SVGFill fill;
            bool    useOpaqueShader      = false;
            bool    useTransparentShader = false;
            bool    hasGradients         = (useGradients == SVGUseGradients.Always);

            if (layers == null)
            {
                return(false);
            }
            int        totalLayers = layers.Length, totalTriangles = 0, opaqueTriangles = 0, transparentTriangles = 0;
            FILL_BLEND lastBlendType = FILL_BLEND.ALPHA_BLENDED;

            // Z Sort meshes
            if (format == SVGAssetFormat.Opaque)
            {
                SVGShape shape;
                if (compressDepth)
                {
                    SVGBounds quadTreeBounds = SVGBounds.InfiniteInverse;
                    for (int i = 0; i < totalLayers; i++)
                    {
                        int totalShapes = layers[i].shapes.Length;
                        for (int j = 0; j < totalShapes; j++)
                        {
                            shape = layers[i].shapes[j];
                            if (shape.bounds.size.sqrMagnitude == 0f)
                            {
                                continue;
                            }
                            quadTreeBounds.Encapsulate(shape.bounds.center, shape.bounds.size);
                        }
                    }

                    quadTreeBounds.size *= 1.2f;

                    if (!quadTreeBounds.isInfiniteInverse)
                    {
                        SVGDepthTree depthTree = new SVGDepthTree(quadTreeBounds);
                        for (int i = 0; i < totalLayers; i++)
                        {
                            int totalShapes = layers[i].shapes.Length;
                            for (int j = 0; j < totalShapes; j++)
                            {
                                shape = layers[i].shapes[j];
                                int[] nodes = depthTree.TestDepthAdd(j, new SVGBounds(shape.bounds.center, shape.bounds.size));

                                int nodesLength = 0;
                                if (nodes == null || nodes.Length == 0)
                                {
                                    shape.depth = 0;
                                }
                                else
                                {
                                    nodesLength = nodes.Length;
                                    int highestDepth = 0;
                                    int highestLayer = -1;

                                    for (int k = 0; k < nodesLength; k++)
                                    {
                                        if ((int)layers[i].shapes[nodes[k]].depth > highestDepth)
                                        {
                                            highestDepth = (int)layers[i].shapes[nodes[k]].depth;
                                            highestLayer = nodes[k];
                                        }
                                    }

                                    if (layers[i].shapes[j].fill.blend == FILL_BLEND.OPAQUE)
                                    {
                                        shape.depth = highestDepth + 1;
                                    }
                                    else
                                    {
                                        if (highestLayer != -1 && layers[i].shapes[highestLayer].fill.blend == FILL_BLEND.OPAQUE)
                                        {
                                            shape.depth = highestDepth + 1;
                                        }
                                        else
                                        {
                                            shape.depth = highestDepth;
                                        }
                                    }
                                }
                                layers[i].shapes[j] = shape;
                            }
                        }
                    }
                }
                else
                {
                    int highestDepth = 0;
                    for (int i = 0; i < totalLayers; i++)
                    {
                        int totalShapes = layers[i].shapes.Length;
                        for (int j = 0; j < totalShapes; j++)
                        {
                            shape = layers[i].shapes[j];
                            fill  = shape.fill;
                            if (fill.blend == FILL_BLEND.OPAQUE || lastBlendType == FILL_BLEND.OPAQUE)
                            {
                                shape.depth = ++highestDepth;
                            }
                            else
                            {
                                shape.depth = highestDepth;
                            }

                            lastBlendType       = fill.blend;
                            layers[i].shapes[j] = shape;
                        }
                    }
                }
            }

            int totalVertices = 0, vertexCount, vertexStart = 0, currentVertex;
            for (int i = 0; i < totalLayers; i++)
            {
                int totalShapes = layers[i].shapes.Length;
                for (int j = 0; j < totalShapes; j++)
                {
                    fill = layers[i].shapes[j].fill;
                    if (fill.blend == FILL_BLEND.OPAQUE)
                    {
                        opaqueTriangles += layers[i].shapes[j].triangles.Length;
                        useOpaqueShader  = true;
                    }
                    else if (fill.blend == FILL_BLEND.ALPHA_BLENDED)
                    {
                        transparentTriangles += layers[i].shapes[j].triangles.Length;
                        useTransparentShader  = true;
                    }
                    if (fill.fillType == FILL_TYPE.GRADIENT)
                    {
                        hasGradients = true;
                    }
                    vertexCount    = layers[i].shapes[j].vertices.Length;
                    totalVertices += vertexCount;
                }
            }

            totalTriangles = opaqueTriangles + transparentTriangles;

            if (useGradients == SVGUseGradients.Never)
            {
                hasGradients = false;
            }
            if (format != SVGAssetFormat.Opaque)
            {
                useOpaqueShader      = false;
                useTransparentShader = true;
            }

            opaqueTriangles = totalVertices = 65000;

            Vector3[]     vertices      = new Vector3[totalVertices];
            Color32[]     colors32      = new Color32[totalVertices];
            Vector2[]     uv            = null;
            Vector2[]     uv2           = null;
            Vector3[]     normals       = null;
            int[][]       triangles     = null;
            List <Shader> outputShaders = new List <Shader>();

            if (antialiased)
            {
                normals = new Vector3[totalVertices];
            }

            if (hasGradients)
            {
                uv  = new Vector2[totalVertices];
                uv2 = new Vector2[totalVertices];

                if (useOpaqueShader)
                {
                    outputShaders.Add(SVGShader.GradientColorOpaque);
                }
                if (useTransparentShader)
                {
                    if (antialiased)
                    {
                        outputShaders.Add(SVGShader.GradientColorAlphaBlendedAntialiased);
                    }
                    else
                    {
                        outputShaders.Add(SVGShader.GradientColorAlphaBlended);
                    }
                }
            }
            else
            {
                if (useOpaqueShader)
                {
                    outputShaders.Add(SVGShader.SolidColorOpaque);
                }
                if (useTransparentShader)
                {
                    if (antialiased)
                    {
                        outputShaders.Add(SVGShader.SolidColorAlphaBlendedAntialiased);
                    }
                    else
                    {
                        outputShaders.Add(SVGShader.SolidColorAlphaBlended);
                    }
                }
            }

            for (int i = 0; i < totalLayers; i++)
            {
                int totalShapes = layers[i].shapes.Length;
                for (int j = 0; j < totalShapes; j++)
                {
                    vertexCount = layers[i].shapes[j].vertices.Length;

                    if (vertexStart + vertexCount >= 65000)
                    {
                        break;
                    }

                    if (layers[i].shapes[j].colors != null && layers[i].shapes[j].colors.Length == vertexCount)
                    {
                        Color32 finalColor = layers[i].shapes[j].fill.finalColor;
                        for (int k = 0; k < vertexCount; k++)
                        {
                            currentVertex           = vertexStart + k;
                            vertices[currentVertex] = layers[i].shapes[j].vertices[k];
                            if (useOpaqueShader)
                            {
                                vertices[currentVertex].z = layers[i].shapes[j].depth * -SVGAssetImport.minDepthOffset;
                            }
                            else
                            {
                                vertices[currentVertex].z = layers[i].shapes[j].depth;
                            }
                            colors32[currentVertex].r = (byte)(finalColor.r * layers[i].shapes[j].colors[k].r / 255);
                            colors32[currentVertex].g = (byte)(finalColor.g * layers[i].shapes[j].colors[k].g / 255);
                            colors32[currentVertex].b = (byte)(finalColor.b * layers[i].shapes[j].colors[k].b / 255);
                            colors32[currentVertex].a = (byte)(finalColor.a * layers[i].shapes[j].colors[k].a / 255);
                        }
                    }
                    else
                    {
                        Color32 finalColor = layers[i].shapes[j].fill.finalColor;
                        for (int k = 0; k < vertexCount; k++)
                        {
                            currentVertex           = vertexStart + k;
                            vertices[currentVertex] = layers[i].shapes[j].vertices[k];
                            if (useOpaqueShader)
                            {
                                vertices[currentVertex].z = layers[i].shapes[j].depth * -SVGAssetImport.minDepthOffset;
                            }
                            else
                            {
                                vertices[currentVertex].z = layers[i].shapes[j].depth;
                            }
                            colors32[currentVertex] = finalColor;
                        }
                    }

                    if (hasGradients)
                    {
                        if (layers[i].shapes[j].fill.fillType == FILL_TYPE.GRADIENT && layers[i].shapes[j].fill.gradientColors != null)
                        {
                            SVGMatrix svgFillTransform = layers[i].shapes[j].fill.transform;
                            Rect      viewport         = layers[i].shapes[j].fill.viewport;

                            Vector2 uvPoint  = Vector2.zero;
                            Vector2 uv2Value = new Vector2(layers[i].shapes[j].fill.gradientColors.index, (int)layers[i].shapes[j].fill.gradientType);

                            if (layers[i].shapes[j].angles != null && layers[i].shapes[j].angles.Length == vertexCount)
                            {
                                for (int k = 0; k < vertexCount; k++)
                                {
                                    currentVertex            = vertexStart + k;
                                    uvPoint.x                = vertices [currentVertex].x;
                                    uvPoint.y                = vertices [currentVertex].y;
                                    uvPoint                  = svgFillTransform.Transform(uvPoint);
                                    uv[currentVertex].x      = (uvPoint.x - viewport.x) / viewport.width;
                                    uv[currentVertex].y      = (uvPoint.y - viewport.y) / viewport.height;
                                    uv2[currentVertex]       = uv2Value;
                                    normals[currentVertex].x = layers[i].shapes[j].angles[k].x;
                                    normals[currentVertex].y = layers[i].shapes[j].angles[k].y;
                                }
                            }
                            else
                            {
                                for (int k = 0; k < vertexCount; k++)
                                {
                                    currentVertex       = vertexStart + k;
                                    uvPoint.x           = vertices [currentVertex].x;
                                    uvPoint.y           = vertices [currentVertex].y;
                                    uvPoint             = svgFillTransform.Transform(uvPoint);
                                    uv[currentVertex].x = (uvPoint.x - viewport.x) / viewport.width;
                                    uv[currentVertex].y = (uvPoint.y - viewport.y) / viewport.height;
                                    uv2[currentVertex]  = uv2Value;
                                }
                            }
                        }
                        else if (layers[i].shapes[j].fill.fillType == FILL_TYPE.TEXTURE)
                        {
                            SVGMatrix svgFillTransform = layers[i].shapes[j].fill.transform;
                            Vector2   uvPoint          = Vector2.zero;
                            if (layers[i].shapes[j].angles != null && layers[i].shapes[j].angles.Length == vertexCount)
                            {
                                for (int k = 0; k < vertexCount; k++)
                                {
                                    currentVertex            = vertexStart + k;
                                    uvPoint.x                = vertices [currentVertex].x;
                                    uvPoint.y                = vertices [currentVertex].y;
                                    uv[currentVertex]        = svgFillTransform.Transform(uvPoint);
                                    normals[currentVertex].x = layers[i].shapes[j].angles[k].x;
                                    normals[currentVertex].y = layers[i].shapes[j].angles[k].y;
                                }
                            }
                            else
                            {
                                for (int k = 0; k < vertexCount; k++)
                                {
                                    currentVertex     = vertexStart + k;
                                    uvPoint.x         = vertices [currentVertex].x;
                                    uvPoint.y         = vertices [currentVertex].y;
                                    uv[currentVertex] = svgFillTransform.Transform(uvPoint);
                                }
                            }
                        }
                        else
                        {
                            if (layers[i].shapes[j].angles != null && layers[i].shapes[j].angles.Length == vertexCount)
                            {
                                for (int k = 0; k < vertexCount; k++)
                                {
                                    currentVertex            = vertexStart + k;
                                    normals[currentVertex].x = layers[i].shapes[j].angles[k].x;
                                    normals[currentVertex].y = layers[i].shapes[j].angles[k].y;
                                }
                            }
                        }
                    }
                    else
                    {
                        if (antialiased)
                        {
                            if (layers[i].shapes[j].angles != null && layers[i].shapes[j].angles.Length == vertexCount)
                            {
                                for (int k = 0; k < vertexCount; k++)
                                {
                                    currentVertex          = vertexStart + k;
                                    normals[currentVertex] = layers[i].shapes[j].angles[k];
                                }
                            }
                        }
                    }
                    vertexStart += vertexCount;
                }
            }

            // Submesh Order
            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 < totalLayers; i++)
                {
                    int totalShapes = layers[i].shapes.Length;
                    if (lastTransparentTriangleIndex + totalShapes > 56000)
                    {
                        break;
                    }
                    for (int j = 0; j < totalShapes; j++)
                    {
                        triangleCount = layers[i].shapes[j].triangles.Length;
                        if (layers[i].shapes[j].fill.blend == FILL_BLEND.OPAQUE)
                        {
                            for (int k = 0; k < triangleCount; k++)
                            {
                                triangles[0][lastOpauqeTriangleIndex++] = lastVertexIndex + layers[i].shapes[j].triangles[k];
                            }
                        }
                        else
                        {
                            for (int k = 0; k < triangleCount; k++)
                            {
                                triangles[1][lastTransparentTriangleIndex++] = lastVertexIndex + layers[i].shapes[j].triangles[k];
                            }
                        }

                        lastVertexIndex += layers[i].shapes[j].vertices.Length;
                    }
                }
            }
            else
            {
                triangles = new int[1][] { new int[totalTriangles] };

                int lastVertexIndex = 0;
                int triangleCount;
                int lastTriangleIndex = 0;

                for (int i = 0; i < totalLayers; i++)
                {
                    int totalShapes = layers[i].shapes.Length;
                    if (lastTriangleIndex + totalShapes > 56000)
                    {
                        break;
                    }
                    for (int j = 0; j < totalShapes; j++)
                    {
                        triangleCount = layers[i].shapes[j].triangles.Length;
                        for (int k = 0; k < triangleCount; k++)
                        {
                            triangles[0][lastTriangleIndex++] = lastVertexIndex + layers[i].shapes[j].triangles[k];
                        }
                        lastVertexIndex += layers[i].shapes[j].vertices.Length;
                    }
                }
            }

            if (outputShaders.Count != 0)
            {
                shaders = outputShaders.ToArray();
            }

            /* * * * * * * * * * * * * * * * * * * * * * * *
            *                                             *
            *      Mesh Creation                          *
            *                                             *
            * * * * * * * * * * * * * * * * * * * * * * * */

            mesh.Clear();
            mesh.MarkDynamic();

            if (vertices != null)
            {
                if (vertices.Length > 65000)
                {
                    Debug.LogError("A mesh may not have more than 65000 vertices. Please try to reduce quality or split SVG file.");
                    return(false);
                }
            }
            else
            {
                return(false);
            }

            mesh.vertices = vertices;
            mesh.colors32 = colors32;

            if (uv != null)
            {
                mesh.uv = uv;
            }

            if (uv2 != null)
            {
                mesh.uv2 = uv2;
            }

            if (normals != null)
            {
                mesh.normals = normals;
            }

            if (triangles.Length == 1)
            {
                mesh.triangles = triangles[0];
            }
            else
            {
                mesh.subMeshCount = triangles.Length;
                for (int i = 0; i < triangles.Length; i++)
                {
                    mesh.SetTriangles(triangles[i], i);
                }
            }

            #if DEBUG_IMPORT
            System.TimeSpan timeSpan = new System.TimeSpan(System.DateTime.Now.Ticks - timeStart);
            Debug.Log("Mesh combination took: " + timeSpan.TotalSeconds + "s");
            #endif

            return(true);
        }
        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;
        }