v0.80.30

AssetStudio/EndianBinaryReader.cs

@@ -1,6 +1,8 @@
 using System;
 using System.Buffers.Binary;
+using System.Collections.Generic;
 using System.IO;
+using System.Text;
 
 namespace AssetStudio
 {
@@ -10,11 +12,10 @@ namespace AssetStudio
 
         public EndianType Endian;
 
-        public EndianBinaryReader(Stream stream, EndianType endian = EndianType.BigEndian, Game game = null) : base(stream)
+        public EndianBinaryReader(Stream stream, EndianType endian = EndianType.BigEndian, bool leaveOpen = false) : base(stream, Encoding.UTF8, leaveOpen)
         {
             Endian = endian;
             buffer = new byte[8];
-            Game = game;
         }
 
         public long Position
@@ -23,8 +24,8 @@ namespace AssetStudio
             set => BaseStream.Position = value;
         }
 
-        public long[] BundlePos = Array.Empty<long>();
-        public Game Game;
+        public long Length => BaseStream.Length;
+        public long Remaining => Length - Position;
 
         public override short ReadInt16()
         {
@@ -108,9 +109,179 @@ namespace AssetStudio
             return base.ReadDouble();
         }
 
-        public Float ReadFloat()
+        public void AlignStream()
         {
-            return new Float(ReadSingle());
+            AlignStream(4);
+        }
+
+        public void AlignStream(int alignment)
+        {
+            var pos = Position;
+            var mod = pos % alignment;
+            if (mod != 0)
+            {
+                Position += alignment - mod;
+            }
+        }
+
+        public string ReadAlignedString()
+        {
+            var length = ReadInt32();
+            if (length > 0 && length <= Remaining)
+            {
+                var stringData = ReadBytes(length);
+                var result = Encoding.UTF8.GetString(stringData);
+                AlignStream(4);
+                return result;
+            }
+            return "";
+        }
+
+        public string ReadStringToNull(int maxLength = 32767)
+        {
+            var bytes = new List<byte>();
+            int count = 0;
+            while (Remaining > 0 && count < maxLength)
+            {
+                var b = ReadByte();
+                if (b == 0)
+                {
+                    break;
+                }
+                bytes.Add(b);
+                count++;
+            }
+            return Encoding.UTF8.GetString(bytes.ToArray());
+        }
+
+        public Quaternion ReadQuaternion()
+        {
+            return new Quaternion(ReadSingle(), ReadSingle(), ReadSingle(), ReadSingle());
+        }
+
+        public Vector2 ReadVector2()
+        {
+            return new Vector2(ReadSingle(), ReadSingle());
+        }
+
+        public Vector3 ReadVector3()
+        {
+            return new Vector3(ReadSingle(), ReadSingle(), ReadSingle());
+        }
+
+        public Vector4 ReadVector4()
+        {
+            return new Vector4(ReadSingle(), ReadSingle(), ReadSingle(), ReadSingle());
+        }
+
+        public Color ReadColor4()
+        {
+            return new Color(ReadSingle(), ReadSingle(), ReadSingle(), ReadSingle());
+        }
+
+        public Matrix4x4 ReadMatrix()
+        {
+            return new Matrix4x4(ReadSingleArray(16));
+        }
+
+        public int ReadMhy0Int()
+        {
+            var buffer = ReadBytes(6);
+            return buffer[2] | (buffer[4] << 8) | (buffer[0] << 0x10) | (buffer[5] << 0x18);
+        }
+
+        public uint ReadMhy0UInt()
+        {
+            var buffer = ReadBytes(7);
+            return (uint)(buffer[1] | (buffer[6] << 8) | (buffer[3] << 0x10) | (buffer[2] << 0x18));
+        }
+
+        public string ReadMhy0String()
+        {
+            var pos = BaseStream.Position;
+            var str = ReadStringToNull();
+            BaseStream.Position += 0x105 - (BaseStream.Position - pos);
+            return str;
+        }
+
+        private T[] ReadArray<T>(Func<T> del, int length)
+        {
+            var array = new T[length];
+            for (int i = 0; i < length; i++)
+            {
+                array[i] = del();
+            }
+            return array;
+        }
+
+        public bool[] ReadBooleanArray()
+        {
+            return ReadArray(ReadBoolean, ReadInt32());
+        }
+
+        public byte[] ReadUInt8Array()
+        {
+            return ReadBytes(ReadInt32());
+        }
+
+        public ushort[] ReadUInt16Array()
+        {
+            return ReadArray(ReadUInt16, ReadInt32());
+        }
+
+        public int[] ReadInt32Array()
+        {
+            return ReadArray(ReadInt32, ReadInt32());
+        }
+
+        public int[] ReadInt32Array(int length)
+        {
+            return ReadArray(ReadInt32, length);
+        }
+
+        public uint[] ReadUInt32Array()
+        {
+            return ReadArray(ReadUInt32, ReadInt32());
+        }
+
+        public uint[][] ReadUInt32ArrayArray()
+        {
+            return ReadArray(ReadUInt32Array, ReadInt32());
+        }
+
+        public uint[] ReadUInt32Array(int length)
+        {
+            return ReadArray(ReadUInt32, length);
+        }
+
+        public float[] ReadSingleArray()
+        {
+            return ReadArray(ReadSingle, ReadInt32());
+        }
+
+        public float[] ReadSingleArray(int length)
+        {
+            return ReadArray(ReadSingle, length);
+        }
+
+        public string[] ReadStringArray()
+        {
+            return ReadArray(ReadAlignedString, ReadInt32());
+        }
+
+        public Vector2[] ReadVector2Array()
+        {
+            return ReadArray(ReadVector2, ReadInt32());
+        }
+
+        public Vector4[] ReadVector4Array()
+        {
+            return ReadArray(ReadVector4, ReadInt32());
+        }
+
+        public Matrix4x4[] ReadMatrixArray()
+        {
+            return ReadArray(ReadMatrix, ReadInt32());
         }
     }
 }