Unity3D PoolManager缓冲池插件

我用的PoolManager版本是5.5.2的，导入的包总共有三个文件夹：Editor，Plugins，PoolManagerExampleFiles

1、Editor这个文件夹里面的东西，顾名思义，就是写关于编辑器的东西，从而使用于可以很方便的为对象添加PreRuntimePoolItem和SpawnPool这两个脚本，生成的编辑器样式为：



2、Plugins文件夹里面主要有三个非常重要的脚本，即PoolManager，PreRuntimePoolItem和SpawnPool这三个脚本

3、PoolManagerExampleFiles文件夹里面存放的就是实例工程文件了

1、SpawnPool脚本

作用：创建缓冲池，并缓冲需要的对象

每一个选项的解释说明如下：

PoolName：缓存池的唯一名称。

MatchPoolScale：勾选后实例化的游戏对象的缩放比例将全是1，不勾选择用Prefab默认的。

MachPool Layer：勾选后实例化的游戏对象的Layer将用Prefab默认的。

Don’t Reparent：勾选后实例化的对象将没有父节点，通通在最上层，建议不要勾选。

Don’t Destroy On Load：这个就不用我解释了吧？切换场景不释放。

Log Messages 是否打印日志信息

Pre-Prefab Pool Options ：缓存池列表，意思就是缓存列表里面可以放各种类型的Prefab。右边有个 “+”按钮点击就添加每个类型的Prefab了

prefab：可以直接把工程里的Prefab直接拖进来。

preloadAmount:缓存池这个Prefab的预加载数量。意思为一开始加载的数量！

preloadTime：如果勾选表示缓存池所有的gameobject可以“异步”加载。

preloadFrames：每几帧加载一个。

preloadDelay：延迟多久开始加载。

limitInstance：是否开启对象实例化的限制功能。

limit Amount：限制实例化Prefab的数量，也就是限制缓冲池的数量，它和上面的preloadAmount是有冲突的，如果同时开启则以limitAmout为准。

limitFIFO：如果我们限制了缓存池里面只能有10个Prefab，如果不勾选它，那么你拿第11个的时候就会返回null。如果勾选它在取第11个的时候他会返回给你前10个里最不常用的那个。

cullDespawend：是否开启缓存池智能自动清理模式。

cull Above：缓存池自动清理，但是始终保留几个对象不清理。

cull Delay：每过多久执行一遍自动清理，单位是秒。从上一次清理过后开始计时

cullMaxPerPass：每次自动清理几个游戏对象。

自动清理：就是当池子里面的对象setActive(false)也就是目前不用的时候，poolManager会根据上述参数自动清理这些对象，清理也就是Destroy()掉。

active变为true或false是由Spawn和Despawn方法决定的！

limitInstance是否开启（打钩）的区别：

不开启情况：假如此时preloadAmount为1，如果用户想要每隔5秒去Spawn一个缓冲池中的对象，那么当加载第二个prefab对象的时候，缓冲池会再创建一个此对象，如果程序再Spawn，那么还会在产生一个这样的对象，就这样一直产生下去，Spawn几次就产生几个对象！

（粒子系统：循环时：Spawn几次，就会产生几个对象，不循环时（循环结束状态为false）：会再产生一个对象，如果此时的Spawn速度特别快，并且检测不到前面的对象状态为false，那么可能会产生多个对象，直到检测到前面的几个对象有false状态，那么产生对象到此为止，程序在此几个对象之间来回Spawn！）

开启情况：

此时Limit Amount为1

limitFIFO勾选：那么程序永远使用的是预加载对象，而不会再产生其他对象！当加载第二次的时候，即使第一个对象处于true状态，也使用它，即操作第一个对象！（粒子系统为循环或者不循环时，效果和这一样）

limitFIFO不勾选：那么程序永远使用的是预加载对象，而不会再产生其他对象！当加载第二次的时候，那么必须等第一个对象变为false状态，才能使用它！如果过了5s，第一个对象还没变为false状态，那么程序会报错！（粒子系统为循环：会循环下去，只有一个预加载对象，不报错，不循环时：等上一个变为false才能进行第二次，只有一个预加载对象，不报错！）

如果limit Amount数量大于1，为10的话

limitFIFO勾选：永远只有10个对象产生，当加载第11个对象时，如果前十个对象没有一个active为false状态，那么程序会选择不常用的那个，从而避免报错！

limitFIFO不勾选：永远只有10个对象产生，但是当加载第11个对象时，如果前十个对象没有一个active为false状态，那么程序会报错！

（粒子系统，永远只有10个对象，不报错！）

缓冲池里面的对象active变为true和false时，触发的事件（此脚本悬挂在缓冲池对象上）：

private void OnSpawned(SpawnPool pool)
{
Debug.Log
(
string.Format
(
"OnSpawnedExample | OnSpawned running for '{0}' in pool '{1}'.",
this.name,
pool.poolName
)
);
}

private void OnDespawned(SpawnPool pool)
{
Debug.Log
(
string.Format
(
"OnSpawnedExample | OnDespawned unning for '{0}' in pool '{1}'.",
this.name,
pool.poolName
)
);
}

获取缓冲池的方式：

SpawnPool pool = PoolManager.Pools[poolName];

