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

ObjectPool

Browse Source 
ObjectPool
This commit is contained in:
ALEXTANG
2022-09-05 14:47:26 +08:00
parent 0766482fab
commit 219649e684
25 changed files with 4738 additions and 4 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
Assets/TEngine/EntryPrefab/TEngine.prefab
View File

@@ -9,7 +9,7 @@ GameObject:
serializedVersion: 6
m_Component:
- component: {fileID: 1672025514}
- component: {fileID: 1672025515}
- component: {fileID: 1198523775}
m_Layer: 0
m_Name: ObjectPool
m_TagString: Untagged
@@ -31,7 +31,7 @@ Transform:
m_Father: {fileID: 3463045026180535779}
m_RootOrder: 6
m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
--- !u!114 &1672025515
--- !u!114 &1198523775
MonoBehaviour:
m_ObjectHideFlags: 0
m_CorrespondingSourceObject: {fileID: 0}
@@ -40,10 +40,9 @@ MonoBehaviour:
m_GameObject: {fileID: 1672025513}
m_Enabled: 1
m_EditorHideFlags: 0
m_Script: {fileID: 11500000, guid: bef095b963a40b54fa82ba105bd1e98e, type: 3}
m_Script: {fileID: 11500000, guid: 07d1c5a0df477d549a3a5799e3f81ad0, type: 3}
m_Name:
m_EditorClassIdentifier:
Limit: 100
--- !u!1 &3463045025307533287
GameObject:
m_ObjectHideFlags: 0

152
Assets/TEngine/Scripts/Editor/Inspector/ObjectPoolComponentInspector.cs Normal file
View File

@@ -0,0 +1,152 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using UnityEditor;
using UnityEngine;
using TEngine.Runtime;
using TEngine.Runtime.ObjectPool;
namespace TEngine.Editor
{
[CustomEditor(typeof(ObjectPoolComponent))]
internal sealed class ObjectPoolComponentInspector : TEngineInspector
{
private readonly HashSet<string> m_OpenedItems = new HashSet<string>();
public override void OnInspectorGUI()
{
base.OnInspectorGUI();
if (!EditorApplication.isPlaying)
{
EditorGUILayout.HelpBox("Available during runtime only.", MessageType.Info);
return;
}
ObjectPoolComponent t = (ObjectPoolComponent)target;
if (IsPrefabInHierarchy(t.gameObject))
{
EditorGUILayout.LabelField("Object Pool Count", t.Count.ToString());
ObjectPoolBase[] objectPools = t.GetAllObjectPools(true);
foreach (ObjectPoolBase objectPool in objectPools)
{
DrawObjectPool(objectPool);
}
}
Repaint();
}
private void OnEnable()
{
}
private void DrawObjectPool(ObjectPoolBase objectPool)
{
bool lastState = m_OpenedItems.Contains(objectPool.FullName);
bool currentState = EditorGUILayout.Foldout(lastState, objectPool.FullName);
if (currentState != lastState)
{
if (currentState)
{
m_OpenedItems.Add(objectPool.FullName);
}
else
{
m_OpenedItems.Remove(objectPool.FullName);
}
}
if (currentState)
{
EditorGUILayout.BeginVertical("box");
{
EditorGUILayout.LabelField("Name", objectPool.Name);
EditorGUILayout.LabelField("Type", objectPool.ObjectType.FullName);
EditorGUILayout.LabelField("Auto Release Interval", objectPool.AutoReleaseInterval.ToString());
EditorGUILayout.LabelField("Capacity", objectPool.Capacity.ToString());
EditorGUILayout.LabelField("Used Count", objectPool.Count.ToString());
EditorGUILayout.LabelField("Can Release Count", objectPool.CanReleaseCount.ToString());
EditorGUILayout.LabelField("Expire Time", objectPool.ExpireTime.ToString());
EditorGUILayout.LabelField("Priority", objectPool.Priority.ToString());
ObjectInfo[] objectInfos = objectPool.GetAllObjectInfos();
if (objectInfos.Length > 0)
{
EditorGUILayout.LabelField("Name",
objectPool.AllowMultiSpawn
? "Locked\tCount\tFlag\tPriority\tLast Use Time"
: "Locked\tIn Use\tFlag\tPriority\tLast Use Time");
foreach (ObjectInfo objectInfo in objectInfos)
{
EditorGUILayout.LabelField(
string.IsNullOrEmpty(objectInfo.Name) ? "<None>" : objectInfo.Name,
Utility.Text.Format("{0}\t{1}\t{2}\t{3}\t{4}", objectInfo.Locked.ToString(),
objectPool.AllowMultiSpawn
? objectInfo.SpawnCount.ToString()
: objectInfo.IsInUse.ToString(), objectInfo.CustomCanReleaseFlag.ToString(),
objectInfo.Priority.ToString(),
objectInfo.LastUseTime.ToLocalTime().ToString("yyyy-MM-dd HH:mm:ss")));
}
if (GUILayout.Button("Release"))
{
objectPool.Release();
}
if (GUILayout.Button("Release All Unused"))
{
objectPool.ReleaseAllUnused();
}
if (GUILayout.Button("Export CSV Data"))
{
string exportFileName = EditorUtility.SaveFilePanel("Export CSV Data", string.Empty,
Utility.Text.Format("Object Pool Data - {0}.csv", objectPool.Name), string.Empty);
if (!string.IsNullOrEmpty(exportFileName))
{
try
{
int index = 0;
string[] data = new string[objectInfos.Length + 1];
data[index++] = Utility.Text.Format(
"Name,Locked,{0},Custom Can Release Flag,Priority,Last Use Time",
objectPool.AllowMultiSpawn ? "Count" : "In Use");
foreach (ObjectInfo objectInfo in objectInfos)
{
data[index++] = Utility.Text.Format("{0},{1},{2},{3},{4},{5}", objectInfo.Name,
objectInfo.Locked.ToString(),
objectPool.AllowMultiSpawn
? objectInfo.SpawnCount.ToString()
: objectInfo.IsInUse.ToString(),
objectInfo.CustomCanReleaseFlag.ToString(), objectInfo.Priority.ToString(),
objectInfo.LastUseTime.ToLocalTime().ToString("yyyy-MM-dd HH:mm:ss"));
}
File.WriteAllLines(exportFileName, data, Encoding.UTF8);
Debug.Log(Utility.Text.Format("Export object pool CSV data to '{0}' success.",
exportFileName));
}
catch (Exception exception)
{
Debug.LogError(Utility.Text.Format(
"Export object pool CSV data to '{0}' failure, exception is '{1}'.",
exportFileName, exception.ToString()));
}
}
}
}
else
{
GUILayout.Label("Object Pool is Empty ...");
}
}
EditorGUILayout.EndVertical();
EditorGUILayout.Separator();
}
}
}
}

11
Assets/TEngine/Scripts/Editor/Inspector/ObjectPoolComponentInspector.cs.meta Normal file
View File

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

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

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

8
Assets/TEngine/Scripts/Runtime/ObjectPool/Core.meta Normal file
View File

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

177
Assets/TEngine/Scripts/Runtime/ObjectPool/Core/IObjectPool.cs Normal file
View File

