refactor

Author: AXiX-official

README.md

@@ -5,7 +5,14 @@
 [![MIT](https://img.shields.io/github/license/AXiX-official/UnityAsset.NET)](https://github.com/AXiX-official/UnityAsset.NET/master/LICENSE)
 [![NuGet Stats](https://img.shields.io/nuget/v/UnityAsset.NET.svg)](https://www.nuget.org/packages/UnityAsset.NET)
 
-A work-in-progress .NET library for parsing/serializing/patching Unity Engine asset files.
+> 🚨 Major Breaking Changes in v0.2.0 🚨
+>
+> This version introduces a complete, low-level refactoring with major breaking changes.
+> The API is not compatible with older versions (v0.1.x). 
+> This update aims to build a foundation that is more performant, type-safe, and provides a cleaner API.
+> Please read the notes below carefully before upgrading.
+
+A .NET library undergoing active refactoring, currently focused on high-performance parsing and reading of Unity Engine asset files.
 
 Only support Unity 2017.x or later.
 
@@ -15,19 +22,22 @@ Only support Unity 2017.x or later.
 
 ### BundleFile
 
-- [x] Parse/Serialize
-- [x] Patch
-- [x] Calculate/Patch crc32
+- [x] Parsing and Reading
+- [ ] ~~Serialization~~ (Temporarily removed, will be re-introduced with a new API in a future version)
+- [ ] ~~Patching~~ (Will be re-introduced in a future version)
+- [ ] Calculate/Patch crc32
 
 ### SerializedFile
 
-- [x] Parse/Serialize
-- [ ] Patch
+- [x] Parsing and Reading
+- [ ] ~~Serialization~~ (Temporarily removed)
+- [ ] ~~Patching~~ (Temporarily removed)
 
 ### Asset
 
-- [x] Parse/Serialize
-- [ ] Patch
+- [x] Parsing based on TypeTree
+- [ ] ~~Serialization~~ (Temporarily removed)
+- [ ] ~~Patching~~ (Temporarily removed)
 
 ## Examples
 
@@ -47,8 +57,9 @@ or
 BundleFile bf = new BundleFile( @"path to your bundlefile", "XxecodrPeGaka2e6");
 ```
 
-To remove Unity CN Encryption form File, you can simply save `BundleFile` without key
+~~To remove Unity CN Encryption form File, you can simply save `BundleFile` without key~~
 ```csharp
+// Temporarily removed
 bf.Serialize(@"path to save file", CompressionType.Lz4HC, CompressionType.Lz4HC);
 ```
 
@@ -59,6 +70,12 @@ Some `BundleFile`'s version may be stripped, to load those file you can set a sp
 Setting.DefaultUnityVerion = "2020.3.48f1"
 ```
 
+## Roadmap
+
+- [ ] v0.3: More Asset Class Interface.
+- [ ] v0.4: Re-architect and re-implement a robust and flexible serialization API.
+- [ ] v0.5: Re-introduce patching capabilities based on the new object model.
+
 ## Credits
 
 ---

UnityAsset.NET/Asset.cs

@@ -1,19 +1,22 @@
 using System.Collections.Specialized;
 using UnityAsset.NET.Files.SerializedFiles;
 using UnityAsset.NET.IO;
+using UnityAsset.NET.TypeTreeHelper;
 
 namespace UnityAsset.NET;
 
 public class Asset
 { 
     public AssetFileInfo Info;
     public IReader RawData;
-    public NodeData NodeData;
+    //public NodeData NodeData;
+    public IAsset Value;
 
     public Asset(AssetFileInfo info, IReader reader)
     {
         Info = info;
-        RawData = reader;
-        NodeData = new NodeData(reader, info.Type.Nodes, info.Type.Nodes[0]);
+        RawData = reader; 
+        Value = UnityObjectFactory.Create(info.Type, reader);
+        //NodeData = new NodeData(reader, info.Type.Nodes, info.Type.Nodes[0]);
     }
 }

UnityAsset.NET/Compression/Compression.cs

@@ -73,4 +73,30 @@ public static long CompressToBytes(ReadOnlySpan<byte> uncompressedData, Span<byt
                 throw new ArgumentException($"Unsupported compression type {compressionType}");
         }
     }
+    
+    public static Stream CompressToStream(ReadOnlySpan<byte> uncompressedData, CompressionType compressionType)
+    {
+        switch (compressionType)
+        {
+            case CompressionType.None:
+                return new MemoryStream(uncompressedData.ToArray());
+            case CompressionType.Lz4:
+                byte[] compressedData = new byte[LZ4Codec.MaximumOutputSize(uncompressedData.Length)];
+                int compressedSize = LZ4Codec.Encode(uncompressedData, compressedData);
+                return new MemoryStream(compressedData[..compressedSize]);
+            case CompressionType.Lz4HC:
+                byte[] compressedDataHC = new byte[LZ4Codec.MaximumOutputSize(uncompressedData.Length)];
+                int compressedSizeHC = LZ4Codec.Encode(uncompressedData, compressedDataHC, LZ4Level.L12_MAX);
+                return new MemoryStream(compressedDataHC[..compressedSizeHC]);
+            case CompressionType.Lzma:
+                var uncompressedStream = new MemoryStream(uncompressedData.ToArray());
+                var encoder = new Encoder();
+                MemoryStream compressedStream = new MemoryStream();
+                encoder.WriteCoderProperties(compressedStream);
+                encoder.Code(uncompressedStream, compressedStream, -1, -1, null);
+                return compressedStream;
+            default:
+                throw new ArgumentException($"Unsupported compression type {compressionType}");
+        }
+    }
 }

UnityAsset.NET/Extensions/BundleFileExtensions.cs

@@ -17,15 +17,7 @@ public static void ParseFilesWithTypeConversion(this BundleFile bf)
             ref var file = ref filesSpan[i];
             if (file is { File: IReader reader, CanBeSerializedFile: true })
             {
-                try
-                {
-                    file = new FileWrapper(SerializedFile.Parse(reader), file.Info);
-                    Console.WriteLine($"File {file.Info.Path} loaded.");
-                }
-                catch (Exception e)
-                {
-                    Console.WriteLine($"Error loading file {file.Info.Path}: {e.Message}");
-                }
+                file = new FileWrapper(SerializedFile.Parse(reader), file.Info);
             }
         }
     }