SpawnPool pool = this.GetComponent<SpawnPool>();

代码为缓冲池预加载对象：这也是PreRuntimePoolItem脚本的作用，SpawnPool下的Options预设必须包含prefabName，并且悬挂PreRuntimePoolItem脚本的对象和SpawnPool脚本下的Options中的预设无关！

public class PreRuntimePoolItem : MonoBehaviour
{
public string poolName = "";//缓冲池名称
public string prefabName = "";//预设名称
public bool despawnOnStart = true; //active初始化为false状态
public bool doNotReparent = false;//是否有父节点

private void Start()
{
SpawnPool pool;
if (!PoolManager.Pools.TryGetValue(this.poolName, out pool))
{
string msg = "PreRuntimePoolItem Error ('{0}'): " +
"No pool with the name '{1}' exists! Create one using the " +
"PoolManager Inspector interface or PoolManager.CreatePool()." +
"See the online docs for more information at " +
"http://docs.poolmanager.path-o-logical.com";

Debug.LogError(string.Format(msg, this.name, this.poolName));
return;
}
pool.Add(this.transform, this.prefabName,
this.despawnOnStart, !this.doNotReparent);
}
}

如果SpawnPool脚本下已经有预设为Cube的对象，并且预加载数量为3，如果此时我们通过 PreRuntimePoolItem脚本的作用，也为此缓冲池加载了2个预设为Cube的对象，那么即使PreRuntimePoolItem脚本的Do Not Reparent是否勾选，一旦程序进行Spawn获取，那么这些预加载对象都会被加载到挂有SpawnPool脚本的对象下，如果Spawn50个，那么就会依次激活他们！Despawn On Start为true的不会算在内！

通过脚本创建缓冲池，取对象，销毁对象：

public class CreationExample : MonoBehaviour
{
//要实例化的预设
public Transform testPrefab;
//缓冲池的名称
public string poolName = "Creator";
//缓冲数量
public int spawnAmount = 50;
//多久实例化或者删除一个对象（Interval：时间间隔）
public float spawnInterval = 0.25f;
//缓冲池对象
private SpawnPool pool;

private void Start()
{
//创建缓冲池，并命名
pool = PoolManager.Pools.Create(this.poolName);
//从缓冲池中创建出来的对象会被列到名称为CreaterGroup这个组中去
pool.group.name = "CreatorGroup";//默认名称为CreatorPool
//指定这个组的父节点（此时的父节点被指定为当前脚本悬挂的对象，即Creator对象）
pool.group.parent = this.transform;
//那么从缓冲池获取对象，对象的层次关系为：
//  Creator
//  -------CreatorGroup
//  ---------------------Sphere（Clone）001
//  ---------------------Sphere（Clone）002
//  ---------------------Sphere（Clone）003
//指定这个组（即CreatorGroup）的位置与旋转
pool.group.localPosition = new Vector3(1.5f, 0, 0);
pool.group.localRotation = Quaternion.identity;

//创建预设
PrefabPool prefabPool = new PrefabPool(testPrefab);
//缓存池这个Prefab的最大保存数量
prefabPool.preloadAmount = 1;
//是否开启缓存池智能自动清理模式
prefabPool.cullDespawned = true;
//缓存池自动清理，但是始终保留几个对象不清理
prefabPool.cullAbove = 3;
//每过多久执行一遍自动清理(销毁)，单位是秒
prefabPool.cullDelay = 6;
//每次自动清理2个游戏对象
prefabPool.cullMaxPerPass = 2;
//是否开启实例的限制功能
prefabPool.limitInstances = true;
//限制缓存池里最大的Prefab的数量，它和上面的preloadAmount是有冲突的，如果同时开启则以limitAmout为准
prefabPool.limitAmount = 3;
//如果我们限制了缓存池里面只能有10个Prefab，如果不勾选它，那么你拿第11个的时候就会返回null。如果勾选它在取第11个的时候他会返回给你前10个里最不常用的那个
prefabPool.limitFIFO = true;
//加入此预设
pool.CreatePrefabPool(prefabPool);
//开启协同，实例化对象
StartCoroutine(Spawner());
}

//每隔一段时间实例化一个对象
private IEnumerator Spawner()
{
int count = this.spawnAmount;
Transform inst;
while (count > 0)
{
inst = pool.Spawn(this.testPrefab, Vector3.zero, Quaternion.identity);
inst.localPosition = new Vector3(this.spawnAmount - count, 0, 0);
count--;
yield return new WaitForSeconds(this.spawnInterval);
}
// 开始销毁对象
this.StartCoroutine(Despawner());
}

//每隔一段时间销毁一个对象
private IEnumerator Despawner()
{
while (pool.Count > 0)
{
Transform instance = pool[pool.Count - 1];
pool.Despawn(instance);

yield return new WaitForSeconds(this.spawnInterval);
}
}
}

取缓冲池中的某一个对象

Transform cubePrefab = PoolManager.Pools["Shapes"].prefabs["Cube"];
Transform cubeinstance = PoolManager.Pools["Shapes"].Spawn(cubePrefab);
cubeinstance.name = "Cube (Spawned By CreationExample.cs)";

转载自：http://blog.csdn.net/henren555/article/details/42100881