public override void DrawOnTileset(OnlineMapsTileSetControl control, int index)
{
base.DrawOnTileset(control, index);
if (!visible)
{
active = false;
return;
}
InitMesh(control, "Line", color, default(Color), texture);
List <Vector3> verticles;
List <Vector3> normals;
List <int> triangles;
List <Vector2> uv;
InitLineMesh(points, control, out verticles, out normals, out triangles, out uv, weight);
mesh.Clear();
mesh.vertices = verticles.ToArray();
mesh.normals = normals.ToArray();
mesh.uv = uv.ToArray();
mesh.SetTriangles(triangles.ToArray(), 0);
UpdateMaterialsQuote(control, index);
}
public override void DrawOnTileset(OnlineMapsTileSetControl control)
{
base.DrawOnTileset(control);
if (!visible)
{
active = false;
return;
}
InitMesh(control, "Poly", borderColor, backgroundColor);
List <Vector3> verticles;
List <Vector3> normals;
List <int> triangles;
List <Vector2> uv;
InitLineMesh(points, control, out verticles, out normals, out triangles, out uv, borderWeight, true);
mesh.Clear();
mesh.subMeshCount = 2;
mesh.vertices = verticles.ToArray();
mesh.normals = normals.ToArray();
mesh.uv = uv.ToArray();
mesh.SetTriangles(triangles.ToArray(), 0);
}
private void OnEnable()
{
OnlineMapsTileSetControl control = GetComponent <OnlineMapsTileSetControl>();
control.OnDrawTile -= OnDrawTile;
control.OnDrawTile += OnDrawTile;
}
private void DrawActivePointsCI3(OnlineMapsTileSetControl control, bool ignoreTop, bool ignoreRight, bool ignoreBottom, List <Vector2> activePoints,
List <Vector2> localPoints, ref List <Vector3> vertices, ref List <Vector3> normals, ref List <int> borderTriangles, ref List <Vector2> uv)
{
int off = 0;
if (ignoreTop)
{
off = 3;
}
else if (ignoreRight)
{
off = 2;
}
else if (ignoreBottom)
{
off = 1;
}
for (int i = 0; i < 2; i++)
{
int ci = i + off;
if (ci > 3)
{
ci -= 4;
}
activePoints.Add(localPoints[ci]);
}
DrawActivePoints(control, ref activePoints, ref vertices, ref normals, ref borderTriangles, ref uv, borderWidth);
}
public override void DrawOnTileset(OnlineMapsTileSetControl control, int index)
{
if (points == null)
{
return;
}
base.DrawOnTileset(control, index);
if (!visible)
{
active = false;
return;
}
active = true;
InitMesh(control, color, default(Color), texture);
InitLineMesh(points, control, ref vertices, ref normals, ref triangles, ref uv, width);
mesh.Clear();
mesh.SetVertices(vertices);
mesh.SetNormals(normals);
mesh.SetUVs(0, uv);
mesh.SetTriangles(triangles.ToArray(), 0);
UpdateMaterialsQuote(control, index);
}
protected void UpdateMaterialsQuote(OnlineMapsTileSetControl control, int index)
{
foreach (Material material in materials)
{
material.renderQueue = control.drawingShader.renderQueue + renderQueueOffset + index;
}
}
protected void UpdateCameraPosition()
{
//if (cameraRotation.x > maxCameraRotationX) cameraRotation.x = 0; //changed value here
//else if (cameraRotation.x < 0) cameraRotation.x = 0;
float rx = 90 - 0;
if (rx > 89.9)
{
rx = 89.9f;
}
double px = Math.Cos(rx * Mathf.Deg2Rad) * cameraDistance;
double py = Math.Sin(rx * Mathf.Deg2Rad) * cameraDistance;
double pz = Math.Cos(cameraRotation.y * Mathf.Deg2Rad) * px;
px = Math.Sin(cameraRotation.y * Mathf.Deg2Rad) * px;
Vector3 targetPosition = transform.position;
if (this is OnlineMapsTileSetControl)
{
Vector3 offset = new Vector3(map.tilesetSize.x / -2, 0, map.tilesetSize.y / 2);
OnlineMapsTileSetControl control = OnlineMapsTileSetControl.instance;
if (control.smoothZoom && control.smoothZoomStarted)
{
targetPosition = originalPosition;
}
if (control.useElevation && control.elevationZoomRange.InRange(map.zoom))
{
double tlx, tly, brx, bry;
map.GetCorners(out tlx, out tly, out brx, out bry);
float yScale = control.GetBestElevationYScale(tlx, tly, brx, bry);
if (cameraAdjustTo == OnlineMapsCameraAdjust.maxElevationInArea)
{
offset.y = control.GetMaxElevationValue(yScale);
}
else
{
offset.y = control.GetElevationValue(targetPosition.x, targetPosition.z, yScale, tlx, tly, brx, bry);
}
}
offset.Scale(control.smoothZoomStarted? control.originalScale: transform.lossyScale);
targetPosition += transform.rotation * offset;
}
Vector3 oldPosition = activeCamera.transform.position;
Vector3 newPosition = transform.rotation * new Vector3((float)px, (float)py, (float)pz) + targetPosition;
activeCamera.transform.position = newPosition;
activeCamera.transform.LookAt(targetPosition);
if (oldPosition != newPosition && OnCameraControl != null)
{
OnCameraControl();
}
}
private void UpdateCameraPosition()
{
if (cameraRotation.x > 80)
{
cameraRotation.x = 80f;
}
else if (cameraRotation.x < 0)
{
cameraRotation.x = 0;
}
float rx = 90 - cameraRotation.x;
if (rx > 89.9)
{
rx = 89.9f;
}
double px = Math.Cos(rx * Mathf.Deg2Rad) * cameraDistance;
double py = Math.Sin(rx * Mathf.Deg2Rad) * cameraDistance;
double pz = Math.Cos(cameraRotation.y * Mathf.Deg2Rad) * px;
px = Math.Sin(cameraRotation.y * Mathf.Deg2Rad) * px;
Vector3 targetPosition = transform.position;
if (this is OnlineMapsTileSetControl)
{
Vector3 offset = new Vector3(api.tilesetSize.x / -2, 0, api.tilesetSize.y / 2);
OnlineMapsTileSetControl control = OnlineMapsTileSetControl.instance;
if (control.smoothZoom && control.smoothZoomStarted)
{
targetPosition = control.originalPosition;
}
if (control.useElevation && control.elevationZoomRange.InRange(api.zoom))
{
double tlx, tly, brx, bry;
api.GetTopLeftPosition(out tlx, out tly);
api.GetBottomRightPosition(out brx, out bry);
float yScale = control.GetBestElevationYScale(tlx, tly, brx, bry);
offset.y = control.GetMaxElevationValue(yScale);
}
targetPosition += transform.rotation * offset;
}
Vector3 oldPosition = activeCamera.transform.position;
Vector3 newPosition = transform.rotation * new Vector3((float)px, (float)py, (float)pz) + targetPosition;
activeCamera.transform.position = newPosition;
activeCamera.transform.LookAt(targetPosition);
if (oldPosition != newPosition && OnCameraControl != null)
{
OnCameraControl();
}
}
private void Start()
{
map = OnlineMaps.instance;
control = OnlineMapsTileSetControl.instance;
map.OnMapUpdated += UpdateMarkers;
OnlineMapsCameraOrbit.instance.OnCameraControl += UpdateMarkers;
markers = new List <MarkerInstance>();
foreach (MarkerData data in datas)
{
GameObject markerGameObject = Instantiate(prefab) as GameObject;
markerGameObject.name = data.title;
RectTransform rectTransform = markerGameObject.transform as RectTransform;
rectTransform.SetParent(container);
markerGameObject.transform.localScale = Vector3.one;
MarkerInstance marker = new MarkerInstance();
marker.data = data;
marker.gameObject = markerGameObject;
marker.transform = rectTransform;
SetText(rectTransform, "Title", data.title);
SetText(rectTransform, "Population", data.population);
markers.Add(marker);
}
UpdateMarkers();
}
private void DrawElevationGUI(OnlineMapsTileSetControl tilesetControl)
{
bool useElevation = tilesetControl.useElevation;
if (useElevation) EditorGUILayout.BeginVertical(GUI.skin.box);
EditorGUI.BeginChangeCheck();
tilesetControl.useElevation = EditorGUILayout.Toggle("Use elevation", tilesetControl.useElevation);
if (EditorGUI.EndChangeCheck() && EditorApplication.isPlaying) control.UpdateControl();
if (tilesetControl.useElevation)
{
EditorGUI.BeginChangeCheck();
tilesetControl.elevationScale = EditorGUILayout.FloatField("Elevation Scale:", tilesetControl.elevationScale);
if (EditorGUI.EndChangeCheck() && EditorApplication.isPlaying) OnlineMaps.instance.Redraw();
if (tilesetControl.elevationZoomRange == null) tilesetControl.elevationZoomRange = new OnlineMapsRange(11, 20);
float min = tilesetControl.elevationZoomRange.min;
float max = tilesetControl.elevationZoomRange.max;
EditorGUILayout.MinMaxSlider(new GUIContent(string.Format("Zoom ({0}-{1}): ", min, max)), ref min, ref max, 3, 20);
tilesetControl.elevationZoomRange.min = Mathf.Clamp(Mathf.RoundToInt(min), 3, 20);
tilesetControl.elevationZoomRange.max = Mathf.Clamp(Mathf.RoundToInt(max), 3, 20);
tilesetControl.bingAPI = EditorGUILayout.TextField("Bing Maps API key:", tilesetControl.bingAPI);
if (GUILayout.Button("Create Bing Maps API Key"))
Process.Start("http://msdn.microsoft.com/en-us/library/ff428642.aspx");
}
if (useElevation) EditorGUILayout.EndVertical();
}
protected bool InitMesh(OnlineMapsTileSetControl control, string name, Color borderColor, Color backgroundColor = default(Color), Texture borderTexture = null, Texture backgroundTexture = null)
{
if (mesh != null)
{
return(false);
}
gameObject = new GameObject(name);
gameObject.transform.parent = control.drawingsGameObject.transform;
gameObject.transform.localPosition = Vector3.zero;
gameObject.transform.localRotation = Quaternion.Euler(Vector3.zero);
MeshFilter meshFilter = gameObject.AddComponent <MeshFilter>();
MeshRenderer renderer = gameObject.AddComponent <MeshRenderer>();
mesh = new Mesh {
name = name
};
meshFilter.mesh = mesh;
renderer.materials = new Material[backgroundColor != default(Color)?2: 1];
Shader shader = control.drawingShader;
renderer.materials[0] = new Material(shader);
renderer.materials[0].shader = shader;
renderer.materials[0].color = borderColor;
renderer.materials[0].mainTexture = borderTexture;
if (backgroundColor != default(Color))
{
renderer.materials[1] = new Material(shader);
renderer.materials[1].shader = shader;
renderer.materials[1].color = backgroundColor;
renderer.materials[1].mainTexture = backgroundTexture;
}
return(true);
}
public override void DrawOnTileset(OnlineMapsTileSetControl control, int index)
{
base.DrawOnTileset(control, index);
if (!visible)
{
active = false;
return;
}
active = true;
InitMesh(control, "Line", color, default(Color), texture);
InitLineMesh(points, control, ref vertices, ref normals, ref triangles, ref uv, width);
mesh.Clear();
#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);
UpdateMaterialsQuote(control, index);
}
private bool HitTest()
{
RaycastHit hit;
OnlineMapsTileSetControl control = OnlineMapsTileSetControl.instance;
return(buildingCollider.Raycast(control.activeCamera.ScreenPointToRay(control.GetInputPosition()), out hit, OnlineMapsUtils.maxRaycastDistance));
}
private void Start()
{
StartCoroutine(changeFramerate());
ForceLandscapeLeft();
if ((!LocalizationSupport.StringsLoaded))
{
LocalizationSupport.LoadStrings();
}
HideDownloading();
control = (OnlineMapsTileSetControl)OnlineMapsControlBase.instance;
api = OnlineMaps.instance;
map = OnlineMaps.instance;
OnlineMapsControlBase3D control2 = GetComponent <OnlineMapsControlBase3D>();
if (control2 == null)
{
Debug.Log("You must use the 3D control (Texture or Tileset).");
return;
}
m_ButtonReset.SetActive(false);
//OnlineMapsControlBase.instance.allowUserControl = false;//true;//false;
// OnlineMaps.instance.OnChangeZoom += OnChangeZoom;
OnlineMapsTile.OnTileDownloaded += OnTileDownloaded;
OnlineMaps.instance.OnStartDownloadTile += OnStartDownloadTile;
control2.OnMapPress += OnMapPress;
control2.OnMapRelease += OnMapRelease;
control2.OnMapZoom += OnMapZoom;
//----------------
// Set 2d mode
Camera c = Camera.main;
c.orthographic = true;
//---------------
/* control2.setUpdateControl (true);
* control2.setAlwaysUpdateControl (true);
* control2.allowUserControl = true;
*/
m_ButtonBack.GetComponentInChildren <UnityEngine.UI.Text>().text = LocalizationSupport.GetString("Back");
m_ButtonNext.GetComponentInChildren <UnityEngine.UI.Text>().text = LocalizationSupport.GetString("BtnDownload");
m_ExplanationText.GetComponent <UnityEngine.UI.Text>().text = LocalizationSupport.GetString("ExplanationOfflineAccess");
m_DownloadBtnStart.GetComponentInChildren <UnityEngine.UI.Text>().text = LocalizationSupport.GetString("BtnDownloadNow");
m_DownloadBtnCompleted.GetComponentInChildren <UnityEngine.UI.Text>().text = LocalizationSupport.GetString("Ok");
m_ButtonNext.SetActive(false);
//OnLocationChanged (new Vector2 (0.0f, 0.0f));
toUserLocation();
}
public MapMarker()
{
OnlineMapsControlBase.instance.OnMapClick += OnMapClick;
OnlineMaps.instance.OnChangePosition += showClusters;
OnlineMaps.instance.OnChangeZoom += OnMapUpdateZoom;
control = OnlineMapsTileSetControl.instance;
//canvas = container.GetComponentInParent<Canvas>();
}
private void Start()
{
map = OnlineMaps.instance;
control = OnlineMapsTileSetControl.instance;
control.OnMapClick += OnMapClick;
map.GetPosition(out lng, out lat);
marker = OnlineMapsMarker3DManager.CreateItem(lng, lat, prefab);
marker.scale = markerScale;
marker.rotationY = rotation;
}
private void Start()
{
// Get Tileset control.
control = OnlineMapsControlBase.instance as OnlineMapsTileSetControl;
if (control == null)
{
Debug.LogError("You must use the Tileset control.");
return;
}
// Intercept elevation request
control.OnGetElevation += OnGetElevation;
}
private void Start()
{
// Get Tileset control.
control = OnlineMapsControlBase.instance as OnlineMapsTileSetControl;
if (control == null)
{
Debug.LogError("You must use the Tileset control.");
return;
}
// Intercept elevation request
OnlineMapsElevationManagerBase.instance.OnGetElevation += OnGetElevation;
}
protected bool InitMesh(OnlineMapsTileSetControl control, Color borderColor, Color backgroundColor = default(Color), Texture borderTexture = null, Texture backgroundTexture = null)
{
if (mesh != null)
{
materials[0].color = borderColor;
if (backgroundColor != default(Color))
{
materials[1].color = backgroundColor;
}
return(false);
}
gameObject = new GameObject(name);
gameObject.transform.parent = control.drawingsGameObject.transform;
gameObject.transform.localPosition = Vector3.zero;
gameObject.transform.localRotation = Quaternion.Euler(Vector3.zero);
gameObject.transform.localScale = Vector3.one;
gameObject.layer = control.drawingsGameObject.layer;
MeshFilter meshFilter = gameObject.AddComponent <MeshFilter>();
MeshRenderer renderer = gameObject.AddComponent <MeshRenderer>();
mesh = new Mesh {
name = name
};
meshFilter.mesh = mesh;
materials = new Material[backgroundColor != default(Color)?2: 1];
Shader shader = control.drawingShader;
Material borderMaterial = materials[0] = new Material(shader);
borderMaterial.shader = shader;
borderMaterial.color = borderColor;
borderMaterial.mainTexture = borderTexture;
if (backgroundColor != default(Color))
{
Material backgroundMaterial = materials[1] = new Material(shader);
backgroundMaterial.shader = shader;
backgroundMaterial.color = backgroundColor;
backgroundMaterial.mainTexture = backgroundTexture;
}
renderer.materials = materials;
for (int i = 0; i < materials.Length; i++)
{
materials[i].renderQueue = shader.renderQueue + renderQueueOffset;
}
return(true);
}
// Use this for initialization
private void Start()
{
// Gets Tileset control instance
OnlineMapsTileSetControl control = OnlineMapsTileSetControl.instance;
if (control == null)
{
Debug.LogError("You must use the Tileset control.");
return;
}
// Subscribe to change material event.
control.OnChangeMaterialTexture += OnChangeMaterialTexture;
}
private static void LoadControl(OnlineMapsXML el, OnlineMaps api)
{
OnlineMapsControlBase control = api.GetComponent <OnlineMapsControlBase>();
if (control == null)
{
return;
}
control.allowAddMarkerByM = el.Get <bool>("AllowAddMarkerByM");
control.allowZoom = el.Get <bool>("AllowZoom");
control.allowUserControl = el.Get <bool>("AllowUserControl");
control.zoomInOnDoubleClick = el.Get <bool>("ZoomInOnDoubleClick");
if (control is OnlineMapsControlBase3D)
{
OnlineMapsControlBase3D control3D = control as OnlineMapsControlBase3D;
control3D.allowAddMarker3DByN = el.Get <bool>("AllowAddMarker3DByN");
control3D.allowCameraControl = el.Get <bool>("AllowCameraControl");
control3D.marker2DMode = (OnlineMapsMarker2DMode)el.Get <int>("Marker2DMode");
control3D.marker2DSize = el.Get <float>("Marker2DSize");
control3D.marker3DScale = el.Get <float>("Marker3DScale");
control3D.activeCamera = GetObject(el.Get <int>("Camera")) as Camera;
if (control3D.allowCameraControl)
{
control3D.cameraDistance = el.Get <float>("CameraDistance");
control3D.cameraRotation = el.Get <Vector2>("CameraRotation");
control3D.cameraSpeed = el.Get <Vector2>("CameraSpeed");
}
}
if (control is OnlineMapsTileSetControl)
{
OnlineMapsTileSetControl ts = control as OnlineMapsTileSetControl;
ts.checkMarker2DVisibility = (OnlineMapsTilesetCheckMarker2DVisibility)el.Get <int>("CheckMarker2DVisibility");
ts.smoothZoom = el.Get <bool>("SmoothZoom");
ts.useElevation = el.Get <bool>("UseElevation");
ts.tileMaterial = GetObject(el.Get <int>("TileMaterial")) as Material;
ts.tilesetShader = GetObject(el.Get <int>("TileShader")) as Shader;
ts.drawingShader = GetObject(el.Get <int>("DrawingShader")) as Shader;
ts.markerMaterial = GetObject(el.Get <int>("MarkerMaterial")) as Material;
ts.markerShader = GetObject(el.Get <int>("MarkerShader")) as Shader;
}
}
private void Start()
{
if (map == null)
{
map = OnlineMaps.instance;
}
control = map.control as OnlineMapsTileSetControl;
control.OnGetInputPosition += OnGetInputPosition;
control.OnGetMultitouchInputPositions += OnGetMultitouchInputPositions;
control.OnGetTouchCount += OnGetTouchCount;
map.notInteractUnderGUI = false;
control.checkScreenSizeForWheelZoom = false;
OnlineMapsGUITooltipDrawer.OnDrawTooltip += OnDrawTooltip;
}
private void Start()
{
// Set a reference to the map and control
map = OnlineMaps.instance;
control = OnlineMapsTileSetControl.instance;
// Disable the movement and zoom of the map with the mouse
control.allowUserControl = false;
control.allowZoom = false;
// Subscribe to change zoom event
map.OnChangeZoom += OnChangeZoom;
// Store tile position of the center of the map
map.GetTilePosition(out tx, out ty);
// Initial update the map
UpdateMap();
}
private void Start()
{
map = OnlineMaps.instance;
control = OnlineMapsTileSetControl.instance;
elevationManager = OnlineMapsElevationManagerBase.instance;
double tlx, tly, brx, bry;
map.GetCorners(out tlx, out tly, out brx, out bry);
Vector3 position = control.GetWorldPosition(map.position);
position.y = altitude;
if (elevationManager != null)
{
position.y *= OnlineMapsElevationManagerBase.GetBestElevationYScale(tlx, tly, brx, bry) * elevationManager.scale;
}
gameObject.transform.position = position;
map.GetPosition(out px, out py);
}
private void Start()
{
if (zoomOffset <= 0)
{
throw new Exception("Zoom offset should be positive.");
}
if (shader == null)
{
shader = Shader.Find("Diffuse");
}
map = OnlineMaps.instance;
control = OnlineMapsTileSetControl.instance;
OnlineMapsTile.OnTileDownloaded += OnTileDownloaded;
if (OnlineMapsCache.instance != null)
{
OnlineMapsCache.instance.OnLoadedFromCache += OnTileDownloaded;
}
map.OnMapUpdated += UpdateMesh;
InitMesh();
}
public override void DrawOnTileset(OnlineMapsTileSetControl control)
{
base.DrawOnTileset(control);
if (!visible)
{
active = false;
return;
}
InitMesh(control, "Line", color, default(Color), texture);
List<Vector3> verticles;
List<Vector3> normals;
List<int> triangles;
List<Vector2> uv;
InitLineMesh(points, control, out verticles, out normals, out triangles, out uv, weight);
mesh.Clear();
mesh.vertices = verticles.ToArray();
mesh.normals = normals.ToArray();
mesh.uv = uv.ToArray();
mesh.SetTriangles(triangles.ToArray(), 0);
}
/// <summary>
/// This method is called when the script starts
/// </summary>
private void Start()
{
// Save the reference to control
control = OnlineMapsTileSetControl.instance;
// Subscribe to update mesh event
control.OnMeshUpdated += UpdateSides;
// Create a new GameObject for baseboards
GameObject sidesContainer = new GameObject("Sides");
sidesContainer.transform.parent = control.transform;
sidesContainer.transform.localPosition = Vector3.zero;
sidesContainer.transform.localScale = Vector3.one;
sidesContainer.transform.localRotation = Quaternion.Euler(Vector3.zero);
MeshFilter meshFilter = sidesContainer.AddComponent <MeshFilter>();
MeshRenderer meshRenderer = sidesContainer.AddComponent <MeshRenderer>();
// Create the baseboard mesh
mesh = new Mesh();
mesh.MarkDynamic();
// Initialize baseboard materials
if (!closeBottom)
{
meshRenderer.sharedMaterial = sideMaterial;
}
else
{
meshRenderer.sharedMaterials = new[] { sideMaterial, bottomMaterial };
mesh.subMeshCount = 2;
}
meshFilter.sharedMesh = mesh;
meshRenderer.material = sideMaterial;
}
private void OnEnable()
{
control = (OnlineMapsControlBase3D)target;
tilesetControl = (OnlineMapsTileSetControl)control;
defaultTilesetShader = Shader.Find("Infinity Code/Online Maps/Tileset");
}
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);
}
void Start ()
{
control = (OnlineMapsTileSetControl) OnlineMapsControlBase.instance;
control.OnGetElevation += OnGetElevation;
}
private void CreateMap()
{
OnlineMaps map = CreateMapGameObject();
GameObject go = map.gameObject;
if (use3DControl == 0)
{
Texture2D texture = CreateTexture(map);
if (mapControl2D == 0)
{
go.AddComponent <OnlineMapsGUITextureControl>();
GUITexture guiTexture = go.GetComponent <GUITexture>();
guiTexture.texture = texture;
go.transform.localPosition = new Vector3(0.5f, 0.5f);
go.transform.localScale = Vector3.zero;
guiTexture.pixelInset = new Rect(textureWidth / -2, textureHeight / -2, textureWidth, textureHeight);
}
else if (mapControl2D == 1)
{
go.AddComponent <OnlineMapsSpriteRendererControl>();
SpriteRenderer spriteRenderer = go.GetComponent <SpriteRenderer>();
spriteRenderer.sprite = Sprite.Create(texture, new Rect(0, 0, textureWidth, textureHeight), Vector2.zero);
go.AddComponent <BoxCollider>();
}
#if !UNITY_4_3 && !UNITY_4_5
else if (mapControl2D == 2 || mapControl2D == 3)
{
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 (mapControl2D == 2)
{
go.AddComponent <OnlineMapsUIImageControl>();
Image image = go.AddComponent <Image>();
image.sprite = Sprite.Create(texture, new Rect(0, 0, textureWidth, textureHeight), Vector2.zero);
}
else
{
go.AddComponent <OnlineMapsUIRawImageControl>();
RawImage image = go.AddComponent <RawImage>();
image.texture = texture;
}
}
#endif
#if NGUI
else if (mapControl2D == 4)
{
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);
go.AddComponent <OnlineMapsNGUITextureControl>();
}
#endif
#if DFGUI
else if (mapControl2D == 5)
{
go.transform.parent = DFGUIParent.transform;
dfTextureSprite textureSprite = go.AddComponent <dfTextureSprite>();
textureSprite.Texture = texture;
textureSprite.Width = textureWidth;
textureSprite.Height = textureHeight;
textureSprite.Pivot = dfPivotPoint.MiddleCenter;
textureSprite.transform.localPosition = Vector3.zero;
go.AddComponent <OnlineMapsDFGUITextureControl>();
}
#endif
#if IGUI
else if (mapControl2D == 6)
{
go.transform.parent = IGUIParent.transform;
iGUIImage image = go.AddComponent <iGUIImage>();
image.image = texture;
image.positionAndSize = new Rect(0, 0, 1, 1);
go.AddComponent <OnlineMapsIGUITextureControl>();
}
#endif
map.useSmartTexture = smartTexture;
map.redrawOnPlay = true;
}
else
{
OnlineMapsControlBase3D control3D = null;
if (mapControl3D == 0)
{
map.target = OnlineMapsTarget.tileset;
map.tilesetWidth = tilesetWidth;
map.tilesetHeight = tilesetHeight;
map.tilesetSize = tilesetSize;
OnlineMapsTileSetControl ts = go.AddComponent <OnlineMapsTileSetControl>();
control3D = ts;
ts.useElevation = useElevation;
ts.bingAPI = bingAPI;
ts.smoothZoom = smoothZoom;
ts.tileMaterial = tileMaterial;
ts.markerMaterial = markerMaterial;
ts.tilesetShader = tilesetShader;
ts.drawingShader = drawingShader;
ts.markerShader = markerShader;
if (moveCameraToTileset)
{
GameObject cameraGO = activeCamera.gameObject;
float minSide = Mathf.Min(tilesetSize.x, tilesetSize.y);
Vector3 position = new Vector3(tilesetSize.x / -2, minSide, tilesetSize.y / 2);
cameraGO.transform.position = position;
cameraGO.transform.rotation = Quaternion.Euler(90, 180, 0);
}
if (useBuildings)
{
go.AddComponent <OnlineMapsBuildings>();
}
}
else if (mapControl3D == 1)
{
control3D = go.AddComponent <OnlineMapsTextureControl>();
map.useSmartTexture = smartTexture;
map.redrawOnPlay = true;
}
if (control3D != null)
{
control3D.activeCamera = activeCamera;
control3D.allowCameraControl = allowCameraControl;
}
}
if (useLocationService)
{
go.AddComponent <OnlineMapsLocationService>();
}
if (useRWT)
{
go.AddComponent <OnlineMapsRWTConnector>();
}
EditorGUIUtility.PingObject(go);
Selection.activeGameObject = go;
}
private void DrawActivePointsCI3(OnlineMapsTileSetControl control, bool ignoreTop, bool ignoreRight, bool ignoreBottom, List<Vector2> activePoints,
List<Vector2> localPoints, ref List<Vector3> verticles, ref List<Vector3> normals, ref List<int> borderTriangles, ref List<Vector2> uv)
{
int off = 0;
if (ignoreTop) off = 3;
else if (ignoreRight) off = 2;
else if (ignoreBottom) off = 1;
for (int i = 0; i < 2; i++)
{
int ci = i + off;
if (ci > 3) ci -= 4;
activePoints.Add(localPoints[ci]);
}
DrawActivePoints(control, ref activePoints, ref verticles, ref normals, ref borderTriangles, ref uv, borderWeight);
}
public override void DrawOnTileset(OnlineMapsTileSetControl control, int index)
{
base.DrawOnTileset(control, index);
if (!visible)
{
active = false;
return;
}
InitMesh(control, "Poly", borderColor, backgroundColor);
List <Vector3> verticles;
List <Vector3> normals;
List <int> triangles;
List <Vector2> uv;
//int[] fillTriangles = null;
InitLineMesh(points, control, out verticles, out normals, out triangles, out uv, borderWeight, true);
/*if (backgroundColor.a > 0 && verticles.Count >= 12)
* {
* float l1 = 0;
* float l2 = 0;
*
* for (int i = 0; i < verticles.Count / 4 - 1; i++)
* {
* Vector3 p11 = verticles[i * 4];
* Vector3 p12 = verticles[(i + 1) * 4];
*
* Vector3 p21 = verticles[i * 4 + 3];
* Vector3 p22 = verticles[(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>(verticles.Count / 4);
* List<Vector2> internalPoints = new List<Vector2>(verticles.Count / 4);
* for (int i = 0; i < verticles.Count / 4; i++)
* {
* Vector3 p = verticles[i * 4 + off1];
* Vector2 p2 = new Vector2(p.x, p.z);
* if (i > 0)
* {
* if ((lastPoint - p2).magnitude > borderWeight / 2)
* {
* internalIndices.Add(i * 4 + off1);
* internalPoints.Add(p2);
* lastPoint = p2;
* }
* }
* else
* {
* internalIndices.Add(i * 4 + off1);
* internalPoints.Add(p2);
* lastPoint = p2;
* }
* p = verticles[i * 4 + off2];
* p2 = new Vector2(p.x, p.z);
* if ((lastPoint - p2).magnitude > borderWeight / 2)
* {
* internalIndices.Add(i * 4 + off2);
* internalPoints.Add(p2);
* lastPoint = p2;
* }
* }
*
* fillTriangles = OnlineMapsUtils.Triangulate(internalPoints).ToArray();
*
* for (int i = 0; i < fillTriangles.Length; i++) fillTriangles[i] = internalIndices[fillTriangles[i]];
*
* Vector3 side1 = verticles[fillTriangles[1]] - verticles[fillTriangles[0]];
* Vector3 side2 = verticles[fillTriangles[2]] - verticles[fillTriangles[0]];
* Vector3 perp = Vector3.Cross(side1, side2);
*
* bool reversed = perp.y < 0;
* if (reversed) fillTriangles = fillTriangles.Reverse().ToArray();
* }*/
mesh.Clear();
mesh.subMeshCount = 2;
mesh.vertices = verticles.ToArray();
mesh.normals = normals.ToArray();
mesh.uv = uv.ToArray();
mesh.SetTriangles(triangles.ToArray(), 0);
//if (fillTriangles != null) mesh.SetTriangles(fillTriangles.ToArray(), 1);
UpdateMaterialsQuote(control, index);
}
protected bool InitMesh(OnlineMapsTileSetControl control, string name, Color borderColor, Color backgroundColor = default(Color))
{
if (mesh != null) return false;
gameObject = new GameObject(name);
gameObject.transform.parent = control.drawingsGameObject.transform;
gameObject.transform.localPosition = Vector3.zero;
MeshFilter meshFilter = gameObject.AddComponent<MeshFilter>();
MeshRenderer renderer = gameObject.AddComponent<MeshRenderer>();
mesh = new Mesh();
mesh.name = name;
meshFilter.mesh = mesh;
renderer.materials = new Material[backgroundColor != default(Color)?2: 1];
Shader shader = Shader.Find("Transparent/Diffuse");
renderer.materials[0] = new Material(shader);
renderer.materials[0].color = borderColor;
renderer.materials[0].shader = shader;
if (backgroundColor != default(Color))
{
renderer.materials[1] = new Material(shader);
renderer.materials[1].color = backgroundColor;
renderer.materials[1].shader = shader;
}
return true;
}
/// <summary>
/// Draws element on a specified TilesetControl.
/// </summary>
/// <param name="control">Reeference to tileset control.</param>
/// <param name="index">Index of drawing element</param>
public virtual void DrawOnTileset(OnlineMapsTileSetControl control, int index)
{
}
private void Start()
{
control = OnlineMapsTileSetControl.instance;
}
public override void DrawOnTileset(OnlineMapsTileSetControl control)
{
InitMesh(control, "Rect", borderColor, backgroundColor);
List<Vector2> localPoints = GetLocalPoints(points, true);
if (localPoints.All(p => p.x < 0))
{
active = false;
return;
}
if (localPoints.All(p => p.x > api.tilesetSize.x))
{
active = false;
return;
}
if (localPoints.All(p => p.y < 0))
{
active = false;
return;
}
if (localPoints.All(p => p.y > api.tilesetSize.y))
{
active = false;
return;
}
if (!active) active = true;
bool ignoreLeft = false;
bool ignoreRight = false;
bool ignoreTop = false;
bool ignoreBottom = false;
int countIgnore = 0;
for (int i = 0; i < localPoints.Count; i++)
{
Vector2 point = localPoints[i];
if (point.x < 0)
{
point.x = 0;
if (!ignoreLeft) countIgnore++;
ignoreLeft = true;
}
if (point.y < 0)
{
point.y = 0;
if (!ignoreTop) countIgnore++;
ignoreTop = true;
}
if (point.x > api.tilesetSize.x)
{
point.x = api.tilesetSize.x;
if (!ignoreRight) countIgnore++;
ignoreRight = true;
}
if (point.y > api.tilesetSize.y)
{
point.y = api.tilesetSize.y;
if (!ignoreBottom) countIgnore++;
ignoreBottom = true;
}
localPoints[i] = point;
}
List<Vector3> verticles = new List<Vector3>();
List<Vector3> normals = new List<Vector3>();
List<int> backTriangles = new List<int>();
List<int> borderTriangles = new List<int>();
List<Vector2> uv = new List<Vector2>();
verticles.Add(new Vector3(-localPoints[0].x, -0.05f, localPoints[0].y));
verticles.Add(new Vector3(-localPoints[1].x, -0.05f, localPoints[1].y));
verticles.Add(new Vector3(-localPoints[2].x, -0.05f, localPoints[2].y));
verticles.Add(new Vector3(-localPoints[3].x, -0.05f, localPoints[3].y));
if (!ignoreTop)
{
verticles[2] += new Vector3(0, 0, borderWeight);
verticles[3] += new Vector3(0, 0, borderWeight);
}
if (!ignoreBottom)
{
verticles[0] -= new Vector3(0, 0, borderWeight);
verticles[1] -= new Vector3(0, 0, borderWeight);
}
if (!ignoreLeft)
{
verticles[0] -= new Vector3(borderWeight, 0, 0);
verticles[3] -= new Vector3(borderWeight, 0, 0);
}
if (!ignoreRight)
{
verticles[1] += new Vector3(borderWeight, 0, 0);
verticles[2] += new Vector3(borderWeight, 0, 0);
}
normals.Add(Vector3.up);
normals.Add(Vector3.up);
normals.Add(Vector3.up);
normals.Add(Vector3.up);
uv.Add(new Vector2(0, 0));
uv.Add(new Vector2(0, 1));
uv.Add(new Vector2(1, 1));
uv.Add(new Vector2(1, 0));
backTriangles.Add(0);
backTriangles.Add(2);
backTriangles.Add(1);
backTriangles.Add(0);
backTriangles.Add(3);
backTriangles.Add(2);
List<Vector2> activePoints = new List<Vector2>();
if (countIgnore == 0)
{
activePoints.Add(localPoints[0] + new Vector2(borderWeight, 0));
activePoints.Add(localPoints[1]);
activePoints.Add(localPoints[2]);
activePoints.Add(localPoints[3]);
activePoints.Add(localPoints[0] + new Vector2(0, borderWeight));
DrawActivePoints(ref activePoints, ref verticles, ref normals, ref borderTriangles, ref uv, borderWeight);
}
else if (countIgnore == 1)
{
int off = 0;
if (ignoreTop) off = 3;
else if (ignoreRight) off = 2;
else if (ignoreBottom) off = 1;
for (int i = 0; i < 4; i++)
{
int ci = i + off;
if (ci > 3) ci -= 4;
activePoints.Add(localPoints[ci]);
}
DrawActivePoints(ref activePoints, ref verticles, ref normals, ref borderTriangles, ref uv, borderWeight);
}
else if (countIgnore == 2)
{
if (ignoreBottom && ignoreTop)
{
activePoints.Add(localPoints[1]);
activePoints.Add(localPoints[2]);
DrawActivePoints(ref activePoints, ref verticles, ref normals, ref borderTriangles, ref uv, borderWeight);
activePoints.Add(localPoints[3]);
activePoints.Add(localPoints[0]);
DrawActivePoints(ref activePoints, ref verticles, ref normals, ref borderTriangles, ref uv, borderWeight);
}
else if (ignoreLeft && ignoreRight)
{
activePoints.Add(localPoints[0]);
activePoints.Add(localPoints[1]);
DrawActivePoints(ref activePoints, ref verticles, ref normals, ref borderTriangles, ref uv, borderWeight);
activePoints.Add(localPoints[2]);
activePoints.Add(localPoints[3]);
DrawActivePoints(ref activePoints, ref verticles, ref normals, ref borderTriangles, ref uv, borderWeight);
}
else
{
int off = 0;
if (ignoreTop) off = 3;
else if (ignoreRight) off = 2;
else if (ignoreBottom) off = 1;
for (int i = 0; i < 3; i++)
{
int ci = i + off;
if (ci > 3) ci -= 4;
activePoints.Add(localPoints[ci]);
}
DrawActivePoints(ref activePoints, ref verticles, ref normals, ref borderTriangles, ref uv, borderWeight);
}
}
else if (countIgnore == 3)
{
int off = 0;
if (ignoreTop) off = 3;
else if (ignoreRight) off = 2;
else if (ignoreBottom) off = 1;
for (int i = 0; i < 2; i++)
{
int ci = i + off;
if (ci > 3) ci -= 4;
activePoints.Add(localPoints[ci]);
}
DrawActivePoints(ref activePoints, ref verticles, ref normals, ref borderTriangles, ref uv, borderWeight);
}
mesh.Clear();
mesh.vertices = verticles.ToArray();
mesh.normals = normals.ToArray();
mesh.uv = uv.ToArray();
mesh.subMeshCount = 2;
mesh.SetTriangles(borderTriangles.ToArray(), 0);
mesh.SetTriangles(backTriangles.ToArray(), 1);
}
/// <summary>
/// Draws element on a specified TilesetControl.
/// </summary>
/// <param name="control"></param>
public virtual void DrawOnTileset(OnlineMapsTileSetControl control)
{
}
public override void DrawOnTileset(OnlineMapsTileSetControl control)
{
base.DrawOnTileset(control);
if (!visible)
{
active = false;
return;
}
InitMesh(control, "Poly", borderColor, backgroundColor);
List<Vector3> verticles;
List<Vector3> normals;
List<int> triangles;
List<Vector2> uv;
InitLineMesh(points, control, out verticles, out normals, out triangles, out uv, borderWeight, true);
mesh.Clear();
mesh.subMeshCount = 2;
mesh.vertices = verticles.ToArray();
mesh.normals = normals.ToArray();
mesh.uv = uv.ToArray();
mesh.SetTriangles(triangles.ToArray(), 0);
}
protected void DrawActivePoints(OnlineMapsTileSetControl control, ref List<Vector2> activePoints, ref List<Vector3> verticles, ref List<Vector3> normals, ref List<int> triangles, ref List<Vector2> uv, float weight)
{
if (activePoints.Count < 2)
{
activePoints.Clear();
return;
}
List<Vector3> side1 = new List<Vector3>();
List<Vector3> side2 = new List<Vector3>();
for (int i = 0; i < activePoints.Count; i++)
{
Vector3 p = new Vector3(-activePoints[i].x, 0, activePoints[i].y);
if (i == 0)
{
float a = OnlineMapsUtils.Angle2DRad(p, new Vector3(-activePoints[i + 1].x, 0, activePoints[i + 1].y), 90);
Vector3 off = new Vector3(Mathf.Cos(a) * weight, 0, Mathf.Sin(a) * weight);
Vector3 s1 = p + off;
Vector3 s2 = p - off;
s1.y = control.GetElevationValue(s1.x, s1.z, bestElevationYScale, tlx, tly, brx, bry);
s2.y = control.GetElevationValue(s2.x, s2.z, bestElevationYScale, tlx, tly, brx, bry);
side1.Add(s1);
side2.Add(s2);
}
else if (i == activePoints.Count - 1)
{
float a = OnlineMapsUtils.Angle2DRad(new Vector3(-activePoints[i - 1].x, 0, activePoints[i - 1].y), p, 90);
Vector3 off = new Vector3(Mathf.Cos(a) * weight, 0, Mathf.Sin(a) * weight);
Vector3 s1 = p + off;
Vector3 s2 = p - off;
s1.y = control.GetElevationValue(s1.x, s1.z, bestElevationYScale, tlx, tly, brx, bry);
s2.y = control.GetElevationValue(s2.x, s2.z, bestElevationYScale, tlx, tly, brx, bry);
side1.Add(s1);
side2.Add(s2);
}
else
{
Vector3 p1 = new Vector3(-activePoints[i - 1].x, 0, activePoints[i - 1].y);
Vector3 p2 = new Vector3(-activePoints[i + 1].x, 0, activePoints[i + 1].y);
float a1 = OnlineMapsUtils.Angle2DRad(p1, p, 90);
float a2 = OnlineMapsUtils.Angle2DRad(p, p2, 90);
Vector3 off1 = new Vector3(Mathf.Cos(a1) * weight, 0, Mathf.Sin(a1) * weight);
Vector3 off2 = new Vector3(Mathf.Cos(a2) * weight, 0, Mathf.Sin(a2) * weight);
Vector3 p21 = p + off1;
Vector3 p22 = p - off1;
Vector3 p31 = p + off2;
Vector3 p32 = p - off2;
int state1, state2;
Vector2 is1 = OnlineMapsUtils.GetIntersectionPointOfTwoLines(p1 + off1, p21, p31, p2 + off2, out state1);
Vector2 is2 = OnlineMapsUtils.GetIntersectionPointOfTwoLines(p1 - off1, p22, p32, p2 - off2, out state2);
if (state1 == 1) side1.Add(new Vector3(is1.x, control.GetElevationValue(is1.x, is1.y, bestElevationYScale, tlx, tly, brx, bry), is1.y));
if (state2 == 1) side2.Add(new Vector3(is2.x, control.GetElevationValue(is2.x, is2.y, bestElevationYScale, tlx, tly, brx, bry), is2.y));
}
}
for (int i = 0; i < Mathf.Min(side1.Count, side2.Count) - 1; i++)
{
int ti = verticles.Count;
verticles.Add(side1[i]);
verticles.Add(side1[i + 1]);
verticles.Add(side2[i + 1]);
verticles.Add(side2[i]);
normals.Add(Vector3.up);
normals.Add(Vector3.up);
normals.Add(Vector3.up);
normals.Add(Vector3.up);
uv.Add(new Vector2(0, 0));
uv.Add(new Vector2(0, 1));
uv.Add(new Vector2(1, 1));
uv.Add(new Vector2(1, 0));
triangles.Add(ti);
triangles.Add(ti + 1);
triangles.Add(ti + 2);
triangles.Add(ti);
triangles.Add(ti + 2);
triangles.Add(ti + 3);
}
activePoints.Clear();
}
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);
}
}
protected void InitLineMesh(List<Vector2> points, OnlineMapsTileSetControl control, out List<Vector3> verticles, out List<Vector3> normals, out List<int> triangles, out List<Vector2> uv, float weight, bool closed = false)
{
api.GetTopLeftPosition(out tlx, out tly);
api.GetBottomRightPosition(out brx, out bry);
if (brx < tlx) brx += 360;
List<Vector2> localPoints = GetLocalPoints(points, closed);
List<Vector2> activePoints = new List<Vector2>();
Rect mapRect = new Rect(0, 0, api.tilesetSize.x, api.tilesetSize.y);
Vector2 lastPoint = Vector2.zero;
Vector2 rightTop = new Vector2(api.tilesetSize.x, 0);
Vector2 rightBottom = new Vector2(api.tilesetSize.x, api.tilesetSize.y);
Vector2 leftBottom = new Vector2(0, api.tilesetSize.y);
bestElevationYScale = control.GetBestElevationYScale(tlx, tly, brx, bry);
verticles = new List<Vector3>();
normals = new List<Vector3>();
triangles = new List<int>();
uv = new List<Vector2>();
for (int i = 0; i < localPoints.Count; i++)
{
Vector2 p = localPoints[i];
if (lastPoint != Vector2.zero)
{
Vector2 crossTop, crossLeft, crossBottom, crossRight;
bool hasCrossTop = OnlineMapsUtils.LineIntersection(lastPoint, p, Vector2.zero, rightTop, out crossTop);
bool hasCrossBottom = OnlineMapsUtils.LineIntersection(lastPoint, p, leftBottom, rightBottom, out crossBottom);
bool hasCrossLeft = OnlineMapsUtils.LineIntersection(lastPoint, p, Vector2.zero, leftBottom, out crossLeft);
bool hasCrossRight = OnlineMapsUtils.LineIntersection(lastPoint, p, rightTop, rightBottom, out crossRight);
List<Vector2> intersections = new List<Vector2>();
if (hasCrossTop) intersections.Add(crossTop);
if (hasCrossBottom) intersections.Add(crossBottom);
if (hasCrossLeft) intersections.Add(crossLeft);
if (hasCrossRight) intersections.Add(crossRight);
if (intersections.Count == 1) activePoints.Add(intersections[0]);
else if (intersections.Count == 2)
{
int minIndex = ((lastPoint - intersections[0]).magnitude < (lastPoint - intersections[1]).magnitude)? 0: 1;
activePoints.Add(intersections[minIndex]);
activePoints.Add(intersections[1 - minIndex]);
}
}
if (mapRect.Contains(p)) activePoints.Add(p);
else if (activePoints.Count > 0) DrawActivePoints(control, ref activePoints, ref verticles, ref normals, ref triangles, ref uv, weight);
lastPoint = p;
}
if (activePoints.Count > 0) DrawActivePoints(control, ref activePoints, ref verticles, ref normals, ref triangles, ref uv, weight);
}
public override void DrawOnTileset(OnlineMapsTileSetControl control)
{
InitMesh(control, "Line", color);
List<Vector2> localPoints = GetLocalPoints(points);
List<Vector2> activePoints = new List<Vector2>();
Rect mapRect = new Rect(0, 0, api.tilesetSize.x, api.tilesetSize.y);
Vector2 lastPoint = Vector2.zero;
Vector2 rightTop = new Vector2(api.tilesetSize.x, 0);
Vector2 rightBottom = new Vector2(api.tilesetSize.x, api.tilesetSize.y);
Vector2 leftBottom = new Vector2(0, api.tilesetSize.y);
List<Vector3> verticles = new List<Vector3>();
List<Vector3> normals = new List<Vector3>();
List<int> triangles = new List<int>();
List<Vector2> uv = new List<Vector2>();
for (int i = 0; i < localPoints.Count; i++)
{
Vector2 p = localPoints[i];
if (lastPoint != Vector2.zero)
{
Vector2 crossTop = OnlineMapsUtils.LineIntersection(lastPoint, p, Vector2.zero, rightTop);
Vector2 crossBottom = OnlineMapsUtils.LineIntersection(lastPoint, p, leftBottom, rightBottom);
Vector2 crossLeft = OnlineMapsUtils.LineIntersection(lastPoint, p, Vector2.zero, leftBottom);
Vector2 crossRight = OnlineMapsUtils.LineIntersection(lastPoint, p, rightTop, rightBottom);
List<Vector2> intersections = new List<Vector2>();
if (crossTop != Vector2.zero) intersections.Add(crossTop);
if (crossBottom != Vector2.zero) intersections.Add(crossBottom);
if (crossLeft != Vector2.zero) intersections.Add(crossLeft);
if (crossRight != Vector2.zero) intersections.Add(crossRight);
if (intersections.Count == 1)
{
activePoints.Add(intersections[0]);
}
else if (intersections.Count == 2)
{
int minIndex = ((lastPoint - intersections[0]).magnitude < (lastPoint - intersections[1]).magnitude)?0: 1;
activePoints.Add(intersections[minIndex]);
activePoints.Add(intersections[1 - minIndex]);
}
}
if (mapRect.Contains(p)) activePoints.Add(p);
else if (activePoints.Count > 0) DrawActivePoints(ref activePoints, ref verticles, ref normals, ref triangles, ref uv, weight);
lastPoint = p;
}
if (activePoints.Count > 0) DrawActivePoints(ref activePoints, ref verticles, ref normals, ref triangles, ref uv, weight);
mesh.Clear();
mesh.vertices = verticles.ToArray();
mesh.normals = normals.ToArray();
mesh.uv = uv.ToArray();
mesh.SetTriangles(triangles.ToArray(), 0);
}
private void UpdateMesh()
{
OnlineMapsTileSetControl control = OnlineMapsTileSetControl.instance;
if (tilesetCollider == null)
{
tilesetCollider = control.GetComponent <Collider>();
}
Bounds bounds = tilesetCollider.bounds;
// Clear overlay mesh
overlayMesh.Clear(true);
// Init verticles and normals
float y = bounds.max.y + 0.5f;
overlayMesh.vertices = new[]
{
new Vector3(bounds.min.x, y, bounds.min.z),
new Vector3(bounds.min.x, y, bounds.max.z),
new Vector3(bounds.max.x, y, bounds.max.z),
new Vector3(bounds.max.x, y, bounds.min.z)
};
overlayMesh.normals = new[]
{
Vector3.up,
Vector3.up,
Vector3.up,
Vector3.up
};
// Init overlay UV
OnlineMaps map = OnlineMaps.instance;
double tlx, tly, brx, bry;
map.GetTileCorners(out tlx, out tly, out brx, out bry);
int maxTileCount = 1 << map.zoom;
float uvX1 = (float)(tlx / maxTileCount);
float uvX2 = (float)(brx / maxTileCount);
if (uvX1 > uvX2)
{
uvX2 += 1;
}
float uvY1 = (float)(1 - tly / maxTileCount);
float uvY2 = (float)(1 - bry / maxTileCount);
overlayMesh.uv = new[]
{
new Vector2(uvX2, uvY1),
new Vector2(uvX2, uvY2),
new Vector2(uvX1, uvY2),
new Vector2(uvX1, uvY1)
};
// Init triangles
overlayMesh.SetTriangles(new[]
{
0, 1, 2,
0, 2, 3
}, 0);
overlayMesh.RecalculateBounds();
overlayMesh.RecalculateNormals();
}
protected bool InitMesh(OnlineMapsTileSetControl control, string name, Color borderColor, Color backgroundColor = default(Color), Texture borderTexture = null, Texture backgroundTexture = null)
{
if (mesh != null) return false;
gameObject = new GameObject(name);
gameObject.transform.parent = control.drawingsGameObject.transform;
gameObject.transform.localPosition = Vector3.zero;
gameObject.transform.localRotation = Quaternion.Euler(Vector3.zero);
MeshFilter meshFilter = gameObject.AddComponent<MeshFilter>();
MeshRenderer renderer = gameObject.AddComponent<MeshRenderer>();
mesh = new Mesh {name = name};
meshFilter.mesh = mesh;
renderer.materials = new Material[backgroundColor != default(Color)?2: 1];
Shader shader = control.drawingShader;
renderer.materials[0] = new Material(shader);
renderer.materials[0].shader = shader;
renderer.materials[0].color = borderColor;
renderer.materials[0].mainTexture = borderTexture;
if (backgroundColor != default(Color))
{
renderer.materials[1] = new Material(shader);
renderer.materials[1].shader = shader;
renderer.materials[1].color = backgroundColor;
renderer.materials[1].mainTexture = backgroundTexture;
}
return true;
}
