Unity粒子系统

一、界面参数介绍

1.主模块

2.Emission 模块

3.Shape 模块

4.Velocity over Lifetime 模块

5.Noise 模块

6.Limit Velocity Over Lifetime 模块

7.Inherit Velocity 模块

8.Force Over Lifetime 模块

9.Color Over Lifetime 模块

10.Color By Speed 模块

11.Size over Lifetime 模块

12、Size by Speed 模块

13.Rotation Over Lifetime 模块

14.Rotation By Speed 模块

15.External Forces 模块

16.Collision 模块

16.1.Planes模式

16.2.World模式

17.Triggers 模块

18.Sub Emitters 模块

要触发子发射器，可使用以下条件：

Birth：粒子的创建时间。
Collision：粒子与对象发生碰撞的时间。
Death：粒子的销毁时间。
Trigger：粒子与触发碰撞体相互作用的时间。
Manual：仅在通过脚本进行请求时触发。请参阅 ParticleSystem.TriggerSubEmitter。

19.Texture Sheet Animation 模块

19.1.Grid 模式属性

19.2.Sprite 模式属性

20.Lights 模块

21.Trails 模块

22.Renderer 模块

二、常用参数和方法解析（待更新）

1. 获取组件与模块：通过 GetComponent<ParticleSystem>() 获取粒子系统组件，再通过 main、emission 等属性获取粒子系统的各个模块。
2. 常用参数设置：
   • mainModule.startSpeed：设置粒子的起始速度。
   • mainModule.startSize：设置粒子的起始大小。
   • mainModule.startColor：设置粒子的起始颜色。
   • mainModule.loop：设置粒子系统是否循环播放。
   • emissionModule.rateOverTime：设置每秒发射的粒子数量。
   • sizeOverLifetimeModule.size：通过 AnimationCurve 控制粒子大小随时间的变化。
3. 常用方法调用：
   • particleSys.Play()：播放粒子系统。
   • particleSys.Stop()：停止粒子系统。
   • particleSys.Clear()：清除所有粒子。

示例代码

using System;
using System.Collections;
using System.Collections.Generic;
using Unity.VisualScripting;
using UnityEngine;
using UnityEngine.Events;

namespace LumberDemo
{
    public class PatticleTool : MonoBehaviour
    {
        [Header("开启粒子触发进入事件")]
        public bool IsOpenEnter = false;
        [Header("开启粒子触发退出事件")]
        public bool IsOpenExit = false;
        [Header("开启粒子位于碰撞体内时触发事件")]
        public bool IsOpenInside = false;
        [Header("开启粒子位于碰撞体外时触发事件")]
        public bool IsOpenOutside = false;
        protected ParticleSystem particle;
        List<ParticleSystem.Particle> inside;
        List<ParticleSystem.Particle> enter;
        List<ParticleSystem.Particle> outside;
        List<ParticleSystem.Particle> exit;


