AlphaaeGameStudio/TEngine
1
0
Fork 0
mirror of https://github.com/Alex-Rachel/TEngine.git synced 2025-08-14 16:51:28 +00:00
Code Issues Packages Projects Releases Wiki Activity

Update

Browse Source 
Update
This commit is contained in:
ALEXTANG
2022-09-05 14:27:02 +08:00
parent 092de9937c
commit 455e57b435
12 changed files with 8 additions and 606 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
Assets/TEngine/Scripts/Editor/Inspector/ObjectPoolManagerInspector.cs
View File

@@ -4,7 +4,7 @@ using UnityEngine;
namespace TEngine.Editor
{
[CustomEditor(typeof(ObjectPoolManager))]
[CustomEditor(typeof(GameObjectPoolManager))]
internal sealed class ObjectPoolManagerInspector : TEngineInspector
{
public override void OnInspectorGUI()
@@ -15,14 +15,14 @@ namespace TEngine.Editor
return;
}
if (ObjectPoolManager.Instance.Helper.ObjectPools.Count == 0)
if (GameObjectPoolManager.Instance.Helper.ObjectPools.Count == 0)
{
GUILayout.BeginHorizontal();
GUILayout.Label("No Runtime Data!");
GUILayout.EndHorizontal();
}
foreach (var pool in ObjectPoolManager.Instance.Helper.ObjectPools)
foreach (var pool in GameObjectPoolManager.Instance.Helper.ObjectPools)
{
GUILayout.BeginHorizontal();
GUILayout.Space(20);

5
Assets/TEngine/Scripts/Runtime/Core/Constant/Constant.Setting.cs
View File

@@ -2,6 +2,11 @@ namespace TEngine
{
public static partial class Constant
{
/// <summary>
/// 默认优先级。
/// </summary>
internal const int DefaultPriority = 0;
public static class Setting
{
public const string HotFixedDllName = "GameHotFixed";

8
Assets/TEngine/Scripts/Runtime/ObjectPool.meta
View File

@@ -1,8 +0,0 @@
fileFormatVersion: 2
guid: 18905312db3bc3d448630110b4a9bcd3
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

8
Assets/TEngine/Scripts/Runtime/ObjectPool/Helper.meta
View File

@@ -1,8 +0,0 @@
fileFormatVersion: 2
guid: eaa7867dbaa447e42b63eb98f3dd8687
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

221
Assets/TEngine/Scripts/Runtime/ObjectPool/Helper/DefaultObjectPoolHelper.cs
View File

@@ -1,221 +0,0 @@
using System;
using System.Collections.Generic;
using UnityEngine;
namespace TEngine.Runtime
{
/// <summary>
/// 默认的对象池管理器助手
/// </summary>
public sealed class DefaultObjectPoolHelper : IObjectPoolHelper
{
/// <summary>
/// 对象池默认上限
/// </summary>
private int _limit;
/// <summary>
/// 所有对象池
/// </summary>
public Dictionary<string, ObjectPool> ObjectPools { get; private set; } =
new Dictionary<string, ObjectPool>();
/// <summary>
/// 初始化助手
/// </summary>
public DefaultObjectPoolHelper()
{
_limit = ObjectPoolManager.Instance.Limit;
}
/// <summary>
/// ShutDown
/// </summary>
public void ShutDown()
{
ClearAll();
}
/// <summary>
/// 注册对象池
/// </summary>
/// <param name="name">对象池名称</param>
/// <param name="allocItem">对象模板</param>
/// <param name="onAlloc">对象生成时初始化委托</param>
/// <param name="onRelease">对象回收时处理委托</param>
/// <param name="limit">对象池上限，等于0时，表示使用默认值</param>
public void RegisterPool(string name, GameObject allocItem, Action<GameObject> onAlloc,
Action<GameObject> onRelease, int limit)
{
if (allocItem == null)
return;
if (!ObjectPools.ContainsKey(name))
{
ObjectPools.Add(name, new ObjectPool(allocItem, limit <= 0 ? _limit : limit, onAlloc, onRelease));
}
else
{
Log.Error($"RegisterPool Failed ,Reason :已存在对象池 {name}");
}
}
/// <summary>
/// 是否存在指定名称的对象池
/// </summary>
/// <param name="name">对象池名称</param>
/// <returns>是否存在</returns>
public bool IsExistPool(string name)
{
return ObjectPools.ContainsKey(name);
}
/// <summary>
/// 移除已注册的对象池
/// </summary>
/// <param name="name">对象池名称</param>
public void UnRegisterPool(string name)
{
if (ObjectPools.ContainsKey(name))
{
ObjectPools[name].Clear();
ObjectPools.Remove(name);
}
else
{
Log.Error("UnRegisterPool ObjectPool Failed：不存在对象池 " + name + " ！");
}
}
/// <summary>
/// 获取对象池中对象数量
/// </summary>
/// <param name="name">对象池名称</param>
/// <returns>对象数量</returns>
public int GetPoolCount(string name)
{
if (ObjectPools.ContainsKey(name))
{
return ObjectPools[name].Count;
}
else
{
Log.Warning("GetPoolCount ObjectPool Failed：不存在对象池 " + name + " ！");
return 0;
}
}
/// <summary>
/// 生成对象
/// </summary>
/// <param name="name">对象池名称</param>
/// <returns>对象</returns>
public GameObject Alloc(string name)
{
if (ObjectPools.ContainsKey(name))
{
return ObjectPools[name].Alloc();
}
else
{
Log.Error("Alloc ObjectPool Failed：不存在对象池 " + name + " ！");
return null;
}
}
/// <summary>
/// 回收对象
/// </summary>
/// <param name="name">对象池名称</param>
/// <param name="target">对象</param>
public void Release(string name, GameObject target)
{
if (target == null)
return;
if (ObjectPools.ContainsKey(name))
{
ObjectPools[name].Release(target);
}
else
{
Log.Error("Releases ObjectPool Failed：不存在对象池 " + name + " ！");
}
}
/// <summary>
/// 批量回收对象
/// </summary>
/// <param name="name">对象池名称</param>
/// <param name="targets">对象数组</param>
public void Releases(string name, GameObject[] targets)
{
if (targets == null)
return;
if (ObjectPools.ContainsKey(name))
{
for (int i = 0; i < targets.Length; i++)
{
ObjectPools[name].Release(targets[i]);
}
}
else
{
Log.Error("Releases ObjectPool Failed：不存在对象池 " + name + " ！");
}
}
/// <summary>
/// 批量回收对象
/// </summary>
/// <param name="name">对象池名称</param>
/// <param name="targets">对象集合</param>
public void Releases(string name, List<GameObject> targets)
{
if (targets == null)
return;
if (ObjectPools.ContainsKey(name))
{
for (int i = 0; i < targets.Count; i++)
{
ObjectPools[name].Release(targets[i]);
}
targets.Clear();
}
else
{
Log.Error("Releases ObjectPool Failed：不存在对象池 " + name + " ！");
}
}
/// <summary>
/// 清空指定的对象池
/// </summary>
/// <param name="name">对象池名称</param>
public void Clear(string name)
{
if (ObjectPools.ContainsKey(name))
{
ObjectPools[name].Clear();
}
else
{
Log.Error("Clear ObjectPool Failed：不存在对象池 " + name + " ！");
}
}
/// <summary>
/// 清空所有对象池
/// </summary>
public void ClearAll()
{
foreach (var pool in ObjectPools)
{
pool.Value.Clear();
}
}
}
}

11
Assets/TEngine/Scripts/Runtime/ObjectPool/Helper/DefaultObjectPoolHelper.cs.meta
View File

@@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: 7f19a0d9040fd24439a22aa1b33b1752
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {fileID: 2800000, guid: 701b9bfeb6deef341a599f8d0f1ec080, type: 3}
userData:
assetBundleName:
assetBundleVariant:

87
Assets/TEngine/Scripts/Runtime/ObjectPool/Helper/IObjectPoolHelper.cs
View File

@@ -1,87 +0,0 @@
using System;
using System.Collections.Generic;
using UnityEngine;
namespace TEngine.Runtime
{
/// <summary>
/// 对象池管理器的助手接口
/// </summary>
public interface IObjectPoolHelper
{
/// <summary>
/// 所有对象池
/// </summary>
Dictionary<string, ObjectPool> ObjectPools { get; }
/// <summary>
/// 注册对象池
/// </summary>
/// <param name="name">对象池名称</param>
/// <param name="allocItem">对象模板</param>
/// <param name="onAlloc">对象生成时初始化委托</param>
/// <param name="onRelease">对象回收时处理委托</param>
/// <param name="limit">对象池上限，等于0时，表示使用默认值</param>
void RegisterPool(string name, GameObject allocItem, Action<GameObject> onAlloc,
Action<GameObject> onRelease, int limit);
/// <summary>
/// 是否存在指定名称的对象池
/// </summary>
/// <param name="name">对象池名称</param>
/// <returns>是否存在</returns>
bool IsExistPool(string name);
/// <summary>
/// 移除已注册的对象池
/// </summary>
/// <param name="name">对象池名称</param>
void UnRegisterPool(string name);
/// <summary>
/// 获取对象池中对象数量
/// </summary>
/// <param name="name">对象池名称</param>
/// <returns>对象数量</returns>
int GetPoolCount(string name);
/// <summary>
/// 生成对象
/// </summary>
/// <param name="name">对象池名称</param>
/// <returns>对象</returns>
GameObject Alloc(string name);
/// <summary>
/// 回收对象
/// </summary>
/// <param name="name">对象池名称</param>
/// <param name="target">对象</param>
void Release(string name, GameObject target);
/// <summary>
/// 批量回收对象
/// </summary>
/// <param name="name">对象池名称</param>
/// <param name="targets">对象数组</param>
void Releases(string name, GameObject[] targets);
/// <summary>
/// 批量回收对象
/// </summary>
/// <param name="name">对象池名称</param>
/// <param name="targets">对象集合</param>
void Releases(string name, List<GameObject> targets);
/// <summary>
/// 清空指定的对象池
/// </summary>
/// <param name="name">对象池名称</param>
void Clear(string name);
/// <summary>
/// 清空所有对象池
/// </summary>
void ClearAll();
}
}

11
Assets/TEngine/Scripts/Runtime/ObjectPool/Helper/IObjectPoolHelper.cs.meta
View File

@@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: 9f0af4beea5247d40a447b27c807de3a
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {fileID: 2800000, guid: 701b9bfeb6deef341a599f8d0f1ec080, type: 3}
userData:
assetBundleName:
assetBundleVariant:

106
Assets/TEngine/Scripts/Runtime/ObjectPool/Helper/ObjectPool.cs
View File

@@ -1,106 +0,0 @@
using System;
using System.Collections.Generic;
using UnityEngine;
namespace TEngine.Runtime
{
/// <summary>
/// 对象池
/// </summary>
public sealed class ObjectPool
{
private readonly GameObject _allocItem;
private readonly int _limit = 100;
private readonly Queue<GameObject> _objectQueue = new Queue<GameObject>();
private readonly Action<GameObject> _onAlloc;
private readonly Action<GameObject> _onRelease;
/// <summary>
/// 对象数量
/// </summary>
public int Count
{
get { return _objectQueue.Count; }
}
/// <summary>
/// 构造函数对象池
/// </summary>
/// <param name="allocItem"></param>
/// <param name="limit"></param>
/// <param name="onAlloc"></param>
/// <param name="onRelease"></param>
public ObjectPool(GameObject allocItem, int limit, Action<GameObject> onAlloc,
Action<GameObject> onRelease)
{
_allocItem = allocItem;
_limit = limit;
_onAlloc = onAlloc;
_onRelease = onRelease;
}
/// <summary>
/// 生成对象
/// </summary>
/// <returns>对象</returns>
public GameObject Alloc()
{
GameObject obj;
if (_objectQueue.Count > 0)
{
obj = _objectQueue.Dequeue();
}
else
{
obj = Utility.GameObjectUtils.CloneGameObject(_allocItem);
}
obj.SetActive(true);
obj.transform.SetParent(null);
_onAlloc?.Invoke(obj);
return obj;
}
/// <summary>
/// 回收对象
/// </summary>
/// <param name="obj">对象</param>
public void Release(GameObject obj)
{
if (_objectQueue.Count >= _limit)
{
_onRelease?.Invoke(obj);
Utility.GameObjectUtils.Kill(obj);
}
else
{
obj.SetActive(false);
_onRelease?.Invoke(obj);
_objectQueue.Enqueue(obj);
obj.transform.SetParent(ObjectPoolManager.Instance.gameObject.transform);
}
}
/// <summary>
/// 清空所有对象
/// </summary>
public void Clear()
{
while (_objectQueue.Count > 0)
{
GameObject obj = _objectQueue.Dequeue();
if (obj)
{
Utility.GameObjectUtils.Kill(obj);
}
}
}
}
}

11
Assets/TEngine/Scripts/Runtime/ObjectPool/Helper/ObjectPool.cs.meta
View File

@@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: 27382aff833de094e97dd246ad567aad
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {fileID: 2800000, guid: 701b9bfeb6deef341a599f8d0f1ec080, type: 3}
userData:
assetBundleName:
assetBundleVariant:

129
Assets/TEngine/Scripts/Runtime/ObjectPool/ObjectPoolManager.cs
View File

@@ -1,129 +0,0 @@
using System;
using System.Collections.Generic;
using UnityEngine;
namespace TEngine.Runtime
{
/// <summary>
/// 对象池管理器
/// </summary>
public sealed class ObjectPoolManager : UnitySingleton<ObjectPoolManager>
{
private IObjectPoolHelper _helper;
public IObjectPoolHelper Helper => _helper;
public override int Priority => -1;
public override void Awake()
{
base.Awake();
_helper = new DefaultObjectPoolHelper();
}
/// <summary>
/// 单个对象池上限
/// </summary>
[SerializeField] internal int Limit = 100;
/// <summary>
/// 注册对象池
/// </summary>
/// <param name="name">对象池名称</param>
/// <param name="allocItem">对象模板</param>
/// <param name="onAlloc">对象生成时初始化委托</param>
/// <param name="onRelease">对象回收时处理委托</param>
/// <param name="limit">对象池上限，等于0时，表示使用默认值</param>
public void RegisterPool(string name, GameObject allocItem, Action<GameObject> onAlloc = null,
Action<GameObject> onRelease = null, int limit = 0)
{
_helper.RegisterPool(name, allocItem, onAlloc, onRelease, limit);
}
/// <summary>
/// 是否存在指定名称的对象池
/// </summary>
/// <param name="name">对象池名称</param>
/// <returns>是否存在</returns>
public bool IsExistPool(string name)
{
return _helper.IsExistPool(name);
}
/// <summary>
/// 移除已注册的对象池
/// </summary>
/// <param name="name">对象池名称</param>
public void UnRegisterPool(string name)
{
_helper.UnRegisterPool(name);
}
/// <summary>
/// 获取对象池中对象数量
/// </summary>
/// <param name="name">对象池名称</param>
/// <returns>对象数量</returns>
public int GetPoolCount(string name)
{
return _helper.GetPoolCount(name);
}
/// <summary>
/// 生成对象
/// </summary>
/// <param name="name">对象池名称</param>
/// <returns>对象</returns>
public GameObject Alloc(string name)
{
return _helper.Alloc(name);
}
/// <summary>
/// 回收对象
/// </summary>
/// <param name="name">对象池名称</param>
/// <param name="target">对象</param>
public void Release(string name, GameObject target)
{
_helper.Release(name, target);
}
/// <summary>
/// 批量回收对象
/// </summary>
/// <param name="name">对象池名称</param>
/// <param name="targets">对象数组</param>
public void Releases(string name, GameObject[] targets)
{
_helper.Releases(name, targets);
}
/// <summary>
/// 批量回收对象
/// </summary>
/// <param name="name">对象池名称</param>
/// <param name="targets">对象集合</param>
public void Releases(string name, List<GameObject> targets)
{
_helper.Releases(name, targets);
}
/// <summary>
/// 清空指定的对象池
/// </summary>
/// <param name="name">对象池名称</param>
public void Clear(string name)
{
_helper.Clear(name);
}
/// <summary>
/// 清空所有对象池
/// </summary>
public void ClearAll()
{
_helper.ClearAll();
}
}
}

11
Assets/TEngine/Scripts/Runtime/ObjectPool/ObjectPoolManager.cs.meta
View File

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