using System.Collections;
|
using System.Collections.Generic;
|
using UnityEngine;
|
|
namespace GAP_ParticleSystemController{
|
|
[System.Serializable]
|
public class ParticleSystemOriginalSettings
|
{
|
public SerializableMinMaxGradient _startColor;
|
public SerializableMinMaxGradient _colorOverLifetimeC;
|
public SerializableMinMaxCurve _startSize;
|
public SerializableMinMaxCurve _startSizeX;
|
public SerializableMinMaxCurve _startSizeY;
|
public SerializableMinMaxCurve _startSizeZ;
|
public SerializableMinMaxCurve _startSpeed;
|
public SerializableMinMaxCurve _startDelay;
|
public SerializableMinMaxCurve _startLifetime;
|
public SerializableMinMaxCurve _velocityOverLifetimeX;
|
public SerializableMinMaxCurve _velocityOverLifetimeY;
|
public SerializableMinMaxCurve _velocityOverLifetimeZ;
|
public SerializableVector3 _localPosition;
|
public SerializableGradient _trailGradient;
|
public float _duration;
|
public float _shapeRadius;
|
public float _trailWidthMultiplier;
|
public float _trailTime;
|
public bool _active;
|
public bool _loop;
|
public bool _prewarm;
|
}
|
|
[ExecuteInEditMode]
|
public class ParticleSystemController : MonoBehaviour {
|
|
public float size = 1;
|
public float speed = 1;
|
public float duration = 1;
|
public bool loop;
|
public bool prewarm;
|
public bool lights;
|
public bool trails;
|
public bool changeColor;
|
public Color newMaxColor = new Color (0,0,0,1);
|
public Color newMinColor = new Color (0,0,0,1);
|
public List<GameObject> ParticleSystems = new List<GameObject>();
|
public List<bool> ActiveParticleSystems = new List<bool>();
|
|
private List<ParticleSystemOriginalSettings> psOriginalSettingsList = new List<ParticleSystemOriginalSettings> ();
|
|
public void UpdateParticleSystem(){
|
//Enables or Disbales Particle Systems you choose in inspector
|
for(int i = 0; i< ParticleSystems.Count; i++){
|
if (ActiveParticleSystems.Count == ParticleSystems.Count) {
|
if (ActiveParticleSystems [i] == true)
|
ParticleSystems [i].SetActive (true);
|
else
|
ParticleSystems [i].SetActive (false);
|
} else {
|
Debug.Log ("Make sure the ActiveParticleSystems list has the same amount as the ParticleSystems list.");
|
return;
|
}
|
}
|
|
if (ParticleSystems.Count > 0) {
|
for (int i = 0; i < ParticleSystems.Count; i ++) {
|
var ps = ParticleSystems [i].GetComponent<ParticleSystem> ();
|
if (ps != null) {
|
var main = ps.main;
|
var shape = ps.shape;
|
var psLights = ps.lights;
|
var psTrails = ps.trails;
|
var colorOverLifetime = ps.colorOverLifetime;
|
var colorOverLifetimeC = colorOverLifetime.color;
|
var startColor = main.startColor;
|
var startSize = main.startSize;
|
var startSizeX = main.startSizeX;
|
var startSizeY = main.startSizeY;
|
var startSizeZ = main.startSizeZ;
|
var startSpeed = main.startSpeed;
|
var startDelay = main.startDelay;
|
var startLifetime = main.startLifetime;
|
var velocityOverLifetime = ps.velocityOverLifetime;
|
var velocityOverLifetimeX = velocityOverLifetime.x;
|
var velocityOverLifetimeY = velocityOverLifetime.y;
|
var velocityOverLifetimeZ = velocityOverLifetime.z;
|
var localPos = ParticleSystems [i].transform.localPosition;
|
|
//KEEP ORIGINAL VALUES
|
if (!SaveParticleSystemScript.CheckExistingFile (gameObject)) {
|
ParticleSystemOriginalSettings psOriginalSettings = new ParticleSystemOriginalSettings () {
|
_startColor = new SerializableMinMaxGradient (startColor),
|
_colorOverLifetimeC = new SerializableMinMaxGradient (colorOverLifetimeC),
|
_startSize = new SerializableMinMaxCurve (startSize),
|
_startSizeX = new SerializableMinMaxCurve (startSizeX),
|
_startSizeY = new SerializableMinMaxCurve (startSizeY),
|
_startSizeZ = new SerializableMinMaxCurve (startSizeZ),
|
_startSpeed = new SerializableMinMaxCurve (startSpeed),
|
_startDelay = new SerializableMinMaxCurve (startDelay),
|
_startLifetime = new SerializableMinMaxCurve (startLifetime),
|
_velocityOverLifetimeX = new SerializableMinMaxCurve (velocityOverLifetimeX),
|
_velocityOverLifetimeY = new SerializableMinMaxCurve (velocityOverLifetimeY),
|
_velocityOverLifetimeZ = new SerializableMinMaxCurve (velocityOverLifetimeZ),
|
_localPosition = new SerializableVector3 (ParticleSystems [i].transform.localPosition),
|
_duration = main.duration,
|
_shapeRadius = shape.radius,
|
_active = ps.gameObject.activeSelf,
|
_loop = main.loop,
|
_prewarm = main.prewarm
|
};
|
psOriginalSettingsList.Add (psOriginalSettings);
|
} else {
|
List<ParticleSystemOriginalSettings> listOriginalSettings = new List<ParticleSystemOriginalSettings> ();
|
listOriginalSettings = SaveParticleSystemScript.LoadVFX (gameObject);
|
|
startColor = listOriginalSettings [i]._startColor.GetMinMaxGradient();
|
colorOverLifetimeC = listOriginalSettings [i]._colorOverLifetimeC.GetMinMaxGradient();
|
startSize = listOriginalSettings [i]._startSize.GetMinMaxCurve();
|
startSizeX = listOriginalSettings [i]._startSizeX.GetMinMaxCurve();
|
startSizeY = listOriginalSettings [i]._startSizeY.GetMinMaxCurve();
|
startSizeZ = listOriginalSettings [i]._startSizeZ.GetMinMaxCurve();
|
startSpeed = listOriginalSettings [i]._startSpeed.GetMinMaxCurve();
|
startDelay = listOriginalSettings [i]._startDelay.GetMinMaxCurve();
|
startLifetime = listOriginalSettings [i]._startLifetime.GetMinMaxCurve();
|
velocityOverLifetimeX = listOriginalSettings [i]._velocityOverLifetimeX.GetMinMaxCurve ();
|
velocityOverLifetimeY = listOriginalSettings [i]._velocityOverLifetimeY.GetMinMaxCurve ();
|
velocityOverLifetimeZ = listOriginalSettings [i]._velocityOverLifetimeZ.GetMinMaxCurve ();
|
localPos = listOriginalSettings [i]._localPosition.GetVector3();
|
main.duration = listOriginalSettings [i]._duration;
|
shape.radius = listOriginalSettings [i]._shapeRadius;
|
ps.gameObject.SetActive (listOriginalSettings [i]._active);
|
loop = listOriginalSettings [i]._loop;
|
prewarm = listOriginalSettings [i]._prewarm;
|
}
|
|
//LOOP
|
main.loop = loop;
|
|
//PREWARM
|
main.prewarm = prewarm;
|
|
//LIGHTS
|
if (!lights && psLights.enabled)
|
psLights.enabled = false;
|
|
//TRAILS
|
if (!trails && psTrails.enabled)
|
psTrails.enabled = false;
|
|
//POSITION
|
if (i > 0) {
|
if (localPos.x != 0 || localPos.y != 0 || localPos.z != 0) {
|
localPos.x *= size;
|
localPos.y *= size;
|
localPos.z *= size;
|
ParticleSystems [i].transform.localPosition = localPos;
|
}
|
}
|
|
//DURATION
|
if(duration != 1){
|
main.duration *= duration;
|
}
|
|
//SIZE
|
if (main.startSize3D) {
|
if (startSize.mode == ParticleSystemCurveMode.TwoConstants) {
|
startSizeX.constantMax *= size;
|
startSizeX.constantMin *= size;
|
|
startSizeY.constantMax *= size;
|
startSizeY.constantMin *= size;
|
|
startSizeZ.constantMax *= size;
|
startSizeZ.constantMin *= size;
|
} else {
|
startSizeX.constant *= size;
|
startSizeY.constant *= size;
|
startSizeZ.constant *= size;
|
}
|
main.startSizeX = startSizeX;
|
main.startSizeY = startSizeY;
|
main.startSizeZ = startSizeZ;
|
} else {
|
if (startSize.mode == ParticleSystemCurveMode.TwoConstants) {
|
startSize.constantMax *= size;
|
startSize.constantMin *= size;
|
} else {
|
startSize.constant *= size;
|
}
|
main.startSize = startSize;
|
}
|
|
//START_SPEED (affected by size)
|
if (startSpeed.mode == ParticleSystemCurveMode.TwoConstants) {
|
startSpeed.constantMax *= size;
|
startSpeed.constantMin *= size;
|
main.startSpeed = startSpeed;
|
} else {
|
startSpeed.constant *= size;
|
main.startSpeed = startSpeed;
|
}
|
|
//START_SPEED (affected by speed)
|
if (startSpeed.mode == ParticleSystemCurveMode.TwoConstants) {
|
startSpeed.constantMax *= speed;
|
startSpeed.constantMin *= speed;
|
main.startSpeed = startSpeed;
|
} else {
|
startSpeed.constant *= speed;
|
main.startSpeed = startSpeed;
|
}
|
|
//LIFETIME
|
if (main.startLifetime.mode == ParticleSystemCurveMode.TwoConstants) {
|
startLifetime.constantMax *= 1 / speed;
|
startLifetime.constantMin *= 1 / speed;
|
main.startLifetime = startLifetime;
|
} else {
|
startLifetime.constant *= 1 / speed;
|
main.startLifetime = startLifetime;
|
}
|
|
//START_DELAY
|
if (startDelay.mode == ParticleSystemCurveMode.TwoConstants) {
|
startDelay.constantMax *= 1 / speed;
|
startDelay.constantMin *= 1 / speed;
|
main.startDelay = startDelay;
|
} else {
|
startDelay.constant *= 1 / speed;
|
main.startDelay = startDelay;
|
}
|
|
//VELOCITY OVERLIFETIME
|
if(velocityOverLifetime.enabled){
|
float amount = 1;
|
if(size != 1)
|
amount = size;
|
if(speed != 1)
|
amount = speed;
|
if(size != 1 && speed != 1)
|
amount = (size + speed)/2;
|
|
if (velocityOverLifetime.x.mode == ParticleSystemCurveMode.TwoConstants) {
|
velocityOverLifetimeX.constantMax *= amount;
|
velocityOverLifetimeX.constantMin *= amount;
|
|
velocityOverLifetimeY.constantMax *= amount;
|
velocityOverLifetimeY.constantMin *= amount;
|
|
velocityOverLifetimeZ.constantMax *= amount;
|
velocityOverLifetimeZ.constantMin *= amount;
|
} else {
|
velocityOverLifetimeX.constant *= amount;
|
velocityOverLifetimeY.constant *= amount;
|
velocityOverLifetimeZ.constant *= amount;
|
}
|
velocityOverLifetime.x = velocityOverLifetimeX;
|
velocityOverLifetime.y = velocityOverLifetimeY;
|
velocityOverLifetime.z = velocityOverLifetimeZ;
|
}
|
|
//RADIUS
|
if (shape.enabled) {
|
shape.radius *= size;
|
}
|
|
//COLOR
|
if (changeColor) {
|
if (main.startColor.mode == ParticleSystemGradientMode.Color) {
|
startColor.color = ChangeHUE (startColor.color, newMaxColor);
|
main.startColor = startColor;
|
}
|
if (main.startColor.mode == ParticleSystemGradientMode.TwoColors) {
|
startColor.colorMax = ChangeHUE (startColor.colorMax, newMaxColor);
|
startColor.colorMin = ChangeHUE (startColor.colorMin, newMinColor);
|
main.startColor = startColor;
|
}
|
if (main.startColor.mode == ParticleSystemGradientMode.Gradient) {
|
startColor.gradient = ChangeGradientColor (startColor.gradient, newMaxColor);
|
main.startColor = startColor;
|
}
|
if (main.startColor.mode == ParticleSystemGradientMode.TwoGradients) {
|
startColor.gradientMax = ChangeGradientColor (startColor.gradientMax, newMaxColor);
|
startColor.gradientMin = ChangeGradientColor (startColor.gradientMin, newMinColor);
|
main.startColor = startColor;
|
}
|
|
//COLOR OVERLIFETIME
|
if (colorOverLifetime.enabled) {
|
if (colorOverLifetime.color.mode == ParticleSystemGradientMode.Gradient) {
|
colorOverLifetimeC.gradient = ChangeGradientColor (colorOverLifetimeC.gradient, newMaxColor);
|
}
|
if (colorOverLifetime.color.mode == ParticleSystemGradientMode.TwoGradients) {
|
colorOverLifetimeC.gradientMax = ChangeGradientColor (colorOverLifetimeC.gradientMax, newMaxColor);
|
colorOverLifetimeC.gradientMin = ChangeGradientColor (colorOverLifetimeC.gradientMin, newMinColor);
|
}
|
colorOverLifetime.color = colorOverLifetimeC;
|
}
|
}
|
} else {
|
//TRAIL RENDERER
|
var trail = ParticleSystems [i].GetComponent<TrailRenderer> ();
|
if (trail != null) {
|
if (!SaveParticleSystemScript.CheckExistingFile (gameObject)) {
|
ParticleSystemOriginalSettings psOriginalSettings = new ParticleSystemOriginalSettings {
|
_trailGradient = new SerializableGradient (trail.colorGradient),
|
_localPosition = new SerializableVector3 (trail.transform.localPosition),
|
_trailWidthMultiplier = trail.widthMultiplier,
|
_trailTime = trail.time
|
};
|
psOriginalSettingsList.Add (psOriginalSettings);
|
} else {
|
List<ParticleSystemOriginalSettings> listOriginalSettings = new List<ParticleSystemOriginalSettings> ();
|
listOriginalSettings = SaveParticleSystemScript.LoadVFX (gameObject);
|
|
trail.colorGradient = listOriginalSettings [i]._trailGradient.GetGradient();
|
trail.transform.localPosition = listOriginalSettings [i]._localPosition.GetVector3 ();
|
trail.widthMultiplier = listOriginalSettings [i]._trailWidthMultiplier;
|
trail.time = listOriginalSettings [i]._trailTime;
|
}
|
trail.colorGradient = ChangeGradientColor (trail.colorGradient, newMaxColor);
|
trail.widthMultiplier *= size;
|
|
float amount = 1;
|
if(size != 1)
|
amount = size;
|
if(speed != 1)
|
amount = speed;
|
if(size != 1 && speed != 1)
|
amount = (size + speed)/2;
|
if(amount > 1)
|
trail.time *= 1 / amount;
|
else
|
trail.time *= amount;
|
}
|
}
|
}
|
if (!SaveParticleSystemScript.CheckExistingFile (gameObject)) {
|
SaveParticleSystemScript.SaveVFX (gameObject, psOriginalSettingsList);
|
}
|
}
|
else
|
Debug.Log("No Particle Systems added to the Particle Systems list");
|
}
|
|
public void ResetParticleSystem (){
|
|
List<ParticleSystemOriginalSettings> listOriginalSettings = new List<ParticleSystemOriginalSettings> ();
|
listOriginalSettings = SaveParticleSystemScript.LoadVFX (gameObject);
|
|
if (listOriginalSettings != null) {
|
for (int i = 0; i < ParticleSystems.Count; i++) {
|
var ps = ParticleSystems [i].GetComponent<ParticleSystem> ();
|
if (ps != null) {
|
var main = ps.main;
|
var shape = ps.shape;
|
var colorOverLifetime = ps.colorOverLifetime;
|
var velocityOverLifetime = ps.velocityOverLifetime;
|
main.startColor = listOriginalSettings [i]._startColor.GetMinMaxGradient ();
|
colorOverLifetime.color = listOriginalSettings [i]._colorOverLifetimeC.GetMinMaxGradient ();
|
main.startSize = listOriginalSettings [i]._startSize.GetMinMaxCurve ();
|
main.startSizeX = listOriginalSettings [i]._startSizeX.GetMinMaxCurve ();
|
main.startSizeY = listOriginalSettings [i]._startSizeY.GetMinMaxCurve ();
|
main.startSizeZ = listOriginalSettings [i]._startSizeZ.GetMinMaxCurve ();
|
main.startSpeed = listOriginalSettings [i]._startSpeed.GetMinMaxCurve ();
|
main.startDelay = listOriginalSettings [i]._startDelay.GetMinMaxCurve ();
|
main.startLifetime = listOriginalSettings [i]._startLifetime.GetMinMaxCurve ();
|
velocityOverLifetime.x = listOriginalSettings [i]._velocityOverLifetimeX.GetMinMaxCurve ();
|
velocityOverLifetime.y = listOriginalSettings [i]._velocityOverLifetimeY.GetMinMaxCurve ();
|
velocityOverLifetime.z = listOriginalSettings [i]._velocityOverLifetimeZ.GetMinMaxCurve ();
|
ParticleSystems [i].transform.localPosition = listOriginalSettings [i]._localPosition.GetVector3 ();
|
main.duration = listOriginalSettings [i]._duration;
|
shape.radius = listOriginalSettings [i]._shapeRadius;
|
ps.gameObject.SetActive (listOriginalSettings [i]._active);
|
main.loop = listOriginalSettings [i]._loop;
|
main.prewarm = listOriginalSettings [i]._prewarm;
|
} else {
|
var trail = ParticleSystems [i].GetComponent<TrailRenderer> ();
|
if (trail != null) {
|
trail.colorGradient = listOriginalSettings [i]._trailGradient.GetGradient ();
|
trail.widthMultiplier = listOriginalSettings [i]._trailWidthMultiplier;
|
trail.time = listOriginalSettings [i]._trailTime;
|
ParticleSystems [i].transform.localPosition = listOriginalSettings [i]._localPosition.GetVector3 ();
|
}
|
}
|
}
|
Debug.Log ( gameObject.name + " reseted to default.");
|
}
|
}
|
|
public Color ChangeHUE (Color oldColor, Color newColor){
|
float newHue;
|
float newSaturation;
|
float newValue;
|
float oldHue;
|
float oldSaturation;
|
float oldValue;
|
float originalAlpha = oldColor.a;
|
Color.RGBToHSV (newColor, out newHue, out newSaturation, out newValue);
|
Color.RGBToHSV (oldColor, out oldHue, out oldSaturation, out oldValue);
|
var updatedColor = Color.HSVToRGB (newHue, oldSaturation, oldValue);
|
updatedColor.a = originalAlpha;
|
return updatedColor;
|
}
|
|
public Gradient ChangeGradientColor (Gradient oldGradient, Color newColor){
|
GradientColorKey[] colorKeys = new GradientColorKey[oldGradient.colorKeys.Length];
|
for(int j = 0; j < oldGradient.colorKeys.Length; j++){
|
colorKeys [j].time = oldGradient.colorKeys [j].time;
|
colorKeys [j].color = ChangeHUE (oldGradient.colorKeys[j].color, newColor);
|
}
|
oldGradient.SetKeys (colorKeys, oldGradient.alphaKeys);
|
return oldGradient;
|
}
|
|
public void FillLists (){
|
if (ParticleSystems.Count == 0) {
|
var ps = GetComponent<ParticleSystem> ();
|
var trail = GetComponent<TrailRenderer> ();
|
if (ps != null || trail != null)
|
ParticleSystems.Add (gameObject);
|
|
AddChildRecurvsively (transform);
|
|
for (int i = 0; i < ParticleSystems.Count; i++) {
|
ActiveParticleSystems.Add (true);
|
}
|
} else {
|
Debug.Log ("Lists already have GameObjects. For automatic filling consider emptying the lists and try again.");
|
}
|
}
|
|
public void EmptyLists (){
|
ParticleSystems.Clear();
|
ActiveParticleSystems.Clear();
|
}
|
|
void AddChildRecurvsively (Transform transf){
|
foreach (Transform t in transf) {
|
var child = t.gameObject;
|
var psChild = child.GetComponent<ParticleSystem> ();
|
var trailChild = child.GetComponent<TrailRenderer> ();
|
if (psChild != null || trailChild != null)
|
ParticleSystems.Add (child);
|
if (child.transform.childCount > 0)
|
AddChildRecurvsively (child.transform);
|
}
|
}
|
}
|
}
|
