public override void HandleError(SerializeError error)
{
ResolveTypeError resolveTypeError = error as ResolveTypeError;
if (resolveTypeError != null)
{
string fixedTypeId = resolveTypeError.TypeId.Replace('+', '.');
if (fixedTypeId.EndsWith("Duality.Resources.Texture.SizeMode"))
{
resolveTypeError.ResolvedType = typeof(Duality.Drawing.TextureSizeMode);
}
else if (fixedTypeId.EndsWith("Duality.Resources.BatchInfo"))
{
resolveTypeError.ResolvedType = typeof(Duality.Drawing.BatchInfo);
}
else if (fixedTypeId.EndsWith("Duality.Resources.BatchInfo.DirtyFlag"))
{
resolveTypeError.ResolvedType = typeof(Duality.Drawing.BatchInfo).GetTypeInfo().DeclaredNestedTypes.FirstOrDefault(t => t.Name == "DirtyFlag");
}
else if (fixedTypeId.EndsWith("Duality.Drawing.DefaultRendererVisibilityStrategy"))
{
resolveTypeError.ResolvedType = typeof(Duality.Components.DefaultRendererVisibilityStrategy);
}
else if (fixedTypeId.EndsWith("Duality.Resources.Pixmap.Layer"))
{
resolveTypeError.ResolvedType = typeof(Duality.Drawing.PixelData);
}
}
return;
}
public override int GetHashCode()
{
int hash = 1;
if (resultCase_ == ResultOneofCase.ParseError)
{
hash ^= ParseError.GetHashCode();
}
if (resultCase_ == ResultOneofCase.SerializeError)
{
hash ^= SerializeError.GetHashCode();
}
if (resultCase_ == ResultOneofCase.RuntimeError)
{
hash ^= RuntimeError.GetHashCode();
}
if (resultCase_ == ResultOneofCase.ProtobufPayload)
{
hash ^= ProtobufPayload.GetHashCode();
}
if (resultCase_ == ResultOneofCase.JsonPayload)
{
hash ^= JsonPayload.GetHashCode();
}
if (resultCase_ == ResultOneofCase.Skipped)
{
hash ^= Skipped.GetHashCode();
}
hash ^= (int)resultCase_;
return(hash);
}
public override void HandleError(SerializeError error)
{
ResolveTypeError resolveTypeError = error as ResolveTypeError;
if (resolveTypeError != null && resolveTypeError.TypeId.EndsWith("RigidBodyRenderer"))
{
resolveTypeError.ResolvedType = typeof(RigidBodyRenderer);
}
return;
}
private void HandleSerializeError(SerializeError error)
{
if (_logger != null)
{
_logger.WarnFormat("HandleSerializeError: {0}", error);
}
if (SerializeErrored != null)
{
SerializeErrored(this, error);
}
if (_isSendShutdown == false)
{
HandleSocketError(SocketError.NoData);
}
}
public override void HandleError(SerializeError error)
{
ResolveTypeError resolveTypeError = error as ResolveTypeError;
if (resolveTypeError != null)
{
string fixedTypeId = resolveTypeError.TypeId;
if (fixedTypeId.StartsWith("Duality_") &&
fixedTypeId.Length > "Duality_".Length &&
(fixedTypeId["Duality_".Length] == '.' || fixedTypeId["Duality_".Length] == '+'))
{
fixedTypeId = "RogueLite" + fixedTypeId.Remove(0, "Duality_".Length);
resolveTypeError.ResolvedType = ReflectionHelper.ResolveType(fixedTypeId);
}
}
return;
}
public override void HandleError(SerializeError error)
{
AssignFieldError assignFieldError = error as AssignFieldError;
ResolveTypeError resolveTypeError = error as ResolveTypeError;
// BatchInfo uniforms and textures were moved to a nested ShaderParameters
if (assignFieldError != null)
{
BatchInfo batchInfo = assignFieldError.TargetObject as BatchInfo;
if (batchInfo != null)
{
if (assignFieldError.FieldName == "uniforms")
{
Dictionary <string, float[]> uniforms = assignFieldError.FieldValue as Dictionary <string, float[]>;
if (uniforms != null)
{
foreach (var pair in uniforms)
{
batchInfo.SetArray(pair.Key, pair.Value);
}
assignFieldError.AssignSuccess = true;
}
}
else if (assignFieldError.FieldName == "textures")
{
Dictionary <string, ContentRef <Texture> > textures = assignFieldError.FieldValue as Dictionary <string, ContentRef <Texture> >;
if (textures != null)
{
foreach (var pair in textures)
{
ContentRef <Texture> texRef = pair.Value;
texRef.EnsureLoaded();
batchInfo.SetTexture(pair.Key, texRef);
}
assignFieldError.AssignSuccess = true;
}
}
}
}
return;
}
public override void HandleError(SerializeError error)
{
AssignFieldError fieldError = error as AssignFieldError;
if (fieldError != null && fieldError.TargetObjectType.Type.AsType() == typeof(Sound))
{
Sound targetObject = fieldError.TargetObject as Sound;
if (targetObject != null)
{
// ContentRef<AudioData> audioData --> List<ContentRef<AudioData>> audioData
if (fieldError.FieldName == "audioData" && fieldError.FieldValue is ContentRef <AudioData> )
{
targetObject.MainData = (ContentRef <AudioData>)fieldError.FieldValue;
fieldError.AssignSuccess = true;
}
}
}
return;
}
public override void HandleError(SerializeError error)
{
AssignFieldError assignFieldError = error as AssignFieldError;
if (assignFieldError == null)
{
return;
}
// RigidBody."continous" was renamed to "useCCD"
RigidBody body = assignFieldError.TargetObject as RigidBody;
if (body != null && assignFieldError.FieldName == "continous")
{
body.ContinousCollision = (bool)assignFieldError.FieldValue;
assignFieldError.AssignSuccess = true;
}
return;
}
public override void HandleError(SerializeError error)
{
ResolveTypeError resolveTypeError = error as ResolveTypeError;
if (resolveTypeError != null)
{
if (resolveTypeError.TypeId == TestResolveTypeId)
{
resolveTypeError.ResolvedType = TestResolveType;
}
}
ResolveMemberError resolveMemberError = error as ResolveMemberError;
if (resolveMemberError != null)
{
if (resolveMemberError.MemberId == TestResolveMemberId)
{
resolveMemberError.ResolvedMember = TestResolveMember;
}
}
return;
}
public override void HandleError(SerializeError error)
{
AssignFieldError fieldError = error as AssignFieldError;
if (fieldError != null && fieldError.TargetObject is JointInfo)
{
RigidBody target = fieldError.FieldValue as RigidBody;
JointInfo joint = fieldError.TargetObject as JointInfo;
bool other = false;
FieldInfo field = null;
if (fieldError.FieldName == "colA")
{
field = fieldError.TargetObjectType.Fields.FirstOrDefault(f => f.Name == "parentBody");
}
else if (fieldError.FieldName == "colB")
{
field = fieldError.TargetObjectType.Fields.FirstOrDefault(f => f.Name == "otherBody");
other = true;
}
if (field != null)
{
if (other)
{
FieldInfo jointsField = typeof(RigidBody).GetField("joints", BindingFlags.Instance | BindingFlags.NonPublic);
IList <JointInfo> jointList = jointsField.GetValue(target) as IList <JointInfo>;
jointList.Remove(joint);
}
field.SetValue(fieldError.TargetObject, fieldError.FieldValue);
fieldError.AssignSuccess = true;
}
}
return;
}
public override void HandleError(SerializeError error)
{
ResolveTypeError resolveTypeError = error as ResolveTypeError;
ResolveMemberError resolveMemberError = error as ResolveMemberError;
// From v2 to v3, a lot of Duality types were renamed or moved
if (resolveTypeError != null)
{
switch (resolveTypeError.TypeId)
{
case "Duality.Resources.BatchInfo": resolveTypeError.ResolvedType = typeof(Duality.Drawing.BatchInfo); break;
case "Duality.Resources.BatchInfo+DirtyFlag": resolveTypeError.ResolvedType = typeof(ObsoleteEnum); break;
case "Duality.Resources.Pixmap+Layer": resolveTypeError.ResolvedType = typeof(Duality.Drawing.PixelData); break;
case "Duality.Drawing.IRendererVisibilityStrategy": resolveTypeError.ResolvedType = typeof(Duality.Components.IRendererVisibilityStrategy); break;
case "Duality.Drawing.DefaultRendererVisibilityStrategy": resolveTypeError.ResolvedType = typeof(Duality.Components.DefaultRendererVisibilityStrategy); break;
case "Duality.Components.Renderers.AnimSpriteRenderer": resolveTypeError.ResolvedType = typeof(Duality.Components.Renderers.SpriteRenderer); break;
}
}
else if (resolveMemberError != null)
{
switch (resolveMemberError.MemberId)
{
case "P:Duality.Components.Transform:RelativePos": resolveMemberError.ResolvedMember = typeof(Duality.Components.Transform).GetRuntimeProperty("LocalPos"); break;
case "P:Duality.Components.Transform:RelativeAngle": resolveMemberError.ResolvedMember = typeof(Duality.Components.Transform).GetRuntimeProperty("LocalAngle"); break;
case "P:Duality.Components.Transform:RelativeScale": resolveMemberError.ResolvedMember = typeof(Duality.Components.Transform).GetRuntimeProperty("LocalScale"); break;
}
}
return;
}
private void HandleSerializeError(SerializeError error)
{
if (_logger != null)
_logger.WarnFormat("HandleSerializeError: {0}", error);
if (SerializeErrored != null)
SerializeErrored(this, error);
if (_isSendShutdown == false)
HandleSocketError(SocketError.NoData);
}
public override void HandleError(SerializeError error)
{
ResolveTypeError resolveTypeError = error as ResolveTypeError;
if (resolveTypeError != null)
{
string fixedTypeId = resolveTypeError.TypeId;
if (fixedTypeId.EndsWith("Duality.VertexFormat.VertexC1P3"))
{
resolveTypeError.ResolvedType = typeof(Duality.Drawing.VertexC1P3);
}
else if (fixedTypeId.EndsWith("Duality.VertexFormat.VertexC1P3T2"))
{
resolveTypeError.ResolvedType = typeof(Duality.Drawing.VertexC1P3T2);
}
else if (fixedTypeId.EndsWith("Duality.VertexFormat.VertexC1P3T4A1"))
{
resolveTypeError.ResolvedType = typeof(Duality.Drawing.VertexC1P3T4A1);
}
else if (fixedTypeId.EndsWith("Duality.VertexFormat.IVertexData"))
{
resolveTypeError.ResolvedType = typeof(Duality.Drawing.IVertexData);
}
else if (fixedTypeId.EndsWith("Duality.ColorFormat.ColorHsva"))
{
resolveTypeError.ResolvedType = typeof(Duality.Drawing.ColorHsva);
}
else if (fixedTypeId.EndsWith("Duality.ColorFormat.ColorRgba"))
{
resolveTypeError.ResolvedType = typeof(Duality.Drawing.ColorRgba);
}
else if (fixedTypeId.EndsWith("Duality.ColorFormat.IColorData"))
{
resolveTypeError.ResolvedType = typeof(Duality.Drawing.IColorData);
}
else if (fixedTypeId.EndsWith("Duality.VisibilityFlag"))
{
resolveTypeError.ResolvedType = typeof(Duality.Drawing.VisibilityFlag);
}
else if (fixedTypeId.EndsWith("Duality.VertexMode"))
{
resolveTypeError.ResolvedType = typeof(Duality.Drawing.VertexMode);
}
else if (fixedTypeId.EndsWith("Duality.RenderMatrix"))
{
resolveTypeError.ResolvedType = typeof(Duality.Drawing.RenderMatrix);
}
else if (fixedTypeId.EndsWith("Duality.PerspectiveMode"))
{
resolveTypeError.ResolvedType = typeof(Duality.Drawing.PerspectiveMode);
}
else if (fixedTypeId.EndsWith("Duality.DashPattern"))
{
resolveTypeError.ResolvedType = typeof(Duality.Drawing.DashPattern);
}
else if (fixedTypeId.EndsWith("Duality.ClearFlag"))
{
resolveTypeError.ResolvedType = typeof(Duality.Drawing.ClearFlag);
}
else if (fixedTypeId.EndsWith("Duality.BlendMode"))
{
resolveTypeError.ResolvedType = typeof(Duality.Drawing.BlendMode);
}
else if (fixedTypeId.EndsWith("Duality.Canvas"))
{
resolveTypeError.ResolvedType = typeof(Duality.Drawing.Canvas);
}
else if (fixedTypeId.EndsWith("Duality.CanvasState"))
{
resolveTypeError.ResolvedType = typeof(Duality.Drawing.CanvasState);
}
else if (fixedTypeId.EndsWith("Duality.CanvasBuffer"))
{
resolveTypeError.ResolvedType = typeof(Duality.Drawing.CanvasBuffer);
}
else if (fixedTypeId.EndsWith("Duality.DrawDevice"))
{
resolveTypeError.ResolvedType = typeof(Duality.Drawing.DrawDevice);
}
else if (fixedTypeId.EndsWith("Duality.IDrawDevice"))
{
resolveTypeError.ResolvedType = typeof(Duality.Drawing.IDrawDevice);
}
else if (fixedTypeId.EndsWith("Duality.Profiling.Profile"))
{
resolveTypeError.ResolvedType = typeof(Duality.Profile);
}
else if (fixedTypeId.EndsWith("Duality.Profiling.ProfileCounter"))
{
resolveTypeError.ResolvedType = typeof(Duality.ProfileCounter);
}
else if (fixedTypeId.EndsWith("Duality.Profiling.ReportCounterData"))
{
resolveTypeError.ResolvedType = typeof(Duality.ProfileReportCounterData);
}
else if (fixedTypeId.EndsWith("Duality.Profiling.ReportOptions"))
{
resolveTypeError.ResolvedType = typeof(Duality.ProfileReportOptions);
}
else if (fixedTypeId.EndsWith("Duality.Profiling.StatCounter"))
{
resolveTypeError.ResolvedType = typeof(Duality.StatCounter);
}
else if (fixedTypeId.EndsWith("Duality.Profiling.TimeCounter"))
{
resolveTypeError.ResolvedType = typeof(Duality.TimeCounter);
}
else if (fixedTypeId.Contains("Duality.FormattedText") && !fixedTypeId.Contains("Duality.Drawing.FormattedText"))
{
resolveTypeError.ResolvedType = ReflectionHelper.ResolveType(
fixedTypeId.Replace("Duality.FormattedText", "Duality.Drawing.FormattedText"),
false);
}
}
return;
}