private void InstantiatePolygon(Polygon polygon, IDictionary <string, dynamic> properties, Tile tile,
                                    Vector2 originInMeters)
    {
        PolygonLoops polygonLoops = BuildingPropertiesHelper.GetPolygonLoopsInMeters(polygon, originInMeters);

        int   levels = BuildingPropertiesHelper.GetNumberOfLevels(properties);
        float height = levels * NumericConstants.LEVEL_HEIGHT;

        MeshInfo roofInfo;
        MeshInfo wallInfo;

        try
        {
            roofInfo = BuildingPropertiesHelper.GetRoofInfo(polygonLoops, height);
            wallInfo = BuildingPropertiesHelper.GetWallInfo(polygonLoops, height);
        }
        catch
        {
            Debug.Log("Some roofs are not visualized.");
            return;
        }

        InstantiateObject(tile, roofInfo, RoofMaterial, RoofPrefab);
        InstantiateObject(tile, wallInfo, WallMaterial, WallPrefab);
    }
示例#2
0
    public static MeshInfo GetWallInfo(PolygonLoops polygonLoops, float height)
    {
        List <int>     triangles = new List <int>();
        List <Vector3> vertices  = new List <Vector3>();

        foreach (var loop in polygonLoops.AllLoops)
        {
            int offset = vertices.Count;

            foreach (var vertex2D in loop)
            {
                vertices.Add(new Vector3(vertex2D.x, 0, vertex2D.y));
                vertices.Add(new Vector3(vertex2D.x, height, vertex2D.y));
            }

            vertices.Add(vertices[0]);
            vertices.Add(vertices[1]);

            int size = loop.Length * 2 + 2;

            for (int i = 0; i < loop.Length; i++)
            {
                triangles.Add(offset + (i * 2));
                triangles.Add(offset + ((i * 2 + 1) % size));
                triangles.Add(offset + (((i + 1) * 2) % size));

                triangles.Add(offset + ((i * 2 + 1) % size));
                triangles.Add(offset + (((i + 1) * 2 + 1) % size));
                triangles.Add(offset + (((i + 1) * 2) % size));
            }

            triangles.Add(vertices.Count - 2);
            triangles.Add(vertices.Count - 4);
            triangles.Add(vertices.Count - 3);

            triangles.Add(vertices.Count - 2);
            triangles.Add(vertices.Count - 3);
            triangles.Add(vertices.Count - 1);
        }

        Vector2[] uvs = new Vector2[vertices.Count];

        float x = 0;

        for (int i = 0; i < uvs.Length; i += 2)
        {
            uvs[i]     = new Vector2(x, 0);
            uvs[i + 1] = new Vector2(x, height);

            x += Vector3.Distance(vertices[i], vertices[(i + 2) % vertices.Count]);
        }

        return(new MeshInfo(vertices.ToArray(), triangles.ToArray(), uvs));
    }
示例#3
0
    public static MeshInfo GetRoofInfo(PolygonLoops polygonLoops, float height)
    {
        Vector2[]   outerLoop = polygonLoops.OuterLoop;
        Vector2[][] holeLoops = polygonLoops.InnerLoops;

        Sebastian.Geometry.Polygon polygon2D;
        if (holeLoops.Length == 0)
        {
            polygon2D = new Sebastian.Geometry.Polygon(outerLoop);
        }
        else
        {
            polygon2D = new Sebastian.Geometry.Polygon(outerLoop, holeLoops);
        }

        Sebastian.Geometry.Triangulator triangulator = new Sebastian.Geometry.Triangulator(polygon2D);
        int[]     triangles  = triangulator.Triangulate();
        Vector2[] vertices2D = polygon2D.points;
        Vector3[] vertices3D = new Vector3[vertices2D.Length * 2];

        int i = 0;

        foreach (var vertex2D in vertices2D)
        {
            vertices3D[i] = new Vector3(vertex2D.x, height, vertex2D.y);
            i++;
        }

        Vector2[] uvs = new Vector2[vertices3D.Length];
        for (int k = 0; k < uvs.Length; k++)
        {
            uvs[k] = new Vector3(vertices3D[k].x, vertices3D[k].z);
        }

        return(new MeshInfo(vertices3D, triangles.ToArray(), uvs));
    }