public void DeserializeBeforeRef(UABUnpacker unpacker, UABField field, ref object value, List <ISerializer> serializers)
{
var data = new Data();
unpacker.Deserialize(data, field.fields, serializers);
value = MeshSerializerHelper.ReadMesh(System.Convert.FromBase64String(field.data));
}
public void DeserializeBeforeRef(UABUnpacker unpacker, UABField field, ref object value, List <ISerializer> serializers)
{
var data = new Data();
unpacker.Deserialize(data, field.fields, serializers);
if (data.colorKeys == null)
{
data.colorKeys = new GradientColorKey[0];
}
if (data.alphaKeys == null)
{
data.alphaKeys = new GradientAlphaKey[0];
}
#if UNITY_5_5_OR_NEWER
value = new Gradient()
{
mode = data.mode, colorKeys = data.colorKeys, alphaKeys = data.alphaKeys
};
#else
value = new Gradient()
{
colorKeys = data.colorKeys, alphaKeys = data.alphaKeys
};
#endif
}
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 RectOffset(data.x, data.y, data.z, data.w);
}
public void Serialize(UABPacker packer, UABField field, ref object value, List <ISerializer> serializers)
{
field.serializatorId = this.GetId();
field.fieldType = FieldType.BinaryType;
var sprite = (value as Sprite);
if (packer == null)
{
#if UNITY_EDITOR
var oldReadable = TextureSerializerHelper.PrepareForEncode(sprite.texture);
var bytes = sprite.texture.EncodeToPNG();
TextureSerializerHelper.CompleteEncoding(sprite.texture, oldReadable);
field.data = System.Convert.ToBase64String(bytes);
#endif
}
else
{
var data = new Data();
data.spriteRect = sprite.rect;
data.spritePivot = sprite.pivot;
data.spritePixelsPerUnit = sprite.pixelsPerUnit;
data.spriteExtrude = 0u;
data.spriteMeshType = SpriteMeshType.FullRect;
data.spriteBorder = sprite.border;
field.fields = packer.Serialize(data, serializers);
}
}
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 AnimationCurve(data.keys);
}
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 Color32(data.r, data.g, data.b, data.a);
}
public void DeserializeBeforeRef(UABUnpacker unpacker, UABField field, ref object value, List <ISerializer> serializers)
{
var data = new Data();
unpacker.Deserialize(data, field.fields, serializers);
var ps = value as ParticleSystem;
#if UNITY_5_5_OR_NEWER
ps.useAutoRandomSeed = data.useAutoRandomSeed;
if (ps.useAutoRandomSeed == false)
{
ps.randomSeed = data.randomSeed;
}
#endif
#if UNITY_5_5_OR_NEWER
UABUtils.CopyToParticleSystemModule(data.main, ps.main);
{
UABUtils.CopyToParticleSystemModule(data.emission.data, ps.emission);
var bursts = new UnityEngine.ParticleSystem.Burst[data.emission.bursts.Length];
for (int i = 0; i < data.emission.bursts.Length; ++i)
{
bursts[i] = UABUtils.CopyToParticleSystemModule(data.emission.bursts[i], bursts[i]);
}
ps.emission.SetBursts(bursts, data.emission.bursts.Length);
}
#endif
UABUtils.CopyToParticleSystemModule(data.shape, ps.shape);
UABUtils.CopyToParticleSystemModule(data.velocityOverLifetime, ps.velocityOverLifetime);
UABUtils.CopyToParticleSystemModule(data.limitVelocityOverLifetime, ps.limitVelocityOverLifetime);
UABUtils.CopyToParticleSystemModule(data.inheritVelocity, ps.inheritVelocity);
UABUtils.CopyToParticleSystemModule(data.forceOverLifetime, ps.forceOverLifetime);
UABUtils.CopyToParticleSystemModule(data.colorOverLifetime, ps.colorOverLifetime);
UABUtils.CopyToParticleSystemModule(data.sizeOverLifetime, ps.sizeOverLifetime);
UABUtils.CopyToParticleSystemModule(data.sizeBySpeed, ps.sizeBySpeed);
UABUtils.CopyToParticleSystemModule(data.rotationOverLifetime, ps.rotationOverLifetime);
UABUtils.CopyToParticleSystemModule(data.rotationBySpeed, ps.rotationBySpeed);
UABUtils.CopyToParticleSystemModule(data.externalForces, ps.externalForces);
UABUtils.CopyToParticleSystemModule(data.rotationBySpeed, ps.rotationBySpeed);
#if UNITY_5_5_OR_NEWER
UABUtils.CopyToParticleSystemModule(data.noise, ps.noise);
#endif
UABUtils.CopyToParticleSystemModule(data.collision, ps.collision);
#if UNITY_5_5_OR_NEWER
UABUtils.CopyToParticleSystemModule(data.trigger, ps.trigger);
{
UABUtils.CopyToParticleSystemModule(data.subEmitters.data, ps.subEmitters);
for (int i = 0; i < data.subEmitters.subEmitters.Length; ++i)
{
ps.subEmitters.AddSubEmitter(data.subEmitters.subEmitters[i], data.subEmitters.types[i], data.subEmitters.properties[i]);
}
}
//UABUtils.CopyToParticleSystemModule(data.textureSheetAnimation, ps.textureSheetAnimation);
UABUtils.CopyToParticleSystemModule(data.lights, ps.lights);
UABUtils.CopyToParticleSystemModule(data.trails, ps.trails);
#endif
}
public void Serialize(UABPacker packer, UABField field, ref object value, List <ISerializer> serializers)
{
field.serializatorId = this.GetId();
var data = new Data();
var tr = value as AnimationCurve;
data.keys = tr.keys;
field.fields = packer.Serialize(data, serializers);
}
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 GradientColorKey()
{
color = data.color, time = data.time
};
}
public void DeserializeBeforeRef(UABUnpacker unpacker, UABField field, ref object value, List <ISerializer> serializers)
{
var data = new Data();
unpacker.Deserialize(data, field.fields, serializers);
#if UNITY_5_5_OR_NEWER
value = new UnityEngine.AI.NavMeshPath();
#else
value = new UnityEngine.NavMeshPath();
#endif
}
public void DeserializeBeforeRef(UABUnpacker unpacker, UABField field, ref object value, List <ISerializer> serializers)
{
var data = new Data();
unpacker.Deserialize(data, field.fields, serializers);
var tr = value as Transform;
tr.localPosition = data.position;
tr.localEulerAngles = data.rotation;
tr.localScale = data.scale;
}
public void Serialize(UABPacker packer, UABField field, ref object value, List <ISerializer> serializers)
{
field.serializatorId = this.GetId();
var tr = value as Transform;
var data = new Data();
data.position = tr.localPosition;
data.rotation = tr.localEulerAngles;
data.scale = tr.localScale;
field.fields = packer.Serialize(data, serializers);
}
public void Serialize(UABPacker packer, UABField field, ref object value, List <ISerializer> serializers)
{
field.serializatorId = this.GetId();
var tr = value as RectOffset;
var data = new Data();
data.x = tr.left;
data.y = tr.right;
data.z = tr.top;
data.w = tr.bottom;
field.fields = packer.Serialize(data, serializers);
}
public void DeserializeBeforeRef(UABUnpacker unpacker, UABField field, ref object value, List <ISerializer> serializers)
{
var data = new Data();
unpacker.Deserialize(data, field.fields, serializers);
var textureData = System.Convert.FromBase64String(field.data);
var tex = new Texture2D(1, 1);
tex.LoadImage(textureData);
tex.Apply(updateMipmaps: true, makeNoLongerReadable: true);
value = tex;
}
public void Serialize(UABPacker packer, UABField field, ref object value, List <ISerializer> serializers)
{
field.serializatorId = this.GetId();
var v = (Gradient)value;
var data = new Data();
#if UNITY_5_5_OR_NEWER
data.mode = v.mode;
#endif
data.colorKeys = v.colorKeys;
data.alphaKeys = v.alphaKeys;
field.fields = packer.Serialize(data, serializers);
}
public void DeserializeBeforeRef(UABUnpacker unpacker, UABField field, ref object value, List <ISerializer> serializers)
{
var data = new Data();
unpacker.Deserialize(data, field.fields, serializers);
var textureData = System.Convert.FromBase64String(field.data);
var tex = new Texture2D(1, 1);
tex.LoadImage(textureData);
tex.Apply(updateMipmaps: true, makeNoLongerReadable: true);
var sprite = Sprite.Create(tex, data.spriteRect, data.spritePivot, data.spritePixelsPerUnit, data.spriteExtrude, data.spriteMeshType, data.spriteBorder);
value = sprite;
}
public void Serialize(UABPacker packer, UABField field, ref object value, List <ISerializer> serializers)
{
field.serializatorId = this.GetId();
var animator = value as Animator;
var data = new Data();
data.avatar = animator.avatar;
data.runtimeAnimatorController = animator.runtimeAnimatorController;
data.cullingMode = animator.cullingMode;
data.updateMode = animator.updateMode;
data.applyRootMotion = animator.applyRootMotion;
data.linearVelocityBlending = animator.linearVelocityBlending;
field.fields = packer.Serialize(data, serializers);
}
public void DeserializeBeforeRef(UABUnpacker unpacker, UABField field, ref object value, List <ISerializer> serializers)
{
var data = new Data();
unpacker.Deserialize(data, field.fields, serializers);
var animator = value as Animator;
animator.avatar = data.avatar;
animator.runtimeAnimatorController = data.runtimeAnimatorController;
animator.cullingMode = data.cullingMode;
animator.updateMode = data.updateMode;
animator.applyRootMotion = data.applyRootMotion;
animator.linearVelocityBlending = data.linearVelocityBlending;
}
public void DeserializeBeforeRef(UABUnpacker unpacker, UABField field, ref object value, List <ISerializer> serializers)
{
var data = new Data();
unpacker.Deserialize(data, field.fields, serializers);
var tr = value as RectTransform;
tr.localPosition = data.position;
tr.localEulerAngles = data.rotation;
tr.localScale = data.scale;
tr.anchoredPosition = data.anchoredPosition;
tr.anchorMax = data.anchorMin;
tr.anchorMin = data.anchorMax;
tr.sizeDelta = data.sizeDelta;
tr.pivot = data.pivot;
}
public void Serialize(UABPacker packer, UABField field, ref object value, List <ISerializer> serializers)
{
field.serializatorId = this.GetId();
var tr = value as RectTransform;
var data = new Data();
data.position = tr.localPosition;
data.rotation = tr.localEulerAngles;
data.scale = tr.localScale;
data.anchoredPosition = tr.anchoredPosition;
data.anchorMax = tr.anchorMin;
data.anchorMin = tr.anchorMax;
data.sizeDelta = tr.sizeDelta;
data.pivot = tr.pivot;
field.fields = packer.Serialize(data, serializers);
}
public void Serialize(UABPacker packer, UABField field, ref object value, List <ISerializer> serializers)
{
field.serializatorId = this.GetId();
field.fieldType = FieldType.BinaryType;
if (packer == null)
{
var bytes = MeshSerializerHelper.WriteMesh(value as Mesh, saveTangents: true);
if (bytes != null)
{
field.data = System.Convert.ToBase64String(bytes);
}
}
else
{
var data = new Data();
field.fields = packer.Serialize(data, serializers);
}
}
public void Serialize(UABPacker packer, UABField field, ref object value, List <ISerializer> serializers)
{
field.serializatorId = this.GetId();
var data = new Data();
var tr = (UnityEngine.ParticleSystem.MinMaxGradient)value;
data.mode = tr.mode;
#if UNITY_5_5_OR_NEWER
data.color = tr.color;
#endif
data.colorMin = tr.colorMin;
data.colorMax = tr.colorMax;
#if UNITY_5_5_OR_NEWER
data.gradient = tr.gradient;
#endif
data.gradientMin = tr.gradientMin;
data.gradientMax = tr.gradientMax;
field.fields = packer.Serialize(data, serializers);
}
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,
};
}
public void Serialize(UABPacker packer, UABField field, ref object value, List <ISerializer> serializers)
{
field.serializatorId = this.GetId();
field.fieldType = FieldType.BinaryType;
if (packer == null)
{
#if UNITY_EDITOR
var oldReadable = TextureSerializerHelper.PrepareForEncode(value as Texture);
var texture = (value as Texture2D);
var bytes = texture.EncodeToPNG();
TextureSerializerHelper.CompleteEncoding(texture, oldReadable);
field.data = System.Convert.ToBase64String(bytes);
#endif
}
else
{
var data = new Data();
field.fields = packer.Serialize(data, serializers);
}
}
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.MinMaxCurve()
{
mode = data.mode,
#if UNITY_5_5_OR_NEWER
constant = data.constant,
#endif
constantMin = data.constantMin,
constantMax = data.constantMax,
#if UNITY_5_5_OR_NEWER
curve = data.curve,
#endif
curveMin = data.curveMin,
curveMax = data.curveMax,
#if UNITY_5_5_OR_NEWER
curveMultiplier = data.curveMultiplier,
#endif
};
}
public void DeserializeBeforeRef(UABUnpacker unpacker, UABField field, ref object value, List <ISerializer> serializers)
{
var keyFrame = new Keyframe();
value = unpacker.Deserialize(keyFrame, field.fields, serializers);
}
public void Serialize(UABPacker packer, UABField field, ref object value, List <ISerializer> serializers)
{
field.serializatorId = this.GetId();
var ps = value as ParticleSystem;
var data = new Data();
#if UNITY_5_5_OR_NEWER
data.useAutoRandomSeed = ps.useAutoRandomSeed;
if (data.useAutoRandomSeed == false)
{
data.randomSeed = ps.randomSeed;
}
else
{
data.randomSeed = 0;
}
#endif
#if UNITY_5_5_OR_NEWER
data.main = UABUtils.CopyFromParticleSystemModule(ps.main, data.main);
{
data.emission.data = UABUtils.CopyFromParticleSystemModule(ps.emission, data.emission.data);
var bursts = new UnityEngine.ParticleSystem.Burst[ps.emission.burstCount];
ps.emission.GetBursts(bursts);
data.emission.bursts = new Data.EmissionModule.Burst[bursts.Length];
for (int i = 0; i < bursts.Length; ++i)
{
data.emission.bursts[i] = new Data.EmissionModule.Burst();
UABUtils.CopyFromParticleSystemModule(bursts[i], data.emission.bursts[i]);
}
}
#endif
data.shape = UABUtils.CopyFromParticleSystemModule(ps.shape, data.shape);
data.velocityOverLifetime = UABUtils.CopyFromParticleSystemModule(ps.velocityOverLifetime, data.velocityOverLifetime);
data.limitVelocityOverLifetime = UABUtils.CopyFromParticleSystemModule(ps.limitVelocityOverLifetime, data.limitVelocityOverLifetime);
data.inheritVelocity = UABUtils.CopyFromParticleSystemModule(ps.inheritVelocity, data.inheritVelocity);
data.forceOverLifetime = UABUtils.CopyFromParticleSystemModule(ps.forceOverLifetime, data.forceOverLifetime);
data.colorOverLifetime = UABUtils.CopyFromParticleSystemModule(ps.colorOverLifetime, data.colorOverLifetime);
data.colorOverLifetime = UABUtils.CopyFromParticleSystemModule(ps.colorOverLifetime, data.colorOverLifetime);
data.sizeOverLifetime = UABUtils.CopyFromParticleSystemModule(ps.sizeOverLifetime, data.sizeOverLifetime);
data.sizeBySpeed = UABUtils.CopyFromParticleSystemModule(ps.sizeBySpeed, data.sizeBySpeed);
data.rotationOverLifetime = UABUtils.CopyFromParticleSystemModule(ps.rotationOverLifetime, data.rotationOverLifetime);
data.rotationBySpeed = UABUtils.CopyFromParticleSystemModule(ps.rotationBySpeed, data.rotationBySpeed);
data.externalForces = UABUtils.CopyFromParticleSystemModule(ps.externalForces, data.externalForces);
data.rotationBySpeed = UABUtils.CopyFromParticleSystemModule(ps.rotationBySpeed, data.rotationBySpeed);
#if UNITY_5_5_OR_NEWER
data.noise = UABUtils.CopyFromParticleSystemModule(ps.noise, data.noise);
#endif
data.collision = UABUtils.CopyFromParticleSystemModule(ps.collision, data.collision);
#if UNITY_5_5_OR_NEWER
data.trigger = UABUtils.CopyFromParticleSystemModule(ps.trigger, data.trigger);
{
data.subEmitters.data = UABUtils.CopyFromParticleSystemModule(ps.subEmitters, data.subEmitters.data);
data.subEmitters.subEmitters = new ParticleSystem[ps.subEmitters.subEmittersCount];
data.subEmitters.properties = new ParticleSystemSubEmitterProperties[ps.subEmitters.subEmittersCount];
data.subEmitters.types = new ParticleSystemSubEmitterType[ps.subEmitters.subEmittersCount];
for (int i = 0; i < ps.subEmitters.subEmittersCount; ++i)
{
data.subEmitters.subEmitters[i] = ps.subEmitters.GetSubEmitterSystem(i);
data.subEmitters.properties[i] = ps.subEmitters.GetSubEmitterProperties(i);
data.subEmitters.types[i] = ps.subEmitters.GetSubEmitterType(i);
}
}
#endif
data.textureSheetAnimation = UABUtils.CopyFromParticleSystemModule(ps.textureSheetAnimation, data.textureSheetAnimation);
#if UNITY_5_5_OR_NEWER
data.lights = UABUtils.CopyFromParticleSystemModule(ps.lights, data.lights);
data.trails = UABUtils.CopyFromParticleSystemModule(ps.trails, data.trails);
#endif
field.fields = packer.Serialize(data, serializers);
}
public void Serialize(UABPacker packer, UABField field, ref object value, List <ISerializer> serializers)
{
field.serializatorId = this.GetId();
field.fields = packer.Serialize(value, serializers);
}
