private void InitTile(int zoom, OnlineMapsVector2i pos, int maxY, List <OnlineMapsTile> newBaseTiles, int y, int px)
{
int py = y + pos.y;
if (py < 0 || py >= maxY)
{
return;
}
OnlineMapsTile tile;
if (!OnlineMapsTile.GetTile(zoom, px, py, out tile))
{
OnlineMapsTile parent = null;
if (!api.useCurrentZoomTiles)
{
int ptx = px / 2;
int pty = py / 2;
if (OnlineMapsTile.GetTile(zoom - 1, ptx, pty, out parent))
{
parent.used = true;
}
}
tile = new OnlineMapsTile(px, py, zoom, api, parent)
{
OnSetColor = OnTileSetColor
};
}
newBaseTiles.Add(tile);
tile.used = true;
}
private bool CheckOverlayColor(double clng, double clat)
{
double tx, ty;
map.projection.CoordinatesToTile(clng, clat, map.zoom, out tx, out ty);
OnlineMapsTile tile = OnlineMapsTile.GetTile(map.zoom, (int)tx, (int)ty);
if (tile == null)
{
return(false);
}
while (tile.status != OnlineMapsTileStatus.loaded)
{
tile = tile.parent;
if (tile == null)
{
return(false);
}
}
Texture2D overlay = null;
if (overlayLayer == OverlayLayer.front)
{
overlay = tile.overlayFrontTexture;
}
else if (overlayLayer == OverlayLayer.back)
{
overlay = tile.overlayBackTexture;
}
else if (overlayLayer == OverlayLayer.traffic)
{
overlay = (tile as OnlineMapsRasterTile).trafficTexture;
}
if (overlay == null)
{
return(false);
}
int px = (int)Math.Round((tx - (int)tx) * 255);
int py = 255 - (int)Math.Round((ty - (int)ty) * 255);
for (int x = Mathf.Max(0, px - 2); x < Mathf.Min(255, px + 3); x++)
{
for (int y = Mathf.Max(0, py - 2); y < Mathf.Min(255, py + 3); y++)
{
if (overlay.GetPixel(x, y) != Color.clear)
{
return(true);
}
}
}
return(false);
}
/// <summary>
/// This method is called when the map is clicked.
/// </summary>
private void OnMapClick()
{
// Get the coordinates under the cursor.
double lng, lat;
OnlineMapsControlBase.instance.GetCoords(out lng, out lat);
// Convert coordinates to tile position
double tx, ty;
OnlineMaps.instance.projection.CoordinatesToTile(lng, lat, OnlineMaps.instance.zoom, out tx, out ty);
// Get tile index
int itx = (int)tx;
int ity = (int)ty;
// Get tile
OnlineMapsTile tile = OnlineMapsTile.GetTile(OnlineMaps.instance.zoom, itx, ity);
// If the tile exists, but is not yet loaded, take the parent
while (tile != null && tile.status != OnlineMapsTileStatus.loaded)
{
tile = tile.parent;
tx /= 2;
ty /= 2;
}
// If the tile does not exist
if (tile == null)
{
Debug.Log("No loaded tiles under cursor");
return;
}
// Calculate the relative position
double rx = tx - (int)tx;
double ry = ty - (int)ty;
// For Target - Tileset
if (OnlineMaps.instance.target == OnlineMapsTarget.tileset)
{
Color color = tile.texture.GetPixelBilinear((float)rx, 1 - (float)ry);
Debug.Log(color);
}
// For Target - Texture
else
{
int row = (int)((1 - ry) * OnlineMapsUtils.tileSize);
Color color = tile.colors[(int)((row + rx) * OnlineMapsUtils.tileSize)];
Debug.Log(color);
}
}
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 = new OnlineMapsTile(px, py, zoom, api)
{
OnSetColor = OnTileSetColor
};
}
newParentTiles.Add(parent);
parent.used = true;
tile.SetParent(parent);
}
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 InitTile(int zoom, OnlineMapsVector2i pos, int maxY, List <OnlineMapsTile> newBaseTiles, int y, int px)
{
int py = y + pos.y;
if (py < 0 || py >= maxY)
{
return;
}
OnlineMapsTile tile;
if (!OnlineMapsTile.GetTile(zoom, px, py, out tile))
{
OnlineMapsTile parent = null;
if (!map.useCurrentZoomTiles)
{
int ptx = px / 2;
int pty = py / 2;
if (OnlineMapsTile.GetTile(zoom - 1, ptx, pty, out parent))
{
parent.used = true;
}
}
tile = map.control.CreateTile(px, py, zoom);
tile.parent = parent;
if (tile is OnlineMapsRasterTile)
{
(tile as OnlineMapsRasterTile).OnSetColor = OnTileSetColor;
}
}
newBaseTiles.Add(tile);
tile.used = true;
}
private void UpdateMapSubMesh(int x, int y, int w, int h, double subMeshSizeX, double subMeshSizeY, int subMeshVX, int subMeshVZ, double startPosX, double startPosZ, float yScale, double tlx, double tly, double brx, double bry, Material[] materials, ref float minY, ref float maxY, bool hasTraffic, bool hasOverlayBack, bool hasOverlayBackAlpha, bool hasOverlayFront, bool hasOverlayFrontAlpha)
{
int mi = x + y * w;
int i = mi * (subMeshVX + 1) * (subMeshVZ + 1);
double cellSizeX = subMeshSizeX / subMeshVX;
double cellSizeY = subMeshSizeY / subMeshVZ;
double uvX = 1.0 / subMeshVX;
double uvZ = 1.0 / subMeshVZ;
int bx = x + bufferPosition.x;
int by = y + bufferPosition.y;
int zoom = map.buffer.renderState.zoom;
int maxX = 1 << zoom;
if (bx >= maxX)
{
bx -= maxX;
}
if (bx < 0)
{
bx += maxX;
}
OnlineMapsTile tile;
OnlineMapsTile.GetTile(zoom, bx, by, out tile);
OnlineMapsTile currentTile = tile;
if (currentTile != null && currentTile.status != OnlineMapsTileStatus.loaded)
{
currentTile = null;
}
Vector2 offset = Vector2.zero;
float scale = 1;
int z = zoom;
Texture tileTexture = currentTile != null ? currentTile.texture : null;
bool sendEvent = true;
while ((currentTile == null || tileTexture == null) && z > 2)
{
z--;
int s = 1 << (zoom - z);
int ctx = bx / s;
int cty = by / s;
OnlineMapsTile t;
OnlineMapsTile.GetTile(z, ctx, cty, out t);
if (t != null && t.status == OnlineMapsTileStatus.loaded)
{
currentTile = t;
tileTexture = t.texture;
scale = 1f / s;
offset.x = bx % s * scale;
offset.y = (s - by % s - 1) * scale;
sendEvent = false;
break;
}
}
bool needGetElevation = OnlineMapsElevationManagerBase.useElevation;
float fy = 0;
double spx = startPosX - x * subMeshSizeX;
double spz = startPosZ + y * subMeshSizeY;
float tilesizeX = sizeInScene.x;
float tilesizeZ = sizeInScene.y;
for (int ty = 0; ty <= subMeshVZ; ty++)
{
double uvy = 1 - uvZ * ty;
double pz = spz + ty * cellSizeY;
if (pz < 0)
{
uvy = uvZ * ((pz + cellSizeY) / cellSizeY - 1) + uvy;
pz = 0;
}
else if (pz > tilesizeZ)
{
uvy = uvZ * ((pz - tilesizeZ) / cellSizeY) + uvy;
pz = tilesizeZ;
}
for (int tx = 0; tx <= subMeshVX; tx++)
{
double uvx = uvX * tx;
double px = spx - tx * cellSizeX;
if (px > 0)
{
uvx = uvX * (px - cellSizeX) / cellSizeX + uvx + uvX;
px = 0;
}
else if (px < -tilesizeX)
{
uvx = uvX * ((px + tilesizeX) / cellSizeX - 1) + uvx + uvX;
px = -tilesizeX;
}
if (needGetElevation)
{
fy = OnlineMapsElevationManagerBase.GetElevation(px, pz, yScale, tlx, tly, brx, bry);
}
float fx = (float)px;
float fz = (float)pz;
float f*x = (float)uvx;
float fuy = (float)uvy;
if (fy < minY)
{
minY = fy;
}
if (fy > maxY)
{
maxY = fy;
}
if (f*x < 0)
{
f*x = 0;
}
else if (f*x > 1)
{
f*x = 1;
}
if (fuy < 0)
{
fuy = 0;
}
else if (fuy > 1)
{
fuy = 1;
}
vertices[i] = new Vector3(fx, fy, fz);
uv[i++] = new Vector2(f*x, fuy);
}
}
Material material = materials[mi];
material.hideFlags = HideFlags.HideInInspector;
if (currentTile != null)
{
bool hasTileTexture = tileTexture != null;
if (!hasTileTexture)
{
if (map.defaultTileTexture != null)
{
tileTexture = map.defaultTileTexture;
}
else if (OnlineMapsRasterTile.emptyColorTexture != null)
{
tileTexture = OnlineMapsRasterTile.emptyColorTexture;
}
else
{
tileTexture = OnlineMapsRasterTile.emptyColorTexture = new Texture2D(1, 1, TextureFormat.ARGB32, mipmapForTiles);
tileTexture.name = "Empty Texture";
OnlineMapsRasterTile.emptyColorTexture.SetPixel(0, 0, map.emptyColor);
OnlineMapsRasterTile.emptyColorTexture.Apply(false);
}
sendEvent = false;
}
material.mainTextureOffset = offset;
material.mainTextureScale = new Vector2(scale, scale);
if (material.mainTexture != tileTexture)
{
material.mainTexture = tileTexture;
if (sendEvent && OnChangeMaterialTexture != null)
{
OnChangeMaterialTexture(currentTile, material);
}
}
if (hasTraffic)
{
material.SetTexture("_TrafficTex", (currentTile as OnlineMapsRasterTile).trafficTexture);
material.SetTextureOffset("_TrafficTex", material.mainTextureOffset);
material.SetTextureScale("_TrafficTex", material.mainTextureScale);
}
if (hasOverlayBack)
{
material.SetTexture("_OverlayBackTex", currentTile.overlayBackTexture);
material.SetTextureOffset("_OverlayBackTex", material.mainTextureOffset);
material.SetTextureScale("_OverlayBackTex", material.mainTextureScale);
}
if (hasOverlayBackAlpha)
{
material.SetFloat("_OverlayBackAlpha", currentTile.overlayBackAlpha);
}
if (hasOverlayFront)
{
if (drawingMode == OnlineMapsTilesetDrawingMode.overlay)
{
if (currentTile.status == OnlineMapsTileStatus.loaded && (currentTile.drawingChanged || currentTile.overlayFrontTexture == null))
{
if (overlayFrontBuffer == null)
{
overlayFrontBuffer = new Color32[OnlineMapsUtils.sqrTileSize];
}
else
{
for (int k = 0; k < OnlineMapsUtils.sqrTileSize; k++)
{
overlayFrontBuffer[k] = new Color32();
}
}
foreach (OnlineMapsDrawingElement drawingElement in OnlineMapsDrawingElementManager.instance)
{
drawingElement.Draw(overlayFrontBuffer, new OnlineMapsVector2i(currentTile.x, currentTile.y), OnlineMapsUtils.tileSize, OnlineMapsUtils.tileSize, currentTile.zoom, true);
}
if (currentTile.overlayFrontTexture == null)
{
currentTile.overlayFrontTexture = new Texture2D(OnlineMapsUtils.tileSize, OnlineMapsUtils.tileSize, TextureFormat.ARGB32, mipmapForTiles);
currentTile.overlayFrontTexture.wrapMode = TextureWrapMode.Clamp;
}
currentTile.overlayFrontTexture.SetPixels32(overlayFrontBuffer);
currentTile.overlayFrontTexture.Apply(false);
}
}
material.SetTexture("_OverlayFrontTex", currentTile.overlayFrontTexture);
material.SetTextureOffset("_OverlayFrontTex", material.mainTextureOffset);
material.SetTextureScale("_OverlayFrontTex", material.mainTextureScale);
}
if (hasOverlayFrontAlpha)
{
material.SetFloat("_OverlayFrontAlpha", currentTile.overlayFrontAlpha);
}
if (OnDrawTile != null)
{
OnDrawTile(currentTile, material);
}
}
else
{
if (map.defaultTileTexture != null)
{
material.mainTexture = map.defaultTileTexture;
}
else
{
if (OnlineMapsRasterTile.emptyColorTexture == null)
{
OnlineMapsRasterTile.emptyColorTexture = new Texture2D(1, 1, TextureFormat.ARGB32, mipmapForTiles);
OnlineMapsRasterTile.emptyColorTexture.name = "Empty Texture";
OnlineMapsRasterTile.emptyColorTexture.SetPixel(0, 0, map.emptyColor);
OnlineMapsRasterTile.emptyColorTexture.Apply(false);
}
material.mainTexture = OnlineMapsRasterTile.emptyColorTexture;
}
if (hasTraffic)
{
material.SetTexture("_TrafficTex", null);
}
if (hasOverlayBack)
{
material.SetTexture("_OverlayBackTex", null);
}
if (hasOverlayFront)
{
material.SetTexture("_OverlayFrontTex", null);
}
}
}
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 = OnlineMapsTile.GetTile(zoom, tileX, tileY);
if (tile == null)
{
OnlineMapsTile parentTile = OnlineMapsTile.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;
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 = OnlineMapsTile.GetTile(zoom, tileX, tileY);
if (tile == null)
{
OnlineMapsTile parentTile = OnlineMapsTile.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 = OnlineMapsTile.GetTile(zoom, tileX, tileY);
if (tile == null)
{
OnlineMapsTile parentTile = OnlineMapsTile.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 = OnlineMapsTile.GetTile(zoom, tileX, tileY);
if (tile == null)
{
OnlineMapsTile parentTile = OnlineMapsTile.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 = OnlineMapsTile.GetTile(zoom, tileX, tileY);
if (tile == null)
{
OnlineMapsTile parentTile = OnlineMapsTile.GetTile(zoom - 1, tileX / 2, tileY / 2);
tile = new OnlineMapsRasterTile(tileX, tileY, zoom, map);
tile.parent = parentTile;
}
tile.Block(this);
extraTiles.Add(tile);
}
}