@@ -0,0 +1,177 @@
using System;
namespace TEngine.Runtime.ObjectPool
{
/// <summary>
/// 对象池接口。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
public interface IObjectPool<T> where T : ObjectBase
{
/// <summary>
/// 获取对象池名称。
/// </summary>
string Name { get; }
/// <summary>
/// 获取对象池完整名称。
/// </summary>
string FullName { get; }
/// <summary>
/// 获取对象池对象类型。
/// </summary>
Type ObjectType { get; }
/// <summary>
/// 获取对象池中对象的数量。
/// </summary>
int Count { get; }
/// <summary>
/// 获取对象池中能被释放的对象的数量。
/// </summary>
int CanReleaseCount { get; }
/// <summary>
/// 获取是否允许对象被多次获取。
/// </summary>
bool AllowMultiSpawn { get; }
/// <summary>
/// 获取或设置对象池自动释放可释放对象的间隔秒数。
/// </summary>
float AutoReleaseInterval { get; set; }
/// <summary>
/// 获取或设置对象池的容量。
/// </summary>
int Capacity { get; set; }
/// <summary>
/// 获取或设置对象池对象过期秒数。
/// </summary>
float ExpireTime { get; set; }
/// <summary>
/// 获取或设置对象池的优先级。
/// </summary>
int Priority { get; set; }
/// <summary>
/// 创建对象。
/// </summary>
/// <param name="obj">对象。</param>
/// <param name="spawned">对象是否已被获取。</param>
void Register(T obj, bool spawned);
/// <summary>
/// 检查对象。
/// </summary>
/// <returns>要检查的对象是否存在。</returns>
bool CanSpawn();
/// <summary>
/// 检查对象。
/// </summary>
/// <param name="name">对象名称。</param>
/// <returns>要检查的对象是否存在。</returns>
bool CanSpawn(string name);
/// <summary>
/// 获取对象。
/// </summary>
/// <returns>要获取的对象。</returns>
T Spawn();
/// <summary>
/// 获取对象。
/// </summary>
/// <param name="name">对象名称。</param>
/// <returns>要获取的对象。</returns>
T Spawn(string name);
/// <summary>
/// 回收对象。
/// </summary>
/// <param name="obj">要回收的对象。</param>
void Unspawn(T obj);
/// <summary>
/// 回收对象。
/// </summary>
/// <param name="target">要回收的对象。</param>
void Unspawn(object target);
/// <summary>
/// 设置对象是否被加锁。
/// </summary>
/// <param name="obj">要设置被加锁的对象。</param>
/// <param name="locked">是否被加锁。</param>
void SetLocked(T obj, bool locked);
/// <summary>
/// 设置对象是否被加锁。
/// </summary>
/// <param name="target">要设置被加锁的对象。</param>
/// <param name="locked">是否被加锁。</param>
void SetLocked(object target, bool locked);
/// <summary>
/// 设置对象的优先级。
/// </summary>
/// <param name="obj">要设置优先级的对象。</param>
/// <param name="priority">优先级。</param>
void SetPriority(T obj, int priority);
/// <summary>
/// 设置对象的优先级。
/// </summary>
/// <param name="target">要设置优先级的对象。</param>
/// <param name="priority">优先级。</param>
void SetPriority(object target, int priority);
/// <summary>
/// 释放对象。
/// </summary>
/// <param name="obj">要释放的对象。</param>
/// <returns>释放对象是否成功。</returns>
bool ReleaseObject(T obj);
/// <summary>
/// 释放对象。
/// </summary>
/// <param name="target">要释放的对象。</param>
/// <returns>释放对象是否成功。</returns>
bool ReleaseObject(object target);
/// <summary>
/// 释放对象池中的可释放对象。
/// </summary>
void Release();
/// <summary>
/// 释放对象池中的可释放对象。
/// </summary>
/// <param name="toReleaseCount">尝试释放对象数量。</param>
void Release(int toReleaseCount);
/// <summary>
/// 释放对象池中的可释放对象。
/// </summary>
/// <param name="releaseObjectFilterCallback">释放对象筛选函数。</param>
void Release(ReleaseObjectFilterCallback<T> releaseObjectFilterCallback);
/// <summary>
/// 释放对象池中的可释放对象。
/// </summary>
/// <param name="toReleaseCount">尝试释放对象数量。</param>
/// <param name="releaseObjectFilterCallback">释放对象筛选函数。</param>
void Release(int toReleaseCount, ReleaseObjectFilterCallback<T> releaseObjectFilterCallback);
/// <summary>
/// 释放对象池中的所有未使用对象。
/// </summary>
void ReleaseAllUnused();
}
}

3
Assets/TEngine/Scripts/Runtime/ObjectPool/Core/IObjectPool.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: 793c3ca317ec4e69ad36dd59b5d37bf1
timeCreated: 1662359575

762
Assets/TEngine/Scripts/Runtime/ObjectPool/Core/IObjectPoolManager.cs Normal file
View File

@@ -0,0 +1,762 @@
using System;
using System.Collections.Generic;
namespace TEngine.Runtime.ObjectPool
{
/// <summary>
/// 对象池管理器。
/// </summary>
public interface IObjectPoolManager
{
/// <summary>
/// 获取对象池数量。
/// </summary>
int Count { get; }
/// <summary>
/// 检查是否存在对象池。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
/// <returns>是否存在对象池。</returns>
bool HasObjectPool<T>() where T : ObjectBase;
/// <summary>
/// 检查是否存在对象池。
/// </summary>
/// <param name="objectType">对象类型。</param>
/// <returns>是否存在对象池。</returns>
bool HasObjectPool(Type objectType);
/// <summary>
/// 检查是否存在对象池。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
/// <param name="name">对象池名称。</param>
/// <returns>是否存在对象池。</returns>
bool HasObjectPool<T>(string name) where T : ObjectBase;
/// <summary>
/// 检查是否存在对象池。
/// </summary>
/// <param name="objectType">对象类型。</param>
/// <param name="name">对象池名称。</param>
/// <returns>是否存在对象池。</returns>
bool HasObjectPool(Type objectType, string name);
/// <summary>
/// 检查是否存在对象池。
/// </summary>
/// <param name="condition">要检查的条件。</param>
/// <returns>是否存在对象池。</returns>
bool HasObjectPool(Predicate<ObjectPoolBase> condition);
/// <summary>
/// 获取对象池。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
/// <returns>要获取的对象池。</returns>
IObjectPool<T> GetObjectPool<T>() where T : ObjectBase;
/// <summary>
/// 获取对象池。
/// </summary>
/// <param name="objectType">对象类型。</param>
/// <returns>要获取的对象池。</returns>
ObjectPoolBase GetObjectPool(Type objectType);
/// <summary>
/// 获取对象池。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
/// <param name="name">对象池名称。</param>
/// <returns>要获取的对象池。</returns>
IObjectPool<T> GetObjectPool<T>(string name) where T : ObjectBase;
/// <summary>
/// 获取对象池。
/// </summary>
/// <param name="objectType">对象类型。</param>
/// <param name="name">对象池名称。</param>
/// <returns>要获取的对象池。</returns>
ObjectPoolBase GetObjectPool(Type objectType, string name);
/// <summary>
/// 获取对象池。
/// </summary>
/// <param name="condition">要检查的条件。</param>
/// <returns>要获取的对象池。</returns>
ObjectPoolBase GetObjectPool(Predicate<ObjectPoolBase> condition);
/// <summary>
/// 获取对象池。
/// </summary>
/// <param name="condition">要检查的条件。</param>
/// <returns>要获取的对象池。</returns>
ObjectPoolBase[] GetObjectPools(Predicate<ObjectPoolBase> condition);
/// <summary>
/// 获取对象池。
/// </summary>
/// <param name="condition">要检查的条件。</param>
/// <param name="results">要获取的对象池。</param>
void GetObjectPools(Predicate<ObjectPoolBase> condition, List<ObjectPoolBase> results);
/// <summary>
/// 获取所有对象池。
/// </summary>
/// <returns>所有对象池。</returns>
ObjectPoolBase[] GetAllObjectPools();
/// <summary>
/// 获取所有对象池。
/// </summary>
/// <param name="results">所有对象池。</param>
void GetAllObjectPools(List<ObjectPoolBase> results);
/// <summary>
/// 获取所有对象池。
/// </summary>
/// <param name="sort">是否根据对象池的优先级排序。</param>
/// <returns>所有对象池。</returns>
ObjectPoolBase[] GetAllObjectPools(bool sort);
/// <summary>
/// 获取所有对象池。
/// </summary>
/// <param name="sort">是否根据对象池的优先级排序。</param>
/// <param name="results">所有对象池。</param>
void GetAllObjectPools(bool sort, List<ObjectPoolBase> results);
/// <summary>
/// 创建允许单次获取的对象池。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
/// <returns>要创建的允许单次获取的对象池。</returns>
IObjectPool<T> CreateSingleSpawnObjectPool<T>() where T : ObjectBase;
/// <summary>
/// 创建允许单次获取的对象池。
/// </summary>
/// <param name="objectType">对象类型。</param>
/// <returns>要创建的允许单次获取的对象池。</returns>
ObjectPoolBase CreateSingleSpawnObjectPool(Type objectType);
/// <summary>
/// 创建允许单次获取的对象池。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
/// <param name="name">对象池名称。</param>
/// <returns>要创建的允许单次获取的对象池。</returns>
IObjectPool<T> CreateSingleSpawnObjectPool<T>(string name) where T : ObjectBase;
/// <summary>
/// 创建允许单次获取的对象池。
/// </summary>
/// <param name="objectType">对象类型。</param>
/// <param name="name">对象池名称。</param>
/// <returns>要创建的允许单次获取的对象池。</returns>
ObjectPoolBase CreateSingleSpawnObjectPool(Type objectType, string name);
/// <summary>
/// 创建允许单次获取的对象池。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
/// <param name="capacity">对象池的容量。</param>
/// <returns>要创建的允许单次获取的对象池。</returns>
IObjectPool<T> CreateSingleSpawnObjectPool<T>(int capacity) where T : ObjectBase;
/// <summary>
/// 创建允许单次获取的对象池。
/// </summary>
/// <param name="objectType">对象类型。</param>
/// <param name="capacity">对象池的容量。</param>
/// <returns>要创建的允许单次获取的对象池。</returns>
ObjectPoolBase CreateSingleSpawnObjectPool(Type objectType, int capacity);
/// <summary>
/// 创建允许单次获取的对象池。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
/// <param name="expireTime">对象池对象过期秒数。</param>
/// <returns>要创建的允许单次获取的对象池。</returns>
IObjectPool<T> CreateSingleSpawnObjectPool<T>(float expireTime) where T : ObjectBase;
/// <summary>
/// 创建允许单次获取的对象池。
/// </summary>
/// <param name="objectType">对象类型。</param>
/// <param name="expireTime">对象池对象过期秒数。</param>
/// <returns>要创建的允许单次获取的对象池。</returns>
ObjectPoolBase CreateSingleSpawnObjectPool(Type objectType, float expireTime);
/// <summary>
/// 创建允许单次获取的对象池。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
/// <param name="name">对象池名称。</param>
/// <param name="capacity">对象池的容量。</param>
/// <returns>要创建的允许单次获取的对象池。</returns>
IObjectPool<T> CreateSingleSpawnObjectPool<T>(string name, int capacity) where T : ObjectBase;
/// <summary>
/// 创建允许单次获取的对象池。
/// </summary>
/// <param name="objectType">对象类型。</param>
/// <param name="name">对象池名称。</param>
/// <param name="capacity">对象池的容量。</param>
/// <returns>要创建的允许单次获取的对象池。</returns>
ObjectPoolBase CreateSingleSpawnObjectPool(Type objectType, string name, int capacity);
/// <summary>
/// 创建允许单次获取的对象池。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
/// <param name="name">对象池名称。</param>
/// <param name="expireTime">对象池对象过期秒数。</param>
/// <returns>要创建的允许单次获取的对象池。</returns>
IObjectPool<T> CreateSingleSpawnObjectPool<T>(string name, float expireTime) where T : ObjectBase;
/// <summary>
/// 创建允许单次获取的对象池。
/// </summary>
/// <param name="objectType">对象类型。</param>
/// <param name="name">对象池名称。</param>
/// <param name="expireTime">对象池对象过期秒数。</param>
/// <returns>要创建的允许单次获取的对象池。</returns>
ObjectPoolBase CreateSingleSpawnObjectPool(Type objectType, string name, float expireTime);
/// <summary>
/// 创建允许单次获取的对象池。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
/// <param name="capacity">对象池的容量。</param>
/// <param name="expireTime">对象池对象过期秒数。</param>
/// <returns>要创建的允许单次获取的对象池。</returns>
IObjectPool<T> CreateSingleSpawnObjectPool<T>(int capacity, float expireTime) where T : ObjectBase;
/// <summary>
/// 创建允许单次获取的对象池。
/// </summary>
/// <param name="objectType">对象类型。</param>
/// <param name="capacity">对象池的容量。</param>
/// <param name="expireTime">对象池对象过期秒数。</param>
/// <returns>要创建的允许单次获取的对象池。</returns>
ObjectPoolBase CreateSingleSpawnObjectPool(Type objectType, int capacity, float expireTime);
/// <summary>
/// 创建允许单次获取的对象池。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
/// <param name="capacity">对象池的容量。</param>
/// <param name="priority">对象池的优先级。</param>
/// <returns>要创建的允许单次获取的对象池。</returns>
IObjectPool<T> CreateSingleSpawnObjectPool<T>(int capacity, int priority) where T : ObjectBase;
/// <summary>
/// 创建允许单次获取的对象池。
/// </summary>
/// <param name="objectType">对象类型。</param>
/// <param name="capacity">对象池的容量。</param>
/// <param name="priority">对象池的优先级。</param>
/// <returns>要创建的允许单次获取的对象池。</returns>
ObjectPoolBase CreateSingleSpawnObjectPool(Type objectType, int capacity, int priority);
/// <summary>
/// 创建允许单次获取的对象池。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
/// <param name="expireTime">对象池对象过期秒数。</param>
/// <param name="priority">对象池的优先级。</param>
/// <returns>要创建的允许单次获取的对象池。</returns>
IObjectPool<T> CreateSingleSpawnObjectPool<T>(float expireTime, int priority) where T : ObjectBase;
/// <summary>
/// 创建允许单次获取的对象池。
/// </summary>
/// <param name="objectType">对象类型。</param>
/// <param name="expireTime">对象池对象过期秒数。</param>
/// <param name="priority">对象池的优先级。</param>
/// <returns>要创建的允许单次获取的对象池。</returns>
ObjectPoolBase CreateSingleSpawnObjectPool(Type objectType, float expireTime, int priority);
/// <summary>
/// 创建允许单次获取的对象池。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
/// <param name="name">对象池名称。</param>
/// <param name="capacity">对象池的容量。</param>
/// <param name="expireTime">对象池对象过期秒数。</param>
/// <returns>要创建的允许单次获取的对象池。</returns>
IObjectPool<T> CreateSingleSpawnObjectPool<T>(string name, int capacity, float expireTime) where T : ObjectBase;
/// <summary>
/// 创建允许单次获取的对象池。
/// </summary>
/// <param name="objectType">对象类型。</param>
/// <param name="name">对象池名称。</param>
/// <param name="capacity">对象池的容量。</param>
/// <param name="expireTime">对象池对象过期秒数。</param>
/// <returns>要创建的允许单次获取的对象池。</returns>
ObjectPoolBase CreateSingleSpawnObjectPool(Type objectType, string name, int capacity, float expireTime);
/// <summary>
/// 创建允许单次获取的对象池。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
/// <param name="name">对象池名称。</param>
/// <param name="capacity">对象池的容量。</param>
/// <param name="priority">对象池的优先级。</param>
/// <returns>要创建的允许单次获取的对象池。</returns>
IObjectPool<T> CreateSingleSpawnObjectPool<T>(string name, int capacity, int priority) where T : ObjectBase;
/// <summary>
/// 创建允许单次获取的对象池。
/// </summary>
/// <param name="objectType">对象类型。</param>
/// <param name="name">对象池名称。</param>
/// <param name="capacity">对象池的容量。</param>
/// <param name="priority">对象池的优先级。</param>
/// <returns>要创建的允许单次获取的对象池。</returns>
ObjectPoolBase CreateSingleSpawnObjectPool(Type objectType, string name, int capacity, int priority);
/// <summary>
/// 创建允许单次获取的对象池。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
/// <param name="name">对象池名称。</param>
/// <param name="expireTime">对象池对象过期秒数。</param>
/// <param name="priority">对象池的优先级。</param>
/// <returns>要创建的允许单次获取的对象池。</returns>
IObjectPool<T> CreateSingleSpawnObjectPool<T>(string name, float expireTime, int priority) where T : ObjectBase;
/// <summary>
/// 创建允许单次获取的对象池。
/// </summary>
/// <param name="objectType">对象类型。</param>
/// <param name="name">对象池名称。</param>
/// <param name="expireTime">对象池对象过期秒数。</param>
/// <param name="priority">对象池的优先级。</param>
/// <returns>要创建的允许单次获取的对象池。</returns>
ObjectPoolBase CreateSingleSpawnObjectPool(Type objectType, string name, float expireTime, int priority);
/// <summary>
/// 创建允许单次获取的对象池。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
/// <param name="capacity">对象池的容量。</param>
/// <param name="expireTime">对象池对象过期秒数。</param>
/// <param name="priority">对象池的优先级。</param>
/// <returns>要创建的允许单次获取的对象池。</returns>
IObjectPool<T> CreateSingleSpawnObjectPool<T>(int capacity, float expireTime, int priority)
where T : ObjectBase;
/// <summary>
/// 创建允许单次获取的对象池。
/// </summary>
/// <param name="objectType">对象类型。</param>
/// <param name="capacity">对象池的容量。</param>
/// <param name="expireTime">对象池对象过期秒数。</param>
/// <param name="priority">对象池的优先级。</param>
/// <returns>要创建的允许单次获取的对象池。</returns>
ObjectPoolBase CreateSingleSpawnObjectPool(Type objectType, int capacity, float expireTime, int priority);
/// <summary>
/// 创建允许单次获取的对象池。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
/// <param name="name">对象池名称。</param>
/// <param name="capacity">对象池的容量。</param>
/// <param name="expireTime">对象池对象过期秒数。</param>
/// <param name="priority">对象池的优先级。</param>
/// <returns>要创建的允许单次获取的对象池。</returns>
IObjectPool<T> CreateSingleSpawnObjectPool<T>(string name, int capacity, float expireTime, int priority)
where T : ObjectBase;
/// <summary>
/// 创建允许单次获取的对象池。
/// </summary>
/// <param name="objectType">对象类型。</param>
/// <param name="name">对象池名称。</param>
/// <param name="capacity">对象池的容量。</param>
/// <param name="expireTime">对象池对象过期秒数。</param>
/// <param name="priority">对象池的优先级。</param>
/// <returns>要创建的允许单次获取的对象池。</returns>
ObjectPoolBase CreateSingleSpawnObjectPool(Type objectType, string name, int capacity, float expireTime,
int priority);
/// <summary>
/// 创建允许单次获取的对象池。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
/// <param name="name">对象池名称。</param>
/// <param name="autoReleaseInterval">对象池自动释放可释放对象的间隔秒数。</param>
/// <param name="capacity">对象池的容量。</param>
/// <param name="expireTime">对象池对象过期秒数。</param>
/// <param name="priority">对象池的优先级。</param>
/// <returns>要创建的允许单次获取的对象池。</returns>
IObjectPool<T> CreateSingleSpawnObjectPool<T>(string name, float autoReleaseInterval, int capacity,
float expireTime, int priority) where T : ObjectBase;
/// <summary>
/// 创建允许单次获取的对象池。
/// </summary>
/// <param name="objectType">对象类型。</param>
/// <param name="name">对象池名称。</param>
/// <param name="autoReleaseInterval">对象池自动释放可释放对象的间隔秒数。</param>
/// <param name="capacity">对象池的容量。</param>
/// <param name="expireTime">对象池对象过期秒数。</param>
/// <param name="priority">对象池的优先级。</param>
/// <returns>要创建的允许单次获取的对象池。</returns>
ObjectPoolBase CreateSingleSpawnObjectPool(Type objectType, string name, float autoReleaseInterval,
int capacity, float expireTime, int priority);
/// <summary>
/// 创建允许多次获取的对象池。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
/// <returns>要创建的允许多次获取的对象池。</returns>
IObjectPool<T> CreateMultiSpawnObjectPool<T>() where T : ObjectBase;
/// <summary>
/// 创建允许多次获取的对象池。
/// </summary>
/// <param name="objectType">对象类型。</param>
/// <returns>要创建的允许多次获取的对象池。</returns>
ObjectPoolBase CreateMultiSpawnObjectPool(Type objectType);
/// <summary>
/// 创建允许多次获取的对象池。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
/// <param name="name">对象池名称。</param>
/// <returns>要创建的允许多次获取的对象池。</returns>
IObjectPool<T> CreateMultiSpawnObjectPool<T>(string name) where T : ObjectBase;
/// <summary>
/// 创建允许多次获取的对象池。
/// </summary>
/// <param name="objectType">对象类型。</param>
/// <param name="name">对象池名称。</param>
/// <returns>要创建的允许多次获取的对象池。</returns>
ObjectPoolBase CreateMultiSpawnObjectPool(Type objectType, string name);
/// <summary>
/// 创建允许多次获取的对象池。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
/// <param name="capacity">对象池的容量。</param>
/// <returns>要创建的允许多次获取的对象池。</returns>
IObjectPool<T> CreateMultiSpawnObjectPool<T>(int capacity) where T : ObjectBase;
/// <summary>
/// 创建允许多次获取的对象池。
/// </summary>
/// <param name="objectType">对象类型。</param>
/// <param name="capacity">对象池的容量。</param>
/// <returns>要创建的允许多次获取的对象池。</returns>
ObjectPoolBase CreateMultiSpawnObjectPool(Type objectType, int capacity);
/// <summary>
/// 创建允许多次获取的对象池。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
/// <param name="expireTime">对象池对象过期秒数。</param>
/// <returns>要创建的允许多次获取的对象池。</returns>
IObjectPool<T> CreateMultiSpawnObjectPool<T>(float expireTime) where T : ObjectBase;
/// <summary>
/// 创建允许多次获取的对象池。
/// </summary>
/// <param name="objectType">对象类型。</param>
/// <param name="expireTime">对象池对象过期秒数。</param>
/// <returns>要创建的允许多次获取的对象池。</returns>
ObjectPoolBase CreateMultiSpawnObjectPool(Type objectType, float expireTime);
/// <summary>
/// 创建允许多次获取的对象池。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
/// <param name="name">对象池名称。</param>
/// <param name="capacity">对象池的容量。</param>
/// <returns>要创建的允许多次获取的对象池。</returns>
IObjectPool<T> CreateMultiSpawnObjectPool<T>(string name, int capacity) where T : ObjectBase;
/// <summary>
/// 创建允许多次获取的对象池。
/// </summary>
/// <param name="objectType">对象类型。</param>
/// <param name="name">对象池名称。</param>
/// <param name="capacity">对象池的容量。</param>
/// <returns>要创建的允许多次获取的对象池。</returns>
ObjectPoolBase CreateMultiSpawnObjectPool(Type objectType, string name, int capacity);
/// <summary>
/// 创建允许多次获取的对象池。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
/// <param name="name">对象池名称。</param>
/// <param name="expireTime">对象池对象过期秒数。</param>
/// <returns>要创建的允许多次获取的对象池。</returns>
IObjectPool<T> CreateMultiSpawnObjectPool<T>(string name, float expireTime) where T : ObjectBase;
/// <summary>
/// 创建允许多次获取的对象池。
/// </summary>
/// <param name="objectType">对象类型。</param>
/// <param name="name">对象池名称。</param>
/// <param name="expireTime">对象池对象过期秒数。</param>
/// <returns>要创建的允许多次获取的对象池。</returns>
ObjectPoolBase CreateMultiSpawnObjectPool(Type objectType, string name, float expireTime);
/// <summary>
/// 创建允许多次获取的对象池。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
/// <param name="capacity">对象池的容量。</param>
/// <param name="expireTime">对象池对象过期秒数。</param>
/// <returns>要创建的允许多次获取的对象池。</returns>
IObjectPool<T> CreateMultiSpawnObjectPool<T>(int capacity, float expireTime) where T : ObjectBase;
/// <summary>
/// 创建允许多次获取的对象池。
/// </summary>
/// <param name="objectType">对象类型。</param>
/// <param name="capacity">对象池的容量。</param>
/// <param name="expireTime">对象池对象过期秒数。</param>
/// <returns>要创建的允许多次获取的对象池。</returns>
ObjectPoolBase CreateMultiSpawnObjectPool(Type objectType, int capacity, float expireTime);
/// <summary>
/// 创建允许多次获取的对象池。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
/// <param name="capacity">对象池的容量。</param>
/// <param name="priority">对象池的优先级。</param>
/// <returns>要创建的允许多次获取的对象池。</returns>
IObjectPool<T> CreateMultiSpawnObjectPool<T>(int capacity, int priority) where T : ObjectBase;
/// <summary>
/// 创建允许多次获取的对象池。
/// </summary>
/// <param name="objectType">对象类型。</param>
/// <param name="capacity">对象池的容量。</param>
/// <param name="priority">对象池的优先级。</param>
/// <returns>要创建的允许多次获取的对象池。</returns>
ObjectPoolBase CreateMultiSpawnObjectPool(Type objectType, int capacity, int priority);
/// <summary>
/// 创建允许多次获取的对象池。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
/// <param name="expireTime">对象池对象过期秒数。</param>
/// <param name="priority">对象池的优先级。</param>
/// <returns>要创建的允许多次获取的对象池。</returns>
IObjectPool<T> CreateMultiSpawnObjectPool<T>(float expireTime, int priority) where T : ObjectBase;
/// <summary>
/// 创建允许多次获取的对象池。
/// </summary>
/// <param name="objectType">对象类型。</param>
/// <param name="expireTime">对象池对象过期秒数。</param>
/// <param name="priority">对象池的优先级。</param>
/// <returns>要创建的允许多次获取的对象池。</returns>
ObjectPoolBase CreateMultiSpawnObjectPool(Type objectType, float expireTime, int priority);
/// <summary>
/// 创建允许多次获取的对象池。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
/// <param name="name">对象池名称。</param>
/// <param name="capacity">对象池的容量。</param>
/// <param name="expireTime">对象池对象过期秒数。</param>
/// <returns>要创建的允许多次获取的对象池。</returns>
IObjectPool<T> CreateMultiSpawnObjectPool<T>(string name, int capacity, float expireTime) where T : ObjectBase;
/// <summary>
/// 创建允许多次获取的对象池。
/// </summary>
/// <param name="objectType">对象类型。</param>
/// <param name="name">对象池名称。</param>
/// <param name="capacity">对象池的容量。</param>
/// <param name="expireTime">对象池对象过期秒数。</param>
/// <returns>要创建的允许多次获取的对象池。</returns>
ObjectPoolBase CreateMultiSpawnObjectPool(Type objectType, string name, int capacity, float expireTime);
/// <summary>
/// 创建允许多次获取的对象池。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
/// <param name="name">对象池名称。</param>
/// <param name="capacity">对象池的容量。</param>
/// <param name="priority">对象池的优先级。</param>
/// <returns>要创建的允许多次获取的对象池。</returns>
IObjectPool<T> CreateMultiSpawnObjectPool<T>(string name, int capacity, int priority) where T : ObjectBase;
/// <summary>
/// 创建允许多次获取的对象池。
/// </summary>
/// <param name="objectType">对象类型。</param>
/// <param name="name">对象池名称。</param>
/// <param name="capacity">对象池的容量。</param>
/// <param name="priority">对象池的优先级。</param>
/// <returns>要创建的允许多次获取的对象池。</returns>
ObjectPoolBase CreateMultiSpawnObjectPool(Type objectType, string name, int capacity, int priority);
/// <summary>
/// 创建允许多次获取的对象池。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
/// <param name="name">对象池名称。</param>
/// <param name="expireTime">对象池对象过期秒数。</param>
/// <param name="priority">对象池的优先级。</param>
/// <returns>要创建的允许多次获取的对象池。</returns>
IObjectPool<T> CreateMultiSpawnObjectPool<T>(string name, float expireTime, int priority) where T : ObjectBase;
/// <summary>
/// 创建允许多次获取的对象池。
/// </summary>
/// <param name="objectType">对象类型。</param>
/// <param name="name">对象池名称。</param>
/// <param name="expireTime">对象池对象过期秒数。</param>
/// <param name="priority">对象池的优先级。</param>
/// <returns>要创建的允许多次获取的对象池。</returns>
ObjectPoolBase CreateMultiSpawnObjectPool(Type objectType, string name, float expireTime, int priority);
/// <summary>
/// 创建允许多次获取的对象池。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
/// <param name="capacity">对象池的容量。</param>
/// <param name="expireTime">对象池对象过期秒数。</param>
/// <param name="priority">对象池的优先级。</param>
/// <returns>要创建的允许多次获取的对象池。</returns>
IObjectPool<T> CreateMultiSpawnObjectPool<T>(int capacity, float expireTime, int priority) where T : ObjectBase;
/// <summary>
/// 创建允许多次获取的对象池。
/// </summary>
/// <param name="objectType">对象类型。</param>
/// <param name="capacity">对象池的容量。</param>
/// <param name="expireTime">对象池对象过期秒数。</param>
/// <param name="priority">对象池的优先级。</param>
/// <returns>要创建的允许多次获取的对象池。</returns>
ObjectPoolBase CreateMultiSpawnObjectPool(Type objectType, int capacity, float expireTime, int priority);
/// <summary>
/// 创建允许多次获取的对象池。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
/// <param name="name">对象池名称。</param>
/// <param name="capacity">对象池的容量。</param>
/// <param name="expireTime">对象池对象过期秒数。</param>
/// <param name="priority">对象池的优先级。</param>
/// <returns>要创建的允许多次获取的对象池。</returns>
IObjectPool<T> CreateMultiSpawnObjectPool<T>(string name, int capacity, float expireTime, int priority)
where T : ObjectBase;
/// <summary>
/// 创建允许多次获取的对象池。
/// </summary>
/// <param name="objectType">对象类型。</param>
/// <param name="name">对象池名称。</param>
/// <param name="capacity">对象池的容量。</param>
/// <param name="expireTime">对象池对象过期秒数。</param>
/// <param name="priority">对象池的优先级。</param>
/// <returns>要创建的允许多次获取的对象池。</returns>
ObjectPoolBase CreateMultiSpawnObjectPool(Type objectType, string name, int capacity, float expireTime,
int priority);
/// <summary>
/// 创建允许多次获取的对象池。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
/// <param name="name">对象池名称。</param>
/// <param name="autoReleaseInterval">对象池自动释放可释放对象的间隔秒数。</param>
/// <param name="capacity">对象池的容量。</param>
/// <param name="expireTime">对象池对象过期秒数。</param>
/// <param name="priority">对象池的优先级。</param>
/// <returns>要创建的允许多次获取的对象池。</returns>
IObjectPool<T> CreateMultiSpawnObjectPool<T>(string name, float autoReleaseInterval, int capacity,
float expireTime, int priority) where T : ObjectBase;
/// <summary>
/// 创建允许多次获取的对象池。
/// </summary>
/// <param name="objectType">对象类型。</param>
/// <param name="name">对象池名称。</param>
/// <param name="autoReleaseInterval">对象池自动释放可释放对象的间隔秒数。</param>
/// <param name="capacity">对象池的容量。</param>
/// <param name="expireTime">对象池对象过期秒数。</param>
/// <param name="priority">对象池的优先级。</param>
/// <returns>要创建的允许多次获取的对象池。</returns>
ObjectPoolBase CreateMultiSpawnObjectPool(Type objectType, string name, float autoReleaseInterval, int capacity,
float expireTime, int priority);
/// <summary>
/// 销毁对象池。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
/// <returns>是否销毁对象池成功。</returns>
bool DestroyObjectPool<T>() where T : ObjectBase;
/// <summary>
/// 销毁对象池。
/// </summary>
/// <param name="objectType">对象类型。</param>
/// <returns>是否销毁对象池成功。</returns>
bool DestroyObjectPool(Type objectType);
/// <summary>
/// 销毁对象池。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
/// <param name="name">要销毁的对象池名称。</param>
/// <returns>是否销毁对象池成功。</returns>
bool DestroyObjectPool<T>(string name) where T : ObjectBase;
/// <summary>
/// 销毁对象池。
/// </summary>
/// <param name="objectType">对象类型。</param>
/// <param name="name">要销毁的对象池名称。</param>
/// <returns>是否销毁对象池成功。</returns>
bool DestroyObjectPool(Type objectType, string name);
/// <summary>
/// 销毁对象池。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
/// <param name="objectPool">要销毁的对象池。</param>
/// <returns>是否销毁对象池成功。</returns>
bool DestroyObjectPool<T>(IObjectPool<T> objectPool) where T : ObjectBase;
/// <summary>
/// 销毁对象池。
/// </summary>
/// <param name="objectPool">要销毁的对象池。</param>
/// <returns>是否销毁对象池成功。</returns>
bool DestroyObjectPool(ObjectPoolBase objectPool);
/// <summary>
/// 释放对象池中的可释放对象。
/// </summary>
void Release();
/// <summary>
/// 释放对象池中的所有未使用对象。
/// </summary>
void ReleaseAllUnused();
/// <summary>
/// 关闭并清理对象池管理器。
/// </summary>
void ShutDown();
/// <summary>
/// 对象池管理器轮询。
/// </summary>
/// <param name="elapseSeconds">逻辑流逝时间，以秒为单位。</param>
/// <param name="realElapseSeconds">真实流逝时间，以秒为单位。</param>
void Update(float elapseSeconds, float realElapseSeconds);
}
}

