和Keyle一起学PoolManager

using UnityEngine; using System.Collections; using System.Collections.Generic; /// 
/// An example that shows the creation of a pool. /// 
public class CreationExample : MonoBehaviour {     public Transform testPrefab; public string poolName = "Creator"; public int spawnAmount = 10; public float spawnInterval = 0.25f; private SpawnPool pool; /// 

    /// 设置预制池不同的属性 /// 
    private void Start() { this.pool = PoolManager.Pools.Create(this.poolName); // 将这个池作为当前物体的子物体
        this.pool.group.parent = this.transform; // 设置池的位置 角度
        this.pool.group.localPosition = new Vector3(1.5f, 0, 0); this.pool.group.localRotation = Quaternion.identity; //PoolManager创建一个预制池，这个池不需要你预先装载，如果没有特殊需求跳过下面步骤，不必要填写下面的参数，预制池自动采取默认参数。
        PrefabPool prefabPool = new PrefabPool(testPrefab); prefabPool.preloadAmount = 5;//默认初始化就是自动生成五个实例
        prefabPool.cullDespawned = true; prefabPool.cullAbove = 10; prefabPool.cullDelay = 1; prefabPool.limitInstances = true; prefabPool.limitAmount = 5; prefabPool.limitFIFO = true; this.pool.CreatePrefabPool(prefabPool);//PoolManager在池组中创建一个预制池

        this.StartCoroutine(Spawner());//开始生产 // 我们有两种方式拿到池中的预制 // 在Shapes池中，我们有一个Key(name)为Cube的预制 // 用名称 或者 Transform 获取都可以 // 值得注意的是 通过Key获取的 会作用于这个池中的所有预制 // 通过Transform获取的，只作用于唯一的一个预制
        Transform cubePrefab = PoolManager.Pools["test"].prefabs["Cube"]; Transform cubeinstance = PoolManager.Pools["Shapes"].Spawn(cubePrefab); cubeinstance.name = "Cube (Spawned By CreationExample.cs)"; } /// 

    /// 周期性生产实例 /// 
    private IEnumerator Spawner() { int count = this.spawnAmount; Transform inst; Transform test = PoolManager.Pools[poolName].prefabs["Sphere"];//在这个池中拿到需要生成的预制;

        while (count > 0) { inst = this.pool.Spawn(testPrefab, Vector3.zero, Quaternion.identity);//从池组中取得预制
 inst.localPosition = new Vector3(this.spawnAmount - count, 0, 0); if (count == 5) { inst.renderer.material.color = Color.red; t = inst; } count--; yield return new WaitForSeconds(this.spawnInterval); } this.StartCoroutine(Despawner());//生产速度
 } Transform t; /// 

    /// 周期性回收实例 /// 
    private IEnumerator Despawner() { while (this.pool.Count > 0) { Transform instance = this.pool[pool.Count - 1]; this.pool.Despawn(instance);  // PoolManager回收 但是没有彻底还原预制原始状态 需要自己控制详情看下面的文档说明
            yield return new WaitForSeconds(this.spawnInterval);//回收速度
 } } }

/// 
/// Online Docs: ///     http://docs.poolmanager2.path-o-logical.com/code-reference/spawnpool
///
/// A special List class that manages object pools and keeps the scene /// organized. ///
/// * Only active/spawned instances are iterable. Inactive/despawned /// instances in the pool are kept internally only. ///
/// * Instanciated objects can optionally be made a child of this GameObject /// (reffered to as a 'group') to keep the scene hierachy organized. ///
/// * Instances will get a number appended to the end of their name. E.g. /// an "Enemy" prefab will be called "Enemy(Clone)001", "Enemy(Clone)002", /// "Enemy(Clone)003", etc. Unity names all clones the same which can be /// confusing to work with. ///
/// * Objects aren't destroyed by the Despawn() method. Instead, they are /// deactivated and stored to an internal queue to be used again. This /// avoids the time it takes unity to destroy gameobjects and helps /// performance by reusing GameObjects. ///
/// * Two events are implimented to enable objects to handle their own reset needs. /// Both are optional. /// 1) When objects are Despawned BroadcastMessage("OnDespawned()") is sent. /// 2) When reactivated, a BroadcastMessage("OnRespawned()") is sent. /// This /// 

 /// 
    /// Spawns an instance or creates a new instance if none are available. /// Either way, an instance will be set to the passed position and /// rotation. ///
    /// Detailed Information: /// Checks the Data structure for an instance that was already created /// using the prefab. If the prefab has been used before, such as by /// setting it in the Unity Editor to preload instances, or just used /// before via this function, one of its instances will be used if one /// is available, or a new one will be created. ///
    /// If the prefab has never been used a new PrefabPool will be started /// with default options. ///
    /// To alter the options on a prefab pool, use the Unity Editor or see /// the documentation for the PrefabPool class and /// SpawnPool.SpawnPrefabPool() ///
    /// Broadcasts "OnSpawned" to the instance. Use this instead of Awake() ///
    /// This function has the same initial signature as Unity's Instantiate() /// that takes position and rotation. The return Type is different though. /// 
    /// 
    /// The prefab used to spawn an instance. Only used for reference if an /// instance is already in the pool and available for respawn. /// NOTE: Type = Transform /// 
    /// The position to set the instance to
    /// The rotation to set the instance to
    /// 
    /// The instance's Transform. ///
    /// If the Limit option was used for the PrefabPool associated with the /// passed prefab, then this method will return null if the limit is /// reached. You DO NOT need to test for null return values unless you /// used the limit option. /// 

/// 

