using System;
using UnityEngine;

namespace InfinityCode.OnlineMapsExamples
{
    /// <summary>
    /// Example of how to make the overlay for the tileset.
    /// </summary>
    [AddComponentMenu("Infinity Code/Online Maps/Examples (API Usage)/TilesetOverlayExample")]
    public class TilesetOverlayExample : MonoBehaviour
    {
        // Overlay texture in mercator projection
        public Texture texture;

        // Overlay transparency
        [Range(0, 1)] public float alpha = 1;

        private Mesh overlayMesh;
        private Material material;
        private Collider tilesetCollider;

        private void Start()
        {
            // Create overlay container
            GameObject overlayContainer = new GameObject("OverlayContainer");
            overlayContainer.transform.parent = transform;

            // Init overlay material
            MeshRenderer meshRenderer = overlayContainer.AddComponent<MeshRenderer>();
            MeshFilter meshFilter = overlayContainer.AddComponent<MeshFilter>();
            material = new Material(Shader.Find("Transparent/Diffuse"));
            material.mainTexture = texture;
            meshRenderer.sharedMaterial = material;

            overlayMesh = meshFilter.sharedMesh = new Mesh();
            overlayMesh.name = "Overlay Mesh";
            overlayMesh.MarkDynamic();
            overlayMesh.vertices = new Vector3[4];

            // Subscribe to events
            OnlineMaps.instance.OnChangePosition += UpdateMesh;
            OnlineMaps.instance.OnChangeZoom += UpdateMesh;

            // Init mesh
            UpdateMesh();
        }

        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 vertices and normals
            Vector2 size = control.sizeInScene;
            Vector3 p1 = new Vector3(-size.x, 0, 0);
            Vector3 p2 = new Vector3(0, 0, size.y);
            float y = 0.5f;
            overlayMesh.vertices = new[]
            {
                new Vector3(p1.x, y, p1.z),
                new Vector3(p1.x, y, p2.z),
                new Vector3(p2.x, y, p2.z),
                new Vector3(p2.x, y, p1.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();
        }

        private void Update()
        {
            if (Math.Abs(material.color.a - alpha) > float.Epsilon)
            {
                Color color = material.color;
                color.a = alpha;
                material.color = color;
            }
        }
    }
}

using System;
using UnityEngine;

public class TilesetOverlayExample2 : MonoBehaviour
{
    // Overlay texture in mercator projection
    public Texture texture;

    /// <summary>
    /// Border coordinates of the overlay
    /// </summary>
    public double leftLongitude;
    public double topLatitude;
    public double rightLongitude;
    public double bottomLatitude;

    // Overlay transparency
    [Range(0, 1)]
    public float alpha = 1;

    private Mesh overlayMesh;
    private Material material;

    private void Start()
    {
        // Create overlay container
        GameObject overlayContainer = new GameObject("OverlayContainer");
        overlayContainer.transform.parent = transform;

        // Init overlay material
        MeshRenderer meshRenderer = overlayContainer.AddComponent<MeshRenderer>();
        MeshFilter meshFilter = overlayContainer.AddComponent<MeshFilter>();
        material = new Material(Shader.Find("Transparent/Diffuse"));
        material.mainTexture = texture;
        material.renderQueue += 1000;
        meshRenderer.sharedMaterial = material;

        overlayMesh = meshFilter.sharedMesh = new Mesh();
        overlayMesh.name = "Overlay Mesh";
        overlayMesh.MarkDynamic();
        overlayMesh.vertices = new Vector3[4];

        // Subscribe to events
        OnlineMapsTileSetControl.instance.OnMeshUpdated += UpdateMesh;

        // Init mesh
        UpdateMesh();
    }

    private void UpdateMesh()
    {
        overlayMesh.Clear();
        OnlineMapsTileSetControl control = OnlineMapsTileSetControl.instance;

        Vector3 p1 = control.GetWorldPosition(leftLongitude, topLatitude);
        Vector3 p2 = control.GetWorldPosition(rightLongitude, bottomLatitude);

        Vector2 size = control.sizeInScene;
        size.x *= -1;

        if (p1.x > 0 && p2.x > 0) return;
        if (p1.x < size.x && p2.x < size.x) return;
        if (p1.z < 0 && p2.z < 0) return;
        if (p1.z > size.y && p2.z > size.y) return;

        Vector2 uv0 = new Vector2(0, 1);
        Vector2 uv1 = new Vector2(1, 0);

        Vector3 v1 = p1;
        Vector3 v2 = p2;

        if (p1.x > 0)
        {
            float m = p1.x / (p1.x - p2.x);
            uv0.x = m;
            v1.x = 0;
        }

        if (p1.z < 0)
        {
            float m = p1.z / (p1.z - p2.z);
            uv0.y = 1 - m;
            v1.z = 0;
        }

        if (p2.x < size.x)
        {
            float m = (p1.x - size.x) / (p1.x - p2.x);
            uv1.x = m;
            v2.x = size.x;
        }

        if (p2.z > size.y)
        {
            float m = (size.y - p2.z) / (p1.z - p2.z);
            uv1.y = m;
            v2.z = size.y;
        }

        overlayMesh.vertices = new[]
        {
            new Vector3(v1.x, 0.1f, v1.z),
            new Vector3(v2.x, 0.1f, v1.z),
            new Vector3(v2.x, 0.1f, v2.z),
            new Vector3(v1.x, 0.1f, v2.z),
        };

        overlayMesh.normals = new[]
        {
            Vector3.up,
            Vector3.up,
            Vector3.up,
            Vector3.up
        };

        overlayMesh.uv = new[]
        {
            uv0,
            new Vector2(uv1.x, uv0.y), 
            uv1, 
            new Vector2(uv0.x, uv1.y), 
        };

        // Init triangles
        overlayMesh.SetTriangles(new[]
        {
            0, 1, 2,
            0, 2, 3
        }, 0);

        overlayMesh.RecalculateBounds();
        overlayMesh.RecalculateNormals();
    }

    private void Update()
    {
        if (Math.Abs(material.color.a - alpha) > float.Epsilon)
        {
            Color color = material.color;
            color.a = alpha;
            material.color = color;
        }
    }
}