com.wallstop-studios.unity-helpers 2.0.0-rc78.9 → 2.0.0-rc79.1

package/Runtime/Utils/Ascii85.cs

@@ -0,0 +1,115 @@
+namespace WallstopStudios.UnityHelpers.Utils
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Text;
+    using System.Threading;
+
+    public static class Ascii85
+    {
+        private static readonly ThreadLocal<StringBuilder> StringBuilderCache = new(() =>
+            new StringBuilder()
+        );
+
+        private static readonly ThreadLocal<byte[]> ChunkCache = new(() => new byte[4]);
+        private static readonly ThreadLocal<char[]> EncodedCache = new(() => new char[5]);
+        private static readonly ThreadLocal<List<byte>> ByteListCache = new(() => new List<byte>());
+
+        private static readonly uint[] Pow85 = { 85 * 85 * 85 * 85, 85 * 85 * 85, 85 * 85, 85, 1 };
+
+        public static string Encode(byte[] data)
+        {
+            if (data == null)
+            {
+                return null;
+            }
+
+            StringBuilder stringBuilder = StringBuilderCache.Value;
+            stringBuilder.Clear();
+            int index = 0;
+
+            byte[] chunk = ChunkCache.Value;
+            char[] encoded = EncodedCache.Value;
+            while (index < data.Length)
+            {
+                Array.Clear(chunk, 0, chunk.Length);
+                int chunkLength = 0;
+
+                for (int i = 0; i < 4 && index < data.Length; ++i)
+                {
+                    chunk[i] = data[index++];
+                    chunkLength++;
+                }
+
+                uint val =
+                    ((uint)chunk[0] << 24)
+                    | ((uint)chunk[1] << 16)
+                    | ((uint)chunk[2] << 8)
+                    | chunk[3];
+
+                if (val == 0 && chunkLength == 4)
+                {
+                    stringBuilder.Append('z');
+                    continue;
+                }
+
+                Array.Clear(encoded, 0, encoded.Length);
+                for (int i = 0; i < encoded.Length; ++i)
+                {
+                    encoded[i] = (char)(val / Pow85[i] + '!');
+                    val %= Pow85[i];
+                }
+
+                for (int i = 0; i < chunkLength + 1; ++i)
+                {
+                    stringBuilder.Append(encoded[i]);
+                }
+            }
+            return stringBuilder.ToString();
+        }
+
+        public static byte[] Decode(string encoded)
+        {
+            if (string.IsNullOrEmpty(encoded))
+            {
+                return Array.Empty<byte>();
+            }
+
+            encoded = encoded.Replace("z", "!!!!!");
+
+            List<byte> result = ByteListCache.Value;
+            result.Clear();
+            int index = 0;
+            char[] chunk = EncodedCache.Value;
+            byte[] decodedBytes = ChunkCache.Value;
+            while (index < encoded.Length)
+            {
+                Array.Fill(chunk, (char)117);
+                int chunkLen = 0;
+
+                for (int i = 0; i < 5 && index < encoded.Length; ++i)
+                {
+                    chunk[i] = encoded[index++];
+                    chunkLen++;
+                }
+
+                uint val = 0;
+                for (int i = 0; i < 5; ++i)
+                {
+                    val += (uint)(chunk[i] - '!') * Pow85[i];
+                }
+
+                decodedBytes[0] = (byte)(val >> 24);
+                decodedBytes[1] = (byte)(val >> 16);
+                decodedBytes[2] = (byte)(val >> 8);
+                decodedBytes[3] = (byte)val;
+
+                for (int i = 0; i < chunkLen - 1; ++i)
+                {
+                    result.Add(decodedBytes[i]);
+                }
+            }
+            return result.ToArray();
+        }
+    }
+}

package/Runtime/Utils/Ascii85.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 852c7e2a84f64cfc9e5e44b0f5d1f597
+timeCreated: 1756399903

package/Runtime/Utils/LZMA.cs