        private UnityEvent<List<ParticleSystem.Particle>> _triggerInsideEvent;
        private UnityEvent<List<ParticleSystem.Particle>> _triggerEnterEvent;
        private UnityEvent<List<ParticleSystem.Particle>> _triggerOutsideEvent;
        private UnityEvent<List<ParticleSystem.Particle>> _triggerExitEvent;
        private UnityEvent<GameObject> _onCollisionEvent;
        private void Awake()
        {
            Init();
        }
        public UnityEvent<List<ParticleSystem.Particle>> OnTriggerInsideEvent
        {
            get
            {
                if (_triggerInsideEvent == null)
                {
                    _triggerInsideEvent = new UnityEvent<List<ParticleSystem.Particle>>();
                }
                return _triggerInsideEvent;
            }
        }
        public UnityEvent<List<ParticleSystem.Particle>> OnTriggerOutsideEvent
        {
            get
            {
                if (_triggerOutsideEvent == null)
                {
                    _triggerOutsideEvent = new UnityEvent<List<ParticleSystem.Particle>>();
                }
                return _triggerOutsideEvent;
            }
        }
        public UnityEvent<List<ParticleSystem.Particle>> OnTriggerEnterEvent
        {
            get
            {
                if (_triggerEnterEvent == null)
                {
                    _triggerEnterEvent = new UnityEvent<List<ParticleSystem.Particle>>();
                }
                return _triggerEnterEvent;
            }

        }
        public UnityEvent<List<ParticleSystem.Particle>> OnTriggerExitEvent
        {
            get
            {
                if (_triggerExitEvent == null)
                {
                    _triggerExitEvent = new UnityEvent<List<ParticleSystem.Particle>>();
                }
                return _triggerExitEvent;
            }
        }
        public UnityEvent<GameObject> OnCollisionEvent
        {
            get
            {
                if (_onCollisionEvent == null)
                {
                    _onCollisionEvent = new UnityEvent<GameObject>();
                }
                return _onCollisionEvent;
            }
        }
        /// <summary>
        /// 初始化
        /// </summary>
        private void Init()
        {
            particle = GetComponent<ParticleSystem>();
            if (!(IsOpenEnter || IsOpenExit || IsOpenInside || IsOpenOutside))
            {
                return;
            }
            if (IsOpenInside)
                inside = new List<ParticleSystem.Particle>();
            if (IsOpenEnter)
                enter = new List<ParticleSystem.Particle>();
            if (IsOpenExit)
                exit = new List<ParticleSystem.Particle>();
            if (IsOpenOutside)
                outside = new List<ParticleSystem.Particle>();
        }


        /// <summary>
        /// 添加粒子触发体
        /// </summary>
        /// <param name="colliderTrs"></param>
        public void AddPatticleCollider(Transform colliderTrs)
        {
            particle.trigger.AddCollider(colliderTrs);
        }
        int insideNum;
        int enterNum;
        int exitNum;
        int outsideNum;
        /// <summary>
        /// 设置粒子触发
        /// </summary>
        protected virtual void OnParticleTrigger()
        {
            if (IsOpenInside)
            {
                insideNum = particle.GetTriggerParticles(ParticleSystemTriggerEventType.Inside, inside);
                if (insideNum > 0)
                    OnInSideTrigger(inside);
                //将修改后的粒子重新分配回粒子系统
                particle.SetTriggerParticles(ParticleSystemTriggerEventType.Inside, inside);
            }

            if (IsOpenEnter)
            {
                enterNum = particle.GetTriggerParticles(ParticleSystemTriggerEventType.Enter, enter);
                if (enterNum > 0)
                    OnEnterTrigger(inside);
                // 将修改后的粒子重新分配回粒子系统
                particle.SetTriggerParticles(ParticleSystemTriggerEventType.Enter, enter);
            }

            if (IsOpenExit)
            {
                exitNum = particle.GetTriggerParticles(ParticleSystemTriggerEventType.Exit, exit);
                if (exitNum > 0)
                    OnExitTrigger(inside);
                // 将修改后的粒子重新分配回粒子系统
                particle.SetTriggerParticles(ParticleSystemTriggerEventType.Exit, exit);
            }

            if (IsOpenOutside)
            {
                outsideNum = particle.GetTriggerParticles(ParticleSystemTriggerEventType.Outside, outside);
                if (outsideNum > 0)
                    OnOutsideTrigger(inside);
                // 将修改后的粒子重新分配回粒子系统
                particle.SetTriggerParticles(ParticleSystemTriggerEventType.Outside, outside);
            }
        }

        private void OnInSideTrigger(List<ParticleSystem.Particle> inside)
        {
            if (IsOpenInside)
                OnTriggerInsideEvent?.Invoke(inside);
        }

        private void OnEnterTrigger(List<ParticleSystem.Particle> inside)
        {
            if (IsOpenEnter)
                OnTriggerEnterEvent?.Invoke(inside);
        }

        private void OnExitTrigger(List<ParticleSystem.Particle> inside)
        {
            if (IsOpenExit)
                OnTriggerExitEvent?.Invoke(inside);
        }

        private void OnOutsideTrigger(List<ParticleSystem.Particle> inside)
        {
            if (IsOpenOutside)
                OnTriggerOutsideEvent?.Invoke(inside);
        }

        private void OnParticleCollision(GameObject other)
        {
            OnCollisionEvent?.Invoke(other);
        }
    }
}