/*         INFINITY CODE         */
/*   https://infinity-code.com   */

using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Net;
using System.Text;
using System.Xml;
using InfinityCode.RealWorldTerrain;
using InfinityCode.RealWorldTerrain.Generators;
using InfinityCode.RealWorldTerrain.Windows;
using UnityEditor;
using UnityEngine;

namespace InfinityCode.RealWorldTerrainExamples
{
    public class UsingGoogleElevationsExample : EditorWindow
    {
        public string googleAPIKey = "";
        public int rows = 22;
        public int cols = 22;

        public double leftLongitude = 37.6188;
        public double topLatitude = 55.7517;
        public double rightLongitude = 37.6528;
        public double bottomLatitude = 55.7291;
        
        private double mx1;
        private double my1;
        private double mx2;
        private double my2;

        private static double[,] elevations;

        private void DownloadElevations()
        {
            RealWorldTerrainUtils.LatLongToMercat(leftLongitude, topLatitude, out mx1, out my1);
            RealWorldTerrainUtils.LatLongToMercat(rightLongitude, bottomLatitude, out mx2, out my2);
            
            double dx = (mx2 - mx1) / (cols - 1);
            double dy = (my2 - my1) / (rows - 1);
            
            elevations = new double[rows, cols];
            List<Tuple<int, double, double>> points = new List<Tuple<int, double, double>>(512);

            for (int y = 0; y < rows; y++)
            {
                double my = my1 + dy * y;
                for (int x = 0; x < cols; x++)
                {
                    double mx = mx1 + dx * x;
                    double lng, lat;
                    RealWorldTerrainUtils.MercatToLatLong(mx, my, out lng, out lat);
                    int index = y * cols + x;
                    points.Add(new Tuple<int, double, double> (index, lng, lat));
                    if (points.Count == 512)
                    {
                        if (!DownloadElevations(points))
                        {
                            return;
                        }
                        
                        points.Clear();
                    }
                }
            }

            if (points.Count > 0)
            {
                if (!DownloadElevations(points))
                {
                    return;
                }
            }
            
            byte[] bytes = new byte[rows * cols * 8];
            int i = 0;
            foreach (double el in elevations)
            {
                byte[] elBytes = BitConverter.GetBytes(el);
                Array.Copy(elBytes, 0, bytes, i, 8);
                i += 8;
            }
            
            File.WriteAllBytes(GetFilename(), bytes);
            
            EditorUtility.DisplayDialog("Success", "Elevations downloaded", "OK");
        }

        private bool DownloadElevations(List<Tuple<int, double, double>> points)
        {
            string polyline = EncodePolyline(points);
            string url = $"https://maps.googleapis.com/maps/api/elevation/xml?locations=enc:{polyline}&key={googleAPIKey}";
            
            WebClient client = new WebClient();
            string response = client.DownloadString(url);
            
            XmlDocument xml = new XmlDocument();
            xml.LoadXml(response);
            
            // Check for error
            XmlNode statusNode = xml.SelectSingleNode("//status");
            if (statusNode != null && statusNode.InnerText != "OK")
            {
                XmlNode errorNode = xml.SelectSingleNode("//error_message");
                EditorUtility.DisplayDialog("Error", errorNode.InnerText, "OK");
                return false;
            }

            int index = 0;
            XmlNodeList results = xml.SelectNodes("//result");
            foreach (XmlNode result in results)
            {
                string text = result.SelectSingleNode("elevation").InnerText;
                double elevation = double.Parse(text, CultureInfo.InvariantCulture);
                int i = points[index].Item1;
                elevations[i / cols, i % cols] = elevation;
                index++;
            }

            return true;
        }
        
