2024/6/5

Author: AXiX-official

UnityAsset.NET/BundleFile/BlocksAndDirectoryInfo.cs

@@ -80,7 +80,8 @@ public void uncompresseFlags()
     {
         foreach (var block in BlocksInfo)
         {
-            block.flags &= ~StorageBlockFlags.CompressionTypeMask;
+            //block.flags &= ~StorageBlockFlags.CompressionTypeMask;
+            block.flags &= 0x0;
             block.compressedSize = block.uncompressedSize;
         }
         Update();
@@ -118,6 +119,33 @@ public void merge()
         BlocksInfo = newBlocksInfo;
         Update();
     }
+    
+    public void Split()
+    {
+        List<StorageBlockInfo> newBlocksInfo = new List<StorageBlockInfo>();
+        foreach (var block in BlocksInfo)
+        {
+            if (block.uncompressedSize > 0x00020000)
+            {
+                uint num = block.uncompressedSize / 0x00020000;
+                uint num2 = block.uncompressedSize % 0x00020000;
+                for (uint i = 0; i < num; i++)
+                {
+                    newBlocksInfo.Add(new StorageBlockInfo(0x00020000, 0x00020000, block.flags));
+                }
+                if (num2 > 0)
+                {
+                    newBlocksInfo.Add(new StorageBlockInfo(num2, num2, block.flags));
+                }
+            }
+            else
+            {
+                newBlocksInfo.Add(block);
+            }
+        }
+        BlocksInfo = newBlocksInfo;
+        Update();
+    }
 
     public void Update(string compressionType = "none")
     {

UnityAsset.NET/BundleFile/BundleFile.cs

@@ -8,26 +8,45 @@ namespace UnityAsset.NET.BundleFile;
 
 public sealed class BundleFile
 {
-    public Header Header;
+    /// <summary>
+    /// BundleFile header
+    /// </summary>
+    public Header Header { get; set; }
 
-    public string? UnityCNKey;
+    /// <summary>
+    /// Key for UnityCN encryption
+    /// </summary>
+    public string? UnityCNKey { get; set; }
 
-    public UnityCN? UnityCNInfo;
+    /// <summary>
+    /// Data for UnityCN encryption
+    /// </summary>
+    public UnityCN? UnityCNInfo { get; set; }
 
-    public BlocksAndDirectoryInfo DataInfo;
+    /// <summary>
+    /// BlocksAndDirectoryInfo
+    /// </summary>
+    public BlocksAndDirectoryInfo DataInfo { get; set; }
 
-    public List<MemoryStream> cabStreams;
+    public List<MemoryStream> cabStreams { get; set; }
 
-    public uint crc32;
+    public uint crc32 { get; set; }
+
+    private bool _blocksInfoAtTheEnd;
 
-    public bool BlocksInfoAtTheEnd = false;
+    public bool BlocksInfoAtTheEnd { get => _blocksInfoAtTheEnd; set => _blocksInfoAtTheEnd = value; }
 
-    public bool HasBlockInfoNeedPaddingAtStart;
+    public bool HasBlockInfoNeedPaddingAtStart { get; set; }
 
-    private bool HeaderAligned = false;
-    
-    private ArchiveFlags mask;
+    private bool HeaderAligned { get; set; }
 
+    private ArchiveFlags mask { get; set; }
+
+    public BundleFile(string path, bool original = false, string? key = null)
+        : this(new FileStream(path, FileMode.Open, FileAccess.Read), original, key)
+    {
+    }
+
     public BundleFile(Stream input, bool original = false, string? key = null)
     {
         using AssetReader reader = new AssetReader(input);
@@ -37,26 +56,6 @@ public BundleFile(Stream input, bool original = false, string? key = null)
         Header = new Header(reader);
         var version = ParseVersion();
 
-        if (Header.version >= 7)
-        {
-            reader.AlignStream(16);
-            HeaderAligned = true;
-        }
-        else if (version[0] == 2019 && version[1] == 4) // temp fix for 2019.4.x
-        {
-            var p = reader.Position;
-            var len = 16 - p % 16;
-            var bytes = reader.ReadBytes((int)len);
-            if (bytes.Any(x => x != 0))
-            {
-                reader.Position = p;
-            }
-            else
-            {
-                HeaderAligned = true;
-            }
-        }
-        
         if (version[0] < 2020 || //2020 and earlier
             (version[0] == 2020 && version[1] == 3 && version[2] <= 34) || //2020.3.34 and earlier
             (version[0] == 2021 && version[1] == 3 && version[2] <= 2) || //2021.3.2 and earlier
@@ -81,7 +80,27 @@ public BundleFile(Stream input, bool original = false, string? key = null)
             Header.flags &= (ArchiveFlags)~mask;
         }
 
-        DataInfo = new BlocksAndDirectoryInfo(reader, Header, ref BlocksInfoAtTheEnd);
+        if (Header.version >= 7)
+        {
+            reader.AlignStream(16);
+            HeaderAligned = true;
+        }
+        else if (version[0] == 2019 && version[1] == 4) // temp fix for 2019.4.x
+        {
+            var p = reader.Position;
+            var len = 16 - p % 16;
+            var bytes = reader.ReadBytes((int)len);
+            if (bytes.Any(x => x != 0))
+            {
+                reader.Position = p;
+            }
+            else
+            {
+                HeaderAligned = true;
+            }
+        }
+        
+        DataInfo = new BlocksAndDirectoryInfo(reader, Header, ref _blocksInfoAtTheEnd);
 
         foreach (var blockInfo in DataInfo.BlocksInfo)
         {
@@ -179,7 +198,7 @@ private string BlocksCompressionType
 
             foreach (var block in DataInfo.BlocksInfo)
             {
-                block.flags &= (StorageBlockFlags)~StorageBlockFlags.CompressionTypeMask;
+                block.flags &= ~StorageBlockFlags.CompressionTypeMask;
                 block.flags |= (StorageBlockFlags)newFlag;
             }
         }
@@ -234,12 +253,16 @@ private void ReadBlocks(AssetReader reader)
         }
     }
 
+    public void WriteToFile(string path, string infoPacker = "none", string dataPacker = "none", bool unityCN = false)
+    {
+        using FileStream fs = new FileStream(path, FileMode.Create, FileAccess.Write);
+        Write(fs, infoPacker, dataPacker, unityCN);
+    }
+    
     public void Write(Stream output, string infoPacker = "none", string dataPacker = "none", bool unityCN = false)
     {
         MemoryStream compressedStream = new MemoryStream();
 
-        //Bumbo();
-        
         fixCRC(crc32, CalculateCRC32());
 
         BlocksCompressionType = dataPacker;
@@ -248,8 +271,15 @@ public void Write(Stream output, string infoPacker = "none", string dataPacker =
         {
             throw new Exception("UnityCN encryption requires lz4 or lz4hc compression type");
         }
-        
-        //DataInfo.merge();
+
+        if (dataPacker == "none")
+        {
+            DataInfo.merge();
+        }
+        else
+        {
+            DataInfo.Split();
+        }
 
         MemoryStream BlocksStream = new MemoryStream();
 

UnityAsset.NET/CRC32.cs

@@ -74,6 +74,16 @@ public static uint CalculateCRC32(byte[] data, uint initialCrc = 0)
         return ~crc;
     }
 
+    public static uint CalculateCRC32(List<byte> data, uint initialCrc = 0)
+    {
+        uint crc = ~initialCrc;
+        foreach (var b in data)
+        {
+            crc = (crc >> 8) ^ Crc32Table[(crc ^ b) & 0xFF];
+        }
+        return ~crc;
+    }
+    
     public static uint CalculateCRC32(Stream data, uint initialCrc = 0)
     {
         data.Position = 0;