C# UnityEngine.Clear方法代码示例

    protected override void OnPopulateMesh(UnityEngine.UI.VertexHelper vh)
    {
        if (!HollowRect) return;

        Color32 color32 = color;

        vh.Clear();

        Rect innerRect = new Rect(pos, size);

        Rect outerRect = GetPixelAdjustedRect();

        AddQuad(vh, new Vector2(outerRect.xMin, outerRect.yMax), new Vector2(outerRect.xMax, innerRect.center.y), color);

        AddQuad(vh, new Vector2(outerRect.xMin, innerRect.center.y), new Vector2(HollowRect.anchoredPosition.x - innerRect.width/2, HollowRect.anchoredPosition.y - innerRect.height/2), color);

        AddQuad(vh, new Vector2(HollowRect.anchoredPosition.x + innerRect.width / 2, innerRect.center.y), new Vector2(outerRect.xMax, HollowRect.anchoredPosition.y -  innerRect.height/2), color);

        AddQuad(vh, new Vector2(outerRect.xMin, HollowRect.anchoredPosition.y - innerRect.height / 2), new Vector2(outerRect.xMax, -outerRect.yMax), color);
    }

        /// Collect and bind geometry from stream
        public void Bind(UnityEngine.Mesh mesh)
        {
            var vertices = new List<Vector3>();
            var triangles = new List<int>();
            var uv = useUV ? new List<Vector2>() : null;
            var color = useColor ? new List<Color32>() : null;
            var normals = useUV ? new List<Vector3>() : null;

            // Collect
            foreach (var gp in geometry.Geometry)
            {
                gp.VertexOffset = vertices.Count;
                vertices.AddRange(gp.Vertices);
                triangles.AddRange(gp.Triangles);
                if (uv != null) { uv.AddRange(gp.UV); }
                if (color != null) { color.AddRange(gp.Color); }
                if (normals != null) { normals.AddRange(gp.Normals); }
            }

            // Attach
            mesh.Clear();
            mesh.vertices = vertices.ToArray();
            mesh.triangles = triangles.ToArray();
            if (useUV) { mesh.uv = uv.ToArray(); }
            if (useColor) { mesh.colors32 = color.ToArray(); }
            if (useNormals) { mesh.normals = normals.ToArray(); }

            // Bind
            if (!useNormals) { mesh.RecalculateNormals(); }
            mesh.RecalculateBounds();
            mesh.Optimize();

            // Summary
            vertexGen = vertices.Count;
            triangleGen = triangles.Count;
        }

	protected override void OnPopulateMesh(UnityEngine.UI.VertexHelper vh)
	{
		if (buffer.modified) {
			buffer.modified = false;
			vh.Clear();
			int count = rectangleCount * 4;
			List<UIVertex> vertices = new List<UIVertex>();
			for (int i = 0; i < count; i += 4) {
				vertices.Add(buffer.vertices[i + 0]);
				vertices.Add(buffer.vertices[i + 1]);
				vertices.Add(buffer.vertices[i + 2]);
				vertices.Add(buffer.vertices[i + 2]);
				vertices.Add(buffer.vertices[i + 3]);
				vertices.Add(buffer.vertices[i + 0]);
			}
			vh.AddUIVertexTriangleStream(vertices);
		}
	}

    public static void MakeMesh(UnityEngine.Mesh mesh, Face face, int vertices_begin, int vertices_end, int indices_begin, int indices_end, int indices_offset)
    {
        //we have to clear the mesh first, otherwise there will be exceptions.
        mesh.Clear();

        int vertices_count = vertices_end - vertices_begin + 1;
        UnityEngine.Vector3[] vertices = new UnityEngine.Vector3[vertices_count];
        UnityEngine.Vector3[] normals = new UnityEngine.Vector3[vertices_count];
        UnityEngine.Vector2[] uv = new UnityEngine.Vector2[vertices_count];
        for (int k = vertices_begin, i = 0; k <= vertices_end; ++k, ++i)
        {
            vertices[i].x = face.Vertices[k].Position.X;
            vertices[i].y = face.Vertices[k].Position.Y;
            //HACK: unity3d uses left-hand coordinate, so we have to mirror z corrd
            vertices[i].z = -face.Vertices[k].Position.Z;

            normals[i].x = face.Vertices[k].Normal.X;
            normals[i].y = face.Vertices[k].Normal.Y;
            //HACK: unity3d uses left-hand coordinate, so we have to mirror z corrd
            normals[i].z = -face.Vertices[k].Normal.Z;

            uv[i].x = face.Vertices[k].TexCoord.X;
            //HACK: unity3d uses left-bottom corner as the origin of the texture
            uv[i].y = 1 - face.Vertices[k].TexCoord.Y;
        }
        //indices for this face
        int[] triangles = new int[indices_end - indices_begin + 1];
        for (int k = indices_begin, i = 0; k <= indices_end; k += 3, i += 3)
        {
            //HACK: OpenGL's default front face is counter-clock-wise
            triangles[i] = face.Indices[k + 2] - indices_offset;
            triangles[i + 1] = face.Indices[k + 1] - indices_offset;
            triangles[i + 2] = face.Indices[k + 0] - indices_offset;
        }

        mesh.vertices = vertices;
        mesh.normals = normals;
        mesh.uv = uv;
        mesh.triangles = triangles;
    }