Upgraded original RothenburgAR to Unity version 2017.4.5f1 (and upgrading from standalone vuforia to the version integrated in unity)

Assets/AssetBundleManager/AssetBundleLoadOperation.cs

@@ -0,0 +1,220 @@
+using UnityEngine;
+using System.Collections;
+
+namespace AssetBundles
+{
+	public abstract class AssetBundleLoadOperation : IEnumerator
+	{
+		public object Current
+		{
+			get
+			{
+				return null;
+			}
+		}
+		public bool MoveNext()
+		{
+			return !IsDone();
+		}
+		
+		public void Reset()
+		{
+		}
+		
+		abstract public bool Update ();
+		
+		abstract public bool IsDone ();
+	}
+	
+	#if UNITY_EDITOR
+	public class AssetBundleLoadLevelSimulationOperation : AssetBundleLoadOperation
+	{	
+		AsyncOperation m_Operation = null;
+	
+	
+		public AssetBundleLoadLevelSimulationOperation (string assetBundleName, string levelName, bool isAdditive)
+		{
+			string[] levelPaths = UnityEditor.AssetDatabase.GetAssetPathsFromAssetBundleAndAssetName(assetBundleName, levelName);
+			if (levelPaths.Length == 0)
+			{
+				///@TODO: The error needs to differentiate that an asset bundle name doesn't exist
+				//        from that there right scene does not exist in the asset bundle...
+				
+				Debug.LogError("There is no scene with name \"" + levelName + "\" in " + assetBundleName);
+				return;
+			}
+			
+			if (isAdditive)
+				m_Operation = UnityEditor.EditorApplication.LoadLevelAdditiveAsyncInPlayMode(levelPaths[0]);
+			else
+				m_Operation = UnityEditor.EditorApplication.LoadLevelAsyncInPlayMode(levelPaths[0]);
+		}
+		
+		public override bool Update ()
+		{
+			return false;
+		}
+		
+		public override bool IsDone ()
+		{		
+			return m_Operation == null || m_Operation.isDone;
+		}
+	}
+	
+	#endif
+	public class AssetBundleLoadLevelOperation : AssetBundleLoadOperation
+	{
+		protected string 				m_AssetBundleName;
+		protected string 				m_LevelName;
+		protected bool 					m_IsAdditive;
+		protected string 				m_DownloadingError;
+		protected AsyncOperation		m_Request;
+	
+		public AssetBundleLoadLevelOperation (string assetbundleName, string levelName, bool isAdditive)
+		{
+			m_AssetBundleName = assetbundleName;
+			m_LevelName = levelName;
+			m_IsAdditive = isAdditive;
+		}
+	
+		public override bool Update ()
+		{
+			if (m_Request != null)
+				return false;
+			
+			LoadedAssetBundle bundle = AssetBundleManager.GetLoadedAssetBundle (m_AssetBundleName, out m_DownloadingError);
+			if (bundle != null)
+			{
+				if (m_IsAdditive)
+					m_Request = Application.LoadLevelAdditiveAsync (m_LevelName);
+				else
+					m_Request = Application.LoadLevelAsync (m_LevelName);
+				return false;
+			}
+			else
+				return true;
+		}
+		
+		public override bool IsDone ()
+		{
+			// Return if meeting downloading error.
+			// m_DownloadingError might come from the dependency downloading.
+			if (m_Request == null && m_DownloadingError != null)
+			{
+				Debug.LogError(m_DownloadingError);
+				return true;
+			}
+			
+			return m_Request != null && m_Request.isDone;
+		}
+	}
+	
+	public abstract class AssetBundleLoadAssetOperation : AssetBundleLoadOperation
+	{
+		public abstract T GetAsset<T>() where T : UnityEngine.Object;
+	}
+	
+	public class AssetBundleLoadAssetOperationSimulation : AssetBundleLoadAssetOperation
+	{
+		Object							m_SimulatedObject;
+		
+		public AssetBundleLoadAssetOperationSimulation (Object simulatedObject)
+		{
+			m_SimulatedObject = simulatedObject;
+		}
+		
+		public override T GetAsset<T>()
+		{
+			return m_SimulatedObject as T;
+		}
+		
+		public override bool Update ()
+		{
+			return false;
+		}
+		
+		public override bool IsDone ()
+		{
+			return true;
+		}
+	}
+	
+	public class AssetBundleLoadAssetOperationFull : AssetBundleLoadAssetOperation
+	{
+		protected string 				m_AssetBundleName;
+		protected string 				m_AssetName;
+		protected string 				m_DownloadingError;
+		protected System.Type 			m_Type;
+		protected AssetBundleRequest	m_Request = null;
+	
+		public AssetBundleLoadAssetOperationFull (string bundleName, string assetName, System.Type type)
+		{
+			m_AssetBundleName = bundleName;
+			m_AssetName = assetName;
+			m_Type = type;
+		}
+		
+		public override T GetAsset<T>()
+		{
+			if (m_Request != null && m_Request.isDone)
+				return m_Request.asset as T;
+			else
+				return null;
+		}
+		
+		// Returns true if more Update calls are required.
+		public override bool Update ()
+		{
+			if (m_Request != null)
+				return false;
+	
+			LoadedAssetBundle bundle = AssetBundleManager.GetLoadedAssetBundle (m_AssetBundleName, out m_DownloadingError);
+			if (bundle != null)
+			{
+				///@TODO: When asset bundle download fails this throws an exception...
+				m_Request = bundle.m_AssetBundle.LoadAssetAsync (m_AssetName, m_Type);
+				return false;
+			}
+			else
+			{
+				return true;
+			}
+		}
+		
+		public override bool IsDone ()
+		{
+			// Return if meeting downloading error.
+			// m_DownloadingError might come from the dependency downloading.
+			if (m_Request == null && m_DownloadingError != null)
+			{
+				Debug.LogError(m_DownloadingError);
+				return true;
+			}
+	
+			return m_Request != null && m_Request.isDone;
+		}
+	}
+	
+	public class AssetBundleLoadManifestOperation : AssetBundleLoadAssetOperationFull
+	{
+		public AssetBundleLoadManifestOperation (string bundleName, string assetName, System.Type type)
+			: base(bundleName, assetName, type)
+		{
+		}
+	
+		public override bool Update ()
+		{
+			base.Update();
+			
+			if (m_Request != null && m_Request.isDone)
+			{
+				AssetBundleManager.AssetBundleManifestObject = GetAsset<AssetBundleManifest>();
+				return false;
+			}
+			else
+				return true;
+		}
+	}
+	
+	
+}

