// TODO support gradients
private static InitialColor ConvertMinMaxGradient(UnityEngine.ParticleSystem.MinMaxGradient gradient)
{
switch (gradient.mode)
{
case ParticleSystemGradientMode.Color:
{
float4 color = new float4(gradient.color.r, gradient.color.g, gradient.color.b, gradient.color.a);
return(new InitialColor {
ColorMin = color, ColorMax = color
});
}
case ParticleSystemGradientMode.TwoColors:
return(new InitialColor
{
ColorMin = new float4(gradient.colorMin.r, gradient.colorMin.g, gradient.colorMin.b, gradient.colorMin.a),
ColorMax = new float4(gradient.colorMax.r, gradient.colorMax.g, gradient.colorMax.b, gradient.colorMax.a)
});
case ParticleSystemGradientMode.Gradient:
case ParticleSystemGradientMode.TwoGradients:
case ParticleSystemGradientMode.RandomColor:
{
UnityEngine.Debug.LogWarning("ParticleSystemGradientMode " + nameof(gradient.mode) + " not supported.");
float4 defaultColor = new float4(1);
return(new InitialColor {
ColorMin = defaultColor, ColorMax = defaultColor
});
}
default:
throw new System.ArgumentOutOfRangeException(nameof(gradient.mode), gradient.mode, null);
}
}
static int _m_GetColor(RealStatePtr L)
{
ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
UnityEngine.ParticleSystem.CustomDataModule __cl_gen_to_be_invoked; translator.Get(L, 1, out __cl_gen_to_be_invoked);
try {
{
UnityEngine.ParticleSystemCustomData stream; translator.Get(L, 2, out stream);
UnityEngine.ParticleSystem.MinMaxGradient __cl_gen_ret = __cl_gen_to_be_invoked.GetColor(stream);
translator.Push(L, __cl_gen_ret);
translator.Update(L, 1, __cl_gen_to_be_invoked);
return(1);
}
} catch (System.Exception __gen_e) {
return(LuaAPI.luaL_error(L, "c# exception:" + __gen_e));
}
}
public void ReplaceParticleFXStartColor(UnityEngine.ParticleSystem.MinMaxGradient newValue)
{
var index = GameComponentsLookup.ParticleFXStartColor;
var component = (ParticleFXStartColorComponent)CreateComponent(index, typeof(ParticleFXStartColorComponent));
component.Value = newValue;
ReplaceComponent(index, component);
}
static int __CreateInstance(RealStatePtr L)
{
ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
try {
if (LuaAPI.lua_gettop(L) == 2 && translator.Assignable <UnityEngine.Color>(L, 2))
{
UnityEngine.Color color; translator.Get(L, 2, out color);
UnityEngine.ParticleSystem.MinMaxGradient __cl_gen_ret = new UnityEngine.ParticleSystem.MinMaxGradient(color);
translator.Push(L, __cl_gen_ret);
return(1);
}
if (LuaAPI.lua_gettop(L) == 2 && translator.Assignable <UnityEngine.Gradient>(L, 2))
{
UnityEngine.Gradient gradient = (UnityEngine.Gradient)translator.GetObject(L, 2, typeof(UnityEngine.Gradient));
UnityEngine.ParticleSystem.MinMaxGradient __cl_gen_ret = new UnityEngine.ParticleSystem.MinMaxGradient(gradient);
translator.Push(L, __cl_gen_ret);
return(1);
}
if (LuaAPI.lua_gettop(L) == 3 && translator.Assignable <UnityEngine.Color>(L, 2) && translator.Assignable <UnityEngine.Color>(L, 3))
{
UnityEngine.Color min; translator.Get(L, 2, out min);
UnityEngine.Color max; translator.Get(L, 3, out max);
UnityEngine.ParticleSystem.MinMaxGradient __cl_gen_ret = new UnityEngine.ParticleSystem.MinMaxGradient(min, max);
translator.Push(L, __cl_gen_ret);
return(1);
}
if (LuaAPI.lua_gettop(L) == 3 && translator.Assignable <UnityEngine.Gradient>(L, 2) && translator.Assignable <UnityEngine.Gradient>(L, 3))
{
UnityEngine.Gradient min = (UnityEngine.Gradient)translator.GetObject(L, 2, typeof(UnityEngine.Gradient));
UnityEngine.Gradient max = (UnityEngine.Gradient)translator.GetObject(L, 3, typeof(UnityEngine.Gradient));
UnityEngine.ParticleSystem.MinMaxGradient __cl_gen_ret = new UnityEngine.ParticleSystem.MinMaxGradient(min, max);
translator.Push(L, __cl_gen_ret);
return(1);
}
if (LuaAPI.lua_gettop(L) == 1)
{
translator.Push(L, default(UnityEngine.ParticleSystem.MinMaxGradient));
return(1);
}
}
catch (System.Exception __gen_e) {
return(LuaAPI.luaL_error(L, "c# exception:" + __gen_e));
}
return(LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.ParticleSystem.MinMaxGradient constructor!"));
}
/// <summary>
/// Write the specified value using the writer.
/// </summary>
/// <param name="value">Value.</param>
/// <param name="writer">Writer.</param>
public override void Write(object value, ISaveGameWriter writer)
{
UnityEngine.ParticleSystem.MinMaxGradient minMaxGradient = (UnityEngine.ParticleSystem.MinMaxGradient)value;
writer.WriteProperty("mode", minMaxGradient.mode);
writer.WriteProperty("gradientMax", minMaxGradient.gradientMax);
writer.WriteProperty("gradientMin", minMaxGradient.gradientMin);
writer.WriteProperty("colorMax", minMaxGradient.colorMax);
writer.WriteProperty("colorMin", minMaxGradient.colorMin);
writer.WriteProperty("color", minMaxGradient.color);
writer.WriteProperty("gradient", minMaxGradient.gradient);
}
protected override void GetDependencies(System.Collections.Generic.Dictionary <long, UnityEngine.Object> dependencies, object obj)
{
base.GetDependencies(dependencies, obj);
if (obj == null)
{
return;
}
UnityEngine.ParticleSystem.MinMaxGradient o = (UnityEngine.ParticleSystem.MinMaxGradient)obj;
GetDependencies(gradientMax, o.gradientMax, dependencies);
GetDependencies(gradientMin, o.gradientMin, dependencies);
GetDependencies(gradient, o.gradient, dependencies);
}
static void WriteBackInstance(ILRuntime.Runtime.Enviorment.AppDomain __domain, StackObject *ptr_of_this_method, IList <object> __mStack, ref UnityEngine.ParticleSystem.MinMaxGradient instance_of_this_method)
{
ptr_of_this_method = ILIntepreter.GetObjectAndResolveReference(ptr_of_this_method);
switch (ptr_of_this_method->ObjectType)
{
case ObjectTypes.Object:
{
__mStack[ptr_of_this_method->Value] = instance_of_this_method;
}
break;
case ObjectTypes.FieldReference:
{
var ___obj = __mStack[ptr_of_this_method->Value];
if (___obj is ILTypeInstance)
{
((ILTypeInstance)___obj)[ptr_of_this_method->ValueLow] = instance_of_this_method;
}
else
{
var t = __domain.GetType(___obj.GetType()) as CLRType;
t.SetFieldValue(ptr_of_this_method->ValueLow, ref ___obj, instance_of_this_method);
}
}
break;
case ObjectTypes.StaticFieldReference:
{
var t = __domain.GetType(ptr_of_this_method->Value);
if (t is ILType)
{
((ILType)t).StaticInstance[ptr_of_this_method->ValueLow] = instance_of_this_method;
}
else
{
((CLRType)t).SetStaticFieldValue(ptr_of_this_method->ValueLow, instance_of_this_method);
}
}
break;
case ObjectTypes.ArrayReference:
{
var instance_of_arrayReference = __mStack[ptr_of_this_method->Value] as UnityEngine.ParticleSystem.MinMaxGradient[];
instance_of_arrayReference[ptr_of_this_method->ValueLow] = instance_of_this_method;
}
break;
}
}
public override void ReadFrom(object obj)
{
base.ReadFrom(obj);
if (obj == null)
{
return;
}
UnityEngine.ParticleSystem.MinMaxGradient o = (UnityEngine.ParticleSystem.MinMaxGradient)obj;
mode = (uint)o.mode;
gradientMax = Read(gradientMax, o.gradientMax);
gradientMin = Read(gradientMin, o.gradientMin);
colorMax = o.colorMax;
colorMin = o.colorMin;
color = o.color;
gradient = Read(gradient, o.gradient);
}
public override object WriteTo(object obj, System.Collections.Generic.Dictionary <long, UnityEngine.Object> objects)
{
obj = base.WriteTo(obj, objects);
if (obj == null)
{
return(null);
}
UnityEngine.ParticleSystem.MinMaxGradient o = (UnityEngine.ParticleSystem.MinMaxGradient)obj;
o.mode = (UnityEngine.ParticleSystemGradientMode)mode;
o.gradientMax = Write(o.gradientMax, gradientMax, objects);
o.gradientMin = Write(o.gradientMin, gradientMin, objects);
o.colorMax = colorMax;
o.colorMin = colorMin;
o.color = color;
o.gradient = Write(o.gradient, gradient, objects);
return(o);
}
public override object Read <T>(ES3Reader reader)
{
var instance = new UnityEngine.ParticleSystem.MinMaxGradient();
string propertyName;
while ((propertyName = reader.ReadPropertyName()) != null)
{
switch (propertyName)
{
case "mode":
instance.mode = reader.Read <UnityEngine.ParticleSystemGradientMode>();
break;
case "gradientMax":
instance.gradientMax = reader.Read <UnityEngine.Gradient>(ES3Type_Gradient.Instance);
break;
case "gradientMin":
instance.gradientMin = reader.Read <UnityEngine.Gradient>(ES3Type_Gradient.Instance);
break;
case "colorMax":
instance.colorMax = reader.Read <UnityEngine.Color>(ES3Type_Color.Instance);
break;
case "colorMin":
instance.colorMin = reader.Read <UnityEngine.Color>(ES3Type_Color.Instance);
break;
case "color":
instance.color = reader.Read <UnityEngine.Color>(ES3Type_Color.Instance);
break;
case "gradient":
instance.gradient = reader.Read <UnityEngine.Gradient>(ES3Type_Gradient.Instance);
break;
default:
reader.Skip();
break;
}
}
return(instance);
}
public void DeserializeBeforeRef(UABUnpacker unpacker, UABField field, ref object value, List <ISerializer> serializers)
{
var data = new Data();
unpacker.Deserialize(data, field.fields, serializers);
value = new UnityEngine.ParticleSystem.MinMaxGradient()
{
mode = data.mode,
#if UNITY_5_5_OR_NEWER
color = data.color,
#endif
colorMin = data.colorMin,
colorMax = data.colorMax,
#if UNITY_5_5_OR_NEWER
gradient = data.gradient,
#endif
gradientMin = data.gradientMin,
gradientMax = data.gradientMax,
};
}
static StackObject *Ctor_0(ILIntepreter __intp, StackObject *__esp, IList <object> __mStack, CLRMethod __method, bool isNewObj)
{
ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
StackObject *ptr_of_this_method;
StackObject *__ret = ILIntepreter.Minus(__esp, 1);
ptr_of_this_method = ILIntepreter.Minus(__esp, 1);
UnityEngine.Color @color = (UnityEngine.Color) typeof(UnityEngine.Color).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack));
__intp.Free(ptr_of_this_method);
var result_of_this_method = new UnityEngine.ParticleSystem.MinMaxGradient(@color);
if (!isNewObj)
{
__ret--;
WriteBackInstance(__domain, __ret, __mStack, ref result_of_this_method);
return(__ret);
}
return(ILIntepreter.PushObject(__ret, __mStack, result_of_this_method));
}
static StackObject *set_startColor_2(ILIntepreter __intp, StackObject *__esp, IList <object> __mStack, CLRMethod __method, bool isNewObj)
{
ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
StackObject *ptr_of_this_method;
StackObject *__ret = ILIntepreter.Minus(__esp, 2);
ptr_of_this_method = ILIntepreter.Minus(__esp, 1);
UnityEngine.ParticleSystem.MinMaxGradient @value = (UnityEngine.ParticleSystem.MinMaxGradient) typeof(UnityEngine.ParticleSystem.MinMaxGradient).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack));
__intp.Free(ptr_of_this_method);
ptr_of_this_method = ILIntepreter.Minus(__esp, 2);
ptr_of_this_method = ILIntepreter.GetObjectAndResolveReference(ptr_of_this_method);
UnityEngine.ParticleSystem.MainModule instance_of_this_method = (UnityEngine.ParticleSystem.MainModule) typeof(UnityEngine.ParticleSystem.MainModule).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack));
instance_of_this_method.startColor = value;
ptr_of_this_method = ILIntepreter.Minus(__esp, 2);
WriteBackInstance(__domain, ptr_of_this_method, __mStack, ref instance_of_this_method);
__intp.Free(ptr_of_this_method);
return(__ret);
}
/// <summary>
/// Read the data using the reader.
/// </summary>
/// <param name="reader">Reader.</param>
public override object Read(ISaveGameReader reader)
{
UnityEngine.ParticleSystem.MinMaxGradient minMaxGradient = new UnityEngine.ParticleSystem.MinMaxGradient();
foreach (string property in reader.Properties)
{
switch (property)
{
case "mode":
minMaxGradient.mode = reader.ReadProperty <UnityEngine.ParticleSystemGradientMode> ();
break;
case "gradientMax":
minMaxGradient.gradientMax = reader.ReadProperty <UnityEngine.Gradient> ();
break;
case "gradientMin":
minMaxGradient.gradientMin = reader.ReadProperty <UnityEngine.Gradient> ();
break;
case "colorMax":
minMaxGradient.colorMax = reader.ReadProperty <UnityEngine.Color> ();
break;
case "colorMin":
minMaxGradient.colorMin = reader.ReadProperty <UnityEngine.Color> ();
break;
case "color":
minMaxGradient.color = reader.ReadProperty <UnityEngine.Color> ();
break;
case "gradient":
minMaxGradient.gradient = reader.ReadProperty <UnityEngine.Gradient> ();
break;
}
}
return(minMaxGradient);
}
