/// <summary>
/// Serializes an <see cref="Asset" /> to the specified stream.
/// </summary>
/// <param name="stream">The stream.</param>
/// <param name="asset">The asset object.</param>
/// <param name="yamlMetadata"></param>
/// <param name="log">The logger.</param>
/// <exception cref="System.ArgumentNullException">
/// stream
/// or
/// assetFileExtension
/// </exception>
public static void Save(Stream stream, object asset, AttachedYamlAssetMetadata yamlMetadata, ILogger log = null)
{
if (stream == null)
{
throw new ArgumentNullException(nameof(stream));
}
if (asset == null)
{
return;
}
var assetFileExtension = AssetRegistry.GetDefaultExtension(asset.GetType());
if (assetFileExtension == null)
{
throw new ArgumentException("Unable to find a serializer for the specified asset. No asset file extension registered to AssetRegistry");
}
var serializer = FindSerializer(assetFileExtension);
if (serializer == null)
{
throw new InvalidOperationException($"Unable to find a serializer for [{assetFileExtension}]");
}
serializer.Save(stream, asset, yamlMetadata, log);
}
public object Load(Stream stream, UFile filePath, ILogger log, bool clearBrokenObjectReferences, out bool aliasOccurred, out AttachedYamlAssetMetadata yamlMetadata)
{
aliasOccurred = false;
var assetFileExtension = filePath.GetFileExtension().ToLowerInvariant();
var type = AssetRegistry.GetAssetTypeFromFileExtension(assetFileExtension);
var asset = (SourceCodeAsset)Activator.CreateInstance(type);
var textAccessor = asset.TextAccessor as DefaultTextAccessor;
if (textAccessor != null)
{
// Don't load the file if we have the file path
textAccessor.FilePath = filePath;
// Set the assets text if it loaded from an in-memory version
// TODO: Propagate dirtiness?
if (stream is MemoryStream)
{
var reader = new StreamReader(stream, Encoding.UTF8);
textAccessor.Set(reader.ReadToEnd());
}
}
// No override in source code assets
yamlMetadata = new AttachedYamlAssetMetadata();
return(asset);
}
public AssetLoadResult(T asset, ILogger logger, bool aliasOccurred, AttachedYamlAssetMetadata yamlMetadata)
{
if (yamlMetadata == null)
{
throw new ArgumentNullException(nameof(yamlMetadata));
}
Asset = asset;
Logger = logger;
AliasOccurred = aliasOccurred;
YamlMetadata = yamlMetadata;
}
public static AttachedYamlAssetMetadata CreateAndProcessMetadata(PropertyContainer yamlPropertyContainer, object deserializedObject, bool clearBrokenObjectReferences, [CanBeNull] ILogger log = null)
{
var yamlMetadata = AttachedYamlAssetMetadata.FromPropertyContainer(yamlPropertyContainer);
var objectReferences = yamlMetadata.RetrieveMetadata(AssetObjectSerializerBackend.ObjectReferencesKey);
if (objectReferences != null)
{
// This metadata is consumed here, no need to return it as attached metadata
FixupObjectReferences.RunFixupPass(deserializedObject, objectReferences, clearBrokenObjectReferences, false, log);
}
return(yamlMetadata);
}
public static void SerializeAndCompare(object instance, YamlAssetMetadata <OverrideType> overrides, string expectedYaml)
{
var stream = new MemoryStream();
var metadata = new AttachedYamlAssetMetadata();
metadata.AttachMetadata(AssetObjectSerializerBackend.OverrideDictionaryKey, overrides);
AssetFileSerializer.Default.Save(stream, instance, metadata, null);
stream.Position = 0;
var streamReader = new StreamReader(stream);
var yaml = streamReader.ReadToEnd();
Assert.Equal(expectedYaml, yaml);
}
private static string SerializeAsString(object instance, YamlAssetMetadata <Guid> objectReferences)
{
using (var stream = new MemoryStream())
{
var metadata = new AttachedYamlAssetMetadata();
if (objectReferences != null)
{
metadata.AttachMetadata(AssetObjectSerializerBackend.ObjectReferencesKey, objectReferences);
}
new YamlAssetSerializer().Save(stream, instance, metadata);
stream.Flush();
stream.Position = 0;
return(new StreamReader(stream).ReadToEnd());
}
}
public void Save(Stream stream, object asset, AttachedYamlAssetMetadata yamlMetadata, ILogger log = null)
{
var settings = new SerializerContextSettings(log);
var overrides = yamlMetadata?.RetrieveMetadata(AssetObjectSerializerBackend.OverrideDictionaryKey);
if (overrides != null)
{
settings.Properties.Add(AssetObjectSerializerBackend.OverrideDictionaryKey, overrides);
}
var objectReferences = yamlMetadata?.RetrieveMetadata(AssetObjectSerializerBackend.ObjectReferencesKey);
if (objectReferences != null)
{
settings.Properties.Add(AssetObjectSerializerBackend.ObjectReferencesKey, objectReferences);
}
AssetYamlSerializer.Default.Serialize(stream, asset, null, settings);
}
/// <inheritdoc />
public bool Process(ref object data, AttachedYamlAssetMetadata metadata)
{
if (data is TransformComponent transform)
{
PatchTransformComponent(transform);
return(true);
}
if (data is EntityComponentCollection collection)
{
var processed = false;
foreach (var t in collection.OfType <TransformComponent>())
{
PatchTransformComponent(t);
processed = true;
}
return(processed);
}
return(false);
}
/// <summary>
/// Serializes an <see cref="Asset" /> to the specified file path.
/// </summary>
/// <param name="filePath">The file path.</param>
/// <param name="asset">The asset object.</param>
/// <param name="yamlMetadata"></param>
/// <param name="log">The logger.</param>
/// <exception cref="System.ArgumentNullException">filePath</exception>
public static void Save(string filePath, object asset, AttachedYamlAssetMetadata yamlMetadata, ILogger log = null)
{
if (filePath == null)
{
throw new ArgumentNullException(nameof(filePath));
}
// Creates automatically the directory when saving an asset.
filePath = FileUtility.GetAbsolutePath(filePath);
var directoryPath = Path.GetDirectoryName(filePath);
if (directoryPath != null && !Directory.Exists(directoryPath))
{
Directory.CreateDirectory(directoryPath);
}
using (var stream = new MemoryStream())
{
Save(stream, asset, yamlMetadata, log);
File.WriteAllBytes(filePath, stream.ToArray());
}
}
public void Save(Stream stream, object asset, AttachedYamlAssetMetadata yamlMetadata, ILogger log = null)
{
((SourceCodeAsset)asset).Save(stream);
}
public object Load(Stream stream, UFile filePath, ILogger log, bool clearBrokenObjectReferences, out bool aliasOccurred, out AttachedYamlAssetMetadata yamlMetadata)
{
PropertyContainer properties;
var result = AssetYamlSerializer.Default.Deserialize(stream, null, log != null ? new SerializerContextSettings {
Logger = log
} : null, out aliasOccurred, out properties);
yamlMetadata = CreateAndProcessMetadata(properties, result, clearBrokenObjectReferences, log);
return(result);
}