        public static string EncodePolyline(List<Tuple<int, double, double>> points)
        {
            List<int> encodedPoints = new List<int>();

            int prevLat = 0, prevLng = 0;

            foreach (var point in points)
            {
                int lat = (int)Math.Round(point.Item3 * 1e5);
                int lng = (int)Math.Round(point.Item2 * 1e5);

                int dLat = lat - prevLat;
                int dLng = lng - prevLng;

                prevLat = lat;
                prevLng = lng;

                encodedPoints.Add(EncodeValue(dLat));
                encodedPoints.Add(EncodeValue(dLng));
            }

            StringBuilder encodedPolyline = new StringBuilder();

            foreach (int value in encodedPoints)
            {
                encodedPolyline.Append(EncodeSignedNumber(value));
            }

            return encodedPolyline.ToString();
        }

        private static string EncodeSignedNumber(int num)
        {
            StringBuilder encoded = new StringBuilder();

            while (num >= 0x20)
            {
                encoded.Append((char)((0x20 | (num & 0x1f)) + 63));
                num >>= 5;
            }

            encoded.Append((char)(num + 63));

            return encoded.ToString();
        }

        private static int EncodeValue(int value)
        {
            value = value < 0 ? ~(value << 1) : (value << 1);
            return value;
        }

        private string GetFilename()
        {
            return Path.Combine(RealWorldTerrainEditorUtils.heightmapCacheFolder, $"google_{leftLongitude}_{topLatitude}_{rightLongitude}_{bottomLatitude}_{rows}_{cols}.raw");
        }

        private bool HasElevations()
        {
            return File.Exists(GetFilename());
        }

        private void LoadElevations()
        {
            if (!HasElevations()) return;
            byte[] bytes = File.ReadAllBytes(GetFilename());
            elevations = new double[rows, cols];
            int i = 0;
            for (int y = 0; y < rows; y++)
            {
                for (int x = 0; x < cols; x++)
                {
                    elevations[y, x] = BitConverter.ToDouble(bytes, i);
                    i += 8;
                }
            }
            
            RealWorldTerrainUtils.LatLongToMercat(leftLongitude, topLatitude, out mx1, out my1);
            RealWorldTerrainUtils.LatLongToMercat(rightLongitude, bottomLatitude, out mx2, out my2);
        }
        
        private void OnDestroy()
        {
            RealWorldTerrainElevationGenerator.OnGetElevation -= OnGetElevation;
            RealWorldTerrainElevationGenerator.OnGetElevationRange -= OnGetElevationRange;
        }

        private void OnGUI()
        {
            googleAPIKey = EditorGUILayout.TextField("Google API Key: ", googleAPIKey);
            leftLongitude = EditorGUILayout.DoubleField("Left Longitude: ", leftLongitude);
            topLatitude = EditorGUILayout.DoubleField("Top Latitude: ", topLatitude);
            rightLongitude = EditorGUILayout.DoubleField("Right Longitude: ", rightLongitude);
            bottomLatitude = EditorGUILayout.DoubleField("Bottom Latitude: ", bottomLatitude);
            rows = EditorGUILayout.IntField("Rows: ", rows);
            cols = EditorGUILayout.IntField("Cols: ", cols);
            
            EditorGUILayout.HelpBox($"Number of requests: {Mathf.CeilToInt(rows * cols / 512f)}", MessageType.Info);

            if (GUILayout.Button("1. Get Area From Real World Terrain"))
            {
                if (RealWorldTerrainWindow.wnd == null) RealWorldTerrainWindow.OpenWindow(RealWorldTerrainGenerateType.full);
                
                RealWorldTerrainPrefs prefs = RealWorldTerrainWindow.prefs;
                leftLongitude = prefs.leftLongitude;
                topLatitude = prefs.topLatitude;
                rightLongitude = prefs.rightLongitude;
                bottomLatitude = prefs.bottomLatitude;
            }
            
            if (GUILayout.Button("2. Download elevations"))
            {
                DownloadElevations();
            }
            
            if (GUILayout.Button("3. Intercept Getting Elevations"))
            {
                if (!HasElevations())
                {
                    EditorUtility.DisplayDialog("Error", "Elevations not downloaded", "OK");
                }
                else
                {
                    LoadElevations();
                    RealWorldTerrainElevationGenerator.OnGetElevation -= OnGetElevation;
                    RealWorldTerrainElevationGenerator.OnGetElevation += OnGetElevation;
                    RealWorldTerrainElevationGenerator.OnGetElevationRange -= OnGetElevationRange;
                    RealWorldTerrainElevationGenerator.OnGetElevationRange += OnGetElevationRange;
                }
            }
            
            EditorGUILayout.HelpBox("4. Start Generation Using Real World Terrain Window", MessageType.Info);
            
            if (GUILayout.Button("5. Release Getting Elevations"))
            {
                RealWorldTerrainElevationGenerator.OnGetElevation -= OnGetElevation;
                RealWorldTerrainElevationGenerator.OnGetElevationRange -= OnGetElevationRange;
            }
        }

