Rebuilt CPK tools (#20)

- Rebuilt how CPKs are read and written to, speeding up CPK repacking and massively reducing allocations

Author: TheTrueColonel

.gitignore

@@ -495,3 +495,4 @@ fabric.properties
 ### Custom ###
 launchSettings.json
 .idea/.idea.ShinRyuModManager-CE/.idea/sonarlint.xml
+dist/

CpkTools/ColumnFlags.cs

@@ -0,0 +1,24 @@
+namespace CpkTools;
+
+public enum StorageFlags {
+    StorageMask = 0xF0,
+    StorageNone = 0x00,
+    StorageZero = 0x10,
+    StorageConstant = 0x30,
+    StoragePerrow = 0x50,
+}
+
+public enum TypeFlags {
+    TypeMask = 0x0F,
+    TypeData = 0x0B,
+    TypeString = 0x0A,
+    TypeFloat = 0x08,
+    Type8Byte2 = 0x07,
+    Type8Byte = 0x06,
+    Type4Byte2 = 0x05,
+    Type4Byte = 0x04,
+    Type2Byte2 = 0x03,
+    Type2Byte = 0x02,
+    Type1Byte2 = 0x01,
+    Type1Byte = 0x00,
+}

CpkTools/Comparers/FileEntryIdComparer.cs

@@ -0,0 +1,15 @@
+using CpkTools.Model;
+
+namespace CpkTools.Comparers;
+
+public sealed class FileEntryIdComparer : IComparer<FileEntry> {
+    public static readonly FileEntryIdComparer Instance = new();
+
+    public int Compare(FileEntry? x, FileEntry? y) {
+        if (ReferenceEquals(x, y)) return 0;
+        if (x is null) return -1;
+        if (y is null) return 1;
+
+        return x.Id.CompareTo(y.Id);
+    }
+}

CpkTools/CpkTools.csproj

@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <TargetFramework>net10.0</TargetFramework>
+        <ImplicitUsings>enable</ImplicitUsings>
+        <Nullable>enable</Nullable>
+    </PropertyGroup>
+
+    <ItemGroup>
+      <PackageReference Include="CommunityToolkit.HighPerformance" Version="8.4.0" />
+    </ItemGroup>
+
+</Project>

CpkTools/Endian/EndianReader.cs

@@ -0,0 +1,176 @@
+using System.Buffers.Binary;
+using CommunityToolkit.HighPerformance;
+
+namespace CpkTools.Endian;
+
+public sealed class EndianReader : IDisposable {
+    public bool IsLittleEndian { get; set; }
+    public long Position { get => BaseStream.Position; }
+    public Stream BaseStream { get; }
+
+    public EndianReader(Memory<byte> data, bool isLittleEndian = false) {
+        BaseStream = data.AsStream();
+        IsLittleEndian = isLittleEndian;
+    }
+
+    public EndianReader(byte[] data, bool isLittleEndian = false) {
+        BaseStream = new MemoryStream(data);
+        IsLittleEndian = isLittleEndian;
+    }
+
+    public EndianReader(Stream stream, bool isLittleEndian = false) {
+        BaseStream = stream;
+        IsLittleEndian = isLittleEndian;
+    }
+
+    public Half ReadHalf() {
+        Span<byte> buffer = stackalloc byte[2];
+
+        BaseStream.ReadExactly(buffer);
+
+        return IsLittleEndian
+            ? BinaryPrimitives.ReadHalfLittleEndian(buffer)
+            : BinaryPrimitives.ReadHalfBigEndian(buffer);
+    }
+
+    public float ReadSingle() {
+        Span<byte> buffer = stackalloc byte[4];
+        
+        BaseStream.ReadExactly(buffer);
+
+        return IsLittleEndian
+            ? BinaryPrimitives.ReadSingleLittleEndian(buffer)
+            : BinaryPrimitives.ReadSingleBigEndian(buffer);
+    }
+
+    public double ReadDouble() {
+        Span<byte> buffer = stackalloc byte[8];
+        
+        BaseStream.ReadExactly(buffer);
+
+        return IsLittleEndian
+            ? BinaryPrimitives.ReadDoubleLittleEndian(buffer)
+            : BinaryPrimitives.ReadDoubleBigEndian(buffer);
+    }
+
+    public short ReadInt16() {
+        Span<byte> buffer = stackalloc byte[2];
+
+        BaseStream.ReadExactly(buffer);
+
+        return IsLittleEndian
+            ? BinaryPrimitives.ReadInt16LittleEndian(buffer)
+            : BinaryPrimitives.ReadInt16BigEndian(buffer);
+    }
+
+    public int ReadInt32() {
+        Span<byte> buffer = stackalloc byte[4];
+
+        BaseStream.ReadExactly(buffer);
+
+        return IsLittleEndian
+            ? BinaryPrimitives.ReadInt32LittleEndian(buffer)
+            : BinaryPrimitives.ReadInt32BigEndian(buffer);
+    }
+
+    public long ReadInt64() {
+        Span<byte> buffer = stackalloc byte[8];
+
+        BaseStream.ReadExactly(buffer);
+
+        return IsLittleEndian
+            ? BinaryPrimitives.ReadInt64LittleEndian(buffer)
+            : BinaryPrimitives.ReadInt64BigEndian(buffer);
+    }
+
+    public ushort ReadUInt16() {
+        Span<byte> buffer = stackalloc byte[2];
+
+        BaseStream.ReadExactly(buffer);
+
+        return IsLittleEndian
+            ? BinaryPrimitives.ReadUInt16LittleEndian(buffer)
+            : BinaryPrimitives.ReadUInt16BigEndian(buffer);
+    }
+
+    public uint ReadUInt32() {
+        Span<byte> buffer = stackalloc byte[4];
+
+        BaseStream.ReadExactly(buffer);
+
+        return IsLittleEndian
+            ? BinaryPrimitives.ReadUInt32LittleEndian(buffer)
+            : BinaryPrimitives.ReadUInt32BigEndian(buffer);
+    }
+
+    public ulong ReadUInt64() {
+        Span<byte> buffer = stackalloc byte[8];
+
+        BaseStream.ReadExactly(buffer);
+
+        return IsLittleEndian
+            ? BinaryPrimitives.ReadUInt64LittleEndian(buffer)
+            : BinaryPrimitives.ReadUInt64BigEndian(buffer);
+    }
+
+    public byte ReadByte() {
+        var value = BaseStream.ReadByte();
+
+        if (value == -1)
+            throw new EndOfStreamException();
+
+        return (byte)value;
+    }
+
+    public byte[] ReadBytes(int count) {
+        ArgumentOutOfRangeException.ThrowIfNegative(count);
+
+        if (count == 0) {
+            return [];
+        }
+
+        var result = new byte[count];
+        var numRead = BaseStream.ReadAtLeast(result, result.Length, throwOnEndOfStream: false);
+
+        if (numRead != result.Length) {
+            // Trim array. This should happen on EOF & possibly net streams.
+            result = result[..numRead];
+        }
+
+        return result;
+    }
+
+    public int ReadStreamInto(Stream dest, int length) {
+        ArgumentOutOfRangeException.ThrowIfNegative(length);
+
+        if (length == 0) {
+            return 0;
+        }
+
+        var buffer = new byte[80 * 1024];
+        var remaining = length;
+        var totalRead = 0;
+
+        while (remaining > 0) {
+            var toRead = Math.Min(buffer.Length, remaining);
+            var read = BaseStream.Read(buffer, 0, toRead);
+            
+            if (read == 0) // EOF
+                break;
+            
+            dest.Write(buffer, 0, read);
+            totalRead += read;
+            remaining -= read;
+        }
+        
+        return totalRead;
+    }
+
+    public void Seek(long offset, SeekOrigin origin) {
+        BaseStream.Seek(offset, origin);
+    }
+
+    public void Dispose() {
+        BaseStream.Dispose();
+    }
+}