/// <summary>
/// Returns yScale for an area
/// </summary>
/// <param name="tlx">Left longitude</param>
/// <param name="tly">Top latitude</param>
/// <param name="brx">Right longitude</param>
/// <param name="bry">Bottom latitude</param>
/// <returns>yScale for an area</returns>
public static float GetBestElevationYScale(double tlx, double tly, double brx, double bry)
{
if (_instance != null && _instance.lockYScale)
{
return(_instance.yScaleValue);
}
double dx, dy;
OnlineMaps map = _instance != null ? _instance.map : OnlineMaps.instance;
if (map == null)
{
return(0);
}
OnlineMapsControlBaseDynamicMesh control = map.control as OnlineMapsControlBaseDynamicMesh;
if (control == null)
{
return(0);
}
OnlineMapsUtils.DistanceBetweenPoints(tlx, tly, brx, bry, out dx, out dy);
dx = dx / control.sizeInScene.x * map.width;
dy = dy / control.sizeInScene.y * map.height;
return((float)Math.Min(map.width / dx, map.height / dy) / 1000);
}
private void OnEnable()
{
_instance = this;
map = GetComponent <OnlineMaps>();
if (map == null)
{
map = FindObjectOfType <OnlineMaps>();
}
control = map.control as OnlineMapsControlBaseDynamicMesh;
}
private bool HitTest()
{
if (buildingCollider == null)
{
return(false);
}
RaycastHit hit;
OnlineMapsControlBaseDynamicMesh control = container.control;
return(buildingCollider.Raycast(control.activeCamera.ScreenPointToRay(control.GetInputPosition()), out hit, OnlineMapsUtils.maxRaycastDistance));
}
private void Start()
{
if (gesture == null)
{
Debug.LogWarning("Online Maps TouchScript Connector / Gesture cannot be null");
Destroy(this);
return;
}
control = OnlineMapsControlBase.instance;
control.allowZoom = false;
dmControl = control as OnlineMapsControlBaseDynamicMesh;
cameraOrbit = GetComponent <OnlineMapsCameraOrbit>();
if (cameraOrbit != null)
{
speed = cameraOrbit.speed;
cameraOrbit.speed = Vector2.zero;
}
gesture.Transformed += GestureOnTransformed;
}
private void OnEnable()
{
map = GetComponent <OnlineMaps>();
control = map.control as OnlineMapsControlBaseDynamicMesh;
bool isFirstEnable = _instance == null;
_instance = this;
buildings = new Dictionary <string, OnlineMapsBuildingBase>();
unusedBuildings = new Dictionary <string, OnlineMapsBuildingBase>();
newBuildingsData = new Queue <OnlineMapsBuildingsNodeData>();
container = new GameObject("Buildings");
container.transform.parent = transform;
container.transform.localPosition = Vector3.zero;
container.transform.localRotation = Quaternion.Euler(Vector3.zero);
container.transform.localScale = Vector3.one;
if (!isFirstEnable)
{
Start();
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="control">Reference to dynamic mesh control</param>
public OnlineMapsMarkerBillboardDrawer(OnlineMapsControlBaseDynamicMesh control)
{
this.control = control;
control.OnDrawMarkers += OnDrawMarkers;
}
private void OnDrawMarkers()
{
if (markersGameObjects == null)
{
InitMarkersMesh(0);
}
double tlx, tly, brx, bry;
map.GetCorners(out tlx, out tly, out brx, out bry);
if (brx < tlx)
{
brx += 360;
}
int zoom = map.buffer.renderState.zoom;
int maxX = 1 << zoom;
double tx, ty;
map.projection.CoordinatesToTile(tlx, tly, zoom, out tx, out ty);
float yScale = OnlineMapsElevationManagerBase.GetBestElevationYScale(tlx, tly, brx, bry);
OnlineMapsControlBaseDynamicMesh tileset = control as OnlineMapsControlBaseDynamicMesh;
float cx = -tileset.sizeInScene.x / map.buffer.renderState.width;
float cy = tileset.sizeInScene.y / map.buffer.renderState.height;
if (usedMarkers == null)
{
usedMarkers = new List <FlatMarker>(32);
}
else
{
for (int i = 0; i < usedMarkers.Count; i++)
{
usedMarkers[i].Dispose();
}
usedMarkers.Clear();
}
List <Texture> usedTextures = new List <Texture>(32)
{
OnlineMapsMarkerManager.instance.defaultTexture
};
List <List <int> > usedTexturesMarkerIndex = new List <List <int> >(32)
{
new List <int>(32)
};
int usedMarkersCount = 0;
Bounds tilesetBounds = new Bounds(
new Vector3(tileset.sizeInScene.x / -2, 0, tileset.sizeInScene.y / 2),
new Vector3(tileset.sizeInScene.x, 0, tileset.sizeInScene.y));
IEnumerable <OnlineMapsMarker> markers = OnlineMapsMarkerManager.instance.Where(delegate(OnlineMapsMarker marker)
{
if (!marker.enabled || !marker.range.InRange(zoom))
{
return(false);
}
if (OnCheckMarker2DVisibility != null)
{
if (!OnCheckMarker2DVisibility(marker))
{
return(false);
}
}
else if (control.checkMarker2DVisibility == OnlineMapsTilesetCheckMarker2DVisibility.pivot)
{
double mx, my;
marker.GetPosition(out mx, out my);
bool a = my > tly ||
my < bry ||
(
(mx <tlx || mx> brx) &&
(mx + 360 < tlx || mx + 360 > brx) &&
(mx - 360 < tlx || mx - 360 > brx)
);
if (a)
{
return(false);
}
}
return(true);
});
float[] offsets = null;
bool useOffsetY = false;
int index = 0;
if (markerComparer != null)
{
markers = markers.OrderBy(m => m, markerComparer);
}
else
{
markers = markers.OrderBy(m =>
{
double mx, my;
m.GetPosition(out mx, out my);
return(90 - my);
});
useOffsetY = OnGetFlatMarkerOffsetY != null;
if (useOffsetY)
{
int countMarkers = markers.Count();
SortedMarker[] sortedMarkers = new SortedMarker[countMarkers];
foreach (OnlineMapsMarker marker in markers)
{
sortedMarkers[index++] = new SortedMarker
{
marker = marker,
offset = OnGetFlatMarkerOffsetY(marker)
};
}
offsets = new float[countMarkers];
OnlineMapsMarker[] nMarkers = new OnlineMapsMarker[countMarkers];
int i = 0;
foreach (SortedMarker sm in sortedMarkers.OrderBy(m => m.offset))
{
nMarkers[i] = sm.marker;
offsets[i] = sm.offset;
i++;
sm.Dispose();
}
markers = nMarkers;
}
}
if (markersVertices == null)
{
markersVertices = new List <Vector3>(64);
}
else
{
markersVertices.Clear();
}
Vector3 tpos = control.transform.position;
foreach (Mesh mesh in markersMeshes)
{
mesh.Clear();
}
float zoomCoof = map.buffer.renderState.zoomCoof;
Matrix4x4 matrix = new Matrix4x4();
int meshIndex = 0;
index = -1;
foreach (OnlineMapsMarker marker in markers)
{
index++;
double fx, fy;
marker.GetTilePosition(out fx, out fy);
Vector2 offset = marker.GetAlignOffset();
offset *= marker.scale;
fx = (fx - tx) / zoomCoof;
if (fx < 0)
{
fx += maxX;
}
else if (fx > maxX)
{
fx -= maxX;
}
fx = fx * OnlineMapsUtils.tileSize - offset.x;
fy = (fy - ty) / zoomCoof * OnlineMapsUtils.tileSize - offset.y;
if (marker.texture == null)
{
marker.texture = OnlineMapsMarkerManager.instance.defaultTexture;
marker.Init();
}
float markerWidth = marker.texture.width * marker.scale;
float markerHeight = marker.texture.height * marker.scale;
float rx1 = (float)(fx * cx);
float ry1 = (float)(fy * cy);
float rx2 = (float)((fx + markerWidth) * cx);
float ry2 = (float)((fy + markerHeight) * cy);
Vector3 center = new Vector3((float)((fx + offset.x) * cx), 0, (float)((fy + offset.y) * cy));
Vector3 p1 = new Vector3(rx1 - center.x, 0, ry1 - center.z);
Vector3 p2 = new Vector3(rx2 - center.x, 0, ry1 - center.z);
Vector3 p3 = new Vector3(rx2 - center.x, 0, ry2 - center.z);
Vector3 p4 = new Vector3(rx1 - center.x, 0, ry2 - center.z);
float angle = Mathf.Repeat(marker.rotation, 1) * 360;
if (Math.Abs(angle) > float.Epsilon)
{
matrix.SetTRS(Vector3.zero, Quaternion.Euler(0, angle, 0), Vector3.one);
p1 = matrix.MultiplyPoint(p1) + center;
p2 = matrix.MultiplyPoint(p2) + center;
p3 = matrix.MultiplyPoint(p3) + center;
p4 = matrix.MultiplyPoint(p4) + center;
}
else
{
p1 += center;
p2 += center;
p3 += center;
p4 += center;
}
if (control.checkMarker2DVisibility == OnlineMapsTilesetCheckMarker2DVisibility.bounds)
{
Vector3 markerCenter = (p2 + p4) / 2;
Vector3 markerSize = p4 - p2;
if (!tilesetBounds.Intersects(new Bounds(markerCenter, markerSize)))
{
continue;
}
}
float y = OnlineMapsElevationManagerBase.GetElevation((rx1 + rx2) / 2, (ry1 + ry2) / 2, yScale, tlx, tly, brx, bry);
float yOffset = useOffsetY ? offsets[index] : 0;
p1.y = p2.y = p3.y = p4.y = y + yOffset;
int vIndex = markersVertices.Count;
markersVertices.Add(p1);
markersVertices.Add(p2);
markersVertices.Add(p3);
markersVertices.Add(p4);
usedMarkers.Add(new FlatMarker(marker, p1 + tpos, p2 + tpos, p3 + tpos, p4 + tpos));
if (OnGenerateMarkerVertices != null)
{
OnGenerateMarkerVertices(marker, markersVertices, vIndex);
}
if (marker.texture == OnlineMapsMarkerManager.instance.defaultTexture)
{
usedTexturesMarkerIndex[0].Add(usedMarkersCount);
}
else
{
int textureIndex = usedTextures.IndexOf(marker.texture);
if (textureIndex != -1)
{
usedTexturesMarkerIndex[textureIndex].Add(usedMarkersCount);
}
else
{
usedTextures.Add(marker.texture);
usedTexturesMarkerIndex.Add(new List <int>(32));
usedTexturesMarkerIndex[usedTexturesMarkerIndex.Count - 1].Add(usedMarkersCount);
}
}
usedMarkersCount++;
if (usedMarkersCount == 16250)
{
SetMarkersMesh(usedMarkersCount, usedTextures, usedTexturesMarkerIndex, meshIndex);
meshIndex++;
markersVertices.Clear();
usedMarkersCount = 0;
usedTextures.Clear();
usedTextures.Add(OnlineMapsMarkerManager.instance.defaultTexture);
usedTexturesMarkerIndex.Clear();
usedTexturesMarkerIndex.Add(new List <int>(32));
}
}
SetMarkersMesh(usedMarkersCount, usedTextures, usedTexturesMarkerIndex, meshIndex);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="control">Reference to dynamic mesh control</param>
public OnlineMapsMarkerFlatDrawer(OnlineMapsControlBaseDynamicMesh control)
{
this.control = control;
map = control.map;
control.OnDrawMarkers += OnDrawMarkers;
}
private void CreateMap()
{
OnlineMaps map = CreateMapGameObject();
GameObject go = map.gameObject;
Sprite sprite = null;
Control control = activeControl;
Component component = go.AddComponent(control.type);
if (control.resultType == OnlineMapsTarget.texture)
{
map.redrawOnPlay = true;
string texturePath;
Texture2D texture = CreateTexture(map, out texturePath);
if (control.useSprite)
{
TextureImporter textureImporter = AssetImporter.GetAtPath(texturePath) as TextureImporter;
textureImporter.textureType = TextureImporterType.Sprite;
textureImporter.SaveAndReimport();
sprite = AssetDatabase.LoadAssetAtPath(texturePath, typeof(Sprite)) as Sprite;
if (component is OnlineMapsSpriteRendererControl)
{
SpriteRenderer spriteRenderer = go.GetComponent <SpriteRenderer>();
spriteRenderer.sprite = sprite;
go.AddComponent <BoxCollider>();
}
}
if (component is OnlineMapsUIImageControl || component is OnlineMapsUIRawImageControl)
{
RectTransform rectTransform = go.AddComponent <RectTransform>();
rectTransform.SetParent(uGUIParent.transform as RectTransform);
go.AddComponent <CanvasRenderer>();
rectTransform.localPosition = Vector3.zero;
rectTransform.anchorMax = rectTransform.anchorMin = new Vector2(0.5f, 0.5f);
rectTransform.pivot = new Vector2(0.5f, 0.5f);
rectTransform.sizeDelta = new Vector2(textureWidth, textureHeight);
if (component is OnlineMapsUIImageControl)
{
Image image = go.AddComponent <Image>();
image.sprite = sprite;
}
else
{
RawImage image = go.AddComponent <RawImage>();
image.texture = texture;
}
}
if (component is OnlineMapsNGUITextureControl)
{
#if NGUI
go.layer = NGUIParent.layer;
UITexture uiTexture = go.AddComponent <UITexture>();
uiTexture.mainTexture = texture;
uiTexture.width = textureWidth;
uiTexture.height = textureHeight;
go.transform.parent = NGUIParent.transform;
go.transform.localPosition = Vector3.zero;
go.transform.localScale = Vector3.one;
go.transform.localRotation = Quaternion.Euler(Vector3.zero);
BoxCollider boxCollider = go.AddComponent <BoxCollider>();
boxCollider.size = new Vector3(textureWidth, textureHeight, 0);
#endif
}
if (component is OnlineMapsTextureControl)
{
Renderer renderer = go.GetComponent <Renderer>();
renderer.sharedMaterial = new Material(Shader.Find("Diffuse"));
renderer.sharedMaterial.mainTexture = texture;
map.redrawOnPlay = true;
}
}
else
{
OnlineMapsControlBaseDynamicMesh control3D = component as OnlineMapsControlBaseDynamicMesh;
map.width = tilesetWidth;
map.height = tilesetHeight;
control3D.sizeInScene = sizeInScene;
map.renderInThread = false;
OnlineMapsTileSetControl tsControl = component as OnlineMapsTileSetControl;
if (tsControl != null)
{
tsControl.tileMaterial = tileMaterial;
tsControl.markerMaterial = markerMaterial;
tsControl.tilesetShader = tilesetShader;
tsControl.drawingShader = drawingShader;
tsControl.markerShader = markerShader;
}
if (moveCameraToMap)
{
GameObject cameraGO = activeCamera.gameObject;
float minSide = Mathf.Min(sizeInScene.x, sizeInScene.y);
Vector3 pos = new Vector3(sizeInScene.x / -2, minSide, sizeInScene.y / 2);
cameraGO.transform.position = pos;
cameraGO.transform.rotation = Quaternion.Euler(90, 180, 0);
}
}
foreach (IPlugin plugin in control.plugins)
{
if (plugin is Plugin)
{
Plugin p = plugin as Plugin;
if (p.enabled)
{
go.AddComponent(p.type);
}
}
else if (plugin is PluginGroup)
{
PluginGroup g = plugin as PluginGroup;
if (g.selected > 0)
{
go.AddComponent(g.plugins.First(p => p.title == g.titles[g.selected]).type);
}
}
}
EditorGUIUtility.PingObject(go);
Selection.activeGameObject = go;
}
private static void UpdateBuildingPosition(OnlineMapsBuildingBase building, OnlineMapsControlBaseDynamicMesh control, double tlx, double tly, double brx, double bry)
{
Vector3 newPosition = control.GetWorldPositionWithElevation(building.centerCoordinates.x, building.centerCoordinates.y, tlx, tly, brx, bry);
building.transform.position = newPosition;
}