Assets/AssetBundleManager/AssetBundleLoadOperation.cs.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: c487cbb6e41638c48ad9675dcfafb3ce
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 

Assets/AssetBundleManager/AssetBundleManager.cs

@@ -0,0 +1,503 @@
+using UnityEngine;
+#if UNITY_EDITOR	
+using UnityEditor;
+#endif
+using System.Collections;
+using System.Collections.Generic;
+
+/*
+ 	In this demo, we demonstrate:
+	1.	Automatic asset bundle dependency resolving & loading.
+		It shows how to use the manifest assetbundle like how to get the dependencies etc.
+	2.	Automatic unloading of asset bundles (When an asset bundle or a dependency thereof is no longer needed, the asset bundle is unloaded)
+	3.	Editor simulation. A bool defines if we load asset bundles from the project or are actually using asset bundles(doesn't work with assetbundle variants for now.)
+		With this, you can player in editor mode without actually building the assetBundles.
+	4.	Optional setup where to download all asset bundles
+	5.	Build pipeline build postprocessor, integration so that building a player builds the asset bundles and puts them into the player data (Default implmenetation for loading assetbundles from disk on any platform)
+	6.	Use WWW.LoadFromCacheOrDownload and feed 128 bit hash to it when downloading via web
+		You can get the hash from the manifest assetbundle.
+	7.	AssetBundle variants. A prioritized list of variants that should be used if the asset bundle with that variant exists, first variant in the list is the most preferred etc.
+*/
+
+namespace AssetBundles
+{	
+	// Loaded assetBundle contains the references count which can be used to unload dependent assetBundles automatically.
+	public class LoadedAssetBundle
+	{
+		public AssetBundle m_AssetBundle;
+		public int m_ReferencedCount;
+		
+		public LoadedAssetBundle(AssetBundle assetBundle)
+		{
+			m_AssetBundle = assetBundle;
+			m_ReferencedCount = 1;
+		}
+	}
+	
+	// Class takes care of loading assetBundle and its dependencies automatically, loading variants automatically.
+	public class AssetBundleManager : MonoBehaviour
+	{
+		public enum LogMode { All, JustErrors };
+		public enum LogType { Info, Warning, Error };
+	
+		static LogMode m_LogMode = LogMode.All;
+		static string m_BaseDownloadingURL = "";
+		static string[] m_ActiveVariants =  {  };
+		static AssetBundleManifest m_AssetBundleManifest = null;
+	#if UNITY_EDITOR	
+		static int m_SimulateAssetBundleInEditor = -1;
+		const string kSimulateAssetBundles = "SimulateAssetBundles";
+	#endif
+	
+		static Dictionary<string, LoadedAssetBundle> m_LoadedAssetBundles = new Dictionary<string, LoadedAssetBundle> ();
+		static Dictionary<string, WWW> m_DownloadingWWWs = new Dictionary<string, WWW> ();
+		static Dictionary<string, string> m_DownloadingErrors = new Dictionary<string, string> ();
+		static List<AssetBundleLoadOperation> m_InProgressOperations = new List<AssetBundleLoadOperation> ();
+		static Dictionary<string, string[]> m_Dependencies = new Dictionary<string, string[]> ();
+	
+		public static LogMode logMode
+		{
+			get { return m_LogMode; }
+			set { m_LogMode = value; }
+		}
+	
+		// The base downloading url which is used to generate the full downloading url with the assetBundle names.
+		public static string BaseDownloadingURL
+		{
+			get { return m_BaseDownloadingURL; }
+			set { m_BaseDownloadingURL = value; }
+		}
+	
+		// Variants which is used to define the active variants.
+		public static string[] ActiveVariants
+		{
+			get { return m_ActiveVariants; }
+			set { m_ActiveVariants = value; }
+		}
+	
+		// AssetBundleManifest object which can be used to load the dependecies and check suitable assetBundle variants.
+		public static AssetBundleManifest AssetBundleManifestObject
+		{
+			set {m_AssetBundleManifest = value; }
+		}
+	
+		private static void Log(LogType logType, string text)
+		{
+			if (logType == LogType.Error)
+				Debug.LogError("[AssetBundleManager] " + text);
+			else if (m_LogMode == LogMode.All)
+				Debug.Log("[AssetBundleManager] " + text);
+		}
+	
+	#if UNITY_EDITOR
+		// Flag to indicate if we want to simulate assetBundles in Editor without building them actually.
+		public static bool SimulateAssetBundleInEditor 
+		{
+			get
+			{
+				if (m_SimulateAssetBundleInEditor == -1)
+					m_SimulateAssetBundleInEditor = EditorPrefs.GetBool(kSimulateAssetBundles, true) ? 1 : 0;
+				
+				return m_SimulateAssetBundleInEditor != 0;
+			}
+			set
+			{
+				int newValue = value ? 1 : 0;
+				if (newValue != m_SimulateAssetBundleInEditor)
+				{
+					m_SimulateAssetBundleInEditor = newValue;
+					EditorPrefs.SetBool(kSimulateAssetBundles, value);
+				}
+			}
+		}
+		
+	
+		#endif
+	
+		private static string GetStreamingAssetsPath()
+		{
+			if (Application.isEditor)
+				return "file://" +  System.Environment.CurrentDirectory.Replace("\\", "/"); // Use the build output folder directly.
+			else if (Application.isMobilePlatform || Application.isConsolePlatform)
+				return Application.streamingAssetsPath;
+			else // For standalone player.
+				return "file://" +  Application.streamingAssetsPath;
+		}
+	
+		public static void SetSourceAssetBundleDirectory(string relativePath)
+		{
+			BaseDownloadingURL = GetStreamingAssetsPath() + relativePath;
+		}
+		
+		public static void SetSourceAssetBundleURL(string absolutePath)
+		{
+			BaseDownloadingURL = absolutePath + Utility.GetPlatformName() + "/";
+		}
+	
+		public static void SetDevelopmentAssetBundleServer()
+		{
+			#if UNITY_EDITOR
+			// If we're in Editor simulation mode, we don't have to setup a download URL
+			if (SimulateAssetBundleInEditor)
+				return;
+			#endif
+			
+			TextAsset urlFile = Resources.Load("AssetBundleServerURL") as TextAsset;
+			string url = (urlFile != null) ? urlFile.text.Trim() : null;
+			if (url == null || url.Length == 0)
+			{
+				Debug.LogError("Development Server URL could not be found.");
+				//AssetBundleManager.SetSourceAssetBundleURL("http://localhost:7888/" + UnityHelper.GetPlatformName() + "/");
+			}
+			else
+			{
+				AssetBundleManager.SetSourceAssetBundleURL(url);
+			}
+		}
+		
+		// Get loaded AssetBundle, only return vaild object when all the dependencies are downloaded successfully.
+		static public LoadedAssetBundle GetLoadedAssetBundle (string assetBundleName, out string error)
+		{
+			if (m_DownloadingErrors.TryGetValue(assetBundleName, out error) )
+				return null;
+		
+			LoadedAssetBundle bundle = null;
+			m_LoadedAssetBundles.TryGetValue(assetBundleName, out bundle);
+			if (bundle == null)
+				return null;
+			
+			// No dependencies are recorded, only the bundle itself is required.
+			string[] dependencies = null;
+			if (!m_Dependencies.TryGetValue(assetBundleName, out dependencies) )
+				return bundle;
+			
+			// Make sure all dependencies are loaded
+			foreach(var dependency in dependencies)
+			{
+				if (m_DownloadingErrors.TryGetValue(assetBundleName, out error) )
+					return bundle;
+	
+				// Wait all the dependent assetBundles being loaded.
+				LoadedAssetBundle dependentBundle;
+				m_LoadedAssetBundles.TryGetValue(dependency, out dependentBundle);
+				if (dependentBundle == null)
+					return null;
+			}
+	
+			return bundle;
+		}
+	
+		static public AssetBundleLoadManifestOperation Initialize ()
+		{
+			return Initialize(Utility.GetPlatformName());
+		}
+			
+	
+		// Load AssetBundleManifest.
+		static public AssetBundleLoadManifestOperation Initialize (string manifestAssetBundleName)
+		{
+	#if UNITY_EDITOR
+			Log (LogType.Info, "Simulation Mode: " + (SimulateAssetBundleInEditor ? "Enabled" : "Disabled"));
+	#endif
+	
+			var go = new GameObject("AssetBundleManager", typeof(AssetBundleManager));
+			DontDestroyOnLoad(go);
+		
+	#if UNITY_EDITOR	
+			// If we're in Editor simulation mode, we don't need the manifest assetBundle.
+			if (SimulateAssetBundleInEditor)
+				return null;
+	#endif
+	
+			LoadAssetBundle(manifestAssetBundleName, true);
+			var operation = new AssetBundleLoadManifestOperation (manifestAssetBundleName, "AssetBundleManifest", typeof(AssetBundleManifest));
+			m_InProgressOperations.Add (operation);
+			return operation;
+		}
+		
+		// Load AssetBundle and its dependencies.
+		static protected void LoadAssetBundle(string assetBundleName, bool isLoadingAssetBundleManifest = false)
+		{
+			Log(LogType.Info, "Loading Asset Bundle " + (isLoadingAssetBundleManifest ? "Manifest: " : ": ") + assetBundleName);
+	
+	#if UNITY_EDITOR
+			// If we're in Editor simulation mode, we don't have to really load the assetBundle and its dependencies.
+			if (SimulateAssetBundleInEditor)
+				return;
+	#endif
+	
+			if (!isLoadingAssetBundleManifest)
+			{
+				if (m_AssetBundleManifest == null)
+				{
+					Debug.LogError("Please initialize AssetBundleManifest by calling AssetBundleManager.Initialize()");
+					return;
+				}
+			}
+	
+			// Check if the assetBundle has already been processed.
+			bool isAlreadyProcessed = LoadAssetBundleInternal(assetBundleName, isLoadingAssetBundleManifest);
+	
+			// Load dependencies.
+			if (!isAlreadyProcessed && !isLoadingAssetBundleManifest)
+				LoadDependencies(assetBundleName);
+		}
+		
+		// Remaps the asset bundle name to the best fitting asset bundle variant.
+		static protected string RemapVariantName(string assetBundleName)
+		{
+			string[] bundlesWithVariant = m_AssetBundleManifest.GetAllAssetBundlesWithVariant();
+
+			string[] split = assetBundleName.Split('.');
+
+			int bestFit = int.MaxValue;
+			int bestFitIndex = -1;
+			// Loop all the assetBundles with variant to find the best fit variant assetBundle.
+			for (int i = 0; i < bundlesWithVariant.Length; i++)
+			{
+				string[] curSplit = bundlesWithVariant[i].Split('.');
+				if (curSplit[0] != split[0])
+					continue;
+				
+				int found = System.Array.IndexOf(m_ActiveVariants, curSplit[1]);
+				
+				// If there is no active variant found. We still want to use the first 
+				if (found == -1)
+					found = int.MaxValue-1;
+						
+				if (found < bestFit)
+				{
+					bestFit = found;
+					bestFitIndex = i;
+				}
+			}
+			
+			if (bestFit == int.MaxValue-1)
+			{
+				Debug.LogWarning("Ambigious asset bundle variant chosen because there was no matching active variant: " + bundlesWithVariant[bestFitIndex]);
+			}
+			
+			if (bestFitIndex != -1)
+			{
+				return bundlesWithVariant[bestFitIndex];
+			}
+			else
+			{
+				return assetBundleName;
+			}
+		}
+	
+		// Where we actuall call WWW to download the assetBundle.
+		static protected bool LoadAssetBundleInternal (string assetBundleName, bool isLoadingAssetBundleManifest)
+		{
+			// Already loaded.
+			LoadedAssetBundle bundle = null;
+			m_LoadedAssetBundles.TryGetValue(assetBundleName, out bundle);
+			if (bundle != null)
+			{
+				bundle.m_ReferencedCount++;
+				return true;
+			}
+	
+			// @TODO: Do we need to consider the referenced count of WWWs?
+			// In the demo, we never have duplicate WWWs as we wait LoadAssetAsync()/LoadLevelAsync() to be finished before calling another LoadAssetAsync()/LoadLevelAsync().
+			// But in the real case, users can call LoadAssetAsync()/LoadLevelAsync() several times then wait them to be finished which might have duplicate WWWs.
+			if (m_DownloadingWWWs.ContainsKey(assetBundleName) )
+				return true;
+	
+			WWW download = null;
+			string url = m_BaseDownloadingURL + assetBundleName;
+		
+			// For manifest assetbundle, always download it as we don't have hash for it.
+			if (isLoadingAssetBundleManifest)
+				download = new WWW(url);
+			else
+				download = WWW.LoadFromCacheOrDownload(url, m_AssetBundleManifest.GetAssetBundleHash(assetBundleName), 0); 
+	
+			m_DownloadingWWWs.Add(assetBundleName, download);
+	
+			return false;
+		}
+	
+		// Where we get all the dependencies and load them all.
+		static protected void LoadDependencies(string assetBundleName)
+		{
+			if (m_AssetBundleManifest == null)
+			{
+				Debug.LogError("Please initialize AssetBundleManifest by calling AssetBundleManager.Initialize()");
+				return;
+			}
+	
+			// Get dependecies from the AssetBundleManifest object..
+			string[] dependencies = m_AssetBundleManifest.GetAllDependencies(assetBundleName);
+			if (dependencies.Length == 0)
+				return;
+				
+			for (int i=0;i<dependencies.Length;i++)
+				dependencies[i] = RemapVariantName (dependencies[i]);
+				
+			// Record and load all dependencies.
+			m_Dependencies.Add(assetBundleName, dependencies);
+			for (int i=0;i<dependencies.Length;i++)
+				LoadAssetBundleInternal(dependencies[i], false);
+		}
+	
+		// Unload assetbundle and its dependencies.
+		static public void UnloadAssetBundle(string assetBundleName)
+		{
+	#if UNITY_EDITOR
+			// If we're in Editor simulation mode, we don't have to load the manifest assetBundle.
+			if (SimulateAssetBundleInEditor)
+				return;
+	#endif
+	
+			//Debug.Log(m_LoadedAssetBundles.Count + " assetbundle(s) in memory before unloading " + assetBundleName);
+	
+			UnloadAssetBundleInternal(assetBundleName);
+			UnloadDependencies(assetBundleName);
+	
+			//Debug.Log(m_LoadedAssetBundles.Count + " assetbundle(s) in memory after unloading " + assetBundleName);
+		}
+	
+		static protected void UnloadDependencies(string assetBundleName)
+		{
+			string[] dependencies = null;
+			if (!m_Dependencies.TryGetValue(assetBundleName, out dependencies) )
+				return;
+	
+			// Loop dependencies.
+			foreach(var dependency in dependencies)
+			{
+				UnloadAssetBundleInternal(dependency);
+			}
+	
+			m_Dependencies.Remove(assetBundleName);
+		}
+	
+		static protected void UnloadAssetBundleInternal(string assetBundleName)
+		{
+			string error;
+			LoadedAssetBundle bundle = GetLoadedAssetBundle(assetBundleName, out error);
+			if (bundle == null)
+				return;
+	
+			if (--bundle.m_ReferencedCount == 0)
+			{
+				bundle.m_AssetBundle.Unload(false);
+				m_LoadedAssetBundles.Remove(assetBundleName);
+	
+				Log(LogType.Info, assetBundleName + " has been unloaded successfully");
+			}
+		}
+	
+		void Update()
+		{
+			// Collect all the finished WWWs.
+			var keysToRemove = new List<string>();
+			foreach (var keyValue in m_DownloadingWWWs)
+			{
+				WWW download = keyValue.Value;
+	
+				// If downloading fails.
+				if (download.error != null)
+				{
+					m_DownloadingErrors.Add(keyValue.Key, string.Format("Failed downloading bundle {0} from {1}: {2}", keyValue.Key, download.url, download.error));
+					keysToRemove.Add(keyValue.Key);
+					continue;
+				}
+	
+				// If downloading succeeds.
+				if(download.isDone)
+				{
+					AssetBundle bundle = download.assetBundle;
+					if (bundle == null)
+					{
+						m_DownloadingErrors.Add(keyValue.Key, string.Format("{0} is not a valid asset bundle.", keyValue.Key));
+						keysToRemove.Add(keyValue.Key);
+						continue;
+					}
+				
+					//Debug.Log("Downloading " + keyValue.Key + " is done at frame " + Time.frameCount);
+					m_LoadedAssetBundles.Add(keyValue.Key, new LoadedAssetBundle(download.assetBundle) );
+					keysToRemove.Add(keyValue.Key);
+				}
+			}
+	
+			// Remove the finished WWWs.
+			foreach( var key in keysToRemove)
+			{
+				WWW download = m_DownloadingWWWs[key];
+				m_DownloadingWWWs.Remove(key);
+				download.Dispose();
+			}
+	
+			// Update all in progress operations
+			for (int i=0;i<m_InProgressOperations.Count;)
+			{
+				if (!m_InProgressOperations[i].Update())
+				{
+					m_InProgressOperations.RemoveAt(i);
+				}
+				else
+					i++;
+			}
+		}
+	
+		// Load asset from the given assetBundle.
+		static public AssetBundleLoadAssetOperation LoadAssetAsync (string assetBundleName, string assetName, System.Type type)
+		{
+			Log(LogType.Info, "Loading " + assetName + " from " + assetBundleName + " bundle");
+	
+			AssetBundleLoadAssetOperation operation = null;
+	#if UNITY_EDITOR
+			if (SimulateAssetBundleInEditor)
+			{
+				string[] assetPaths = AssetDatabase.GetAssetPathsFromAssetBundleAndAssetName(assetBundleName, assetName);
+				if (assetPaths.Length == 0)
+				{
+					Debug.LogError("There is no asset with name \"" + assetName + "\" in " + assetBundleName);
+					return null;
+				}
+	
+				// @TODO: Now we only get the main object from the first asset. Should consider type also.
+				Object target = AssetDatabase.LoadMainAssetAtPath(assetPaths[0]);
+				operation = new AssetBundleLoadAssetOperationSimulation (target);
+			}
+			else
+	#endif
+			{
+				assetBundleName = RemapVariantName (assetBundleName);
+				LoadAssetBundle (assetBundleName);
+				operation = new AssetBundleLoadAssetOperationFull (assetBundleName, assetName, type);
+	
+				m_InProgressOperations.Add (operation);
+			}
+	
+			return operation;
+		}
+	
+		// Load level from the given assetBundle.
+		static public AssetBundleLoadOperation LoadLevelAsync (string assetBundleName, string levelName, bool isAdditive)
+		{
+			Log(LogType.Info, "Loading " + levelName + " from " + assetBundleName + " bundle");
+	
+			AssetBundleLoadOperation operation = null;
+	#if UNITY_EDITOR
+			if (SimulateAssetBundleInEditor)
+			{
+				operation = new AssetBundleLoadLevelSimulationOperation(assetBundleName, levelName, isAdditive);
+			}
+			else
+	#endif
+			{
+				assetBundleName = RemapVariantName(assetBundleName);
+				LoadAssetBundle (assetBundleName);
+				operation = new AssetBundleLoadLevelOperation (assetBundleName, levelName, isAdditive);
+	
+				m_InProgressOperations.Add (operation);
+			}
+	
+			return operation;
+		}
+	} // End of AssetBundleManager.
+}

