internal static void WriteBundleLayout(Stream stream, BuildLayout layout)
{
using (StreamWriter sw = new StreamWriter(stream))
{
TabWriter writer = new TabWriter(sw);
writer.WriteLine("WARNING! The formatting in this file may change in future package versions.");
writer.WriteLine($"Unity Version: {UnityEngine.Application.unityVersion}");
PackageManager.PackageInfo info = PackageManager.PackageInfo.FindForAssembly(typeof(BuildLayoutPrinter).Assembly);
if (info != null)
{
writer.WriteLine($"{info.name}: {info.version}");
}
WriteSummary(writer, layout);
writer.WriteLine("");
foreach (BuildLayout.Group grp in layout.Groups)
{
PrintGroup(writer, grp);
}
using (writer.IndentScope("BuiltIn Bundles"))
foreach (BuildLayout.Bundle b in layout.BuiltInBundles)
{
PrintArchive(writer, b);
}
}
}
static void WriteSummary(TabWriter writer, BuildLayout layout)
{
int ExplicitAssetCount = 0;
int SceneBundleCount = 0;
int AssetBundleCount = 0;
ulong TotalBuildSize = 0;
ulong MonoScriptSize = 0;
ulong BundleOverheadSize = 0;
foreach (BuildLayout.File f in BuildLayoutHelpers.EnumerateFiles(layout))
{
BundleOverheadSize += f.BundleObjectInfo != null ? f.BundleObjectInfo.Size : 0;
MonoScriptSize += f.MonoScriptSize;
}
foreach (BuildLayout.Bundle b in BuildLayoutHelpers.EnumerateBundles(layout))
{
bool sceneBundle = BuildLayoutHelpers.EnumerateAssets(b).FirstOrDefault(x => x.AssetPath.EndsWith(".unity", StringComparison.OrdinalIgnoreCase)) != null;
SceneBundleCount += sceneBundle ? 1 : 0;
AssetBundleCount += sceneBundle ? 0 : 1;
TotalBuildSize += b.FileSize;
}
ExplicitAssetCount = BuildLayoutHelpers.EnumerateAssets(layout).Count();
using (writer.IndentScope("Summary"))
{
writer.WriteLine($"Addressable Groups: {layout.Groups.Count}");
writer.WriteLine($"Explicit Assets Addressed: {ExplicitAssetCount}");
writer.WriteLine($"Total Bundle: {SceneBundleCount+AssetBundleCount} ({SceneBundleCount} Scene Bundles, {AssetBundleCount} Non-Scene Bundles)");
writer.WriteLine($"Total Build Size: {GetFriendlySize(TotalBuildSize)}");
writer.WriteLine($"Total MonoScript Size: {GetFriendlySize(MonoScriptSize)}");
writer.WriteLine($"Total AssetBundle Object Size: {GetFriendlySize(BundleOverheadSize)}");
}
}
static void PrintFile(TabWriter writer, BuildLayout.File file, int i)
{
AttrBuilder attr = new AttrBuilder();
if (file.PreloadInfoSize > 0)
{
attr.AddSize("PreloadInfoSize", (ulong)file.PreloadInfoSize);
}
attr.Add("MonoScripts", file.MonoScriptCount.ToString());
attr.AddSize("MonoScript Size", file.MonoScriptSize);
using (writer.IndentScope($"File {i} {attr}"))
{
foreach (BuildLayout.SubFile sf in file.SubFiles)
{
AttrBuilder attr2 = new AttrBuilder();
attr2.AddSize("Size", sf.Size);
writer.WriteLine($"{sf.Name} {attr2}");
}
using (writer.IndentScope($"Data From Other Assets ({file.OtherAssets.Count})"))
{
foreach (BuildLayout.DataFromOtherAsset otherData in file.OtherAssets)
{
PrintDataFromOtherAsset(writer, otherData);
}
}
}
}
static void PrintSchema(TabWriter writer, BuildLayout.SchemaData sd)
{
string text = sd.Type;
if (sd.KvpDetails.Count > 0)
{
AttrBuilder attr = new AttrBuilder();
sd.KvpDetails.ForEach(x => attr.Add(x.Item1, x.Item2));
text += " " + attr;
}
writer.WriteLine(text);
}
static void PrintDataFromOtherAsset(TabWriter writer, BuildLayout.DataFromOtherAsset asset)
{
AttrBuilder attr = new AttrBuilder();
attr.AddSize("Size", asset.SerializedSize + asset.StreamedSize);
attr.AddSize("Size from Objects", asset.SerializedSize);
attr.AddSize("Size from Streamed Data", asset.StreamedSize);
attr.Add("Object Count", asset.ObjectCount.ToString());
using (writer.IndentScope($"{asset.AssetPath} {attr}"))
{
writer.WriteLine($"Referencing Assets: {string.Join(", ", asset.ReferencingAssets.Select(x => x.AssetPath))}");
}
}
public void GenerateGroove()
{
;
for (var i = 0; i < 20; i++)
{
var timeSignature = new TimeSignature(Randomizer.ProbabilityOfTrue(0.7) ? 4 : 3, 4);
var feel = Randomizer.ProbabilityOfTrue(0.75) ? 4 : 3;
var groove = GrooveGenerator.GenerateGroove(new SongInfo(timeSignature, feel));
var drumStyle = new DrumStyle(SectionType.Verse);
drumStyle.Generate(groove);
Console.WriteLine("{0}, {1} feel", timeSignature, feel);
Console.WriteLine(TabWriter.AsTab(groove.Feel, drumStyle.Notes, timeSignature.BeatCount));
}
}
public void GrooveWithFill()
{
var time = TimeSignature.CommonTime;
var feel = Randomizer.ProbabilityOfTrue(0.6) ? 4 : 3;
const int measures = 4;
var totalLength = measures * time.BeatCount;
var drumStyle = new DrumStyle(SectionType.None);
drumStyle.Generate(GrooveGenerator.GenerateGroove(new SongInfo(time, feel)));
var grooveNotes = Enumerable.Range(0, measures).SelectMany(i => drumStyle.Notes.Select(n => new PercussionNote(n.Start + i * time.BeatCount, n.Percussion, n.Velocity)));
var fillLength = Randomizer.ProbabilityOfTrue(0.5) ? 2 : 4;
var fill = FillGenerator.GetFill(totalLength - fillLength, fillLength, feel);
grooveNotes = grooveNotes.Where(n => n.Start < totalLength - fillLength).Union(fill);
Console.WriteLine(TabWriter.AsTab(feel, grooveNotes.ToList(), measures * time.BeatCount));
}
static void PrintArchive(TabWriter writer, BuildLayout.Bundle archive)
{
AttrBuilder attr = new AttrBuilder();
attr.AddSize("Size", archive.FileSize);
attr.Add("Compression", archive.Compression);
ulong bundleSize = archive.Files.First(x => x.BundleObjectInfo != null).BundleObjectInfo.Size;
attr.AddSize("Asset Bundle Object Size", bundleSize);
using (writer.IndentScope($"Archive {archive.Name} {attr}"))
{
if (archive.Dependencies != null)
{
writer.WriteLine("Bundle Dependencies: " + string.Join(", ", archive.Dependencies.Select(x => x.Name)));
}
if (archive.ExpandedDependencies != null)
{
writer.WriteLine("Expanded Bundle Dependencies: " + string.Join(", ", archive.ExpandedDependencies.Select(x => x.Name)));
}
using (writer.IndentScope($"Explicit Assets"))
{
for (int i = 0; i < archive.Files.Count; i++)
{
BuildLayout.File f = archive.Files[i];
foreach (BuildLayout.ExplicitAsset asset in f.Assets)
{
PrintAsset(writer, asset, i);
}
}
}
using (writer.IndentScope($"Files:"))
{
for (int i = 0; i < archive.Files.Count; i++)
{
PrintFile(writer, archive.Files[i], i);
}
}
}
}
static void PrintGroup(TabWriter writer, BuildLayout.Group grp)
{
int explicitAssetCount = grp.Bundles.Sum(x => x.Files.Sum(y => y.Assets.Count));
AttrBuilder attr = new AttrBuilder();
attr.Add("Bundles", grp.Bundles.Count.ToString());
attr.AddSize("Total Size", (ulong)grp.Bundles.Sum(x => (long)x.FileSize));
attr.Add("Explicit Asset Count", explicitAssetCount.ToString());
using (writer.IndentScope($"Group {grp.Name} {attr}"))
{
using (writer.IndentScope("Schemas"))
grp.Schemas.ForEach(x => PrintSchema(writer, x));
foreach (BuildLayout.Bundle archive in grp.Bundles)
{
PrintArchive(writer, archive);
}
}
}
static void PrintAsset(TabWriter writer, BuildLayout.ExplicitAsset asset, int fileIndex)
{
AttrBuilder attr = new AttrBuilder();
attr.AddSize("Total Size", asset.SerializedSize + asset.StreamedSize);
attr.AddSize("Size from Objects", asset.SerializedSize);
attr.AddSize("Size from Streamed Data", asset.StreamedSize);
attr.Add("File Index", fileIndex.ToString());
attr.Add("Addressable Name", asset.AddressableName);
using (writer.IndentScope($"{asset.AssetPath} {attr}"))
{
if (asset.ExternallyReferencedAssets.Count > 0)
{
writer.WriteLine("External References: " + string.Join(", ", asset.ExternallyReferencedAssets.Select(x => x.AssetPath)));
}
if (asset.InternalReferencedOtherAssets.Count > 0)
{
writer.WriteLine("Internal References: " + string.Join(", ", asset.InternalReferencedOtherAssets.Select(x => x.AssetPath)));
}
}
}
public void WriteScripts_ScriptGuidCorrect()
{
//ARRANGE
var app = new Application();
app.Tabs = new List <Tab> {
new Tab
{
Name = "testTab",
Guid = "ac4a4f4c-b9af-4c87-8fb4-35ca0f4a9b63"
}
};
//ACT
var writer = new TabWriter();
var text = writer.WriteTabGuids(app);
//ASSERT
var properties = ParseTestHelper.GetClassDefinition(text).Members.First();
Assert.Equal("public const string testTab = \"ac4a4f4c-b9af-4c87-8fb4-35ca0f4a9b63\";", properties.ToString(), ignoreWhiteSpaceDifferences: true);
}
public TabWriterIdentScope(TabWriter writer)
{
m_Writer = writer;
writer.Indentation++;
}
public void GetFill()
{
const double lengthInBeats = 4.0;
Console.WriteLine(TabWriter.AsTab(3, FillGenerator.GetFill(0, lengthInBeats, 3).ToList(), (int)lengthInBeats));
}
