public MinMaxGradientData(Gradient gradient, ParticleSystemGradientMode mode)
{
_mode = mode; // ParticleSystemGradientMode.RandomColor or Gradient
_color1 = _color2 = Color.clear;
_gradient1 = gradient;
_gradient2 = null;
_startColor = MakeMinMaxGradient(_mode, _color1, _color2, _gradient1, _gradient2);
}
} // 0x000000018004E7D0-0x000000018004E7E0
// Constructors
public MinMaxGradient(Color color) : this()
{
m_Mode = default;
m_GradientMin = default;
m_GradientMax = default;
m_ColorMin = default;
m_ColorMax = default;
} // 0x000000018004E770-0x000000018004E7D0
public MinMaxGradientData(Gradient gradient1, Gradient gradient2)
{
_mode = ParticleSystemGradientMode.TwoGradients;
_color1 = _color2 = Color.clear;
_gradient1 = gradient1;
_gradient2 = gradient2;
_startColor = MakeMinMaxGradient(_mode, _color1, _color2, _gradient1, _gradient2);
}
public MinMaxGradientData(Color c1)
{
_mode = ParticleSystemGradientMode.Color;
_color1 = c1;
_color2 = Color.clear;
_gradient1 = _gradient2 = null;
_startColor = MakeMinMaxGradient(_mode, _color1, _color2, _gradient1, _gradient2);
}
public MinMaxGradientData(Color c1, Color c2)
{
_mode = ParticleSystemGradientMode.TwoColors;
_color1 = c1;
_color2 = c2;
_gradient1 = _gradient2 = null;
_startColor = MakeMinMaxGradient(_mode, _color1, _color2, _gradient1, _gradient2);
}
public YoooMinMaxGradient(ParticleSystem.MinMaxGradient gradient)
{
Data = gradient;
colorMax = Data.colorMax;
colorMin = Data.colorMin;
gradientMax = Data.gradientMax;
gradientMin = Data.gradientMin;
mode = Data.mode;
}
protected override void ReadFromImpl(object obj)
{
base.ReadFromImpl(obj);
ParticleSystem.MinMaxGradient uo = (ParticleSystem.MinMaxGradient)obj;
mode = uo.mode;
gradientMax = uo.gradientMax;
gradientMin = uo.gradientMin;
colorMax = uo.colorMax;
colorMin = uo.colorMin;
color = uo.color;
gradient = uo.gradient;
}
private void Awake()
{
var main = particleSystem.main;
if (main.startSize3D)
{
ssX = main.startSizeX;
ssX2 = main.startSizeX;
ssY = main.startSizeY;
ssY2 = main.startSizeY;
ssZ = main.startSizeZ;
ssZ2 = main.startSizeZ;
}
else
{
ss = main.startSize;
ss2 = main.startSize;
}
startSpeedMultiplier = main.startSpeedMultiplier;
transform.SetParent(null);
transform.position = Vector3.zero;
transform.rotation = Quaternion.identity;
transform.localScale = Vector3.one;
var e = particleSystem.emission;
e.enabled = false;
//Start Color
var m = particleSystem.main;
sc = m.startColor;
colorMode = sc.mode;
if (colorMode == ParticleSystemGradientMode.Color)
{
c = sc.color;
}
else if (colorMode == ParticleSystemGradientMode.TwoColors)
{
c0 = sc.colorMin;
c1 = sc.colorMax;
}
//add others?
}
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);
}
static ParticleSystem.MinMaxGradient MakeMinMaxGradient(ParticleSystemGradientMode mode,
Color col1, Color col2, Gradient gradient1, Gradient gradient2)
{
ParticleSystem.MinMaxGradient _mmGradient;
if (mode == ParticleSystemGradientMode.Gradient ||
mode == ParticleSystemGradientMode.RandomColor)
{
_mmGradient = new ParticleSystem.MinMaxGradient(gradient1);
}
else if (mode == ParticleSystemGradientMode.TwoColors)
{
_mmGradient = new ParticleSystem.MinMaxGradient(col1, col2);
}
else if (mode == ParticleSystemGradientMode.TwoGradients)
{
_mmGradient = new ParticleSystem.MinMaxGradient(gradient1, gradient2);
}
else // if (ps.main.startColor.mode == ParticleSystemGradientMode.Color)
{
_mmGradient = new ParticleSystem.MinMaxGradient(col1);
}
_mmGradient.mode = mode;
return(_mmGradient);
}
public SerializablePSGradientMode(ParticleSystemGradientMode psGradientMode)
{
mode = psGradientMode.ToString();
}
/// <summary>
/// <para>Randomly select colors based on the interval between the minimum and maximum gradients.</para>
/// </summary>
/// <param name="min">The gradient describing the minimum colors to be evaluated.</param>
/// <param name="max">The gradient describing the maximum colors to be evaluated.</param>
public MinMaxGradient(Gradient min, Gradient max)
{
this.m_Mode = ParticleSystemGradientMode.TwoGradients;
this.m_GradientMin = min;
this.m_GradientMax = max;
this.m_ColorMin = Color.black;
this.m_ColorMax = Color.black;
}
/// <summary>
/// <para>Randomly select colors based on the interval between the minimum and maximum constants.</para>
/// </summary>
/// <param name="min">The constant color describing the minimum colors to be evaluated.</param>
/// <param name="max">The constant color describing the maximum colors to be evaluated.</param>
public MinMaxGradient(Color min, Color max)
{
this.m_Mode = ParticleSystemGradientMode.TwoColors;
this.m_GradientMin = (Gradient) null;
this.m_GradientMax = (Gradient) null;
this.m_ColorMin = min;
this.m_ColorMax = max;
}
/// <summary>
/// <para>Use one gradient when evaluating numbers along this Min-Max gradient.</para>
/// </summary>
/// <param name="gradient">A single gradient for evaluating against.</param>
public MinMaxGradient(Gradient gradient)
{
this.m_Mode = ParticleSystemGradientMode.Gradient;
this.m_GradientMin = (Gradient) null;
this.m_GradientMax = gradient;
this.m_ColorMin = Color.black;
this.m_ColorMax = Color.black;
}
/// <summary>
/// <para>A single constant color for the entire gradient.</para>
/// </summary>
/// <param name="color">Constant color.</param>
public MinMaxGradient(Color color)
{
this.m_Mode = ParticleSystemGradientMode.Color;
this.m_GradientMin = (Gradient) null;
this.m_GradientMax = (Gradient) null;
this.m_ColorMin = Color.black;
this.m_ColorMax = color;
}
private bool ValidateColorMode(ParticleSystemGradientMode mode)
{
return(mode == ParticleSystemGradientMode.Color);
}