Assets/AssetBundleManager/AssetBundleManager.cs.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 6309cb12c9f62482c8451f716f97d470
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 

Assets/AssetBundleManager/Editor.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: ff5782c7c93fa460fb79d0aa4097c52b
+folderAsset: yes
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/AssetBundleManager/Editor/AssetBundleServer.exe.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 59c71df8bbeda4a1a994a635b0aa6675
+timeCreated: 1431456701
+licenseType: Store
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/AssetBundleManager/Editor/AssetbundlesMenuItems.cs

@@ -0,0 +1,30 @@
+using UnityEngine;
+using UnityEditor;
+using System.Collections;
+
+namespace AssetBundles
+{
+	public class AssetBundlesMenuItems
+	{
+		const string kSimulationMode = "Assets/AssetBundles/Simulation Mode";
+	
+		[MenuItem(kSimulationMode)]
+		public static void ToggleSimulationMode ()
+		{
+			AssetBundleManager.SimulateAssetBundleInEditor = !AssetBundleManager.SimulateAssetBundleInEditor;
+		}
+	
+		[MenuItem(kSimulationMode, true)]
+		public static bool ToggleSimulationModeValidate ()
+		{
+			Menu.SetChecked(kSimulationMode, AssetBundleManager.SimulateAssetBundleInEditor);
+			return true;
+		}
+		
+		[MenuItem ("Assets/AssetBundles/Build AssetBundles")]
+		static public void BuildAssetBundles ()
+		{
+			BuildScript.BuildAssetBundles();
+		}
+	}
+}

