/// <inheritdoc/>
public override void Serialize(ref EffectParameterKeyStandardGenerator obj, ArchiveMode mode, SerializationStream stream)
{
if (mode == ArchiveMode.Serialize)
{
stream.Write(obj.Count);
foreach (var item in obj)
{
stream.SerializeExtended(item.Key, mode);
var valueType = item.Value.GetType();
if (valueType.IsGenericType && valueType.GetGenericTypeDefinition() == typeof(EffectParameterValuesGenerator <>))
{
var value = (IEffectParameterValueGenerator)item.Value;
var count = value.GenerateValues(item.Key).Count();
stream.Write(count);
foreach (var item2 in value.GenerateValues(item.Key))
{
stream.SerializeExtended(item2, mode);
}
}
else
{
stream.SerializeExtended(item.Value, mode);
}
}
}
else if (mode == ArchiveMode.Deserialize)
{
throw new NotImplementedException();
}
}
public override void Serialize(ref ParameterCollectionData obj, ArchiveMode mode, SerializationStream stream)
{
if (mode == ArchiveMode.Deserialize)
{
// Should be null if it was
int count = stream.ReadInt32();
for (int i = 0; i < count; ++i)
{
ParameterKey key = null;
object value = null;
bool matchingType = false;
stream.SerializeExtended(ref key, mode);
stream.Serialize(ref matchingType);
var valueType = matchingType ? key.PropertyType : typeof(object);
if (reuseReferences)
{
MemberReuseSerializer.SerializeExtended(stream, valueType, ref value, mode);
}
else
{
MemberNonSealedSerializer.SerializeExtended(stream, valueType, ref value, mode);
}
obj.Add(key, value);
}
}
else if (mode == ArchiveMode.Serialize)
{
stream.Write(obj.Count);
foreach (var item in obj)
{
var key = item.Key;
// When serializing convert the value type to the expecting type
// This should probably better done at the source (when creating/filling the ParameterCollectionData)
var value = item.Key.ConvertValue(item.Value);
stream.SerializeExtended(ref key, mode);
bool matchingType = value.GetType().GetTypeInfo().IsAssignableFrom(key.PropertyType.GetTypeInfo());
stream.Serialize(ref matchingType);
var valueType = matchingType ? key.PropertyType : typeof(object);
if (reuseReferences)
{
MemberReuseSerializer.SerializeExtended(stream, valueType, ref value, mode);
}
else
{
MemberNonSealedSerializer.SerializeExtended(stream, valueType, ref value, mode);
}
}
}
}
public override void Serialize(ref AssetBase assetBase, ArchiveMode mode, SerializationStream stream)
{
if (mode == ArchiveMode.Serialize)
{
stream.Write(assetBase.Location);
stream.SerializeExtended(assetBase.Asset, mode);
}
else
{
var location = stream.ReadString();
Asset asset = null;
stream.SerializeExtended(ref asset, mode);
assetBase = new AssetBase(location, asset);
}
}
public override void Serialize(ref EntityComponent obj, ArchiveMode mode, SerializationStream stream)
{
var entity = obj.Entity;
// Force containing Entity to be collected by serialization, no need to reassign it to EntityComponent.Entity
stream.SerializeExtended(ref entity, mode);
}
public override void Serialize(ContentSerializerContext context, SerializationStream stream, ref T obj)
{
// Get serializer
// TODO: Cache it? Need to make sure it doesn't end up being different between different serialization mode.
var dataSerializer = stream.Context.SerializerSelector.GetSerializer <T>();
// Serialize object
stream.SerializeExtended(ref obj, context.Mode, dataSerializer);
}
public override void Serialize(ref EntityComponent obj, ArchiveMode mode, SerializationStream stream)
{
var entity = obj.Entity;
// Force containing Entity to be collected by serialization, no need to reassign it to EntityComponent.Entity
stream.SerializeExtended(ref entity, mode);
// Serialize Id
var id = obj.Id;
guidSerializer.Serialize(ref id, mode, stream);
if (mode == ArchiveMode.Deserialize)
{
obj.Id = id;
}
}
public void Serialize(ContentSerializerContext context, SerializationStream stream, T obj)
{
// Get serializer
// Note: Currently registered serializer is the content reference one
// However, we would like to serialize the actual type here
if (dataSerializer == null)
{
var dataSerializerType = DataSerializerFactory.GetSerializer("Default", typeof(T)).SerializerType;
if (dataSerializerType == null)
{
throw new InvalidOperationException($"Could not find a serializer for type {typeof(T)}");
}
dataSerializer = (DataSerializer <T>)Activator.CreateInstance(dataSerializerType);
dataSerializer.Initialize(stream.Context.SerializerSelector);
}
// Serialize object
stream.SerializeExtended(ref obj, context.Mode, dataSerializer);
}
public override void Serialize(ref ParameterCollection parameterCollection, ArchiveMode mode, SerializationStream stream)
{
stream.Serialize(ref parameterCollection.parameterKeyInfos, mode);
stream.SerializeExtended(ref parameterCollection.ObjectValues, mode);
stream.Serialize(ref parameterCollection.DataValues, mode);
}
public override void Serialize(ref PropertyContainer propertyCollection, ArchiveMode mode, SerializationStream stream)
{
stream.SerializeExtended(ref propertyCollection.properties, mode);
}