        private double? OnGetElevation(double mx, double my)
        {
            if (mx < mx1 || mx > mx2 || my < my1 || my > my2) return null;
            double x = (mx - mx1) / (mx2 - mx1) * (elevations.GetLength(1) - 1);
            double y = (my - my1) / (my2 - my1) * (elevations.GetLength(0) - 1);
            int x1 = (int) x;
            int y1 = (int) y;
            int x2 = x1 + 1;
            int y2 = y1 + 1;
            
            if (x2 >= elevations.GetLength(1)) x2 = elevations.GetLength(1) - 1;
            if (y2 >= elevations.GetLength(0)) y2 = elevations.GetLength(0) - 1;
            
            double dx = x - x1;
            double dy = y - y1;
            double el1 = elevations[y1, x1];
            double el2 = elevations[y1, x2];
            double el3 = elevations[y2, x1];
            double el4 = elevations[y2, x2];
            double el = el1 * (1 - dx) * (1 - dy) + el2 * dx * (1 - dy) + el3 * (1 - dx) * dy + el4 * dx * dy;
            return el;
        }

        private void OnGetElevationRange(out double minElevation, out double maxElevation)
        {
            double min = double.MaxValue;
            double max = double.MinValue;
            
            for (int y = 0; y < rows; y++)
            {
                for (int x = 0; x < cols; x++) 
                {
                    double el = elevations[y, x];
                    if (el < min) min = el;
                    if (el > max) max = el;
                }
            }
            
            minElevation = min;
            maxElevation = max;
        }

        [MenuItem("RWT/Using Google Elevation API")]
        public static void OpenWindow()
        {
            GetWindow<UsingGoogleElevationsExample>(true, "Google Elevation API Example");
        }
    }
}

using System.Collections.Generic;
using System.Globalization;
using InfinityCode.RealWorldTerrain;
using InfinityCode.RealWorldTerrain.Generators;
using InfinityCode.RealWorldTerrain.OSM;
using InfinityCode.RealWorldTerrain.Windows;
using UnityEditor;
using UnityEngine;

namespace InfinityCode.RealWorldTerrainExamples
{
    /// <summary>
    /// Example of using the Real World Terrain API to not generate buildings under certain conditions.
    /// </summary>
    public class DoNotGenerateBuildingsByConditions : EditorWindow
    {
        /// <summary>
        /// Will the conditions from the script be used?
        /// </summary>
        private static bool active = false;
        
        /// <summary>
        /// Minimum building height.
        /// </summary>
        private static float minHeight = 30;
        
