using UnityEngine;
|
using System;
|
|
namespace GAP_ParticleSystemController{
|
|
[Serializable]
|
public class SerializableMinMaxGradient{
|
public SerializableColor color;
|
public SerializableColor colorMax;
|
public SerializableColor colorMin;
|
public SerializableAlphaKeys gradientAlphaKeys;
|
public SerializableColorKeys gradientColorKeys;
|
public SerializableAlphaKeys gradientMaxAlphaKeys;
|
public SerializableColorKeys gradientMaxColorKeys;
|
public SerializableAlphaKeys gradientMinAlphaKeys;
|
public SerializableColorKeys gradientMinColorKeys;
|
public SerializablePSGradientMode gradientMode;
|
|
public SerializableMinMaxGradient (ParticleSystem.MinMaxGradient minMaxGradient){
|
|
gradientMode = new SerializablePSGradientMode (minMaxGradient.mode);
|
|
if (minMaxGradient.mode == ParticleSystemGradientMode.Color)
|
color = new SerializableColor (minMaxGradient.color);
|
|
if (minMaxGradient.mode == ParticleSystemGradientMode.TwoColors) {
|
colorMax = new SerializableColor (minMaxGradient.colorMax);
|
colorMin = new SerializableColor (minMaxGradient.colorMin);
|
}
|
|
if (minMaxGradient.mode == ParticleSystemGradientMode.Gradient) {
|
gradientAlphaKeys = new SerializableAlphaKeys (minMaxGradient.gradient.alphaKeys);
|
gradientColorKeys = new SerializableColorKeys (minMaxGradient.gradient.colorKeys);
|
}
|
|
if (minMaxGradient.mode == ParticleSystemGradientMode.TwoGradients) {
|
gradientMaxAlphaKeys = new SerializableAlphaKeys (minMaxGradient.gradientMax.alphaKeys);
|
gradientMaxColorKeys = new SerializableColorKeys (minMaxGradient.gradientMax.colorKeys);
|
gradientMinAlphaKeys = new SerializableAlphaKeys (minMaxGradient.gradientMin.alphaKeys);
|
gradientMinColorKeys = new SerializableColorKeys (minMaxGradient.gradientMin.colorKeys);
|
}
|
}
|
|
public ParticleSystem.MinMaxGradient GetMinMaxGradient (){
|
ParticleSystem.MinMaxGradient minMaxGradient = new ParticleSystem.MinMaxGradient ();
|
if (gradientMode.GetGradientMode () == ParticleSystemGradientMode.Color) {
|
if (minMaxGradient.color == null)
|
minMaxGradient.color = new Color ();
|
minMaxGradient.color = color.GetColor ();
|
}
|
|
if (gradientMode.GetGradientMode() == ParticleSystemGradientMode.TwoColors) {
|
if (minMaxGradient.colorMax == null)
|
minMaxGradient.colorMax = new Color ();
|
minMaxGradient.colorMax = colorMax.GetColor ();
|
|
if (minMaxGradient.colorMin == null)
|
minMaxGradient.colorMin = new Color ();
|
minMaxGradient.colorMin = colorMin.GetColor ();
|
}
|
|
if (gradientMode.GetGradientMode() == ParticleSystemGradientMode.Gradient) {
|
if (minMaxGradient.gradient == null)
|
minMaxGradient.gradient = new Gradient ();
|
minMaxGradient.gradient.alphaKeys = gradientAlphaKeys.GetAlphaKeys ();
|
minMaxGradient.gradient.colorKeys = gradientColorKeys.GetColorKeys ();
|
}
|
|
if (gradientMode.GetGradientMode() == ParticleSystemGradientMode.TwoGradients) {
|
if (minMaxGradient.gradientMax == null)
|
minMaxGradient.gradientMax = new Gradient ();
|
minMaxGradient.gradientMax.alphaKeys = gradientMaxAlphaKeys.GetAlphaKeys ();
|
minMaxGradient.gradientMax.colorKeys = gradientMaxColorKeys.GetColorKeys ();
|
|
if (minMaxGradient.gradientMin == null)
|
minMaxGradient.gradientMin = new Gradient ();
|
minMaxGradient.gradientMin.alphaKeys = gradientMinAlphaKeys.GetAlphaKeys ();
|
minMaxGradient.gradientMin.colorKeys = gradientMinColorKeys.GetColorKeys ();
|
}
|
|
minMaxGradient.mode = gradientMode.GetGradientMode ();
|
|
return minMaxGradient;
|
}
|
}
|
|
[Serializable]
|
public class SerializableMinMaxCurve{
|
public float constant;
|
public float constantMax;
|
public float constantMin;
|
public SerializableAnimationCurve curve;
|
public SerializableAnimationCurve curveMax;
|
public SerializableAnimationCurve curveMin;
|
public float curveMultiplier;
|
public SerializablePSCurveMode curveMode;
|
|
public SerializableMinMaxCurve (ParticleSystem.MinMaxCurve minMaxCurve){
|
|
curveMode = new SerializablePSCurveMode (minMaxCurve.mode);
|
|
if (minMaxCurve.mode == ParticleSystemCurveMode.Constant)
|
constant = minMaxCurve.constant;
|
|
if (minMaxCurve.mode == ParticleSystemCurveMode.Curve)
|
curve = new SerializableAnimationCurve (minMaxCurve.curve);
|
|
if (minMaxCurve.mode == ParticleSystemCurveMode.TwoConstants) {
|
constantMax = minMaxCurve.constantMax;
|
constantMin = minMaxCurve.constantMin;
|
}
|
|
if (minMaxCurve.mode == ParticleSystemCurveMode.TwoCurves) {
|
curveMax = new SerializableAnimationCurve (minMaxCurve.curveMax);
|
curveMin = new SerializableAnimationCurve (minMaxCurve.curve);
|
}
|
|
curveMultiplier = minMaxCurve.curveMultiplier;
|
}
|
|
public ParticleSystem.MinMaxCurve GetMinMaxCurve (){
|
ParticleSystem.MinMaxCurve minMaxCurve = new ParticleSystem.MinMaxCurve ();
|
|
if (curveMode.GetCurveMode() == ParticleSystemCurveMode.Constant)
|
minMaxCurve.constant = constant;
|
|
if (curveMode.GetCurveMode() == ParticleSystemCurveMode.TwoConstants) {
|
minMaxCurve.constantMax = constantMax;
|
minMaxCurve.constantMin = constantMin;
|
}
|
|
if (curveMode.GetCurveMode () == ParticleSystemCurveMode.Curve) {
|
if (minMaxCurve.curve == null)
|
minMaxCurve.curve = new AnimationCurve ();
|
minMaxCurve.curve = curve.GetAnimationCurve ();
|
}
|
|
if (curveMode.GetCurveMode() == ParticleSystemCurveMode.TwoCurves) {
|
if (minMaxCurve.curveMax == null)
|
minMaxCurve.curveMax = new AnimationCurve ();
|
minMaxCurve.curveMax = curveMax.GetAnimationCurve();
|
|
if (minMaxCurve.curveMin == null)
|
minMaxCurve.curveMin = new AnimationCurve ();
|
minMaxCurve.curveMin = curveMin.GetAnimationCurve();
|
}
|
|
minMaxCurve.curveMultiplier = curveMultiplier;
|
minMaxCurve.mode = curveMode.GetCurveMode ();
|
|
return minMaxCurve;
|
}
|
}
|
|
[Serializable]
|
public class SerializableAnimationCurve {
|
public SerializableKeyFrames[] keys;
|
public SerializableWrapMode postWrapMode;
|
public SerializableWrapMode preWrapMode;
|
|
public SerializableAnimationCurve (AnimationCurve animCurve){
|
SerializableKeyFrames[] keys_ = new SerializableKeyFrames[animCurve.keys.Length];
|
for (int i = 0; i < animCurve.length; i++) {
|
keys_[i] = new SerializableKeyFrames (animCurve.keys[i]);
|
}
|
keys = keys_;
|
postWrapMode = new SerializableWrapMode(animCurve.postWrapMode);
|
preWrapMode = new SerializableWrapMode(animCurve.preWrapMode);
|
}
|
|
public AnimationCurve GetAnimationCurve (){
|
AnimationCurve animCurv = new AnimationCurve ();
|
animCurv.keys = new Keyframe[keys.Length];
|
for(int i = 0; i < keys.Length; i++){
|
animCurv.keys[i] = keys[i].GetKeyFrames();
|
}
|
animCurv.postWrapMode = postWrapMode.GetWrapMode();
|
animCurv.preWrapMode = preWrapMode.GetWrapMode();
|
|
return animCurv;
|
}
|
}
|
|
[Serializable]
|
public class SerializableKeyFrames{
|
public float inTangent;
|
public float outTangent;
|
public int tangentMode;
|
public float time;
|
public float value;
|
|
public SerializableKeyFrames (Keyframe keyFrame){
|
inTangent = keyFrame.inTangent;
|
outTangent = keyFrame.outTangent;
|
tangentMode = keyFrame.tangentMode;
|
time = keyFrame.time;
|
value = keyFrame.value;
|
}
|
|
public Keyframe GetKeyFrames (){
|
Keyframe kf = new Keyframe();
|
|
kf.inTangent = inTangent;
|
kf.outTangent = outTangent;
|
kf.tangentMode = tangentMode;
|
kf.time = time;
|
kf.value = value;
|
|
return kf;
|
}
|
}
|
|
[Serializable]
|
public class SerializableAlphaKeys{
|
public float[] alpha;
|
public float[] time;
|
|
public SerializableAlphaKeys (GradientAlphaKey[] gradAlphaKeys){
|
float[] alpha_ = new float[gradAlphaKeys.Length];
|
float[] time_ = new float[gradAlphaKeys.Length];
|
for (int i = 0; i < gradAlphaKeys.Length; i++) {
|
alpha_[i] = gradAlphaKeys[i].alpha;
|
time_[i] = gradAlphaKeys[i].time;
|
}
|
alpha = alpha_;
|
time = time_;
|
}
|
|
public GradientAlphaKey[] GetAlphaKeys (){
|
GradientAlphaKey[] gak = new GradientAlphaKey[alpha.Length];
|
for (int i = 0; i < alpha.Length; i++) {
|
gak [i].alpha = alpha [i];
|
gak [i].time = time [i];
|
}
|
return gak;
|
}
|
}
|
|
[Serializable]
|
public class SerializableColorKeys{
|
public SerializableColor[] color;
|
public float[] time;
|
|
public SerializableColorKeys (GradientColorKey[] gradColorKeys){
|
SerializableColor[] color_ = new SerializableColor[gradColorKeys.Length];
|
float[] time_ = new float[gradColorKeys.Length];
|
for (int i = 0; i < gradColorKeys.Length; i++) {
|
color_[i] = new SerializableColor (gradColorKeys[i].color);
|
time_[i] = gradColorKeys[i].time;
|
}
|
color = color_;
|
time = time_;
|
}
|
|
public GradientColorKey[] GetColorKeys (){
|
GradientColorKey[] gck = new GradientColorKey[color.Length];
|
for (int i = 0; i < color.Length; i++) {
|
gck [i].color = color [i].GetColor();
|
gck [i].time = time [i];
|
}
|
return gck;
|
}
|
}
|
|
[Serializable]
|
public class SerializableColor {
|
public float R;
|
public float G;
|
public float B;
|
public float A;
|
|
public SerializableColor (Color color){
|
R = color.r;
|
G = color.g;
|
B = color.b;
|
A = color.a;
|
}
|
|
public Color GetColor (){
|
return new Color (R,G,B,A);
|
}
|
}
|
|
[Serializable]
|
public class SerializableVector3 {
|
public float x;
|
public float y;
|
public float z;
|
|
public SerializableVector3 (Vector3 v3){
|
x = v3.x;
|
y = v3.y;
|
z = v3.z;
|
}
|
|
public Vector3 GetVector3 (){
|
return new Vector3 (x,y,z);
|
}
|
}
|
|
[Serializable]
|
public class SerializableGradient{
|
public SerializableAlphaKeys gradientAlphaKeys;
|
public SerializableColorKeys gradientColorKeys;
|
public SerializableGradientMode gradientMode;
|
|
public SerializableGradient (Gradient gradient){
|
gradientMode = new SerializableGradientMode (gradient.mode);
|
gradientAlphaKeys = new SerializableAlphaKeys (gradient.alphaKeys);
|
gradientColorKeys = new SerializableColorKeys (gradient.colorKeys);
|
}
|
|
public Gradient GetGradient (){
|
Gradient gradient = new Gradient ();
|
gradient.alphaKeys = gradientAlphaKeys.GetAlphaKeys ();
|
gradient.colorKeys = gradientColorKeys.GetColorKeys ();
|
gradient.mode = gradientMode.GetGradientMode ();
|
|
return gradient;
|
}
|
}
|
|
[Serializable]
|
public class SerializablePSGradientMode{
|
public string mode;
|
|
public SerializablePSGradientMode (ParticleSystemGradientMode psGradientMode){
|
mode = psGradientMode.ToString();
|
}
|
|
public ParticleSystemGradientMode GetGradientMode (){
|
ParticleSystemGradientMode psGradientMode = new ParticleSystemGradientMode ();
|
switch (mode) {
|
case "Color":
|
{
|
psGradientMode = ParticleSystemGradientMode.Color;
|
break;
|
}
|
case "Gradient":
|
{
|
psGradientMode = ParticleSystemGradientMode.Gradient;
|
break;
|
}
|
case "RandomColor":
|
{
|
psGradientMode = ParticleSystemGradientMode.RandomColor;
|
break;
|
}
|
case "TwoColors":
|
{
|
psGradientMode = ParticleSystemGradientMode.TwoColors;
|
break;
|
}
|
case "TwoGradients":
|
{
|
psGradientMode = ParticleSystemGradientMode.TwoGradients;
|
break;
|
}
|
}
|
return psGradientMode;
|
}
|
}
|
|
[Serializable]
|
public class SerializableGradientMode{
|
public string mode;
|
|
public SerializableGradientMode (GradientMode gradientMode){
|
mode = gradientMode.ToString();
|
}
|
|
public GradientMode GetGradientMode (){
|
GradientMode gradientMode = new GradientMode ();
|
switch (mode) {
|
case "Blend":
|
{
|
gradientMode = GradientMode.Blend;
|
break;
|
}
|
case "Fixed":
|
{
|
gradientMode = GradientMode.Fixed;
|
break;
|
}
|
}
|
return gradientMode;
|
}
|
}
|
|
[Serializable]
|
public class SerializablePSCurveMode{
|
public string mode;
|
|
public SerializablePSCurveMode (ParticleSystemCurveMode psCurveMode){
|
mode = psCurveMode.ToString();
|
}
|
|
public ParticleSystemCurveMode GetCurveMode (){
|
ParticleSystemCurveMode psCurveMode = new ParticleSystemCurveMode ();
|
switch (mode) {
|
case "Constant":
|
{
|
psCurveMode = ParticleSystemCurveMode.Constant;
|
break;
|
}
|
case "Curve":
|
{
|
psCurveMode = ParticleSystemCurveMode.Curve;
|
break;
|
}
|
case "TwoConstants":
|
{
|
psCurveMode = ParticleSystemCurveMode.TwoConstants;
|
break;
|
}
|
case "TwoCurves":
|
{
|
psCurveMode = ParticleSystemCurveMode.TwoCurves;
|
break;
|
}
|
}
|
|
return psCurveMode;
|
}
|
}
|
|
[Serializable]
|
public class SerializableWrapMode {
|
public string mode;
|
|
public SerializableWrapMode (WrapMode wrapMode){
|
mode = wrapMode.ToString();
|
}
|
|
public WrapMode GetWrapMode (){
|
WrapMode wrapMode = new WrapMode ();
|
switch (mode) {
|
case "Clamp":
|
{
|
wrapMode = WrapMode.Clamp;
|
break;
|
}
|
case "ClampForever":
|
{
|
wrapMode = WrapMode.ClampForever;
|
break;
|
}
|
case "Default":
|
{
|
wrapMode = WrapMode.Default;
|
break;
|
}
|
case "Loop":
|
{
|
wrapMode = WrapMode.Loop;
|
break;
|
}
|
case "Once":
|
{
|
wrapMode = WrapMode.Once;
|
break;
|
}
|
case "PingPong":
|
{
|
wrapMode = WrapMode.PingPong;
|
break;
|
}
|
}
|
|
return wrapMode;
|
}
|
}
|
}
|