3
Assets/TEngine/Scripts/Runtime/ObjectPool/Core/IObjectPoolManager.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: e8ce315e69e6410eab5b16e255d93e40
timeCreated: 1662359640

173
Assets/TEngine/Scripts/Runtime/ObjectPool/Core/ObjectBase.cs Normal file
View File

@@ -0,0 +1,173 @@
using System;
namespace TEngine.Runtime.ObjectPool
{
/// <summary>
/// 对象基类。
/// </summary>
public abstract class ObjectBase : IMemory
{
private string m_Name;
private object m_Target;
private bool m_Locked;
private int m_Priority;
private DateTime m_LastUseTime;
/// <summary>
/// 初始化对象基类的新实例。
/// </summary>
public ObjectBase()
{
m_Name = null;
m_Target = null;
m_Locked = false;
m_Priority = 0;
m_LastUseTime = default(DateTime);
}
/// <summary>
/// 获取对象名称。
/// </summary>
public string Name
{
get { return m_Name; }
}
/// <summary>
/// 获取对象。
/// </summary>
public object Target
{
get { return m_Target; }
}
/// <summary>
/// 获取或设置对象是否被加锁。
/// </summary>
public bool Locked
{
get { return m_Locked; }
set { m_Locked = value; }
}
/// <summary>
/// 获取或设置对象的优先级。
/// </summary>
public int Priority
{
get { return m_Priority; }
set { m_Priority = value; }
}
/// <summary>
/// 获取自定义释放检查标记。
/// </summary>
public virtual bool CustomCanReleaseFlag
{
get { return true; }
}
/// <summary>
/// 获取对象上次使用时间。
/// </summary>
public DateTime LastUseTime
{
get { return m_LastUseTime; }
internal set { m_LastUseTime = value; }
}
/// <summary>
/// 初始化对象基类。
/// </summary>
/// <param name="target">对象。</param>
protected void Initialize(object target)
{
Initialize(null, target, false, 0);
}
/// <summary>
/// 初始化对象基类。
/// </summary>
/// <param name="name">对象名称。</param>
/// <param name="target">对象。</param>
protected void Initialize(string name, object target)
{
Initialize(name, target, false, 0);
}
/// <summary>
/// 初始化对象基类。
/// </summary>
/// <param name="name">对象名称。</param>
/// <param name="target">对象。</param>
/// <param name="locked">对象是否被加锁。</param>
protected void Initialize(string name, object target, bool locked)
{
Initialize(name, target, locked, 0);
}
/// <summary>
/// 初始化对象基类。
/// </summary>
/// <param name="name">对象名称。</param>
/// <param name="target">对象。</param>
/// <param name="priority">对象的优先级。</param>
protected void Initialize(string name, object target, int priority)
{
Initialize(name, target, false, priority);
}
/// <summary>
/// 初始化对象基类。
/// </summary>
/// <param name="name">对象名称。</param>
/// <param name="target">对象。</param>
/// <param name="locked">对象是否被加锁。</param>
/// <param name="priority">对象的优先级。</param>
protected void Initialize(string name, object target, bool locked, int priority)
{
if (target == null)
{
throw new Exception(Utility.Text.Format("Target '{0}' is invalid.", name));
}
m_Name = name ?? string.Empty;
m_Target = target;
m_Locked = locked;
m_Priority = priority;
m_LastUseTime = DateTime.UtcNow;
}
/// <summary>
/// 清理对象基类。
/// </summary>
public virtual void Clear()
{
m_Name = null;
m_Target = null;
m_Locked = false;
m_Priority = 0;
m_LastUseTime = default(DateTime);
}
/// <summary>
/// 获取对象时的事件。
/// </summary>
protected internal virtual void OnSpawn()
{
}
/// <summary>
/// 回收对象时的事件。
/// </summary>
protected internal virtual void OnUnspawn()
{
}
/// <summary>
/// 释放对象。
/// </summary>
/// <param name="isShutdown">是否是关闭对象池时触发。</param>
protected internal abstract void Release(bool isShutdown);
}
}

