public override object ReadJson(JsonReader reader, Type ty,
object existingValue, JsonSerializer serializer)
{
var bytes = reader.Value as byte[];
if (ty.IsGenericType && ty.GetGenericTypeDefinition() == typeof(SortedMap <,>))
{
// will dispatch to Spreads types
return(Serializer.Deserialize(bytes, ty));
}
// Other than maps, we are cool at arrays. For other types JSON.NET is cool
if (!ty.IsArray)
{
return(serializer.Deserialize(reader, ty));
}
var elTy = ty.GetElementType();
if (BlittableHelper.IsBlittable(elTy)
//|| ty == typeof(DateTimeOffset)
|| ty == typeof(DateTime))
{
//if (bytes == null) {
// return null;
//} else if (bytes.Length == 0) {
// return Array.CreateInstance(ty.GetElementType(), 0);
//}
// will dispatch to Spreads types
return(Serializer.Deserialize(bytes, ty));
}
//var bytes = reader.Value as byte[];
return(serializer.Deserialize(reader, ty));
}
public static AnimationCurveEvaluatorDirectGroup Create <T>()
{
// Those types require interpolators
// TODO: Simple enough for now, but at some point we might want a mechanism to register them externally?
if (typeof(T) == typeof(float))
{
return(new AnimationCurveEvaluatorDirectFloatGroup());
}
if (typeof(T) == typeof(Quaternion))
{
return(new AnimationCurveEvaluatorDirectQuaternionGroup());
}
if (typeof(T) == typeof(Vector3))
{
return(new AnimationCurveEvaluatorDirectVector3Group());
}
if (typeof(T) == typeof(Vector4))
{
return(new AnimationCurveEvaluatorDirectVector4Group());
}
// Blittable
if (BlittableHelper.IsBlittable(typeof(T)))
{
return(new AnimationCurveEvaluatorDirectBlittableGroup <T>());
}
// Objects
return(new AnimationCurveEvaluatorDirectObjectGroup <T>());
}
public override void WriteJson(JsonWriter writer, object value,
JsonSerializer serializer)
{
var ty = value.GetType();
//if (ty.IsGenericType && ty.GetGenericTypeDefinition() == typeof(SortedMap<,>)) {
// // will dispatch to Spreads types
// var bytes = Serializer.Serialize(value); // TODO resolvedCall = true
// writer.WriteValue(bytes);
//}
//// Other than maps, we are cool at arrays. For other types JSON.NET is cool
//if (!ty.IsArray) {
// serializer.Serialize(writer, value);
//}
if (ty.IsArray)
{
var elTy = ty.GetElementType();
if (BlittableHelper.IsBlittable(elTy)
//|| ty == typeof(DateTimeOffset)
|| ty == typeof(DateTime))
{
//var arr = (Array)value;
//if (arr.Length == 0) {
// writer.WriteValue(EmptyArray<byte>.Instance);
//} else {
// will dispatch to Spreads types
var bytes = Serializer.Serialize(value); // TODO resolvedCall = true
writer.WriteValue(bytes);
//}
}
else
{
serializer.Serialize(writer, value);
}
}
else
{
// will dispatch to Spreads types
var bytes = Serializer.Serialize(value); // TODO resolvedCall = true
writer.WriteValue(bytes);
}
}
public static AnimationCurveEvaluatorOptimizedGroup Create <T>()
{
// Those types require interpolators
// TODO: Simple enough for now, but at some point we might want a mechanism to register them externally?
if (typeof(T) == typeof(float))
{
return(new AnimationCurveEvaluatorOptimizedFloatGroup());
}
// TODO: Reintroduces explicit int path for now, since generic path does not work on iOS
if (typeof(T) == typeof(int))
{
return(new AnimationCurveEvaluatorOptimizedIntGroup());
}
if (typeof(T) == typeof(Quaternion))
{
return(new AnimationCurveEvaluatorOptimizedQuaternionGroup());
}
if (typeof(T) == typeof(Vector3))
{
return(new AnimationCurveEvaluatorOptimizedVector3Group());
}
if (typeof(T) == typeof(Vector4))
{
return(new AnimationCurveEvaluatorOptimizedVector4Group());
}
// Blittable
if (BlittableHelper.IsBlittable(typeof(T)))
{
return(new AnimationCurveEvaluatorOptimizedBlittableGroup <T>());
}
// Objects
return(new AnimationCurveEvaluatorOptimizedObjectGroup <T>());
}
protected override sealed JsonConverter ResolveContractConverter(Type ty)
{
// Serialize maps directly
if (ty.IsGenericType && ty.GetGenericTypeDefinition() == typeof(SortedMap <,>))
{
return(new SpreadsJsonConverter());
}
// Other than maps, we are cool at arrays. For other types JSON.NET is cool
if (!ty.IsArray)
{
return(base.ResolveContractConverter(ty));
}
var elTy = ty.GetElementType();
if (BlittableHelper.IsBlittable(elTy) ||
elTy == typeof(DateTimeOffset) ||
elTy == typeof(DateTime))
{
return(new SpreadsJsonConverter());
}
return(base.ResolveContractConverter(ty));
}
public void BlittableDateTimeTest()
{
Assert.True(BlittableHelper.IsBlittable <BlittableDateTime>());
}
public void BlittableCharTest()
{
Assert.True(BlittableHelper.IsBlittable <BlittableChar>());
}
public void DecimalWrapperTest()
{
Assert.False(BlittableHelper.IsBlittable <DecimalWrapper>());
}
public void DecimalTest()
{
Assert.False(BlittableHelper.IsBlittable <decimal>());
}
public void DateTimeTest()
{
Assert.False(BlittableHelper.IsBlittable <DateTime>());
}
public void ArrayTest()
{
Assert.True(BlittableHelper.IsBlittable <int[]>());
}
public void BlittableCompositeTestWrapper()
{
Assert.True(BlittableHelper.IsBlittable <BlittableCompositeWrapper>());
}
public void BlittableDecimalTestWrapper()
{
Assert.True(BlittableHelper.IsBlittable <BlittableDecimalWrapper>());
}
public void BlittableDecimalTest()
{
Assert.True(BlittableHelper.IsBlittable <BlittableDecimal>());
}
public void BooleanTest()
{
Assert.False(BlittableHelper.IsBlittable <bool>());
}
public void BlittableBooleanWrapperTest()
{
Assert.True(BlittableHelper.IsBlittable <BlittableBooleanWrapper>());
}
public void CharTest()
{
Assert.False(BlittableHelper.IsBlittable <char>());
}
public AnimationClipEvaluator CreateEvaluator(AnimationClip clip)
{
// Check if this clip has already been used
if (clips.Add(clip) || clip.ShouldRescanChannels)
{
// If new clip, let's scan its channel to add new ones.
foreach (var curve in clip.Channels)
{
Channel channel;
if (channelsByName.TryGetValue(curve.Key, out channel))
{
// TODO: Check if channel matches
}
else
{
// New channel, add it to every evaluator
// Find blend type
BlendType blendType;
var elementType = curve.Value.ElementType;
if (elementType == typeof(Quaternion))
{
blendType = BlendType.Quaternion;
}
else if (elementType == typeof(float))
{
blendType = BlendType.Float1;
}
else if (elementType == typeof(Vector2))
{
blendType = BlendType.Float2;
}
else if (elementType == typeof(Vector3))
{
blendType = BlendType.Float3;
}
else if (elementType == typeof(Vector4))
{
blendType = BlendType.Float4;
}
else
{
blendType = BlittableHelper.IsBlittable(elementType) ? BlendType.Blit : BlendType.Object;
}
// Create channel structure
channel.BlendType = blendType;
channel.Offset = blendType == BlendType.Object ? objectsSize : structureSize;
channel.PropertyName = curve.Key;
channel.Size = curve.Value.ElementSize;
channel.IsUserCustomProperty = curve.Value.IsUserCustomProperty;
// Add channel
channelsByName.Add(channel.PropertyName, channel);
channels.Add(channel);
if (blendType == BlendType.Object)
{
objectsSize++;
}
else
{
// Update new structure size
// We also reserve space for a float that will specify channel existence and factor in case of subtree blending
structureSize += sizeof(float) + channel.Size;
}
// Add new channel update info to every evaluator
// TODO: Maybe it's better lazily done? (avoid need to store list of all evaluators)
foreach (var currentEvaluator in evaluators)
{
currentEvaluator.AddChannel(ref channel);
}
}
}
}
// Update results to fit the new data size
lock (availableResultsPool)
{
foreach (var result in availableResultsPool)
{
if (result.DataSize < structureSize)
{
result.DataSize = structureSize;
result.Data = new byte[structureSize];
}
}
}
// Create evaluator and store it in list of instantiated evaluators
AnimationClipEvaluator evaluator;
lock (evaluatorPool)
{
if (evaluatorPool.Count > 0)
{
evaluator = evaluatorPool.Pop();
}
else
{
evaluator = new AnimationClipEvaluator();
}
}
evaluator.Initialize(clip, channels);
evaluators.Add(evaluator);
return(evaluator);
}
/// <summary> /// Check if an array is of primtive types, these can be skipped in most processors /// </summary> /// <param name="descriptor"></param> /// <returns></returns> protected bool IsArrayOfPrimitiveType(ArrayDescriptor descriptor) => BlittableHelper.IsBlittable(descriptor.ElementType);