public CustomFeatureUnity(VectorTileFeature feature, CustomTile tile, float layerExtent, bool buildingsWithUniqueIds = false)
{
Data = feature;
Properties = Data.GetProperties();
Points.Clear();
Tile = tile;
//this is a temp hack until we figure out how streets ids works
_geom = buildingsWithUniqueIds ? feature.Geometry <float>() : feature.Geometry <float>(0);
_rectSizex = tile.Rect.Size.x;
_rectSizey = tile.Rect.Size.y;
_geomCount = _geom.Count;
for (var i = 0; i < _geomCount; i++)
{
_pointCount = _geom[i].Count;
_newPoints = new List <Vector3>(_pointCount);
for (var j = 0; j < _pointCount; j++)
{
var point = _geom[i][j];
_newPoints.Add(new Vector3((float)(point.X / layerExtent * _rectSizex - (_rectSizex / 2)) * tile.TileScale, 0, (float)((layerExtent - point.Y) / layerExtent * _rectSizey - (_rectSizey / 2)) * tile.TileScale));
}
Points.Add(_newPoints);
}
}
private void MakeEntity(CustomTile tile, MeshData value)
{
var go = new GameObject($"Building {_indices[tile]++.ToString()}");
go.transform.position = tile.Position;
go.transform.SetParent(tile.Transform, true);
var filter = go.AddComponent <MeshFilter>();
filter.sharedMesh = new Mesh();
go.AddComponent <MeshRenderer>().sharedMaterial = BuildingMaterial;
filter.sharedMesh.subMeshCount = value.Triangles.Count;
filter.sharedMesh.SetVertices(value.Vertices);
filter.sharedMesh.SetNormals(value.Normals);
for (var i = 0; i < value.Triangles.Count; i++)
{
filter.sharedMesh.SetTriangles(value.Triangles[i], i);
}
for (var i = 0; i < value.UV.Count; i++)
{
filter.sharedMesh.SetUVs(i, value.UV[i]);
}
go.layer = LayerMask.NameToLayer("Buildings");
}
private void OnImageReceived(CustomTile tile, RasterTile rasterTile)
{
if (tile == null)
{
return;
}
TilesWaitingResponse.Remove(tile);
var raster = new Texture2D(512, 512, TextureFormat.RGB24, false)
{
wrapMode = TextureWrapMode.Clamp
};
raster.LoadImage(rasterTile.Data);
raster.Compress(true);
_textures[tile.TextureIndex] = raster;
_combineInstances[tile.TextureIndex] = new CombineInstance
{
mesh = tile.QuadMesh,
transform = tile.Transform.parent.localToWorldMatrix * tile.Transform.localToWorldMatrix
};
tile.ClearMesh();
if (++_counter == ManhattanTileProvider.Tiles.Count)
{
OnComplete();
}
}
public void Create(VectorTileLayer layer, CustomTile tile)
{
if (tile == null || layer == null)
{
return;
}
var properties = MakeProperties(layer);
CoroutineManager.Run(ProcessingRoutine(properties, tile));
}
public void Terminate(CustomTile tile)
{
if (_accumulation.TryGetValue(tile, out var value) && value.Vertices.Count > 3)
{
MakeEntity(tile, value);
}
tile.VectorDataState = TilePropertyState.Loaded;
_accumulation.Remove(tile);
}
private void Terminate(CustomTile tile, MeshData data)
{
if (!_accumulation.TryGetValue(tile, out var value) || value.Vertices.Count <= 3)
{
return;
}
MakeEntity(tile, value);
_accumulation[tile] = data;
}
protected override void OnRegistered(CustomTile tile)
{
tile.VectorDataState = TilePropertyState.Loading;
TilesWaitingResponse.Add(tile);
_dataFetcher.FetchData(new BuildingMeshFetcherParameters
{
canonicalTileId = tile.CanonicalTileId,
tilesetId = TilesetId,
cTile = tile,
useOptimizedStyle = false,
style = _sourceOptions.layerSource
});
}
private void OnVectorDataReceived(CustomTile tile, VectorTile vectorTile)
{
if (tile == null)
{
return;
}
TilesWaitingResponse.Remove(tile);
_builder.Create(vectorTile.Data.GetLayer(DronesMap.LayerName), tile);
if (++_counter != ManhattanTileProvider.Tiles.Count)
{
return;
}
AllBuildingsLoaded?.Invoke();
}
protected override void OnRegistered(CustomTile tile)
{
if (Properties.sourceType != ImagerySourceType.Custom)
{
Properties.sourceOptions.layerSource = MapboxDefaultImagery.GetParameters(Properties.sourceType);
}
var parameters = new TerrainImageFetcherParameters
{
canonicalTileId = tile.CanonicalTileId,
tilesetId = TilesetId,
cTile = tile,
useRetina = Properties.rasterOptions.useRetina
};
_dataFetcher.FetchData(parameters);
}
private void ProcessFeature(int index, CustomTile tile, BuildingMeshBuilderProperties layerProperties)
{
var layerExtent = layerProperties.VectorTileLayer.Extent;
var fe = layerProperties.VectorTileLayer.GetFeature(index);
List <List <Point2d <float> > > geom;
if (layerProperties.BuildingsWithUniqueIds)
{
geom = fe.Geometry <float>();
if (geom[0][0].X <0 || geom[0][0].X> layerExtent || geom[0][0].Y <0 || geom[0][0].Y> layerExtent)
{
return;
}
}
else
{
geom = fe.Geometry <float>(0); //passing zero means clip at tile edge
}
var feature = new CustomFeatureUnity(
layerProperties.VectorTileLayer.GetFeature(index),
geom,
tile,
layerProperties.VectorTileLayer.Extent,
layerProperties.BuildingsWithUniqueIds);
if (!IsFeatureEligibleAfterFiltering(feature, layerProperties) ||
tile == null || tile.VectorDataState == TilePropertyState.Cancelled)
{
return;
}
if (feature.Properties.ContainsKey("extrude") && !Convert.ToBoolean(feature.Properties["extrude"]))
{
return;
}
if (feature.Points.Count < 1)
{
return;
}
_processor.Execute(tile, feature);
}
private void Append(CustomTile tile, MeshData data)
{
if (!_accumulation.TryGetValue(tile, out var value))
{
value = _accumulation[tile] = data;
}
if (data.Vertices.Count <= 3)
{
return;
}
var st = value.Vertices.Count;
value.Vertices.AddRange(data.Vertices);
value.Normals.AddRange(data.Normals);
for (var j = 0; j < data.UV.Count; j++)
{
if (value.UV.Count <= j)
{
value.UV.Add(new List <Vector2>(data.UV[j].Count));
}
}
for (var j = 0; j < data.UV.Count; j++)
{
value.UV[j].AddRange(data.UV[j]);
}
for (var j = 0; j < data.Triangles.Count; j++)
{
if (value.Triangles.Count <= j)
{
value.Triangles.Add(new List <int>(data.Triangles[j].Count));
}
}
for (var j = 0; j < data.Triangles.Count; j++)
{
for (var k = 0; k < data.Triangles[j].Count; k++)
{
value.Triangles[j].Add(data.Triangles[j][k] + st);
}
}
}
public void Execute(CustomTile tile, CustomFeatureUnity feature)
{
var meshData = new MeshData {
TileRect = tile.Rect
};
if (!_accumulation.ContainsKey(tile))
{
_accumulation.Add(tile, new MeshData
{
Edges = new List <int>(),
Normals = new List <Vector3>(),
Tangents = new List <Vector4>(),
Triangles = new List <List <int> > {
new List <int>()
},
UV = new List <List <Vector2> > {
new List <Vector2>()
},
Vertices = new List <Vector3>()
});
_indices.Add(tile, 0);
}
foreach (var modifier in _modifiers)
{
modifier.Run((VectorFeatureUnity)feature, meshData);
}
if (_accumulation[tile].Vertices.Count + meshData.Vertices.Count < 65000)
{
Append(tile, meshData);
}
else
{
Terminate(tile, meshData);
}
}
public CustomFeatureUnity(VectorTileFeature feature, List <List <Point2d <float> > > geom, CustomTile tile, float layerExtent, bool buildingsWithUniqueIds = false)
{
Data = feature;
Properties = Data.GetProperties();
Points.Clear();
Tile = tile;
_geom = geom;
_rectSizex = tile.Rect.Size.x;
_rectSizey = tile.Rect.Size.y;
_geomCount = _geom.Count;
for (var i = 0; i < _geomCount; i++)
{
_pointCount = _geom[i].Count;
_newPoints = new List <Vector3>(_pointCount);
for (var j = 0; j < _pointCount; j++)
{
var point = _geom[i][j];
_newPoints.Add(new Vector3((float)(point.X / layerExtent * _rectSizex - (_rectSizex / 2)) * tile.TileScale, 0, (float)((layerExtent - point.Y) / layerExtent * _rectSizey - (_rectSizey / 2)) * tile.TileScale));
}
Points.Add(_newPoints);
}
}
private IEnumerator ProcessingRoutine(BuildingMeshBuilderProperties properties, CustomTile tile)
{
for (var i = 0; i < properties.FeatureCount; ++i)
{
ProcessFeature(i, tile, properties);
yield return(null);
}
_processor.Terminate(tile);
}
protected abstract void OnRegistered(CustomTile tile);
public void Register(CustomTile tile)
{
OnRegistered(tile);
}