Assets/AssetBundleManager/Editor/AssetbundlesMenuItems.cs.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 0906f670aa52147688cf79b1e471f36d
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 

Assets/AssetBundleManager/Editor/BuildScript.cs

@@ -0,0 +1,161 @@
+using UnityEngine;
+using UnityEditor;
+using UnityEditor.Callbacks;
+using System.Collections;
+using System.Collections.Generic;
+using System.IO;
+using System.Net;
+using System.Net.Sockets;
+
+namespace AssetBundles
+{
+	public class BuildScript
+	{
+		public static string overloadedDevelopmentServerURL = "";
+	
+		public static void BuildAssetBundles()
+		{
+			// Choose the output path according to the build target.
+			string outputPath = Path.Combine(Utility.AssetBundlesOutputPath,  Utility.GetPlatformName());
+			if (!Directory.Exists(outputPath) )
+				Directory.CreateDirectory (outputPath);
+	
+			//@TODO: use append hash... (Make sure pipeline works correctly with it.)
+			BuildPipeline.BuildAssetBundles (outputPath, BuildAssetBundleOptions.None, EditorUserBuildSettings.activeBuildTarget);
+		}
+	
+		public static void WriteServerURL()
+		{
+			string downloadURL;
+			if (string.IsNullOrEmpty(overloadedDevelopmentServerURL) == false)
+			{
+				downloadURL = overloadedDevelopmentServerURL;
+			}
+			else
+			{
+				IPHostEntry host;
+				string localIP = "";
+				host = Dns.GetHostEntry(Dns.GetHostName());
+				foreach (IPAddress ip in host.AddressList)
+				{
+					if (ip.AddressFamily == AddressFamily.InterNetwork)
+					{
+						localIP = ip.ToString();
+						break;
+					}
+				}
+				downloadURL = "http://"+localIP+":7888/";
+			}
+			
+			string assetBundleManagerResourcesDirectory = "Assets/AssetBundleManager/Resources";
+			string assetBundleUrlPath = Path.Combine (assetBundleManagerResourcesDirectory, "AssetBundleServerURL.bytes");
+			Directory.CreateDirectory(assetBundleManagerResourcesDirectory);
+			File.WriteAllText(assetBundleUrlPath, downloadURL);
+			AssetDatabase.Refresh();
+		}
+	
+		public static void BuildPlayer()
+		{
+			var outputPath = EditorUtility.SaveFolderPanel("Choose Location of the Built Game", "", "");
+			if (outputPath.Length == 0)
+				return;
+	
+			string[] levels = GetLevelsFromBuildSettings();
+			if (levels.Length == 0)
+			{
+				Debug.Log("Nothing to build.");
+				return;
+			}
+	
+			string targetName = GetBuildTargetName(EditorUserBuildSettings.activeBuildTarget);
+			if (targetName == null)
+				return;
+	
+			// Build and copy AssetBundles.
+			BuildScript.BuildAssetBundles();
+			WriteServerURL();
+	
+			BuildOptions option = EditorUserBuildSettings.development ? BuildOptions.Development : BuildOptions.None;
+			BuildPipeline.BuildPlayer(levels, outputPath + targetName, EditorUserBuildSettings.activeBuildTarget, option);
+		}
+		
+		public static void BuildStandalonePlayer()
+		{
+			var outputPath = EditorUtility.SaveFolderPanel("Choose Location of the Built Game", "", "");
+			if (outputPath.Length == 0)
+				return;
+			
+			string[] levels = GetLevelsFromBuildSettings();
+			if (levels.Length == 0)
+			{
+				Debug.Log("Nothing to build.");
+				return;
+			}
+			
+			string targetName = GetBuildTargetName(EditorUserBuildSettings.activeBuildTarget);
+			if (targetName == null)
+				return;
+			
+			// Build and copy AssetBundles.
+			BuildScript.BuildAssetBundles();
+			BuildScript.CopyAssetBundlesTo(Path.Combine(Application.streamingAssetsPath, Utility.AssetBundlesOutputPath) );
+			AssetDatabase.Refresh();
+			
+			BuildOptions option = EditorUserBuildSettings.development ? BuildOptions.Development : BuildOptions.None;
+			BuildPipeline.BuildPlayer(levels, outputPath + targetName, EditorUserBuildSettings.activeBuildTarget, option);
+		}
+	
+		public static string GetBuildTargetName(BuildTarget target)
+		{
+			switch(target)
+			{
+			case BuildTarget.Android :
+				return "/test.apk";
+			case BuildTarget.StandaloneWindows:
+			case BuildTarget.StandaloneWindows64:
+				return "/test.exe";
+			case BuildTarget.StandaloneOSX:
+				return "/test.app";
+			case BuildTarget.WebGL:
+				return "";
+				// Add more build targets for your own.
+			default:
+				Debug.Log("Target not implemented.");
+				return null;
+			}
+		}
+	
+		static void CopyAssetBundlesTo(string outputPath)
+		{
+			// Clear streaming assets folder.
+			FileUtil.DeleteFileOrDirectory(Application.streamingAssetsPath);
+			Directory.CreateDirectory(outputPath);
+	
+			string outputFolder = Utility.GetPlatformName();
+	
+			// Setup the source folder for assetbundles.
+			var source = Path.Combine(Path.Combine(System.Environment.CurrentDirectory, Utility.AssetBundlesOutputPath), outputFolder);
+			if (!System.IO.Directory.Exists(source) )
+				Debug.Log("No assetBundle output folder, try to build the assetBundles first.");
+	
+			// Setup the destination folder for assetbundles.
+			var destination = System.IO.Path.Combine(outputPath, outputFolder);
+			if (System.IO.Directory.Exists(destination) )
+				FileUtil.DeleteFileOrDirectory(destination);
+			
+			FileUtil.CopyFileOrDirectory(source, destination);
+		}
+	
+		static string[] GetLevelsFromBuildSettings()
+		{
+			List<string> levels = new List<string>();
+			for(int i = 0 ; i < EditorBuildSettings.scenes.Length; ++i)
+			{
+				if (EditorBuildSettings.scenes[i].enabled)
+					levels.Add(EditorBuildSettings.scenes[i].path);
+			}
+	
+			return levels.ToArray();
+		}
+	}
+}

