com.wallstop-studios.unity-helpers 2.0.0-rc79 → 2.0.0-rc79.2

package/Runtime/Core/Helper/FormattingHelpers.cs

@@ -1,6 +1,8 @@
 namespace WallstopStudios.UnityHelpers.Core.Helper
 {
     using System;
+    using System.Text;
+    using WallstopStudios.UnityHelpers.Utils;
 
     public static class FormattingHelpers
     {
@@ -26,7 +28,11 @@
                 }
             }
 
-            return $"{len:0.##} {ByteSizes[order]}";
+            StringBuilder stringBuilder = Buffers.StringBuilder;
+            stringBuilder.Clear();
+            stringBuilder.AppendFormat("{0:0.##} ", len);
+            stringBuilder.Append(ByteSizes[order]);
+            return stringBuilder.ToString();
         }
     }
 }

package/Runtime/Utils/Buffers.cs

@@ -1,6 +1,7 @@
 namespace WallstopStudios.UnityHelpers.Utils
 {
     using System.Collections.Generic;
+    using System.Text;
     using UnityEngine;
 
     public static class Buffers
@@ -20,10 +21,13 @@
         public static readonly System.Random Random = new();
         public static readonly WaitForFixedUpdate WaitForFixedUpdate = new();
         public static readonly WaitForEndOfFrame WaitForEndOfFrame = new();
+
+        public static readonly StringBuilder StringBuilder = new();
     }
 
     public static class Buffers<T>
     {
+        public static readonly T[] Array = new T[Buffers.BufferSize];
         public static readonly List<T> List = new();
         public static readonly HashSet<T> HashSet = new();
         public static readonly Queue<T> Queue = new();

package/Runtime/Utils/CircleLineRenderer.cs

@@ -1,5 +1,7 @@
 namespace WallstopStudios.UnityHelpers.Utils
 {
+    using System;
+    using System.Collections.Generic;
     using Core.Attributes;
     using Core.Extension;
     using Core.Helper;
@@ -34,6 +36,8 @@
 
         private Coroutine _update;
 
+        private readonly Dictionary<int, Vector3[]> _cachedSegments = new();
+
         private void Awake()
         {
             this.AssignSiblingComponents();
@@ -114,7 +118,13 @@
                 float angle = 360f / numSegments;
                 float offsetRadians = PRNG.Instance.NextFloat(angle);
                 float currentOffset = offsetRadians;
-                Vector3[] positions = new Vector3[numSegments];
+                if (!_cachedSegments.TryGetValue(numSegments, out Vector3[] positions))
+                {
+                    positions = new Vector3[numSegments];
+                    _cachedSegments[numSegments] = positions;
+                }
+
+                Array.Clear(positions, 0, numSegments);
                 for (int i = 0; i < numSegments; ++i)
                 {
                     positions[i] =

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: