Cutting holes

sdkproject/Assets/Mapbox/Core/Unity/MeshGeneration/Components/FeatureBehaviour.cs

@@ -12,11 +12,19 @@ public class FeatureBehaviour : MonoBehaviour
         [Multiline(10)]
         public string DataString;
 
+        [Multiline(10)]
+        public string Points;
+
         public void Init(VectorFeatureUnity feature)
         {
             Transform = transform;
             Data = feature;
             DataString = string.Join(" \r\n ", Data.Properties.Select(x => x.Key + " - " + x.Value.ToString()).ToArray());
+            foreach (var item in feature.Points)
+            {
+                Points += string.Join(",", item.Select(x => x.x + "-" + x.z).ToArray());
+                Points += "\r\n ";
+            }
         }
     }
 }

sdkproject/Assets/Mapbox/Core/Unity/MeshGeneration/Data/MeshData.cs

@@ -1,25 +1,30 @@
-namespace Mapbox.Unity.MeshGeneration.Data
-{
-    using System.Collections.Generic;
-    using UnityEngine;
-    using Utils;
-
-    public class MeshData
-    {
-        public Vector2 MercatorCenter { get; set; }
-        public RectD TileRect { get; set; }
+namespace Mapbox.Unity.MeshGeneration.Data
+{
+    using System.Collections.Generic;
+    using TriangleNet.Geometry;
+    using TriangleNet.Meshing;
+    using UnityEngine;
+    using Utils;
+
+    public class MeshData
+    {
+        public List<int> Edges { get; set; }
+        public IMesh PolygonMesh { get; set; }
+        public Vector2 MercatorCenter { get; set; }
+        public RectD TileRect { get; set; }
         public List<Vector3> Vertices { get; set; }
         public List<Vector3> Normals { get; set; }
-        public List<List<int>> Triangles { get; set; }
-        public List<List<Vector2>> UV { get; set; }
-
-        public MeshData()
-        {
-            Vertices = new List<Vector3>();
-            Normals = new List<Vector3>();
-            Triangles = new List<List<int>>();
-            UV = new List<List<Vector2>>();
-            UV.Add(new List<Vector2>());
-        }
-    }
-}
+        public List<List<int>> Triangles { get; set; }
+        public List<List<Vector2>> UV { get; set; }
+
+        public MeshData()
+        {
+            Edges = new List<int>();
+            Vertices = new List<Vector3>();
+            Normals = new List<Vector3>();
+            Triangles = new List<List<int>>();
+            UV = new List<List<Vector2>>();
+            UV.Add(new List<Vector2>());
+        }
+    }
+}

sdkproject/Assets/Mapbox/Core/Unity/MeshGeneration/Data/VectorFeatureUnity.cs

@@ -12,6 +12,11 @@ public class VectorFeatureUnity
         public Dictionary<string, object> Properties { get; set; }
         public List<List<Vector3>> Points;
 
+        public VectorFeatureUnity()
+        {
+            Points = new List<List<Vector3>>();
+        }
+
         public VectorFeatureUnity(VectorTileFeature feature, UnityTile tile, float layerExtent)
         {
             Data = feature;
@@ -25,7 +30,7 @@ public VectorFeatureUnity(VectorTileFeature feature, UnityTile tile, float layer
                 for (int j = 0; j < geom[i].Count; j++)
                 {
                     var point = geom[i][j];
-                    nl.Add(new Vector3((float)(point.X / layerExtent * tile.Rect.Size.x - (tile.Rect.Size.x/2)), 0, (float)((layerExtent - point.Y) / layerExtent * tile.Rect.Size.y - (tile.Rect.Size.y / 2))));
+                    nl.Add(new Vector3((float)(point.X / layerExtent * tile.Rect.Size.x - (tile.Rect.Size.x / 2)), 0, (float)((layerExtent - point.Y) / layerExtent * tile.Rect.Size.y - (tile.Rect.Size.y / 2))));
                 }
                 Points.Add(nl);
             }

sdkproject/Assets/Mapbox/Core/Unity/MeshGeneration/Factories/DirectionsFactory.cs

@@ -39,18 +39,21 @@ public void Query(List<Transform> waypoints)
         void HandleDirectionsResponse(DirectionsResponse response)
         {
             var meshData = new MeshData();
-
+            var dat = new List<Vector3>();
             foreach (var leg in response.Routes[0].Legs)
             {
                 foreach (var point in response.Routes[0].Geometry)
                 {
-                    meshData.Vertices.Add(Conversions.GeoToWorldPosition(point.x, point.y, Parameters.ReferenceTileRect.Center, Parameters.WorldScaleFactor).ToVector3xz());
+                    dat.Add(Conversions.GeoToWorldPosition(point.x, point.y, Parameters.ReferenceTileRect.Center, Parameters.WorldScaleFactor).ToVector3xz());
                 }
             }
 
+            var feat = new VectorFeatureUnity();
+            feat.Points.Add(dat);
+
             foreach (MeshModifier mod in MeshModifiers.Where(x => x.Active))
             {
-                mod.Run(null, meshData);
+                mod.Run(feat, meshData);
             }
 
             CreateGameObject(meshData);

sdkproject/Assets/Mapbox/Core/Unity/MeshGeneration/LayerVisualizers/VectorLayerVisualizer.cs

@@ -109,102 +109,65 @@ public override void Create(VectorTileLayer layer, UnityTile tile)
         /// <param name="feature"></param>
         /// <param name="tile"></param>
         /// <param name="parent"></param>
-        private void Build(VectorFeatureUnity feature, UnityTile tile, GameObject parent)
+         private bool IsFeatureValid(VectorFeatureUnity feature)
         {
             if (feature.Properties.ContainsKey("extrude") && !bool.Parse(feature.Properties["extrude"].ToString()))
-                return;
+                return false;
 
-            //we're not cutting out the holes yet
-            foreach (var geometry in feature.Points)
-            {
-                var meshData = new MeshData();
-                meshData.TileRect = tile.Rect;
+            if (feature.Points.Count < 1)
+                return false;
 
-                if (geometry.Count <= 1)
-                    continue;
+            return true;
+        }
 
-                //this will be improved in next version and will probably be replaced by filters
-                string styleSelectorKey = "";
-                if (string.IsNullOrEmpty(_classificationKey))
-                {
-                    if (feature.Properties.ContainsKey("type"))
-                    {
-                        styleSelectorKey = feature.Properties["type"].ToString().ToLowerInvariant();
-                    }
-                    else if (feature.Properties.ContainsKey("class"))
-                    {
-                        styleSelectorKey = feature.Properties["class"].ToString().ToLowerInvariant();
-                    }
-                }
-                else if (feature.Properties.ContainsKey(_classificationKey))
-                {
-                    if (feature.Properties.ContainsKey(_classificationKey))
-                    {
-                        styleSelectorKey = feature.Properties[_classificationKey].ToString().ToLowerInvariant();
-                    }
-                }
+        private void Build(VectorFeatureUnity feature, UnityTile tile, GameObject parent)
+        {
+            if (!IsFeatureValid(feature))
+                return;
 
-                //we'll run all visualizers on MeshData here 
-                var list = geometry;
-                //.Select(x => Conversions.GeoToWorldPosition(x.Lat, x.Lng, tile.Rect.Center).ToVector3xz()).ToList();
+            //this will be improved in next version and will probably be replaced by filters
+            var styleSelectorKey = FindSelectorKey(feature);
 
-                //long straight edges looks bad on bumpy terrain
-                if (_subdivideLongEdges)
-                {
-                    var verts = new List<Vector3>();
-                    if (list.Count > 1)
-                    {
-                        for (int i = 0; i < list.Count - 1; i++)
-                        {
-                            verts.Add(list[i]);
-                            var dist = Vector3.Distance(list[i], list[i + 1]);
-                            var step = Math.Min(_maxEdgeSectionCount, dist / _preferredEdgeSectionLength);
-                            if (step > 1)
-                            {
-                                var counter = 1;
-                                while (counter < step)
-                                {
-                                    var nv = Vector3.Lerp(list[i], list[i + 1], Mathf.Min(1, counter / step));
-                                    verts.Add(nv);
-                                    counter++;
-                                }
-                            }
-                        }
-                    }
-                    verts.Add(list.Last());
-                    list = verts;
-                }
+            var meshData = new MeshData();
+            meshData.TileRect = tile.Rect;
+
+            //and finally, running the modifier stack on the feature
+            var mod = Stacks.FirstOrDefault(x => x.Type.Contains(styleSelectorKey));
+            GameObject go;
+            if (mod != null)
+            {
+                go = mod.Stack.Execute(tile, feature, meshData, parent, mod.Type);
+            }
+            else
+            {
+                if (_defaultStack != null)
+                    go = _defaultStack.Execute(tile, feature, meshData, parent, _key);
+            }
+            //go.layer = LayerMask.NameToLayer(_key);
+        }
 
-                //adding terrain & building min_height to vertices
-                //we may move this into height modifier in the future
-                meshData.Vertices = list.Select(vertex =>
+        private string FindSelectorKey(VectorFeatureUnity feature)
+        {
+            if (string.IsNullOrEmpty(_classificationKey))
+            {
+                if (feature.Properties.ContainsKey("type"))
                 {
-                    var h = tile.QueryHeightData((float)((vertex.x + tile.Rect.Size.x / 2) / tile.Rect.Size.x), (float)((vertex.z + tile.Rect.Size.y / 2) / tile.Rect.Size.y));
-                    vertex += new Vector3(0, h, 0);
-
-                    if (feature.Properties.ContainsKey("min_height"))
-                    {
-                        var min_height = Convert.ToSingle(feature.Properties["min_height"]);
-                        vertex += new Vector3(0, min_height, 0);
-                    }
-
-                    return vertex;
-                }).ToList();
-
-                //and finally, running the modifier stack on the feature
-                var mod = Stacks.FirstOrDefault(x => x.Type.Contains(styleSelectorKey));
-                GameObject go;
-                if (mod != null)
+                    return feature.Properties["type"].ToString().ToLowerInvariant();
+                }
+                else if (feature.Properties.ContainsKey("class"))
                 {
-                    go = mod.Stack.Execute(tile, feature, meshData, parent, mod.Type);
+                    return feature.Properties["class"].ToString().ToLowerInvariant();
                 }
-                else
+            }
+            else if (feature.Properties.ContainsKey(_classificationKey))
+            {
+                if (feature.Properties.ContainsKey(_classificationKey))
                 {
-                    if (_defaultStack != null)
-                        go = _defaultStack.Execute(tile, feature, meshData, parent, _key);
+                    return feature.Properties[_classificationKey].ToString().ToLowerInvariant();
                 }
-                //go.layer = LayerMask.NameToLayer(_key);
             }
+
+            return "";
         }
     }
 }

sdkproject/Assets/Mapbox/Core/Unity/MeshGeneration/MapController.cs

@@ -67,18 +67,11 @@ public void Start()
         /// <summary>
         /// Pulls the root world object to origin for ease of use/view
         /// </summary>
-        public void Update()
+        private void SnapZero(UnityTile s, object e)
         {
-            if (_snapYToZero)
-            {
-                var ray = new Ray(new Vector3(0, 1000, 0), Vector3.down);
-                RaycastHit rayhit;
-                if (Physics.Raycast(ray, out rayhit))
-                {
-                    Root.transform.position = new Vector3(0, -rayhit.point.y, 0);
-                    _snapYToZero = false;
-                }
-            }
+            var h = Conversions.GetRelativeHeightFromColor(s.HeightData.GetPixel(127, 127), s.RelativeScale);
+            Root.transform.position = new Vector3(0, -h * WorldParameters.WorldScaleFactor, 0);
+            s.HeightDataChanged -= SnapZero;
         }
 
         public void Execute()
@@ -109,6 +102,11 @@ public void Execute(double lat, double lng, int zoom, Vector4 frame)
                     tile.transform.position = new Vector3((float)(tile.Rect.Center.x - WorldParameters.ReferenceTileRect.Center.x), 0, (float)(tile.Rect.Center.y - WorldParameters.ReferenceTileRect.Center.y));
                     tile.transform.SetParent(Root.transform, false);
                     MapVisualization.ShowTile(tile);
+
+                    if (_snapYToZero && j == _refTile.y && i == _refTile.x)
+                    {
+                        tile.HeightDataChanged += SnapZero;
+                    }
                 }
             }
 

sdkproject/Assets/Mapbox/Core/Unity/MeshGeneration/Modifiers/MergedModifierStack.cs

@@ -27,6 +27,8 @@ public class MergedModifierStack : ModifierStackBase
 
         public override GameObject Execute(UnityTile tile, VectorFeatureUnity feature, MeshData meshData, GameObject parent = null, string type = "")
         {
+            base.Execute(tile, feature, meshData, parent, type);
+
             if (!_cacheVertexCount.ContainsKey(tile))
             {
                 _cacheVertexCount.Add(tile, 0);
@@ -37,7 +39,7 @@ public override GameObject Execute(UnityTile tile, VectorFeatureUnity feature, M
             _buildingCount[tile]++;
             foreach (MeshModifier mod in MeshModifiers.Where(x => x.Active))
             {
-                mod.Run(feature, meshData);
+                mod.Run(feature, meshData, tile);
             }
 
             GameObject go = null;

sdkproject/Assets/Mapbox/Core/Unity/MeshGeneration/Modifiers/MeshModifier.cs

@@ -12,7 +12,7 @@ public class MeshModifier : ModifierBase
     {
         public virtual ModifierType Type { get { return ModifierType.Preprocess; } }
 
-        public virtual void Run(VectorFeatureUnity feature, MeshData md)
+        public virtual void Run(VectorFeatureUnity feature, MeshData md, UnityTile tile = null)
         {
 
         }

sdkproject/Assets/Mapbox/Core/Unity/MeshGeneration/Modifiers/MeshModifiers/ChamferModifier.cs

@@ -14,7 +14,7 @@ public class ChamferModifier : MeshModifier
         [SerializeField]
         private float _size;
 
-        public override void Run(VectorFeatureUnity feature, MeshData md)
+        public override void Run(VectorFeatureUnity feature, MeshData md, UnityTile tile = null)
         {
             if (md.Vertices.Count == 0)
                 return;