com.amanotes.gdk 0.2.75 → 0.2.78

package/Runtime/Core/GDKPrefabPool.cs

@@ -0,0 +1,571 @@
+using UnityEngine;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Amanotes.Core.Internal
+{
+	public sealed class GDKPrefabPool : MonoBehaviour
+	{
+		public enum StartupPoolMode
+		{
+			Awake,
+			Start,
+			CallManually
+		};
+
+		[System.Serializable]
+		public class StartupPool
+		{
+			public int size;
+			public GameObject prefab;
+		}
+
+		private static GDKPrefabPool _instance;
+		private static readonly List<GameObject> tempList = new List<GameObject>();
+
+		private readonly Dictionary<GameObject, List<GameObject>> _pooledObjects = new Dictionary<GameObject, List<GameObject>>();
+		private readonly Dictionary<GameObject, GameObject> _spawnedObjects = new Dictionary<GameObject, GameObject>();
+
+		public StartupPoolMode startupPoolMode;
+		public StartupPool[] startupPools;
+
+		private bool _startupPoolsCreated;
+
+		void Awake()
+		{
+			if (_instance != null)
+			{
+				Destroy(this);
+				return;
+			}
+			_instance = this;
+			DontDestroyOnLoad(this);
+			if (startupPoolMode == StartupPoolMode.Awake)
+				CreateStartupPools();
+		}
+
+		void Start()
+		{
+			if (startupPoolMode == StartupPoolMode.Start)
+				CreateStartupPools();
+		}
+
+		private static void CreateStartupPools()
+		{
+			if (instance._startupPoolsCreated)
+				return;
+			instance._startupPoolsCreated = true;
+			var pools = instance.startupPools;
+			if (pools == null || pools.Length <= 0)
+				return;
+			foreach (var t in pools)
+				CreatePool(t.prefab, t.size);
+		}
+
+		public static void CreatePool<T>(T prefab, int initialPoolSize) where T : Component
+		{
+			CreatePool(prefab.gameObject, initialPoolSize);
+		}
+
+		public static void CreatePool(GameObject prefab, int initialPoolSize)
+		{
+			if (prefab == null || instance._pooledObjects.ContainsKey(prefab))
+				return;
+			var list = new List<GameObject>();
+			instance._pooledObjects.Add(prefab, list);
+
+			if (initialPoolSize <= 0)
+				return;
+			bool active = prefab.activeSelf;
+			prefab.SetActive(false);
+			Transform parent = instance.transform;
+			while (list.Count < initialPoolSize)
+			{
+				var obj = Instantiate(prefab, parent, true);
+				list.Add(obj);
+			}
+
+			prefab.SetActive(active);
+		}
+
+		public static T Spawn<T>(T prefab, Transform parent, Vector3 position, Quaternion rotation) where T : Component
+		{
+			return Spawn(prefab.gameObject, parent, position, rotation).GetComponent<T>();
+		}
+
+		public static T Spawn<T>(T prefab, Vector3 position, Quaternion rotation) where T : Component
+		{
+			return Spawn(prefab.gameObject, null, position, rotation).GetComponent<T>();
+		}
+
+		public static T Spawn<T>(T prefab, Transform parent, Vector3 position) where T : Component
+		{
+			return Spawn(prefab.gameObject, parent, position, Quaternion.identity).GetComponent<T>();
+		}
+
+		public static T Spawn<T>(T prefab, Vector3 position) where T : Component
+		{
+			return Spawn(prefab.gameObject, null, position, Quaternion.identity).GetComponent<T>();
+		}
+
+		public static T Spawn<T>(T prefab, Transform parent) where T : Component
+		{
+			return Spawn(prefab.gameObject, parent, Vector3.zero, Quaternion.identity).GetComponent<T>();
+		}
+
+		public static T Spawn<T>(T prefab) where T : Component
+		{
+			return Spawn(prefab.gameObject, null, Vector3.zero, Quaternion.identity).GetComponent<T>();
+		}
+
+		public static GameObject Spawn(GameObject prefab, Transform parent, Vector3 position, Quaternion rotation)
+		{
+			Transform trans;
+			GameObject obj;
+			if (instance._pooledObjects.TryGetValue(prefab, out var list))
+			{
+				obj = null;
+				if (list.Count > 0)
+				{
+					while (obj == null && list.Count > 0)
+					{
+						obj = list[0];
+						list.RemoveAt(0);
+					}
+
+					if (obj != null)
+					{
+						trans = obj.transform;
+						trans.SetParent(parent);
+						trans.localScale = prefab.transform.localScale;
+						trans.localPosition = position;
+						trans.localRotation = rotation;
+						obj.SetActive(true);
+						instance._spawnedObjects.Add(obj, prefab);
+						return obj;
+					}
+				}
+
+				obj = Instantiate(prefab);
+				trans = obj.transform;
+				trans.SetParent(parent);
+				trans.localScale = prefab.transform.localScale;
+				trans.localPosition = position;
+				trans.localRotation = rotation;
+				instance._spawnedObjects.Add(obj, prefab);
+				return obj;
+			}
+			else
+			{
+				obj = Instantiate(prefab);
+				trans = obj.GetComponent<Transform>();
+				trans.SetParent(parent);
+				trans.localScale = prefab.transform.localScale;
+				trans.localPosition = position;
+				trans.localRotation = rotation;
+				return obj;
+			}
+		}
+
+		public static GameObject Spawn(GameObject prefab, Transform parent, Vector3 position)
+		{
+			return Spawn(prefab, parent, position, Quaternion.identity);
+		}
+
+		public static GameObject Spawn(GameObject prefab, Vector3 position, Quaternion rotation)
+		{
+			return Spawn(prefab, null, position, rotation);
+		}
+
+		public static GameObject Spawn(GameObject prefab, Transform parent)
+		{
+			return Spawn(prefab, parent, Vector3.zero, Quaternion.identity);
+		}
+
+		public static GameObject Spawn(GameObject prefab, Vector3 position)
+		{
+			return Spawn(prefab, null, position, Quaternion.identity);
+		}
+
+		public static GameObject Spawn(GameObject prefab)
+		{
+			return Spawn(prefab, null, Vector3.zero, Quaternion.identity);
+		}
+
+		public static void Recycle<T>(T obj) where T : Component
+		{
+			Recycle(obj.gameObject);
+		}
+
+		public static void Recycle(GameObject obj)
+		{
+			if (instance._spawnedObjects.TryGetValue(obj, out var prefab))
+				Recycle(obj, prefab);
+			else
+				Destroy(obj);
+		}
+
+		private static void Recycle(GameObject obj, GameObject prefab)
+		{
+			instance._pooledObjects[prefab].Add(obj);
+			instance._spawnedObjects.Remove(obj);
+			obj.transform.SetParent(instance.transform);
+			obj.SetActive(false);
+		}
+
+		public static void RecycleAll<T>(T prefab) where T : Component
+		{
+			RecycleAll(prefab.gameObject);
+		}
+
+		public static void RecycleAll(GameObject prefab)
+		{
+			foreach (var item in instance._spawnedObjects)
+				if (item.Value == prefab)
+					tempList.Add(item.Key);
+			foreach (var t in tempList)
+				Recycle(t);
+			tempList.Clear();
+		}
+
+		public static void RecycleAll()
+		{
+			tempList.AddRange(instance._spawnedObjects.Keys);
+			foreach (var t in tempList)
+				Recycle(t);
+			tempList.Clear();
+		}
+
+		public static bool IsSpawned(GameObject obj)
+		{
+			return instance._spawnedObjects.ContainsKey(obj);
+		}
+
+		public static int CountPooled<T>(T prefab) where T : Component
+		{
+			return CountPooled(prefab.gameObject);
+		}
+
+		public static int CountPooled(GameObject prefab)
+		{
+			if (instance._pooledObjects.TryGetValue(prefab, out var list))
+				return list.Count;
+			return 0;
+		}
+
+		public static int CountSpawned<T>(T prefab) where T : Component
+		{
+			return CountSpawned(prefab.gameObject);
+		}
+
+		public static int CountSpawned(GameObject prefab)
+		{
+			int count = 0;
+			foreach (var instancePrefab in instance._spawnedObjects.Values)
+				if (prefab == instancePrefab)
+					++count;
+			return count;
+		}
+
+		public static int CountAllPooled()
+		{
+			return instance._pooledObjects.Values.Sum(list => list.Count);
+		}
+
+		public static List<GameObject> GetPooled(GameObject prefab, List<GameObject> list, bool appendList)
+		{
+			list ??= new List<GameObject>();
+			if (!appendList)
+				list.Clear();
+			if (instance._pooledObjects.TryGetValue(prefab, out var pooled))
+				list.AddRange(pooled);
+			return list;
+		}
+
+		public static List<T> GetPooled<T>(T prefab, List<T> list, bool appendList) where T : Component
+		{
+			list ??= new List<T>();
+			if (!appendList)
+				list.Clear();
+			if (!instance._pooledObjects.TryGetValue(prefab.gameObject, out var pooled))
+				return list;
+			list.AddRange(pooled.Select(t => t.GetComponent<T>()));
+			return list;
+		}
+
+		public static List<GameObject> GetSpawned(GameObject prefab, List<GameObject> list, bool appendList)
+		{
+			list ??= new List<GameObject>();
+			if (!appendList)
+				list.Clear();
+			list.AddRange(from item in instance._spawnedObjects where item.Value == prefab select item.Key);
+			return list;
+		}
+
+		public static List<T> GetSpawned<T>(T prefab, List<T> list, bool appendList) where T : Component
+		{
+			list ??= new List<T>();
+			if (!appendList)
+				list.Clear();
+			var prefabObj = prefab.gameObject;
+			foreach (var item in instance._spawnedObjects)
+				if (item.Value == prefabObj)
+					list.Add(item.Key.GetComponent<T>());
+			return list;
+		}
+
+		public static void DestroyPooled(GameObject prefab)
+		{
+			if (!instance._pooledObjects.TryGetValue(prefab, out var pooled))
+				return;
+			foreach (var t in pooled)
+				Destroy(t);
+			pooled.Clear();
+		}
+
+		public static void DestroyPooled<T>(T prefab) where T : Component
+		{
+			DestroyPooled(prefab.gameObject);
+		}
+
+		public static void DestroyAll(GameObject prefab)
+		{
+			RecycleAll(prefab);
+			DestroyPooled(prefab);
+		}
+
+		public static void DestroyAll<T>(T prefab) where T : Component
+		{
+			DestroyAll(prefab.gameObject);
+		}
+
+		public static GDKPrefabPool instance
+		{
+			get
+			{
+				if (_instance != null)
+					return _instance;
+
+				_instance = FindObjectOfType<GDKPrefabPool>();
+				if (_instance != null)
+					return _instance;
+
+				var obj = new GameObject("ObjectPool")
+				{
+					transform =
+					{
+						localPosition = Vector3.zero,
+						localRotation = Quaternion.identity,
+						localScale = Vector3.one
+					}
+				};
+				_instance = obj.AddComponent<GDKPrefabPool>();
+				return _instance;
+			}
+		}
+	}
+
+	public static class ObjectPoolExtensions
+	{
+		public static void CreatePool<T>(this T prefab) where T : Component
+		{
+			GDKPrefabPool.CreatePool(prefab, 0);
+		}
+
+		public static void CreatePool<T>(this T prefab, int initialPoolSize) where T : Component
+		{
+			GDKPrefabPool.CreatePool(prefab, initialPoolSize);
+		}
+
+		public static void CreatePool(this GameObject prefab)
+		{
+			GDKPrefabPool.CreatePool(prefab, 0);
+		}
+
+		public static void CreatePool(this GameObject prefab, int initialPoolSize)
+		{
+			GDKPrefabPool.CreatePool(prefab, initialPoolSize);
+		}
+
+		public static T Spawn<T>(this T prefab, Transform parent, Vector3 position, Quaternion rotation)
+			where T : Component
+		{
+			return GDKPrefabPool.Spawn(prefab, parent, position, rotation);
+		}
+
+		public static T Spawn<T>(this T prefab, Vector3 position, Quaternion rotation) where T : Component
+		{
+			return GDKPrefabPool.Spawn(prefab, null, position, rotation);
+		}
+
+		public static T Spawn<T>(this T prefab, Transform parent, Vector3 position) where T : Component
+		{
+			return GDKPrefabPool.Spawn(prefab, parent, position, Quaternion.identity);
+		}
+
+		public static T Spawn<T>(this T prefab, Vector3 position) where T : Component
+		{
+			return GDKPrefabPool.Spawn(prefab, null, position, Quaternion.identity);
+		}
+
+		public static T Spawn<T>(this T prefab, Transform parent) where T : Component
+		{
+			return GDKPrefabPool.Spawn(prefab, parent, Vector3.zero, Quaternion.identity);
+		}
+
+		public static T Spawn<T>(this T prefab) where T : Component
+		{
+			return GDKPrefabPool.Spawn(prefab, null, Vector3.zero, Quaternion.identity);
+		}
+
+		public static GameObject Spawn(this GameObject prefab, Transform parent, Vector3 position, Quaternion rotation)
+		{
+			return GDKPrefabPool.Spawn(prefab, parent, position, rotation);
+		}
+
+		public static GameObject Spawn(this GameObject prefab, Vector3 position, Quaternion rotation)
+		{
+			return GDKPrefabPool.Spawn(prefab, null, position, rotation);
+		}
+
+		public static GameObject Spawn(this GameObject prefab, Transform parent, Vector3 position)
+		{
+			return GDKPrefabPool.Spawn(prefab, parent, position, Quaternion.identity);
+		}
+
+		public static GameObject Spawn(this GameObject prefab, Vector3 position)
+		{
+			return GDKPrefabPool.Spawn(prefab, null, position, Quaternion.identity);
+		}
+
+		public static GameObject Spawn(this GameObject prefab, Transform parent)
+		{
+			return GDKPrefabPool.Spawn(prefab, parent, Vector3.zero, Quaternion.identity);
+		}
+
+		public static GameObject Spawn(this GameObject prefab)
+		{
+			return GDKPrefabPool.Spawn(prefab, null, Vector3.zero, Quaternion.identity);
+		}
+
+		public static void Recycle<T>(this T obj) where T : Component
+		{
+			GDKPrefabPool.Recycle(obj);
+		}
+
+		public static void Recycle(this GameObject obj)
+		{
+			GDKPrefabPool.Recycle(obj);
+		}
+
+		public static void RecycleAll<T>(this T prefab) where T : Component
+		{
+			GDKPrefabPool.RecycleAll(prefab);
+		}
+
+		public static void RecycleAll(this GameObject prefab)
+		{
+			GDKPrefabPool.RecycleAll(prefab);
+		}
+
+		public static int CountPooled<T>(this T prefab) where T : Component
+		{
+			return GDKPrefabPool.CountPooled(prefab);
+		}
+
+		public static int CountPooled(this GameObject prefab)
+		{
+			return GDKPrefabPool.CountPooled(prefab);
+		}
+
+		public static int CountSpawned<T>(this T prefab) where T : Component
+		{
+			return GDKPrefabPool.CountSpawned(prefab);
+		}
+
+		public static int CountSpawned(this GameObject prefab)
+		{
+			return GDKPrefabPool.CountSpawned(prefab);
+		}
+
+		public static List<GameObject> GetSpawned(this GameObject prefab, List<GameObject> list, bool appendList)
+		{
+			return GDKPrefabPool.GetSpawned(prefab, list, appendList);
+		}
+
+		public static List<GameObject> GetSpawned(this GameObject prefab, List<GameObject> list)
+		{
+			return GDKPrefabPool.GetSpawned(prefab, list, false);
+		}
+
+		public static List<GameObject> GetSpawned(this GameObject prefab)
+		{
+			return GDKPrefabPool.GetSpawned(prefab, null, false);
+		}
+
+		public static List<T> GetSpawned<T>(this T prefab, List<T> list, bool appendList) where T : Component
+		{
+			return GDKPrefabPool.GetSpawned(prefab, list, appendList);
+		}
+
+		public static List<T> GetSpawned<T>(this T prefab, List<T> list) where T : Component
+		{
+			return GDKPrefabPool.GetSpawned(prefab, list, false);
+		}
+
+		public static List<T> GetSpawned<T>(this T prefab) where T : Component
+		{
+			return GDKPrefabPool.GetSpawned(prefab, null, false);
+		}
+
+		public static List<GameObject> GetPooled(this GameObject prefab, List<GameObject> list, bool appendList)
+		{
+			return GDKPrefabPool.GetPooled(prefab, list, appendList);
+		}
+
+		public static List<GameObject> GetPooled(this GameObject prefab, List<GameObject> list)
+		{
+			return GDKPrefabPool.GetPooled(prefab, list, false);
+		}
+
+		public static List<GameObject> GetPooled(this GameObject prefab)
+		{
+			return GDKPrefabPool.GetPooled(prefab, null, false);
+		}
+
+		public static List<T> GetPooled<T>(this T prefab, List<T> list, bool appendList) where T : Component
+		{
+			return GDKPrefabPool.GetPooled(prefab, list, appendList);
+		}
+
+		public static List<T> GetPooled<T>(this T prefab, List<T> list) where T : Component
+		{
+			return GDKPrefabPool.GetPooled(prefab, list, false);
+		}
+
+		public static List<T> GetPooled<T>(this T prefab) where T : Component
+		{
+			return GDKPrefabPool.GetPooled(prefab, null, false);
+		}
+
+		public static void DestroyPooled(this GameObject prefab)
+		{
+			GDKPrefabPool.DestroyPooled(prefab);
+		}
+
+		public static void DestroyPooled<T>(this T prefab) where T : Component
+		{
+			GDKPrefabPool.DestroyPooled(prefab.gameObject);
+		}
+
+		public static void DestroyAll(this GameObject prefab)
+		{
+			GDKPrefabPool.DestroyAll(prefab);
+		}
+
+		public static void DestroyAll<T>(this T prefab) where T : Component
+		{
+			GDKPrefabPool.DestroyAll(prefab.gameObject);
+		}
+	}
+}

