public override void ReadInto <T>(ES3Reader reader, object obj)
{
var instance = (UnityEngine.AnimationCurve)obj;
string propertyName;
while ((propertyName = reader.ReadPropertyName()) != null)
{
switch (propertyName)
{
case "keys":
instance.keys = reader.Read <UnityEngine.Keyframe[]>();
break;
case "preWrapMode":
instance.preWrapMode = reader.Read <UnityEngine.WrapMode>();
break;
case "postWrapMode":
instance.postWrapMode = reader.Read <UnityEngine.WrapMode>();
break;
default:
reader.Skip();
break;
}
}
}
public override void ReadInto <T>(ES3Reader reader, object obj)
{
var instance = (UnityEngine.ParticleSystem.ColorBySpeedModule)obj;
string propertyName;
while ((propertyName = reader.ReadPropertyName()) != null)
{
switch (propertyName)
{
case "enabled":
instance.enabled = reader.Read <System.Boolean>(ES3Type_bool.Instance);
break;
case "color":
instance.color = reader.Read <UnityEngine.ParticleSystem.MinMaxGradient>(ES3Type_MinMaxGradient.Instance);
break;
case "range":
instance.range = reader.Read <UnityEngine.Vector2>(ES3Type_Vector2.Instance);
break;
default:
reader.Skip();
break;
}
}
}
public override void ReadInto <T>(ES3Reader reader, object obj)
{
var instance = (UnityEngine.ParticleSystem.InheritVelocityModule)obj;
string propertyName;
while ((propertyName = reader.ReadPropertyName()) != null)
{
switch (propertyName)
{
case "enabled":
instance.enabled = reader.Read <System.Boolean>(ES3Type_bool.Instance);
break;
case "mode":
instance.mode = reader.Read <UnityEngine.ParticleSystemInheritVelocityMode>();
break;
case "curve":
instance.curve = reader.Read <UnityEngine.ParticleSystem.MinMaxCurve>(ES3Type_MinMaxCurve.Instance);
break;
case "curveMultiplier":
instance.curveMultiplier = reader.Read <System.Single>(ES3Type_float.Instance);
break;
default:
reader.Skip();
break;
}
}
}
public override void ReadInto <T>(ES3Reader reader, object obj)
{
var instance = (UnityEngine.Gradient)obj;
instance.SetKeys(
reader.ReadProperty <UnityEngine.GradientColorKey[]>(ES3Type_GradientColorKeyArray.Instance),
reader.ReadProperty <UnityEngine.GradientAlphaKey[]>(ES3Type_GradientAlphaKeyArray.Instance)
);
string propertyName;
while ((propertyName = reader.ReadPropertyName()) != null)
{
switch (propertyName)
{
case "mode":
instance.mode = reader.Read <UnityEngine.GradientMode>();
break;
default:
reader.Skip();
break;
}
}
}
public override void ReadInto <T>(ES3Reader reader, object obj)
{
var instance = (UnityEngine.ParticleSystem.SizeBySpeedModule)obj;
string propertyName;
while ((propertyName = reader.ReadPropertyName()) != null)
{
switch (propertyName)
{
case "enabled":
instance.enabled = reader.Read <System.Boolean>(ES3Type_bool.Instance);
break;
case "size":
instance.size = reader.Read <UnityEngine.ParticleSystem.MinMaxCurve>(ES3Type_MinMaxCurve.Instance);
break;
case "sizeMultiplier":
instance.sizeMultiplier = reader.Read <System.Single>(ES3Type_float.Instance);
break;
case "x":
instance.x = reader.Read <UnityEngine.ParticleSystem.MinMaxCurve>(ES3Type_MinMaxCurve.Instance);
break;
case "xMultiplier":
instance.xMultiplier = reader.Read <System.Single>(ES3Type_float.Instance);
break;
case "y":
instance.y = reader.Read <UnityEngine.ParticleSystem.MinMaxCurve>(ES3Type_MinMaxCurve.Instance);
break;
case "yMultiplier":
instance.yMultiplier = reader.Read <System.Single>(ES3Type_float.Instance);
break;
case "z":
instance.z = reader.Read <UnityEngine.ParticleSystem.MinMaxCurve>(ES3Type_MinMaxCurve.Instance);
break;
case "zMultiplier":
instance.zMultiplier = reader.Read <System.Single>(ES3Type_float.Instance);
break;
case "separateAxes":
instance.separateAxes = reader.Read <System.Boolean>(ES3Type_bool.Instance);
break;
case "range":
instance.range = reader.Read <UnityEngine.Vector2>(ES3Type_Vector2.Instance);
break;
default:
reader.Skip();
break;
}
}
}
public override void ReadInto <T>(ES3Reader reader, object obj)
{
var instance = (UnityEngine.ParticleSystem.ForceOverLifetimeModule)obj;
string propertyName;
while ((propertyName = reader.ReadPropertyName()) != null)
{
switch (propertyName)
{
case "enabled":
instance.enabled = reader.Read <System.Boolean>(ES3Type_bool.Instance);
break;
case "x":
instance.x = reader.Read <UnityEngine.ParticleSystem.MinMaxCurve>(ES3Type_MinMaxCurve.Instance);
break;
case "y":
instance.y = reader.Read <UnityEngine.ParticleSystem.MinMaxCurve>(ES3Type_MinMaxCurve.Instance);
break;
case "z":
instance.z = reader.Read <UnityEngine.ParticleSystem.MinMaxCurve>(ES3Type_MinMaxCurve.Instance);
break;
case "xMultiplier":
instance.xMultiplier = reader.Read <System.Single>(ES3Type_float.Instance);
break;
case "yMultiplier":
instance.yMultiplier = reader.Read <System.Single>(ES3Type_float.Instance);
break;
case "zMultiplier":
instance.zMultiplier = reader.Read <System.Single>(ES3Type_float.Instance);
break;
case "space":
instance.space = reader.Read <UnityEngine.ParticleSystemSimulationSpace>();
break;
case "randomized":
instance.randomized = reader.Read <System.Boolean>(ES3Type_bool.Instance);
break;
default:
reader.Skip();
break;
}
}
}
public override object Read <T>(ES3Reader reader)
{
var instance = new UnityEngine.ParticleSystem.MinMaxCurve();
string propertyName;
while ((propertyName = reader.ReadPropertyName()) != null)
{
switch (propertyName)
{
case "mode":
instance.mode = reader.Read <UnityEngine.ParticleSystemCurveMode>();
break;
case "curveMultiplier":
instance.curveMultiplier = reader.Read <System.Single>(ES3Type_float.Instance);
break;
case "curveMax":
instance.curveMax = reader.Read <UnityEngine.AnimationCurve>(ES3Type_AnimationCurve.Instance);
break;
case "curveMin":
instance.curveMin = reader.Read <UnityEngine.AnimationCurve>(ES3Type_AnimationCurve.Instance);
break;
case "constantMax":
instance.constantMax = reader.Read <System.Single>(ES3Type_float.Instance);
break;
case "constantMin":
instance.constantMin = reader.Read <System.Single>(ES3Type_float.Instance);
break;
case "constant":
instance.constant = reader.Read <System.Single>(ES3Type_float.Instance);
break;
case "curve":
instance.curve = reader.Read <UnityEngine.AnimationCurve>(ES3Type_AnimationCurve.Instance);
break;
default:
reader.Skip();
break;
}
}
return(instance);
}
public IEnumerator GetEnumerator()
{
while (true)
{
string key = reader.ReadPropertyName();
if (key == null)
{
yield break;
}
Type type = reader.ReadKeyPrefix();
byte[] bytes = reader.ReadElement();
reader.ReadKeySuffix();
yield return(new KeyValuePair <string, ES3Data>(key, new ES3Data(type, bytes)));
}
}
public override void ReadInto <T>(ES3Reader reader, object obj)
{
var instance = (UnityEngine.ParticleSystem.SubEmittersModule)obj;
ParticleSystemSubEmitterProperties[] seProperties = null;
ParticleSystem[] seSystems = null;
ParticleSystemSubEmitterType[] seTypes = null;
string propertyName;
while ((propertyName = reader.ReadPropertyName()) != null)
{
switch (propertyName)
{
case "enabled":
instance.enabled = reader.Read <System.Boolean>(ES3Type_bool.Instance);
break;
case "properties":
seProperties = reader.Read <ParticleSystemSubEmitterProperties[]>(new ES3ArrayType(typeof(ParticleSystemSubEmitterProperties[])));
break;
case "systems":
seSystems = reader.Read <ParticleSystem[]>();
break;
case "types":
seTypes = reader.Read <ParticleSystemSubEmitterType[]>();
break;
default:
reader.Skip();
break;
}
}
if (seProperties != null)
{
for (int i = 0; i < seProperties.Length; i++)
{
instance.RemoveSubEmitter(i);
instance.AddSubEmitter(seSystems[i], seTypes[i], seProperties[i]);
}
}
}
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 override void ReadInto <T>(ES3Reader reader, object obj)
{
var instance = (UnityEngine.Flare)obj;
string propertyName;
while ((propertyName = reader.ReadPropertyName()) != null)
{
switch (propertyName)
{
case "hideFlags":
instance.hideFlags = reader.Read <UnityEngine.HideFlags>();
break;
default:
reader.Skip();
break;
}
}
}
public override void ReadInto <T>(ES3Reader reader, object obj)
{
var instance = (UnityEngine.Font)obj;
string propertyName;
while ((propertyName = reader.ReadPropertyName()) != null)
{
switch (propertyName)
{
case "material":
instance.material = reader.Read <UnityEngine.Material>(ES3Type_Material.Instance);
break;
default:
reader.Skip();
break;
}
}
}
public override object Read <T>(ES3Reader reader)
{
LayerMask instance = new LayerMask();
string propertyName;
while ((propertyName = reader.ReadPropertyName()) != null)
{
switch (propertyName)
{
case "value":
instance = reader.Read <int>(ES3Type_int.Instance);
break;
default:
reader.Skip();
break;
}
}
return(instance);
}
public override object Read <T>(ES3Reader reader)
{
if (members == null)
{
GetMembers(reader.settings.safeReflection);
}
object obj;
string propertyName = reader.ReadPropertyName();
// If we're loading a derived type, use it's specific ES3Type.
if (propertyName == ES3Type.typeFieldName)
{
return(ES3TypeMgr.GetOrCreateES3Type(reader.ReadType()).Read <T>(reader));
}
// If we're loading a reference, load it. Else, create an instance.
if (propertyName == ES3ReferenceMgrBase.referencePropertyName)
{
long id = reader.Read <long>(ES3Type_long.Instance);
obj = ES3ReferenceMgrBase.Current.Get(id);
if (obj == null)
{
// If an instance isn't already registered for this object, create an instance and register the reference.
obj = ES3Reflection.CreateInstance(this.type);
ES3ReferenceMgrBase.Current.Add((UnityEngine.Object)obj, id);
}
}
else
{
reader.overridePropertiesName = propertyName;
obj = ES3Reflection.CreateInstance(this.type);
}
// Iterate through each property in the file and try to load it using the appropriate
// ES3Property in the members array.
ReadProperties(reader, obj);
return(obj);
}
public override void ReadInto <T>(ES3Reader reader, object obj)
{
var instance = (UnityEngine.ParticleSystem.TriggerModule)obj;
string propertyName;
while ((propertyName = reader.ReadPropertyName()) != null)
{
switch (propertyName)
{
case "enabled":
instance.enabled = reader.Read <System.Boolean>(ES3Type_bool.Instance);
break;
case "inside":
instance.inside = reader.Read <UnityEngine.ParticleSystemOverlapAction>();
break;
case "outside":
instance.outside = reader.Read <UnityEngine.ParticleSystemOverlapAction>();
break;
case "enter":
instance.enter = reader.Read <UnityEngine.ParticleSystemOverlapAction>();
break;
case "exit":
instance.exit = reader.Read <UnityEngine.ParticleSystemOverlapAction>();
break;
case "radiusScale":
instance.radiusScale = reader.Read <System.Single>(ES3Type_float.Instance);
break;
default:
reader.Skip();
break;
}
}
}
public override void ReadInto <T>(ES3Reader reader, object obj)
{
var instance = (UnityEngine.GradientAlphaKey)obj;
string propertyName;
while ((propertyName = reader.ReadPropertyName()) != null)
{
switch (propertyName)
{
case "alpha":
instance.alpha = reader.Read <System.Single>(ES3Type_float.Instance);
break;
case "time":
instance.time = reader.Read <System.Single>(ES3Type_float.Instance);
break;
default:
reader.Skip();
break;
}
}
}
public override void ReadInto <T>(ES3Reader reader, object obj)
{
var instance = (UnityEngine.ParticleSystem.ExternalForcesModule)obj;
string propertyName;
while ((propertyName = reader.ReadPropertyName()) != null)
{
switch (propertyName)
{
case "enabled":
instance.enabled = reader.Read <System.Boolean>(ES3Type_bool.Instance);
break;
case "multiplier":
instance.multiplier = reader.Read <System.Single>(ES3Type_float.Instance);
break;
default:
reader.Skip();
break;
}
}
}
public IEnumerator GetEnumerator()
{
string propertyName;
while (true)
{
// Allows us to repeat a property name or insert one of our own.
if (reader.overridePropertiesName != null)
{
string tempName = reader.overridePropertiesName;
reader.overridePropertiesName = null;
yield return(tempName);
}
else
{
if ((propertyName = reader.ReadPropertyName()) == null)
{
yield break;
}
yield return(propertyName);
}
}
}
public override void ReadInto <T>(ES3Reader reader, object obj)
{
if (members == null)
{
GetMembers(reader.settings.safeReflection);
}
string propertyName = reader.ReadPropertyName();
// If we're loading a derived type, use it's specific ES3Type.
if (propertyName == ES3Type.typeFieldName)
{
ES3TypeMgr.GetOrCreateES3Type(reader.ReadType()).ReadInto <T>(reader, obj);
return;
}
else
{
reader.overridePropertiesName = propertyName;
}
// Iterate through each property in the file and try to load it using the appropriate
// ES3Property in the members array.
ReadProperties(reader, obj);
}
public override void ReadInto <T>(ES3Reader reader, object obj)
{
var instance = (UnityEngine.ParticleSystem.LimitVelocityOverLifetimeModule)obj;
string propertyName;
while ((propertyName = reader.ReadPropertyName()) != null)
{
switch (propertyName)
{
case "enabled":
instance.enabled = reader.Read <System.Boolean>(ES3Type_bool.Instance);
break;
case "limitX":
instance.limitX = reader.Read <UnityEngine.ParticleSystem.MinMaxCurve>(ES3Type_MinMaxCurve.Instance);
break;
case "limitXMultiplier":
instance.limitXMultiplier = reader.Read <System.Single>(ES3Type_float.Instance);
break;
case "limitY":
instance.limitY = reader.Read <UnityEngine.ParticleSystem.MinMaxCurve>(ES3Type_MinMaxCurve.Instance);
break;
case "limitYMultiplier":
instance.limitYMultiplier = reader.Read <System.Single>(ES3Type_float.Instance);
break;
case "limitZ":
instance.limitZ = reader.Read <UnityEngine.ParticleSystem.MinMaxCurve>(ES3Type_MinMaxCurve.Instance);
break;
case "limitZMultiplier":
instance.limitZMultiplier = reader.Read <System.Single>(ES3Type_float.Instance);
break;
case "limit":
instance.limit = reader.Read <UnityEngine.ParticleSystem.MinMaxCurve>(ES3Type_MinMaxCurve.Instance);
break;
case "limitMultiplier":
instance.limitMultiplier = reader.Read <System.Single>(ES3Type_float.Instance);
break;
case "dampen":
instance.dampen = reader.Read <System.Single>(ES3Type_float.Instance);
break;
case "separateAxes":
instance.separateAxes = reader.Read <System.Boolean>(ES3Type_bool.Instance);
break;
case "space":
instance.space = reader.Read <UnityEngine.ParticleSystemSimulationSpace>();
break;
default:
reader.Skip();
break;
}
}
}
public override void ReadInto <T>(ES3Reader reader, object obj)
{
var instance = (UnityEngine.ParticleSystem.NoiseModule)obj;
string propertyName;
while ((propertyName = reader.ReadPropertyName()) != null)
{
switch (propertyName)
{
case "enabled":
instance.enabled = reader.Read <System.Boolean>(ES3Type_bool.Instance);
break;
case "separateAxes":
instance.separateAxes = reader.Read <System.Boolean>(ES3Type_bool.Instance);
break;
case "strength":
instance.strength = reader.Read <UnityEngine.ParticleSystem.MinMaxCurve>(ES3Type_MinMaxCurve.Instance);
break;
case "strengthMultiplier":
instance.strengthMultiplier = reader.Read <System.Single>(ES3Type_float.Instance);
break;
case "strengthX":
instance.strengthX = reader.Read <UnityEngine.ParticleSystem.MinMaxCurve>(ES3Type_MinMaxCurve.Instance);
break;
case "strengthXMultiplier":
instance.strengthXMultiplier = reader.Read <System.Single>(ES3Type_float.Instance);
break;
case "strengthY":
instance.strengthY = reader.Read <UnityEngine.ParticleSystem.MinMaxCurve>(ES3Type_MinMaxCurve.Instance);
break;
case "strengthYMultiplier":
instance.strengthYMultiplier = reader.Read <System.Single>(ES3Type_float.Instance);
break;
case "strengthZ":
instance.strengthZ = reader.Read <UnityEngine.ParticleSystem.MinMaxCurve>(ES3Type_MinMaxCurve.Instance);
break;
case "strengthZMultiplier":
instance.strengthZMultiplier = reader.Read <System.Single>(ES3Type_float.Instance);
break;
case "frequency":
instance.frequency = reader.Read <System.Single>(ES3Type_float.Instance);
break;
case "damping":
instance.damping = reader.Read <System.Boolean>(ES3Type_bool.Instance);
break;
case "octaveCount":
instance.octaveCount = reader.Read <System.Int32>(ES3Type_int.Instance);
break;
case "octaveMultiplier":
instance.octaveMultiplier = reader.Read <System.Single>(ES3Type_float.Instance);
break;
case "octaveScale":
instance.octaveScale = reader.Read <System.Single>(ES3Type_float.Instance);
break;
case "quality":
instance.quality = reader.Read <UnityEngine.ParticleSystemNoiseQuality>();
break;
case "scrollSpeed":
instance.scrollSpeed = reader.Read <UnityEngine.ParticleSystem.MinMaxCurve>(ES3Type_MinMaxCurve.Instance);
break;
case "scrollSpeedMultiplier":
instance.scrollSpeedMultiplier = reader.Read <System.Single>(ES3Type_float.Instance);
break;
case "remapEnabled":
instance.remapEnabled = reader.Read <System.Boolean>(ES3Type_bool.Instance);
break;
case "remap":
instance.remap = reader.Read <UnityEngine.ParticleSystem.MinMaxCurve>(ES3Type_MinMaxCurve.Instance);
break;
case "remapMultiplier":
instance.remapMultiplier = reader.Read <System.Single>(ES3Type_float.Instance);
break;
case "remapX":
instance.remapX = reader.Read <UnityEngine.ParticleSystem.MinMaxCurve>(ES3Type_MinMaxCurve.Instance);
break;
case "remapXMultiplier":
instance.remapXMultiplier = reader.Read <System.Single>(ES3Type_float.Instance);
break;
case "remapY":
instance.remapY = reader.Read <UnityEngine.ParticleSystem.MinMaxCurve>(ES3Type_MinMaxCurve.Instance);
break;
case "remapYMultiplier":
instance.remapYMultiplier = reader.Read <System.Single>(ES3Type_float.Instance);
break;
case "remapZ":
instance.remapZ = reader.Read <UnityEngine.ParticleSystem.MinMaxCurve>(ES3Type_MinMaxCurve.Instance);
break;
case "remapZMultiplier":
instance.remapZMultiplier = reader.Read <System.Single>(ES3Type_float.Instance);
break;
default:
reader.Skip();
break;
}
}
}
public override void ReadInto <T>(ES3Reader reader, object obj)
{
var instance = (UnityEngine.ParticleSystem.TrailModule)obj;
string propertyName;
while ((propertyName = reader.ReadPropertyName()) != null)
{
switch (propertyName)
{
case "enabled":
instance.enabled = reader.Read <System.Boolean>(ES3Type_bool.Instance);
break;
case "ratio":
instance.ratio = reader.Read <System.Single>(ES3Type_float.Instance);
break;
case "lifetime":
instance.lifetime = reader.Read <UnityEngine.ParticleSystem.MinMaxCurve>(ES3Type_MinMaxCurve.Instance);
break;
case "lifetimeMultiplier":
instance.lifetimeMultiplier = reader.Read <System.Single>(ES3Type_float.Instance);
break;
case "minVertexDistance":
instance.minVertexDistance = reader.Read <System.Single>(ES3Type_float.Instance);
break;
case "textureMode":
instance.textureMode = reader.Read <UnityEngine.ParticleSystemTrailTextureMode>();
break;
case "worldSpace":
instance.worldSpace = reader.Read <System.Boolean>(ES3Type_bool.Instance);
break;
case "dieWithParticles":
instance.dieWithParticles = reader.Read <System.Boolean>(ES3Type_bool.Instance);
break;
case "sizeAffectsWidth":
instance.sizeAffectsWidth = reader.Read <System.Boolean>(ES3Type_bool.Instance);
break;
case "sizeAffectsLifetime":
instance.sizeAffectsLifetime = reader.Read <System.Boolean>(ES3Type_bool.Instance);
break;
case "inheritParticleColor":
instance.inheritParticleColor = reader.Read <System.Boolean>(ES3Type_bool.Instance);
break;
case "colorOverLifetime":
instance.colorOverLifetime = reader.Read <UnityEngine.ParticleSystem.MinMaxGradient>(ES3Type_MinMaxGradient.Instance);
break;
case "widthOverTrail":
instance.widthOverTrail = reader.Read <UnityEngine.ParticleSystem.MinMaxCurve>(ES3Type_MinMaxCurve.Instance);
break;
case "widthOverTrailMultiplier":
instance.widthOverTrailMultiplier = reader.Read <System.Single>(ES3Type_float.Instance);
break;
case "colorOverTrail":
instance.colorOverTrail = reader.Read <UnityEngine.ParticleSystem.MinMaxGradient>(ES3Type_MinMaxGradient.Instance);
break;
default:
reader.Skip();
break;
}
}
}
public override object Read <T>(ES3Reader reader)
{
reader.ReadPropertyName();
return(new DateTime(reader.Read <long>(ES3Type_long.Instance)));
}
public override void ReadInto <T>(ES3Reader reader, object obj)
{
var instance = (UnityEngine.ParticleSystem.ShapeModule)obj;
string propertyName;
while ((propertyName = reader.ReadPropertyName()) != null)
{
switch (propertyName)
{
case "enabled":
instance.enabled = reader.Read <System.Boolean>(ES3Type_bool.Instance);
break;
case "shapeType":
instance.shapeType = reader.Read <UnityEngine.ParticleSystemShapeType>();
break;
case "randomDirectionAmount":
instance.randomDirectionAmount = reader.Read <System.Single>(ES3Type_float.Instance);
break;
case "sphericalDirectionAmount":
instance.sphericalDirectionAmount = reader.Read <System.Single>(ES3Type_float.Instance);
break;
case "alignToDirection":
instance.alignToDirection = reader.Read <System.Boolean>(ES3Type_bool.Instance);
break;
case "radius":
instance.radius = reader.Read <System.Single>(ES3Type_float.Instance);
break;
case "angle":
instance.angle = reader.Read <System.Single>(ES3Type_float.Instance);
break;
case "length":
instance.length = reader.Read <System.Single>(ES3Type_float.Instance);
break;
#if UNITY_5
case "box":
instance.box = reader.Read <UnityEngine.Vector3>(ES3Type_Vector3.Instance);
break;
case "meshScale":
instance.meshScale = reader.Read <System.Single>(ES3Type_float.Instance);
break;
#else
case "scale":
instance.scale = reader.Read <UnityEngine.Vector3>(ES3Type_Vector3.Instance);
break;
#endif
case "meshShapeType":
instance.meshShapeType = reader.Read <UnityEngine.ParticleSystemMeshShapeType>();
break;
case "mesh":
instance.mesh = reader.Read <UnityEngine.Mesh>();
break;
case "meshRenderer":
instance.meshRenderer = reader.Read <UnityEngine.MeshRenderer>();
break;
case "skinnedMeshRenderer":
instance.skinnedMeshRenderer = reader.Read <UnityEngine.SkinnedMeshRenderer>();
break;
case "useMeshMaterialIndex":
instance.useMeshMaterialIndex = reader.Read <System.Boolean>(ES3Type_bool.Instance);
break;
case "meshMaterialIndex":
instance.meshMaterialIndex = reader.Read <System.Int32>(ES3Type_int.Instance);
break;
case "useMeshColors":
instance.useMeshColors = reader.Read <System.Boolean>(ES3Type_bool.Instance);
break;
case "normalOffset":
instance.normalOffset = reader.Read <System.Single>(ES3Type_float.Instance);
break;
case "arc":
instance.arc = reader.Read <System.Single>(ES3Type_float.Instance);
break;
default:
reader.Skip();
break;
}
}
}
public override void ReadInto <T>(ES3Reader reader, object obj)
{
var instance = (UnityEngine.ParticleSystem.TextureSheetAnimationModule)obj;
string propertyName;
while ((propertyName = reader.ReadPropertyName()) != null)
{
switch (propertyName)
{
case "enabled":
instance.enabled = reader.Read <System.Boolean>(ES3Type_bool.Instance);
break;
case "numTilesX":
instance.numTilesX = reader.Read <System.Int32>(ES3Type_int.Instance);
break;
case "numTilesY":
instance.numTilesY = reader.Read <System.Int32>(ES3Type_int.Instance);
break;
case "animation":
instance.animation = reader.Read <UnityEngine.ParticleSystemAnimationType>();
break;
#if UNITY_2019_1_OR_NEWER
case "rowMode":
instance.rowMode = reader.Read <ParticleSystemAnimationRowMode>();
break;
#else
case "useRandomRow":
instance.useRandomRow = reader.Read <System.Boolean>(ES3Type_bool.Instance);
break;
#endif
case "frameOverTime":
instance.frameOverTime = reader.Read <UnityEngine.ParticleSystem.MinMaxCurve>(ES3Type_MinMaxCurve.Instance);
break;
case "frameOverTimeMultiplier":
instance.frameOverTimeMultiplier = reader.Read <System.Single>(ES3Type_float.Instance);
break;
case "startFrame":
instance.startFrame = reader.Read <UnityEngine.ParticleSystem.MinMaxCurve>(ES3Type_MinMaxCurve.Instance);
break;
case "startFrameMultiplier":
instance.startFrameMultiplier = reader.Read <System.Single>(ES3Type_float.Instance);
break;
case "cycleCount":
instance.cycleCount = reader.Read <System.Int32>(ES3Type_int.Instance);
break;
case "rowIndex":
instance.rowIndex = reader.Read <System.Int32>(ES3Type_int.Instance);
break;
case "uvChannelMask":
instance.uvChannelMask = reader.Read <UnityEngine.Rendering.UVChannelFlags>();
break;
/*case "flipU":
* instance.flipU = reader.Read<System.Single>(ES3Type_float.Instance);
* break;
* case "flipV":
* instance.flipV = reader.Read<System.Single>(ES3Type_float.Instance);
* break;*/
default:
reader.Skip();
break;
}
}
}
public override void ReadInto <T>(ES3Reader reader, object obj)
{
var instance = (UnityEngine.ParticleSystem.CollisionModule)obj;
string propertyName;
while ((propertyName = reader.ReadPropertyName()) != null)
{
switch (propertyName)
{
case "enabled":
instance.enabled = reader.Read <System.Boolean>();
break;
case "type":
instance.type = reader.Read <UnityEngine.ParticleSystemCollisionType>();
break;
case "mode":
instance.mode = reader.Read <UnityEngine.ParticleSystemCollisionMode>();
break;
case "dampen":
instance.dampen = reader.Read <UnityEngine.ParticleSystem.MinMaxCurve>(ES3Type_MinMaxCurve.Instance);
break;
case "dampenMultiplier":
instance.dampenMultiplier = reader.Read <System.Single>();
break;
case "bounce":
instance.bounce = reader.Read <UnityEngine.ParticleSystem.MinMaxCurve>(ES3Type_MinMaxCurve.Instance);
break;
case "bounceMultiplier":
instance.bounceMultiplier = reader.Read <System.Single>();
break;
case "lifetimeLoss":
instance.lifetimeLoss = reader.Read <UnityEngine.ParticleSystem.MinMaxCurve>(ES3Type_MinMaxCurve.Instance);
break;
case "lifetimeLossMultiplier":
instance.lifetimeLossMultiplier = reader.Read <System.Single>();
break;
case "minKillSpeed":
instance.minKillSpeed = reader.Read <System.Single>();
break;
case "maxKillSpeed":
instance.maxKillSpeed = reader.Read <System.Single>();
break;
case "collidesWith":
instance.collidesWith = reader.Read <UnityEngine.LayerMask>();
break;
case "enableDynamicColliders":
instance.enableDynamicColliders = reader.Read <System.Boolean>();
break;
case "maxCollisionShapes":
instance.maxCollisionShapes = reader.Read <System.Int32>();
break;
case "quality":
instance.quality = reader.Read <UnityEngine.ParticleSystemCollisionQuality>();
break;
case "voxelSize":
instance.voxelSize = reader.Read <System.Single>();
break;
case "radiusScale":
instance.radiusScale = reader.Read <System.Single>();
break;
case "sendCollisionMessages":
instance.sendCollisionMessages = reader.Read <System.Boolean>();
break;
default:
reader.Skip();
break;
}
}
}
public override void ReadInto <T>(ES3Reader reader, object obj)
{
var instance = (UnityEngine.ParticleSystem.MainModule)obj;
string propertyName;
while ((propertyName = reader.ReadPropertyName()) != null)
{
switch (propertyName)
{
case "duration":
instance.duration = reader.Read <System.Single>(ES3Type_float.Instance);
break;
case "loop":
instance.loop = reader.Read <System.Boolean>(ES3Type_bool.Instance);
break;
case "prewarm":
instance.prewarm = reader.Read <System.Boolean>(ES3Type_bool.Instance);
break;
case "startDelay":
instance.startDelay = reader.Read <UnityEngine.ParticleSystem.MinMaxCurve>(ES3Type_MinMaxCurve.Instance);
break;
case "startDelayMultiplier":
instance.startDelayMultiplier = reader.Read <System.Single>(ES3Type_float.Instance);
break;
case "startLifetime":
instance.startLifetime = reader.Read <UnityEngine.ParticleSystem.MinMaxCurve>(ES3Type_MinMaxCurve.Instance);
break;
case "startLifetimeMultiplier":
instance.startLifetimeMultiplier = reader.Read <System.Single>(ES3Type_float.Instance);
break;
case "startSpeed":
instance.startSpeed = reader.Read <UnityEngine.ParticleSystem.MinMaxCurve>(ES3Type_MinMaxCurve.Instance);
break;
case "startSpeedMultiplier":
instance.startSpeedMultiplier = reader.Read <System.Single>(ES3Type_float.Instance);
break;
case "startSize3D":
instance.startSize3D = reader.Read <System.Boolean>(ES3Type_bool.Instance);
break;
case "startSize":
instance.startSize = reader.Read <UnityEngine.ParticleSystem.MinMaxCurve>(ES3Type_MinMaxCurve.Instance);
break;
case "startSizeMultiplier":
instance.startSizeMultiplier = reader.Read <System.Single>(ES3Type_float.Instance);
break;
case "startSizeX":
instance.startSizeX = reader.Read <UnityEngine.ParticleSystem.MinMaxCurve>(ES3Type_MinMaxCurve.Instance);
break;
case "startSizeXMultiplier":
instance.startSizeXMultiplier = reader.Read <System.Single>(ES3Type_float.Instance);
break;
case "startSizeY":
instance.startSizeY = reader.Read <UnityEngine.ParticleSystem.MinMaxCurve>(ES3Type_MinMaxCurve.Instance);
break;
case "startSizeYMultiplier":
instance.startSizeYMultiplier = reader.Read <System.Single>(ES3Type_float.Instance);
break;
case "startSizeZ":
instance.startSizeZ = reader.Read <UnityEngine.ParticleSystem.MinMaxCurve>(ES3Type_MinMaxCurve.Instance);
break;
case "startSizeZMultiplier":
instance.startSizeZMultiplier = reader.Read <System.Single>(ES3Type_float.Instance);
break;
case "startRotation3D":
instance.startRotation3D = reader.Read <System.Boolean>(ES3Type_bool.Instance);
break;
case "startRotation":
instance.startRotation = reader.Read <UnityEngine.ParticleSystem.MinMaxCurve>(ES3Type_MinMaxCurve.Instance);
break;
case "startRotationMultiplier":
instance.startRotationMultiplier = reader.Read <System.Single>(ES3Type_float.Instance);
break;
case "startRotationX":
instance.startRotationX = reader.Read <UnityEngine.ParticleSystem.MinMaxCurve>(ES3Type_MinMaxCurve.Instance);
break;
case "startRotationXMultiplier":
instance.startRotationXMultiplier = reader.Read <System.Single>(ES3Type_float.Instance);
break;
case "startRotationY":
instance.startRotationY = reader.Read <UnityEngine.ParticleSystem.MinMaxCurve>(ES3Type_MinMaxCurve.Instance);
break;
case "startRotationYMultiplier":
instance.startRotationYMultiplier = reader.Read <System.Single>(ES3Type_float.Instance);
break;
case "startRotationZ":
instance.startRotationZ = reader.Read <UnityEngine.ParticleSystem.MinMaxCurve>(ES3Type_MinMaxCurve.Instance);
break;
case "startRotationZMultiplier":
instance.startRotationZMultiplier = reader.Read <System.Single>(ES3Type_float.Instance);
break;
#if UNITY_2018_1_OR_NEWER
case "flipRotation":
instance.flipRotation = reader.Read <System.Single>(ES3Type_float.Instance);
break;
case "randomizeRotationDirection":
instance.flipRotation = reader.Read <System.Single>(ES3Type_float.Instance);
break;
#else
case "randomizeRotationDirection":
instance.randomizeRotationDirection = reader.Read <System.Single>(ES3Type_float.Instance);
break;
#endif
case "startColor":
instance.startColor = reader.Read <UnityEngine.ParticleSystem.MinMaxGradient>(ES3Type_MinMaxGradient.Instance);
break;
case "gravityModifier":
instance.gravityModifier = reader.Read <UnityEngine.ParticleSystem.MinMaxCurve>(ES3Type_MinMaxCurve.Instance);
break;
case "gravityModifierMultiplier":
instance.gravityModifierMultiplier = reader.Read <System.Single>(ES3Type_float.Instance);
break;
case "simulationSpace":
instance.simulationSpace = reader.Read <UnityEngine.ParticleSystemSimulationSpace>();
break;
case "customSimulationSpace":
instance.customSimulationSpace = reader.Read <UnityEngine.Transform>(ES3Type_Transform.Instance);
break;
case "simulationSpeed":
instance.simulationSpeed = reader.Read <System.Single>(ES3Type_float.Instance);
break;
case "scalingMode":
instance.scalingMode = reader.Read <UnityEngine.ParticleSystemScalingMode>();
break;
case "playOnAwake":
instance.playOnAwake = reader.Read <System.Boolean>(ES3Type_bool.Instance);
break;
case "maxParticles":
instance.maxParticles = reader.Read <System.Int32>(ES3Type_int.Instance);
break;
default:
reader.Skip();
break;
}
}
}
public override void ReadInto <T>(ES3Reader reader, object obj)
{
var instance = (UnityEngine.ParticleSystem.LightsModule)obj;
string propertyName;
while ((propertyName = reader.ReadPropertyName()) != null)
{
switch (propertyName)
{
case "enabled":
instance.enabled = reader.Read <System.Boolean>(ES3Type_bool.Instance);
break;
case "ratio":
instance.ratio = reader.Read <System.Single>(ES3Type_float.Instance);
break;
case "useRandomDistribution":
instance.useRandomDistribution = reader.Read <System.Boolean>(ES3Type_bool.Instance);
break;
case "light":
instance.light = reader.Read <UnityEngine.Light>(ES3Type_Light.Instance);
break;
case "useParticleColor":
instance.useParticleColor = reader.Read <System.Boolean>(ES3Type_bool.Instance);
break;
case "sizeAffectsRange":
instance.sizeAffectsRange = reader.Read <System.Boolean>(ES3Type_bool.Instance);
break;
case "alphaAffectsIntensity":
instance.alphaAffectsIntensity = reader.Read <System.Boolean>(ES3Type_bool.Instance);
break;
case "range":
instance.range = reader.Read <UnityEngine.ParticleSystem.MinMaxCurve>(ES3Type_MinMaxCurve.Instance);
break;
case "rangeMultiplier":
instance.rangeMultiplier = reader.Read <System.Single>(ES3Type_float.Instance);
break;
case "intensity":
instance.intensity = reader.Read <UnityEngine.ParticleSystem.MinMaxCurve>(ES3Type_MinMaxCurve.Instance);
break;
case "intensityMultiplier":
instance.intensityMultiplier = reader.Read <System.Single>(ES3Type_float.Instance);
break;
case "maxLights":
instance.maxLights = reader.Read <System.Int32>(ES3Type_int.Instance);
break;
default:
reader.Skip();
break;
}
}
}