        /// <summary>
        /// Determines whether to generate building based on provided conditions.
        /// </summary>
        /// <param name="points">List of points for the building base.</param>
        /// <param name="way">The OSM Way data for the building.</param>
        /// <param name="nodes">The OSM Node data associated with the building.</param>
        /// <returns>True - the building should not be generated, false - it should be generated.</returns>
        private bool OnGenerateBuilding(List<Vector3> points, RealWorldTerrainOSMWay way, Dictionary<string, RealWorldTerrainOSMNode> nodes)
        {
            // Default building height.
            float baseHeight = 15;
            
            // Get the height of the building from the OSM data.
            string heightStr = way.GetTagValue("height");
            
            // If the height is not specified, try to get the number of floors.
            string levelsStr = way.GetTagValue("building:levels");
            
            // Parse the height from the string.
            RealWorldTerrainBuildingGenerator.GetHeightFromString(heightStr, ref baseHeight);
            
            // If the height is not specified, but the number of floors is specified, calculate the height based on the number of floors.
            if (string.IsNullOrEmpty(heightStr))
            {
                if (!string.IsNullOrEmpty(levelsStr))
                {
                    float h;
                    if (float.TryParse(levelsStr, NumberStyles.AllowDecimalPoint, RealWorldTerrainCultureInfo.cultureInfo, out h)) baseHeight = h * RealWorldTerrainWindow.prefs.buildingFloorHeight;
                }
                else baseHeight = RealWorldTerrainWindow.prefs.buildingFloorLimits.Random() * RealWorldTerrainWindow.prefs.buildingFloorHeight;
            }
            
            // If the height is less than the minimum, do not generate the building.
            if (baseHeight < minHeight) return true;

            // Otherwise, generate the building.
            return false;
        }

        /// <summary>
        /// Displays the GUI controls for the editor window.
        /// </summary>
        private void OnGUI()
        {
            EditorGUILayout.HelpBox("If active, buildings will not be generated under the conditions specified in the OnGenerateBuilding method.", MessageType.Info);
            
            EditorGUI.BeginChangeCheck();
            active = EditorGUILayout.Toggle("Active", active);
            if (EditorGUI.EndChangeCheck())
            {
                if (active)
                {
                    // Subscribe to the OnGenerateBuilding event.
                    RealWorldTerrainBuildingGenerator.OnGenerateBuilding -= OnGenerateBuilding;
                    RealWorldTerrainBuildingGenerator.OnGenerateBuilding += OnGenerateBuilding;
                }
                else
                {
                    // Unsubscribe from the OnGenerateBuilding event.
                    RealWorldTerrainBuildingGenerator.OnGenerateBuilding -= OnGenerateBuilding;
                }
            }
            
            minHeight = EditorGUILayout.FloatField("Min Height", minHeight);
        
            if (GUILayout.Button("Open Real World Terrain"))
            {
                RealWorldTerrainWindow.OpenWindow(RealWorldTerrainGenerateType.full);
            }
        }

        /// <summary>
        /// Opens the window.
        /// </summary>
        [MenuItem("RWT/Do Not Generate Buildings By Conditions")]
        private static void OpenWindow()
        {
            GetWindow<DoNotGenerateBuildingsByConditions>(false, "Do Not Generate Buildings By Conditions", true);
        }
    }
}

using InfinityCode.RealWorldTerrain.Generators;
using UnityEditor;
using UnityEngine;

public class InterceptGetElevationExample : EditorWindow
{
    public static bool isIntercepted = false;

    private void OnGUI()
    {
        EditorGUI.BeginDisabledGroup(isIntercepted);

        if (GUILayout.Button("Intercept"))
        {
            // Subscribe to OnGetElevation event, to intercept receiving elevation from the provider.
            RealWorldTerrainElevationGenerator.OnGetElevation += OnGetElevation;

            // If you want to use the range of values from the selected elevation provider, just do not subscribe to RealWorldTerrainElevationGenerator.OnGetElevationRange.
            RealWorldTerrainElevationGenerator.OnGetElevationRange += OnGetElevationRange;
            isIntercepted = true;
        }

        EditorGUI.EndDisabledGroup();

        EditorGUI.BeginDisabledGroup(!isIntercepted);

        if (GUILayout.Button("Release"))
        {
            RealWorldTerrainElevationGenerator.OnGetElevation -= OnGetElevation;
            RealWorldTerrainElevationGenerator.OnGetElevationRange -= OnGetElevationRange;
            isIntercepted = false;
        }

        EditorGUI.EndDisabledGroup();
    }

