Exemple #1
0
    public Mesh BuildCarLaneMesh()
    {
        if (Corners.Count != 4)
        {
            return(null);
        }

        List <Vector3> verts = new List <Vector3> {
            Corners[0].Position, Corners[1].Position, Corners[2].Position, Corners[3].Position
        };

        verts.SortAsPointsClockwiseAlongY();
        for (int i = 0; i < verts.Count; i++)
        {
            verts[i] -= Position;
        }
        List <int> tris = new List <int> {
            0, 1, 2, 0, 2, 3
        };
        Mesh m = ExtMesh.BuildMesh(verts, tris);

        m.Subdivide(2);
        return(m);
    }
Exemple #2
0
    static void GetSceneMeshes(List <ExtMesh> meshes)
    {
        var filters         = GameObject.FindObjectsOfType(typeof(MeshFilter)) as MeshFilter[];
        var filteredFilters = new List <MeshFilter>(filters.Length / 3);

        var mask  = StaticEditorFlags.NavigationStatic | StaticEditorFlags.LightmapStatic;
        var scene = EditorSceneManager.GetActiveScene();

        for (int i = 0; i < filters.Length; i++)
        {
            MeshFilter filter = filters[i];
            Renderer   render = filter.GetComponent <Renderer>();

            if (render == null)
            {
                continue;
            }

            if (filter.sharedMesh == null)
            {
                continue;
            }

            var flags = GameObjectUtility.GetStaticEditorFlags(filter.gameObject);
            if ((flags & ~mask) != 0)
            {
                GameObjectUtility.SetStaticEditorFlags(filter.gameObject, flags & mask);
                EditorUtility.SetDirty(filter.gameObject);
                EditorSceneManager.MarkSceneDirty(scene);
            }

            if (!GameObjectUtility.AreStaticEditorFlagsSet(filter.gameObject, StaticEditorFlags.NavigationStatic))
            {
                continue;
            }

            if (GameObjectUtility.GetNavMeshArea(filter.gameObject) == 0)
            {
                if (filter.gameObject.GetComponent <MeshCollider>() == null)
                {
                    var c = filter.gameObject.AddComponent <MeshCollider>();
                    c.sharedMesh = filter.sharedMesh;
                    EditorUtility.SetDirty(filter.gameObject);
                    EditorSceneManager.MarkSceneDirty(scene);
                }
            }

            filteredFilters.Add(filter);
        }


        var cachedVertices = new Dictionary <Mesh, Vector3[]>();
        var cachedTris     = new Dictionary <Mesh, int[]>();

        for (int i = 0; i < filteredFilters.Count; i++)
        {
            MeshFilter filter = filteredFilters[i];

            Renderer render = filter.GetComponent <Renderer>();

            Mesh mesh  = filter.sharedMesh;
            var  smesh = new ExtMesh();
            smesh.Matrix   = render.localToWorldMatrix;
            smesh.Original = filter;
            smesh.Scale    = filter.gameObject.transform.localScale;

            if (cachedVertices.ContainsKey(mesh))
            {
                smesh.Vertices  = cachedVertices[mesh];
                smesh.Triangles = cachedTris[mesh];
            }
            else
            {
                smesh.Vertices  = mesh.vertices;
                smesh.Triangles = mesh.triangles;
                var normal = mesh.normals;
                var uv     = mesh.uv;
                cachedVertices[mesh] = smesh.Vertices;
                cachedTris[mesh]     = smesh.Triangles;
            }

            smesh.Bounds = render.bounds;
            smesh.Area   = GameObjectUtility.GetNavMeshArea(filter.gameObject);

            meshes.Add(smesh);
        }
    }
Exemple #3
0
    public List <Mesh> BuildSidewalkMeshes()
    {
        if (Corners.Count != 4)
        {
            return(null);
        }
        List <Mesh> meshes = new List <Mesh>();

        for (int i = 0; i < Corners.Count; i++)
        {
            List <Vector3> verts = new List <Vector3>();
            List <int>     tris  = new List <int>();
            //a corner can only ever be connected to 1 or 2 Streets
            if (Corners[i].ConnectedTo.Count == 1)
            {
            }
            else if (Corners[i].ConnectedTo.Count == 2)
            {
                Vector3 offset0 = Corners[i].GetSidewalkOffset(0);
                Vector3 offset1 = Corners[i].GetSidewalkOffset(0);
                Vector3 yOffset = sidewalkHeight * Vector3.up;
                //top face
                verts.Add(Corners[i].Position - Position + yOffset);
                verts.Add(Corners[i].Position + offset0 - Position + yOffset);
                verts.Add(Corners[i].Position + offset1 - Position + yOffset);
                verts.Add(Corners[i].Position + offset0 + offset1 - Position + yOffset);

                tris.Add(0);
                tris.Add(3);
                tris.Add(1);

                tris.Add(0);
                tris.Add(2);
                tris.Add(3);

                //side faces
                verts.Add(Corners[i].Position + offset0 - Position + yOffset);
                verts.Add(Corners[i].Position + offset0 - Position - yOffset);
                verts.Add(Corners[i].Position + offset0 + offset1 - Position + yOffset);
                verts.Add(Corners[i].Position + offset0 + offset1 - Position - yOffset);

                tris.Add(5);
                tris.Add(4);
                tris.Add(6);

                tris.Add(5);
                tris.Add(7);
                tris.Add(4);

                verts.Add(Corners[i].Position + offset1 - Position + yOffset);
                verts.Add(Corners[i].Position + offset1 - Position - yOffset);
                verts.Add(Corners[i].Position + offset0 + offset1 - Position + yOffset);
                verts.Add(Corners[i].Position + offset0 + offset1 - Position - yOffset);

                tris.Add(9);
                tris.Add(8);
                tris.Add(10);

                tris.Add(9);
                tris.Add(11);
                tris.Add(8);
            }
            else
            {
                DB.Error("Corner of Intersection can't be built because of invalid n of connections");
            }
            meshes.Add(ExtMesh.BuildMesh(verts, tris));
        }
        return(meshes);
    }