11
Assets/TEngine/Scripts/Runtime/ObjectPool/Core/ObjectBase.cs.meta Normal file
View File

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

95
Assets/TEngine/Scripts/Runtime/ObjectPool/Core/ObjectInfo.cs Normal file
View File

@@ -0,0 +1,95 @@
using System;
using System.Runtime.InteropServices;
namespace TEngine.Runtime.ObjectPool
{
/// <summary>
/// 对象信息。
/// </summary>
[StructLayout(LayoutKind.Auto)]
public struct ObjectInfo
{
private readonly string m_Name;
private readonly bool m_Locked;
private readonly bool m_CustomCanReleaseFlag;
private readonly int m_Priority;
private readonly DateTime m_LastUseTime;
private readonly int m_SpawnCount;
/// <summary>
/// 初始化对象信息的新实例。
/// </summary>
/// <param name="name">对象名称。</param>
/// <param name="locked">对象是否被加锁。</param>
/// <param name="customCanReleaseFlag">对象自定义释放检查标记。</param>
/// <param name="priority">对象的优先级。</param>
/// <param name="lastUseTime">对象上次使用时间。</param>
/// <param name="spawnCount">对象的获取计数。</param>
public ObjectInfo(string name, bool locked, bool customCanReleaseFlag, int priority, DateTime lastUseTime,
int spawnCount)
{
m_Name = name;
m_Locked = locked;
m_CustomCanReleaseFlag = customCanReleaseFlag;
m_Priority = priority;
m_LastUseTime = lastUseTime;
m_SpawnCount = spawnCount;
}
/// <summary>
/// 获取对象名称。
/// </summary>
public string Name
{
get { return m_Name; }
}
/// <summary>
/// 获取对象是否被加锁。
/// </summary>
public bool Locked
{
get { return m_Locked; }
}
/// <summary>
/// 获取对象自定义释放检查标记。
/// </summary>
public bool CustomCanReleaseFlag
{
get { return m_CustomCanReleaseFlag; }
}
/// <summary>
/// 获取对象的优先级。
/// </summary>
public int Priority
{
get { return m_Priority; }
}
/// <summary>
/// 获取对象上次使用时间。
/// </summary>
public DateTime LastUseTime
{
get { return m_LastUseTime; }
}
/// <summary>
/// 获取对象是否正在使用。
/// </summary>
public bool IsInUse
{
get { return m_SpawnCount > 0; }
}
/// <summary>
/// 获取对象的获取计数。
/// </summary>
public int SpawnCount
{
get { return m_SpawnCount; }
}
}
}

3
Assets/TEngine/Scripts/Runtime/ObjectPool/Core/ObjectInfo.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: a4682d5bde734d3babd92bce4fba1cc8
timeCreated: 1662359545

111
Assets/TEngine/Scripts/Runtime/ObjectPool/Core/ObjectPoolBase.cs Normal file
View File

@@ -0,0 +1,111 @@
using System;
namespace TEngine.Runtime.ObjectPool
{
/// <summary>
/// 对象池基类。
/// </summary>
public abstract class ObjectPoolBase
{
private readonly string m_Name;
/// <summary>
/// 初始化对象池基类的新实例。
/// </summary>
public ObjectPoolBase()
: this(null)
{
}
/// <summary>
/// 初始化对象池基类的新实例。
/// </summary>
/// <param name="name">对象池名称。</param>
public ObjectPoolBase(string name)
{
m_Name = name ?? string.Empty;
}
/// <summary>
/// 获取对象池名称。
/// </summary>
public string Name
{
get { return m_Name; }
}
/// <summary>
/// 获取对象池完整名称。
/// </summary>
public string FullName
{
get { return new TypeNamePair(ObjectType, m_Name).ToString(); }
}
/// <summary>
/// 获取对象池对象类型。
/// </summary>
public abstract Type ObjectType { get; }
/// <summary>
/// 获取对象池中对象的数量。
/// </summary>
public abstract int Count { get; }
/// <summary>
/// 获取对象池中能被释放的对象的数量。
/// </summary>
public abstract int CanReleaseCount { get; }
/// <summary>
/// 获取是否允许对象被多次获取。
/// </summary>
public abstract bool AllowMultiSpawn { get; }
/// <summary>
/// 获取或设置对象池自动释放可释放对象的间隔秒数。
/// </summary>
public abstract float AutoReleaseInterval { get; set; }
/// <summary>
/// 获取或设置对象池的容量。
/// </summary>
public abstract int Capacity { get; set; }
/// <summary>
/// 获取或设置对象池对象过期秒数。
/// </summary>
public abstract float ExpireTime { get; set; }
/// <summary>
/// 获取或设置对象池的优先级。
/// </summary>
public abstract int Priority { get; set; }
/// <summary>
/// 释放对象池中的可释放对象。
/// </summary>
public abstract void Release();
/// <summary>
/// 释放对象池中的可释放对象。
/// </summary>
/// <param name="toReleaseCount">尝试释放对象数量。</param>
public abstract void Release(int toReleaseCount);
/// <summary>
/// 释放对象池中的所有未使用对象。
/// </summary>
public abstract void ReleaseAllUnused();
/// <summary>
/// 获取所有对象信息。
/// </summary>
/// <returns>所有对象信息。</returns>
public abstract ObjectInfo[] GetAllObjectInfos();
internal abstract void Update(float elapseSeconds, float realElapseSeconds);
internal abstract void Shutdown();
}
}

3
Assets/TEngine/Scripts/Runtime/ObjectPool/Core/ObjectPoolBase.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: db8915b17e3249fba34df8c264a95805
timeCreated: 1662359670

1047
Assets/TEngine/Scripts/Runtime/ObjectPool/Core/ObjectPoolComponent.cs Normal file
View File

File diff suppressed because it is too large Load Diff

11
Assets/TEngine/Scripts/Runtime/ObjectPool/Core/ObjectPoolComponent.cs.meta Normal file
View File

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

163
Assets/TEngine/Scripts/Runtime/ObjectPool/Core/ObjectPoolManager.Object.cs Normal file
View File

@@ -0,0 +1,163 @@
using System;
namespace TEngine.Runtime.ObjectPool
{
internal sealed partial class ObjectPoolManager
{
/// <summary>
/// 内部对象。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
private sealed class Object<T> : IMemory where T : ObjectBase
{
private T m_Object;
private int m_SpawnCount;
/// <summary>
/// 初始化内部对象的新实例。
/// </summary>
public Object()
{
m_Object = null;
m_SpawnCount = 0;
}
/// <summary>
/// 获取对象名称。
/// </summary>
public string Name
{
get { return m_Object.Name; }
}
/// <summary>
/// 获取对象是否被加锁。
/// </summary>
public bool Locked
{
get { return m_Object.Locked; }
internal set { m_Object.Locked = value; }
}
/// <summary>
/// 获取对象的优先级。
/// </summary>
public int Priority
{
get { return m_Object.Priority; }
internal set { m_Object.Priority = value; }
}
/// <summary>
/// 获取自定义释放检查标记。
/// </summary>
public bool CustomCanReleaseFlag
{
get { return m_Object.CustomCanReleaseFlag; }
}
/// <summary>
/// 获取对象上次使用时间。
/// </summary>
public DateTime LastUseTime
{
get { return m_Object.LastUseTime; }
}
/// <summary>
/// 获取对象是否正在使用。
/// </summary>
public bool IsInUse
{
get { return m_SpawnCount > 0; }
}
/// <summary>
/// 获取对象的获取计数。
/// </summary>
public int SpawnCount
{
get { return m_SpawnCount; }
}
/// <summary>
/// 创建内部对象。
/// </summary>
/// <param name="obj">对象。</param>
/// <param name="spawned">对象是否已被获取。</param>
/// <returns>创建的内部对象。</returns>
public static Object<T> Create(T obj, bool spawned)
{
if (obj == null)
{
throw new Exception("Object is invalid.");
}
Object<T> internalObject = MemoryPool.Acquire<Object<T>>();
internalObject.m_Object = obj;
internalObject.m_SpawnCount = spawned ? 1 : 0;
if (spawned)
{
obj.OnSpawn();
}
return internalObject;
}
/// <summary>
/// 清理内部对象。
/// </summary>
public void Clear()
{
m_Object = null;
m_SpawnCount = 0;
}
/// <summary>
/// 查看对象。
/// </summary>
/// <returns>对象。</returns>
public T Peek()
{
return m_Object;
}
/// <summary>
/// 获取对象。
/// </summary>
/// <returns>对象。</returns>
public T Spawn()
{
m_SpawnCount++;
m_Object.LastUseTime = DateTime.UtcNow;
m_Object.OnSpawn();
return m_Object;
}
/// <summary>
/// 回收对象。
/// </summary>
public void Unspawn()
{
m_Object.OnUnspawn();
m_Object.LastUseTime = DateTime.UtcNow;
m_SpawnCount--;
if (m_SpawnCount < 0)
{
throw new Exception(Utility.Text.Format("Object '{0}' spawn count is less than 0.",
Name));
}
}
/// <summary>
/// 释放对象。
/// </summary>
/// <param name="isShutdown">是否是关闭对象池时触发。</param>
public void Release(bool isShutdown)
{
m_Object.Release(isShutdown);
MemoryPool.Release(m_Object);
}
}
}
}

3
Assets/TEngine/Scripts/Runtime/ObjectPool/Core/ObjectPoolManager.Object.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: 40d305530ac24084ad02b9bcb9712d46
timeCreated: 1662359765

615
Assets/TEngine/Scripts/Runtime/ObjectPool/Core/ObjectPoolManager.ObjectPool.cs Normal file
View File

@@ -0,0 +1,615 @@
using System;
using System.Collections.Generic;
namespace TEngine.Runtime.ObjectPool
{
internal sealed partial class ObjectPoolManager
{
/// <summary>
/// 对象池。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
private sealed class ObjectPool<T> : ObjectPoolBase, IObjectPool<T> where T : ObjectBase
{
private readonly MultiDictionary<string, Object<T>> m_Objects;
private readonly Dictionary<object, Object<T>> m_ObjectMap;
private readonly ReleaseObjectFilterCallback<T> m_DefaultReleaseObjectFilterCallback;
private readonly List<T> m_CachedCanReleaseObjects;
private readonly List<T> m_CachedToReleaseObjects;
private readonly bool m_AllowMultiSpawn;
private float m_AutoReleaseInterval;
private int m_Capacity;
private float m_ExpireTime;
private int m_Priority;
private float m_AutoReleaseTime;
/// <summary>
/// 初始化对象池的新实例。
/// </summary>
/// <param name="name">对象池名称。</param>
/// <param name="allowMultiSpawn">是否允许对象被多次获取。</param>
/// <param name="autoReleaseInterval">对象池自动释放可释放对象的间隔秒数。</param>
/// <param name="capacity">对象池的容量。</param>
/// <param name="expireTime">对象池对象过期秒数。</param>
/// <param name="priority">对象池的优先级。</param>
public ObjectPool(string name, bool allowMultiSpawn, float autoReleaseInterval, int capacity,
float expireTime, int priority)
: base(name)
{
m_Objects = new MultiDictionary<string, Object<T>>();
m_ObjectMap = new Dictionary<object, Object<T>>();
m_DefaultReleaseObjectFilterCallback = DefaultReleaseObjectFilterCallback;
m_CachedCanReleaseObjects = new List<T>();
m_CachedToReleaseObjects = new List<T>();
m_AllowMultiSpawn = allowMultiSpawn;
m_AutoReleaseInterval = autoReleaseInterval;
Capacity = capacity;
ExpireTime = expireTime;
m_Priority = priority;
m_AutoReleaseTime = 0f;
}
/// <summary>
/// 获取对象池对象类型。
/// </summary>
public override Type ObjectType
{
get { return typeof(T); }
}
/// <summary>
/// 获取对象池中对象的数量。
/// </summary>
public override int Count
{
get { return m_ObjectMap.Count; }
}
/// <summary>
/// 获取对象池中能被释放的对象的数量。
/// </summary>
public override int CanReleaseCount
{
get
{
GetCanReleaseObjects(m_CachedCanReleaseObjects);
return m_CachedCanReleaseObjects.Count;
}
}
/// <summary>
/// 获取是否允许对象被多次获取。
/// </summary>
public override bool AllowMultiSpawn
{
get { return m_AllowMultiSpawn; }
}
/// <summary>
/// 获取或设置对象池自动释放可释放对象的间隔秒数。
/// </summary>
public override float AutoReleaseInterval
{
get { return m_AutoReleaseInterval; }
set { m_AutoReleaseInterval = value; }
}
/// <summary>
/// 获取或设置对象池的容量。
/// </summary>
public override int Capacity
{
get { return m_Capacity; }
set
{
if (value < 0)
{
throw new Exception("Capacity is invalid.");
}
if (m_Capacity == value)
{
return;
}
m_Capacity = value;
Release();
}
}
/// <summary>
/// 获取或设置对象池对象过期秒数。
/// </summary>
public override float ExpireTime
{
get { return m_ExpireTime; }
set
{
if (value < 0f)
{
throw new Exception("ExpireTime is invalid.");
}
if (ExpireTime == value)
{
return;
}
m_ExpireTime = value;
Release();
}
}
/// <summary>
/// 获取或设置对象池的优先级。
/// </summary>
public override int Priority
{
get { return m_Priority; }
set { m_Priority = value; }
}
/// <summary>
/// 创建对象。
/// </summary>
/// <param name="obj">对象。</param>
/// <param name="spawned">对象是否已被获取。</param>
public void Register(T obj, bool spawned)
{
if (obj == null)
{
throw new Exception("Object is invalid.");
}
Object<T> internalObject = Object<T>.Create(obj, spawned);
m_Objects.Add(obj.Name, internalObject);
m_ObjectMap.Add(obj.Target, internalObject);
if (Count > m_Capacity)
{
Release();
}
}
/// <summary>
/// 检查对象。
/// </summary>
/// <returns>要检查的对象是否存在。</returns>
public bool CanSpawn()
{
return CanSpawn(string.Empty);
}
/// <summary>
/// 检查对象。
/// </summary>
/// <param name="name">对象名称。</param>
/// <returns>要检查的对象是否存在。</returns>
public bool CanSpawn(string name)
{
if (name == null)
{
throw new Exception("Name is invalid.");
}
LinkedListRange<Object<T>> objectRange = default(LinkedListRange<Object<T>>);
if (m_Objects.TryGetValue(name, out objectRange))
{
foreach (Object<T> internalObject in objectRange)
{
if (m_AllowMultiSpawn || !internalObject.IsInUse)
{
return true;
}
}
}
return false;
}
/// <summary>
/// 获取对象。
/// </summary>
/// <returns>要获取的对象。</returns>
public T Spawn()
{
return Spawn(string.Empty);
}
/// <summary>
/// 获取对象。
/// </summary>
/// <param name="name">对象名称。</param>
/// <returns>要获取的对象。</returns>
public T Spawn(string name)
{
if (name == null)
{
throw new Exception("Name is invalid.");
}
LinkedListRange<Object<T>> objectRange = default(LinkedListRange<Object<T>>);
if (m_Objects.TryGetValue(name, out objectRange))
{
foreach (Object<T> internalObject in objectRange)
{
if (m_AllowMultiSpawn || !internalObject.IsInUse)
{
return internalObject.Spawn();
}
}
}
return null;
}
/// <summary>
/// 回收对象。
/// </summary>
/// <param name="obj">要回收的对象。</param>
public void Unspawn(T obj)
{
if (obj == null)
{
throw new Exception("Object is invalid.");
}
Unspawn(obj.Target);
}
/// <summary>
/// 回收对象。
/// </summary>
/// <param name="target">要回收的对象。</param>
public void Unspawn(object target)
{
if (target == null)
{
throw new Exception("Target is invalid.");
}
Object<T> internalObject = GetObject(target);
if (internalObject != null)
{
internalObject.Unspawn();
if (Count > m_Capacity && internalObject.SpawnCount <= 0)
{
Release();
}
}
else
{
throw new Exception(Utility.Text.Format(
"Can not find target in object pool '{0}', target type is '{1}', target value is '{2}'.",
new TypeNamePair(typeof(T), Name), target.GetType().FullName, target));
}
}
/// <summary>
/// 设置对象是否被加锁。
/// </summary>
/// <param name="obj">要设置被加锁的对象。</param>
/// <param name="locked">是否被加锁。</param>
public void SetLocked(T obj, bool locked)
{
if (obj == null)
{
throw new Exception("Object is invalid.");
}
SetLocked(obj.Target, locked);
}
/// <summary>
/// 设置对象是否被加锁。
/// </summary>
/// <param name="target">要设置被加锁的对象。</param>
/// <param name="locked">是否被加锁。</param>
public void SetLocked(object target, bool locked)
{
if (target == null)
{
throw new Exception("Target is invalid.");
}
Object<T> internalObject = GetObject(target);
if (internalObject != null)
{
internalObject.Locked = locked;
}
else
{
throw new Exception(Utility.Text.Format(
"Can not find target in object pool '{0}', target type is '{1}', target value is '{2}'.",
new TypeNamePair(typeof(T), Name), target.GetType().FullName, target));
}
}
/// <summary>
/// 设置对象的优先级。
/// </summary>
/// <param name="obj">要设置优先级的对象。</param>
/// <param name="priority">优先级。</param>
public void SetPriority(T obj, int priority)
{
if (obj == null)
{
throw new Exception("Object is invalid.");
}
SetPriority(obj.Target, priority);
}
/// <summary>
/// 设置对象的优先级。
/// </summary>
/// <param name="target">要设置优先级的对象。</param>
/// <param name="priority">优先级。</param>
public void SetPriority(object target, int priority)
{
if (target == null)
{
throw new Exception("Target is invalid.");
}
Object<T> internalObject = GetObject(target);
if (internalObject != null)
{
internalObject.Priority = priority;
}
else
{
throw new Exception(Utility.Text.Format(
"Can not find target in object pool '{0}', target type is '{1}', target value is '{2}'.",
new TypeNamePair(typeof(T), Name), target.GetType().FullName, target));
}
}
/// <summary>
/// 释放对象。
/// </summary>
/// <param name="obj">要释放的对象。</param>
/// <returns>释放对象是否成功。</returns>
public bool ReleaseObject(T obj)
{
if (obj == null)
{
throw new Exception("Object is invalid.");
}
return ReleaseObject(obj.Target);
}
/// <summary>
/// 释放对象。
/// </summary>
/// <param name="target">要释放的对象。</param>
/// <returns>释放对象是否成功。</returns>
public bool ReleaseObject(object target)
{
if (target == null)
{
throw new Exception("Target is invalid.");
}
Object<T> internalObject = GetObject(target);
if (internalObject == null)
{
return false;
}
if (internalObject.IsInUse || internalObject.Locked || !internalObject.CustomCanReleaseFlag)
{
return false;
}
m_Objects.Remove(internalObject.Name, internalObject);
m_ObjectMap.Remove(internalObject.Peek().Target);
internalObject.Release(false);
MemoryPool.Release(internalObject);
return true;
}
/// <summary>
/// 释放对象池中的可释放对象。
/// </summary>
public override void Release()
{
Release(Count - m_Capacity, m_DefaultReleaseObjectFilterCallback);
}
/// <summary>
/// 释放对象池中的可释放对象。
/// </summary>
/// <param name="toReleaseCount">尝试释放对象数量。</param>
public override void Release(int toReleaseCount)
{
Release(toReleaseCount, m_DefaultReleaseObjectFilterCallback);
}
/// <summary>
/// 释放对象池中的可释放对象。
/// </summary>
/// <param name="releaseObjectFilterCallback">释放对象筛选函数。</param>
public void Release(ReleaseObjectFilterCallback<T> releaseObjectFilterCallback)
{
Release(Count - m_Capacity, releaseObjectFilterCallback);
}
/// <summary>
/// 释放对象池中的可释放对象。
/// </summary>
/// <param name="toReleaseCount">尝试释放对象数量。</param>
/// <param name="releaseObjectFilterCallback">释放对象筛选函数。</param>
public void Release(int toReleaseCount, ReleaseObjectFilterCallback<T> releaseObjectFilterCallback)
{
if (releaseObjectFilterCallback == null)
{
throw new Exception("Release object filter callback is invalid.");
}
if (toReleaseCount < 0)
{
toReleaseCount = 0;
}
DateTime expireTime = DateTime.MinValue;
if (m_ExpireTime < float.MaxValue)
{
expireTime = DateTime.UtcNow.AddSeconds(-m_ExpireTime);
}
m_AutoReleaseTime = 0f;
GetCanReleaseObjects(m_CachedCanReleaseObjects);
List<T> toReleaseObjects =
releaseObjectFilterCallback(m_CachedCanReleaseObjects, toReleaseCount, expireTime);
if (toReleaseObjects == null || toReleaseObjects.Count <= 0)
{
return;
}
foreach (T toReleaseObject in toReleaseObjects)
{
ReleaseObject(toReleaseObject);
}
}
/// <summary>
/// 释放对象池中的所有未使用对象。
/// </summary>
public override void ReleaseAllUnused()
{
m_AutoReleaseTime = 0f;
GetCanReleaseObjects(m_CachedCanReleaseObjects);
foreach (T toReleaseObject in m_CachedCanReleaseObjects)
{
ReleaseObject(toReleaseObject);
}
}
/// <summary>
/// 获取所有对象信息。
/// </summary>
/// <returns>所有对象信息。</returns>
public override ObjectInfo[] GetAllObjectInfos()
{
List<ObjectInfo> results = new List<ObjectInfo>();
foreach (KeyValuePair<string, LinkedListRange<Object<T>>> objectRanges in m_Objects)
{
foreach (Object<T> internalObject in objectRanges.Value)
{
results.Add(new ObjectInfo(internalObject.Name, internalObject.Locked,
internalObject.CustomCanReleaseFlag, internalObject.Priority, internalObject.LastUseTime,
internalObject.SpawnCount));
}
}
return results.ToArray();
}
internal override void Update(float elapseSeconds, float realElapseSeconds)
{
m_AutoReleaseTime += realElapseSeconds;
if (m_AutoReleaseTime < m_AutoReleaseInterval)
{
return;
}
Release();
}
internal override void Shutdown()
{
foreach (KeyValuePair<object, Object<T>> objectInMap in m_ObjectMap)
{
objectInMap.Value.Release(true);
MemoryPool.Release(objectInMap.Value);
}
m_Objects.Clear();
m_ObjectMap.Clear();
m_CachedCanReleaseObjects.Clear();
m_CachedToReleaseObjects.Clear();
}
private Object<T> GetObject(object target)
{
if (target == null)
{
throw new Exception("Target is invalid.");
}
Object<T> internalObject = null;
if (m_ObjectMap.TryGetValue(target, out internalObject))
{
return internalObject;
}
return null;
}
private void GetCanReleaseObjects(List<T> results)
{
if (results == null)
{
throw new Exception("Results is invalid.");
}
results.Clear();
foreach (KeyValuePair<object, Object<T>> objectInMap in m_ObjectMap)
{
Object<T> internalObject = objectInMap.Value;
if (internalObject.IsInUse || internalObject.Locked || !internalObject.CustomCanReleaseFlag)
{
continue;
}
results.Add(internalObject.Peek());
}
}
private List<T> DefaultReleaseObjectFilterCallback(List<T> candidateObjects, int toReleaseCount,
DateTime expireTime)
{
m_CachedToReleaseObjects.Clear();
if (expireTime > DateTime.MinValue)
{
for (int i = candidateObjects.Count - 1; i >= 0; i--)
{
if (candidateObjects[i].LastUseTime <= expireTime)
{
m_CachedToReleaseObjects.Add(candidateObjects[i]);
candidateObjects.RemoveAt(i);
continue;
}
}
toReleaseCount -= m_CachedToReleaseObjects.Count;
}
for (int i = 0; toReleaseCount > 0 && i < candidateObjects.Count; i++)
{
for (int j = i + 1; j < candidateObjects.Count; j++)
{
if (candidateObjects[i].Priority > candidateObjects[j].Priority
|| candidateObjects[i].Priority == candidateObjects[j].Priority &&
candidateObjects[i].LastUseTime > candidateObjects[j].LastUseTime)
{
T temp = candidateObjects[i];
candidateObjects[i] = candidateObjects[j];
candidateObjects[j] = temp;
}
}
m_CachedToReleaseObjects.Add(candidateObjects[i]);
toReleaseCount--;
}
return m_CachedToReleaseObjects;
}
}
}
}

3
Assets/TEngine/Scripts/Runtime/ObjectPool/Core/ObjectPoolManager.ObjectPool.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: 4f79710eaa5a486e9c192ed9400ff18f
timeCreated: 1662359778

1352
Assets/TEngine/Scripts/Runtime/ObjectPool/Core/ObjectPoolManager.cs Normal file
View File

File diff suppressed because it is too large Load Diff

3
Assets/TEngine/Scripts/Runtime/ObjectPool/Core/ObjectPoolManager.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: af3d18697d7e4167bf3ec431020248b8
timeCreated: 1662359698

15
Assets/TEngine/Scripts/Runtime/ObjectPool/Core/ReleaseObjectFilterCallback.cs Normal file
View File

@@ -0,0 +1,15 @@
using System;
using System.Collections.Generic;
namespace TEngine.Runtime.ObjectPool
{
/// <summary>
/// 释放对象筛选函数。
/// </summary>
/// <typeparam name="T">对象类型。</typeparam>
/// <param name="candidateObjects">要筛选的对象集合。</param>
/// <param name="toReleaseCount">需要释放的对象数量。</param>
/// <param name="expireTime">对象过期参考时间。</param>
/// <returns>经筛选需要释放的对象集合。</returns>
public delegate List<T> ReleaseObjectFilterCallback<T>(List<T> candidateObjects, int toReleaseCount, DateTime expireTime) where T : ObjectBase;
}

3
Assets/TEngine/Scripts/Runtime/ObjectPool/Core/ReleaseObjectFilterCallback.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: 66e9f591627745d297bbe1bc7d783263
timeCreated: 1662359607