    /// <summary>
    /// This method will be called when the RWT wants to get the range of elevation values.
    /// If you want to use the range of values from the selected elevation provider, just do not subscribe to RealWorldTerrainElevationGenerator.OnGetElevationRange.
    /// </summary>
    /// <param name="minEl">Minimum elevation for the area (meters)</param>
    /// <param name="maxEl">Maximum elevation for the area (meters)</param>
    private void OnGetElevationRange(out double minEl, out double maxEl)
    {
        minEl = maxEl = 0;

        // Here you calculate the maximum and minimum elevation value,
        // or return the pre-calculated values.
    }

    /// <summary>
    /// This method will be called when the RWT wants to get the elevation value from the provider
    /// </summary>
    /// <param name="mx">Mercator position X (0-1)</param>
    /// <param name="my">Mercator position Y (0-1)</param>
    /// <returns>Elevation value in meters or null (if you need to get elevation value from the provider)</returns>
    private double? OnGetElevation(double mx, double my)
    {
        // Mercator position is a tile position for zoom 0.
        // https://www.maptiler.com/google-maps-coordinates-tile-bounds-projection/
        // https://docs.microsoft.com/en-us/bingmaps/articles/bing-maps-tile-system?redirectedfrom=MSDN

        // Here you calculate your elevation value in meters, and return that value.
        // Or return null if you need to get elevation value from the provider.

        // Points of interest:
        // Use RealWorldTerrainUtils.MercatToLatLong if you need to convert Mercator position to geographic coordinates.

        return null;
    }

    [MenuItem("RWT/Intercept Elevation")]
    private static void OpenWindow()
    {
        GetWindow<InterceptGetElevationExample>("Intercept Elevation");
    }
}

using System;
using System.Collections.Generic;
using InfinityCode.RealWorldTerrain;
using InfinityCode.RealWorldTerrain.Windows;
using UnityEditor;
using UnityEngine;

public class AutomatorExample : EditorWindow
{
    private RealWorldTerrainContainer container;
    private List<Rule> rules = new List<Rule>();
    private Vector2 scrollPosition;
    private int status = 0; // 0 - idle, 1 - execute, 2 - finalize
    private int executeIndex = -1;
    private bool finished = false;

    private void Execute()
    {
        if (container == null) return;
        if (container.terrains == null) return;
        if (rules.Count == 0) return;

        status = 1;
        executeIndex = -1;
        ExecuteNextTerrain();
    }

    private void ExecuteNextTerrain()
    {
        int ruleIndex = -1;
        Rule activeRule = null;
        RealWorldTerrainItem item = null;

        do
        {
            executeIndex++;
            if (executeIndex == container.terrainCount)
            {
                status = 2;
                Repaint();
                return;
            }

            item = container.terrains[executeIndex];

            for (int i = 0; i < rules.Count; i++)
            {
                Rule rule = rules[i];
                if (rule.Contains(item) && (rule.textureResolution != item.prefs.textureSize.x || !item.generateTextures))
                {
                    activeRule = rule;
                    ruleIndex = i;
                    break;
                }
            }
        } while (activeRule == null);

        finished = false;

        Debug.Log(item + ", Rule - " + ruleIndex);

        RealWorldTerrainWindow.OpenWindow(RealWorldTerrainGenerateType.texture, item);

        RealWorldTerrainWindow.prefs.generateTextures = true;
        RealWorldTerrainWindow.prefs.textureSize = new RealWorldTerrainVector2i(activeRule.textureResolution, activeRule.textureResolution);
        RealWorldTerrainWindow.OnCaptureCompleted += OnCaptureCompleted;
        RealWorldTerrainWindow.OnCaptureCanceled += OnCaptureCanceled;

        RealWorldTerrainWindow.StartCapture();
    }