package/Runtime/Core/GDKPrefabPool.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 9039521c948b9458382fee4138d2dff0
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Core/GDKRoutine.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections;
 using UnityEngine;
+using UnityEngine.Networking;
 using static Amanotes.Core.GDKDebug;
 
 namespace Amanotes.Core.Internal
@@ -76,13 +77,58 @@ namespace Amanotes.Core.Internal
         public static GDKRoutine StartCoroutine(IEnumerator action)
         {
             var routine = new GDKRoutine(action);
-            DoOnMainThread(routine.StartRoutine);
+            if (isOnMainThread)
+            {
+                routine.StartRoutine();
+            }
+            else
+            {
+                DoOnMainThread(routine.StartRoutine);    
+            }
+            
             return routine;
         }
 
         public static void StopCoroutine(GDKRoutine gdkRoutine)
         {
-            DoOnMainThread(() => { gdkRoutine?.StopRoutine(); });
+            if (gdkRoutine == null) return;
+            if (isOnMainThread)
+            {
+                gdkRoutine.StopRoutine();
+                return;
+            }
+            
+            DoOnMainThread(gdkRoutine.StopRoutine);
+        }
+
+        public static void DownloadURL(string url, Action<string> onComplete, Action<string> onError = null)
+        {
+            StartCoroutine(RequestRoutine(url, onComplete, onError));
+        }
+
+        private static IEnumerator RequestRoutine(string url, Action<string> onComplete, Action<string> onError)
+        {
+            using UnityWebRequest webRequest = UnityWebRequest.Get(url);
+            UnityWebRequestAsyncOperation request = webRequest.SendWebRequest();
+
+            if (Application.isPlaying)
+            {
+                yield return request;
+            }
+            else // request can not be yield in Edit mode so yield it manually
+            {
+                while (!request.isDone) yield return null;
+            }
+
+            if (webRequest.result == UnityWebRequest.Result.Success)
+            {
+                SafeInvoke(onComplete, webRequest.downloadHandler.text);
+                yield break;
+            }
+
+            LogWarning($"Download error <{url}>\n{webRequest.result}");
+            SafeInvoke(onError, webRequest.error);
+            SafeInvoke(onComplete, null);
         }
     }
 }

