Object Pooling

using UnityEngine;

namespace Patterns.Optimization.ObjectPooling
{
    /// <summary>
    /// Fires bullets on a timer. It asks the pool for bullets instead of
    /// calling Instantiate, so firing allocates nothing after warm-up.
    /// </summary>
    public class Turret : MonoBehaviour
    {
        [SerializeField] private BulletPool pool;
        [SerializeField] private Transform muzzle;
        [SerializeField] private float fireRate = 8f;
        [SerializeField] private float bulletSpeed = 25f;

        private float cooldown;

        private void Update()
        {
            cooldown -= Time.deltaTime;
            if (cooldown > 0f || !Input.GetButton("Fire1"))
                return;

            cooldown = 1f / fireRate;
            Fire();
        }

        private void Fire()
        {
            Bullet bullet = pool.Get();
            bullet.transform.SetPositionAndRotation(muzzle.position, muzzle.rotation);
            bullet.Launch(muzzle.forward * bulletSpeed);
        }
    }
}

using UnityEngine;
using UnityEngine.Pool;

namespace Patterns.Optimization.ObjectPooling
{
    /// <summary>
    /// Wraps Unity's built-in ObjectPool&lt;T&gt; for bullets and pre-warms
    /// it so the first volley does not hitch.
    /// </summary>
    public class BulletPool : MonoBehaviour
    {
        [SerializeField] private Bullet prefab;
        [SerializeField] private int defaultCapacity = 20;
        [SerializeField] private int maxSize = 100;
        [SerializeField] private int prewarm = 20;

        private ObjectPool<Bullet> pool;

        private void Awake()
        {
            pool = new ObjectPool<Bullet>(
                createFunc: () =>
                {
                    Bullet b = Instantiate(prefab, transform);
                    b.SetPool(pool);
                    return b;
                },
                actionOnGet: b => b.gameObject.SetActive(true),
                actionOnRelease: b => b.gameObject.SetActive(false),
                actionOnDestroy: b => Destroy(b.gameObject),
                collectionCheck: Application.isEditor,
                defaultCapacity: defaultCapacity,
                maxSize: maxSize);

            // Create everything now, during loading, then shelve it.
            var warm = new Bullet[prewarm];
            for (int i = 0; i < prewarm; i++) warm[i] = pool.Get();
            for (int i = 0; i < prewarm; i++) pool.Release(warm[i]);
        }

        public Bullet Get() => pool.Get();

        public int CountActive => pool.CountActive;
        public int CountInactive => pool.CountInactive;
    }
}

using UnityEngine;
using UnityEngine.Pool;

namespace Patterns.Optimization.ObjectPooling
{
    /// <summary>
    /// A pooled projectile. Instead of destroying itself, it releases
    /// back to the pool on hit or when its lifetime runs out.
    /// </summary>
    [RequireComponent(typeof(Rigidbody))]
    public class Bullet : MonoBehaviour
    {
        [SerializeField] private float lifetime = 2f;

        private IObjectPool<Bullet> pool;
        private Rigidbody body;
        private float timer;
        private bool released;

        private void Awake() => body = GetComponent<Rigidbody>();

        public void SetPool(IObjectPool<Bullet> owner) => pool = owner;

        public void Launch(Vector3 velocity)
        {
            // Reset ALL state: this object has been used before.
            released = false;
            timer = lifetime;
            body.linearVelocity = velocity;
            body.angularVelocity = Vector3.zero;
        }

        private void Update()
        {
            timer -= Time.deltaTime;
            if (timer <= 0f) Release();
        }

        private void OnCollisionEnter(Collision collision) => Release();

        private void Release()
        {
            if (released) return; // guard against double release
            released = true;
            pool.Release(this);
        }
    }
}