public override void Serialize(SiliconStudio.Core.Serialization.Contents.ContentSerializerContext context, SerializationStream stream, ref SamplerState samplerState)
{
if (context.Mode == ArchiveMode.Serialize)
{
var samplerStateDescription = samplerState.Description;
stream.Serialize(ref samplerStateDescription, context.Mode);
}
else
{
var samplerStateDescription = SamplerStateDescription.Default;
stream.Serialize(ref samplerStateDescription, context.Mode);
samplerState = new FakeSamplerState(samplerStateDescription);
}
}
public override object Construct(SiliconStudio.Core.Serialization.Contents.ContentSerializerContext context)
{
return(new Texture(graphicsDevice));
}
public override void Serialize(ContentSerializerContext context, SerializationStream stream, T obj)
{
dataSerializerHelper.Serialize(context, stream, obj);
}
public override object Construct(SiliconStudio.Core.Serialization.Contents.ContentSerializerContext context)
{
return(null);
}
/// <inheritdoc/>
public void Serialize(ContentSerializerContext context, SerializationStream stream, object obj)
{
var objT = (T)obj;
Serialize(context, stream, objT);
}
/// <inheritdoc/>
public virtual void Serialize(ContentSerializerContext context, SerializationStream stream, T obj)
{
}
/// <inheritdoc/>
public virtual object Construct(ContentSerializerContext context)
{
return(hasParameterlessConstructor ? Activator.CreateInstance <T>() : default(T));
}
private void SerializeObject(Queue <SerializeOperation> serializeOperations, string url, object obj, bool publicReference)
{
// Don't create context in case we don't want to serialize referenced objects
//if (!SerializeReferencedObjects && obj != RootObject)
// return null;
// Already saved?
// TODO: Ref counting? Should we change it on save? Probably depends if we cache or not.
if (LoadedAssetReferences.ContainsKey(obj))
{
return;
}
var serializer = Serializer.GetSerializer(null, obj.GetType());
if (serializer == null)
{
throw new InvalidOperationException(string.Format("Content serializer for {0} could not be found.", obj.GetType()));
}
var contentSerializerContext = new ContentSerializerContext(url, ArchiveMode.Serialize, this);
using (var stream = FileProvider.OpenStream(url, VirtualFileMode.Create, VirtualFileAccess.Write))
{
var streamWriter = new BinarySerializationWriter(stream);
PrepareSerializerContext(contentSerializerContext, streamWriter.Context);
ChunkHeader header = null;
// Allocate space in the stream, and also include header version in the hash computation, which is better
// If serialization type is null, it means there should be no header.
var serializationType = serializer.SerializationType;
if (serializationType != null)
{
header = new ChunkHeader();
header.Type = serializer.SerializationType.AssemblyQualifiedName;
header.Write(streamWriter);
header.OffsetToObject = (int)streamWriter.NativeStream.Position;
}
contentSerializerContext.SerializeContent(streamWriter, serializer, obj);
// Write references and updated header
if (header != null)
{
header.OffsetToReferences = (int)streamWriter.NativeStream.Position;
contentSerializerContext.SerializeReferences(streamWriter);
// Move back to the pre-allocated header position in the steam
stream.Seek(0, SeekOrigin.Begin);
// Write actual header.
header.Write(new BinarySerializationWriter(stream));
}
}
var assetReference = new Reference(url, publicReference);
SetAssetObject(assetReference, obj);
// Process content references
// TODO: Should we work at ChunkReference level?
foreach (var contentReference in contentSerializerContext.ContentReferences)
{
if (contentReference.ObjectValue != null)
{
var attachedReference = AttachedReferenceManager.GetAttachedReference(contentReference.ObjectValue);
if (attachedReference == null || attachedReference.IsProxy)
{
continue;
}
serializeOperations.Enqueue(new SerializeOperation(contentReference.Location, contentReference.ObjectValue, false));
}
}
}
private object DeserializeObject(Queue <DeserializeOperation> serializeOperations, Reference parentReference, string url, Type objType, object obj, ContentManagerLoaderSettings settings)
{
// Try to find already loaded object
Reference reference = FindDeserializedObject(url, objType);
if (reference != null && reference.Deserialized)
{
// Add reference
bool isRoot = parentReference == null;
if (isRoot || parentReference.References.Add(reference))
{
IncrementReference(reference, isRoot);
}
return(reference.Object);
}
if (!FileProvider.FileExists(url))
{
HandleAssetNotFound(url);
return(null);
}
ContentSerializerContext contentSerializerContext;
object result;
// Open asset binary stream
try
{
using (var stream = FileProvider.OpenStream(url, VirtualFileMode.Open, VirtualFileAccess.Read))
{
// File does not exist
// TODO/Benlitz: Add a log entry for that, it's not expected to happen
if (stream == null)
{
return(null);
}
Type headerObjType = null;
// Read header
var streamReader = new BinarySerializationReader(stream);
var chunkHeader = ChunkHeader.Read(streamReader);
if (chunkHeader != null)
{
headerObjType = AssemblyRegistry.GetType(chunkHeader.Type);
}
// Find serializer
var serializer = Serializer.GetSerializer(headerObjType, objType);
if (serializer == null)
{
throw new InvalidOperationException(string.Format("Content serializer for {0}/{1} could not be found.", headerObjType, objType));
}
contentSerializerContext = new ContentSerializerContext(url, ArchiveMode.Deserialize, this)
{
LoadContentReferences = settings.LoadContentReferences
};
// Read chunk references
if (chunkHeader != null && chunkHeader.OffsetToReferences != -1)
{
// Seek to where references are stored and deserialize them
streamReader.NativeStream.Seek(chunkHeader.OffsetToReferences, SeekOrigin.Begin);
contentSerializerContext.SerializeReferences(streamReader);
streamReader.NativeStream.Seek(chunkHeader.OffsetToObject, SeekOrigin.Begin);
}
if (reference == null)
{
// Create Reference
reference = new Reference(url, parentReference == null);
result = obj ?? serializer.Construct(contentSerializerContext);
SetAssetObject(reference, result);
}
else
{
result = reference.Object;
}
reference.Deserialized = true;
PrepareSerializerContext(contentSerializerContext, streamReader.Context);
contentSerializerContext.SerializeContent(streamReader, serializer, result);
// Add reference
if (parentReference != null)
{
parentReference.References.Add(reference);
}
}
}
catch (Exception exception)
{
throw new ContentManagerException(string.Format("Unexpected exception while loading asset [{0}]. Reason: {1}. Check inner-exception for details.", url, exception.Message), exception);
}
if (settings.LoadContentReferences)
{
// Process content references
// TODO: Should we work at ChunkReference level?
foreach (var contentReference in contentSerializerContext.ContentReferences)
{
bool shouldBeLoaded = true;
//Reference childReference;
settings.ContentFilter?.Invoke(contentReference, ref shouldBeLoaded);
if (shouldBeLoaded)
{
serializeOperations.Enqueue(new DeserializeOperation(reference, contentReference.Location, contentReference.Type, contentReference.ObjectValue));
}
}
}
return(result);
}