    private void OnCaptureCanceled()
    {
        UnsubscribeFromEvents();

        status = 2;
    }

    private void OnCaptureCompleted()
    {
        UnsubscribeFromEvents();

        finished = true;
        Repaint();
    }

    private void OnGUI()
    {
        if (status == 0) OnIdleGUI();
        else if (status == 1) OnWaitGUI();
        else if (Event.current.type == EventType.Repaint)
        {
            status = 0;
            Repaint();
        }
    }

    private void OnIdleGUI()
    {
        int rulesCount = rules.Count;
        int moveUp = -1;
        int moveDown = -1;

        container = EditorGUILayout.ObjectField("RWT Container", container, typeof(RealWorldTerrainContainer), true) as RealWorldTerrainContainer;

        try
        {
            scrollPosition = EditorGUILayout.BeginScrollView(scrollPosition);
        }
        catch
        {
            Debug.Log(Event.current.type);
        }
        

        for (int i = 0; i < rulesCount; i++)
        {
            Rule rule = rules[i];

            EditorGUILayout.BeginHorizontal();

            EditorGUILayout.LabelField("From X", GUILayout.Width(50));
            rule.fromX = EditorGUILayout.IntField(rule.fromX);
            EditorGUILayout.LabelField("Y", GUILayout.Width(20));
            rule.fromY = EditorGUILayout.IntField(rule.fromY);

            EditorGUILayout.LabelField(" To X", GUILayout.Width(40));
            rule.toX = EditorGUILayout.IntField(rule.toX);
            EditorGUILayout.LabelField("Y", GUILayout.Width(20));
            rule.toY = EditorGUILayout.IntField(rule.toY);

            EditorGUILayout.LabelField(" Resolution", GUILayout.Width(80));
            rule.textureResolution = EditorGUILayout.IntField(rule.textureResolution);

            if (GUILayout.Button("Up", GUILayout.ExpandWidth(false))) moveUp = i;
            if (GUILayout.Button("Down", GUILayout.ExpandWidth(false))) moveDown = i;
            if (GUILayout.Button("X", GUILayout.ExpandWidth(false)))
            {
                rules.RemoveAt(i);
                rulesCount--;
            }

            EditorGUILayout.EndHorizontal();
        }

        EditorGUILayout.EndScrollView();

        if (moveUp > 0)
        {
            Rule t = rules[moveUp - 1];
            rules[moveUp - 1] = rules[moveUp];
            rules[moveUp] = t;
        }

        if (moveDown != -1 && moveDown < rulesCount - 1)
        {
            Rule t = rules[moveDown + 1];
            rules[moveDown + 1] = rules[moveDown];
            rules[moveDown] = t;
        }

        if (GUILayout.Button("Add")) rules.Add(new Rule());
        if (GUILayout.Button("Execute")) Execute();
    }

    private void OnWaitGUI()
    {
        if (finished) ExecuteNextTerrain();

        Rect rect = GUILayoutUtility.GetRect(GUIContent.none, GUI.skin.box, GUILayout.Height(20), GUILayout.ExpandWidth(true));
        float progress = (float)executeIndex / (container.terrainCount - 1);
        EditorGUI.ProgressBar(rect, progress, Mathf.FloorToInt(progress * 100) + " %");

        if (GUILayout.Button("Cancel"))
        {
            status = 2;
            RealWorldTerrainWindow.CancelCapture();
        }
    }

    [MenuItem("RWT/Automator")]
    private static void OpenWindow()
    {
        GetWindow<AutomatorExample>();
    }

    private void UnsubscribeFromEvents()
    {
        RealWorldTerrainWindow.OnCaptureCompleted -= OnCaptureCompleted;
        RealWorldTerrainWindow.OnCaptureCanceled -= OnCaptureCanceled;
    }

    internal class Rule
    {
        public int fromX;
        public int fromY;
        public int toX;
        public int toY;
        public int textureResolution = 256;

        public bool Contains(RealWorldTerrainItem item)
        {
            return fromX <= item.x && toX >= item.x && fromY <= item.y && toY >= item.y;
        }
    }
}

/*     INFINITY CODE 2013-2018      */
/*   http://www.infinity-code.com   */

using InfinityCode.RealWorldTerrain;
using UnityEngine;

namespace InfinityCode.OnlineMapsExamples
{
    public class FindRouteOnTerrainUsingOnlineMaps : MonoBehaviour
    {
        /// <summary>
        /// Real World Terrain Container
        /// </summary>
        public RealWorldTerrainContainer container;

        /// <summary>
        /// Material for the route, and points on terrainsMat
        /// </summary>
        public Material lineRendererMaterial;

        /// <summary>
        /// Index of point (click)
        /// </summary>
        private int pointIndex = 0;

        /// <summary>
        /// Coordinates of points
        /// </summary>
        private Vector2[] points;

        /// <summary>
        /// Instances of points
        /// </summary>
        private GameObject[] pointInstances;

        /// <summary>
        /// Instance of LineRenderer
        /// </summary>
        private LineRenderer lineRenderer;

        /// <summary>
        /// Screen position of last press
        /// </summary>
        private Vector2 pressPoint;

        /// <summary>
        /// This method is called when responding from the Google Directions API
        /// </summary>
        /// <param name="response">Response string</param>
        private void OnGoogleDirectionsComplete(string response)
        {
            OnlineMapsGoogleDirectionsResult result = OnlineMapsGoogleDirections.GetResult(response);
            if (result == null || result.routes.Length == 0) return;

            Vector2[] polyline = result.routes[0].overview_polyline;

            GameObject go = new GameObject("LineRenderer");
            lineRenderer = go.AddComponent<LineRenderer>();
            lineRenderer.sharedMaterial = lineRendererMaterial;
            lineRenderer.widthCurve = AnimationCurve.Constant(0, 1, 2);
            lineRenderer.startColor = lineRenderer.endColor = Color.blue;
            lineRenderer.positionCount = polyline.Length;

            for (int i = 0; i < polyline.Length; i++)
            {
                Vector3 p;
                container.GetWorldPosition(polyline[i], out p);
                lineRenderer.SetPosition(i, p + new Vector3(0, 2, 0));
            }
        }

        /// <summary>
        /// Process click on terrain
        /// </summary>
        private void ProcessClick()
        {
            bool success = container.GetCoordinatesUnderCursor(out points[pointIndex]);
            if (!success) return;

            if (pointIndex == 0)
            {
                if (lineRenderer != null)
                {
                    DestroyImmediate(lineRenderer.gameObject);
                    DestroyImmediate(pointInstances[0]);
                    DestroyImmediate(pointInstances[1]);
                    lineRenderer = null;
                }
            }

            GameObject go = GameObject.CreatePrimitive(PrimitiveType.Sphere);
            Vector3 p;
            container.GetWorldPosition(points[pointIndex], out p);
            go.transform.position = p;
            go.transform.localScale = new Vector3(3, 3, 3);
            go.GetComponent<Renderer>().sharedMaterial = lineRendererMaterial;
            pointInstances[pointIndex] = go;

            pointIndex++;
            if (pointIndex < 2) return;

            pointIndex = 0;

            OnlineMapsGoogleDirections.Find(points[0], points[1]).OnComplete += OnGoogleDirectionsComplete;
        }

        private void Start()
        {
            points = new Vector2[2];
            pointInstances = new GameObject[2];
        }

        private void Update()
        {
            if (Input.GetMouseButtonDown(0)) pressPoint = Input.mousePosition;
            else if (Input.GetMouseButtonUp(0))
            {
                if ((pressPoint - (Vector2) Input.mousePosition).magnitude < 10) ProcessClick();
            }
        }
    }
}