Main:            Start Lifetime 1-2, Start Size 0.3-0.8, Start Color warm orange
Emission:        Rate 30-50
Shape:           Cone, Angle 15, Radius 0.1
Velocity:        Y = 1-3 (curves upward)
Color Lifetime:  Yellow → Orange → Red → Black (alpha 0 at end)
Size Lifetime:   Slight growth then shrink
Noise:           Strength 0.5, Frequency 2
Renderer:        Additive particle material
+ Sub Emitter → Ember sparks (small, fast, short lifetime, gravity 0.5)
+ Sub Emitter → Smoke (separate system: large, slow, grey, alpha fade)

Main:            Duration 0.5, Looping OFF, Start Lifetime 0.3-0.8
Emission:        Burst count 30-60 at time 0
Shape:           Sphere, Radius 0.1
Start Speed:     5-15 (random between two constants)
Color Lifetime:  White → Yellow → Orange → transparent
Size Lifetime:   Start large, shrink to 0
Gravity:         0.5 (debris falls)
+ Sub Emitter (Birth): Shockwave ring (mesh particle, torus, grows fast, fades)
+ Sub Emitter (Birth): Smoke cloud (slow, large, long lifetime)

Trails:          Enabled, Ratio 1, Lifetime 0.5
                 Texture Mode: Stretch
                 Size affects Width: ON
                 Color affects Color: ON
Renderer:        Trail Material (Particles/Additive or custom)

using UnityEngine;

public class ParticleEffectPlayer : MonoBehaviour
{
    [SerializeField] private ParticleSystem _hitEffect;
    [SerializeField] private ParticleSystem _trailEffect;

    // --- One-shot effect at a position ---
    public void PlayHitEffect(Vector3 position, Vector3 normal)
    {
        // Option A: Move and play
        _hitEffect.transform.SetPositionAndRotation(position, Quaternion.LookRotation(normal));
        _hitEffect.Play();

        // Option B: Instantiate a copy (auto-destroy)
        var instance = Instantiate(_hitEffect, position, Quaternion.LookRotation(normal));
        instance.Play();
        Destroy(instance.gameObject, instance.main.duration + instance.main.startLifetime.constantMax);
    }

    // --- Modify at runtime ---
    public void SetEmissionRate(float rate)
    {
        var emission = _trailEffect.emission;
        emission.rateOverTime = rate;
    }

    public void SetColor(Color color)
    {
        var main = _trailEffect.main;
        main.startColor = color;
    }

    // --- Emit particles manually ---
    public void EmitBurst(int count)
    {
        _hitEffect.Emit(count);
    }
}

using UnityEngine;
using UnityEngine.Pool;

public class ParticlePool : MonoBehaviour
{
    [SerializeField] private ParticleSystem _prefab;

    private ObjectPool<ParticleSystem> _pool;

    private void Awake()
    {
        _pool = new ObjectPool<ParticleSystem>(
            createFunc: () =>
            {
                var ps = Instantiate(_prefab, transform);
                var main = ps.main;
                main.stopAction = ParticleSystemStopAction.Callback;

                var callback = ps.gameObject.AddComponent<ParticleReturnToPool>();
                callback.Initialize(_pool, ps);

                return ps;
            },
            actionOnGet: ps =>
            {
                ps.gameObject.SetActive(true);
            },
            actionOnRelease: ps =>
            {
                ps.gameObject.SetActive(false);
            },
            defaultCapacity: 10,
            maxSize: 50
        );
    }

    public ParticleSystem Get(Vector3 position, Quaternion rotation)
    {
        var ps = _pool.Get();
        ps.transform.SetPositionAndRotation(position, rotation);
        ps.Play();
        return ps;
    }
}

public class ParticleReturnToPool : MonoBehaviour
{
    private ObjectPool<ParticleSystem> _pool;
    private ParticleSystem _ps;

    public void Initialize(ObjectPool<ParticleSystem> pool, ParticleSystem ps)
    {
        _pool = pool;
        _ps = ps;
    }

    // Called by Particle System when Stop Action = Callback
    private void OnParticleSystemStopped()
    {
        _pool.Release(_ps);
    }
}

┌─────────────┐
│   Spawn     │  How many particles to create (rate, burst)
├─────────────┤
│ Initialize  │  Set initial values (position, velocity, lifetime, colour, size)
├─────────────┤
│   Update    │  Per-frame logic (forces, noise, collisions, aging)
├─────────────┤
│   Output    │  Rendering (quad, mesh, line, lit/unlit, orientation)
└─────────────┘

using UnityEngine;
using UnityEngine.VFX;

public class VFXController : MonoBehaviour
{
    [SerializeField] private VisualEffect _vfx;

    private static readonly int SpawnRate  = Shader.PropertyToID("SpawnRate");
    private static readonly int HitPos    = Shader.PropertyToID("HitPosition");
    private static readonly int BaseColor = Shader.PropertyToID("BaseColor");

    public void SetSpawnRate(float rate)
    {
        _vfx.SetFloat(SpawnRate, rate);
    }

    public void TriggerHitEffect(Vector3 position)
    {
        _vfx.SetVector3(HitPos, position);
        _vfx.SendEvent("OnHit");  // Matches a GPU Event context in the graph
    }

    public void SetColor(Color color)
    {
        _vfx.SetVector4(BaseColor, color);
    }

    public void StopEffect()
    {
        _vfx.Stop();
    }
}

using UnityEngine;

[RequireComponent(typeof(TrailRenderer))]
public class ProjectileTrail : MonoBehaviour
{
    private TrailRenderer _trail;

    private void Awake()
    {
        _trail = GetComponent<TrailRenderer>();
    }

    // Clear trail when recycling from pool
    public void ResetTrail()
    {
        _trail.Clear();
    }

    // Fade trail over time
    public void FadeOut(float duration)
    {
        StartCoroutine(FadeRoutine(duration));
    }

    private System.Collections.IEnumerator FadeRoutine(float duration)
    {
        float start = _trail.startColor.a;
        float elapsed = 0f;

        while (elapsed < duration)
        {
            elapsed += Time.deltaTime;
            float alpha = Mathf.Lerp(start, 0f, elapsed / duration);

            var startColor = _trail.startColor;
            startColor.a = alpha;
            _trail.startColor = startColor;

            var endColor = _trail.endColor;
            endColor.a = alpha;
            _trail.endColor = endColor;

            yield return null;
        }
    }
}