Assets/AssetBundleManager/Editor/BuildScript.cs.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: f19ef23648157ec49ab02b99bee74403
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 

Assets/AssetBundleManager/Editor/ExecuteInternalMono.cs

@@ -0,0 +1,128 @@
+using UnityEditor;
+using UnityEngine;
+using System.Text.RegularExpressions;
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using System;
+
+namespace AssetBundles
+{
+	class MonoInstallationFinder
+	{
+		public static string GetFrameWorksFolder()
+		{
+			var editorAppPath = EditorApplication.applicationPath;
+			if (Application.platform == RuntimePlatform.WindowsEditor)
+				return Path.Combine(Path.GetDirectoryName(editorAppPath), "Data");
+			else if (Application.platform == RuntimePlatform.OSXEditor)
+				return Path.Combine(editorAppPath, Path.Combine("Contents", "Frameworks"));
+			else // Linux...?
+				return Path.Combine(Path.GetDirectoryName(editorAppPath), "Data");
+		}
+		
+		public static string GetProfileDirectory (BuildTarget target, string profile)
+		{
+			var monoprefix = GetMonoInstallation();
+			return Path.Combine(monoprefix, Path.Combine("lib", Path.Combine("mono", profile)));
+		}
+		
+		public static string GetMonoInstallation()
+		{
+			#if INCLUDE_MONO_2_12
+			return GetMonoInstallation("MonoBleedingEdge");
+			#else
+			return GetMonoInstallation("Mono");
+			#endif
+		}
+		
+		public static string GetMonoInstallation(string monoName)
+		{
+			return Path.Combine(GetFrameWorksFolder(), monoName);
+		}
+	}
+	
+	class ExecuteInternalMono
+	{
+		private static readonly Regex UnsafeCharsWindows = new Regex("[^A-Za-z0-9\\_\\-\\.\\:\\,\\/\\@\\\\]");
+		private static readonly Regex UnescapeableChars = new Regex("[\\x00-\\x08\\x10-\\x1a\\x1c-\\x1f\\x7f\\xff]");
+		private static readonly Regex Quotes = new Regex("\"");
+		
+		public ProcessStartInfo processStartInfo = null;
+		
+		public static string PrepareFileName(string input)
+		{
+			if (Application.platform == RuntimePlatform.OSXEditor)
+			{
+				return EscapeCharsQuote(input);
+			}
+			return EscapeCharsWindows(input);
+		}
+		
+		public static string EscapeCharsQuote(string input)
+		{
+			if (input.IndexOf('\'') == -1)
+			{
+				return "'" + input + "'";
+			}
+			if (input.IndexOf('"') == -1)
+			{
+				return "\"" + input + "\"";
+			}
+			return null;
+		}
+		
+		public static string EscapeCharsWindows(string input)
+		{
+			if (input.Length == 0)
+			{
+				return "\"\"";
+			}
+			if (UnescapeableChars.IsMatch(input))
+			{
+				UnityEngine.Debug.LogWarning("Cannot escape control characters in string");
+				return "\"\"";
+			}
+			if (UnsafeCharsWindows.IsMatch(input))
+			{
+				return "\"" + Quotes.Replace(input, "\"\"") + "\"";
+			}
+			return input;
+		}
+		
+		public static ProcessStartInfo GetProfileStartInfoForMono(string monodistribution, string profile, string executable, string arguments, bool setMonoEnvironmentVariables)
+		{
+			var monoexe = PathCombine(monodistribution, "bin", "mono");
+			var profileAbspath = PathCombine(monodistribution, "lib", "mono", profile);
+			if (Application.platform == RuntimePlatform.WindowsEditor)
+				monoexe = PrepareFileName(monoexe + ".exe");
+			
+			var startInfo = new ProcessStartInfo
+			{
+				Arguments = PrepareFileName(executable) + " " + arguments,
+				CreateNoWindow = true,
+				FileName = monoexe,
+				RedirectStandardError = true,
+				RedirectStandardOutput = true,
+				WorkingDirectory = Application.dataPath + "/..",
+				UseShellExecute = false
+			};
+			
+			if (setMonoEnvironmentVariables)
+			{
+				startInfo.EnvironmentVariables["MONO_PATH"] = profileAbspath;
+				startInfo.EnvironmentVariables["MONO_CFG_DIR"] = PathCombine(monodistribution, "etc");
+			}
+			return startInfo;
+		}
+		
+		static string PathCombine(params string[] parts)
+		{
+			var path = parts[0];
+			for (var i = 1; i < parts.Length; ++i)
+				path = Path.Combine(path, parts[i]);
+			return path;
+		}
+	}
+}

