private void LoadTile(OnlineMapsTile tile, byte[] bytes)
{
Texture2D texture = new Texture2D(256, 256, TextureFormat.ARGB32, map.control.mipmapForTiles);
texture.LoadImage(bytes);
texture.wrapMode = TextureWrapMode.Clamp;
if (map.control.resultIsTexture)
{
(tile as OnlineMapsRasterTile).ApplyTexture(texture);
map.buffer.ApplyTile(tile);
OnlineMapsUtils.Destroy(texture);
}
else
{
tile.texture = texture;
tile.status = OnlineMapsTileStatus.loaded;
}
OnlineMapsRasterTile rTile = tile as OnlineMapsRasterTile;
if (map.traffic && !string.IsNullOrEmpty(rTile.trafficURL))
{
if (map.traffic && !string.IsNullOrEmpty(rTile.trafficURL))
{
rTile.trafficWWW = new OnlineMapsWWW(rTile.trafficURL);
rTile.trafficWWW["tile"] = tile;
rTile.trafficWWW.OnComplete += OnlineMapsTileManager.OnTrafficWWWComplete;
}
}
}
private void OnTileSetColor(OnlineMapsRasterTile tile)
{
if (tile.zoom == renderState.zoom)
{
SetBufferTile(tile);
}
}
private static IEnumerator StartDownloadTileAsync(OnlineMapsTile tile)
{
bool loadOnline = true;
if (map.source != OnlineMapsSource.Online)
{
ResourceRequest resourceRequest = Resources.LoadAsync(tile.resourcesPath);
yield return(resourceRequest);
Object tileTexture = resourceRequest.asset;
if (tileTexture != null)
{
tileTexture = Object.Instantiate(tileTexture);
if (map.control.resultIsTexture)
{
(tile as OnlineMapsRasterTile).ApplyTexture(tileTexture as Texture2D);
map.buffer.ApplyTile(tile);
}
else
{
tile.texture = tileTexture as Texture2D;
tile.status = OnlineMapsTileStatus.loaded;
}
tile.MarkLoaded();
map.Redraw();
loadOnline = false;
}
else if (map.source == OnlineMapsSource.Resources)
{
tile.status = OnlineMapsTileStatus.error;
yield break;
}
}
if (loadOnline)
{
if (tile.www != null)
{
Debug.Log("tile has www " + tile + " " + tile.status);
yield break;
}
tile.www = new OnlineMapsWWW(tile.url);
tile.www["tile"] = tile;
tile.www.OnComplete += OnTileWWWComplete;
tile.status = OnlineMapsTileStatus.loading;
}
OnlineMapsRasterTile rTile = tile as OnlineMapsRasterTile;
if (map.traffic && !string.IsNullOrEmpty(rTile.trafficURL))
{
rTile.trafficWWW = new OnlineMapsWWW(rTile.trafficURL);
rTile.trafficWWW["tile"] = tile;
rTile.trafficWWW.OnComplete += OnTrafficWWWComplete;
}
}
private static IEnumerator StartDownloadTileAsync(OnlineMapsTile tile)
{
bool loadOnline = true;
OnlineMapsSource source = tile.map.source;
if (source != OnlineMapsSource.Online)
{
if (source == OnlineMapsSource.Resources || source == OnlineMapsSource.ResourcesAndOnline)
{
yield return(TryLoadFromResources(tile));
if (tile.status == OnlineMapsTileStatus.error)
{
yield break;
}
if (tile.status == OnlineMapsTileStatus.loaded)
{
loadOnline = false;
}
}
else if (source == OnlineMapsSource.StreamingAssets || source == OnlineMapsSource.StreamingAssetsAndOnline)
{
TryLoadFromStreamingAssets(tile);
if (tile.status == OnlineMapsTileStatus.error)
{
yield break;
}
if (tile.status == OnlineMapsTileStatus.loaded)
{
loadOnline = false;
}
}
}
if (loadOnline)
{
if (tile.www != null)
{
Debug.Log("tile has www " + tile + " " + tile.status);
yield break;
}
tile.www = new OnlineMapsWWW(tile.url);
tile.www["tile"] = tile;
tile.www.OnComplete += OnTileWWWComplete;
tile.status = OnlineMapsTileStatus.loading;
}
OnlineMapsRasterTile rTile = tile as OnlineMapsRasterTile;
if (tile.map.traffic && !string.IsNullOrEmpty(rTile.trafficURL))
{
rTile.trafficWWW = new OnlineMapsWWW(rTile.trafficURL);
rTile.trafficWWW["tile"] = tile;
rTile.trafficWWW.OnComplete += OnTrafficWWWComplete;
}
}
private static string GetTileKey(OnlineMapsTile tile)
{
StringBuilder stringBuilder = GetStringBuilder();
OnlineMapsRasterTile rTile = tile as OnlineMapsRasterTile;
stringBuilder.Append(rTile.mapType.fullID).Append(tile.key).Append(rTile.labels).Append(rTile.language);
return(stringBuilder.ToString());
}
private bool SetBufferTileFromParent(OnlineMapsTile tile, int px, int py, int size, int sx, int sy)
{
OnlineMapsTile parent = tile.parent;
if (parent == null)
{
return(false);
}
const int s = OnlineMapsUtils.tileSize;
const int hs = s / 2;
if (parent.status != OnlineMapsTileStatus.loaded || !parent.hasColors)
{
sx = sx / 2 + parent.x % 2 * hs;
sy = sy / 2 + parent.y % 2 * hs;
return(SetBufferTileFromParent(parent, px, py, size / 2, sx, sy));
}
OnlineMapsRasterTile rParent = parent as OnlineMapsRasterTile;
Color32[] colors = rParent.colors;
int scale = s / size;
if (colors.Length != OnlineMapsUtils.sqrTileSize)
{
return(false);
}
int ry = s - sy - 1;
lock (colors)
{
for (int y = 0; y < size; y++)
{
int oys = (ry - y) * s + sx;
int scaledY = y * scale + py;
for (int x = 0; x < size; x++)
{
Color32 clr = colors[oys + x];
int scaledX = x * scale + px;
for (int by = scaledY; by < scaledY + scale; by++)
{
int bpy = by * width + scaledX;
for (int bx = bpy; bx < bpy + scale; bx++)
{
backBuffer[bx] = clr;
}
}
}
}
}
return(true);
}
public static void OnTrafficWWWComplete(OnlineMapsWWW www)
{
OnlineMapsRasterTile tile = www["tile"] as OnlineMapsRasterTile;
if (tile == null)
{
return;
}
if (tile.trafficWWW == null || !tile.trafficWWW.isDone)
{
return;
}
if (tile.status == OnlineMapsTileStatus.disposed)
{
tile.trafficWWW = null;
return;
}
if (!www.hasError)
{
if (map.control.resultIsTexture)
{
if (tile.OnLabelDownloadComplete())
{
map.buffer.ApplyTile(tile);
}
}
else if (tile.trafficWWW != null && map.traffic)
{
Texture2D trafficTexture = new Texture2D(256, 256, TextureFormat.ARGB32, false)
{
wrapMode = TextureWrapMode.Clamp
};
if (map.useSoftwareJPEGDecoder)
{
OnlineMapsRasterTile.LoadTexture(trafficTexture, www.bytes);
}
else
{
tile.trafficWWW.LoadImageIntoTexture(trafficTexture);
}
tile.trafficTexture = trafficTexture;
}
if (OnlineMapsTile.OnTrafficDownloaded != null)
{
OnlineMapsTile.OnTrafficDownloaded(tile);
}
map.Redraw();
}
tile.trafficWWW = null;
}
protected override void LoadTileFromWWW(OnlineMapsWWW www)
{
if (map.control.resultIsTexture)
{
DownloadComplete();
if (status != OnlineMapsTileStatus.error)
{
map.buffer.ApplyTile(this);
}
}
else
{
Texture2D tileTexture = new Texture2D(256, 256, TextureFormat.RGB24, map.control.mipmapForTiles)
{
wrapMode = TextureWrapMode.Clamp
};
if (map.useSoftwareJPEGDecoder)
{
OnlineMapsRasterTile.LoadTexture(tileTexture, www.bytes);
}
else
{
www.LoadImageIntoTexture(tileTexture);
}
tileTexture.name = zoom + "x" + x + "x" + y;
CheckTextureSize(tileTexture);
if (status != OnlineMapsTileStatus.error && status != OnlineMapsTileStatus.disposed)
{
texture = tileTexture;
status = OnlineMapsTileStatus.loaded;
}
}
if (status != OnlineMapsTileStatus.error && status != OnlineMapsTileStatus.disposed)
{
if (OnTileDownloaded != null)
{
OnTileDownloaded(this);
}
}
MarkLoaded();
map.Redraw();
}
private static string GetTileKey(OnlineMapsTile tile)
{
if (stringBuilder == null)
{
stringBuilder = new StringBuilder();
}
else
{
stringBuilder.Length = 0;
}
OnlineMapsRasterTile rTile = tile as OnlineMapsRasterTile;
stringBuilder.Append(rTile.mapType.fullID).Append(tile.key).Append(rTile.labels).Append(rTile.language);
return(stringBuilder.ToString());
}
/// <summary>
/// Gets the local path for tile.
/// </summary>
/// <param name="tile">Reference to tile</param>
/// <returns>Local path for tile</returns>
private static string GetTilePath(OnlineMapsTile tile)
{
OnlineMapsRasterTile rTile = tile as OnlineMapsRasterTile;
string[] parts =
{
Application.persistentDataPath,
"OnlineMapsTileCache",
rTile.mapType.provider.id,
rTile.mapType.id,
tile.zoom.ToString(),
tile.x.ToString(),
tile.y + ".png"
};
return(string.Join("/", parts));
}
/// <summary>
/// Get the relative path to the tile in the file cache.
/// </summary>
/// <param name="tile">Tile</param>
/// <returns>Relative path to the tile in the file cache</returns>
public StringBuilder GetShortTilePath(OnlineMapsTile tile)
{
#if ALLOW_FILECACHE
int startIndex = 0;
StringBuilder stringBuilder = GetStringBuilder();
OnlineMapsRasterTile rTile = tile as OnlineMapsRasterTile;
int l = fileCacheTilePath.Length;
for (int i = 0; i < l; i++)
{
char c = fileCacheTilePath[i];
if (c == '{')
{
for (int j = i + 1; j < l; j++)
{
c = fileCacheTilePath[j];
if (c == '}')
{
stringBuilder.Append(fileCacheTilePath.Substring(startIndex, i - startIndex));
string v = fileCacheTilePath.Substring(i + 1, j - i - 1).ToLower();
if (v == "pid") stringBuilder.Append(rTile.mapType.provider.id);
else if (v == "mid") stringBuilder.Append(rTile.mapType.id);
else if (v == "zoom" || v == "z") stringBuilder.Append(tile.zoom);
else if (v == "x") stringBuilder.Append(tile.x);
else if (v == "y") stringBuilder.Append(tile.y);
else if (v == "quad") OnlineMapsUtils.TileToQuadKey(tile.x, tile.y, tile.zoom, stringBuilder);
else if (v == "lng") stringBuilder.Append(rTile.language);
else if (v == "lbs") stringBuilder.Append(rTile.labels ? "le" : "ld");
else stringBuilder.Append(v);
i = j;
startIndex = j + 1;
break;
}
}
}
}
stringBuilder.Append(fileCacheTilePath.Substring(startIndex, l - startIndex));
return stringBuilder;
#else
return null;
#endif
}
public void UnloadOldTypes()
{
try
{
lock (OnlineMapsTile.lockTiles)
{
foreach (OnlineMapsTile tile in OnlineMapsTile.tiles)
{
OnlineMapsRasterTile rt = tile as OnlineMapsRasterTile;
if (rt != null && map.activeType != rt.mapType)
{
tile.Dispose();
}
}
}
}
catch (Exception exception)
{
Debug.Log(exception.Message);
}
}
private void CreateTileParent(int zoom, OnlineMapsTile tile, List <OnlineMapsTile> newParentTiles)
{
int px = tile.x / 2;
int py = tile.y / 2;
OnlineMapsTile parent;
if (!OnlineMapsTile.GetTile(zoom, px, py, out parent))
{
parent = map.control.CreateTile(px, py, zoom);
OnlineMapsRasterTile rParent = parent as OnlineMapsRasterTile;
if (rParent != null)
{
rParent.OnSetColor = OnTileSetColor;
}
}
newParentTiles.Add(parent);
parent.used = true;
tile.SetParent(parent);
}
private void ApplyNewTiles()
{
if (newTiles == null || newTiles.Count == 0)
{
return;
}
lock (newTiles)
{
foreach (OnlineMapsTile tile in newTiles)
{
if (disposed)
{
return;
}
if (tile.status == OnlineMapsTileStatus.disposed)
{
continue;
}
OnlineMapsRasterTile rTile = tile as OnlineMapsRasterTile;
#if !UNITY_WEBGL
int counter = 20;
while (rTile.colors.Length < OnlineMapsUtils.sqrTileSize && counter > 0)
{
OnlineMapsUtils.ThreadSleep(1);
counter--;
}
#endif
rTile.ApplyColorsToChilds();
}
if (newTiles.Count > 0)
{
newTiles.Clear();
}
}
}
private void UpdateMesh()
{
int zoom = map.zoom - zoomOffset;
if (zoom < 3)
{
zoom = 3;
}
for (int i = 0; i < tiles.Length; i++)
{
if (tiles[i] != null)
{
tiles[i].Unblock(this);
}
}
double tx, ty;
map.GetTilePosition(out tx, out ty, zoom);
int itx = Mathf.RoundToInt((float)(tx - countX / 2f));
int ity = Mathf.RoundToInt((float)(ty - countY / 2f));
Vector3 offset = new Vector3(0, positionYOffset, 0) - transform.position;
int max = 1 << zoom;
Material[] materials = meshRenderer.sharedMaterials;
float r1 = resolution - 1;
int vi = 0;
for (int x = 0; x < countX; x++)
{
int tileX = itx + x;
int nextTileX = tileX + 1;
if (tileX >= max)
{
tileX -= max;
}
if (nextTileX >= max)
{
nextTileX -= max;
}
for (int y = 0; y < countY; y++)
{
int tileY = ity + y;
int nextTileY = tileY + 1;
if (tileY >= max)
{
tileY -= max;
}
if (nextTileY >= max)
{
nextTileY -= max;
}
OnlineMapsTile tile = map.tileManager.GetTile(zoom, tileX, tileY);
if (tile == null)
{
OnlineMapsTile parentTile = map.tileManager.GetTile(zoom - 1, tileX / 2, tileY / 2);
tile = new OnlineMapsRasterTile(tileX, tileY, zoom, map);
tile.parent = parentTile;
}
int tileIndex = x * countY + y;
tiles[tileIndex] = tile;
tile.Block(this);
double px, py;
map.projection.TileToCoordinates(tileX, tileY, zoom, out px, out py);
Vector3 v1 = control.GetWorldPosition(px, py) + offset;
map.projection.TileToCoordinates(nextTileX, nextTileY, zoom, out px, out py);
Vector3 v2 = control.GetWorldPosition(px, py) + offset;
Vector3 ov = (v2 - v1) / r1;
float uvScale = 1;
Vector2 uvOffset = Vector2.zero;
if (tile.texture == null)
{
while (tile.parent != null)
{
tile = tile.parent;
int s = 1 << (zoom - tile.zoom);
uvScale = 1f / s;
uvOffset.x = tileX % s * uvScale;
uvOffset.y = (s - tileY % s - 1) * uvScale;
if (tile.texture != null)
{
break;
}
}
}
for (int vx = 0; vx < resolution; vx++)
{
for (int vz = 0; vz < resolution; vz++)
{
Vector3 v = new Vector3(ov.x * vx + v1.x, 0, ov.z * vz + v1.z);
v.y = positionYOffset;
uv[vi] = new Vector2((vx / r1) * uvScale + uvOffset.x, (1 - vz / r1) * uvScale + uvOffset.y);
vertices[vi++] = v;
}
}
materials[tileIndex].mainTexture = tile.texture;
materials[tileIndex].color = new Color(1, 1, 1, tile.texture != null ? 1 : 0);
}
}
mesh.vertices = vertices;
mesh.uv = uv;
PreloadBorders();
}
private void PreloadBorders()
{
int zoom = map.zoom - zoomOffset;
if (zoom < 3)
{
zoom = 3;
}
double tx, ty;
map.GetTilePosition(out tx, out ty, zoom);
int itx = Mathf.RoundToInt((float)(tx - countX / 2f));
int ity = Mathf.RoundToInt((float)(ty - countY / 2f));
foreach (OnlineMapsTile tile in extraTiles)
{
tile.Unblock(this);
}
extraTiles.Clear();
int max = 1 << zoom;
OnlineMapsTileManager tileManager = map.tileManager;
for (int x = -1; x < countX + 1; x++)
{
int tileX = itx + x;
if (tileX >= max)
{
tileX -= max;
}
int tileY = ity - 1;
if (tileY >= max)
{
tileY -= max;
}
OnlineMapsTile tile = tileManager.GetTile(zoom, tileX, tileY);
if (tile == null)
{
OnlineMapsTile parentTile = tileManager.GetTile(zoom - 1, tileX / 2, tileY / 2);
tile = new OnlineMapsRasterTile(tileX, tileY, zoom, map);
tile.parent = parentTile;
}
tile.Block(this);
extraTiles.Add(tile);
tileY = ity + countY;
if (tileY >= max)
{
tileY -= max;
}
tile = tileManager.GetTile(zoom, tileX, tileY);
if (tile == null)
{
OnlineMapsTile parentTile = tileManager.GetTile(zoom - 1, tileX / 2, tileY / 2);
tile = new OnlineMapsRasterTile(tileX, tileY, zoom, map);
tile.parent = parentTile;
}
tile.Block(this);
extraTiles.Add(tile);
}
for (int y = 0; y < countY; y++)
{
int tileY = ity + y;
if (tileY >= max)
{
tileY -= max;
}
int tileX = itx - 1;
if (tileX >= max)
{
tileX -= max;
}
OnlineMapsTile tile = tileManager.GetTile(zoom, tileX, tileY);
if (tile == null)
{
OnlineMapsTile parentTile = tileManager.GetTile(zoom - 1, tileX / 2, tileY / 2);
tile = new OnlineMapsRasterTile(tileX, tileY, zoom, map);
tile.parent = parentTile;
}
tile.Block(this);
extraTiles.Add(tile);
tileX = itx + countX;
if (tileX >= max)
{
tileX -= max;
}
tile = tileManager.GetTile(zoom, tileX, tileY);
if (tile == null)
{
OnlineMapsTile parentTile = tileManager.GetTile(zoom - 1, tileX / 2, tileY / 2);
tile = new OnlineMapsRasterTile(tileX, tileY, zoom, map);
tile.parent = parentTile;
}
tile.Block(this);
extraTiles.Add(tile);
}
}
public static void LoadTexture(Texture2D texture, byte[] bytes)
{
OnlineMapsRasterTile.LoadTexture(texture, bytes);
}
private Rect SetBufferTile(OnlineMapsTile tile, int?offsetX = null)
{
if (!map.control.resultIsTexture)
{
return(default(Rect));
}
const int s = OnlineMapsUtils.tileSize;
int i = 0;
int px = tile.x - bufferPosition.x;
int py = tile.y - bufferPosition.y;
int maxX = 1 << tile.zoom;
if (px < 0)
{
px += maxX;
}
else if (px >= maxX)
{
px -= maxX;
}
if (renderState.width == maxX * s && px < 2 && !offsetX.HasValue)
{
SetBufferTile(tile, maxX);
}
if (offsetX.HasValue)
{
px += offsetX.Value;
}
px *= s;
py *= s;
if (px + s < 0 || py + s < 0 || px > width || py > height)
{
return(new Rect(0, 0, 0, 0));
}
if (!tile.hasColors || tile.status != OnlineMapsTileStatus.loaded)
{
const int hs = s / 2;
int sx = tile.x % 2 * hs;
int sy = tile.y % 2 * hs;
if (SetBufferTileFromParent(tile, px, py, s / 2, sx, sy))
{
return(new Rect(px, py, OnlineMapsUtils.tileSize, OnlineMapsUtils.tileSize));
}
}
OnlineMapsRasterTile rTile = tile as OnlineMapsRasterTile;
Color32[] colors = rTile.colors;
lock (colors)
{
int maxSize = width * height;
for (int y = py + s - 1; y >= py; y--)
{
int bp = y * width + px;
if (bp + s < 0 || bp >= maxSize)
{
continue;
}
int l = s;
if (bp < 0)
{
l -= bp;
bp = 0;
}
else if (bp + s > maxSize)
{
l -= maxSize - (bp + s);
bp = maxSize - s - 1;
}
try
{
Array.Copy(colors, i, backBuffer, bp, l);
}
catch
{
}
i += s;
}
return(new Rect(px, py, OnlineMapsUtils.tileSize, OnlineMapsUtils.tileSize));
}
}
private void CheckBaseProps()
{
if (mapType != _mapType)
{
activeType = OnlineMapsProvider.FindMapType(mapType);
_mapType = mapType = activeType.fullID;
if (_buffer != null)
{
_buffer.UnloadOldTypes();
}
Redraw();
}
if (_language != language || _labels != labels)
{
_labels = labels;
_language = language;
if (_buffer != null)
{
_buffer.Dispose();
_buffer = null;
#if NETFX_CORE
if (renderThread != null)
{
renderThread.Dispose();
}
#endif
#if !UNITY_WEBGL
renderThread = null;
#endif
}
Redraw();
}
if (traffic != _traffic || trafficProviderID != _trafficProviderID)
{
_traffic = traffic;
_trafficProviderID = trafficProviderID;
trafficProvider = OnlineMapsTrafficProvider.GetByID(trafficProviderID);
OnlineMapsTile[] tiles;
lock (OnlineMapsTile.lockTiles)
{
tiles = OnlineMapsTile.tiles.ToArray();
}
if (traffic)
{
foreach (OnlineMapsTile tile in tiles)
{
OnlineMapsRasterTile rTile = tile as OnlineMapsRasterTile;
rTile.trafficProvider = trafficProvider;
rTile.trafficWWW = new OnlineMapsWWW(rTile.trafficURL);
rTile.trafficWWW["tile"] = tile;
rTile.trafficWWW.OnComplete += OnlineMapsTileManager.OnTrafficWWWComplete;
if (rTile.trafficTexture != null)
{
OnlineMapsUtils.Destroy(rTile.trafficTexture);
rTile.trafficTexture = null;
}
}
}
else
{
foreach (OnlineMapsTile tile in tiles)
{
OnlineMapsRasterTile rTile = tile as OnlineMapsRasterTile;
if (rTile.trafficTexture != null)
{
OnlineMapsUtils.Destroy(rTile.trafficTexture);
rTile.trafficTexture = null;
}
rTile.trafficWWW = null;
}
}
Redraw();
}
}