UnityAsset.NET/Extensions/ListExtensions.cs

@@ -1,4 +1,5 @@
 using System.Runtime.InteropServices;
+using System.Text;
 
 namespace UnityAsset.NET.Extensions;
 
@@ -13,4 +14,17 @@ public static ReadOnlySpan<T> AsReadOnlySpan<T>(this List<T> list)
     {
         return list.AsSpan();
     }
+
+    public static string ToPlainText<T>(this List<T> list, string indent = "")
+    {
+        var sb = new StringBuilder();
+        sb.AppendLine($"{indent}    Array Array");
+        sb.AppendLine($"{indent}    int size = {list.Count}");
+        for (int i = 0; i < list.Count; i++)
+        {
+            sb.AppendLine($"{indent}        [{i}]");
+            
+        }
+        return sb.ToString();
+    }
 }

UnityAsset.NET/Extensions/TypeTreeNodeExtensions.cs

@@ -6,24 +6,37 @@ public static class TypeTreeNodeExtensions
 {
     public static bool RequiresAlign(this TypeTreeNode node) => (node.MetaFlags & 0x4000) != 0;
 
-    public static TypeTreeNode? Parent(this TypeTreeNode current, List<TypeTreeNode> nodes)
+    public static bool RequiresAlign(this TypeTreeNode node, List<TypeTreeNode> nodes)
+    {
+        switch (node.Type)
+        {
+            case "string" :
+            case "vector" :
+                return node.RequiresAlign() || node.Children(nodes)[0].RequiresAlign();
+            case "map" :
+                return node.RequiresAlign() || node.Children(nodes)[0].Children(nodes)[1].RequiresAlign();
+            default: return (node.MetaFlags & 0x4000) != 0;
+        }
+    }
+    
+    public static TypeTreeNode Parent(this TypeTreeNode current, List<TypeTreeNode> nodes)
     {
         if (current.Index == 0)
-            return null;
+            throw new IndexOutOfRangeException();
         var nodesSpan = nodes.AsReadOnlySpan();
         for (int i = (int)current.Index - 1; i >= 0; i--)
         {
             if (nodesSpan[i].Level < current.Level)
                 return nodesSpan[i];
         }
-        return null;
+        throw new IndexOutOfRangeException();
     }
 
-    public static List<TypeTreeNode>? Children(this TypeTreeNode current, List<TypeTreeNode> nodes)
+    public static List<TypeTreeNode> Children(this TypeTreeNode current, List<TypeTreeNode> nodes)
     {
         var nodesSpan = nodes.AsReadOnlySpan();
         if ((int)current.Index + 1 >= nodesSpan.Length || nodesSpan[(int)current.Index + 1].Level <= current.Level)
-            return null;
+            return new();
         var children = new List<TypeTreeNode>();
         for (int i = (int)current.Index + 1; i < nodesSpan.Length; i++)
         {

UnityAsset.NET/Files/BundleFiles/BlocksAndDirectoryInfo.cs

@@ -1,5 +1,4 @@
-using System.Runtime.InteropServices;
-using System.Text;
+using System.Text;
 using UnityAsset.NET.Extensions;
 using UnityAsset.NET.IO;
 
@@ -26,7 +25,7 @@ public BlocksAndDirectoryInfo(byte[] uncompressedDataHash,
         reader.ReadList(reader.ReadInt32(), FileEntry.Parse)
     );
 
-    public void Serialize(IWriter writer)
+    /*public void Serialize(IWriter writer)
     {
         writer.WriteBytes(UncompressedDataHash);
         writer.WriteListWithCount(BlocksInfo, (w, info) => info.Serialize(w));
@@ -35,7 +34,7 @@ public void Serialize(IWriter writer)
 
     public long SerializeSize => UncompressedDataHash.Length + 8 + 
                                  BlocksInfo.Sum(item => item.SerializeSize) + 
-                                 DirectoryInfo.Sum(item => item.SerializeSize);
+                                 DirectoryInfo.Sum(item => item.SerializeSize);*/
 
     public override string ToString()
     {