@@ -0,0 +1,53 @@
+namespace WallstopStudios.UnityHelpers.Utils
+{
+    // LzmaHelper.cs - A wrapper for the LZMA SDK
+    using System;
+    using System.IO;
+    using System.Threading;
+    using SevenZip.Compression.LZMA;
+
+    public static class LZMA
+    {
+        private static readonly ThreadLocal<Decoder> Decoders = new(() => new Decoder());
+        private static readonly ThreadLocal<Encoder> Encoders = new(() => new Encoder());
+        private static readonly ThreadLocal<byte[]> Properties = new(() => new byte[5]);
+        private static readonly ThreadLocal<byte[]> FileLengths = new(() => new byte[8]);
+
+        public static byte[] Compress(byte[] input)
+        {
+            Encoder encoder = Encoders.Value;
+            using MemoryStream inStream = new(input, writable: false);
+            using MemoryStream outStream = new();
+            encoder.WriteCoderProperties(outStream);
+
+            // Write original file size
+            outStream.Write(BitConverter.GetBytes(inStream.Length), 0, 8);
+
+            // Compress the data
+            encoder.Code(inStream, outStream, inStream.Length, -1, null);
+            return outStream.ToArray();
+        }
+
+        public static byte[] Decompress(byte[] input)
+        {
+            Decoder decoder = Decoders.Value;
+            using MemoryStream inStream = new(input, writable: false);
+            using MemoryStream outStream = new();
+            // Read decoder properties
+            byte[] properties = Properties.Value;
+            Array.Clear(properties, 0, properties.Length);
+            inStream.Read(properties, 0, properties.Length);
+            decoder.SetDecoderProperties(properties);
+
+            // Read original file size
+            byte[] fileLengthBytes = FileLengths.Value;
+            Array.Clear(fileLengthBytes, 0, fileLengthBytes.Length);
+            inStream.Read(fileLengthBytes, 0, 8);
+            long fileLength = BitConverter.ToInt64(fileLengthBytes, 0);
+
+            // Decompress the data
+            decoder.Code(inStream, outStream, inStream.Length, fileLength, null);
+            return outStream.ToArray();
+        }
+    }
+}

package/Runtime/Utils/LZMA.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: a40192abcf3c407080bcba2fc551e225
+timeCreated: 1756402526

package/Runtime/Utils/SevenZip/Common/CRC.cs

@@ -0,0 +1,61 @@
+// Common/CRC.cs
+
+namespace SevenZip
+{
+    class CRC
+    {
+        public static readonly uint[] Table;
+
+        static CRC()
+        {
+            Table = new uint[256];
+            const uint kPoly = 0xEDB88320;
+            for (uint i = 0; i < 256; i++)
+            {
+                uint r = i;
+                for (int j = 0; j < 8; j++)
+                    if ((r & 1) != 0)
+                        r = (r >> 1) ^ kPoly;
+                    else
+                        r >>= 1;
+                Table[i] = r;
+            }
+        }
+
+        uint _value = 0xFFFFFFFF;
+
+        public void Init()
+        {
+            _value = 0xFFFFFFFF;
+        }
+
+        public void UpdateByte(byte b)
+        {
+            _value = Table[(((byte)(_value)) ^ b)] ^ (_value >> 8);
+        }
+
+        public void Update(byte[] data, uint offset, uint size)
+        {
+            for (uint i = 0; i < size; i++)
+                _value = Table[(((byte)(_value)) ^ data[offset + i])] ^ (_value >> 8);
+        }
+
+        public uint GetDigest()
+        {
+            return _value ^ 0xFFFFFFFF;
+        }
+
+        static uint CalculateDigest(byte[] data, uint offset, uint size)
+        {
+            CRC crc = new CRC();
+            // crc.Init();
+            crc.Update(data, offset, size);
+            return crc.GetDigest();
+        }
+
+        static bool VerifyDigest(uint digest, byte[] data, uint offset, uint size)
+        {
+            return (CalculateDigest(data, offset, size) == digest);
+        }
+    }
+}

package/Runtime/Utils/SevenZip/Common/CRC.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 3dc8670f79b8cc04ebf2dc9503c3b212
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Utils/SevenZip/Common/InBuffer.cs

