private static IEnumerator TryLoadFromResources(OnlineMapsTile tile)
{
ResourceRequest resourceRequest = Resources.LoadAsync(tile.resourcesPath);
yield return(resourceRequest);
if (tile.map == null)
{
tile.MarkError();
yield break;
}
Texture2D texture = resourceRequest.asset as Texture2D;
if (texture != null)
{
texture.wrapMode = TextureWrapMode.Clamp;
if (tile.map.control.resultIsTexture)
{
(tile as OnlineMapsRasterTile).ApplyTexture(texture);
tile.map.buffer.ApplyTile(tile);
OnlineMapsUtils.Destroy(texture);
}
else
{
tile.texture = texture;
tile.status = OnlineMapsTileStatus.loaded;
}
tile.MarkLoaded();
tile.loadedFromResources = true;
tile.map.Redraw();
}
else if (tile.map.source == OnlineMapsSource.Resources)
{
tile.MarkError();
}
}
private void OnGeocodeComplete(OnlineMapsWWW www)
{
if (www.hasError)
{
Debug.Log(www.error);
return;
}
OnlineMapsJSONItem json = OnlineMapsJSON.Parse(www.text);
OnlineMapsJSONItem firstItem = json["candidates/0"];
if (firstItem == null)
{
return;
}
OnlineMapsVector2d center = firstItem["location"].Deserialize <OnlineMapsVector2d>();
OnlineMapsJSONItem extent = firstItem["extent"];
double xmin = extent.V <double>("xmin"),
ymin = extent.V <double>("ymin"),
xmax = extent.V <double>("xmax"),
ymax = extent.V <double>("ymax");
Vector2[] points =
{
new Vector2((float)xmin, (float)ymin),
new Vector2((float)xmax, (float)ymax),
};
Vector2 c;
int zoom;
OnlineMapsUtils.GetCenterPointAndZoom(points, out c, out zoom);
OnlineMaps.instance.SetPositionAndZoom(center.x, center.y, zoom);
}
protected OnlineMapsGooglePlacesAutocomplete(string input, string key, string types, int offset, Vector2 lnglat, int radius, string language, string components)
{
_status = OnlineMapsQueryStatus.downloading;
StringBuilder url = new StringBuilder("https://maps.googleapis.com/maps/api/place/autocomplete/xml?sensor=false");
url.Append("&input=").Append(OnlineMapsWWW.EscapeURL(input));
url.Append("&key=").Append(key);
if (lnglat != default(Vector2))
{
url.AppendFormat("&location={0},{1}", lnglat.y, lnglat.x);
}
if (radius != -1)
{
url.Append("&radius=").Append(radius);
}
if (offset != -1)
{
url.Append("&offset=").Append(offset);
}
if (!string.IsNullOrEmpty(types))
{
url.Append("&types=").Append(types);
}
if (!string.IsNullOrEmpty(components))
{
url.Append("&components=").Append(components);
}
if (!string.IsNullOrEmpty(language))
{
url.Append("&language=").Append(language);
}
www = OnlineMapsUtils.GetWWW(url);
www.OnComplete += OnRequestComplete;
}
private void OnUpdateLate()
{
OnlineMapsMarkerBase tooltipMarker = OnlineMapsTooltipDrawerBase.tooltipMarker;
if (tooltipMarker == marker)
{
if (tooltip == null)
{
tooltip = Instantiate(tooltipPrefab) as GameObject;
(tooltip.transform as RectTransform).SetParent(container.transform);
}
Vector2 screenPosition = OnlineMapsControlBase.instance.GetScreenPosition(marker.position);
screenPosition.y += marker.height;
Vector2 point;
RectTransformUtility.ScreenPointToLocalPointInRectangle(container.transform as RectTransform, screenPosition, null, out point);
(tooltip.transform as RectTransform).localPosition = point;
tooltip.GetComponentInChildren <Text>().text = marker.label;
}
else if (tooltip != null)
{
OnlineMapsUtils.Destroy(tooltip);
tooltip = null;
}
}
private OnlineMapsFindAutocomplete(string input, string key, string types, int offset, Vector2 latlng, int radius, string language, string components)
{
_status = OnlineMapsQueryStatus.downloading;
string url = "https://maps.googleapis.com/maps/api/place/autocomplete/xml?sensor=false";
url += "&input=" + input.Replace(" ", "+");
url += "&key=" + key;
if (latlng != default(Vector2))
{
url += string.Format("&location={0},{1}", latlng.y, latlng.x);
}
if (radius != -1)
{
url += "&radius=" + radius;
}
if (offset != -1)
{
url += "&offset=" + offset;
}
if (!string.IsNullOrEmpty(types))
{
url += "&types=" + types;
}
if (!string.IsNullOrEmpty(components))
{
url += "&components=" + components;
}
if (!string.IsNullOrEmpty(language))
{
url += "&language=" + language;
}
www = OnlineMapsUtils.GetWWW(url);
}
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;
}
#if !UNITY_WEBGL
int counter = 20;
while (tile.colors.Length < OnlineMapsUtils.sqrTileSize && counter > 0)
{
OnlineMapsUtils.ThreadSleep(1);
counter--;
}
#endif
tile.ApplyColorsToChilds();
}
if (newTiles.Count > 0)
{
newTiles.Clear();
}
}
}
private void StartNextAction()
{
#if !UNITY_WEBGL
while (isAlive)
{
bool actionInvoked = false;
lock (threadActions)
{
if (threadActions.Count > 0)
{
Action action = threadActions[0];
threadActions.RemoveAt(0);
action();
actionInvoked = true;
}
}
if (!actionInvoked)
{
OnlineMapsUtils.ThreadSleep(1);
}
}
threadActions = null;
#endif
}
void OnDistanceChange(Vector2 userPoint)
{
if (currentData == null)
{
return;
}
Vector2 markerCoordinates = new Vector2((float)currentData.Longitude_User, (float)currentData.Latitude_User);
Vector2 userCoordinares = userPoint;
// Calculate the distance in km between locations.
distanceBetweenPOI = OnlineMapsUtils.DistanceBetweenPoints(userCoordinares, markerCoordinates).magnitude * 1000;
if (distanceBetweenPOI > 1000)
{
GoadRange.text = string.Format("距離 {0} km", (distanceBetweenPOI / 1000).ToString("0.00"));
}
else
{
GoadRange.text = string.Format("距離 {0} m", distanceBetweenPOI.ToString("0.0"));
}
//GoadRange.text = "距離 " + distanceBetweenPOI.ToString("0.0") + " m";
}
public OnlineMapsTile(int x, int y, int zoom, OnlineMaps api, bool isMapTile = true)
{
int maxX = 2 << (zoom - 1);
if (x < 0)
{
x += maxX;
}
else if (x >= maxX)
{
x -= maxX;
}
this.x = x;
this.y = y;
this.zoom = zoom;
OnlineMapsTile.api = api;
this.isMapTile = isMapTile;
provider = api.provider;
type = api.type;
labels = api.labels;
language = api.language;
topLeft = OnlineMapsUtils.TileToLatLong(x, y, zoom);
bottomRight = OnlineMapsUtils.TileToLatLong(x + 1, y + 1, zoom);
globalPosition = Vector2.Lerp(topLeft, bottomRight, 0.5f);
trafficURL = String.Format("https://mts0.google.com/vt?pb=!1m4!1m3!1i{0}!2i{1}!3i{2}!2m3!1e0!2sm!3i301114286!2m6!1e2!2straffic!4m2!1soffset_polylines!2s0!5i1!2m12!1e2!2spsm!4m2!1sgid!2sl0t0vMkIqfb3hBb090479A!4m2!1ssp!2s1!5i1!8m2!13m1!14b1!3m25!2sru-RU!3sUS!5e18!12m1!1e50!12m3!1e37!2m1!1ssmartmaps!12m5!1e14!2m1!1ssolid!2m1!1soffset_polylines!12m4!1e52!2m2!1sentity_class!2s0S!12m4!1e26!2m2!1sstyles!2zcy5lOmx8cC52Om9mZixzLnQ6MXxwLnY6b2ZmLHMudDozfHAudjpvZmY!4e0", zoom, x, y);
if (isMapTile)
{
tiles.Add(this);
}
}
/// <summary>
/// Initializes this object.
/// </summary>
/// <param name="parent">
/// The parent transform.
/// </param>
public void Init(Transform parent)
{
if (instance != null)
{
OnlineMapsUtils.Destroy(instance);
}
if (prefab == null)
{
instance = GameObject.CreatePrimitive(PrimitiveType.Cube);
instance.transform.localScale = Vector3.one;
}
else
{
instance = Object.Instantiate(prefab) as GameObject;
}
_prefab = prefab;
instance.transform.parent = parent;
instance.transform.localRotation = Quaternion.Euler(0, _rotationY, 0);
instance.layer = parent.gameObject.layer;
instance.AddComponent <OnlineMapsMarker3DInstance>().marker = this;
visible = false;
inited = true;
control = map.control as OnlineMapsControlBase3D;
Update();
if (OnInitComplete != null)
{
OnInitComplete(this);
}
}
/// <summary>
/// This method is called when a response is received.
/// </summary>
/// <param name="s">Response string</param>
private void OnComplete(string s)
{
// Trying to get an array of results.
OnlineMapsGooglePlacesResult[] results = OnlineMapsGooglePlaces.GetResults(s);
// If there is no result
if (results == null)
{
Debug.Log("Error");
Debug.Log(s);
return;
}
List <OnlineMapsMarker> markers = new List <OnlineMapsMarker>();
foreach (OnlineMapsGooglePlacesResult result in results)
{
// Log name and location of each result.
Debug.Log(result.name);
Debug.Log(result.location);
// Create a marker at the location of the result.
OnlineMapsMarker marker = OnlineMaps.instance.AddMarker(result.location, result.name);
markers.Add(marker);
}
// Get center point and best zoom for markers
Vector2 center;
int zoom;
OnlineMapsUtils.GetCenterPointAndZoom(markers.ToArray(), out center, out zoom);
// Set map position and zoom.
OnlineMaps.instance.position = center;
OnlineMaps.instance.zoom = zoom + 1;
}
private void SetMarkerToBuffer(OnlineMapsMarker marker, OnlineMapsVector2i bufferPosition, int bufferZoom, OnlineMapsVector2i frontBufferPosition, double sx, double sy, double ex, double ey)
{
const int s = OnlineMapsUtils.tileSize;
double mx, my;
marker.GetPosition(out mx, out my);
int maxX = 1 << bufferZoom;
bool isEntireWorld = map.buffer.renderState.width == maxX * s;
bool isBiggestThatBuffer = map.buffer.renderState.width + 512 == maxX * s;
if (isEntireWorld || isBiggestThatBuffer)
{
}
else if (!(((mx > sx && mx < ex) || (mx + 360 > sx && mx + 360 < ex) || (mx - 360 > sx && mx - 360 < ex)) &&
my < sy && my > ey))
{
return;
}
#if !UNITY_WEBGL
int maxCount = 20;
while (marker.locked && maxCount > 0)
{
OnlineMapsUtils.ThreadSleep(1);
maxCount--;
}
#endif
marker.locked = true;
double px, py;
map.projection.CoordinatesToTile(mx, my, bufferZoom, out px, out py);
px -= bufferPosition.x;
py -= bufferPosition.y;
if (isEntireWorld)
{
double tx, ty;
map.projection.CoordinatesToTile(map.buffer.renderState.longitude, map.buffer.renderState.latitude, bufferZoom, out tx, out ty);
tx -= map.buffer.renderState.width / s / 2;
if (px < tx)
{
px += maxX;
}
}
else
{
if (px < 0)
{
px += maxX;
}
else if (px > maxX)
{
px -= maxX;
}
}
float zoomCoof = map.buffer.renderState.zoomCoof;
px *= s;
py *= s;
int ipx = (int)((px - frontBufferPosition.x) / zoomCoof);
int ipy = (int)((py - frontBufferPosition.y) / zoomCoof);
OnlineMapsVector2i ip = marker.GetAlignedPosition(ipx, ipy);
Color32[] markerColors = marker.colors;
if (markerColors == null || markerColors.Length == 0)
{
return;
}
int markerWidth = marker.width;
int markerHeight = marker.height;
OnlineMapsBuffer buffer = map.buffer;
for (int y = 0; y < marker.height; y++)
{
if (ip.y + y < 0 || ip.y + y >= map.height)
{
continue;
}
int cy = (markerHeight - y - 1) * markerWidth;
for (int x = 0; x < marker.width; x++)
{
if (ip.x + x < 0 || ip.x + x >= map.buffer.renderState.width)
{
continue;
}
try
{
buffer.SetColorToBuffer(markerColors[cy + x], ip, y, x);
}
catch
{
}
}
}
if (isEntireWorld)
{
ip.x -= (int)(buffer.renderState.width / zoomCoof);
for (int y = 0; y < marker.height; y++)
{
if (ip.y + y < 0 || ip.y + y >= map.height)
{
continue;
}
int cy = (markerHeight - y - 1) * markerWidth;
for (int x = 0; x < marker.width; x++)
{
if (ip.x + x < 0 || ip.x + x >= map.buffer.renderState.width)
{
continue;
}
try
{
buffer.SetColorToBuffer(markerColors[cy + x], ip, y, x);
}
catch
{
}
}
}
ip.x += (int)(buffer.renderState.width * 2 / zoomCoof);
for (int y = 0; y < marker.height; y++)
{
if (ip.y + y < 0 || ip.y + y >= map.height)
{
continue;
}
int cy = (markerHeight - y - 1) * markerWidth;
for (int x = 0; x < marker.width; x++)
{
if (ip.x + x < 0 || ip.x + x >= map.buffer.renderState.width)
{
continue;
}
try
{
buffer.SetColorToBuffer(markerColors[cy + x], ip, y, x);
}
catch
{
}
}
}
}
marker.locked = false;
}
protected void FillPoly(Color32[] buffer, Vector2 bufferPosition, int bufferWidth, int bufferHeight, float zoom, IEnumerable points, Color32 color, bool invertY)
{
if (color.a == 0)
{
return;
}
float alpha = color.a / 255f;
double minX, maxX, minY, maxY;
double[] bufferPoints = GetBufferPoints(bufferPosition, zoom, points, out minX, out maxX, out minY, out maxY);
if (maxX < 0 || minX > bufferWidth || maxY < 0 || minY > bufferHeight)
{
return;
}
double stX = minX;
if (stX < 0)
{
stX = 0;
}
else if (stX > bufferWidth)
{
stX = bufferWidth;
}
double stY = minY;
if (stY < 0)
{
stY = 0;
}
else if (stY > bufferHeight)
{
stY = bufferHeight;
}
double endX = maxX;
if (endX < 0)
{
stX = 0;
}
else if (endX > bufferWidth)
{
endX = bufferWidth;
}
double endY = maxY;
if (endY < 0)
{
endY = 0;
}
else if (endY > bufferHeight)
{
endY = bufferHeight;
}
int lengthX = (int)Math.Round(endX - stX);
int lengthY = (int)Math.Round(endY - stY);
Color32 clr = new Color32(color.r, color.g, color.b, 255);
const int blockSize = 5;
int blockCountX = lengthX / blockSize + (lengthX % blockSize == 0 ? 0 : 1);
int blockCountY = lengthY / blockSize + (lengthY % blockSize == 0 ? 0 : 1);
byte clrR = clr.r;
byte clrG = clr.g;
byte clrB = clr.b;
int istx = (int)Math.Round(stX);
int isty = (int)Math.Round(stY);
for (int by = 0; by < blockCountY; by++)
{
int byp = by * blockSize;
double bufferY = byp + stY;
int iby = byp + isty;
for (int bx = 0; bx < blockCountX; bx++)
{
int bxp = bx * blockSize;
double bufferX = bxp + stX;
int ibx = bxp + istx;
bool p1 = OnlineMapsUtils.IsPointInPolygon(bufferPoints, bufferX, bufferY);
bool p2 = OnlineMapsUtils.IsPointInPolygon(bufferPoints, bufferX + blockSize - 1, bufferY);
bool p3 = OnlineMapsUtils.IsPointInPolygon(bufferPoints, bufferX + blockSize - 1, bufferY + blockSize - 1);
bool p4 = OnlineMapsUtils.IsPointInPolygon(bufferPoints, bufferX, bufferY + blockSize - 1);
if (p1 && p2 && p3 && p4)
{
for (int y = 0; y < blockSize; y++)
{
if (byp + y >= lengthY)
{
break;
}
int cby = iby + y;
if (!invertY)
{
cby = bufferHeight - cby - 1;
}
int byi = cby * bufferWidth + ibx;
for (int x = 0; x < blockSize; x++)
{
if (bxp + x >= lengthX)
{
break;
}
int bufferIndex = byi + x;
Color32 a = buffer[bufferIndex];
a.r = (byte)(a.r + (clrR - a.r) * alpha);
a.g = (byte)(a.g + (clrG - a.g) * alpha);
a.b = (byte)(a.b + (clrB - a.b) * alpha);
a.a = (byte)(a.a + (255 - a.a) * alpha);
buffer[bufferIndex] = a;
}
}
}
else if (!p1 && !p2 && !p3 && !p4)
{
}
else
{
for (int y = 0; y < blockSize; y++)
{
if (byp + y >= lengthY)
{
break;
}
int cby = iby + y;
if (!invertY)
{
cby = bufferHeight - cby - 1;
}
int byi = cby * bufferWidth + ibx;
for (int x = 0; x < blockSize; x++)
{
if (bxp + x >= lengthX)
{
break;
}
if (OnlineMapsUtils.IsPointInPolygon(bufferPoints, bufferX + x, bufferY + y))
{
int bufferIndex = byi + x;
Color32 a = buffer[bufferIndex];
a.r = (byte)(a.r + (clrR - a.r) * alpha);
a.g = (byte)(a.g + (clrG - a.g) * alpha);
a.b = (byte)(a.b + (clrB - a.b) * alpha);
a.a = (byte)(a.a + (255 - a.a) * alpha);
buffer[bufferIndex] = a;
}
}
}
}
}
}
}
/// <summary>
/// Updates billboard markers.
/// </summary>
protected void UpdateMarkersBillboard()
{
if (markersGameObject == null)
{
InitMarkersMesh();
}
if (markerBillboards == null)
{
markerBillboards = new Dictionary <int, OnlineMapsMarkerBillboard>();
}
double tlx, tly, brx, bry;
api.GetTopLeftPosition(out tlx, out tly);
api.GetBottomRightPosition(out brx, out bry);
if (brx < tlx)
{
brx += 360;
}
int maxX = (2 << api.buffer.apiZoom) / 2;
double px, py;
OnlineMapsUtils.LatLongToTiled(tlx, tly, api.zoom, out px, out py);
float yScale = GetBestElevationYScale(tlx, tly, brx, bry);
Bounds mapBounds = cl.bounds;
Vector3 positionOffset = transform.position - mapBounds.min;
Vector3 size = mapBounds.size;
size = transform.rotation * size;
if (api.target == OnlineMapsTarget.tileset)
{
positionOffset.x -= size.x;
}
foreach (KeyValuePair <int, OnlineMapsMarkerBillboard> billboard in markerBillboards)
{
billboard.Value.used = false;
}
foreach (OnlineMapsMarker marker in api.markers)
{
if (!marker.enabled || !marker.range.InRange(api.zoom))
{
continue;
}
float mx = marker.position.x;
if (!(((mx > tlx && mx < brx) || (mx + 360 > tlx && mx + 360 < brx) ||
(mx - 360 > tlx && mx - 360 < brx)) &&
marker.position.y < tly && marker.position.y > bry))
{
continue;
}
int markerHashCode = marker.GetHashCode();
OnlineMapsMarkerBillboard markerBillboard = null;
if (!markerBillboards.ContainsKey(markerHashCode))
{
markerBillboard = OnlineMapsMarkerBillboard.Create(marker);
markerBillboard.transform.parent = markersGameObject.transform;
markerBillboards.Add(markerHashCode, markerBillboard);
}
else
{
markerBillboard = markerBillboards[markerHashCode];
}
float sx = size.x / api.width * marker2DSize * marker.scale;
float sz = size.z / api.height * marker2DSize * marker.scale;
float s = Mathf.Max(sx, sz);
markerBillboard.transform.localScale = new Vector3(-s, s, s);
Vector2 p = OnlineMapsUtils.LatLongToTilef(marker.position, api.buffer.apiZoom);
p.x = Mathf.Repeat(p.x - (float)px, maxX);
p.y -= (float)py;
float x = -p.x / api.width * OnlineMapsUtils.tileSize * size.x + positionOffset.x;
float z = p.y / api.height * OnlineMapsUtils.tileSize * size.z - positionOffset.z;
float y = GetElevationValue(x, z, yScale, tlx, tly, brx, bry);
markerBillboard.transform.localPosition = transform.rotation * new Vector3(x, y, z);
markerBillboard.used = true;
}
List <int> keysForRemove = new List <int>();
foreach (KeyValuePair <int, OnlineMapsMarkerBillboard> billboard in markerBillboards)
{
if (!billboard.Value.used)
{
billboard.Value.Dispose();
keysForRemove.Add(billboard.Key);
}
}
foreach (int key in keysForRemove)
{
markerBillboards.Remove(key);
}
}
private OnlineMapsWhat3Words(StringBuilder url)
{
_status = OnlineMapsQueryStatus.downloading;
www = OnlineMapsUtils.GetWWW(url);
www.OnComplete += OnRequestComplete;
}
public static List <Vector2> DecodePolylinePoints(string encodedPoints)
{
return(OnlineMapsUtils.DecodePolylinePoints(encodedPoints));
}
public override void DrawOnTileset(OnlineMapsTileSetControl control, int index)
{
base.DrawOnTileset(control, index);
if (!visible)
{
active = false;
return;
}
InitMesh(control, "Poly", borderColor, backgroundColor);
InitLineMesh(points, control, ref vertices, ref normals, ref triangles, ref uv, borderWidth, true, false);
mesh.Clear();
if (vertices.Count < 4)
{
return;
}
active = true;
Vector3 v1 = (vertices[0] + vertices[3]) / 2;
Vector3 v2 = (vertices[vertices.Count - 3] + vertices[vertices.Count - 2]) / 2;
if (Math.Abs((v1 - v2).magnitude) < float.Epsilon)
{
vertices[0] = vertices[vertices.Count - 3] = (vertices[0] + vertices[vertices.Count - 3]) / 2;
vertices[3] = vertices[vertices.Count - 2] = (vertices[3] + vertices[vertices.Count - 2]) / 2;
}
int[] fillTriangles = null;
if (!checkMapBoundaries && backgroundColor.a > 0 && vertices.Count > 0)
{
float l1 = 0;
float l2 = 0;
for (int i = 0; i < vertices.Count / 4 - 1; i++)
{
Vector3 p11 = vertices[i * 4];
Vector3 p12 = vertices[(i + 1) * 4];
Vector3 p21 = vertices[i * 4 + 3];
Vector3 p22 = vertices[(i + 1) * 4 + 3];
l1 += (p11 - p12).magnitude;
l2 += (p21 - p22).magnitude;
}
bool side = l2 < l1;
int off1 = side ? 3 : 0;
int off2 = side ? 2 : 1;
Vector2 lastPoint = Vector2.zero;
List <int> internalIndices = new List <int>(vertices.Count / 4);
List <Vector2> internalPoints = new List <Vector2>(vertices.Count / 4);
for (int i = 0; i < vertices.Count / 4; i++)
{
Vector3 p = vertices[i * 4 + off1];
Vector2 p2 = new Vector2(p.x, p.z);
if (i > 0)
{
if ((lastPoint - p2).magnitude > borderWidth / 2)
{
internalIndices.Add(i * 4 + off1);
internalPoints.Add(p2);
lastPoint = p2;
}
}
else
{
internalIndices.Add(i * 4 + off1);
internalPoints.Add(p2);
lastPoint = p2;
}
p = vertices[i * 4 + off2];
p2 = new Vector2(p.x, p.z);
if ((lastPoint - p2).magnitude > borderWidth / 2)
{
internalIndices.Add(i * 4 + off2);
internalPoints.Add(p2);
lastPoint = p2;
}
}
if (internalPoints[0] == internalPoints[internalPoints.Count - 1])
{
internalPoints.RemoveAt(internalPoints.Count - 1);
}
fillTriangles = OnlineMapsUtils.Triangulate(internalPoints).ToArray();
if (fillTriangles.Length > 2)
{
for (int i = 0; i < fillTriangles.Length; i++)
{
fillTriangles[i] = internalIndices[fillTriangles[i]];
}
Vector3 side1 = vertices[fillTriangles[1]] - vertices[fillTriangles[0]];
Vector3 side2 = vertices[fillTriangles[2]] - vertices[fillTriangles[0]];
Vector3 perp = Vector3.Cross(side1, side2);
bool reversed = perp.y < 0;
if (reversed)
{
fillTriangles = fillTriangles.Reverse().ToArray();
}
}
else
{
fillTriangles = null;
}
}
mesh.subMeshCount = 2;
#if UNITY_4_6 || UNITY_4_7 || UNITY_5_0 || UNITY_5_1
mesh.vertices = vertices.ToArray();
mesh.normals = normals.ToArray();
mesh.uv = uv.ToArray();
#else
mesh.SetVertices(vertices);
mesh.SetNormals(normals);
mesh.SetUVs(0, uv);
#endif
mesh.SetTriangles(triangles.ToArray(), 0);
if (fillTriangles != null)
{
mesh.SetTriangles(fillTriangles.ToArray(), 1);
}
UpdateMaterialsQuote(control, index);
}
private OnlineMapsGoogleDirections(Params p)
{
_status = OnlineMapsQueryStatus.downloading;
StringBuilder url = new StringBuilder();
url.Append("https://maps.googleapis.com/maps/api/directions/xml?sensor=false");
url.Append("&origin=");
if (p.origin is string)
{
url.Append(OnlineMapsWWW.EscapeURL(p.origin as string));
}
else if (p.origin is Vector2)
{
Vector2 o = (Vector2)p.origin;
url.Append(o.y).Append(",").Append(o.x);
}
else
{
throw new Exception("Origin must be string or Vector2.");
}
url.Append("&destination=");
if (p.destination is string)
{
url.Append(OnlineMapsWWW.EscapeURL(p.destination as string));
}
else if (p.destination is Vector2)
{
Vector2 d = (Vector2)p.destination;
url.Append(d.y).Append(",").Append(d.x);
}
else
{
throw new Exception("Destination must be string or Vector2.");
}
if (p.mode.HasValue && p.mode.Value != Mode.driving)
{
url.Append("&mode=").Append(Enum.GetName(typeof(Mode), p.mode.Value));
}
if (p.waypoints != null)
{
StringBuilder waypointStr = new StringBuilder();
bool isFirst = true;
int countWaypoints = 0;
foreach (object w in p.waypoints)
{
if (countWaypoints >= 8)
{
Debug.LogWarning("The maximum number of waypoints is 8.");
break;
}
if (!isFirst)
{
waypointStr = waypointStr.Append("|");
}
if (w is string)
{
waypointStr.Append(OnlineMapsWWW.EscapeURL(w as string));
}
else if (w is Vector2)
{
Vector2 v = (Vector2)w;
waypointStr.Append(v.y).Append(",").Append(v.x);
}
else
{
throw new Exception("Waypoints must be string or Vector2.");
}
countWaypoints++;
isFirst = false;
}
if (countWaypoints > 0)
{
url.Append("&waypoints=optimize:true|").Append(waypointStr);
}
}
if (p.alternatives)
{
url.Append("&alternatives=true");
}
if (p.avoid.HasValue && p.avoid.Value != Avoid.none)
{
url.Append("&avoid=").Append(Enum.GetName(typeof(Avoid), p.avoid.Value));
}
if (p.units.HasValue && p.units.Value != Units.metric)
{
url.Append("&units=").Append(Enum.GetName(typeof(Units), p.units.Value));
}
if (!string.IsNullOrEmpty(p.region))
{
url.Append("®ion=").Append(p.region);
}
if (p.departure_time != null)
{
url.Append("&departure_time=").Append(p.departure_time);
}
if (p.arrival_time.HasValue && p.arrival_time.Value > 0)
{
url.Append("&arrival_time=").Append(p.arrival_time.Value);
}
if (!string.IsNullOrEmpty(p.language))
{
url.Append("&language=").Append(p.language);
}
if (!string.IsNullOrEmpty(p.key))
{
url.Append("&key=").Append(p.key);
}
if (p.traffic_model.HasValue && p.traffic_model.Value != TrafficModel.bestGuess)
{
url.Append("&traffic_model=").Append(Enum.GetName(typeof(TrafficModel), p.traffic_model.Value));
}
if (p.transit_mode.HasValue)
{
OnlineMapsUtils.GetValuesFromEnum(url, "transit_mode", typeof(TransitMode), (int)p.transit_mode.Value);
}
if (p.transit_routing_preference.HasValue)
{
url.Append("&transit_routing_preference=").Append(Enum.GetName(typeof(TransitRoutingPreference), p.transit_routing_preference.Value));
}
www = OnlineMapsUtils.GetWWW(url);
www.OnComplete += OnRequestComplete;
}
/// <summary>
/// Updates billboard markers.
/// </summary>
protected void UpdateMarkersBillboard()
{
if (markersGameObjects == null)
{
InitMarkersMesh(0);
}
if (markerBillboards == null)
{
markerBillboards = new Dictionary <int, OnlineMapsMarkerBillboard>();
}
// Debug.Log("update " + markerBillboards.Count());
double tlx, tly, brx, bry;
map.GetCorners(out tlx, out tly, out brx, out bry);
if (brx < tlx)
{
brx += 360;
}
int maxX = (2 << map.buffer.apiZoom) / 2;
double px, py;
map.projection.CoordinatesToTile(tlx, tly, map.zoom, out px, out py);
float yScale = GetBestElevationYScale(tlx, tly, brx, bry);
Bounds mapBounds = cl.bounds;
Vector3 positionOffset = transform.position - mapBounds.min;
Vector3 size = mapBounds.size;
size = transform.rotation * size;
if (map.target == OnlineMapsTarget.tileset)
{
positionOffset.x -= size.x;
}
foreach (KeyValuePair <int, OnlineMapsMarkerBillboard> billboard in markerBillboards)
{
billboard.Value.used = false;
}
foreach (OnlineMapsMarker marker in map.markers)
{
// Debug.Log("mảk");
if (!marker.enabled || !marker.range.InRange(map.zoom))
{
continue;
}
// Debug.Log("mảk enable");
double mx, my;
marker.GetPosition(out mx, out my);
if (!(((mx > tlx && mx < brx) || (mx + 360 > tlx && mx + 360 < brx) ||
(mx - 360 > tlx && mx - 360 < brx)) &&
my < tly && my > bry))
{
continue;
}
int markerHashCode = marker.GetHashCode();
OnlineMapsMarkerBillboard markerBillboard;
if (!markerBillboards.ContainsKey(markerHashCode))
{
// Debug.Log("mảk hashcode");
markerBillboard = OnlineMapsMarkerBillboard.Create(marker);
markerBillboard.transform.parent = markersGameObjects[0].transform;
markerBillboard.gameObject.layer = markersGameObjects[0].layer;
markerBillboards.Add(markerHashCode, markerBillboard);
}
else
{
markerBillboard = markerBillboards[markerHashCode];
}
if (markerBillboard == null)
{
continue;
}
float sx = size.x / map.width * marker2DSize * marker.scale;
float sz = size.z / map.height * marker2DSize * marker.scale;
float s = Mathf.Max(sx, sz);
#if !UNITY_4_6 && !UNITY_4_7 && !UNITY_5_0 && !UNITY_5_1 && !UNITY_5_2
markerBillboard.transform.localScale = new Vector3(s, s, s);
#else
markerBillboard.transform.localScale = new Vector3(-s, s, s);
#endif
double mpx, mpy;
map.projection.CoordinatesToTile(mx, my, map.buffer.apiZoom, out mpx, out mpy);
mpx = OnlineMapsUtils.Repeat(mpx - px, 0, maxX);
mpy -= py;
float x = (float)(-mpx / map.width * OnlineMapsUtils.tileSize * size.x + positionOffset.x);
float z = (float)(mpy / map.height * OnlineMapsUtils.tileSize * size.z - positionOffset.z);
float y = GetElevationValue(x, z, yScale, tlx, tly, brx, bry);
markerBillboard.transform.localPosition = transform.rotation * new Vector3(x, y, z);
markerBillboard.used = true;
}
List <int> keysForRemove = new List <int>();
foreach (KeyValuePair <int, OnlineMapsMarkerBillboard> billboard in markerBillboards)
{
if (!billboard.Value.used)
{
billboard.Value.Dispose();
keysForRemove.Add(billboard.Key);
}
}
foreach (int key in keysForRemove)
{
markerBillboards.Remove(key);
}
}
private void Destroy()
{
lock (tiles)
{
tiles.Remove(this);
}
if (texture != null)
{
OnlineMapsUtils.DestroyImmediate(texture);
}
if (trafficTexture != null)
{
OnlineMapsUtils.DestroyImmediate(trafficTexture);
}
if (overlayBackTexture != null)
{
OnlineMapsUtils.DestroyImmediate(overlayBackTexture);
}
if (overlayFrontTexture != null)
{
OnlineMapsUtils.DestroyImmediate(overlayFrontTexture);
}
texture = null;
trafficTexture = null;
overlayBackTexture = null;
overlayFrontTexture = null;
customData = null;
_colors = null;
_url = null;
labelData = null;
labelColors = null;
data = null;
OnSetColor = null;
if (hasChilds)
{
foreach (OnlineMapsTile child in childs)
{
if (child != null)
{
child.parent = null;
}
}
}
if (parent != null)
{
if (parent.childs != null)
{
for (int i = 0; i < 4; i++)
{
if (parent.childs[i] == this)
{
parent.childs[i] = null;
break;
}
}
}
}
parent = null;
childs = null;
hasChilds = false;
hasColors = false;
OnDisposed = null;
OnSetColor = null;
}
private void GroupMarkers()
{
List <MarkerGroup> groups = new List <MarkerGroup>();
for (int zoom = OnlineMaps.MAXZOOM; zoom >= OnlineMaps.MINZOOM; zoom--)
{
List <OnlineMapsMarker> ms = markers.Select(m => m).ToList();
for (int j = 0; j < ms.Count - 1; j++)
{
OnlineMapsMarker marker = ms[j];
MarkerGroup group = null;
double px, py;
marker.GetPosition(out px, out py);
OnlineMaps.instance.projection.CoordinatesToTile(px, py, zoom, out px, out py);
int k = j + 1;
while (k < ms.Count)
{
OnlineMapsMarker marker2 = ms[k];
double p2x, p2y;
marker2.GetPosition(out p2x, out p2y);
OnlineMaps.instance.projection.CoordinatesToTile(p2x, p2y, zoom, out p2x, out p2y);
if (OnlineMapsUtils.Magnitude(px, py, p2x, p2y) < distance)
{
if (group == null)
{
group = new MarkerGroup(zoom, groupTexture);
groups.Add(group);
group.Add(marker);
if (Math.Abs(marker.range.min - OnlineMaps.MINZOOM) < float.Epsilon)
{
marker.range.min = zoom + 1;
}
}
group.Add(marker2);
if (Math.Abs(marker2.range.min - OnlineMaps.MINZOOM) < float.Epsilon)
{
marker2.range.min = zoom + 1;
}
ms.RemoveAt(k);
px = group.tilePositionX;
py = group.tilePositionY;
}
else
{
k++;
}
}
}
}
foreach (MarkerGroup g in groups)
{
g.Apply(font);
}
}
/// <summary>
/// Creates a new building, based on Open Street Map.
/// </summary>
/// <param name="container">Reference to OnlineMapsBuildings.</param>
/// <param name="way">Way of building.</param>
/// <param name="nodes">Nodes obtained from Open Street Maps.</param>
/// <returns>Building instance.</returns>
public static OnlineMapsBuildingBase Create(OnlineMapsBuildings container, OnlineMapsOSMWay way, Dictionary <string, OnlineMapsOSMNode> nodes)
{
if (CheckIgnoredBuildings(way))
{
return(null);
}
if (usedNodes == null)
{
usedNodes = new List <OnlineMapsOSMNode>(30);
}
else
{
usedNodes.Clear();
}
way.GetNodes(nodes, usedNodes);
List <Vector3> points = GetLocalPoints(usedNodes);
if (points.Count < 3)
{
return(null);
}
if (points[0] == points[points.Count - 1])
{
points.RemoveAt(points.Count - 1);
}
if (points.Count < 3)
{
return(null);
}
for (int i = 0; i < points.Count; i++)
{
int prev = i - 1;
if (prev < 0)
{
prev = points.Count - 1;
}
int next = i + 1;
if (next >= points.Count)
{
next = 0;
}
float a1 = OnlineMapsUtils.Angle2D(points[prev], points[i]);
float a2 = OnlineMapsUtils.Angle2D(points[i], points[next]);
if (Mathf.Abs(a1 - a2) < 5)
{
points.RemoveAt(i);
i--;
}
}
if (points.Count < 3)
{
return(null);
}
Vector4 cp = new Vector4(float.MaxValue, float.MaxValue, float.MinValue, float.MinValue);
for (int i = 0; i < points.Count; i++)
{
Vector3 point = points[i];
if (point.x < cp.x)
{
cp.x = point.x;
}
if (point.z < cp.y)
{
cp.y = point.z;
}
if (point.x > cp.z)
{
cp.z = point.x;
}
if (point.z > cp.w)
{
cp.w = point.z;
}
}
Vector3 centerPoint = new Vector3((cp.z + cp.x) / 2, 0, (cp.y + cp.w) / 2);
for (int i = 0; i < points.Count; i++)
{
points[i] -= centerPoint;
}
bool generateWall = true;
if (way.HasTagKey("building"))
{
string buildingType = way.GetTagValue("building");
if (buildingType == "roof")
{
generateWall = false;
}
}
float baseHeight = 15;
float roofHeight = 0;
OnlineMapsBuildingMaterial material = GetRandomMaterial(container);
Material wallMaterial;
Material roofMaterial;
Vector2 scale = Vector2.one;
if (defaultShader == null)
{
defaultShader = Shader.Find("Diffuse");
}
if (material != null)
{
if (material.wall != null)
{
wallMaterial = Instantiate(material.wall) as Material;
}
else
{
wallMaterial = new Material(defaultShader);
}
if (material.roof != null)
{
roofMaterial = Instantiate(material.roof) as Material;
}
else
{
roofMaterial = new Material(defaultShader);
}
scale = material.scale;
}
else
{
if (defaultWallMaterial == null)
{
defaultWallMaterial = new Material(defaultShader);
}
if (defaultRoofMaterial == null)
{
defaultRoofMaterial = new Material(defaultShader);
}
wallMaterial = Instantiate(defaultWallMaterial) as Material;
roofMaterial = Instantiate(defaultRoofMaterial) as Material;
}
RoofType roofType = RoofType.flat;
AnalizeHouseTags(way, ref wallMaterial, ref roofMaterial, ref baseHeight);
AnalizeHouseRoofType(way, ref baseHeight, ref roofType, ref roofHeight);
GameObject houseGO = CreateGameObject(way.id);
MeshRenderer renderer = houseGO.AddComponent <MeshRenderer>();
MeshFilter meshFilter = houseGO.AddComponent <MeshFilter>();
Mesh mesh = new Mesh {
name = way.id
};
meshFilter.sharedMesh = mesh;
renderer.sharedMaterials = new []
{
wallMaterial,
roofMaterial
};
OnlineMapsBuildingBuiltIn building = houseGO.AddComponent <OnlineMapsBuildingBuiltIn>();
building.way = way;
building.nodes = usedNodes;
houseGO.transform.localPosition = centerPoint;
houseGO.transform.localRotation = Quaternion.Euler(Vector3.zero);
houseGO.transform.localScale = Vector3.one;
Vector2 centerCoords = Vector2.zero;
float minCX = float.MaxValue, minCY = float.MaxValue, maxCX = float.MinValue, maxCY = float.MinValue;
foreach (OnlineMapsOSMNode node in usedNodes)
{
Vector2 nodeCoords = node;
centerCoords += nodeCoords;
if (nodeCoords.x < minCX)
{
minCX = nodeCoords.x;
}
if (nodeCoords.y < minCY)
{
minCY = nodeCoords.y;
}
if (nodeCoords.x > maxCX)
{
maxCX = nodeCoords.x;
}
if (nodeCoords.y > maxCY)
{
maxCY = nodeCoords.y;
}
}
building.id = way.id;
building.initialZoom = OnlineMaps.instance.zoom;
building.centerCoordinates = new Vector2((maxCX + minCX) / 2, (maxCY + minCY) / 2);
building.boundsCoords = new Bounds(building.centerCoordinates, new Vector3(maxCX - minCX, maxCY - minCY));
int wallVerticesCount = (points.Count + 1) * 2;
int roofVerticesCount = points.Count;
int verticesCount = wallVerticesCount + roofVerticesCount;
int countTriangles = wallVerticesCount * 3;
if (vertices == null)
{
vertices = new List <Vector3>(verticesCount);
}
else
{
vertices.Clear();
}
if (uvs == null)
{
uvs = new List <Vector2>(verticesCount);
}
else
{
uvs.Clear();
}
if (wallTriangles == null)
{
wallTriangles = new List <int>(countTriangles);
}
else
{
wallTriangles.Clear();
}
if (roofTriangles == null)
{
roofTriangles = new List <int>();
}
else
{
roofTriangles.Clear();
}
if (generateWall)
{
building.CreateHouseWall(points, baseHeight, wallMaterial, scale);
}
building.CreateHouseRoof(points, baseHeight, roofHeight, roofType);
if (building.hasErrors)
{
OnlineMapsUtils.DestroyImmediate(building.gameObject);
return(null);
}
mesh.vertices = vertices.ToArray();
mesh.uv = uvs.ToArray();
mesh.subMeshCount = 2;
mesh.SetTriangles(wallTriangles.ToArray(), 0);
mesh.SetTriangles(roofTriangles.ToArray(), 1);
mesh.RecalculateBounds();
mesh.RecalculateNormals();
building.buildingCollider = houseGO.AddComponent <MeshCollider>();
(building.buildingCollider as MeshCollider).sharedMesh = mesh;
return(building);
}
private string GetURL(OnlineMapsTile tile, string url, bool labels)
{
url = Regex.Replace(url, @"{\w+}", delegate(Match match)
{
string v = match.Value.ToLower().Trim('{', '}');
if (OnlineMapsTile.OnReplaceURLToken != null)
{
string ret = OnlineMapsTile.OnReplaceURLToken(tile, v);
if (ret != null)
{
return(ret);
}
}
if (v == "zoom")
{
return(tile.zoom.ToString());
}
if (v == "z")
{
return(tile.zoom.ToString());
}
if (v == "x")
{
return(tile.x.ToString());
}
if (v == "y")
{
return(tile.y.ToString());
}
if (v == "quad")
{
return(OnlineMapsUtils.TileToQuadKey(tile.x, tile.y, tile.zoom));
}
if (v == "lng")
{
return(tile.language);
}
if (v == "ext")
{
return(ext);
}
if (v == "prop")
{
return(labels ? propWithLabels : propWithoutLabels);
}
if (v == "variant")
{
return(labels ? variantWithLabels : variantWithoutLabels);
}
if (TryUseExtraFields(ref v))
{
return(v);
}
return(v);
});
url = Regex.Replace(url, @"{rnd(\d+)-(\d+)}", delegate(Match match)
{
int v1 = int.Parse(match.Groups[1].Value);
int v2 = int.Parse(match.Groups[2].Value);
return(Random.Range(v1, v2 + 1).ToString());
});
if (logUrl)
{
Debug.Log(url);
}
return(url);
}
private bool CreateHouseWallVerticles(float baseHeight, List <Vector3> baseVertices, List <Vector3> vertices, List <Vector2> uvs)
{
float topPoint = baseHeight * OnlineMapsBuildings.instance.heightScale;
int baseVerticesCount = baseVertices.Count;
Vector3 pp = Vector3.zero;
Vector3 ptv = Vector3.zero;
for (int i = 0; i <= baseVerticesCount; i++)
{
int j = i;
if (j >= baseVerticesCount)
{
j -= baseVerticesCount;
}
Vector3 p = baseVertices[j];
Vector3 tv = new Vector3(p.x, topPoint, p.z);
if (i > 0)
{
vertices.Add(pp);
vertices.Add(ptv);
vertices.Add(p);
vertices.Add(tv);
}
pp = p;
ptv = tv;
}
float currentDistance = 0;
int countVertices = vertices.Count;
int fourthVerticesCount = countVertices / 4;
perimeter = 0;
for (int i = 0; i < fourthVerticesCount; i++)
{
int i1 = i * 4;
int i2 = i * 4 + 2;
float magnitude = (vertices[i1] - vertices[i2]).magnitude;
perimeter += magnitude;
}
float prevDistance = 0;
for (int i = 0; i < fourthVerticesCount; i++)
{
int i1 = i * 4;
int i2 = i * 4 + 2;
float magnitude = (vertices[i1] - vertices[i2]).magnitude;
float prevU = prevDistance / perimeter;
currentDistance += magnitude;
prevDistance = currentDistance;
float curU = currentDistance / perimeter;
uvs.Add(new Vector2(prevU, 0));
uvs.Add(new Vector2(prevU, 1));
uvs.Add(new Vector2(curU, 0));
uvs.Add(new Vector2(curU, 1));
}
int southIndex = -1;
float southZ = float.MaxValue;
for (int i = 0; i < baseVerticesCount; i++)
{
if (baseVertices[i].z < southZ)
{
southZ = baseVertices[i].z;
southIndex = i;
}
}
int prevIndex = southIndex - 1;
if (prevIndex < 0)
{
prevIndex = baseVerticesCount - 1;
}
int nextIndex = southIndex + 1;
if (nextIndex >= baseVerticesCount)
{
nextIndex = 0;
}
float angle1 = OnlineMapsUtils.Angle2D(baseVertices[southIndex], baseVertices[nextIndex]);
float angle2 = OnlineMapsUtils.Angle2D(baseVertices[southIndex], baseVertices[prevIndex]);
return(angle1 < angle2);
}
private void Update()
{
if (pointIndex == -1)
{
return;
}
// Start point
OnlineMapsVector2d p1 = points[pointIndex];
// End point
OnlineMapsVector2d p2 = points[pointIndex + 1];
// Total step distance
double dx, dy;
OnlineMapsUtils.DistanceBetweenPoints(p1.x, p1.y, p2.x, p2.y, out dx, out dy);
double stepDistance = Math.Sqrt(dx * dx + dy * dy);
// Total step time
double totalTime = stepDistance / speed * 3600;
// Current step progress
progress += Time.deltaTime / totalTime;
OnlineMapsVector2d position;
if (progress < 1)
{
position = OnlineMapsVector2d.Lerp(p1, p2, progress);
marker.SetPosition(position.x, position.y);
// Orient marker
if (orientMarkerOnNextPoint)
{
marker.rotation = 1.25f - OnlineMapsUtils.Angle2D((Vector2)p1, (Vector2)p2) / 360f;
}
}
else
{
position = p2;
marker.SetPosition(position.x, position.y);
pointIndex++;
progress = 0;
if (pointIndex >= points.Length - 1)
{
Debug.Log("Finish");
pointIndex = -1;
}
else
{
// Orient marker
if (orientMarkerOnNextPoint)
{
marker.rotation = 1.25f - OnlineMapsUtils.Angle2D(p2, points[pointIndex + 1]) / 360;
}
}
}
if (lookToMarker)
{
OnlineMaps.instance.SetPosition(position.x, position.y);
}
OnlineMaps.instance.Redraw();
}
private void UpdateLine()
{
_size = size;
float totalDistance = 0;
Vector3 lastPosition = Vector3.zero;
List <Vector3> vertices = new List <Vector3>();
List <Vector2> uvs = new List <Vector2>();
List <Vector3> normals = new List <Vector3>();
List <int> triangles = new List <int>();
List <Vector3> positions = new List <Vector3>();
for (int i = 0; i < coords.Length; i++)
{
// Get world position by coordinates
Vector3 position = OnlineMapsTileSetControl.instance.GetWorldPosition(coords[i]);
positions.Add(position);
if (i != 0)
{
// Calculate angle between coordinates.
float a = OnlineMapsUtils.Angle2DRad(lastPosition, position, 90);
// Calculate offset
Vector3 off = new Vector3(Mathf.Cos(a) * size, 0, Mathf.Sin(a) * size);
// Init vertices, normals and triangles.
int vCount = vertices.Count;
vertices.Add(lastPosition + off);
vertices.Add(lastPosition - off);
vertices.Add(position + off);
vertices.Add(position - off);
normals.Add(Vector3.up);
normals.Add(Vector3.up);
normals.Add(Vector3.up);
normals.Add(Vector3.up);
triangles.Add(vCount);
triangles.Add(vCount + 3);
triangles.Add(vCount + 1);
triangles.Add(vCount);
triangles.Add(vCount + 2);
triangles.Add(vCount + 3);
totalDistance += (lastPosition - position).magnitude;
}
lastPosition = position;
}
float tDistance = 0;
for (int i = 1; i < positions.Count; i++)
{
float distance = (positions[i - 1] - positions[i]).magnitude;
// Updates UV
uvs.Add(new Vector2(tDistance / totalDistance, 0));
uvs.Add(new Vector2(tDistance / totalDistance, 1));
tDistance += distance;
uvs.Add(new Vector2(tDistance / totalDistance, 0));
uvs.Add(new Vector2(tDistance / totalDistance, 1));
}
// Update mesh
mesh.vertices = vertices.ToArray();
mesh.normals = normals.ToArray();
mesh.uv = uvs.ToArray();
mesh.triangles = triangles.ToArray();
mesh.RecalculateBounds();
// Scale texture
Vector2 scale = new Vector2(totalDistance / size, 1);
scale.Scale(uvScale);
meshRenderer.material.mainTextureScale = scale;
}
public new static OnlineMapsFindPlaceDetailsResult GetResult(string response)
{
OnlineMapsGooglePlaceDetailsResult results = OnlineMapsGooglePlaceDetails.GetResult(response);
return(OnlineMapsUtils.DeepCopy <OnlineMapsFindPlaceDetailsResult>(results));
}
public override void Update(double tlx, double tly, double brx, double bry, int zoom)
{
if (instance == null)
{
Debug.Log("No instance");
return;
}
if (!range.InRange(zoom))
{
enabled = false;
}
else if (position.y > tly || position.y < bry)
{
enabled = false;
}
else if (tlx < brx && (position.x < tlx || position.x > brx))
{
enabled = false;
}
else if (tlx > brx && position.x < tlx && position.x > brx)
{
enabled = false;
}
else
{
enabled = true;
}
if (!enabled)
{
return;
}
if (_prefab != prefab)
{
Reinit(tlx, tly, brx, bry, zoom);
}
double mx, my;
OnlineMapsUtils.LatLongToTiled(position.x, position.y, zoom, out mx, out my);
double ttlx, ttly, tbrx, tbry;
OnlineMapsUtils.LatLongToTiled(tlx, tly, zoom, out ttlx, out ttly);
OnlineMapsUtils.LatLongToTiled(brx, bry, zoom, out tbrx, out tbry);
int maxX = (2 << zoom) / 2;
OnlineMaps api = OnlineMaps.instance;
Bounds bounds = api.GetComponent <Collider>().bounds;
double sx = tbrx - ttlx;
if (sx < 0)
{
sx += maxX;
}
double mpx = mx - ttlx;
if (mpx < 0)
{
mpx += maxX;
}
double px = mpx / sx;
double pz = (ttly - my) / (ttly - tbry);
_relativePosition = new Vector3((float)px, 0, (float)pz);
if (OnlineMapsControlBase.instance is OnlineMapsTileSetControl)
{
px = -api.tilesetSize.x / 2 - (px - 0.5) * api.tilesetSize.x;
pz = api.tilesetSize.y / 2 + (pz - 0.5) * api.tilesetSize.y;
}
else
{
Vector3 center = bounds.center;
Vector3 size = bounds.size;
px = center.x - (px - 0.5) * size.x - api.transform.position.x;
pz = center.z + (pz - 0.5) * size.z - api.transform.position.z;
}
Vector3 oldPosition = instance.transform.localPosition;
float y = 0;
if (OnlineMapsControlBase.instance is OnlineMapsTileSetControl)
{
OnlineMapsTileSetControl control = OnlineMapsTileSetControl.instance;
y = control.GetElevationValue((float)px, (float)pz, control.GetBestElevationYScale(tlx, tly, brx, bry), tlx, tly, brx, bry);
}
Vector3 newPosition = new Vector3((float)px, y, (float)pz);
instance.transform.localPosition = newPosition;
if (oldPosition != newPosition && OnPositionChanged != null)
{
OnPositionChanged(this);
}
}
public override bool HitTest(Vector2 positionLngLat, int zoom)
{
if (points == null)
{
return(false);
}
double cx, cy;
OnlineMapsProjection projection = api.projection;
projection.CoordinatesToTile(positionLngLat.x, positionLngLat.y, zoom, out cx, out cy);
int valueType = -1; // 0 - Vector2, 1 - float, 2 - double, 3 - OnlineMapsVector2d
object v1 = null;
object v2 = null;
object v3 = null;
int i = 0;
float w = hitTestWidth.HasValue ? hitTestWidth.Value : width;
float sqrW = w * w;
foreach (object p in points)
{
if (valueType == -1)
{
if (p is Vector2)
{
valueType = 0;
}
else if (p is float)
{
valueType = 1;
}
else if (p is double)
{
valueType = 2;
}
else if (p is OnlineMapsVector2d)
{
valueType = 3;
}
}
object v4 = v3;
v3 = v2;
v2 = v1;
v1 = p;
double p1tx = 0, p1ty = 0, p2tx = 0, p2ty = 0;
bool drawPart = false;
if (valueType == 0)
{
if (i > 0)
{
Vector2 p1 = (Vector2)v2;
Vector2 p2 = (Vector2)v1;
projection.CoordinatesToTile(p1.x, p1.y, zoom, out p1tx, out p1ty);
projection.CoordinatesToTile(p2.x, p2.y, zoom, out p2tx, out p2ty);
drawPart = true;
}
}
else if (valueType == 3)
{
if (i > 0)
{
OnlineMapsVector2d p1 = (OnlineMapsVector2d)v2;
OnlineMapsVector2d p2 = (OnlineMapsVector2d)v1;
projection.CoordinatesToTile(p1.x, p1.y, zoom, out p1tx, out p1ty);
projection.CoordinatesToTile(p2.x, p2.y, zoom, out p2tx, out p2ty);
drawPart = true;
}
}
else if (i > 2 && i % 2 == 1)
{
if (valueType == 1)
{
projection.CoordinatesToTile((float)v4, (float)v3, zoom, out p1tx, out p1ty);
projection.CoordinatesToTile((float)v2, (float)v1, zoom, out p2tx, out p2ty);
}
else if (valueType == 2)
{
projection.CoordinatesToTile((double)v4, (double)v3, zoom, out p1tx, out p1ty);
projection.CoordinatesToTile((double)v2, (double)v1, zoom, out p2tx, out p2ty);
}
drawPart = true;
}
if (drawPart)
{
double nx, ny;
OnlineMapsUtils.NearestPointStrict(cx, cy, p1tx, p1ty, p2tx, p2ty, out nx, out ny);
double dx = (cx - nx) * OnlineMapsUtils.tileSize;
double dy = (cy - ny) * OnlineMapsUtils.tileSize;
double d = dx * dx + dy * dy;
if (d < sqrW)
{
return(true);
}
}
i++;
}
return(false);
}
public override bool HitTest(Vector2 positionLngLat, int zoom)
{
return(OnlineMapsUtils.IsPointInPolygon(points, positionLngLat.x, positionLngLat.y));
}
