/// <summary>
/// Save all objects that are registered.
/// </summary>
/// <param name="saveName">Name of the save file.</param>
/// <param name="fileType">Type of the save.</param>
/// <param name="compressionLevel">Compression applied after saving.</param>
public static void SaveAll(string saveName, FileType fileType, CompressionLevel compressionLevel)
{
IsSaving = true;
try
{
SaveData[] allSaves = new SaveData[saveablesList.Count];
for (int i = 0; i < saveablesList.Count; i++)
{
if (i <= allSaves.GetUpperBound(0))
{
allSaves[i] = saveablesList[i].GetSave();
}
else
{
Debug.LogWarning("There is more objects marked as saveables than there are objects saved on the disk.");
break;
}
}
Save(fileType, saveName, new AllSaveData <SaveData> {
saves = allSaves
});
if (compressionLevel != CompressionLevel.NoCompression)
{
Compress(compressionLevel);
}
}
catch (Exception e)
{
Debug.LogWarning(e);
}
IsSaving = false;
}
public static byte[] Compress(byte[] data, bool useGZipCompression = true)
{
System.IO.Compression.CompressionLevel compressionLevel = System.IO.Compression.CompressionLevel.Fastest;
using (MemoryStream memoryStream = new MemoryStream())
{
if (useGZipCompression)
{
using (System.IO.Compression.GZipStream gZipStream = new System.IO.Compression.GZipStream(memoryStream,
compressionLevel, true))
{
gZipStream.Write(data, 0, data.Length);
}
}
else
{
using (System.IO.Compression.GZipStream gZipStream = new System.IO.Compression.GZipStream(memoryStream,
compressionLevel, true))
{
gZipStream.Write(data, 0, data.Length);
}
}
return(memoryStream.ToArray());
}
}
//https://stackoverflow.com/questions/39191950/how-to-compress-a-byte-array-without-stream-or-system-io
public static byte[] GetCompressed(this byte[] data, CompressionLevel _compressionLevel = CompressionLevel.Fastest)
{
MemoryStream output = new MemoryStream();
using (DeflateStream dstream = new DeflateStream(output, _compressionLevel))
{
dstream.Write(data, 0, data.Length);
}
return(output.ToArray());
}
private static void AddEntry(ZipArchive archive, string fileNameOnDisk, string entryFileName,
CompressionLevel compressionLevel = CompressionLevel.Fastest)
{
// @DIRSEP: Converting to '/' because it will be a zip archive name and '/' is to spec
var entry = archive.CreateEntry(entryFileName.ToForwardSlashes(), compressionLevel);
entry.LastWriteTime = new FileInfo(fileNameOnDisk).LastWriteTime;
using var fs = new FileStream(fileNameOnDisk, FileMode.Open, FileAccess.Read);
using var eo = entry.Open();
fs.CopyTo(eo);
}
public static byte[] Compress(byte[] data, System.IO.Compression.CompressionLevel compressionLevel = System.IO.Compression.CompressionLevel.Optimal)
{
try {
UnityEngine.Profiling.Profiler.BeginSample("Compress");
MemoryStream output = new MemoryStream();
using (DeflateStream dstream = new DeflateStream(output, compressionLevel)) {
dstream.Write(data, 0, data.Length);
}
return(output.ToArray());
}
finally {
UnityEngine.Profiling.Profiler.EndSample();
}
}
/// <summary>
/// Compress the save folder in to a .zip file.
/// </summary>
private static void Compress(CompressionLevel compressionLevel)
{
if (Directory.Exists(GetSaveDirectoryPath()))
{
if (File.Exists(GetZipFilePath()))
{
File.Delete(GetZipFilePath());
}
ZipFile.CreateFromDirectory(GetSaveDirectoryPath(), GetZipFilePath(), compressionLevel, false);
ClearSaves(); // Remove remaining files because they are now saves in the .zip file.
return;
}
LogWarning(GetSaveDirectoryPath());
}
public static CompressionLevel ToCompressionLevel(this SystemCompressionLevel thisValue)
{
switch (thisValue)
{
case SystemCompressionLevel.NoCompression:
return(CompressionLevel.None);
case SystemCompressionLevel.Fastest:
return(CompressionLevel.Fast);
case SystemCompressionLevel.Optimal:
return(CompressionLevel.Ultra);
default:
throw new ArgumentOutOfRangeException(nameof(thisValue), thisValue, null);
}
}
private void ExportCTP_Click(object sender, EventArgs e)
{
SaveFileDialog saver = new SaveFileDialog();
saver.Filter = "Customization Tool Project (*.ctp) | *.ctp";
DialogResult res = saver.ShowDialog();
if (res == DialogResult.OK)
{
UnpackingLoader.Visible = true;
ExportCTP.Enabled = false;
StatusLabel.Text = "Exporting Customization Tool Project..";
System.IO.Compression.CompressionLevel ctpCompression = System.IO.Compression.CompressionLevel.Optimal;
if (CTPCompression.Value == 1)
{
ctpCompression = System.IO.Compression.CompressionLevel.NoCompression;
}
if (CTPCompression.Value == 2)
{
ctpCompression = System.IO.Compression.CompressionLevel.Fastest;
}
if (CTPCompression.Value == 3)
{
ctpCompression = System.IO.Compression.CompressionLevel.Optimal;
}
Thread ExportThread = new Thread(delegate()
{
ZipFile.CreateFromDirectory(AppDomain.CurrentDomain.BaseDirectory + "\\tmp", saver.FileName, ctpCompression, false);
});
ExportThread.Start();
while (ExportThread.IsAlive)
{
Application.DoEvents();
}
MessageBox.Show("Exporting completed", "Complete");
StatusLabel.Text = "Done.";
ExportCTP.Enabled = true;
UnpackingLoader.Visible = false;
}
}
public static byte[] Compress(IAkyuiLoader loader)
{
const CompressionLevel compressionLevel = CompressionLevel.Fastest;
using (var memoryStream = new MemoryStream())
{
using (var zipArchive = new ZipArchive(memoryStream, ZipArchiveMode.Create))
{
{
var newEntry = zipArchive.CreateEntry(Path.Combine(loader.LayoutInfo.Name, "layout.json"), compressionLevel);
using (var stream = new BinaryWriter(newEntry.Open()))
{
var text = JsonSerializer.ToJsonString(ToSerializable(loader.LayoutInfo));
var textBytes = System.Text.Encoding.UTF8.GetBytes(text);
stream.Write(textBytes, 0, textBytes.Length);
}
}
{
var newEntry = zipArchive.CreateEntry(Path.Combine(loader.LayoutInfo.Name, "assets.json"), compressionLevel);
using (var stream = new BinaryWriter(newEntry.Open()))
{
var text = JsonSerializer.ToJsonString(ToSerializable(loader.AssetsInfo));
var textBytes = System.Text.Encoding.UTF8.GetBytes(text);
stream.Write(textBytes, 0, textBytes.Length);
}
}
foreach (var asset in loader.AssetsInfo.Assets)
{
var newEntry = zipArchive.CreateEntry(Path.Combine(loader.LayoutInfo.Name, "assets", asset.FileName), compressionLevel);
using (var stream = new BinaryWriter(newEntry.Open()))
{
var bytes = loader.LoadAsset(asset.FileName);
stream.Write(bytes, 0, bytes.Length);
}
}
}
return(memoryStream.ToArray());
}
}
private void initStream()
{
if (deflateStream != null)
{
return;
}
// I must create the DeflateStream only if necessary, because of its bug with empty input (sigh)
// I must create with leaveopen=true always and do the closing myself, because MS moronic implementation of DeflateStream: I cant force a flush of the underlying stream witouth closing (sigh bis)
System.IO.Compression.CompressionLevel clevel = CompressionLevel.Optimal;
// thaks for the granularity, MS!
if (compressLevel >= 1 && compressLevel <= 5)
{
clevel = CompressionLevel.Fastest;
}
else if (compressLevel == 0)
{
clevel = CompressionLevel.NoCompression;
}
deflateStream = new DeflateStream(rawStream, clevel, true);
}
/// <inheritdoc cref="IZipArchiver.SetCompressionLevel"/>
public void SetCompressionLevel(ArchiveCompressionLevel archiveCompressionLevel)
{
switch (archiveCompressionLevel)
{
case ArchiveCompressionLevel.None:
_compressionLevel = CompressionLevel.NoCompression;
break;
case ArchiveCompressionLevel.Fastest:
_compressionLevel = CompressionLevel.Fastest;
break;
case ArchiveCompressionLevel.Optimal:
_compressionLevel = CompressionLevel.Optimal;
break;
default:
throw new ArgumentOutOfRangeException(nameof(archiveCompressionLevel), archiveCompressionLevel, null);
}
}
public static byte[] Compress(byte[] data, CompressAlgorithm method = CompressAlgorithm.Deflate, CompressionLevel level = CompressionLevel.Optimal)
{
MemoryStream output = new MemoryStream();
switch (method)
{
case CompressAlgorithm.Deflate:
{
using (DeflateStream dstream = new DeflateStream(output, level))
{
dstream.Write(data, 0, data.Length);
}
}
break;
case CompressAlgorithm.Zstd:
{
var opt = new CompressionOptions(CompressionOptions.DefaultCompressionLevel);
using (var compressor = new Compressor(opt))
{
return(compressor.Wrap(data));
}
}
}
return(output.ToArray());
}
public System.IO.Compression.ZipArchiveEntry CreateEntry(string entryName, System.IO.Compression.CompressionLevel compressionLevel)
{
throw null;
}
public GZipCompression(CompressionOptions options)
: base(options)
{
_compressionLevel = MapCompressionLevel(options.CompressionLevel);
}