Assets/AssetBundleManager/Editor/ExecuteInternalMono.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 8127c6674aa9d419ebdf60f64e3bfbb9
+timeCreated: 1431509895
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/AssetBundleManager/Editor/LaunchAssetBundleServer.cs

@@ -0,0 +1,99 @@
+using UnityEngine;
+using UnityEditor;
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using System;
+using System.Net;
+using System.Threading;
+using UnityEditor.Utils;
+
+namespace AssetBundles
+{
+	internal class LaunchAssetBundleServer : ScriptableSingleton<LaunchAssetBundleServer>
+	{
+		const string kLocalAssetbundleServerMenu = "Assets/AssetBundles/Local AssetBundle Server";
+
+		[SerializeField]
+		int 	m_ServerPID = 0;
+
+		[MenuItem (kLocalAssetbundleServerMenu)]
+		public static void ToggleLocalAssetBundleServer ()
+		{
+			bool isRunning = IsRunning();
+			if (!isRunning)
+			{
+				Run ();
+			}
+			else
+			{
+				KillRunningAssetBundleServer ();
+			}
+		}
+
+		[MenuItem (kLocalAssetbundleServerMenu, true)]
+		public static bool ToggleLocalAssetBundleServerValidate ()
+		{
+			bool isRunnning = IsRunning ();
+			Menu.SetChecked(kLocalAssetbundleServerMenu, isRunnning);
+			return true;
+		}
+
+		static bool IsRunning ()
+		{
+			if (instance.m_ServerPID == 0)
+				return false;
+
+			var process = Process.GetProcessById (instance.m_ServerPID);
+			if (process == null)
+				return false;
+
+			return !process.HasExited;
+		}
+
+		static void KillRunningAssetBundleServer ()
+		{
+			// Kill the last time we ran
+			try
+			{
+				if (instance.m_ServerPID == 0)
+					return;
+
+				var lastProcess = Process.GetProcessById (instance.m_ServerPID);
+				lastProcess.Kill();
+				instance.m_ServerPID = 0;
+			}
+			catch
+			{
+			}
+		}
+		
+		static void Run ()
+		{
+			string pathToAssetServer = Path.Combine(Application.dataPath, "AssetBundleManager/Editor/AssetBundleServer.exe");
+			string pathToApp = Application.dataPath.Substring(0, Application.dataPath.LastIndexOf('/'));
+	
+			KillRunningAssetBundleServer();
+			
+			BuildScript.WriteServerURL();
+			
+			string args = Path.Combine (pathToApp, "AssetBundles");
+			args = string.Format("\"{0}\" {1}", args, Process.GetCurrentProcess().Id);
+			ProcessStartInfo startInfo = ExecuteInternalMono.GetProfileStartInfoForMono(MonoInstallationFinder.GetMonoInstallation("MonoBleedingEdge"), "4.0", pathToAssetServer, args, true);
+			startInfo.WorkingDirectory = Path.Combine(System.Environment.CurrentDirectory, "AssetBundles");
+			startInfo.UseShellExecute = false;
+			Process launchProcess = Process.Start(startInfo);
+			if (launchProcess == null || launchProcess.HasExited == true || launchProcess.Id == 0)
+			{
+				//Unable to start process
+				UnityEngine.Debug.LogError ("Unable Start AssetBundleServer process");
+			}
+			else
+			{
+				//We seem to have launched, let's save the PID
+				instance.m_ServerPID = launchProcess.Id;
+			}
+		}
+	}
+}