@@ -0,0 +1,71 @@
+// InBuffer.cs
+
+namespace SevenZip.Buffer
+{
+    public class InBuffer
+    {
+        byte[] m_Buffer;
+        uint m_Pos;
+        uint m_Limit;
+        uint m_BufferSize;
+        System.IO.Stream m_Stream;
+        bool m_StreamWasExhausted;
+        ulong m_ProcessedSize;
+
+        public InBuffer(uint bufferSize)
+        {
+            m_Buffer = new byte[bufferSize];
+            m_BufferSize = bufferSize;
+        }
+
+        public void Init(System.IO.Stream stream)
+        {
+            m_Stream = stream;
+            m_ProcessedSize = 0;
+            m_Limit = 0;
+            m_Pos = 0;
+            m_StreamWasExhausted = false;
+        }
+
+        public bool ReadBlock()
+        {
+            if (m_StreamWasExhausted)
+                return false;
+            m_ProcessedSize += m_Pos;
+            int aNumProcessedBytes = m_Stream.Read(m_Buffer, 0, (int)m_BufferSize);
+            m_Pos = 0;
+            m_Limit = (uint)aNumProcessedBytes;
+            m_StreamWasExhausted = (aNumProcessedBytes == 0);
+            return (!m_StreamWasExhausted);
+        }
+
+        public void ReleaseStream()
+        {
+            // m_Stream.Close();
+            m_Stream = null;
+        }
+
+        public bool ReadByte(byte b) // check it
+        {
+            if (m_Pos >= m_Limit)
+                if (!ReadBlock())
+                    return false;
+            b = m_Buffer[m_Pos++];
+            return true;
+        }
+
+        public byte ReadByte()
+        {
+            // return (byte)m_Stream.ReadByte();
+            if (m_Pos >= m_Limit)
+                if (!ReadBlock())
+                    return 0xFF;
+            return m_Buffer[m_Pos++];
+        }
+
+        public ulong GetProcessedSize()
+        {
+            return m_ProcessedSize + m_Pos;
+        }
+    }
+}

package/Runtime/Utils/SevenZip/Common/InBuffer.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: d9ac1800f49f3ef49b15cedc6801f985
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Utils/SevenZip/Common/OutBuffer.cs

@@ -0,0 +1,65 @@
+// OutBuffer.cs
+
+namespace SevenZip.Buffer
+{
+    public class OutBuffer
+    {
+        byte[] m_Buffer;
+        uint m_Pos;
+        uint m_BufferSize;
+        System.IO.Stream m_Stream;
+        ulong m_ProcessedSize;
+
+        public OutBuffer(uint bufferSize)
+        {
+            m_Buffer = new byte[bufferSize];
+            m_BufferSize = bufferSize;
+        }
+
+        public void SetStream(System.IO.Stream stream)
+        {
+            m_Stream = stream;
+        }
+
+        public void FlushStream()
+        {
+            m_Stream.Flush();
+        }
+
+        public void CloseStream()
+        {
+            m_Stream.Close();
+        }
+
+        public void ReleaseStream()
+        {
+            m_Stream = null;
+        }
+
+        public void Init()
+        {
+            m_ProcessedSize = 0;
+            m_Pos = 0;
+        }
+
+        public void WriteByte(byte b)
+        {
+            m_Buffer[m_Pos++] = b;
+            if (m_Pos >= m_BufferSize)
+                FlushData();
+        }
+
+        public void FlushData()
+        {
+            if (m_Pos == 0)
+                return;
+            m_Stream.Write(m_Buffer, 0, (int)m_Pos);
+            m_Pos = 0;
+        }
+
+        public ulong GetProcessedSize()
+        {
+            return m_ProcessedSize + m_Pos;
+        }
+    }
+}

package/Runtime/Utils/SevenZip/Common/OutBuffer.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 694fae53bf0755f4daf26b34bc69017c
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Utils/SevenZip/Common.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 1aabbf2e9b0c44cab7a350196de304ee
+timeCreated: 1756403037

package/Runtime/Utils/SevenZip/Compress/LZ/IMatchFinder.cs

@@ -0,0 +1,28 @@
+// IMatchFinder.cs
+
+using System;
+
+namespace SevenZip.Compression.LZ
+{
+    interface IInWindowStream
+    {
+        void SetStream(System.IO.Stream inStream);
+        void Init();
+        void ReleaseStream();
+        Byte GetIndexByte(Int32 index);
+        UInt32 GetMatchLen(Int32 index, UInt32 distance, UInt32 limit);
+        UInt32 GetNumAvailableBytes();
+    }
+
+    interface IMatchFinder : IInWindowStream
+    {
+        void Create(
+            UInt32 historySize,
+            UInt32 keepAddBufferBefore,
+            UInt32 matchMaxLen,
+            UInt32 keepAddBufferAfter
+        );
+        UInt32 GetMatches(UInt32[] distances);
+        void Skip(UInt32 num);
+    }
+}

package/Runtime/Utils/SevenZip/Compress/LZ/IMatchFinder.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: faf30c7802a24124cb5e5942544e622c
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: