Multithreaded HTTPRequests

sdkproject/Assets/Mapbox/Core/Unity/MeshGeneration/Factories/MapImageFactory.cs

@@ -72,7 +72,7 @@ private void Run(UnityTile tile)
                 var rasterTile = parameters.MapId.StartsWith("mapbox://") ? new RasterTile() : new ClassicRasterTile();
                 rasterTile.Initialize(parameters, (Action)(() =>
                 {
-                    if (rasterTile.Error != null)
+                    if (rasterTile.HasError)
                     {
                         tile.ImageDataState = TilePropertyState.Error;
                         return;

sdkproject/Assets/Mapbox/Core/Unity/MeshGeneration/Factories/MeshFactory.cs

@@ -1,17 +1,18 @@
 namespace Mapbox.Unity.MeshGeneration.Factories
 {
-    using System.Collections.Generic;
-    using UnityEngine;
-    using Mapbox.Unity.MeshGeneration.Enums;
-    using Mapbox.Unity.MeshGeneration.Data;
-    using Mapbox.Unity.MeshGeneration.Interfaces;
-    using Mapbox.Platform;
+	using System.Collections.Generic;
+	using UnityEngine;
+	using Mapbox.Unity.MeshGeneration.Enums;
+	using Mapbox.Unity.MeshGeneration.Data;
+	using Mapbox.Unity.MeshGeneration.Interfaces;
+	using Mapbox.Platform;
+	using System.Linq;
 
-    /// <summary>
-    /// Uses vector tile api to visualize vector data.
-    /// Fetches the vector data for given tile and passes layer data to layer visualizers.
-    /// </summary>
-    [CreateAssetMenu(menuName = "Mapbox/Factories/Mesh Factory")]
+	/// <summary>
+	/// Uses vector tile api to visualize vector data.
+	/// Fetches the vector data for given tile and passes layer data to layer visualizers.
+	/// </summary>
+	[CreateAssetMenu(menuName = "Mapbox/Factories/Mesh Factory")]
     public class MeshFactory : Factory
     {
         [SerializeField]
@@ -107,9 +108,9 @@ private void CreateMeshes(UnityTile tile, object e)
             var vectorTile = new Mapbox.Map.VectorTile();
             vectorTile.Initialize(parameters, () =>
             {
-                if (vectorTile.Error != null)
+                if (vectorTile.HasError)
                 {
-                    Debug.Log(vectorTile.Error);
+                    Debug.Log(string.Join(System.Environment.NewLine, vectorTile.Exceptions.Select(ex=>ex.Message).ToArray()));
                     return;
                 }
 

sdkproject/Assets/Mapbox/Core/Unity/MeshGeneration/Factories/TerrainFactory.cs

@@ -112,7 +112,7 @@ private void CreateTerrainHeight(UnityTile tile, float heightMultiplier = 1)
                 var pngRasterTile = new RawPngRasterTile();
                 pngRasterTile.Initialize(parameters, () =>
                 {
-                    if (pngRasterTile.Error != null)
+                    if (pngRasterTile.HasError)
                     {
                         tile.HeightDataState = TilePropertyState.Error;
                         return;

sdkproject/Assets/Mapbox/Core/Unity/Utilities/DispatcherEditor.cs

@@ -0,0 +1,51 @@
+namespace Mapbox.Unity {
+
+
+	using System;
+	using System.Collections.Generic;
+	using System.Threading;
+	using UnityEditor;
+
+
+	[InitializeOnLoad]
+	public static class DispatcherEditor {
+
+
+		static DispatcherEditor() {
+			_mainThread = Thread.CurrentThread;
+			EditorApplication.update += Update;
+		}
+
+
+		private static object _lock = new object();
+		private static readonly Queue<Action> _actions = new Queue<Action>();
+		private static Thread _mainThread;
+
+
+		private static bool isMainThread {
+			get { return Thread.CurrentThread == _mainThread; }
+		}
+
+
+		public static void Update() {
+			lock (_lock) {
+				while (_actions.Count > 0) {
+					_actions.Dequeue()();
+				}
+			}
+		}
+
+
+		public static void InvokeAsync(Action action) {
+			if (isMainThread) {
+				action();
+			}else {
+				lock (_lock) {
+					_actions.Enqueue(action);
+				}
+			}
+		}
+
+
+	}
+}

sdkproject/Assets/Mapbox/Examples/Playground/Scripts/RasterTileExample.cs

@@ -118,7 +118,7 @@ void ToggleDropdownStyles(int target)
         /// <param name="tile">Tile.</param>
         public void OnNext(RasterTile tile)
         {
-            if (tile.CurrentState != Tile.State.Loaded || tile.Error != null)
+            if (tile.CurrentState != Tile.State.Loaded || tile.HasError)
             {
                 return;
             }

sdkproject/Assets/Mapbox/Examples/Playground/Scripts/VectorTileExample.cs

@@ -80,7 +80,7 @@ void Redraw()
         /// <param name="tile">Tile.</param>
         public void OnNext(VectorTile tile)
         {
-            if (tile.CurrentState != Tile.State.Loaded || tile.Error != null)
+            if (tile.CurrentState != Tile.State.Loaded || tile.HasError)
             {
                 return;
             }

sdkproject/Assets/Mapbox/Examples/Voxels/Scripts/VoxelTile.cs

@@ -116,7 +116,7 @@ void FetchWorldData(Vector2d coordinates)
 
         public void OnNext(RasterTile tile)
         {
-            if (tile.CurrentState == Tile.State.Loaded && string.IsNullOrEmpty(tile.Error))
+            if (tile.CurrentState == Tile.State.Loaded && !tile.HasError)
             {
                 _rasterTexture = new Texture2D(2, 2);
                 _rasterTexture.LoadImage(tile.Data);
@@ -131,7 +131,7 @@ public void OnNext(RasterTile tile)
 
         public void OnNext(RawPngRasterTile tile)
         {
-            if (tile.CurrentState == Tile.State.Loaded && string.IsNullOrEmpty(tile.Error))
+            if (tile.CurrentState == Tile.State.Loaded && !tile.HasError)
             {
                 _elevationTexture = new Texture2D(2, 2);
                 _elevationTexture.LoadImage(tile.Data);

sdkproject/Assets/ThirdPartyAssets/UnityToolbagDispatcher/Dispatcher.cs

@@ -0,0 +1,114 @@
+using UnityEngine;
+using System;
+using System.Collections.Generic;
+using System.Threading;
+
+namespace UnityToolbag {
+	/// <summary>
+	/// A system for dispatching code to execute on the main thread.
+	/// </summary>
+	[AddComponentMenu("UnityToolbag/Dispatcher")]
+	public class Dispatcher : MonoBehaviour {
+		private static Dispatcher _instance;
+
+		// We can't use the behaviour reference from other threads, so we use a separate bool
+		// to track the instance so we can use that on the other threads.
+		// edit by BergWerkGIS: make public to see if dispatcher is attached
+		public static bool _instanceExists;
+
+		private static Thread _mainThread;
+		private static object _lockObject = new object();
+		private static readonly Queue<Action> _actions = new Queue<Action>();
+
+		/// <summary>
+		/// Gets a value indicating whether or not the current thread is the game's main thread.
+		/// </summary>
+		public static bool isMainThread {
+			get {
+				return Thread.CurrentThread == _mainThread;
+			}
+		}
+
+		/// <summary>
+		/// Queues an action to be invoked on the main game thread.
+		/// </summary>
+		/// <param name="action">The action to be queued.</param>
+		public static void InvokeAsync(Action action) {
+
+			if (!_instanceExists) {
+				Debug.LogError("No Dispatcher exists in the scene. Actions will not be invoked!");
+				return;
+			}
+
+			if (isMainThread) {
+				// Don't bother queuing work on the main thread; just execute it.
+				action();
+			} else {
+				lock (_lockObject) {
+					_actions.Enqueue(action);
+				}
+			}
+		}
+
+		/// <summary>
+		/// Queues an action to be invoked on the main game thread and blocks the
+		/// current thread until the action has been executed.
+		/// </summary>
+		/// <param name="action">The action to be queued.</param>
+		public static void Invoke(Action action) {
+
+			if (!_instanceExists) {
+				Debug.LogError("No Dispatcher exists in the scene. Actions will not be invoked!");
+				return;
+			}
+
+
+			bool hasRun = false;
+
+			InvokeAsync(() => {
+				action();
+				hasRun = true;
+			});
+
+			// Lock until the action has run
+			while (!hasRun) {
+#if !NETFX_CORE
+				Thread.Sleep(5);
+#else
+				System.Threading.Tasks.Task.Delay(5).Wait();
+#endif
+			}
+		}
+
+		void Awake() {
+			if (_instance) {
+				DestroyImmediate(this);
+			} else {
+				_instance = this;
+				_instanceExists = true;
+				_mainThread = Thread.CurrentThread;
+			}
+		}
+
+		void OnDestroy() {
+			if (_instance == this) {
+				_instance = null;
+				_instanceExists = false;
+			}
+		}
+
+		//int cnt = 0;
+		void Update() {
+			//cnt++;
+			//if (cnt < 100) { return; }
+			//cnt = 0;
+			////if (_actions.Count > 0) UnityEngine.Debug.Log("-------------------- update -----------------" + DateTime.Now.Ticks);
+			lock (_lockObject) {
+				while (_actions.Count > 0) {
+					//UnityEngine.Debug.Log("QUEUE: " + _actions.Count + " " + DateTime.Now.Ticks);
+					_actions.Dequeue()();
+				}
+			}
+		}
+	}
+}