public static InitializeRequest Initialize(bool forceAssetBundle, IAssetPathProvider pathProvider)
{
if (pathProvider != null)
{
PathProvider = pathProvider;
}
if (assetProvider != null)
{
if ((forceAssetBundle && assetProvider is AssetDatabaseAssetProvider) || (!forceAssetBundle && assetProvider is AssetBundleAssetProvider))
{
Destroy();
}
}
#if UNITY_EDITOR
//仅编辑器模式下才可以使用AssetDatabase进行加载
if (assetProvider == null && !forceAssetBundle)
{
assetProvider = new AssetDatabaseAssetProvider();
}
#endif
if (assetProvider == null)
{
assetProvider = new AssetBundleAssetProvider();
}
return(assetProvider.Initialize());
}
} // Default to writing current version
public LevelSerializeContext(BinaryWriter bw, ImageWriter imageWriter, IAssetPathProvider assetPathProvider, int version)
{
this.bw = bw;
this.assetPathProvider = assetPathProvider;
this.Version = version;
if (Version > LevelSerializeContext.formatVersion)
{
throw new Exception("Tried to save Level with a version that is too new");
}
if (Version < 13)
{
throw new Exception("Level version too old!");
}
bw.Write(Version);
animationSerializeContext = new AnimationSerializeContext(bw, imageWriter); // <- writes out animation version number
}
public void WriteToFile(string path, IAssetPathProvider assetPathProvider)
{
// Write out textures...
ImageWriter imageWriter = new ImageWriter();
this.RegisterImages(imageWriter, assetPathProvider);
string texturePath = System.IO.Path.ChangeExtension(path, ".tex");
#if false // OLD FORMAT
using (var stream = File.Create(texturePath))
{
using (var zip = new GZipStream(stream, CompressionMode.Compress, true))
{
using (var bw = new BinaryWriter(zip))
{
imageWriter.WriteOutAllImagesOLD(bw);
}
}
}
#else
MemoryStream ms = new MemoryStream();
ms.WriteByte(0); // <- version
imageWriter.WriteOutAllImages(ms);
ms.Position = 0;
File.WriteAllBytes(texturePath, ms.ToArray());
#endif
// Write out Level:
using (var stream = File.Create(path))
{
using (var zip = new GZipStream(stream, CompressionMode.Compress, true))
{
using (var bw = new BinaryWriter(zip))
{
Serialize(new LevelSerializeContext(bw, imageWriter, assetPathProvider));
}
}
}
}
public void RegisterImages(ImageWriter imageWriter, IAssetPathProvider assetPathProvider)
{
// NOTE: Using assetPathProvider to check if the item is embedded
// (Kind of ugly, as it duplicates the condition in LevelSerializeContext)
if (levelAnimation != null && assetPathProvider.GetAssetPath(levelAnimation) == null)
{
levelAnimation.RegisterImages(imageWriter);
}
foreach (var thing in things)
{
if (thing.AnimationSet != null && assetPathProvider.GetAssetPath(thing.AnimationSet) == null)
{
thing.AnimationSet.RegisterImages(imageWriter);
}
}
foreach (var shim in shims)
{
if (shim.AnimationSet != null && assetPathProvider.GetAssetPath(shim.AnimationSet) == null)
{
shim.AnimationSet.RegisterImages(imageWriter);
}
}
}
public LevelSerializeContext(BinaryWriter bw, ImageWriter imageWriter, IAssetPathProvider assetPathProvider) : this(bw, imageWriter, assetPathProvider, formatVersion)
{
} // Default to writing current version
/// <summary>Check that an AnimationSet round-trips through serialization cleanly</summary>
public void RoundTripCheck(GraphicsDevice graphicsDevice, IAssetProvider assetProvider, IAssetPathProvider assetPathProvider, bool useExternalImages)
{
// Serialize a first time
MemoryStream firstMemoryStream = new MemoryStream();
BinaryWriter firstBinaryWriter = new BinaryWriter(firstMemoryStream);
ImageWriter firstImageWriter = null;
if (useExternalImages)
{
firstImageWriter = new ImageWriter();
this.RegisterImages(firstImageWriter, assetPathProvider);
firstImageWriter.WriteOutAllImages(firstMemoryStream);
}
LevelSerializeContext firstSerializeContext = new LevelSerializeContext(firstBinaryWriter, firstImageWriter, assetPathProvider);
Serialize(firstSerializeContext);
byte[] originalData = firstMemoryStream.ToArray();
// Then deserialize that data
BinaryReader br = new BinaryReader(new MemoryStream(originalData));
ImageBundle imageBundle = null;
if (useExternalImages)
{
var helper = new SimpleTextureLoadHelper(graphicsDevice);
imageBundle = new ImageBundle();
br.BaseStream.Position = imageBundle.ReadAllImages(originalData, (int)br.BaseStream.Position, helper);
}
LevelDeserializeContext deserializeContext = new LevelDeserializeContext(br, imageBundle, assetProvider, graphicsDevice);
Level deserialized = new Level(deserializeContext);
// Then serialize that deserialized data and see if it matches
MemoryCompareStream secondMemoryStream = new MemoryCompareStream(originalData);
BinaryWriter secondBinaryWriter = new BinaryWriter(secondMemoryStream);
ImageWriter secondImageWriter = null;
if (useExternalImages)
{
secondImageWriter = new ImageWriter();
deserialized.RegisterImages(secondImageWriter, assetPathProvider);
secondImageWriter.WriteOutAllImages(secondMemoryStream);
}
LevelSerializeContext secondSerializeContext = new LevelSerializeContext(secondBinaryWriter, secondImageWriter, assetPathProvider);
deserialized.Serialize(secondSerializeContext);
// Clean-up:
if (imageBundle != null)
{
imageBundle.Dispose();
}
}