Assets/AssetBundleManager/Editor/LaunchAssetBundleServer.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 23a84bb10f0e2473bbe44fcb9c23e157
+timeCreated: 1429472835
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/AssetBundleManager/Resources.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 22022de167524490db7116e26e11c5ba
+folderAsset: yes
+timeCreated: 1431881731
+licenseType: Store
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/AssetBundleManager/Resources/AssetBundleServerURL.bytes

@@ -0,0 +1 @@
+http://192.168.1.115:7888/

Assets/AssetBundleManager/Resources/AssetBundleServerURL.bytes.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 412195e63b8901646adb12ef3f33f415
+timeCreated: 1438698780
+licenseType: Store
+TextScriptImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/AssetBundleManager/Utility.cs

@@ -0,0 +1,66 @@
+using UnityEngine;
+#if UNITY_EDITOR	
+using UnityEditor;
+#endif
+
+namespace AssetBundles
+{
+	public class Utility
+	{
+		public const string AssetBundlesOutputPath = "AssetBundles";
+	
+		public static string GetPlatformName()
+		{
+	#if UNITY_EDITOR
+			return GetPlatformForAssetBundles(EditorUserBuildSettings.activeBuildTarget);
+	#else
+			return GetPlatformForAssetBundles(Application.platform);
+	#endif
+		}
+	
+	#if UNITY_EDITOR
+		private static string GetPlatformForAssetBundles(BuildTarget target)
+		{
+			switch(target)
+			{
+			case BuildTarget.Android:
+				return "Android";
+			case BuildTarget.iOS:
+				return "iOS";
+			case BuildTarget.WebGL:
+                    return "WebGL";
+			case BuildTarget.StandaloneWindows:
+			case BuildTarget.StandaloneWindows64:
+				return "Windows";
+			case BuildTarget.StandaloneOSX:
+				return "OSX";
+				// Add more build targets for your own.
+				// If you add more targets, don't forget to add the same platforms to GetPlatformForAssetBundles(RuntimePlatform) function.
+			default:
+				return null;
+			}
+		}
+	#endif
+	
+		private static string GetPlatformForAssetBundles(RuntimePlatform platform)
+		{
+			switch(platform)
+			{
+			case RuntimePlatform.Android:
+				return "Android";
+			case RuntimePlatform.IPhonePlayer:
+				return "iOS";
+			case RuntimePlatform.WebGLPlayer:
+				return "WebGL";
+			case RuntimePlatform.WindowsPlayer:
+				return "Windows";
+			case RuntimePlatform.OSXPlayer:
+				return "OSX";
+				// Add more build targets for your own.
+				// If you add more targets, don't forget to add the same platforms to GetPlatformForAssetBundles(RuntimePlatform) function.
+			default:
+				return null;
+			}
+		}
+	}
+}

Assets/AssetBundleManager/Utility.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: e5eb071745f174d8b8fd080714b40b93
+timeCreated: 1431883330
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: