public override long Write(AssetsFileWriter writer) { //memorystream for alignment issue using (MemoryStream ms = new MemoryStream()) using (AssetsFileWriter w = new AssetsFileWriter(ms)) { assetsFile.Write(w, -1, replacers, fileId, typeMeta); writer.Write(ms.ToArray()); } return(writer.Position); }
//does NOT write the endianness byte for format < 9! public void Write(AssetsFileWriter writer) { writer.bigEndian = true; writer.Write(metadataSize); writer.Write(fileSize); writer.Write(format); writer.Write(firstFileOffset); writer.Write((byte)endianness); writer.bigEndian = endianness == 1 ? true : false; writer.Write(unknown); }
public void Write(AssetsFileWriter writer) { writer.Write(len); for (int i = 0; i < len; i++) { writer.Write(items[i].fileID); writer.Align(); writer.Write(items[i].pathID); writer.Align(); } }
public ulong Write(AssetsFileWriter writer, ulong filePos, int version) { writer.Write(classId); writer.Write(baseClass); name.Write(writer, filePos); writer.Write(fields.Count); for (int i = 0; i < fields.Count; i++) { fields[i].Write(writer, filePos, version); } return(writer.Position); }
public override long WriteReplacer(AssetsFileWriter writer) { writer.Write((short)2); //replacer type writer.Write((byte)0); //file type (0 bundle, 1 assets) writer.WriteCountStringInt16(oldName); writer.WriteCountStringInt16(newName); writer.Write(hasSerializedData); writer.Write(GetSize()); Write(writer); return(writer.Position); }
//does NOT write the endianness byte for format < 9! public ulong Write(ulong pos, AssetsFileWriter writer) { writer.bigEndian = true; writer.Write(metadataSize); writer.Write(fileSize); writer.Write(format); writer.Write(offs_firstFile); writer.Write((byte)endianness); writer.bigEndian = endianness == 1 ? true : false; writer.Write(unknown); return(writer.Position); }
public void Write(AssetsFileWriter writer) { writer.WriteNullTerminated(bufferedPath); guid.Write(writer); writer.Write(type); string assetPathTemp = assetPath; if (assetPathTemp.StartsWith("Resources\\") || assetPathTemp.StartsWith("Resources/")) { assetPathTemp = "library/" + assetPath.Substring(10); } writer.WriteNullTerminated(assetPathTemp); }
public override long WriteReplacer(AssetsFileWriter writer) { writer.Write((short)0); //replacer type writer.Write((byte)1); //file type (0 bundle, 1 assets) writer.Write((byte)1); //idk, always 1 writer.Write(0); //always 0 even when fileid is something else writer.Write(pathID); writer.Write(classID); writer.Write(monoScriptIndex); writer.Write(0); //flags, which are ignored since this is a remover return(writer.Position); }
public override long Write(AssetsFileWriter writer) { // Some parts of an assets file need to be aligned to a multiple of 4/8/16 bytes, // but for this to work correctly, the start of the file of course needs to be aligned too. // In a loose .assets file this is true by default, but inside a bundle file, // this might not be the case. Therefore wrap the bundle output stream in a SegmentStream // which will make it look like the start of the new assets file is at position 0 SegmentStream alignedStream = new SegmentStream(writer.BaseStream, writer.Position); AssetsFileWriter alignedWriter = new AssetsFileWriter(alignedStream); assetsFile.Write(alignedWriter, -1, assetReplacers); writer.Position = writer.BaseStream.Length; return(writer.Position); }
public ulong Write(ulong absFilePos, AssetsFileWriter writer) { writer.Write(bufferedPath); guid.Write(writer.Position, writer); writer.Write(type); string assetPathTemp = assetPath; if (assetPathTemp.StartsWith("Resources\\")) { assetPathTemp = "library/" + assetPath.Substring(10); } writer.WriteNullTerminated(assetPathTemp); return(writer.Position); }
public void Write(AssetsFileWriter writer, uint format) { writer.Write(version); writer.Write(depth); writer.Write(isArray); writer.Write(typeStringOffset); writer.Write(nameStringOffset); writer.Write(size); writer.Write(index); writer.Write(flags); if (format >= 0x12) { writer.Write(unknown); } }
public override long WriteReplacer(AssetsFileWriter writer) { writer.Write((short)4); //replacer type writer.Write((byte)0); //file type (0 bundle, 1 assets) writer.WriteCountStringInt16(oldName); writer.WriteCountStringInt16(newName); writer.Write((byte)1); //probably hasSerializedData writer.Write((long)assetReplacers.Count); foreach (AssetsReplacer replacer in assetReplacers) { replacer.WriteReplacer(writer); } return(writer.Position); }
public override long Write(AssetsFileWriter writer) { //todo, we have to write to ms because AssetsFile.Write //rewrites back at 0 which is the bundle header, not //the top of the assets file byte[] data; using (MemoryStream ms = new MemoryStream()) using (AssetsFileWriter w = new AssetsFileWriter(ms)) { assetsFile.Write(w, 0, replacers, fileId); data = ms.ToArray(); } writer.Write(data); return(writer.Position); }
public void Write(AssetsFileWriter writer, int version, byte flags) { writer.Write(classId); writer.Write(baseClass); name.Write(writer); if ((flags & 1) != 0) { assemblyFileName.Write(writer); } writer.Write(fields.Count); for (int i = 0; i < fields.Count; i++) { fields[i].Write(writer, version); } }
public ulong Write(ulong curFilePos, AssetsFileWriter writer, uint format) { writer.Write(version); writer.Write(depth); writer.Write(isArray); writer.Write(typeStringOffset); writer.Write(nameStringOffset); writer.Write(size); writer.Write(index); writer.Write(flags); if (format >= 0x12) { writer.Write(unknown); } return(writer.Position); }
public void Write(AssetsFileWriter writer) { writer.WriteNullTerminated(bufferedPath); guid.Write(writer); writer.Write(type); string assetPathTemp = assetPath; if ((assetPath == "Resources/unity_builtin_extra" || assetPath == "Resources/unity default resources" || assetPath == "Resources/unity editor resources") && originalAssetPath != string.Empty) { assetPathTemp = originalAssetPath; } writer.WriteNullTerminated(assetPathTemp); }
}//Minimum AssetsFile format : 6 public void Write(AssetsFileWriter writer, uint version) { writer.WriteNullTerminated(unityVersion); writer.Write(this.version); writer.Write(hasTypeTree); fieldCount = unity5Types.Count; writer.Write(fieldCount); for (int i = 0; i < fieldCount; i++) { unity5Types[i].Write(hasTypeTree, writer, version); } if (version < 0x0E) { writer.WriteUInt24(dwUnknown); } }
public void Write(AssetsFileWriter writer) { header.Write(writer); writer.Write(classes.Count); for (int i = 0; i < classes.Count; i++) { classes[i].Write(writer, header.fileVersion, header.flags); } long stringTablePos = writer.Position; writer.Write(stringTable); long stringTableLen = writer.Position - stringTablePos; long fileSize = writer.Position; header.stringTablePos = (uint)stringTablePos; header.stringTableLen = (uint)stringTableLen; header.uncompressedSize = (uint)fileSize; writer.Position = 0; header.Write(writer); }
public void Write(bool hasTypeTree, AssetsFileWriter writer, uint version) { writer.Write(classId); if (version >= 0x10) { writer.Write(unknown16_1); } if (version >= 0x11) { writer.Write(scriptIndex); } if ((version < 0x11 && classId < 0) || (version >= 0x11 && classId == 0x72)) { writer.Write(scriptHash1); writer.Write(scriptHash2); writer.Write(scriptHash3); writer.Write(scriptHash4); } writer.Write(typeHash1); writer.Write(typeHash2); writer.Write(typeHash3); writer.Write(typeHash4); if (hasTypeTree) { writer.Write(typeFieldsExCount); writer.Write(stringTable.Length); for (int i = 0; i < typeFieldsExCount; i++) { typeFieldsEx[i].Write(writer, version); } writer.Write(stringTable); if (version >= 0x15) { writer.Write(dependenciesCount); for (int i = 0; i < dependenciesCount; i++) { writer.Write(dependencies[i]); } } } }
public ulong Write(AssetsFileWriter writer, ulong filePos, int optimizeStringTable, uint compress, bool writeStringTable = true) { header.Write(writer, writer.Position); writer.Write(classes.Count); for (int i = 0; i < classes.Count; i++) { classes[i].Write(writer, filePos, header.fileVersion); } ulong stringTablePos = writer.Position; writer.Write(stringTable); ulong stringTableLen = writer.Position - stringTablePos; ulong fileSize = writer.Position; header.stringTablePos = (uint)stringTablePos; header.stringTableLen = (uint)stringTableLen; header.uncompressedSize = (uint)fileSize; writer.Position = 0; header.Write(writer, writer.Position); return(0); }
public override bool Init(AssetsFileReader entryReader, long entryPos, long entrySize, ClassDatabaseFile typeMeta = null) { if (assetsFile != null) { return(false); } this.typeMeta = typeMeta; entryReader.Position = entryPos; //memorystream for alignment issue MemoryStream ms = new MemoryStream(); AssetsFileReader r = new AssetsFileReader(ms); AssetsFileWriter w = new AssetsFileWriter(ms); { w.Write(entryReader.ReadBytes((int)entrySize)); ms.Position = 0; assetsFile = new AssetsFile(r); } return(true); }
public void Write(AssetsFileWriter writer) { writer.bigEndian = false; writer.Write(Encoding.ASCII.GetBytes(header)); writer.Write(fileVersion); if (fileVersion == 4) { writer.Write(flags); } switch (fileVersion) { case 1: writer.Write((byte)0); break; case 2: writer.Write(compressionType); break; case 3: case 4: writer.Write(compressionType); writer.Write(compressedSize); writer.Write(uncompressedSize); break; default: return; } writer.Write(unityVersionCount); for (int i = 0; i < unityVersionCount; i++) { writer.WriteCountString(unityVersions[i]); } writer.Write(stringTableLen); writer.Write(stringTablePos); }
public void Write(AssetsFileWriter writer) { writer.bigEndian = false; writer.Write(Encoding.ASCII.GetBytes(header)); writer.Write(fileVersion); if (fileVersion == 4) { writer.Write(flags); } switch (fileVersion) { case 1: break; case 3: case 4: if (compressionType != 0) { throw new NotImplementedException("compressed cldb writing not supported"); } writer.Write(compressionType); writer.Write(compressedSize); writer.Write(uncompressedSize); break; default: return; } writer.Write(unityVersionCount); for (int i = 0; i < unityVersionCount; i++) { writer.WriteCountString(unityVersions[i]); } writer.Write(stringTableLen); writer.Write(stringTablePos); }
public void Write(AssetsFileWriter writer) { writer.bigEndian = false; writer.Write(Encoding.ASCII.GetBytes(magic)); writer.Write(fileVersion); writer.Write(compressionType); writer.Write(stringTableOffset); writer.Write(stringTableLenUncompressed); writer.Write(stringTableLenCompressed); if (fileVersion == 1) { writer.Write(fileBlockSize); } writer.Write(fileCount); for (int i = 0; i < fileCount; i++) { ClassDatabaseFileRef fileRef = files[i]; writer.Write(fileRef.offset); writer.Write(fileRef.length); string fixedFileName = fileRef.name.PadRight(15, '\0').Substring(0, 15); writer.Write(Encoding.ASCII.GetBytes(fixedFileName)); } }
public override long WriteReplacer(AssetsFileWriter writer) { throw new NotImplementedException("not implemented"); }
public override long Write(AssetsFileWriter writer) { writer.Write(buffer); return(writer.Position); }
public bool Write(AssetsFileWriter writer, List <BundleReplacer> replacers, ClassDatabaseFile typeMeta = null) { bundleHeader6.Write(writer); if (bundleHeader6.fileVersion >= 7) { writer.Align16(); } AssetBundleBlockAndDirectoryList06 newBundleInf6 = new AssetBundleBlockAndDirectoryList06() { checksumLow = 0, checksumHigh = 0 }; //I could map the assets to their blocks but I don't //have any more-than-1-block files to test on //this should work just fine as far as I know newBundleInf6.blockInf = new AssetBundleBlockInfo06[] { new AssetBundleBlockInfo06 { compressedSize = 0, decompressedSize = 0, flags = 0x40 } }; //assets that did not have their data modified but need //the original info to read from the original file var newToOriginalDirInfoLookup = new Dictionary <AssetBundleDirectoryInfo06, AssetBundleDirectoryInfo06>(); List <AssetBundleDirectoryInfo06> originalDirInfos = new List <AssetBundleDirectoryInfo06>(); List <AssetBundleDirectoryInfo06> dirInfos = new List <AssetBundleDirectoryInfo06>(); List <BundleReplacer> currentReplacers = replacers.ToList(); //this is kind of useless at the moment but leaving it here //because if the AssetsFile size can be precalculated in the //future, we can use this to skip rewriting sizes long currentOffset = 0; //write all original files, modify sizes if needed and skip those to be removed for (int i = 0; i < bundleInf6.directoryCount; i++) { AssetBundleDirectoryInfo06 info = bundleInf6.dirInf[i]; originalDirInfos.Add(info); AssetBundleDirectoryInfo06 newInfo = new AssetBundleDirectoryInfo06() { offset = currentOffset, decompressedSize = info.decompressedSize, flags = info.flags, name = info.name }; BundleReplacer replacer = currentReplacers.FirstOrDefault(n => n.GetOriginalEntryName() == newInfo.name); if (replacer != null) { currentReplacers.Remove(replacer); if (replacer.GetReplacementType() == BundleReplacementType.AddOrModify) { newInfo = new AssetBundleDirectoryInfo06() { offset = currentOffset, decompressedSize = replacer.GetSize(), flags = info.flags, name = replacer.GetEntryName() }; } else if (replacer.GetReplacementType() == BundleReplacementType.Rename) { newInfo = new AssetBundleDirectoryInfo06() { offset = currentOffset, decompressedSize = info.decompressedSize, flags = info.flags, name = replacer.GetEntryName() }; newToOriginalDirInfoLookup[newInfo] = info; } else if (replacer.GetReplacementType() == BundleReplacementType.Remove) { continue; } } else { newToOriginalDirInfoLookup[newInfo] = info; } if (newInfo.decompressedSize != -1) { currentOffset += newInfo.decompressedSize; } dirInfos.Add(newInfo); } //write new files while (currentReplacers.Count > 0) { BundleReplacer replacer = currentReplacers[0]; if (replacer.GetReplacementType() == BundleReplacementType.AddOrModify) { AssetBundleDirectoryInfo06 info = new AssetBundleDirectoryInfo06() { offset = currentOffset, decompressedSize = replacer.GetSize(), flags = 0x04, //idk it just works (tm) name = replacer.GetEntryName() }; currentOffset += info.decompressedSize; dirInfos.Add(info); } currentReplacers.Remove(replacer); } //write the listings long bundleInfPos = writer.Position; newBundleInf6.dirInf = dirInfos.ToArray(); //this is only here to allocate enough space so it's fine if it's inaccurate newBundleInf6.Write(writer); long assetDataPos = writer.Position; //actually write the file data to the bundle now for (int i = 0; i < dirInfos.Count; i++) { AssetBundleDirectoryInfo06 info = dirInfos[i]; BundleReplacer replacer = replacers.FirstOrDefault(n => n.GetEntryName() == info.name); if (replacer != null) { if (replacer.GetReplacementType() == BundleReplacementType.AddOrModify) { long startPos = writer.Position; long endPos = replacer.Write(writer); long size = endPos - startPos; dirInfos[i].decompressedSize = size; dirInfos[i].offset = startPos - assetDataPos; } else if (replacer.GetReplacementType() == BundleReplacementType.Remove) { continue; } } else { if (newToOriginalDirInfoLookup.TryGetValue(info, out AssetBundleDirectoryInfo06 originalInfo)) { long startPos = writer.Position; reader.Position = bundleHeader6.GetFileDataOffset() + originalInfo.offset; reader.BaseStream.CopyToCompat(writer.BaseStream, originalInfo.decompressedSize); dirInfos[i].offset = startPos - assetDataPos; } } } //now that we know what the sizes are of the written files let's go back and fix them long finalSize = writer.Position; uint assetSize = (uint)(finalSize - assetDataPos); writer.Position = bundleInfPos; newBundleInf6.blockInf[0].decompressedSize = assetSize; newBundleInf6.blockInf[0].compressedSize = assetSize; newBundleInf6.dirInf = dirInfos.ToArray(); newBundleInf6.Write(writer); uint infoSize = (uint)(assetDataPos - bundleInfPos); writer.Position = 0; AssetBundleHeader06 newBundleHeader6 = new AssetBundleHeader06() { signature = bundleHeader6.signature, fileVersion = bundleHeader6.fileVersion, minPlayerVersion = bundleHeader6.minPlayerVersion, fileEngineVersion = bundleHeader6.fileEngineVersion, totalFileSize = finalSize, compressedSize = infoSize, decompressedSize = infoSize, flags = bundleHeader6.flags & unchecked ((uint)~0x80) & unchecked ((uint)~0x3f) //unset info at end flag and compression value }; newBundleHeader6.Write(writer); return(true); }
public bool Pack(AssetsFileReader reader, AssetsFileWriter writer, AssetBundleCompressionType compType) { reader.Position = 0; writer.Position = 0; if (Read(reader, false)) { AssetBundleHeader06 newHeader = new AssetBundleHeader06() { signature = bundleHeader6.signature, fileVersion = bundleHeader6.fileVersion, minPlayerVersion = bundleHeader6.minPlayerVersion, fileEngineVersion = bundleHeader6.fileEngineVersion, totalFileSize = 0, compressedSize = 0, decompressedSize = 0, flags = 0x43 }; AssetBundleBlockAndDirectoryList06 newBlockAndDirList = new AssetBundleBlockAndDirectoryList06() { checksumLow = 0, checksumHigh = 0, blockCount = 0, blockInf = null, directoryCount = bundleInf6.directoryCount, dirInf = bundleInf6.dirInf }; List <AssetBundleBlockInfo06> newBlocks = new List <AssetBundleBlockInfo06>(); reader.Position = bundleHeader6.GetFileDataOffset(); int fileDataLength = (int)(bundleHeader6.totalFileSize - reader.Position); byte[] fileData = reader.ReadBytes(fileDataLength); //todo, we just write everything to memory and then write to file //we could calculate the blocks we need ahead of time and correctly //size the block listing before this so we can write directly to file byte[] compressedFileData; switch (compType) { case AssetBundleCompressionType.LZMA: { compressedFileData = SevenZipHelper.Compress(fileData); newBlocks.Add(new AssetBundleBlockInfo06() { compressedSize = (uint)compressedFileData.Length, decompressedSize = (uint)fileData.Length, flags = 0x41 }); break; } case AssetBundleCompressionType.LZ4: { using (var memStreamCom = new MemoryStream()) using (var binaryWriter = new BinaryWriter(memStreamCom)) { using (var memStreamUnc = new MemoryStream(fileData)) using (var binaryReader = new BinaryReader(memStreamUnc)) { //compress into 0x20000 blocks byte[] uncompressedBlock = binaryReader.ReadBytes(131072); while (uncompressedBlock.Length != 0) { byte[] compressedBlock = LZ4Codec.Encode32HC(uncompressedBlock, 0, uncompressedBlock.Length); if (compressedBlock.Length > uncompressedBlock.Length) { newBlocks.Add(new AssetBundleBlockInfo06() { compressedSize = (uint)uncompressedBlock.Length, decompressedSize = (uint)uncompressedBlock.Length, flags = 0x0 }); binaryWriter.Write(uncompressedBlock); } else { newBlocks.Add(new AssetBundleBlockInfo06() { compressedSize = (uint)compressedBlock.Length, decompressedSize = (uint)uncompressedBlock.Length, flags = 0x3 }); binaryWriter.Write(compressedBlock); } uncompressedBlock = binaryReader.ReadBytes(131072); } } compressedFileData = memStreamCom.ToArray(); } break; } case AssetBundleCompressionType.NONE: { compressedFileData = fileData; newBlocks.Add(new AssetBundleBlockInfo06() { compressedSize = (uint)fileData.Length, decompressedSize = (uint)fileData.Length, flags = 0x00 }); break; } default: { return(false); } } newBlockAndDirList.blockInf = newBlocks.ToArray(); byte[] bundleInfoBytes; using (var memStream = new MemoryStream()) { var afw = new AssetsFileWriter(memStream); newBlockAndDirList.Write(afw); bundleInfoBytes = memStream.ToArray(); } if (bundleInfoBytes == null || bundleInfoBytes.Length == 0) { return(false); } //listing is usually lz4 even if the data blocks are lzma byte[] bundleInfoBytesCom = LZ4Codec.Encode32HC(bundleInfoBytes, 0, bundleInfoBytes.Length); byte[] bundleHeaderBytes = null; using (var memStream = new MemoryStream()) { var afw = new AssetsFileWriter(memStream); newHeader.Write(afw); bundleHeaderBytes = memStream.ToArray(); } if (bundleHeaderBytes == null || bundleHeaderBytes.Length == 0) { return(false); } uint totalFileSize = (uint)(bundleHeaderBytes.Length + bundleInfoBytesCom.Length + compressedFileData.Length); newHeader.totalFileSize = totalFileSize; newHeader.decompressedSize = (uint)bundleInfoBytes.Length; newHeader.compressedSize = (uint)bundleInfoBytesCom.Length; newHeader.Write(writer); if (newHeader.fileVersion >= 7) { writer.Align16(); } writer.Write(bundleInfoBytesCom); writer.Write(compressedFileData); return(true); } return(false); }
public bool Unpack(AssetsFileReader reader, AssetsFileWriter writer) { reader.Position = 0; if (Read(reader, true)) { reader.Position = bundleHeader6.GetBundleInfoOffset(); MemoryStream blocksInfoStream; AssetsFileReader memReader; int compressedSize = (int)bundleHeader6.compressedSize; switch (bundleHeader6.GetCompressionType()) { case 1: using (MemoryStream mstream = new MemoryStream(reader.ReadBytes(compressedSize))) { blocksInfoStream = SevenZipHelper.StreamDecompress(mstream); } break; case 2: case 3: byte[] uncompressedBytes = new byte[bundleHeader6.decompressedSize]; using (MemoryStream mstream = new MemoryStream(reader.ReadBytes(compressedSize))) { var decoder = new Lz4DecoderStream(mstream); decoder.Read(uncompressedBytes, 0, (int)bundleHeader6.decompressedSize); decoder.Dispose(); } blocksInfoStream = new MemoryStream(uncompressedBytes); break; default: blocksInfoStream = null; break; } if (bundleHeader6.GetCompressionType() != 0) { using (memReader = new AssetsFileReader(blocksInfoStream)) { memReader.Position = 0; bundleInf6.Read(0, memReader); } } AssetBundleHeader06 newBundleHeader6 = new AssetBundleHeader06() { signature = bundleHeader6.signature, fileVersion = bundleHeader6.fileVersion, minPlayerVersion = bundleHeader6.minPlayerVersion, fileEngineVersion = bundleHeader6.fileEngineVersion, totalFileSize = 0, compressedSize = bundleHeader6.decompressedSize, decompressedSize = bundleHeader6.decompressedSize, flags = bundleHeader6.flags & 0x40 //set compression and block position to 0 }; long fileSize = newBundleHeader6.GetFileDataOffset(); for (int i = 0; i < bundleInf6.blockCount; i++) { fileSize += bundleInf6.blockInf[i].decompressedSize; } newBundleHeader6.totalFileSize = fileSize; AssetBundleBlockAndDirectoryList06 newBundleInf6 = new AssetBundleBlockAndDirectoryList06() { checksumLow = 0, //-todo, figure out how to make real checksums, uabe sets these to 0 too checksumHigh = 0, blockCount = bundleInf6.blockCount, directoryCount = bundleInf6.directoryCount }; newBundleInf6.blockInf = new AssetBundleBlockInfo06[newBundleInf6.blockCount]; for (int i = 0; i < newBundleInf6.blockCount; i++) { newBundleInf6.blockInf[i] = new AssetBundleBlockInfo06() { compressedSize = bundleInf6.blockInf[i].decompressedSize, decompressedSize = bundleInf6.blockInf[i].decompressedSize, flags = (ushort)(bundleInf6.blockInf[i].flags & 0xC0) //set compression to none }; } newBundleInf6.dirInf = new AssetBundleDirectoryInfo06[newBundleInf6.directoryCount]; for (int i = 0; i < newBundleInf6.directoryCount; i++) { newBundleInf6.dirInf[i] = new AssetBundleDirectoryInfo06() { offset = bundleInf6.dirInf[i].offset, decompressedSize = bundleInf6.dirInf[i].decompressedSize, flags = bundleInf6.dirInf[i].flags, name = bundleInf6.dirInf[i].name }; } newBundleHeader6.Write(writer); if (newBundleHeader6.fileVersion >= 7) { writer.Align16(); } newBundleInf6.Write(writer); reader.Position = bundleHeader6.GetFileDataOffset(); for (int i = 0; i < newBundleInf6.blockCount; i++) { AssetBundleBlockInfo06 info = bundleInf6.blockInf[i]; switch (info.GetCompressionType()) { case 0: reader.BaseStream.CopyToCompat(writer.BaseStream, info.compressedSize); break; case 1: SevenZipHelper.StreamDecompress(reader.BaseStream, writer.BaseStream, info.compressedSize, info.decompressedSize); break; case 2: case 3: using (MemoryStream tempMs = new MemoryStream()) { reader.BaseStream.CopyToCompat(tempMs, info.compressedSize); tempMs.Position = 0; using (Lz4DecoderStream decoder = new Lz4DecoderStream(tempMs)) { decoder.CopyToCompat(writer.BaseStream, info.decompressedSize); } } break; } } return(true); } return(false); }
public abstract long WriteReplacer(AssetsFileWriter writer);