public override object Read <T>(ES3Reader reader)
{
var instance = new UnityEngine.ParticleSystem.MainModule();
ReadInto <T>(reader, instance);
return(instance);
}
protected override void Create(EntityObject entity)
{
base.Create(entity);
m_ps = this.GetComponentInChildren <ParticleSystem>();
UnityEngine.ParticleSystem.MainModule main = m_ps.main;
main.startLifetimeMultiplier = m_entity.Data.length * 0.033f;
m_entity.Data.bodyVisible = false;
}
protected override void Update()
{
base.Update();
if (m_ps != null && m_entity != null)
{
if (m_ps.main.startLifetimeMultiplier != m_entity.Data.length * 0.033f)
{
UnityEngine.ParticleSystem.MainModule main = m_ps.main;
main.startLifetimeMultiplier = m_entity.Data.length * 0.033f;
}
}
}
static void WriteBackInstance(ILRuntime.Runtime.Enviorment.AppDomain __domain, StackObject *ptr_of_this_method, IList <object> __mStack, ref UnityEngine.ParticleSystem.MainModule 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.MainModule[];
instance_of_arrayReference[ptr_of_this_method->ValueLow] = instance_of_this_method;
}
break;
}
}
/// <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.MainModule mainModule = (UnityEngine.ParticleSystem.MainModule)value;
writer.WriteProperty("duration", mainModule.duration);
writer.WriteProperty("loop", mainModule.loop);
writer.WriteProperty("prewarm", mainModule.prewarm);
writer.WriteProperty("startDelay", mainModule.startDelay);
writer.WriteProperty("startDelayMultiplier", mainModule.startDelayMultiplier);
writer.WriteProperty("startLifetime", mainModule.startLifetime);
writer.WriteProperty("startLifetimeMultiplier", mainModule.startLifetimeMultiplier);
writer.WriteProperty("startSpeed", mainModule.startSpeed);
writer.WriteProperty("startSpeedMultiplier", mainModule.startSpeedMultiplier);
writer.WriteProperty("startSize3D", mainModule.startSize3D);
writer.WriteProperty("startSize", mainModule.startSize);
writer.WriteProperty("startSizeMultiplier", mainModule.startSizeMultiplier);
writer.WriteProperty("startSizeX", mainModule.startSizeX);
writer.WriteProperty("startSizeXMultiplier", mainModule.startSizeXMultiplier);
writer.WriteProperty("startSizeY", mainModule.startSizeY);
writer.WriteProperty("startSizeYMultiplier", mainModule.startSizeYMultiplier);
writer.WriteProperty("startSizeZ", mainModule.startSizeZ);
writer.WriteProperty("startSizeZMultiplier", mainModule.startSizeZMultiplier);
writer.WriteProperty("startRotation3D", mainModule.startRotation3D);
writer.WriteProperty("startRotation", mainModule.startRotation);
writer.WriteProperty("startRotationMultiplier", mainModule.startRotationMultiplier);
writer.WriteProperty("startRotationX", mainModule.startRotationX);
writer.WriteProperty("startRotationXMultiplier", mainModule.startRotationXMultiplier);
writer.WriteProperty("startRotationY", mainModule.startRotationY);
writer.WriteProperty("startRotationYMultiplier", mainModule.startRotationYMultiplier);
writer.WriteProperty("startRotationZ", mainModule.startRotationZ);
writer.WriteProperty("startRotationZMultiplier", mainModule.startRotationZMultiplier);
//writer.WriteProperty("randomizeRotationDirection", mainModule.flipRotation);
writer.WriteProperty("startColor", mainModule.startColor);
writer.WriteProperty("gravityModifier", mainModule.gravityModifier);
writer.WriteProperty("gravityModifierMultiplier", mainModule.gravityModifierMultiplier);
writer.WriteProperty("simulationSpace", mainModule.simulationSpace);
writer.WriteProperty("customSimulationSpace", mainModule.customSimulationSpace);
writer.WriteProperty("simulationSpeed", mainModule.simulationSpeed);
#if UNITY_2017_1_OR_NEWER
writer.WriteProperty("useUnscaledTime", mainModule.useUnscaledTime);
#endif
writer.WriteProperty("scalingMode", mainModule.scalingMode);
writer.WriteProperty("playOnAwake", mainModule.playOnAwake);
writer.WriteProperty("maxParticles", mainModule.maxParticles);
#if UNITY_2017_1_OR_NEWER
writer.WriteProperty("emitterVelocityMode", mainModule.emitterVelocityMode);
#endif
}
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.MainModule o = (UnityEngine.ParticleSystem.MainModule)obj;
o.duration = duration;
o.loop = loop;
o.prewarm = prewarm;
o.startDelay = Write(o.startDelay, startDelay, objects);
o.startDelayMultiplier = startDelayMultiplier;
o.startLifetime = Write(o.startLifetime, startLifetime, objects);
o.startLifetimeMultiplier = startLifetimeMultiplier;
o.startSpeed = Write(o.startSpeed, startSpeed, objects);
o.startSpeedMultiplier = startSpeedMultiplier;
o.startSize3D = startSize3D;
o.startSize = Write(o.startSize, startSize, objects);
o.startSizeMultiplier = startSizeMultiplier;
o.startSizeX = Write(o.startSizeX, startSizeX, objects);
o.startSizeXMultiplier = startSizeXMultiplier;
o.startSizeY = Write(o.startSizeY, startSizeY, objects);
o.startSizeYMultiplier = startSizeYMultiplier;
o.startSizeZ = Write(o.startSizeZ, startSizeZ, objects);
o.startSizeZMultiplier = startSizeZMultiplier;
o.startRotation3D = startRotation3D;
o.startRotation = Write(o.startRotation, startRotation, objects);
o.startRotationMultiplier = startRotationMultiplier;
o.startRotationX = Write(o.startRotationX, startRotationX, objects);
o.startRotationXMultiplier = startRotationXMultiplier;
o.startRotationY = Write(o.startRotationY, startRotationY, objects);
o.startRotationYMultiplier = startRotationYMultiplier;
o.startRotationZ = Write(o.startRotationZ, startRotationZ, objects);
o.startRotationZMultiplier = startRotationZMultiplier;
o.randomizeRotationDirection = randomizeRotationDirection;
o.startColor = Write(o.startColor, startColor, objects);
o.gravityModifier = Write(o.gravityModifier, gravityModifier, objects);
o.gravityModifierMultiplier = gravityModifierMultiplier;
o.simulationSpace = (UnityEngine.ParticleSystemSimulationSpace)simulationSpace;
o.customSimulationSpace = (UnityEngine.Transform)objects.Get(customSimulationSpace);
o.simulationSpeed = simulationSpeed;
o.scalingMode = (UnityEngine.ParticleSystemScalingMode)scalingMode;
o.playOnAwake = playOnAwake;
o.maxParticles = maxParticles;
return(o);
}
public override void ReadFrom(object obj)
{
base.ReadFrom(obj);
if (obj == null)
{
return;
}
UnityEngine.ParticleSystem.MainModule o = (UnityEngine.ParticleSystem.MainModule)obj;
duration = o.duration;
loop = o.loop;
prewarm = o.prewarm;
startDelay = Read(startDelay, o.startDelay);
startDelayMultiplier = o.startDelayMultiplier;
startLifetime = Read(startLifetime, o.startLifetime);
startLifetimeMultiplier = o.startLifetimeMultiplier;
startSpeed = Read(startSpeed, o.startSpeed);
startSpeedMultiplier = o.startSpeedMultiplier;
startSize3D = o.startSize3D;
startSize = Read(startSize, o.startSize);
startSizeMultiplier = o.startSizeMultiplier;
startSizeX = Read(startSizeX, o.startSizeX);
startSizeXMultiplier = o.startSizeXMultiplier;
startSizeY = Read(startSizeY, o.startSizeY);
startSizeYMultiplier = o.startSizeYMultiplier;
startSizeZ = Read(startSizeZ, o.startSizeZ);
startSizeZMultiplier = o.startSizeZMultiplier;
startRotation3D = o.startRotation3D;
startRotation = Read(startRotation, o.startRotation);
startRotationMultiplier = o.startRotationMultiplier;
startRotationX = Read(startRotationX, o.startRotationX);
startRotationXMultiplier = o.startRotationXMultiplier;
startRotationY = Read(startRotationY, o.startRotationY);
startRotationYMultiplier = o.startRotationYMultiplier;
startRotationZ = Read(startRotationZ, o.startRotationZ);
startRotationZMultiplier = o.startRotationZMultiplier;
randomizeRotationDirection = o.randomizeRotationDirection;
startColor = Read(startColor, o.startColor);
gravityModifier = Read(gravityModifier, o.gravityModifier);
gravityModifierMultiplier = o.gravityModifierMultiplier;
simulationSpace = (uint)o.simulationSpace;
customSimulationSpace = o.customSimulationSpace.GetMappedInstanceID();
simulationSpeed = o.simulationSpeed;
scalingMode = (uint)o.scalingMode;
playOnAwake = o.playOnAwake;
maxParticles = o.maxParticles;
}
static StackObject *set_scalingMode_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, 2);
ptr_of_this_method = ILIntepreter.Minus(__esp, 1);
UnityEngine.ParticleSystemScalingMode @value = (UnityEngine.ParticleSystemScalingMode) typeof(UnityEngine.ParticleSystemScalingMode).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.scalingMode = 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);
}
protected override void GetDependencies(System.Collections.Generic.Dictionary <long, UnityEngine.Object> dependencies, object obj)
{
base.GetDependencies(dependencies, obj);
if (obj == null)
{
return;
}
UnityEngine.ParticleSystem.MainModule o = (UnityEngine.ParticleSystem.MainModule)obj;
GetDependencies(startDelay, o.startDelay, dependencies);
GetDependencies(startLifetime, o.startLifetime, dependencies);
GetDependencies(startSpeed, o.startSpeed, dependencies);
GetDependencies(startSize, o.startSize, dependencies);
GetDependencies(startSizeX, o.startSizeX, dependencies);
GetDependencies(startSizeY, o.startSizeY, dependencies);
GetDependencies(startSizeZ, o.startSizeZ, dependencies);
GetDependencies(startRotation, o.startRotation, dependencies);
GetDependencies(startRotationX, o.startRotationX, dependencies);
GetDependencies(startRotationY, o.startRotationY, dependencies);
GetDependencies(startRotationZ, o.startRotationZ, dependencies);
GetDependencies(startColor, o.startColor, dependencies);
GetDependencies(gravityModifier, o.gravityModifier, dependencies);
AddDependency(o.customSimulationSpace, dependencies);
}
/// <summary>
/// Read the data using the reader.
/// </summary>
/// <param name="reader">Reader.</param>
public override object Read(ISaveGameReader reader)
{
UnityEngine.ParticleSystem.MainModule mainModule = new UnityEngine.ParticleSystem.MainModule();
foreach (string property in reader.Properties)
{
switch (property)
{
case "duration":
mainModule.duration = reader.ReadProperty <System.Single>();
break;
case "loop":
mainModule.loop = reader.ReadProperty <System.Boolean>();
break;
case "prewarm":
mainModule.prewarm = reader.ReadProperty <System.Boolean>();
break;
case "startDelay":
mainModule.startDelay = reader.ReadProperty <UnityEngine.ParticleSystem.MinMaxCurve>();
break;
case "startDelayMultiplier":
mainModule.startDelayMultiplier = reader.ReadProperty <System.Single>();
break;
case "startLifetime":
mainModule.startLifetime = reader.ReadProperty <UnityEngine.ParticleSystem.MinMaxCurve>();
break;
case "startLifetimeMultiplier":
mainModule.startLifetimeMultiplier = reader.ReadProperty <System.Single>();
break;
case "startSpeed":
mainModule.startSpeed = reader.ReadProperty <UnityEngine.ParticleSystem.MinMaxCurve>();
break;
case "startSpeedMultiplier":
mainModule.startSpeedMultiplier = reader.ReadProperty <System.Single>();
break;
case "startSize3D":
mainModule.startSize3D = reader.ReadProperty <System.Boolean>();
break;
case "startSize":
mainModule.startSize = reader.ReadProperty <UnityEngine.ParticleSystem.MinMaxCurve>();
break;
case "startSizeMultiplier":
mainModule.startSizeMultiplier = reader.ReadProperty <System.Single>();
break;
case "startSizeX":
mainModule.startSizeX = reader.ReadProperty <UnityEngine.ParticleSystem.MinMaxCurve>();
break;
case "startSizeXMultiplier":
mainModule.startSizeXMultiplier = reader.ReadProperty <System.Single>();
break;
case "startSizeY":
mainModule.startSizeY = reader.ReadProperty <UnityEngine.ParticleSystem.MinMaxCurve>();
break;
case "startSizeYMultiplier":
mainModule.startSizeYMultiplier = reader.ReadProperty <System.Single>();
break;
case "startSizeZ":
mainModule.startSizeZ = reader.ReadProperty <UnityEngine.ParticleSystem.MinMaxCurve>();
break;
case "startSizeZMultiplier":
mainModule.startSizeZMultiplier = reader.ReadProperty <System.Single>();
break;
case "startRotation3D":
mainModule.startRotation3D = reader.ReadProperty <System.Boolean>();
break;
case "startRotation":
mainModule.startRotation = reader.ReadProperty <UnityEngine.ParticleSystem.MinMaxCurve>();
break;
case "startRotationMultiplier":
mainModule.startRotationMultiplier = reader.ReadProperty <System.Single>();
break;
case "startRotationX":
mainModule.startRotationX = reader.ReadProperty <UnityEngine.ParticleSystem.MinMaxCurve>();
break;
case "startRotationXMultiplier":
mainModule.startRotationXMultiplier = reader.ReadProperty <System.Single>();
break;
case "startRotationY":
mainModule.startRotationY = reader.ReadProperty <UnityEngine.ParticleSystem.MinMaxCurve>();
break;
case "startRotationYMultiplier":
mainModule.startRotationYMultiplier = reader.ReadProperty <System.Single>();
break;
case "startRotationZ":
mainModule.startRotationZ = reader.ReadProperty <UnityEngine.ParticleSystem.MinMaxCurve>();
break;
case "startRotationZMultiplier":
mainModule.startRotationZMultiplier = reader.ReadProperty <System.Single>();
break;
case "randomizeRotationDirection": // Removed in Unity 2017.4
reader.ReadProperty <System.Single>();
break;
case "startColor":
mainModule.startColor = reader.ReadProperty <UnityEngine.ParticleSystem.MinMaxGradient>();
break;
case "gravityModifier":
mainModule.gravityModifier = reader.ReadProperty <UnityEngine.ParticleSystem.MinMaxCurve>();
break;
case "gravityModifierMultiplier":
mainModule.gravityModifierMultiplier = reader.ReadProperty <System.Single>();
break;
case "simulationSpace":
mainModule.simulationSpace = reader.ReadProperty <UnityEngine.ParticleSystemSimulationSpace>();
break;
case "customSimulationSpace":
if (mainModule.customSimulationSpace == null)
{
mainModule.customSimulationSpace = reader.ReadProperty <UnityEngine.Transform>();
}
else
{
reader.ReadIntoProperty <UnityEngine.Transform>(mainModule.customSimulationSpace);
}
break;
case "simulationSpeed":
mainModule.simulationSpeed = reader.ReadProperty <System.Single>();
break;
case "useUnscaledTime":
#if UNITY_2017_1_OR_NEWER
mainModule.useUnscaledTime = reader.ReadProperty <System.Boolean>();
#else
reader.ReadProperty <System.Boolean>();
#endif
break;
case "scalingMode":
mainModule.scalingMode = reader.ReadProperty <UnityEngine.ParticleSystemScalingMode>();
break;
case "playOnAwake":
mainModule.playOnAwake = reader.ReadProperty <System.Boolean>();
break;
case "maxParticles":
mainModule.maxParticles = reader.ReadProperty <System.Int32>();
break;
case "emitterVelocityMode":
#if UNITY_2017_1_OR_NEWER
mainModule.emitterVelocityMode = reader.ReadProperty <UnityEngine.ParticleSystemEmitterVelocityMode>();
#endif
break;
}
}
return(mainModule);
}
