public override bool Cleanup(UnwrappedTileId tile)
{
return(!_currentExtent.activeTiles.Contains(tile));
}
protected virtual void TileProvider_OnTileRepositioned(UnwrappedTileId tileId)
{
_mapVisualizer.RepositionTile(tileId);
}
void TileProvider_OnTileRemoved(UnwrappedTileId tileId)
{
_mapVisualizer.DisposeTile(tileId);
}
/// <summary>
/// Gets the unity tile from unwrapped tile identifier.
/// </summary>
/// <returns>The unity tile from unwrapped tile identifier.</returns>
/// <param name="tileId">Tile identifier.</param>
public UnityTile GetUnityTileFromUnwrappedTileId(UnwrappedTileId tileId)
{
return(_activeTiles[tileId]);
}
/// <summary>
/// Checkes all neighbours of the given tile and stitches the edges to achieve a smooth mesh surface.
/// </summary>
/// <param name="tile"></param>
/// <param name="mesh"></param>
private void FixStitches(UnwrappedTileId tileId, MeshData mesh)
{
var meshVertCount = mesh.Vertices.Count;
_stitchTarget = null;
_meshData.TryGetValue(tileId.North, out _stitchTarget);
var cap = _sampleCount - 1;
if (_stitchTarget != null)
{
_stitchTarget.GetVertices(_stitchTargetMeshData.Vertices);
_stitchTarget.GetNormals(_stitchTargetMeshData.Normals);
for (int i = 0; i < cap; i++)
{
mesh.Vertices[6 * i] = new Vector3(
mesh.Vertices[6 * i].x,
_stitchTargetMeshData.Vertices[6 * cap * (cap - 1) + 6 * i + 2].y,
mesh.Vertices[6 * i].z);
mesh.Vertices[6 * i + 1] = new Vector3(
mesh.Vertices[6 * i + 1].x,
_stitchTargetMeshData.Vertices[6 * cap * (cap - 1) + 6 * i + 4].y,
mesh.Vertices[6 * i + 1].z);
mesh.Vertices[6 * i + 3] = new Vector3(
mesh.Vertices[6 * i + 3].x,
_stitchTargetMeshData.Vertices[6 * cap * (cap - 1) + 6 * i + 4].y,
mesh.Vertices[6 * i + 3].z);
}
}
_stitchTarget = null;
_meshData.TryGetValue(tileId.South, out _stitchTarget);
if (_stitchTarget != null)
{
_stitchTarget.GetVertices(_stitchTargetMeshData.Vertices);
_stitchTarget.GetNormals(_stitchTargetMeshData.Normals);
for (int i = 0; i < cap; i++)
{
mesh.Vertices[6 * cap * (cap - 1) + 6 * i + 2] = new Vector3(
mesh.Vertices[6 * cap * (cap - 1) + 6 * i + 2].x,
_stitchTargetMeshData.Vertices[6 * i].y,
mesh.Vertices[6 * cap * (cap - 1) + 6 * i + 2].z);
mesh.Vertices[6 * cap * (cap - 1) + 6 * i + 5] = new Vector3(
mesh.Vertices[6 * cap * (cap - 1) + 6 * i + 5].x,
_stitchTargetMeshData.Vertices[6 * i].y,
mesh.Vertices[6 * cap * (cap - 1) + 6 * i + 5].z);
mesh.Vertices[6 * cap * (cap - 1) + 6 * i + 4] = new Vector3(
mesh.Vertices[6 * cap * (cap - 1) + 6 * i + 4].x,
_stitchTargetMeshData.Vertices[6 * i + 3].y,
mesh.Vertices[6 * cap * (cap - 1) + 6 * i + 4].z);
}
}
_stitchTarget = null;
_meshData.TryGetValue(tileId.West, out _stitchTarget);
if (_stitchTarget != null)
{
_stitchTarget.GetVertices(_stitchTargetMeshData.Vertices);
_stitchTarget.GetNormals(_stitchTargetMeshData.Normals);
for (int i = 0; i < cap; i++)
{
mesh.Vertices[6 * cap * i] = new Vector3(
mesh.Vertices[6 * cap * i].x,
_stitchTargetMeshData.Vertices[6 * cap * i + 6 * cap - 5].y,
mesh.Vertices[6 * cap * i].z);
mesh.Vertices[6 * cap * i + 2] = new Vector3(
mesh.Vertices[6 * cap * i + 2].x,
_stitchTargetMeshData.Vertices[6 * cap * i + 6 * cap - 2].y,
mesh.Vertices[6 * cap * i + 2].z);
mesh.Vertices[6 * cap * i + 5] = new Vector3(
mesh.Vertices[6 * cap * i + 5].x,
_stitchTargetMeshData.Vertices[6 * cap * i + 6 * cap - 2].y,
mesh.Vertices[6 * cap * i + 5].z);
}
}
_stitchTarget = null;
_meshData.TryGetValue(tileId.East, out _stitchTarget);
if (_stitchTarget != null)
{
_stitchTarget.GetVertices(_stitchTargetMeshData.Vertices);
_stitchTarget.GetNormals(_stitchTargetMeshData.Normals);
for (int i = 0; i < cap; i++)
{
mesh.Vertices[6 * cap * i + 6 * cap - 5] = new Vector3(
mesh.Vertices[6 * cap * i + 6 * cap - 5].x,
_stitchTargetMeshData.Vertices[6 * cap * i].y,
mesh.Vertices[6 * cap * i + 6 * cap - 5].z);
mesh.Vertices[6 * cap * i + 6 * cap - 3] = new Vector3(
mesh.Vertices[6 * cap * i + 6 * cap - 3].x,
_stitchTargetMeshData.Vertices[6 * cap * i].y,
mesh.Vertices[6 * cap * i + 6 * cap - 3].z);
mesh.Vertices[6 * cap * i + 6 * cap - 2] = new Vector3(
mesh.Vertices[6 * cap * i + 6 * cap - 2].x,
_stitchTargetMeshData.Vertices[6 * cap * i + 5].y,
mesh.Vertices[6 * cap * i + 6 * cap - 2].z);
}
}
_stitchTarget = null;
_meshData.TryGetValue(tileId.NorthWest, out _stitchTarget);
if (_stitchTarget != null)
{
_stitchTarget.GetVertices(_stitchTargetMeshData.Vertices);
_stitchTarget.GetNormals(_stitchTargetMeshData.Normals);
mesh.Vertices[0] = new Vector3(
mesh.Vertices[0].x,
_stitchTargetMeshData.Vertices[meshVertCount - 2].y,
mesh.Vertices[0].z);
}
_stitchTarget = null;
_meshData.TryGetValue(tileId.NorthEast, out _stitchTarget);
if (_stitchTarget != null)
{
_stitchTarget.GetVertices(_stitchTargetMeshData.Vertices);
_stitchTarget.GetNormals(_stitchTargetMeshData.Normals);
mesh.Vertices[6 * cap - 5] = new Vector3(
mesh.Vertices[6 * cap - 5].x,
_stitchTargetMeshData.Vertices[6 * (cap - 1) * cap + 2].y,
mesh.Vertices[6 * cap - 5].z);
mesh.Vertices[6 * cap - 3] = new Vector3(
mesh.Vertices[6 * cap - 3].x,
_stitchTargetMeshData.Vertices[6 * (cap - 1) * cap + 2].y,
mesh.Vertices[6 * cap - 3].z);
}
_stitchTarget = null;
_meshData.TryGetValue(tileId.SouthWest, out _stitchTarget);
if (_stitchTarget != null)
{
_stitchTarget.GetVertices(_stitchTargetMeshData.Vertices);
_stitchTarget.GetNormals(_stitchTargetMeshData.Normals);
mesh.Vertices[6 * (cap - 1) * cap + 2] = new Vector3(
mesh.Vertices[6 * (cap - 1) * cap + 2].x,
_stitchTargetMeshData.Vertices[6 * cap - 5].y,
mesh.Vertices[6 * (cap - 1) * cap + 2].z);
mesh.Vertices[6 * (cap - 1) * cap + 5] = new Vector3(
mesh.Vertices[6 * (cap - 1) * cap + 5].x,
_stitchTargetMeshData.Vertices[6 * cap - 5].y,
mesh.Vertices[6 * (cap - 1) * cap + 5].z);
}
_stitchTarget = null;
_meshData.TryGetValue(tileId.SouthEast, out _stitchTarget);
if (_stitchTarget != null)
{
_stitchTarget.GetVertices(_stitchTargetMeshData.Vertices);
_stitchTarget.GetNormals(_stitchTargetMeshData.Normals);
mesh.Vertices[6 * cap * cap - 2] = new Vector3(
mesh.Vertices[6 * cap * cap - 2].x,
_stitchTargetMeshData.Vertices[0].y,
mesh.Vertices[6 * cap * cap - 2].z);
}
}
/// <summary>
/// Checkes all neighbours of the given tile and stitches the edges to achieve a smooth mesh surface.
/// </summary>
/// <param name="tileId"></param>
/// <param name="mesh"></param>
private void FixStitches(UnwrappedTileId tileId, MeshData mesh)
{
var _sampleCount = _elevationOptions.modificationOptions.sampleCount;
var meshVertCount = _sampleCount * _sampleCount;
_stitchTarget = null;
_meshData.TryGetValue(tileId.North, out _stitchTarget);
if (_stitchTarget != null)
{
_stitchTarget.GetVertices(_stitchTargetMeshData.Vertices);
_stitchTarget.GetNormals(_stitchTargetMeshData.Normals);
for (int i = 0; i < _sampleCount; i++)
{
//just snapping the y because vertex pos is relative and we'll have to do tile pos + vertex pos for x&z otherwise
mesh.Vertices[i] = new Vector3(
mesh.Vertices[i].x,
_stitchTargetMeshData.Vertices[meshVertCount - _sampleCount + i].y,
mesh.Vertices[i].z);
mesh.Vertices[meshVertCount + (8 * i)] = mesh.Vertices[i];
mesh.Normals[i] = new Vector3(_stitchTargetMeshData.Normals[meshVertCount - _sampleCount + i].x,
_stitchTargetMeshData.Normals[meshVertCount - _sampleCount + i].y,
_stitchTargetMeshData.Normals[meshVertCount - _sampleCount + i].z);
}
}
_stitchTarget = null;
_meshData.TryGetValue(tileId.South, out _stitchTarget);
if (_stitchTarget != null)
{
_stitchTarget.GetVertices(_stitchTargetMeshData.Vertices);
_stitchTarget.GetNormals(_stitchTargetMeshData.Normals);
for (int i = 0; i < _sampleCount; i++)
{
mesh.Vertices[meshVertCount - _sampleCount + i] = new Vector3(
mesh.Vertices[meshVertCount - _sampleCount + i].x,
_stitchTargetMeshData.Vertices[i].y,
mesh.Vertices[meshVertCount - _sampleCount + i].z);
mesh.Vertices[meshVertCount + 6 + (8 * i)] = mesh.Vertices[meshVertCount - _sampleCount + i];
mesh.Normals[meshVertCount - _sampleCount + i] = new Vector3(
_stitchTargetMeshData.Normals[i].x,
_stitchTargetMeshData.Normals[i].y,
_stitchTargetMeshData.Normals[i].z);
}
}
_stitchTarget = null;
_meshData.TryGetValue(tileId.West, out _stitchTarget);
if (_stitchTarget != null)
{
_stitchTarget.GetVertices(_stitchTargetMeshData.Vertices);
_stitchTarget.GetNormals(_stitchTargetMeshData.Normals);
for (int i = 0; i < _sampleCount; i++)
{
mesh.Vertices[i * _sampleCount] = new Vector3(
mesh.Vertices[i * _sampleCount].x,
_stitchTargetMeshData.Vertices[i * _sampleCount + _sampleCount - 1].y,
mesh.Vertices[i * _sampleCount].z);
mesh.Vertices[meshVertCount + 2 + (8 * i)] = mesh.Vertices[i * _sampleCount];
mesh.Normals[i * _sampleCount] = new Vector3(
_stitchTargetMeshData.Normals[i * _sampleCount + _sampleCount - 1].x,
_stitchTargetMeshData.Normals[i * _sampleCount + _sampleCount - 1].y,
_stitchTargetMeshData.Normals[i * _sampleCount + _sampleCount - 1].z);
}
}
_stitchTarget = null;
_meshData.TryGetValue(tileId.East, out _stitchTarget);
if (_stitchTarget != null)
{
_stitchTarget.GetVertices(_stitchTargetMeshData.Vertices);
_stitchTarget.GetNormals(_stitchTargetMeshData.Normals);
for (int i = 0; i < _sampleCount; i++)
{
mesh.Vertices[i * _sampleCount + _sampleCount - 1] = new Vector3(
mesh.Vertices[i * _sampleCount + _sampleCount - 1].x,
_stitchTargetMeshData.Vertices[i * _sampleCount].y,
mesh.Vertices[i * _sampleCount + _sampleCount - 1].z);
mesh.Vertices[meshVertCount + 4 + (8 * i)] = mesh.Vertices[i * _sampleCount + _sampleCount - 1];
mesh.Normals[i * _sampleCount + _sampleCount - 1] = new Vector3(
_stitchTargetMeshData.Normals[i * _sampleCount].x,
_stitchTargetMeshData.Normals[i * _sampleCount].y,
_stitchTargetMeshData.Normals[i * _sampleCount].z);
}
}
_stitchTarget = null;
_meshData.TryGetValue(tileId.NorthWest, out _stitchTarget);
if (_stitchTarget != null)
{
_stitchTarget.GetVertices(_stitchTargetMeshData.Vertices);
_stitchTarget.GetNormals(_stitchTargetMeshData.Normals);
mesh.Vertices[0] = new Vector3(
mesh.Vertices[0].x,
_stitchTargetMeshData.Vertices[meshVertCount - 1].y,
mesh.Vertices[0].z);
mesh.Normals[0] = new Vector3(
_stitchTargetMeshData.Normals[meshVertCount - 1].x,
_stitchTargetMeshData.Normals[meshVertCount - 1].y,
_stitchTargetMeshData.Normals[meshVertCount - 1].z);
}
_stitchTarget = null;
_meshData.TryGetValue(tileId.NorthEast, out _stitchTarget);
if (_stitchTarget != null)
{
_stitchTarget.GetVertices(_stitchTargetMeshData.Vertices);
_stitchTarget.GetNormals(_stitchTargetMeshData.Normals);
mesh.Vertices[_sampleCount - 1] = new Vector3(
mesh.Vertices[_sampleCount - 1].x,
_stitchTargetMeshData.Vertices[meshVertCount - _sampleCount].y,
mesh.Vertices[_sampleCount - 1].z);
mesh.Normals[_sampleCount - 1] = new Vector3(
_stitchTargetMeshData.Normals[meshVertCount - _sampleCount].x,
_stitchTargetMeshData.Normals[meshVertCount - _sampleCount].y,
_stitchTargetMeshData.Normals[meshVertCount - _sampleCount].z);
}
_stitchTarget = null;
_meshData.TryGetValue(tileId.SouthWest, out _stitchTarget);
if (_stitchTarget != null)
{
_stitchTarget.GetVertices(_stitchTargetMeshData.Vertices);
_stitchTarget.GetNormals(_stitchTargetMeshData.Normals);
mesh.Vertices[meshVertCount - _sampleCount] = new Vector3(
mesh.Vertices[meshVertCount - _sampleCount].x,
_stitchTargetMeshData.Vertices[_sampleCount - 1].y,
mesh.Vertices[meshVertCount - _sampleCount].z);
mesh.Normals[meshVertCount - _sampleCount] = new Vector3(
_stitchTargetMeshData.Normals[_sampleCount - 1].x,
_stitchTargetMeshData.Normals[_sampleCount - 1].y,
_stitchTargetMeshData.Normals[_sampleCount - 1].z);
}
_stitchTarget = null;
_meshData.TryGetValue(tileId.SouthEast, out _stitchTarget);
if (_stitchTarget != null)
{
_stitchTarget.GetVertices(_stitchTargetMeshData.Vertices);
_stitchTarget.GetNormals(_stitchTargetMeshData.Normals);
mesh.Vertices[meshVertCount - 1] = new Vector3(
mesh.Vertices[meshVertCount - 1].x,
_stitchTargetMeshData.Vertices[0].y,
mesh.Vertices[meshVertCount - 1].z);
mesh.Normals[meshVertCount - 1] = new Vector3(
_stitchTargetMeshData.Normals[0].x,
_stitchTargetMeshData.Normals[0].y,
_stitchTargetMeshData.Normals[0].z);
}
}
protected abstract void PlaceTile(UnwrappedTileId tileId, UnityTile tile, IMapReadable map);
protected void TileProvider_OnTileRemoved(UnwrappedTileId tileId)
{
// event handler
_mapVisualizer.DisposeTile(tileId);
}
/// <summary>
/// Checkes all neighbours of the given tile and stitches the edges to achieve a smooth mesh surface.
/// </summary>
/// <param name="tile"></param>
/// <param name="mesh"></param>
private void FixStitches(UnwrappedTileId tileId, MeshData mesh)
{
var meshVertCount = mesh.Vertices.Count;
_stitchTarget = null;
_meshData.TryGetValue(tileId.North, out _stitchTarget);
if (_stitchTarget != null)
{
#if UNITY_5_5_OR_NEWER
_stitchTarget.GetVertices(_stitchTargetMeshData.Vertices);
_stitchTarget.GetNormals(_stitchTargetMeshData.Normals);
#else
_stitchTargetMeshData.Vertices.Clear();
_stitchTargetMeshData.Vertices.AddRange(_stitchTarget.vertices);
_stitchTargetMeshData.Normals.Clear();
_stitchTargetMeshData.Normals.AddRange(_stitchTarget.normals);
#endif
for (int i = 0; i < _sampleCount; i++)
{
//just snapping the y because vertex pos is relative and we'll have to do tile pos + vertex pos for x&z otherwise
mesh.Vertices[i] = new Vector3(
mesh.Vertices[i].x,
_stitchTargetMeshData.Vertices[meshVertCount - _sampleCount + i].y,
mesh.Vertices[i].z);
mesh.Normals[i] = new Vector3(_stitchTargetMeshData.Normals[meshVertCount - _sampleCount + i].x,
_stitchTargetMeshData.Normals[meshVertCount - _sampleCount + i].y,
_stitchTargetMeshData.Normals[meshVertCount - _sampleCount + i].z);
}
}
_stitchTarget = null;
_meshData.TryGetValue(tileId.South, out _stitchTarget);
if (_stitchTarget != null)
{
#if UNITY_5_5_OR_NEWER
_stitchTarget.GetVertices(_stitchTargetMeshData.Vertices);
_stitchTarget.GetNormals(_stitchTargetMeshData.Normals);
#else
_stitchTargetMeshData.Vertices.Clear();
_stitchTargetMeshData.Vertices.AddRange(_stitchTarget.vertices);
_stitchTargetMeshData.Normals.Clear();
_stitchTargetMeshData.Normals.AddRange(_stitchTarget.normals);
#endif
for (int i = 0; i < _sampleCount; i++)
{
mesh.Vertices[meshVertCount - _sampleCount + i] = new Vector3(
mesh.Vertices[meshVertCount - _sampleCount + i].x,
_stitchTargetMeshData.Vertices[i].y,
mesh.Vertices[meshVertCount - _sampleCount + i].z);
mesh.Normals[meshVertCount - _sampleCount + i] = new Vector3(
_stitchTargetMeshData.Normals[i].x,
_stitchTargetMeshData.Normals[i].y,
_stitchTargetMeshData.Normals[i].z);
}
}
_stitchTarget = null;
_meshData.TryGetValue(tileId.West, out _stitchTarget);
if (_stitchTarget != null)
{
#if UNITY_5_5_OR_NEWER
_stitchTarget.GetVertices(_stitchTargetMeshData.Vertices);
_stitchTarget.GetNormals(_stitchTargetMeshData.Normals);
#else
_stitchTargetMeshData.Vertices.Clear();
_stitchTargetMeshData.Vertices.AddRange(_stitchTarget.vertices);
_stitchTargetMeshData.Normals.Clear();
_stitchTargetMeshData.Normals.AddRange(_stitchTarget.normals);
#endif
for (int i = 0; i < _sampleCount; i++)
{
mesh.Vertices[i * _sampleCount] = new Vector3(
mesh.Vertices[i * _sampleCount].x,
_stitchTargetMeshData.Vertices[i * _sampleCount + _sampleCount - 1].y,
mesh.Vertices[i * _sampleCount].z);
mesh.Normals[i * _sampleCount] = new Vector3(
_stitchTargetMeshData.Normals[i * _sampleCount + _sampleCount - 1].x,
_stitchTargetMeshData.Normals[i * _sampleCount + _sampleCount - 1].y,
_stitchTargetMeshData.Normals[i * _sampleCount + _sampleCount - 1].z);
}
}
_stitchTarget = null;
_meshData.TryGetValue(tileId.East, out _stitchTarget);
if (_stitchTarget != null)
{
#if UNITY_5_5_OR_NEWER
_stitchTarget.GetVertices(_stitchTargetMeshData.Vertices);
_stitchTarget.GetNormals(_stitchTargetMeshData.Normals);
#else
_stitchTargetMeshData.Vertices.Clear();
_stitchTargetMeshData.Vertices.AddRange(_stitchTarget.vertices);
_stitchTargetMeshData.Normals.Clear();
_stitchTargetMeshData.Normals.AddRange(_stitchTarget.normals);
#endif
for (int i = 0; i < _sampleCount; i++)
{
mesh.Vertices[i * _sampleCount + _sampleCount - 1] = new Vector3(
mesh.Vertices[i * _sampleCount + _sampleCount - 1].x,
_stitchTargetMeshData.Vertices[i * _sampleCount].y,
mesh.Vertices[i * _sampleCount + _sampleCount - 1].z);
mesh.Normals[i * _sampleCount + _sampleCount - 1] = new Vector3(
_stitchTargetMeshData.Normals[i * _sampleCount].x,
_stitchTargetMeshData.Normals[i * _sampleCount].y,
_stitchTargetMeshData.Normals[i * _sampleCount].z);
}
}
_stitchTarget = null;
_meshData.TryGetValue(tileId.NorthWest, out _stitchTarget);
if (_stitchTarget != null)
{
#if UNITY_5_5_OR_NEWER
_stitchTarget.GetVertices(_stitchTargetMeshData.Vertices);
_stitchTarget.GetNormals(_stitchTargetMeshData.Normals);
#else
_stitchTargetMeshData.Vertices.Clear();
_stitchTargetMeshData.Vertices.AddRange(_stitchTarget.vertices);
_stitchTargetMeshData.Normals.Clear();
_stitchTargetMeshData.Normals.AddRange(_stitchTarget.normals);
#endif
mesh.Vertices[0] = new Vector3(
mesh.Vertices[0].x,
_stitchTargetMeshData.Vertices[meshVertCount - 1].y,
mesh.Vertices[0].z);
mesh.Normals[0] = new Vector3(
_stitchTargetMeshData.Normals[meshVertCount - 1].x,
_stitchTargetMeshData.Normals[meshVertCount - 1].y,
_stitchTargetMeshData.Normals[meshVertCount - 1].z);
}
_stitchTarget = null;
_meshData.TryGetValue(tileId.NorthEast, out _stitchTarget);
if (_stitchTarget != null)
{
#if UNITY_5_5_OR_NEWER
_stitchTarget.GetVertices(_stitchTargetMeshData.Vertices);
_stitchTarget.GetNormals(_stitchTargetMeshData.Normals);
#else
_stitchTargetMeshData.Vertices.Clear();
_stitchTargetMeshData.Vertices.AddRange(_stitchTarget.vertices);
_stitchTargetMeshData.Normals.Clear();
_stitchTargetMeshData.Normals.AddRange(_stitchTarget.normals);
#endif
mesh.Vertices[_sampleCount - 1] = new Vector3(
mesh.Vertices[_sampleCount - 1].x,
_stitchTargetMeshData.Vertices[meshVertCount - _sampleCount].y,
mesh.Vertices[_sampleCount - 1].z);
mesh.Normals[_sampleCount - 1] = new Vector3(
_stitchTargetMeshData.Normals[meshVertCount - _sampleCount].x,
_stitchTargetMeshData.Normals[meshVertCount - _sampleCount].y,
_stitchTargetMeshData.Normals[meshVertCount - _sampleCount].z);
}
_stitchTarget = null;
_meshData.TryGetValue(tileId.SouthWest, out _stitchTarget);
if (_stitchTarget != null)
{
#if UNITY_5_5_OR_NEWER
_stitchTarget.GetVertices(_stitchTargetMeshData.Vertices);
_stitchTarget.GetNormals(_stitchTargetMeshData.Normals);
#else
_stitchTargetMeshData.Vertices.Clear();
_stitchTargetMeshData.Vertices.AddRange(_stitchTarget.vertices);
_stitchTargetMeshData.Normals.Clear();
_stitchTargetMeshData.Normals.AddRange(_stitchTarget.normals);
#endif
mesh.Vertices[meshVertCount - _sampleCount] = new Vector3(
mesh.Vertices[meshVertCount - _sampleCount].x,
_stitchTargetMeshData.Vertices[_sampleCount - 1].y,
mesh.Vertices[meshVertCount - _sampleCount].z);
mesh.Normals[meshVertCount - _sampleCount] = new Vector3(
_stitchTargetMeshData.Normals[_sampleCount - 1].x,
_stitchTargetMeshData.Normals[_sampleCount - 1].y,
_stitchTargetMeshData.Normals[_sampleCount - 1].z);
}
_stitchTarget = null;
_meshData.TryGetValue(tileId.SouthEast, out _stitchTarget);
if (_stitchTarget != null)
{
#if UNITY_5_5_OR_NEWER
_stitchTarget.GetVertices(_stitchTargetMeshData.Vertices);
_stitchTarget.GetNormals(_stitchTargetMeshData.Normals);
#else
_stitchTargetMeshData.Vertices.Clear();
_stitchTargetMeshData.Vertices.AddRange(_stitchTarget.vertices);
_stitchTargetMeshData.Normals.Clear();
_stitchTargetMeshData.Normals.AddRange(_stitchTarget.normals);
#endif
mesh.Vertices[meshVertCount - 1] = new Vector3(
mesh.Vertices[meshVertCount - 1].x,
_stitchTargetMeshData.Vertices[0].y,
mesh.Vertices[meshVertCount - 1].z);
mesh.Normals[meshVertCount - 1] = new Vector3(
_stitchTargetMeshData.Normals[0].x,
_stitchTargetMeshData.Normals[0].y,
_stitchTargetMeshData.Normals[0].z);
}
}
protected void TileProvider_OnTileAdded(UnwrappedTileId tileId)
{
// event handler
_mapVisualizer.LoadTile(tileId);
}
/// <summary>
/// corrects and adjusts the mapCenterLatLong at the start and after zoom as the user-specified
/// string is unlikely to be the actual center coordinates for the center tile at the start,
/// or after zoom the coordinates much be updated
/// </summary>
private void CorrectCenterLatitudeLongitude()
{
UnwrappedTileId CenterTile = TileCover.CoordinateToTileId(_mapCenterLatitudeLongitude, _zoom);
CenterLatitudeLongitude = Conversions.TileIdToCenterLatitudeLongitude(CenterTile.X, CenterTile.Y, CenterTile.Z);
}
protected IEnumerator ProcessLayer(VectorTileLayer layer, UnityTile tile, UnwrappedTileId tileId, Action <UnityTile, LayerVisualizerBase> callback = null)
{
//HACK to prevent request finishing on same frame which breaks modules started/finished events
yield return(null);
if (tile == null)
{
yield break;
}
VectorLayerVisualizerProperties tempLayerProperties = new VectorLayerVisualizerProperties();
tempLayerProperties.vectorTileLayer = layer;
tempLayerProperties.featureProcessingStage = FeatureProcessingStage.PreProcess;
//Get all filters in the array.
tempLayerProperties.layerFeatureFilters = _layerProperties.filterOptions.filters.Select(m => m.GetFilterComparer()).ToArray();
// Pass them to the combiner
tempLayerProperties.layerFeatureFilterCombiner = new Filters.LayerFilterComparer();
switch (_layerProperties.filterOptions.combinerType)
{
case Filters.LayerFilterCombinerOperationType.Any:
tempLayerProperties.layerFeatureFilterCombiner = Filters.LayerFilterComparer.AnyOf(tempLayerProperties.layerFeatureFilters);
break;
case Filters.LayerFilterCombinerOperationType.All:
tempLayerProperties.layerFeatureFilterCombiner = Filters.LayerFilterComparer.AllOf(tempLayerProperties.layerFeatureFilters);
break;
case Filters.LayerFilterCombinerOperationType.None:
tempLayerProperties.layerFeatureFilterCombiner = Filters.LayerFilterComparer.NoneOf(tempLayerProperties.layerFeatureFilters);
break;
default:
break;
}
tempLayerProperties.buildingsWithUniqueIds = (_layerProperties.honorBuildingIdSetting) && _layerProperties.buildingsWithUniqueIds;
////find any replacement criteria and assign them
foreach (var goModifier in _defaultStack.GoModifiers)
{
if (goModifier is IReplacementCriteria && goModifier.Active)
{
SetReplacementCriteria((IReplacementCriteria)goModifier);
}
}
#region PreProcess & Process.
var featureCount = (tempLayerProperties.vectorTileLayer == null) ? 0 : tempLayerProperties.vectorTileLayer.FeatureCount();
do
{
for (int i = 0; i < featureCount; i++)
{
//checking if tile is recycled and changed
if (tile.UnwrappedTileId != tileId || !_activeCoroutines.ContainsKey(tile) || tile.TileState == Enums.TilePropertyState.Unregistered)
{
yield break;
}
ProcessFeature(i, tile, tempLayerProperties, layer.Extent);
if (IsCoroutineBucketFull)
{
//Reset bucket..
_entityInCurrentCoroutine = 0;
yield return(null);
}
}
// move processing to next stage.
tempLayerProperties.featureProcessingStage++;
} while (tempLayerProperties.featureProcessingStage == FeatureProcessingStage.PreProcess ||
tempLayerProperties.featureProcessingStage == FeatureProcessingStage.Process);
#endregion
#region PostProcess
// TODO : Clean this up to follow the same pattern.
var mergedStack = _defaultStack as MergedModifierStack;
if (mergedStack != null && tile != null)
{
mergedStack.End(tile, tile.gameObject, layer.Name);
}
#endregion
if (callback != null)
{
callback(tile, this);
}
}
void TileProvider_OnTileAdded(UnwrappedTileId tileId)
{
_mapVisualizer.LoadTile(tileId);
}
public abstract bool Cleanup(UnwrappedTileId tile);