package/Runtime/Internal/AmaGDK.Internal.cs

@@ -46,7 +46,7 @@ namespace Amanotes.Core.Internal
 #if UNITY_EDITOR
 
         [MenuItem("GameObject/AmaGDK/Add AmaGDK Prefab", false, 10)]
-        private static void AddAmaGDKPrefab()
+        public static void AddAmaGDKPrefab()
         {
             AssetDatabase.ImportPackage(Res.AMAGDK_CONFIG_PACKAGE, false);
             var prefab = AssetDatabase.LoadAssetAtPath<GameObject>(AMAGDK_PREFAB);

package/Runtime/Internal/AmaGDK.Utils.cs

@@ -10,6 +10,9 @@ using UnityEngine;
 using UnityEngine.Profiling;
 using static Amanotes.Core.GDKDebug;
 
+using System.Threading.Tasks;
+using UnityEngine.Networking;
+
 namespace Amanotes.Core.Internal
 {
     public static partial class GDKUtils
@@ -251,6 +254,41 @@ namespace Amanotes.Core.Internal
             return content;
         }
 
+        public static async Task<string> LoadFromStreamingAssets(string fileName)
+        {
+            string filePath = Path.Combine(Application.streamingAssetsPath, fileName);
+
+            // Android
+            if (Application.platform == RuntimePlatform.Android)
+            {
+                using (UnityWebRequest request = UnityWebRequest.Get(filePath))
+                {
+                    var operation = request.SendWebRequest();
+                    while (!operation.isDone)
+                    {
+                        await Task.Yield();
+                    }
+                    if (request.result != UnityWebRequest.Result.Success)
+                    {
+                        LogWarning($"Error reading file: {request.error}");
+                        return null;
+                    }
+                    return request.downloadHandler.text;
+                }
+            }
+
+            // Other
+            try
+            {
+                return File.ReadAllText(filePath);
+            }
+            catch (Exception e)
+            {
+                LogWarning($"Error reading file: {e.Message}");
+            }
+            return null;
+        }
+
         internal static void Delete(string fileName)
         {
             string path = GetPath(fileName);