/// This class is used to display a more complex user entry interface in the /// Unity Editor so we can collect more options related to each Prefab. ///
/// See this class documentation for Editor Options. ///
/// This class is also the primary pool functionality for SpawnPool. SpawnPool /// manages the Pool using these settings and methods. See the SpawnPool /// documentation for user documentation and usage. /// 

//PoolManager创建一个预制池，这个池不需要你预先装载，如果没有特殊需求跳过下面步骤，不必要填写下面的参数，预制池自动采取默认参数。
 PrefabPool prefabPool = new PrefabPool(testPrefab); prefabPool.preloadAmount = 5;//PoolManager默认初始化就是自动生成五个实例
         prefabPool.cullDespawned = true; prefabPool.cullAbove = 10; prefabPool.cullDelay = 1; prefabPool.limitInstances = true; prefabPool.limitAmount = 5; prefabPool.limitFIFO = true; this.pool.CreatePrefabPool(prefabPool);//PoolManager在池组中创建一个预制池

/// 

    /// The number of instances to preload /// 
    public int preloadAmount = 1; /// 

    /// Displays the 'preload over time' options /// 
    public bool preloadTime = false; /// 

    /// The number of frames it will take to preload all requested instances /// 
    public int preloadFrames = 2; /// 

    /// The number of seconds to wait before preloading any instances /// 
    public float preloadDelay = 0; /// 

    /// Limits the number of instances allowed in the game. Turning this ON /// means when 'Limit Amount' is hit, no more instances will be created. /// CALLS TO SpawnPool.Spawn() WILL BE IGNORED, and return null! ///
    /// This can be good for non-critical objects like bullets or explosion /// Flares. You would never want to use this for enemies unless it makes /// sense to begin ignoring enemy spawns in the context of your game. /// 
    public bool limitInstances = false; /// 

    /// This is the max number of instances allowed if 'limitInstances' is ON. /// 
    public int limitAmount = 100; /// 

    /// FIFO stands for "first-in-first-out". Normally, limiting instances will /// stop spawning and return null. If this is turned on (set to true) the /// first spawned instance will be despawned and reused instead, keeping the /// total spawned instances limited but still spawning new instances. /// 
    public bool limitFIFO = false;  // Keep after limitAmount for auto-inspector
    
    /// 

    /// Turn this ON to activate the culling feature for this Pool. /// Use this feature to remove despawned (inactive) instances from the pool /// if the size of the pool grows too large. ///
    /// DO NOT USE THIS UNLESS YOU NEED TO MANAGE MEMORY ISSUES! /// This should only be used in extreme cases for memory management. /// For most pools (or games for that matter), it is better to leave this /// off as memory is more plentiful than performance. If you do need this /// you can fine tune how often this is triggered to target extreme events. ///
    /// A good example of when to use this would be if you you are Pooling /// projectiles and usually never need more than 10 at a time, but then /// there is a big one-off fire-fight where 50 projectiles are needed. /// Rather than keep the extra 40 around in memory from then on, set the /// 'Cull Above' property to 15 (well above the expected max) and the Pool /// will Destroy() the extra instances from the game to free up the memory. ///
    /// This won't be done immediately, because you wouldn't want this culling /// feature to be fighting the Pool and causing extra Instantiate() and /// Destroy() calls while the fire-fight is still going on. See /// "Cull Delay" for more information about how to fine tune this. /// 
    public bool cullDespawned = false; /// 

    /// The number of TOTAL (spawned + despawned) instances to keep. /// 
    public int cullAbove = 50; /// 

    /// The amount of time, in seconds, to wait before culling. This is timed /// from the moment when the Queue's TOTAL count (spawned + despawned) /// becomes greater than 'Cull Above'. Once triggered, the timer is repeated /// until the count falls below 'Cull Above'. /// 
    public int cullDelay = 60; /// 

    /// The maximum number of instances to destroy per this.cullDelay /// 
    public int cullMaxPerPass = 5;

/// 

    /// Creates a new GameObject with a SpawnPool Component which registers itself /// with the PoolManager.Pools dictionary. The SpawnPool can then be accessed /// directly via the return value of this function or by via the PoolManager.Pools /// dictionary using a 'key' (string : the name of the pool, SpawnPool.poolName). /// 
    /// 
    /// The name for the new SpawnPool. The GameObject will have the word "Pool" /// Added at the end. /// 
    /// A reference to the new SpawnPool component
    public SpawnPool Create(string poolName) { // Add "Pool" to the end of the poolName to make a more user-friendly // GameObject name. This gets stripped back out in SpawnPool Awake()
        var owner = new GameObject(poolName + "Pool"); return owner.AddComponent(); } /// 

    ///Creates a SpawnPool Component on an 'owner' GameObject which registers /// itself with the PoolManager.Pools dictionary. The SpawnPool can then be /// accessed directly via the return value of this function or via the /// PoolManager.Pools dictionary. /// 
    /// 
    /// The name for the new SpawnPool. The GameObject will have the word "Pool" /// Added at the end. /// 
    /// A GameObject to add the SpawnPool Component
    /// A reference to the new SpawnPool component
    public SpawnPool Create(string poolName, GameObject owner) { if (!this.assertValidPoolName(poolName)) return null; // When the SpawnPool is created below, there is no way to set the poolName // before awake runs. The SpawnPool will use the gameObject name by default // so a try statement is used to temporarily change the parent's name in a // safe way. The finally block will always run, even if there is an error.
        string ownerName = owner.gameObject.name; try { owner.gameObject.name = poolName; // Note: This will use SpawnPool.Awake() to finish init and self-add the pool
            return owner.AddComponent(); } finally { // Runs no matter what
            owner.gameObject.name = ownerName; } }