Projektdateien hinzufügen.

Directory.Build.props

@@ -0,0 +1,13 @@
+<Project>
+
+ <PropertyGroup>
+   <LangVersion>latest</LangVersion>
+   <Copyright>Copyright © Pilzinsel64 2018 - 2024</Copyright>
+    <Authors>Pilzinsel64</Authors>
+ </PropertyGroup>
+ 
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
+  <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
+</PropertyGroup>
+
+</Project>

SM64Lib.LIBMIO0/MIO0.cs

@@ -0,0 +1,151 @@
+using System;
+
+namespace SM64Lib.LIBMIO0
+{
+    public struct MIO0_Header
+    {
+        public uint dest_size;
+        public uint comp_offset;
+        public uint uncomp_offset;
+        public bool big_endian;
+    };
+
+    public class MIO0
+    {
+
+        private const int MIO0_HEADER_LENGTH = 16;
+
+        private static int GET_BIT(byte[] buf, int offset, int bit)
+        {
+            return buf[(bit / 8) + offset] & (1 << (7 - (bit % 8)));
+        }
+
+        private static bool compareByteArrays(byte[] buf1, byte[] buf2, int length)
+        {
+            for (int i = 0; i < length; ++i)
+                if (buf1[i] != buf2[i]) return false;
+            return true;
+        }
+
+        private static uint read_u32_be(byte[] buf, int off)
+        {
+            return (uint)(((buf)[off + 0] << 24) + ((buf)[off + 1] << 16) +
+                ((buf)[off + 2] << 8) + ((buf)[off + 3]));
+        }
+
+        private static uint read_u32_le(byte[] buf, int off)
+        {
+            return (uint)(((buf)[off + 1] << 24) + ((buf)[off + 0] << 16) +
+                ((buf)[off + 3] << 8) + ((buf)[off + 2]));
+        }
+
+        private static void write_u32_be(byte[] buf, uint val, int off)
+        {
+            buf[off + 0] = (byte)((val >> 24) & 0xFF);
+            buf[off + 1] = (byte)((val >> 16) & 0xFF);
+            buf[off + 2] = (byte)((val >> 8) & 0xFF);
+            buf[off + 3] = (byte)(val & 0xFF);
+        }
+
+        ///<summary>
+        /// decode MIO0 header<para/>
+        /// returns true if valid header, false otherwise
+        ///</summary>
+        public static bool decode_header(byte[] buf, ref MIO0_Header head)
+        {
+            byte[] mio0_ascii_be = new byte[] { 0x4D, 0x49, 0x4F, 0x30 };
+            byte[] mio0_ascii_le = new byte[] { 0x49, 0x4D, 0x30, 0x4F };
+
+            if (compareByteArrays(buf, mio0_ascii_be, 4))
+            {
+                head.dest_size = read_u32_be(buf, 4);
+                head.comp_offset = read_u32_be(buf, 8);
+                head.uncomp_offset = read_u32_be(buf, 12);
+                head.big_endian = true;
+                return true;
+            }
+            else if (compareByteArrays(buf, mio0_ascii_le, 4))
+            {
+                head.dest_size = read_u32_le(buf, 4);
+                head.comp_offset = read_u32_le(buf, 8);
+                head.uncomp_offset = read_u32_le(buf, 12);
+                head.big_endian = false;
+                return true;
+            }
+
+            return false;
+        }
+
+        ///<summary>
+        /// encode MIO0 header from struct
+        ///</summary>
+        public static void encode_header(byte[] buf, ref MIO0_Header head)
+        {
+            write_u32_be(buf, 0x4D494F30, 0); // write "MIO0" at start of buffer
+            write_u32_be(buf, head.dest_size, 4);
+            write_u32_be(buf, head.comp_offset, 8);
+            write_u32_be(buf, head.uncomp_offset, 12);
+        }
+
+        ///<summary>
+        /// decode MIO0 data<para/>
+        /// mio0_buf: buffer containing MIO0 data<para/>
+        /// returns the raw data as a byte array
+        ///</summary>
+        public static byte[] mio0_decode(byte[] mio0_buf)
+        {
+
+            MIO0_Header head = new MIO0_Header();
+            uint bytes_written = 0;
+            int bit_idx = 0;
+            int comp_idx = 0;
+            int uncomp_idx = 0;
+            bool valid;
+
+            // extract header
+            valid = decode_header(mio0_buf, ref head);
+            // verify MIO0 header
+            if (!valid)
+            {
+                return null;
+            }
+
+            if (!head.big_endian)
+            {
+                return null;
+            }
+
+            byte[] decoded = new byte[head.dest_size];
+
+            // decode data
+            while (bytes_written < head.dest_size)
+            {
+                if (GET_BIT(mio0_buf, MIO0_HEADER_LENGTH, bit_idx) > 0)
+                {
+                    // 1 - pull uncompressed data
+                    decoded[bytes_written] = mio0_buf[head.uncomp_offset + uncomp_idx];
+                    bytes_written++;
+                    uncomp_idx++;
+                }
+                else
+                {
+                    // 0 - read compressed data
+                    byte a = mio0_buf[head.comp_offset + comp_idx + 0];
+                    byte b = mio0_buf[head.comp_offset + comp_idx + 1];
+                    comp_idx += 2;
+                    int length = ((a & 0xF0) >> 4) + 3;
+                    int idx = ((a & 0x0F) << 8) + b + 1;
+                    for (int i = 0; i < length; i++)
+                    {
+                        decoded[bytes_written] = decoded[bytes_written - idx];
+                        bytes_written++;
+                    }
+
+                }
+                bit_idx++;
+            }
+            return decoded;
+        }
+
+    }
+}

SM64Lib.LIBMIO0/Properties/AssemblyInfo.cs

@@ -0,0 +1,11 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// Durch Festlegen von ComVisible auf FALSE werden die Typen in dieser Assembly
+// für COM-Komponenten unsichtbar.  Wenn Sie auf einen Typ in dieser Assembly von
+// COM aus zugreifen müssen, sollten Sie das ComVisible-Attribut für diesen Typ auf "True" festlegen.
+[assembly: ComVisible(false)]
+
+// Die folgende GUID bestimmt die ID der Typbibliothek, wenn dieses Projekt für COM verfügbar gemacht wird
+[assembly: Guid("e4cec3b1-5778-4d63-8c97-c95153cdc052")]

SM64Lib.LIBMIO0/SM64Lib.LIBMIO0.csproj

@@ -0,0 +1,21 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <AssemblyTitle>LIBMIO0</AssemblyTitle>
+    <Product>Quad64</Product>
+    <Copyright>Copyright © David 2018</Copyright>
+    <Platforms>AnyCPU</Platforms>
+    <Configurations>Debug;Release;ReleaseBundle;ReleaseStandalone</Configurations>
+  </PropertyGroup>
+  <ItemGroup>
+    <PackageReference Include="Microsoft.VisualBasic" Version="10.3.0" />
+    <PackageReference Include="System.Data.DataSetExtensions" Version="4.5.0" />
+    <PackageReference Include="Microsoft.CSharp" Version="4.7.0" />
+    <PackageReference Include="System.Net.Http" Version="4.3.4" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Remove="obj\RelMono\TemporaryGeneratedFile_036C0B5B-1481-4323-8D20-8F5ADCB23D92.cs" />
+    <Compile Remove="obj\RelMono\TemporaryGeneratedFile_5937a670-0e60-4077-877b-f7221da3dda1.cs" />
+    <Compile Remove="obj\RelMono\TemporaryGeneratedFile_E7A71F73-0F8D-4B9B-B56E-8E70B10BC5D3.cs" />
+  </ItemGroup>
+</Project>

SM64Lib.N64Graphics/N64Graphics.cs

@@ -0,0 +1,524 @@
+using System.Drawing;
+
+namespace SM64Lib.N64Graphics
+{
+    public enum N64Codec { RGBA16, RGBA32, IA16, IA8, IA4, I8, I4, CI8, CI4, ONEBPP };
+    public enum N64IMode { AlphaCopyIntensity, AlphaBinary, AlphaOne };
+
+    public class N64Graphics
+    {
+        private static int SCALE_5_8(int val)
+        {
+            return (val * 0xFF) / 0x1F;
+        }
+
+        private static byte SCALE_8_5(byte val)
+        {
+            return (byte)((((val) + 4) * 0x1F) / 0xFF);
+        }
+
+        private static byte SCALE_8_4(byte val)
+        {
+            return (byte)(val / 0x11);
+        }
+
+        private static int SCALE_3_8(byte val)
+        {
+            return (val * 0xFF) / 0x7;
+        }
+
+        private static byte SCALE_8_3(byte val)
+        {
+            return (byte)(val / 0x24);
+        }
+
+        public static Color RGBA16Color(byte c0, byte c1)
+        {
+            int r = SCALE_5_8((c0 & 0xF8) >> 3);
+            int g = SCALE_5_8(((c0 & 0x07) << 2) | ((c1 & 0xC0) >> 6));
+            int b = SCALE_5_8((c1 & 0x3E) >> 1);
+            int a = ((c1 & 0x1) > 0) ? 255 : 0;
+            return Color.FromArgb(a, r, g, b);
+        }
+
+        public static void ColorRGBA16(Color col, out byte c0, out byte c1)
+        {
+            byte r, g, b;
+            r = SCALE_8_5(col.R);
+            g = SCALE_8_5(col.G);
+            b = SCALE_8_5(col.B);
+            c0 = (byte)((r << 3) | (g >> 2));
+            c1 = (byte)(((g & 0x3) << 6) | (b << 1) | ((col.A > 0) ? 1 : 0));
+        }
+
+        public static Color RGBA16Color(byte[] data, int pixOffset)
+        {
+            byte c0 = data[pixOffset];
+            byte c1 = data[pixOffset + 1];
+
+            return RGBA16Color(c0, c1);
+        }
+
+        public static Color RGBA32Color(byte[] data, int pixOffset)
+        {
+            int r, g, b, a;
+            r = data[pixOffset];
+            g = data[pixOffset + 1];
+            b = data[pixOffset + 2];
+            a = data[pixOffset + 3];
+            return Color.FromArgb(a, r, g, b);
+        }
+
+        public static Color IA16Color(byte[] data, int pixOffset)
+        {
+            int i = data[pixOffset];
+            int a = data[pixOffset + 1];
+            return Color.FromArgb(a, i, i, i);
+        }
+
+        public static Color IA8Color(byte[] data, int pixOffset)
+        {
+            int i, a;
+            byte c = data[pixOffset];
+            i = (c >> 4) * 0x11;
+            a = (c & 0xF) * 0x11;
+            return Color.FromArgb(a, i, i, i);
+        }
+
+        public static Color IA4Color(byte[] data, int pixOffset, int nibble)
+        {
+            int shift = (1 - nibble) * 4;
+            int i, a;
+            int val = (data[pixOffset] >> shift) & 0xF;
+            i = SCALE_3_8((byte)(val >> 1));
+            a = (val & 0x1) > 0 ? 0xFF : 0x00;
+            return Color.FromArgb(a, i, i, i);
+        }
+
+        public static Color I8Color(byte[] data, int pixOffset, N64IMode mode = N64IMode.AlphaCopyIntensity)
+        {
+            int i = data[pixOffset];
+            int a = i;
+            switch (mode)
+            {
+                case N64IMode.AlphaBinary: a = (i == 0) ? 0 : 0xFF; break;
+                case N64IMode.AlphaCopyIntensity: a = i; break;
+                case N64IMode.AlphaOne: a = 0xFF; break;
+            }
+            return Color.FromArgb(a, i, i, i);
+        }
+
+        public static Color I4Color(byte[] data, int pixOffset, int nibble, N64IMode mode = N64IMode.AlphaCopyIntensity)
+        {
+            int shift = (1 - nibble) * 4;
+            int i = (data[pixOffset] >> shift) & 0xF;
+            i *= 0x11;
+            int a = i;
+            switch (mode)
+            {
+                case N64IMode.AlphaBinary: a = (i == 0) ? 0 : 0xFF; break;
+                case N64IMode.AlphaCopyIntensity: a = i; break;
+                case N64IMode.AlphaOne: a = 0xFF; break;
+            }
+            return Color.FromArgb(a, i, i, i);
+        }
+
+        public static Color CI8Color(byte[] data, byte[] palette, int pixOffset)
+        {
+            byte c0, c1;
+            int palOffset = 2 * data[pixOffset];
+            c0 = palette[palOffset];
+            c1 = palette[palOffset + 1];
+
+            return RGBA16Color(c0, c1);
+        }
+
+        public static Color CI4Color(byte[] data, byte[] palette, int pixOffset, int nibble)
+        {
+            byte c0, c1;
+            int shift = (1 - nibble) * 4;
+            int palOffset = 2 * ((data[pixOffset] >> shift) & 0xF);
+            c0 = palette[palOffset];
+            c1 = palette[palOffset + 1];
+
+            return RGBA16Color(c0, c1);
+        }
+
+        public static Color BPPColor(byte[] data, int pixOffset, int bit)
+        {
+            int i, a;
+            int val = (data[pixOffset] >> (7 - bit)) & 0x1;
+            i = a = val == 0 ? 0x00 : 0xFF;
+            return Color.FromArgb(a, i, i, i);
+        }
+
+        // return number of bytes needed to encode numPixels using codec
+        public static int PixelsToBytes(N64Codec codec, int numPixels)
+        {
+            int numBytes = 0;
+            switch (codec)
+            {
+                case N64Codec.RGBA16: numBytes = numPixels * 2; break;
+                case N64Codec.RGBA32: numBytes = numPixels * 4; break;
+                case N64Codec.IA16: numBytes = numPixels * 2; break;
+                case N64Codec.IA8: numBytes = numPixels; break;
+                case N64Codec.IA4: numBytes = numPixels / 2; break;
+                case N64Codec.I8: numBytes = numPixels; break;
+                case N64Codec.I4: numBytes = numPixels / 2; break;
+                case N64Codec.CI8: numBytes = numPixels; break;
+                case N64Codec.CI4: numBytes = numPixels / 2; break;
+                case N64Codec.ONEBPP: numBytes = numPixels / 8; break;
+            }
+            return numBytes;
+        }
+
+        public static string CodecString(N64Codec codec)
+        {
+            switch (codec)
+            {
+                case N64Codec.RGBA16: return "rgba16";
+                case N64Codec.RGBA32: return "rgba32";
+                case N64Codec.IA16: return "ia16";
+                case N64Codec.IA8: return "ia8";
+                case N64Codec.IA4: return "ia4";
+                case N64Codec.I8: return "i8";
+                case N64Codec.I4: return "i4";
+                case N64Codec.CI8: return "ci8";
+                case N64Codec.CI4: return "ci4";
+                case N64Codec.ONEBPP: return "1bpp";
+            }
+            return "unk";
+        }
+
+        public static N64Codec StringCodec(string str)
+        {
+            switch (str.ToLower())
+            {
+                default:
+                case "rgba16": return N64Codec.RGBA16;
+                case "rgba32": return N64Codec.RGBA32;
+                case "ia16": return N64Codec.IA16;
+                case "ia8": return N64Codec.IA8;
+                case "ia4": return N64Codec.IA4;
+                case "i8": return N64Codec.I8;
+                case "i4": return N64Codec.I4;
+                case "ci8": return N64Codec.CI8;
+                case "ci4": return N64Codec.CI4;
+                case "1bpp": return N64Codec.ONEBPP;
+            }
+        }
+
+        public static Color MakeColor(byte[] data, byte[] palette, int offset, int select, N64Codec codec, N64IMode mode)
+        {
+            Color color;
+            switch (codec)
+            {
+                case N64Codec.RGBA16:
+                    color = RGBA16Color(data, offset);
+                    break;
+                case N64Codec.RGBA32:
+                    color = RGBA32Color(data, offset);
+                    break;
+                case N64Codec.IA16:
+                    color = IA16Color(data, offset);
+                    break;
+                case N64Codec.IA8:
+                    color = IA8Color(data, offset);
+                    break;
+                case N64Codec.IA4:
+                    color = IA4Color(data, offset, select);
+                    break;
+                case N64Codec.I8:
+                    color = I8Color(data, offset, mode);
+                    break;
+                case N64Codec.I4:
+                    color = I4Color(data, offset, select, mode);
+                    break;
+                case N64Codec.CI8:
+                    color = CI8Color(data, palette, offset);
+                    break;
+                case N64Codec.CI4:
+                    color = CI4Color(data, palette, offset, select);
+                    break;
+                case N64Codec.ONEBPP:
+                    color = BPPColor(data, offset, select);
+                    break;
+                default:
+                    color = RGBA16Color(data, offset);
+                    break;
+            }
+            return color;
+        }
+
+        public static void RenderTexture(Graphics g, byte[] data, byte[] palette, int offset, int width, int height, int scale, N64Codec codec, N64IMode mode)
+        {
+            Brush brush;
+            for (int h = 0; h < height; h++)
+            {
+                for (int w = 0; w < width; w++)
+                {
+                    int pixOffset = (h * width + w);
+                    int bytesPerPix = 1;
+                    int select = 0;
+                    switch (codec)
+                    {
+                        case N64Codec.RGBA16: bytesPerPix = 2; pixOffset *= bytesPerPix; break;
+                        case N64Codec.RGBA32: bytesPerPix = 4; pixOffset *= bytesPerPix; break;
+                        case N64Codec.IA16: bytesPerPix = 2; pixOffset *= bytesPerPix; break;
+                        case N64Codec.IA8: break;
+                        case N64Codec.IA4:
+                            select = pixOffset & 0x1;
+                            pixOffset /= 2;
+                            break;
+                        case N64Codec.I8: break;
+                        case N64Codec.I4:
+                        case N64Codec.CI4:
+                            select = pixOffset & 0x1;
+                            pixOffset /= 2;
+                            break;
+                        case N64Codec.CI8: break;
+                        case N64Codec.ONEBPP:
+                            select = pixOffset & 0x7;
+                            pixOffset /= 8;
+                            break;
+                    }
+                    pixOffset += offset;
+                    if (data.Length > pixOffset + bytesPerPix - 1)
+                    {
+                        brush = new SolidBrush(MakeColor(data, palette, pixOffset, select, codec, mode));
+                        g.FillRectangle(brush, w * scale, h * scale, scale, scale);
+                    }
+                }
+            }
+        }
+
+        // return palette index of matching c0/c1 16-bit dataset, or -1 if not found
+        private static int paletteIndex(byte[] pal, int palCount, byte c0, byte c1)
+        {
+            for (int i = 0; i < palCount; i++)
+            {
+                if (pal[2 * i] == c0 && pal[2 * i + 1] == c1)
+                {
+                    return i;
+                }
+            }
+            return -1;
+        }
+
+        public static void Convert(ref byte[] imageData, ref byte[] paletteData, N64Codec codec, Bitmap bm)
+        {
+            int numPixels = bm.Width * bm.Height;
+            imageData = new byte[PixelsToBytes(codec, numPixels)];
+            int palCount = 0;
+            switch (codec)
+            {
+                case N64Codec.RGBA16:
+                    for (int y = 0; y < bm.Height; y++)
+                    {
+                        for (int x = 0; x < bm.Width; x++)
+                        {
+                            Color col = bm.GetPixel(x, y);
+                            byte c0;
+                            byte c1;
+                            ColorRGBA16(col, out c0, out c1);
+                            int idx = 2 * (y * bm.Width + x);
+                            imageData[idx + 0] = c0;
+                            imageData[idx + 1] = c1;
+                        }
+                    }
+                    break;
+                case N64Codec.RGBA32:
+                    for (int y = 0; y < bm.Height; y++)
+                    {
+                        for (int x = 0; x < bm.Width; x++)
+                        {
+                            Color col = bm.GetPixel(x, y);
+                            int idx = 4 * (y * bm.Width + x);
+                            imageData[idx + 0] = col.R;
+                            imageData[idx + 1] = col.G;
+                            imageData[idx + 2] = col.B;
+                            imageData[idx + 3] = col.A;
+                        }
+                    }
+                    break;
+                case N64Codec.IA16:
+                    for (int y = 0; y < bm.Height; y++)
+                    {
+                        for (int x = 0; x < bm.Width; x++)
+                        {
+                            Color col = bm.GetPixel(x, y);
+                            int sum = col.R + col.G + col.B;
+                            byte intensity = (byte)(sum / 3);
+                            byte alpha = col.A;
+                            int idx = 2 * (y * bm.Width + x);
+                            imageData[idx + 0] = intensity;
+                            imageData[idx + 1] = alpha;
+                        }
+                    }
+                    break;
+                case N64Codec.IA8:
+                    for (int y = 0; y < bm.Height; y++)
+                    {
+                        for (int x = 0; x < bm.Width; x++)
+                        {
+                            Color col = bm.GetPixel(x, y);
+                            int sum = col.R + col.G + col.B;
+                            byte intensity = SCALE_8_4((byte)(sum / 3));
+                            byte alpha = SCALE_8_4(col.A);
+                            int idx = y * bm.Width + x;
+                            imageData[idx] = (byte)((intensity << 4) | alpha);
+                        }
+                    }
+                    break;
+                case N64Codec.IA4:
+                    for (int y = 0; y < bm.Height; y++)
+                    {
+                        for (int x = 0; x < bm.Width; x++)
+                        {
+                            Color col = bm.GetPixel(x, y);
+                            int sum = col.R + col.G + col.B;
+                            byte intensity = SCALE_8_3((byte)(sum / 3));
+                            byte alpha = (byte)(col.A > 0 ? 1 : 0);
+                            int idx = y * bm.Width + x;
+                            byte old = imageData[idx / 2];
+                            if ((idx % 2) > 0)
+                            {
+                                imageData[idx / 2] = (byte)((old & 0xF0) | (intensity << 1) | alpha);
+                            }
+                            else
+                            {
+                                imageData[idx / 2] = (byte)((old & 0x0F) | (((intensity << 1) | alpha) << 4));
+                            }
+                        }
+                    }
+                    break;
+                case N64Codec.I8:
+                    for (int y = 0; y < bm.Height; y++)
+                    {
+                        for (int x = 0; x < bm.Width; x++)
+                        {
+                            Color col = bm.GetPixel(x, y);
+                            int sum = col.R + col.G + col.B;
+                            byte intensity = (byte)(sum / 3);
+                            int idx = y * bm.Width + x;
+                            imageData[idx] = intensity;
+                        }
+                    }
+                    break;
+                case N64Codec.I4:
+                    for (int y = 0; y < bm.Height; y++)
+                    {
+                        for (int x = 0; x < bm.Width; x++)
+                        {
+                            Color col = bm.GetPixel(x, y);
+                            int sum = col.R + col.G + col.B;
+                            byte intensity = SCALE_8_4((byte)(sum / 3));
+                            int idx = y * bm.Width + x;
+                            byte old = imageData[idx / 2];
+                            if ((idx % 2) > 0)
+                            {
+                                imageData[idx / 2] = (byte)((old & 0xF0) | intensity);
+                            }
+                            else
+                            {
+                                imageData[idx / 2] = (byte)((old & 0x0F) | (intensity << 4));
+                            }
+                        }
+                    }
+                    break;
+                case N64Codec.CI4:
+                    paletteData = new byte[16 * 2];
+                    for (int y = 0; y < bm.Height; y++)
+                    {
+                        for (int x = 0; x < bm.Width; x++)
+                        {
+                            Color col = bm.GetPixel(x, y);
+                            byte r, g, b;
+                            r = SCALE_8_5(col.R);
+                            g = SCALE_8_5(col.G);
+                            b = SCALE_8_5(col.B);
+                            byte c0 = (byte)((r << 3) | (g >> 2));
+                            byte c1 = (byte)(((g & 0x3) << 6) | (b << 1) | ((col.A > 0) ? 1 : 0));
+                            int idx = y * bm.Width + x;
+                            int palIdx = paletteIndex(paletteData, palCount, c0, c1);
+                            if (palIdx < 0)
+                            {
+                                if (palCount < paletteData.Length / 2)
+                                {
+                                    palIdx = palCount;
+                                    paletteData[2 * palCount] = c0;
+                                    paletteData[2 * palCount + 1] = c1;
+                                    palCount++;
+                                }
+                                else
+                                {
+                                    palIdx = 0;
+                                    // TODO: out of palette entries. error or pick closest?
+                                }
+                            }
+                            byte old = imageData[idx / 2];
+                            if ((idx % 2) > 0)
+                            {
+                                imageData[idx / 2] = (byte)((old & 0xF0) | (byte)palIdx);
+                            }
+                            else
+                            {
+                                imageData[idx / 2] = (byte)((old & 0x0F) | ((byte)palIdx << 4));
+                            }
+                        }
+                    }
+                    break;
+                case N64Codec.CI8:
+                    paletteData = new byte[256 * 2];
+                    for (int y = 0; y < bm.Height; y++)
+                    {
+                        for (int x = 0; x < bm.Width; x++)
+                        {
+                            Color col = bm.GetPixel(x, y);
+                            byte r, g, b;
+                            r = SCALE_8_5(col.R);
+                            g = SCALE_8_5(col.G);
+                            b = SCALE_8_5(col.B);
+                            byte c0 = (byte)((r << 3) | (g >> 2));
+                            byte c1 = (byte)(((g & 0x3) << 6) | (b << 1) | ((col.A > 0) ? 1 : 0));
+                            int idx = y * bm.Width + x;
+                            int palIdx = paletteIndex(paletteData, palCount, c0, c1);
+                            if (palIdx < 0)
+                            {
+                                if (palCount < paletteData.Length / 2)
+                                {
+                                    palIdx = palCount;
+                                    paletteData[2 * palCount] = c0;
+                                    paletteData[2 * palCount + 1] = c1;
+                                    palCount++;
+                                }
+                                else
+                                {
+                                    palIdx = 0;
+                                    // TODO: out of palette entries. error or pick closest?
+                                }
+                            }
+                            imageData[idx] = (byte)palIdx;
+                        }
+                    }
+                    break;
+                case N64Codec.ONEBPP:
+                    for (int y = 0; y < bm.Height; y++)
+                    {
+                        for (int x = 0; x < bm.Width; x++)
+                        {
+                            Color col = bm.GetPixel(x, y);
+                            int sum = col.R + col.G + col.B;
+                            byte intensity = (sum > 0) ? (byte)1 : (byte)0;
+                            int idx = y * bm.Width + x;
+                            byte old = imageData[idx / 8];
+                            int bit = idx % 8;
+                            int mask = ~(1 << bit);
+                            imageData[idx / 8] = (byte)((old & mask) | (intensity << bit));
+                        }
+                    }
+                    break;
+            }
+        }
+    }
+}

SM64Lib.N64Graphics/Properties/AssemblyInfo.cs

@@ -0,0 +1,11 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// Durch Festlegen von ComVisible auf "false" werden die Typen in dieser Assembly unsichtbar 
+// für COM-Komponenten.  Wenn Sie auf einen Typ in dieser Assembly von 
+// COM aus zugreifen müssen, sollten Sie das ComVisible-Attribut für diesen Typ auf "True" festlegen.
+[assembly: ComVisible(false)]
+
+// Die folgende GUID bestimmt die ID der Typbibliothek, wenn dieses Projekt für COM verfügbar gemacht wird
+[assembly: Guid("d9258483-950c-46d1-a333-31f32492cd7e")]

SM64Lib.N64Graphics/SM64Lib.N64Graphics.csproj

@@ -0,0 +1,23 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net8.0-windows</TargetFramework>
+    <AssemblyTitle>N64Graphics</AssemblyTitle>
+    <Company>Pilzinsel64</Company>
+    <Product>N64Graphics</Product>
+    <Copyright>Copyright © Pilzinsel64 2017 - 2018</Copyright>
+    <UseWindowsForms>true</UseWindowsForms>
+    <Platforms>AnyCPU</Platforms>
+    <Configurations>Debug;Release;ReleaseBundle;ReleaseStandalone</Configurations>
+  </PropertyGroup>
+  <ItemGroup>
+    <PackageReference Include="Microsoft.VisualBasic" Version="10.3.0" />
+    <PackageReference Include="System.Data.DataSetExtensions" Version="4.5.0" />
+    <PackageReference Include="Microsoft.CSharp" Version="4.7.0" />
+    <PackageReference Include="System.Net.Http" Version="4.3.4" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Remove="obj\RelMono\TemporaryGeneratedFile_036C0B5B-1481-4323-8D20-8F5ADCB23D92.cs" />
+    <Compile Remove="obj\RelMono\TemporaryGeneratedFile_5937a670-0e60-4077-877b-f7221da3dda1.cs" />
+    <Compile Remove="obj\RelMono\TemporaryGeneratedFile_E7A71F73-0F8D-4B9B-B56E-8E70B10BC5D3.cs" />
+  </ItemGroup>
+</Project>

SM64Lib.N64Graphics/TextureFormat.cs

@@ -0,0 +1,598 @@
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+using System.Drawing.Imaging;
+using System.Linq;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace SM64Lib.N64Graphics
+{
+    public class TextureFormats
+    {
+        public static Bitmap createColorTexture(Color color)
+        {
+            Bitmap tex = new Bitmap(1, 1);
+            Graphics.FromImage(tex).Clear(color);
+            return tex;
+        }
+
+        public static string ConvertFormatToString(byte formatColorType, byte formatByteSize)
+        {
+            string formatStr = "";
+            switch (formatColorType & 7)
+            {
+                case 0: formatStr = "RGBA"; break;
+                case 1: formatStr = "YUV"; break;
+                case 2: formatStr = "CI"; break;
+                case 3: formatStr = "IA"; break;
+                case 4: formatStr = "I"; break;
+                default: formatStr = "UNKNOWN"; break;
+            }
+            switch (formatByteSize & 3)
+            {
+                case 0: formatStr += "4"; break;
+                case 1: formatStr += "8"; break;
+                case 2: formatStr += "16"; break;
+                case 3: formatStr += "32"; break;
+            }
+            return formatStr;
+        }
+
+        public static byte ConvertStringToFormat(string str)
+        {
+            str = str.ToLower();
+            if (str.Equals("rgba16"))
+                return 0x10;
+            else if (str.Equals("rgba32"))
+                return 0x18;
+            else if (str.Equals("ci4"))
+                return 0x40;
+            else if (str.Equals("ci8"))
+                return 0x48;
+            else if (str.Equals("ia4"))
+                return 0x60;
+            else if (str.Equals("ia8"))
+                return 0x68;
+            else if (str.Equals("ia16"))
+                return 0x70;
+            else if (str.Equals("i4"))
+                return 0x80;
+            else if (str.Equals("i8"))
+                return 0x88;
+            else if (str.Equals("1bpp")) // Not a real F3D format.
+                return 0x00;
+
+            return 0x10;
+        }
+
+        public static int getNumberOfBitsForFormat(byte format)
+        {
+            switch (format)
+            {
+                case 0x00: // Note: "1 bit per pixel" is not a Fast3D format.
+                    return 1;
+                case 0x40:
+                case 0x60:
+                case 0x80:
+                    return 4;
+                case 0x48:
+                case 0x68:
+                case 0x88:
+                    return 8;
+                case 0x10:
+                case 0x70:
+                case 0x90:
+                default:
+                    return 16;
+                case 0x18:
+                    return 32;
+            }
+        }
+
+        public static byte[] encodeTexture(N64Codec format, Bitmap texture)
+        {
+            switch (format)
+            {
+                default:
+                case N64Codec.ONEBPP: // Note: "1 bit per pixel" is not a Fast3D format.
+                    return encode1BPP(texture);
+                case N64Codec.RGBA16:
+                    return encodeRGBA16(texture);
+                case N64Codec.RGBA32:
+                    return encodeRGBA32(texture);
+                case N64Codec.IA4:
+                    return encodeIA4(texture);
+                case N64Codec.IA8:
+                    return encodeIA8(texture);
+                case N64Codec.IA16:
+                    return encodeIA16(texture);
+                case N64Codec.I4:
+                    return encodeI4(texture);
+                case N64Codec.I8:
+                    return encodeI4(texture);
+                case N64Codec.CI4:
+                case N64Codec.CI8:
+                    throw new ArgumentException("CI texture encoding is not currently supported in this version.");
+            }
+        }
+
+        public static byte getBit(int color, int bit)
+        {
+            return (byte)(((color >> 24) & 0xFF) > 0 ? (1 << bit) : 0);
+        }
+
+        public static byte[] encode1BPP(Bitmap texture)
+        {
+            int data_size = (texture.Width * texture.Height) / 8;
+            byte[] data = new byte[data_size];
+            for (int i = 0; i < data_size; i++)
+            {
+                int x = (i * 8) % texture.Width;
+                int y = (i * 8) / texture.Width;
+
+                data[i] = (byte)(
+                    getBit(texture.GetPixel(x + 0, y).ToArgb(), 7) |
+                    getBit(texture.GetPixel(x + 1, y).ToArgb(), 6) |
+                    getBit(texture.GetPixel(x + 2, y).ToArgb(), 5) |
+                    getBit(texture.GetPixel(x + 3, y).ToArgb(), 4) |
+                    getBit(texture.GetPixel(x + 4, y).ToArgb(), 3) |
+                    getBit(texture.GetPixel(x + 5, y).ToArgb(), 2) |
+                    getBit(texture.GetPixel(x + 6, y).ToArgb(), 1) |
+                    getBit(texture.GetPixel(x + 7, y).ToArgb(), 0)
+                );
+            }
+            return data;
+        }
+
+        public static byte[] encodeRGBA16(Bitmap texture)
+        {
+            int data_size = (texture.Width * texture.Height) * 2;
+            byte[] data = new byte[data_size];
+            for (int i = 0; i < data_size / 2; i++)
+            {
+                int x = i % texture.Width;
+                int y = i / texture.Width;
+                Color pix = texture.GetPixel(x, y);
+                byte red = (byte)((pix.R / 256.0f) * 32.0f);
+                byte green = (byte)((pix.G / 256.0f) * 32.0f);
+                byte blue = (byte)((pix.B / 256.0f) * 32.0f);
+                byte alpha = (byte)(pix.A >= 128.0f ? 1 : 0);
+
+                data[i * 2] = (byte)((red << 3) | (green >> 2));
+                data[(i * 2) + 1] = (byte)(((green & 3) << 6) | (blue << 1) | alpha);
+            }
+            return data;
+        }
+
+        public static byte[] encodeRGBA32(Bitmap texture)
+        {
+            int data_size = (texture.Width * texture.Height) * 4;
+            byte[] data = new byte[data_size];
+            for (int i = 0; i < data_size / 4; i++)
+            {
+                int x = i % texture.Width;
+                int y = i / texture.Width;
+                Color pix = texture.GetPixel(x, y);
+
+                data[(i * 4) + 0] = pix.R;
+                data[(i * 4) + 1] = pix.G;
+                data[(i * 4) + 2] = pix.B;
+                data[(i * 4) + 3] = pix.A;
+            }
+            return data;
+        }
+
+        public static byte[] encodeIA4(Bitmap texture)
+        {
+            int data_size = (texture.Width * texture.Height) / 2;
+            byte[] data = new byte[data_size];
+            for (int i = 0; i < data_size; i++)
+            {
+                int x = (i * 2) % texture.Width;
+                int y = (i * 2) / texture.Width;
+
+                Color pix1 = texture.GetPixel(x, y);
+                byte pix1_avg = (byte)((((pix1.R + pix1.G + pix1.B) / 3) / 255.0f) * 8.0f);
+                byte upper = (byte)((pix1_avg << 1) | (pix1.A < 255 ? 0 : 1));
+
+                Color pix2 = texture.GetPixel(x + 1, y);
+                byte pix2_avg = (byte)((((pix2.R + pix2.G + pix2.B) / 3) / 255.0f) * 8.0f);
+                byte lower = (byte)((pix2_avg << 1) | (pix2.A < 255 ? 0 : 1));
+
+                data[i] = (byte)(((upper & 0xF) << 4) | (lower & 0xF));
+            }
+            return data;
+        }
+
+        public static byte[] encodeIA8(Bitmap texture)
+        {
+            int data_size = texture.Width * texture.Height;
+            byte[] data = new byte[data_size];
+            for (int i = 0; i < data_size; i++)
+            {
+                int x = i % texture.Width;
+                int y = i / texture.Width;
+
+                Color pix = texture.GetPixel(x, y);
+                byte pix_avg = (byte)((((pix.R + pix.G + pix.B) / 3) / 255.0f) * 16.0f);
+                byte pix_alpha = (byte)((pix.A / 255.0f) * 16.0f);
+
+                data[i] = (byte)(((pix_avg & 0xF) << 4) | (pix_alpha & 0xF));
+            }
+            return data;
+        }
+
+        public static byte[] encodeIA16(Bitmap texture)
+        {
+            int data_size = texture.Width * texture.Height * 2;
+            byte[] data = new byte[data_size];
+            for (int i = 0; i < data_size / 2; i++)
+            {
+                int x = i % texture.Width;
+                int y = i / texture.Width;
+
+                Color pix = texture.GetPixel(x, y);
+                byte pix_avg = (byte)((pix.R + pix.G + pix.B) / 3);
+
+                data[i * 2] = pix_avg;
+                data[(i * 2) + 1] = pix.A;
+            }
+            return data;
+        }
+
+        public static byte[] encodeI4(Bitmap texture)
+        {
+            int data_size = (texture.Width * texture.Height) / 2;
+            byte[] data = new byte[data_size];
+            for (int i = 0; i < data_size; i++)
+            {
+                int x = (i * 2) % texture.Width;
+                int y = (i * 2) / texture.Width;
+
+                Color pix1 = texture.GetPixel(x, y);
+                byte upper = (byte)((((pix1.R + pix1.G + pix1.B) / 3) / 255.0f) * 16.0f);
+
+                Color pix2 = texture.GetPixel(x + 1, y);
+                byte lower = (byte)((((pix2.R + pix2.G + pix2.B) / 3) / 255.0f) * 16.0f);
+
+                data[i] = (byte)(((upper & 0xF) << 4) | (lower & 0xF));
+            }
+            return data;
+        }
+
+
+        public static byte[] encodeI8(Bitmap texture)
+        {
+            int data_size = texture.Width * texture.Height;
+            byte[] data = new byte[data_size];
+            for (int i = 0; i < data_size; i++)
+            {
+                int x = i % texture.Width;
+                int y = i / texture.Width;
+
+                Color pix = texture.GetPixel(x, y);
+
+                data[i] = (byte)((pix.R + pix.G + pix.B) / 3);
+            }
+            return data;
+        }
+
+        public static Bitmap decodeTexture(N64Codec format, byte[] data, int width, int height, ushort[] palette)
+        {
+            switch (format)
+            {
+                default:
+                case N64Codec.ONEBPP: // Note: "1 bit per pixel" is not a Fast3D format.
+                    return decode1BPP(data, width, height);
+                case N64Codec.RGBA16:
+                    return decodeRGBA16(data, width, height);
+                case N64Codec.RGBA32:
+                    return decodeRGBA32(data, width, height);
+                case N64Codec.CI4:
+                    return decodeCI4(data, width, height, palette);
+                case N64Codec.CI8:
+                    return decodeCI8(data, width, height, palette);
+                case N64Codec.IA4:
+                    return decodeIA4(data, width, height);
+                case N64Codec.IA8:
+                    return decodeIA8(data, width, height);
+                case N64Codec.IA16:
+                    return decodeIA16(data, width, height);
+                case N64Codec.I4:
+                    return decodeI4(data, width, height);
+                case N64Codec.I8:
+                    return decodeI8(data, width, height);
+            }
+        }
+
+
+        public static Bitmap decode1BPP(byte[] data, int width, int height)
+        {
+            Bitmap tex = new Bitmap(width, height);
+            if (data.Length >= (width * height) / 8) // Sanity Check
+            {
+                int len = (width * height) / 8;
+                for (int i = 0; i < len; ++i)
+                {
+                    for (int x = 0; x < 8; x++)
+                    {
+                        byte intensity = (byte)((data[i] >> (7 - x)) & 1);
+                        if (intensity > 0)
+                            intensity = 0xFF;
+                        int alpha = intensity;
+                        int pos = (i * 8) + x;
+                        tex.SetPixel(pos % width, pos / width, Color.FromArgb(alpha, intensity, intensity, intensity));
+                    }
+                }
+            }
+            tex.Tag = new string[] { "Format: 1BPP", "Width: " + width,
+             "Height: " + height };
+            return tex;
+        }
+
+        public static Bitmap decodeRGBA32(byte[] data, int width, int height)
+        {
+            Console.WriteLine("Texture size = (" + width + "x" + height + ")");
+            Console.WriteLine("data.Length = (" + data.Length + ")");
+            Bitmap tex = new Bitmap(width, height);
+
+            if (data.Length >= width * height * 4) // Sanity Check
+            {
+                BitmapData bitmapData = tex.LockBits(new Rectangle(0, 0, width, height),
+                ImageLockMode.ReadWrite, tex.PixelFormat);
+
+                int len = width * height;
+                for (int i = 0; i < len; i++)
+                {
+                    // Swap red and blue values
+                    byte temp_red = data[(i * 4) + 0];
+                    data[(i * 4) + 0] = data[(i * 4) + 2];
+                    data[(i * 4) + 2] = temp_red;
+                }
+                Marshal.Copy(data, 0, bitmapData.Scan0, data.Length);
+                tex.UnlockBits(bitmapData);
+
+            }
+            tex.Tag = new string[] { "Format: RGBA32", "Width: " + width,
+             "Height: " + height };
+            return tex;
+        }
+
+        public static Bitmap decodeRGBA16(byte[] data, int width, int height)
+        {
+            Bitmap tex = new Bitmap(width, height);
+            if (data.Length >= width * height * 2) // Sanity Check
+            {
+                BitmapData bitmapData = tex.LockBits(new Rectangle(0, 0, width, height),
+                    ImageLockMode.ReadWrite, tex.PixelFormat);
+                byte[] pixels = new byte[width * height * 4];
+
+                int len = width * height;
+                for (int i = 0; i < len; i++)
+                {
+                    ushort pixel = (ushort)((data[i * 2] << 8) | data[i * 2 + 1]);
+                    pixels[(i * 4) + 2] = (byte)(((pixel >> 11) & 0x1F) * 8); // Red
+                    pixels[(i * 4) + 1] = (byte)(((pixel >> 6) & 0x1F) * 8); // Green
+                    pixels[(i * 4) + 0] = (byte)(((pixel >> 1) & 0x1F) * 8); // Blue
+                    pixels[(i * 4) + 3] = (pixel & 1) > 0 ? (byte)0xFF : (byte)0x00; // (Transparency)
+                }
+                Marshal.Copy(pixels, 0, bitmapData.Scan0, pixels.Length);
+                tex.UnlockBits(bitmapData);
+            }
+
+            tex.Tag = new string[] { "Format: RGBA16", "Width: " + width,
+             "Height: " + height };
+            return tex;
+        }
+
+        public static Bitmap decodeIA16(byte[] data, int width, int height)
+        {
+            Bitmap tex = new Bitmap(width, height);
+            if (data.Length >= width * height * 2) // Sanity Check
+            {
+                BitmapData bitmapData = tex.LockBits(new Rectangle(0, 0, width, height),
+                ImageLockMode.ReadWrite, tex.PixelFormat);
+                byte[] pixels = new byte[width * height * 4];
+
+                int len = width * height;
+                for (int i = 0; i < len; i++)
+                {
+                    pixels[(i * 4) + 2] = data[i * 2]; // Red
+                    pixels[(i * 4) + 1] = data[i * 2]; // Green
+                    pixels[(i * 4) + 0] = data[i * 2]; // Blue
+                    pixels[(i * 4) + 3] = data[(i * 2) + 1]; // Alpha
+                }
+                Marshal.Copy(pixels, 0, bitmapData.Scan0, pixels.Length);
+                tex.UnlockBits(bitmapData);
+            }
+            tex.Tag = new string[] { "Format: IA16", "Width: " + width,
+             "Height: " + height};
+            return tex;
+        }
+
+        public static Bitmap decodeIA8(byte[] data, int width, int height)
+        {
+            Bitmap tex = new Bitmap(width, height);
+            if (data.Length >= width * height) // Sanity Check
+            {
+                BitmapData bitmapData = tex.LockBits(new Rectangle(0, 0, width, height),
+                ImageLockMode.ReadWrite, tex.PixelFormat);
+                byte[] pixels = new byte[width * height * 4];
+
+                int len = width * height;
+                for (int i = 0; i < len; i++)
+                {
+                    byte intensity = (byte)(((data[i] >> 4) & 0xF) * 16);
+                    pixels[(i * 4) + 2] = intensity; // Red
+                    pixels[(i * 4) + 1] = intensity; // Green
+                    pixels[(i * 4) + 0] = intensity; // Blue
+                    pixels[(i * 4) + 3] = (byte)((data[i] & 0xF) * 16); // Alpha
+                }
+                Marshal.Copy(pixels, 0, bitmapData.Scan0, pixels.Length);
+                tex.UnlockBits(bitmapData);
+            }
+            tex.Tag = new string[] { "Format: IA8", "Width: " + width,
+             "Height: " + height };
+            return tex;
+        }
+        public static Bitmap decodeIA4(byte[] data, int width, int height)
+        {
+            Bitmap tex = new Bitmap(width, height);
+
+            if (data.Length >= (width * height) / 2) // Sanity Check
+            {
+                BitmapData bitmapData = tex.LockBits(new Rectangle(0, 0, width, height),
+                ImageLockMode.ReadWrite, tex.PixelFormat);
+                byte[] pixels = new byte[width * height * 4];
+
+                int len = (width * height) / 2;
+                for (int i = 0; i < len; i++)
+                {
+                    byte twoPixels = data[i];
+
+                    byte intensity = (byte)((twoPixels >> 5) * 32);
+                    pixels[(i * 8) + 2] = intensity; // Red
+                    pixels[(i * 8) + 1] = intensity; // Green
+                    pixels[(i * 8) + 0] = intensity; // Blue
+                    pixels[(i * 8) + 3] = (byte)(((twoPixels >> 4) & 0x1) * 255); // Alpha
+
+                    intensity = (byte)(((twoPixels >> 1) & 0x7) * 32);
+                    pixels[(i * 8) + 6] = intensity; // Red
+                    pixels[(i * 8) + 5] = intensity; // Green
+                    pixels[(i * 8) + 4] = intensity; // Blue
+                    pixels[(i * 8) + 7] = (byte)((twoPixels & 0x1) * 255); // Alpha
+                }
+                Marshal.Copy(pixels, 0, bitmapData.Scan0, pixels.Length);
+                tex.UnlockBits(bitmapData);
+                tex.Tag = new string[] { "Format: IA4", "Width: " + width,
+             "Height: " + height };
+            }
+            return tex;
+        }
+        public static Bitmap decodeI8(byte[] data, int width, int height)
+        {
+            Bitmap tex = new Bitmap(width, height);
+
+            if (data.Length >= width * height) // Sanity Check
+            {
+                BitmapData bitmapData = tex.LockBits(new Rectangle(0, 0, width, height),
+                ImageLockMode.ReadWrite, tex.PixelFormat);
+                byte[] pixels = new byte[width * height * 4];
+
+                int len = width * height;
+                for (int i = 0; i < len; i++)
+                {
+                    byte intensity = data[i];
+                    pixels[(i * 4) + 2] = intensity; // Red
+                    pixels[(i * 4) + 1] = intensity; // Green
+                    pixels[(i * 4) + 0] = intensity; // Blue
+                    pixels[(i * 4) + 3] = 0xFF; // Alpha
+                }
+                Marshal.Copy(pixels, 0, bitmapData.Scan0, pixels.Length);
+                tex.UnlockBits(bitmapData);
+
+                tex.Tag = new string[] { "Format: I8", "Width: " + width,
+             "Height: " + height };
+            }
+            return tex;
+        }
+        public static Bitmap decodeI4(byte[] data, int width, int height)
+        {
+            Bitmap tex = new Bitmap(width, height);
+
+            if (data.Length >= (width * height) / 2) // Sanity Check
+            {
+                BitmapData bitmapData = tex.LockBits(new Rectangle(0, 0, width, height),
+                ImageLockMode.ReadWrite, tex.PixelFormat);
+                byte[] pixels = new byte[width * height * 4];
+
+                int len = (width * height) / 2;
+                for (int i = 0; i < len; i++)
+                {
+                    byte twoPixels = data[i];
+
+                    byte intensity = (byte)((twoPixels >> 4) * 16);
+                    pixels[(i * 8) + 2] = intensity; // Red
+                    pixels[(i * 8) + 1] = intensity; // Green
+                    pixels[(i * 8) + 0] = intensity; // Blue
+                    pixels[(i * 8) + 3] = 0xFF; // Alpha
+
+                    intensity = (byte)((twoPixels & 0xF) * 16);
+                    pixels[(i * 8) + 6] = intensity; // Red
+                    pixels[(i * 8) + 5] = intensity; // Green
+                    pixels[(i * 8) + 4] = intensity; // Blue
+                    pixels[(i * 8) + 7] = 0xFF; // Alpha
+                }
+                Marshal.Copy(pixels, 0, bitmapData.Scan0, pixels.Length);
+                tex.UnlockBits(bitmapData);
+            }
+            tex.Tag = new string[] { "Format: I4", "Width: " + width,
+             "Height: " + height };
+            return tex;
+        }
+
+        public static Bitmap decodeCI4(byte[] data, int width, int height, ushort[] palette)
+        {
+            Bitmap tex = new Bitmap(width, height);
+
+            if (data.Length >= (width * height) / 2) // Sanity Check
+            {
+                BitmapData bitmapData = tex.LockBits(new Rectangle(0, 0, width, height),
+                ImageLockMode.ReadWrite, tex.PixelFormat);
+                byte[] pixels = new byte[width * height * 4];
+
+                int len = (width * height) / 2;
+                for (int i = 0; i < len; i++)
+                {
+                    ushort pixel = palette[(data[i] >> 4) & 0xF];
+                    pixels[(i * 8) + 2] = (byte)(((pixel >> 11) & 0x1F) * 8); // Red
+                    pixels[(i * 8) + 1] = (byte)(((pixel >> 6) & 0x1F) * 8); // Green
+                    pixels[(i * 8) + 0] = (byte)(((pixel >> 1) & 0x1F) * 8); // Blue
+                    pixels[(i * 8) + 3] = (pixel & 1) > 0 ? (byte)0xFF : (byte)0x00; // Alpha
+
+                    pixel = palette[(data[i]) & 0xF];
+                    pixels[(i * 8) + 6] = (byte)(((pixel >> 11) & 0x1F) * 8); // Red
+                    pixels[(i * 8) + 5] = (byte)(((pixel >> 6) & 0x1F) * 8); // Green
+                    pixels[(i * 8) + 4] = (byte)(((pixel >> 1) & 0x1F) * 8); // Blue
+                    pixels[(i * 8) + 7] = (pixel & 1) > 0 ? (byte)0xFF : (byte)0x00; // Alpha
+
+                }
+                Marshal.Copy(pixels, 0, bitmapData.Scan0, pixels.Length);
+                tex.UnlockBits(bitmapData);
+            }
+            tex.Tag = new string[] { "Format: CI4", "Width: " + width,
+             "Height: " + height };
+            return tex;
+        }
+
+        public static Bitmap decodeCI8(byte[] data, int width, int height, ushort[] palette)
+        {
+            Bitmap tex = new Bitmap(width, height);
+
+            if (data.Length >= width * height) // Sanity Check
+            {
+                BitmapData bitmapData = tex.LockBits(new Rectangle(0, 0, width, height),
+                ImageLockMode.ReadWrite, tex.PixelFormat);
+                byte[] pixels = new byte[width * height * 4];
+
+                int len = width * height;
+                for (int i = 0; i < len; i++)
+                {
+                    ushort pixel = palette[data[i]];
+                    pixels[(i * 4) + 2] = (byte)(((pixel >> 11) & 0x1F) * 8); // Red
+                    pixels[(i * 4) + 1] = (byte)(((pixel >> 6) & 0x1F) * 8); // Green
+                    pixels[(i * 4) + 0] = (byte)(((pixel >> 1) & 0x1F) * 8); // Blue
+                    pixels[(i * 4) + 3] = (pixel & 1) > 0 ? (byte)0xFF : (byte)0x00; // (Transparency)
+                                                                                     //tex.SetPixel(i % width, i / width, Color.FromArgb(alpha, red, green, blue));
+                }
+                Marshal.Copy(pixels, 0, bitmapData.Scan0, pixels.Length);
+                tex.UnlockBits(bitmapData);
+            }
+            tex.Tag = new string[] { "Format: CI8", "Width: " + width,
+             "Height: " + height };
+            return tex;
+        }
+    }
+}

SM64Lib.Text.Exporters/ExcelExporter.cs

@@ -0,0 +1,102 @@
+using OfficeOpenXml;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace SM64Lib.Text.Exporters
+{
+    public class ExcelExporter
+    {
+        public ExcelExporter()
+        {
+            ExcelPackage.LicenseContext = LicenseContext.NonCommercial;
+        }
+
+        public async Task Export(string destFilePath, TextGroup[] groups)
+        {
+            var pkg = new ExcelPackage();
+
+            foreach (var tg in groups)
+            {
+                var ws = pkg.Workbook.Worksheets.Add(tg.TextGroupInfo.Name);
+                var hasDialogCells = false;
+
+                ws.Cells.Style.VerticalAlignment = OfficeOpenXml.Style.ExcelVerticalAlignment.Top;
+                ws.Cells.Style.HorizontalAlignment = OfficeOpenXml.Style.ExcelHorizontalAlignment.Left;
+                ws.Row(1).Style.Font.Bold = true;
+                ws.Cells[1, 1].Value = "#";
+                ws.Cells[1, 2].Value = "Text";
+
+                for (int i = 0; i < tg.Count; i++)
+                {
+                    var ti = tg[i];
+                    var ri = i + 2;
+
+                    ws.Cells[ri, 1].Value = i;
+                    ws.Cells[ri, 2].Value = ti.Text;
+
+                    if (ti is TextTableDialogItem)
+                        hasDialogCells = true;
+                }
+
+
+                for (int ri = 1; ri <= ws.Cells.Rows; ri++)
+                {
+                    var r = ws.Row(ri);
+                    r.CustomHeight = false;
+                }
+
+                if (hasDialogCells)
+                {
+                    var c = ws.Column(2);
+                    c.Style.WrapText = true;
+                    c.Width = 30;
+                }
+
+                for (int ci = 1; ci <= 2; ci++)
+                {
+                    var c = ws.Column(ci);
+                    if (!c.Style.WrapText)
+                        c.AutoFit();
+                }
+            }
+
+            await pkg.SaveAsAsync(new FileInfo(destFilePath));
+            pkg.Dispose();
+        }
+
+        public async Task Import(string filePath, TextGroup[] groups)
+        {
+            try
+            {
+                var pkg = new ExcelPackage();
+                await pkg.LoadAsync(new FileInfo(filePath));
+
+                foreach (var tg in groups)
+                {
+                    var ws = pkg.Workbook.Worksheets[tg.TextGroupInfo.Name];
+                    if (ws is not null)
+                    {
+                        for (int iti = 0; iti < tg.Count; iti++)
+                        {
+                            var ti = tg[iti];
+                            var ri = iti + 2;
+                            var c = ws.Cells[ri, 2];
+
+                            ti.Text = ((string)c.Value).Replace("\r\n", "\n").Replace("\n", "\r\n");
+                            tg.NeedToSave = true;
+                        }
+                    }
+                }
+
+                pkg.Dispose();
+            }
+            catch (Exception)
+            {
+            }
+        }
+    }
+}

SM64Lib.Text.Exporters/Properties/AssemblyInfo.cs

@@ -0,0 +1,11 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// Durch Festlegen von ComVisible auf FALSE werden die Typen in dieser Assembly
+// für COM-Komponenten unsichtbar.  Wenn Sie auf einen Typ in dieser Assembly von
+// COM aus zugreifen müssen, sollten Sie das ComVisible-Attribut für diesen Typ auf "True" festlegen.
+[assembly: ComVisible(false)]
+
+// Die folgende GUID bestimmt die ID der Typbibliothek, wenn dieses Projekt für COM verfügbar gemacht wird
+[assembly: Guid("e6305a1d-e5da-4bb6-992e-3a341bc99a7b")]

SM64Lib.Text.Exporters/SM64Lib.Text.Exporters.csproj

@@ -0,0 +1,23 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net8.0-windows</TargetFramework>
+    <AssemblyTitle>SM64Lib.Text.Exporters</AssemblyTitle>
+    <Product>SM64Lib.Text.Exporters</Product>
+    <Copyright>Copyright ©  2020</Copyright>
+    <Platforms>AnyCPU</Platforms>
+    <Configurations>Debug;Release;ReleaseBundle;ReleaseStandalone</Configurations>
+  </PropertyGroup>
+  <ItemGroup>
+    <PackageReference Include="Microsoft.VisualBasic" Version="10.3.0" />
+    <PackageReference Include="System.Threading.Tasks" Version="4.3.0" />
+    <PackageReference Include="System.Data.DataSetExtensions" Version="4.5.0" />
+    <PackageReference Include="Microsoft.CSharp" Version="4.7.0" />
+    <PackageReference Include="System.Net.Http" Version="4.3.4" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\SM64Lib\SM64Lib.csproj" />
+  </ItemGroup>
+  <ItemGroup>
+    <PackageReference Include="EPPlus" Version="7.1.2" />
+  </ItemGroup>
+</Project>

SM64Lib.Text.Exporters/TxtExporter.cs

@@ -0,0 +1,48 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace SM64Lib.Text.Exporters
+{
+    public class TxtExporter
+    {
+        public async Task Export(string destFilePath, TextGroup[] groups)
+        {
+            var sw = new StreamWriter(destFilePath);
+
+            for (int itg = 0; itg < groups.Length; itg++)
+            {
+                var tg = groups[itg];
+
+                if (itg != 0)
+                    await sw.WriteLineAsync("------------------------------\n");
+                await sw.WriteLineAsync($"Text Group - {tg.TextGroupInfo.Name}\n");
+                await sw.WriteLineAsync("------------------------------\n");
+
+                for (int iti = 0; iti < tg.Count; iti++)
+                {
+                    var ti = tg[iti];
+                    
+                    if (ti is TextTableDialogItem)
+                    {
+                        await sw.WriteLineAsync($"Dialog #{iti}\n");
+                        await sw.WriteLineAsync(ti.Text);
+                        await sw.WriteLineAsync("\n\n");
+                    }
+                    else
+                    {
+                        await sw.WriteLineAsync($"Text Item #{iti}");
+                        await sw.WriteLineAsync(ti.Text);
+                        await sw.WriteLineAsync();
+                    }
+                }
+            }
+
+            await sw.FlushAsync();
+            sw.Close();
+        }
+    }
+}

SM64Lib.TextValueConverter/Properties/AssemblyInfo.cs

@@ -0,0 +1,8 @@
+using global::System;
+using global::System.Reflection;
+using global::System.Runtime.InteropServices;
+[assembly: ComVisible(false)]
+
+// Die folgende GUID bestimmt die ID der Typbibliothek, wenn dieses Projekt für COM verfügbar gemacht wird.
+[assembly: Guid("245f4730-1df1-43f7-8bef-9626648c4204")]
+

SM64Lib.TextValueConverter/SM64Lib.TextValueConverter.csproj

@@ -0,0 +1,62 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <MyType>Windows</MyType>
+    <TargetFramework>net8.0</TargetFramework>
+    <DefaultItemExcludes>$(DefaultItemExcludes);$(ProjectDir)**\*.vb</DefaultItemExcludes>
+    <LangVersion>latest</LangVersion>
+    <AssemblyTitle>TextValueConverter</AssemblyTitle>
+    <Company>DRSN</Company>
+    <Product>TextValueConverter</Product>
+    <Copyright>Copyright © Pilzinsel64 2018 - 2020</Copyright>
+    <DocumentationFile>SM64Lib.TextValueConverter.xml</DocumentationFile>
+    <DefineTrace>true</DefineTrace>
+    <NoWarn>42016,41999,42017,42018,42019,42032,42036,42020,42021,42022,CS1591,CS0168</NoWarn>
+    <Platforms>AnyCPU</Platforms>
+    <Configurations>Debug;Release;ReleaseBundle;ReleaseStandalone</Configurations>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
+    <DefineDebug>true</DefineDebug>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
+    <DefineDebug>false</DefineDebug>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseStandalone|AnyCPU'">
+    <DefineDebug>false</DefineDebug>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseBundle|AnyCPU'">
+    <DefineDebug>false</DefineDebug>
+  </PropertyGroup>
+  <PropertyGroup>
+    <OptionExplicit>On</OptionExplicit>
+  </PropertyGroup>
+  <PropertyGroup>
+    <OptionCompare>Binary</OptionCompare>
+  </PropertyGroup>
+  <PropertyGroup>
+    <OptionStrict>Off</OptionStrict>
+  </PropertyGroup>
+  <PropertyGroup>
+    <OptionInfer>On</OptionInfer>
+  </PropertyGroup>
+  <ItemGroup>
+    <PackageReference Include="Microsoft.VisualBasic" Version="10.3.0" />
+    <PackageReference Include="System.Data.DataSetExtensions" Version="4.5.0" />
+    <PackageReference Include="System.Net.Http" Version="4.3.4" />
+  </ItemGroup>
+  <ItemGroup>
+    <Import Include="Microsoft.VisualBasic" />
+    <Import Include="System" />
+    <Import Include="System.Collections" />
+    <Import Include="System.Collections.Generic" />
+    <Import Include="System.Data" />
+    <Import Include="System.Diagnostics" />
+    <Import Include="System.Linq" />
+    <Import Include="System.Xml.Linq" />
+    <Import Include="System.Threading.Tasks" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Remove="obj\RelMono\TemporaryGeneratedFile_036C0B5B-1481-4323-8D20-8F5ADCB23D92.cs" />
+    <Compile Remove="obj\RelMono\TemporaryGeneratedFile_5937a670-0e60-4077-877b-f7221da3dda1.cs" />
+    <Compile Remove="obj\RelMono\TemporaryGeneratedFile_E7A71F73-0F8D-4B9B-B56E-8E70B10BC5D3.cs" />
+  </ItemGroup>
+</Project>

SM64Lib.TextValueConverter/SM64Lib.TextValueConverter.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0"?>
+<doc>
+    <assembly>
+        <name>SM64Lib.TextValueConverter</name>
+    </assembly>
+    <members>
+    </members>
+</doc>

SM64Lib.TextValueConverter/TextValueConverter.cs

@@ -0,0 +1,89 @@
+using System;
+using Microsoft.VisualBasic.CompilerServices;
+
+namespace SM64Lib.TextValueConverter
+{
+    public static class TextValueConverter
+    {
+        public static event WantIntegerValueModeEventHandler WantIntegerValueMode;
+        public delegate void WantIntegerValueModeEventHandler(WantIntegerValueModeEventArgs e);
+
+        public static int ValueFromText(string Text, int DefaultValue = 0, int useIVM = -1)
+        {
+            return Convert.ToInt32(LongFromText(Text, DefaultValue, useIVM));
+        }
+
+        public static long LongFromText(string Text, long DefaultValue = 0, int useIVM = -1)
+        {
+            try
+            {
+                int IVM = useIVM > -1 ? useIVM : GetIntegerValueMode();
+                Text = Text?.ToLower()?.Trim();
+
+                if (string.IsNullOrWhiteSpace(Text))
+                    return 0;
+
+                switch (true)
+                {
+                    case object _ when Text.StartsWith("0x"):
+                    case object _ when Text.StartsWith("&h"):
+                        return Convert.ToInt32(Text.Substring(2), 16);
+                    case object _ when Text.StartsWith("$"):
+                        return Convert.ToInt32(Text.Substring(1), 16);
+                    case object _ when Text.StartsWith("0b"):
+                    case object _ when Text.StartsWith("&b"):
+                        return Convert.ToInt32(Text.Substring(2), 2);
+                    default:
+                        return Convert.ToInt32(Text);
+                }
+            }
+            catch (Exception)
+            {
+                return DefaultValue;
+            }
+        }
+
+        public static string TextFromValue(long Value, int IVM = -1, int charCount = 0)
+        {
+            if (IVM == -1)
+            {
+                IVM = GetIntegerValueMode();
+            }
+
+            switch (IVM)
+            {
+                case 0:
+                    return Value.ToString(GetCharCountAsZeroString(charCount));
+                case 1:
+                    return "0x" + Value.ToString("X" + (charCount > 0 ? charCount.ToString() : ""));
+                case 2:
+                    return "&H" + Value.ToString("X" + (charCount > 0 ? charCount.ToString() : ""));
+                case 3:
+                    return "$" + Value.ToString("X" + (charCount > 0 ? charCount.ToString() : ""));
+                default:
+                    return string.Empty;
+            }
+        }
+
+        private static string GetCharCountAsZeroString(int charCount)
+        {
+            string GetCharCountAsZeroStringRet = default;
+            GetCharCountAsZeroStringRet = "";
+            while (GetCharCountAsZeroStringRet.Length < charCount)
+                GetCharCountAsZeroStringRet += "0";
+            return GetCharCountAsZeroStringRet;
+        }
+
+        private static int GetIntegerValueMode()
+        {
+            var e = new WantIntegerValueModeEventArgs();
+            WantIntegerValueMode?.Invoke(e);
+            return e.IntegerValueMode;
+        }
+    }
+
+    public class WantIntegerValueModeEventArgs : EventArgs
+    {
+        public int IntegerValueMode { get; set; }
+    }
+}

SM64Lib/ASM/CustomAsmArea.cs

@@ -0,0 +1,83 @@
+using Newtonsoft.Json;
+using SM64Lib.Data;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace SM64Lib.ASM
+{
+    public class CustomAsmArea
+    {
+        public byte[] AreaBytes { get; set; }
+
+        [JsonProperty(nameof(Config))]
+        private CustomAsmAreaConfig config;
+
+        [JsonIgnore]
+        public CustomAsmAreaConfig Config
+        {
+            get
+            {
+                if (config == null)
+                    config = new CustomAsmAreaConfig();
+                return config;
+            }
+        }
+
+        [JsonConstructor]
+        private CustomAsmArea(JsonConstructorAttribute emptyObject)
+        {
+        }
+
+        public CustomAsmArea()
+            : this(true)
+        {
+        }
+
+        private CustomAsmArea(bool createEmptyAreaBytesArray)
+            : this(null, createEmptyAreaBytesArray)
+        {
+        }
+
+        public CustomAsmArea(CustomAsmAreaConfig config)
+            : this(config, false)
+        {
+        }
+
+        private CustomAsmArea(CustomAsmAreaConfig config, bool createEmptyAreaBytesArray)
+        {
+            this.config = config;
+
+            if (createEmptyAreaBytesArray)
+                AreaBytes = new byte[] { };
+        }
+
+        public void Load(BinaryData data, CustomAsmBankConfig bankConfig)
+        {
+            if (Config.RomAddress != -1 && Config.Length > 0)
+            {
+                data.Position = Config.RomAddress;
+                AreaBytes = data.Read(Config.Length);
+            }
+            else
+                AreaBytes = new byte[] { };
+        }
+
+        public int Save(BinaryData data, int address, CustomAsmBankConfig bankConfig)
+        {
+            data.Position = address;
+            data.Write(AreaBytes);
+            return UpdateAddresses(address, bankConfig);
+        }
+
+        internal int UpdateAddresses(int address, CustomAsmBankConfig bankConfig)
+        {
+            Config.RomAddress = address;
+            Config.Length = AreaBytes.Length;
+            Config.RamAddress = address - bankConfig.GetRomStartAddress() + bankConfig.GetRamStartAddress();
+            return Config.Length;
+        }
+    }
+}

SM64Lib/ASM/CustomAsmAreaConfig.cs

@@ -0,0 +1,39 @@
+using Newtonsoft.Json;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Pilz.Cryptography;
+using Pilz.Json.Converters;
+
+namespace SM64Lib.ASM
+{
+    public class CustomAsmAreaConfig
+    {
+        internal delegate void RequestCustomAsmAreaEventHandler(CustomAsmAreaConfig config, RequestCustomAsmAreaEventArgs request);
+        internal static event RequestCustomAsmAreaEventHandler RequestCustomAsmArea;
+
+        [JsonConverter(typeof(UniquieIDStringJsonConverter))]
+        public UniquieID ID { get; set; } = new();
+        public string Name { get; set; }
+        [JsonProperty]
+        public int RamAddress { get; internal set; } = -1;
+        [JsonProperty]
+        public int RomAddress { get; internal set; } = -1;
+        [JsonProperty]
+        public int Length { get; internal set; } = 0;
+
+        public CustomAsmArea FindCustomAsmArea()
+        {
+            var args = new RequestCustomAsmAreaEventArgs();
+            RequestCustomAsmArea?.Invoke(this, args);
+            return args.CustomAsmArea;
+        }
+
+        internal class RequestCustomAsmAreaEventArgs
+        {
+            public CustomAsmArea CustomAsmArea { get; set; }
+        }
+    }
+}

SM64Lib/ASM/CustomAsmBank.cs

@@ -0,0 +1,85 @@
+using Newtonsoft.Json;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace SM64Lib.ASM
+{
+    public class CustomAsmBank
+    {
+        public CustomAsmBankConfig Config { get; }
+        [JsonIgnore]
+        public List<CustomAsmArea> Areas { get; } = new List<CustomAsmArea>();
+
+        public CustomAsmBank() : this(new CustomAsmBankConfig())
+        {
+        }
+
+        public CustomAsmBank(CustomAsmBankConfig config)
+        {
+            Config = config;
+        }
+
+        public void Load(RomManager romManager)
+        {
+            Areas.Clear();
+
+            bool canLoadArea(CustomAsmAreaConfig areaConfig) =>
+                areaConfig.RomAddress != -1;
+
+            if (Config.Areas.Where(n => canLoadArea(n)).Any())
+            {
+                var data = romManager.GetBinaryRom(System.IO.FileAccess.Read);
+
+                foreach (var areaConfig in Config.Areas)
+                {
+                    var area = new CustomAsmArea(areaConfig);
+                    area.Config.ID.GenerateIfNull();
+                    area.Load(data, Config);
+                    Areas.Add(area);
+                }
+
+                data.Close();
+            }
+        }
+
+        public void Save(RomManager romManager)
+        {
+            var startAddr = Config.GetRomStartAddress();
+            var curRomAddr = startAddr;
+
+            if (Areas.Any())
+            {
+                var data = romManager.GetBinaryRom(System.IO.FileAccess.ReadWrite);
+
+                foreach (var area in Areas)
+                    curRomAddr += area.Save(data, curRomAddr, Config);
+
+                data.Close();
+            }
+
+            UpdateAreaConfigCollection();
+            Config.Length = curRomAddr - startAddr;
+        }
+
+        public void UpdateAddresses()
+        {
+            if (Areas.Any())
+            {
+                var startAddr = Config.GetRomStartAddress();
+                var curRomAddr = startAddr;
+                foreach (var area in Areas)
+                    curRomAddr += area.UpdateAddresses(curRomAddr, Config);
+                Config.Length = curRomAddr - startAddr;
+            }
+        }
+
+        public void UpdateAreaConfigCollection()
+        {
+            Config.Areas.Clear();
+            Config.Areas.AddRange(Areas.Select(n => n.Config));
+        }
+    }
+}

SM64Lib/ASM/CustomAsmBankConfig.cs

@@ -0,0 +1,50 @@
+using Newtonsoft.Json;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace SM64Lib.ASM
+{
+    public class CustomAsmBankConfig
+    {
+        public static int DefaultMaxLength { get; set; } = 0xA000;
+        public static int DefaultRomStartAddress { get; internal set; } = 0x1206000;
+        public static int DefaultRamStartAddress { get; internal set; } = 0x406000;
+
+        public List<CustomAsmAreaConfig> Areas { get; } = new List<CustomAsmAreaConfig>();
+        public int MaxLength { get; set; } = -1;
+        [JsonProperty]
+        public int Length { get; internal set; } = -1;
+        public int RomStartAddress { get; set; } = -1;
+        public int RamStartAddress { get; set; } = -1;
+
+        public int GetRomStartAddress()
+            => GetRomStartAddressAdv().address;
+
+        public (int address, bool isDefault) GetRomStartAddressAdv()
+        {
+            bool isDefault = RomStartAddress == -1;
+            return (isDefault ? DefaultRomStartAddress : RomStartAddress, isDefault);
+        }
+
+        public int GetRamStartAddress()
+            => GetRamStartAddressAdv().address;
+
+        public (int address, bool isDefault) GetRamStartAddressAdv()
+        {
+            bool isDefault = RamStartAddress == -1;
+            return (isDefault ? DefaultRamStartAddress : RamStartAddress, isDefault);
+        }
+
+        public int GetMaxLength()
+            => GetMaxLengthAdv().length;
+
+        public (int length, bool isDefault) GetMaxLengthAdv()
+        {
+            bool isDefault = RamStartAddress == -1;
+            return (isDefault ? DefaultMaxLength : MaxLength, isDefault);
+        }
+    }
+}

SM64Lib/BaseTweakScriptInfo.cs

@@ -0,0 +1,30 @@
+using SM64Lib.Patching;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace SM64Lib
+{
+    public class BaseTweakScriptInfo
+    {
+        public PatchScript Script { get; private set; }
+        public int Priority { get; private set; }
+        public bool IsReadOnly { get; private set; }
+        public string Name { get; private set; }
+        public bool EnabledByDefault { get; private set; }
+        public bool Enabled { get; set; }
+
+        public BaseTweakScriptInfo(PatchScript script)
+        {
+            var infos = script.Name.Split('#');
+            Priority = Convert.ToInt32(infos[0]);
+            IsReadOnly = infos[1] == "w" ? true : false;
+            EnabledByDefault = infos[2] == "y" ? true : false;
+            Enabled = EnabledByDefault;
+            Name = infos[3];
+            Script = script;
+        }
+    }
+}

SM64Lib/Behaviors/Behavior.cs

@@ -0,0 +1,241 @@
+using Newtonsoft.Json;
+using SM64Lib.ASM;
+using SM64Lib.Behaviors.Script;
+using SM64Lib.Data;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Z.Collections.Extensions;
+using static SM64Lib.Extensions.ObjectExtensions;
+
+namespace SM64Lib.Behaviors
+{
+    public class Behavior
+    {
+        private readonly Dictionary<CustomAsmAreaConfig, BehaviorscriptCommand> knownCustomAsmCommands = new Dictionary<CustomAsmAreaConfig, BehaviorscriptCommand>();
+
+        [JsonProperty]
+        public BehaviorConfig Config { get; private set; }
+        [JsonProperty]
+        public Behaviorscript Script { get; private set; }
+        public int CollisionPointer { get; set; }
+        public bool EnableCollisionPointer { get; set; }
+        public List<int> BehaviorAddressDestinations { get; set; } = new List<int>();
+
+        [JsonIgnore]
+        public long Length
+        {
+            get
+            {
+                if (Config.FixedLength == -1)
+                    return Script.Length;
+                else
+                    return Config.FixedLength;
+            }
+        }
+
+        public Behavior() : this(new BehaviorConfig())
+        {
+        }
+
+        public Behavior(BehaviorConfig config)
+        {
+            CreateNewBehaviorscript();
+            Config = config;
+        }
+
+        public Behavior(BehaviorCreationTypes behaviorCreationType) : this()
+        {
+            Create(behaviorCreationType);
+        }
+
+        public void Create(BehaviorCreationTypes type)
+        {
+            CreateNewBehaviorscript();
+
+            switch (type)
+            {
+                case BehaviorCreationTypes.SolidObject:
+                    Script.Add(new BehaviorscriptCommand("00 09 00 00"));
+                    Script.Add(new BehaviorscriptCommand("11 01 00 01"));
+                    Script.Add(new BehaviorscriptCommand("2a 00 00 00 00 00 00 00"));
+                    Script.Add(new BehaviorscriptCommand("08 00 00 00"));
+                    Script.Add(new BehaviorscriptCommand("0c 00 00 00 80 38 39 cc"));
+                    Script.Add(new BehaviorscriptCommand("09 00 00 00"));
+                    break;
+            }
+
+            ParseScript();
+        }
+
+        private void CreateNewBehaviorscript()
+        {
+            if (Script != null)
+                Script.Close();
+            Script = new Behaviorscript();
+        }
+
+        public bool Read(BinaryData data, int address)
+        {
+            CreateNewBehaviorscript();
+            var success = Script.Read(data, address, Config.IsVanilla, Config.ExpectedLength != -1, Config.ExpectedLength);
+            if (Config.IsVanilla)
+                Config.FixedLength = (int)Script.Length;
+            Config.ExpectedLength = (int)Script.Length;
+            ParseScript();
+            return success;
+        }
+
+        public void Write(BinaryData data, int address)
+        {
+            //if (!Config.IsVanilla)
+            TakeoverSettingsToScript();
+
+            var length = Script.Write(data, address);
+
+            if (Config.FixedLength != -1 && length != Config.FixedLength)
+                data.Position -= length - Config.FixedLength;
+            Config.ExpectedLength = length;
+        }
+
+        public void ParseScript()
+        {
+            var dicCustomAsmFuncs = new Dictionary<int, CustomAsmAreaLinkOptions>();
+            EnableCollisionPointer = false;
+            knownCustomAsmCommands.Clear();
+
+            foreach (var link in Config.CustomAsmLinks)
+                dicCustomAsmFuncs.AddOrUpdate(link.CustomAsmAreaConfig.RamAddress | unchecked((int)0x80000000), link);
+
+            foreach (BehaviorscriptCommand cmd in Script)
+            {
+                switch (cmd.CommandType)
+                {
+                    case BehaviorscriptCommandTypes.x2A_SetCollision:
+                        CollisionPointer = BehaviorscriptCommandFunctions.X2A.GetCollisionPointer(cmd);
+                        EnableCollisionPointer = true;
+                        break;
+                    case BehaviorscriptCommandTypes.x0C_CallFunction:
+                        var ptr = BehaviorscriptCommandFunctions.X0C.GetAsmPointer(cmd);
+                        if (dicCustomAsmFuncs.ContainsKey(ptr))
+                            knownCustomAsmCommands.AddOrUpdate(dicCustomAsmFuncs[ptr].CustomAsmAreaConfig, cmd);
+                        break;
+                }
+            }
+        }
+
+        public void TakeoverSettingsToScript()
+        {
+            // Update collision pointer
+            AddUpdateRemoveCmd(
+                BehaviorscriptCommandTypes.x2A_SetCollision,
+                EnableCollisionPointer,
+                () => BehaviorscriptCommandFactory.Build_x2A(CollisionPointer),
+                (cmd) => BehaviorscriptCommandFunctions.X2A.SetCollisionPointer(cmd, CollisionPointer));
+
+            // Insert Custom Asm Links
+            {
+                foreach (var link in Config.CustomAsmLinks)
+                {
+                    var asmPointer = link.CustomAsmAreaConfig.RamAddress | unchecked((int)0x80000000);
+                    var cmdStartLoop = Script.FirstOfType(BehaviorscriptCommandTypes.x08_LoopStart);
+                    var cmdStartLoopIndex = Script.IndexOf(cmdStartLoop);
+                    int iInsert;
+
+                    if (link.Loop)
+                    {
+                        if (cmdStartLoop is not null)
+                            iInsert = cmdStartLoopIndex + 1;
+                        else
+                            iInsert = -1;
+                    }
+                    else
+                    {
+                        if (cmdStartLoop is not null)
+                            iInsert = cmdStartLoopIndex;
+                        else
+                            iInsert = (int)Script.Count - 2;
+                    }
+
+                    if (knownCustomAsmCommands.ContainsKey(link.CustomAsmAreaConfig))
+                    {
+                        var cmd = knownCustomAsmCommands[link.CustomAsmAreaConfig];
+                        var cmdIndex = Script.IndexOf(cmd);
+                        BehaviorscriptCommandFunctions.X0C.SetAsmPointer(cmd, asmPointer);
+
+                        if (cmdIndex != -1)
+                        {
+                            var reinsert = false;
+
+                            if (link.Loop && cmdIndex < cmdStartLoopIndex)
+                            {
+                                reinsert = true;
+                                iInsert -= 1;
+                            }
+                            else if (!link.Loop && cmdIndex > cmdStartLoopIndex)
+                                reinsert = true;
+
+                            if (reinsert)
+                            {
+                                Script.Remove(cmd);
+                                Script.Insert(iInsert, cmd);
+                            }
+                        }
+                    }
+                    else if (iInsert != -1)
+                    {
+                        var cmd = BehaviorscriptCommandFactory.Build_x0C(asmPointer);
+                        Script.Insert(iInsert, cmd);
+                        knownCustomAsmCommands.Add(link.CustomAsmAreaConfig, cmd);
+                    }
+                }
+
+                foreach (var kvp in knownCustomAsmCommands.ToArray())
+                {
+                    if (!Config.CustomAsmLinks.Where(n => n.CustomAsmAreaConfig == kvp.Key).Any())
+                    {
+                        knownCustomAsmCommands.Remove(kvp.Key);
+                        Script.RemoveIfContains(kvp.Value);
+                        kvp.Value.Close();
+                    }
+                }
+            }
+        }
+
+        private void AddUpdateRemoveCmd(BehaviorscriptCommandTypes cmdType, bool conditionAddUpdate, Func<BehaviorscriptCommand> createCmd, Action<BehaviorscriptCommand> updateCmd)
+        {
+            var cmd = Script.FirstOfType(cmdType);
+            if (cmd is not null)
+            {
+                if (conditionAddUpdate)
+                    updateCmd(cmd);
+                else
+                {
+                    Script.Remove(cmd);
+                    cmd.Close();
+                }
+            }
+            else if (conditionAddUpdate)
+            {
+                cmd = createCmd();
+                Script.Insert(1, cmd);
+            }
+        }
+
+        public void CopyPropertiesTo(Behavior dest)
+        {
+            // Copy Script
+            TakeoverSettingsToScript();
+            dest.Script.Close();
+            dest.Script.AddRange(Script);
+            dest.ParseScript();
+
+            // Copy Configs
+            dest.Config.Name = Config.Name;
+            Config.ParamsInfo.CloneTo(dest.Config.ParamsInfo);
+        }
+
+    }
+}

SM64Lib/Behaviors/BehaviorBank.cs

@@ -0,0 +1,220 @@
+using Newtonsoft.Json;
+using SM64Lib.Data;
+using SM64Lib.SegmentedBanking;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Z.Collections.Extensions;
+
+namespace SM64Lib.Behaviors
+{
+    public class BehaviorBank
+    {
+        public BehaviorBankConfig Config { get; private set; }
+        public List<Behavior> Behaviors { get; } = new List<Behavior>();
+
+        [JsonIgnore]
+        public long Length
+        {
+            get => Behaviors.Sum(n => n.Length);
+        }
+
+        public BehaviorBank(BehaviorBankConfig config)
+        {
+            Config = config;
+        }
+
+        public void ReadBank(SegmentedBank seg, int offset)
+        {
+            ReadBank(seg, offset, false);
+        }
+
+        public void ReadVanillaBank(SegmentedBank seg)
+        {
+            ReadBank(seg, 0, true);
+        }
+
+        private void ReadBank(SegmentedBank seg, int offset, bool isVanilla)
+        {
+            var data = new BinaryStreamData(seg.Data);
+            data.Position = offset;
+            ReadBank(data, isVanilla, seg.Length, (sbyte)seg.BankID);
+        }
+
+        public void ReadBank(BinaryData data)
+        {
+            ReadBank(data, false, -1, -1);
+        }
+
+        private void ReadBank(BinaryData data, bool isVanilla, int endAddress, sbyte bankID)
+        {
+            // Clear current list
+            Behaviors.Clear();
+
+            if (isVanilla)
+            {
+                while (data.Position <= endAddress - 0x10)
+                {
+                    var conf = new BehaviorConfig();
+                    Config.BehaviorConfigs.Add(conf);
+                    readBehavior(conf);
+                }
+            }
+            else
+            {
+                foreach (var config in Config.BehaviorConfigs.OrderBy(n => n.BankAddress))
+                    readBehavior(config);
+            }
+
+            void readBehavior(BehaviorConfig config)
+            {
+                int bankOffset;
+                Behavior behav = new Behavior(config);
+
+                if (isVanilla)
+                {
+                    bankOffset = (int)data.Position;
+                    config.BankAddress = (bankID << 24) | bankOffset;
+                    behav.Config.IsVanilla = true;
+                }
+                else
+                {
+                    bankOffset = config.BankAddress & 0xffffff;
+                    if (!behav.Config.IsVanilla && !config.ID.HasID) config.ID.Generate();
+                }
+
+                var lastBehav = Behaviors.LastOrDefault();
+
+                if (behav.Read(data, bankOffset))
+                {
+                    if (isVanilla && lastBehav is not null && lastBehav.Config.IsVanilla && lastBehav.Config.FixedLength != -1)
+                        lastBehav.Config.FixedLength = bankOffset - (lastBehav.Config.BankAddress & 0xffffff);
+
+                    Behaviors.Add(behav);
+                }
+            }
+        }
+
+        public SegmentedBank WriteToSeg(byte bankID, int offset, RomManager rommgr)
+        {
+            var segStream = new MemoryStream();
+            var seg = new SegmentedBank(bankID, segStream);
+            int lastPos = WriteToSeg(seg, offset, rommgr);
+            seg.Length = General.HexRoundUp1(lastPos);
+            return seg;
+        }
+
+        public int WriteToSeg(SegmentedBank seg, int offset, RomManager rommgr)
+        {
+            var addressUpdates = new Dictionary<int, int>();
+            var segStartAddress = seg.BankAddress | offset;
+            var data = new BinaryStreamData(seg.Data);
+            data.Position = offset;
+
+            if (Behaviors.Any())
+            {
+                // Save Behaviors to ROM
+                foreach (var behav in Behaviors)
+                {
+                    var address = (int)data.Position;
+                    var newBankAddress = (int)data.Position - offset + segStartAddress;
+                    if (newBankAddress != behav.Config.BankAddress)
+                    {
+                        if (behav.Config.BankAddress != -1)
+                            addressUpdates.AddOrUpdate(behav.Config.BankAddress, newBankAddress);
+                        behav.Config.BankAddress = newBankAddress;
+                    }
+                    behav.Write(data, (int)data.Position);
+                }
+            }
+
+            // Delete unused configs / Add new configs
+            Config.BehaviorConfigs.Clear();
+            Config.BehaviorConfigs.AddRange(Behaviors.Select(n => n.Config));
+
+            // Update addresses
+            UpdateBehaviorAddresses(rommgr, addressUpdates);
+
+            return (int)data.Position;
+        }
+
+        private void UpdateBehaviorAddresses(RomManager rommgr, Dictionary<int, int> addressUpdates)
+        {
+            if (Behaviors.Any() && rommgr is not null)
+            {
+                foreach (var lvl in rommgr.Levels)
+                {
+                    foreach (var area in lvl.Areas)
+                    {
+                        foreach (var obj in area.Objects)
+                        {
+                            var behavAddr = Levels.Script.Commands.clNormal3DObject.GetSegBehaviorAddr(obj);
+                            foreach (var kvp in addressUpdates)
+                            {
+                                if (behavAddr == kvp.Key)
+                                    Levels.Script.Commands.clNormal3DObject.SetSegBehaviorAddr(obj, (uint)kvp.Value);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        public void WriteBehaviorAddresss(RomManager rommgr)
+        {
+            var data = rommgr.GetBinaryRom(FileAccess.ReadWrite);
+            WriteBehaviorAddresss(data);
+            data.Close();
+        }
+
+        public void WriteBehaviorAddresss(BinaryData data)
+        {
+            if (Behaviors.Any())
+            {
+                foreach (var behav in Behaviors)
+                {
+                    foreach (var dest in behav.BehaviorAddressDestinations)
+                    {
+                        data.Position = dest;
+                        data.Write(behav.Config.BankAddress);
+                    }
+                }
+            }
+        }
+
+        public Behavior GetBehaviorByID(string id)
+        {
+            return Behaviors.FirstOrDefault(n => n.Config.ID == id);
+        }
+
+        public Behavior GetBehaviorByBankAddress(int bankAddress)
+        {
+            return Behaviors.FirstOrDefault(n => n.Config.BankAddress == bankAddress);
+        }
+
+        public void CalculateBehaviorBankAddresses(int bankStartAddress, RomManager rommgr)
+        {
+            var length = 0;
+            var addressUpdates = new Dictionary<int, int>();
+
+            foreach (var behav in Behaviors)
+            {
+                if (behav.Config.IsVanilla)
+                    length += behav.Config.FixedLength;
+                else
+                {
+                    var newBankAddress = bankStartAddress + length;
+                    addressUpdates.AddIfNotContainsKey(behav.Config.BankAddress, newBankAddress);
+                    behav.Config.BankAddress = newBankAddress;
+                    length += (int)behav.Script.Length;
+                }
+            }
+
+            // Update addresses
+            UpdateBehaviorAddresses(rommgr, addressUpdates);
+        }
+    }
+}

SM64Lib/Behaviors/BehaviorBankConfig.cs

@@ -0,0 +1,36 @@
+using Newtonsoft.Json;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace SM64Lib.Behaviors
+{
+    public class BehaviorBankConfig
+    {
+        public bool IsVanilla { get; set; } = true;
+        public List<BehaviorConfig> BehaviorConfigs { get; } = new List<BehaviorConfig>();
+
+        [JsonProperty(nameof(Enabled))]
+        private bool enabled = false;
+        public void Enable() => enabled = true;
+        internal void Disable()
+        {
+            enabled = false;
+            IsVanilla = true;
+            BehaviorConfigs.Clear();
+        }
+
+        [JsonIgnore]
+        public bool Enabled
+        {
+            get
+            {
+                if (!enabled && !IsVanilla)
+                    enabled = true;
+                return enabled;
+            }
+        }
+    }
+}

SM64Lib/Behaviors/BehaviorConfig.cs

@@ -0,0 +1,39 @@
+using Newtonsoft.Json;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Pilz.Cryptography;
+using Pilz.Json.Converters;
+
+namespace SM64Lib.Behaviors
+{
+    public class BehaviorConfig
+    {
+        internal delegate void RequestModelEventHandler(BehaviorConfig config, RequestBehaviorEventArgs request);
+        internal static event RequestModelEventHandler RequestBehavior;
+
+        [JsonConverter(typeof(UniquieIDStringJsonConverter))]
+        public UniquieID ID { get; set; } = new();
+        public int BankAddress { get; set; } = -1;
+        public bool IsVanilla { get; set; } = false;
+        public string Name { get; set; } = string.Empty;
+        public int FixedLength { get; set; } = -1;
+        public int ExpectedLength { get; set; } = -1;
+        public List<CustomAsmAreaLinkOptions> CustomAsmLinks { get; } = new List<CustomAsmAreaLinkOptions>();
+        public BehaviorParamsInfo ParamsInfo { get; } = new BehaviorParamsInfo();
+
+        public Behavior FindBehavior()
+        {
+            var args = new RequestBehaviorEventArgs();
+            RequestBehavior?.Invoke(this, args);
+            return args.Behavior;
+        }
+
+        internal class RequestBehaviorEventArgs
+        {
+            public Behavior Behavior { get; set; }
+        }
+    }
+}

SM64Lib/Behaviors/BehaviorCreationTypes.cs

@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace SM64Lib.Behaviors
+{
+    public enum BehaviorCreationTypes
+    {
+        SolidObject
+    }
+}

SM64Lib/Behaviors/BehaviorParamInfo.cs

@@ -0,0 +1,15 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace SM64Lib.Behaviors
+{
+    public class BehaviorParamInfo
+    {
+        public string Name { get; set; } = string.Empty;
+        public string Description { get; set; } = string.Empty;
+        public List<BehaviorParamValue> Values { get; } = new List<BehaviorParamValue>();
+    }
+}

SM64Lib/Behaviors/BehaviorParamValue.cs

@@ -0,0 +1,14 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace SM64Lib.Behaviors
+{
+    public class BehaviorParamValue
+    {
+        public string Name { get; set; } = "";
+        public byte Value { get; set; } = 0;
+    }
+}

SM64Lib/Behaviors/BehaviorParamsInfo.cs

@@ -0,0 +1,16 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace SM64Lib.Behaviors
+{
+    public class BehaviorParamsInfo
+    {
+        public BehaviorParamInfo Param1 { get; } = new();
+        public BehaviorParamInfo Param2 { get; } = new();
+        public BehaviorParamInfo Param3 { get; } = new();
+        public BehaviorParamInfo Param4 { get; } = new();
+    }
+}

SM64Lib/Behaviors/CustomAsmAreaLinkOptions.cs

@@ -0,0 +1,25 @@
+using Newtonsoft.Json;
+using SM64Lib.ASM;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace SM64Lib.Behaviors
+{
+    public class CustomAsmAreaLinkOptions
+    {
+        // Temporary fix - Remove custom property code and make it auto property in v1.?
+        private CustomAsmAreaConfig customAsmAreaConfig;
+        public CustomAsmAreaConfig CustomAsmAreaConfig
+        {
+            get => customAsmAreaConfig ?? CustomAsm?.Config;
+            set => customAsmAreaConfig = value;
+        }
+        // Temporary fix for old files - Remove property in v1.?
+        [JsonProperty]
+        public CustomAsmArea CustomAsm { get; private set; }
+        public bool Loop { get; set; }
+    }
+}

SM64Lib/Behaviors/Script/Behaviorscript.cs

@@ -0,0 +1,106 @@
+using SM64Lib.Data;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace SM64Lib.Behaviors.Script
+{
+    public class Behaviorscript : BehaviorscriptCommandCollection
+    {
+        public bool Read(BinaryData data, int address, bool detectJumpsAsEnd = false, bool ignoreEndCmds = false, int expectedLength = -1)
+        {
+            bool ende = false;
+            bool success = true;
+            var newCmds = new List<BehaviorscriptCommand>();
+            
+            data.Position = address;
+
+            if (expectedLength < 0)
+                expectedLength = (int)data.Length;
+            else
+                expectedLength += address;
+
+            while (!ende)
+            {
+                if (expectedLength - data.Position >= 4)
+                {
+                    // Get command infos
+                    var cmdType = (BehaviorscriptCommandTypes)data.ReadByte();
+                    int cmdLength = BehaviorscriptCommand.GetCommandLength(cmdType);
+                    var unknownCmd = cmdLength == -1;
+                    bool isEndCmd = ignoreEndCmds ? false : (unknownCmd || BehaviorscriptCommand.IsEndCommand(cmdType, detectJumpsAsEnd));
+
+                    if (!unknownCmd)
+                    {
+                        // Reset position
+                        data.Position -= 1;
+
+                        if (data.Position + cmdLength <= expectedLength)
+                        {
+                            // Read full command
+                            byte[] buf = new byte[cmdLength];
+                            data.Read(buf);
+
+                            // Create & add command
+                            try
+                            {
+                                newCmds.Add(new BehaviorscriptCommand(buf));
+                            }
+                            catch (Exception)
+                            {
+                                success = false;
+                            }
+
+                            ende = isEndCmd;
+                        }
+                        else
+                            ende = true;
+                    }
+                    else
+                    {
+                        data.Position += 3;
+                        ende = isEndCmd;
+                    }
+                }
+                else
+                    ende = true;
+            }
+
+            // Add new Cmds
+            if (success && newCmds.Any())
+            {
+                Close();
+                AddRange(newCmds.ToArray());
+            }
+
+            return success;
+        }
+
+        public int Write(BinaryData data, int address)
+        {
+            data.Position = address;
+
+            foreach (BehaviorscriptCommand command in this)
+            {
+                var cmdLength = BehaviorscriptCommand.GetCommandLength(command.CommandType);
+                if (command.Length != cmdLength)
+                    command.SetLength(cmdLength);
+                data.Write(command.ToArray());
+            }
+
+            return (int)data.Position - address;
+        }
+
+        public int IndexOfType(BehaviorscriptCommandTypes cmdType)
+        {
+            return IndexOf(this.FirstOrDefault(n => n.CommandType == cmdType));
+        }
+
+        public BehaviorscriptCommand FirstOfType(BehaviorscriptCommandTypes cmdType)
+        {
+            return (BehaviorscriptCommand)this.FirstOrDefault(n => n.CommandType == cmdType);
+        }
+
+    }
+}

SM64Lib/Behaviors/Script/BehaviorscriptCommand.cs

@@ -0,0 +1,120 @@
+
+using Newtonsoft.Json;
+using SM64Lib.Json;
+
+namespace SM64Lib.Behaviors.Script
+{
+    [JsonConverter(typeof(BehaviorscriptCommandJsonConverter))]
+    public class BehaviorscriptCommand : SM64Lib.Script.BaseCommand<BehaviorscriptCommandTypes>
+    {
+
+        public override BehaviorscriptCommandTypes CommandType
+        {
+            get
+            {
+                Position = 0;
+                return (BehaviorscriptCommandTypes)ReadByte();
+            }
+
+            set
+            {
+                Position = 0;
+                WriteByte((byte)value);
+            }
+        }
+
+        public BehaviorscriptCommand() : base()
+        {
+        }
+
+        public BehaviorscriptCommand(byte[] cmd) : base(cmd)
+        {
+        }
+
+        public BehaviorscriptCommand(string cmd) : base(cmd, true)
+        {
+        }
+
+        public static int GetCommandLength(BehaviorscriptCommandTypes type)
+        {
+            switch (type)
+            {
+                case BehaviorscriptCommandTypes.x00_Start: return 4;
+                case BehaviorscriptCommandTypes.x01_StateLoop: return 4;
+                case BehaviorscriptCommandTypes.x02_JumpandLink: return 8;
+                case BehaviorscriptCommandTypes.x03_Return: return 4;
+                case BehaviorscriptCommandTypes.x04_Jump: return 8;
+                case BehaviorscriptCommandTypes.x05_LoopN: return 4;
+                case BehaviorscriptCommandTypes.x06_EndLoopN: return 4;
+                case BehaviorscriptCommandTypes.x07_InfiniteLoop: return 4;
+                case BehaviorscriptCommandTypes.x08_LoopStart: return 4;
+                case BehaviorscriptCommandTypes.x09_LoopEnd: return 4;
+                case BehaviorscriptCommandTypes.x0A_EndBehaviorscript: return 4;
+                case BehaviorscriptCommandTypes.x0B_EndBehaviorscript_Unused: return 4;
+                case BehaviorscriptCommandTypes.x0C_CallFunction: return 8;
+                case BehaviorscriptCommandTypes.x0D_OffsetbyFloat: return 4;
+                case BehaviorscriptCommandTypes.x0E_SettoFloat: return 4;
+                case BehaviorscriptCommandTypes.x0F_OffsetbyInteger: return 4;
+                case BehaviorscriptCommandTypes.x10_SettoInteger: return 4;
+                case BehaviorscriptCommandTypes.x11_BitSet: return 4;
+                case BehaviorscriptCommandTypes.x12_BitClear: return 4;
+                case BehaviorscriptCommandTypes.x13_AddRNG: return 8;
+                case BehaviorscriptCommandTypes.x14_ObjectType: return 8;
+                case BehaviorscriptCommandTypes.x15_FloatMultiply: return 8;
+                case BehaviorscriptCommandTypes.x16_FloatAdd: return 8;
+                case BehaviorscriptCommandTypes.x17_AddRNG2: return 8;
+                case BehaviorscriptCommandTypes.x18_NoOperation: return 4;
+                case BehaviorscriptCommandTypes.x19_NoOperation: return 4;
+                case BehaviorscriptCommandTypes.x1A_NoOperation: return 4;
+                case BehaviorscriptCommandTypes.x1B_ChangeModelID: return 4;
+                case BehaviorscriptCommandTypes.x1C_LoadChildObject: return 0xC;
+                case BehaviorscriptCommandTypes.x1D_Deactivate: return 4;
+                case BehaviorscriptCommandTypes.x1E_DroptoGround: return 4;
+                case BehaviorscriptCommandTypes.x1F_UsedforWaves: return 4;
+                case BehaviorscriptCommandTypes.x20_Unused: return 4;
+                case BehaviorscriptCommandTypes.x21_SetBillboarding: return 4;
+                case BehaviorscriptCommandTypes.x22_SetRenderInvisibleflag: return 4;
+                case BehaviorscriptCommandTypes.x23_Collisioncylindersize: return 8;
+                case BehaviorscriptCommandTypes.x24_Nothing: return 4;
+                case BehaviorscriptCommandTypes.x25_StateCycle: return 4;
+                case BehaviorscriptCommandTypes.x26_Loop: return 4;
+                case BehaviorscriptCommandTypes.x27_SetWord: return 8;
+                case BehaviorscriptCommandTypes.x28_Animates: return 4;
+                case BehaviorscriptCommandTypes.x29_LoadChildObject: return 0xC;
+                case BehaviorscriptCommandTypes.x2A_SetCollision: return 8;
+                case BehaviorscriptCommandTypes.x2B_SetCollisionSphere: return 0xC;
+                case BehaviorscriptCommandTypes.x2C_SpawnObject: return 0xC;
+                case BehaviorscriptCommandTypes.x2D_SetInitPosition: return 4;
+                case BehaviorscriptCommandTypes.x2E_SetHurtbox: return 8;
+                case BehaviorscriptCommandTypes.x2F_SetInteraction: return 8;
+                case BehaviorscriptCommandTypes.x30_SetGravity: return 0x14;
+                case BehaviorscriptCommandTypes.x31_SetInteractionSubType: return 8;
+                case BehaviorscriptCommandTypes.x32_ScaleObject: return 4;
+                case BehaviorscriptCommandTypes.x33_ChildObjectChange: return 8;
+                case BehaviorscriptCommandTypes.x34_TextureAnimateRate: return 4;
+                case BehaviorscriptCommandTypes.x35_ClearGraphFlag: return 4;
+                case BehaviorscriptCommandTypes.x36_SetValue: return 8;
+                case BehaviorscriptCommandTypes.x37_SpawnSomething: return 8;
+                default: return -1; //throw new System.Exception("Command type not found!");
+            }
+        }
+
+        public static bool IsEndCommand(BehaviorscriptCommandTypes type, bool detectJumpsAsEnd = true)
+        {
+            switch (type)
+            {
+                case BehaviorscriptCommandTypes.x02_JumpandLink:
+                case BehaviorscriptCommandTypes.x04_Jump:
+                    return detectJumpsAsEnd;
+                case BehaviorscriptCommandTypes.x06_EndLoopN:
+                case BehaviorscriptCommandTypes.x0A_EndBehaviorscript:
+                case BehaviorscriptCommandTypes.x0B_EndBehaviorscript_Unused:
+                case BehaviorscriptCommandTypes.x09_LoopEnd:
+                    return true;
+                default:
+                    return false;
+            }
+        }
+
+    }
+}

SM64Lib/Behaviors/Script/BehaviorscriptCommandCollection.cs

@@ -0,0 +1,7 @@
+
+namespace SM64Lib.Behaviors.Script
+{
+    public class BehaviorscriptCommandCollection : SM64Lib.Script.BaseCommandCollection<BehaviorscriptCommand, BehaviorscriptCommandTypes>
+    {
+    }
+}

SM64Lib/Behaviors/Script/BehaviorscriptCommandFactory.cs

@@ -0,0 +1,32 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace SM64Lib.Behaviors.Script
+{
+    public static class BehaviorscriptCommandFactory
+    {
+        public static BehaviorscriptCommand Build_x2A(int collisionPointer = -1)
+        {
+            var cmd = new BehaviorscriptCommand("2a 00 00 00 00 00 00 00");
+            if (collisionPointer != -1)
+                BehaviorscriptCommandFunctions.X2A.SetCollisionPointer(cmd, collisionPointer);
+            return cmd;
+        }
+
+        public static BehaviorscriptCommand Build_x08()
+        {
+            return new BehaviorscriptCommand("08 00 00 00");
+        }
+
+        public static BehaviorscriptCommand Build_x0C(int asmPointer = -1)
+        {
+            var cmd = new BehaviorscriptCommand("0C 00 00 00 00 00 00 00");
+            if (asmPointer != -1)
+                BehaviorscriptCommandFunctions.X2A.SetCollisionPointer(cmd, asmPointer);
+            return cmd;
+        }
+    }
+}

SM64Lib/Behaviors/Script/BehaviorscriptCommandFunctions.cs

@@ -0,0 +1,39 @@
+using SM64Lib.Data;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace SM64Lib.Behaviors.Script
+{
+    public class BehaviorscriptCommandFunctions
+    {
+        public class X2A
+        {
+            public static int GetCollisionPointer(BehaviorscriptCommand cmd)
+            {
+                cmd.Position = 4;
+                return cmd.ReadInt32();
+            }
+            public static void SetCollisionPointer(BehaviorscriptCommand cmd, int pointer)
+            {
+                cmd.Position = 4;
+                cmd.Write(pointer);
+            }
+        }
+        public class X0C
+        {
+            public static int GetAsmPointer(BehaviorscriptCommand cmd)
+            {
+                cmd.Position = 4;
+                return cmd.ReadInt32();
+            }
+            public static void SetAsmPointer(BehaviorscriptCommand cmd, int pointer)
+            {
+                cmd.Position = 4;
+                cmd.Write(pointer);
+            }
+        }
+    }
+}

SM64Lib/Behaviors/Script/BehaviorscriptCommandTypes.cs

@@ -0,0 +1,62 @@
+namespace SM64Lib.Behaviors.Script
+{
+    public enum BehaviorscriptCommandTypes
+    {
+        x00_Start,
+        x01_StateLoop,
+        x02_JumpandLink,
+        x03_Return,
+        x04_Jump,
+        x05_LoopN,
+        x06_EndLoopN,
+        x07_InfiniteLoop,
+        x08_LoopStart,
+        x09_LoopEnd,
+        x0A_EndBehaviorscript,
+        x0B_EndBehaviorscript_Unused,
+        x0C_CallFunction,
+        x0D_OffsetbyFloat,
+        x0E_SettoFloat,
+        x0F_OffsetbyInteger,
+        x10_SettoInteger,
+        x11_BitSet,
+        x12_BitClear,
+        x13_AddRNG,
+        x14_ObjectType,
+        x15_FloatMultiply,
+        x16_FloatAdd,
+        x17_AddRNG2,
+        x18_NoOperation,
+        x19_NoOperation,
+        x1A_NoOperation,
+        x1B_ChangeModelID,
+        x1C_LoadChildObject,
+        x1D_Deactivate,
+        x1E_DroptoGround,
+        x1F_UsedforWaves,
+        x20_Unused,
+        x21_SetBillboarding,
+        x22_SetRenderInvisibleflag,
+        x23_Collisioncylindersize,
+        x24_Nothing,
+        x25_StateCycle,
+        x26_Loop,
+        x27_SetWord,
+        x28_Animates,
+        x29_LoadChildObject,
+        x2A_SetCollision,
+        x2B_SetCollisionSphere,
+        x2C_SpawnObject,
+        x2D_SetInitPosition,
+        x2E_SetHurtbox,
+        x2F_SetInteraction,
+        x30_SetGravity,
+        x31_SetInteractionSubType,
+        x32_ScaleObject,
+        x33_ChildObjectChange,
+        x34_TextureAnimateRate,
+        x35_ClearGraphFlag,
+        x36_SetValue,
+        x37_SpawnSomething
+    }
+}

SM64Lib/Configuration/CollisionBasicConfig.cs

@@ -0,0 +1,22 @@
+using Newtonsoft.Json;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace SM64Lib.Configuration
+{
+    public class CollisionBasicConfig
+    {
+        private List<byte> collisionTypesWithParams = new List<byte>()
+        { 4, 14, 44, 36, 37, 39, 45 };
+
+        [JsonProperty("CollisionTypesWithParamsV2", ObjectCreationHandling = ObjectCreationHandling.Replace)]
+        public List<byte> CollisionTypesWithParams
+        {
+            get => collisionTypesWithParams;
+            private set => collisionTypesWithParams = value.Distinct().ToList();
+        }
+    }
+}

SM64Lib/Configuration/CustomModelConfig.cs

@@ -0,0 +1,31 @@
+using Newtonsoft.Json;
+using SM64Lib.Objects.ModelBanks;
+using System.Collections.Generic;
+using Pilz.Cryptography;
+using Pilz.Json.Converters;
+
+namespace SM64Lib.Configuration
+{
+    public class CustomModelConfig
+    {
+        internal delegate void RequestModelEventHandler(CustomModelConfig config, RequestModelEventArgs request);
+        internal static event RequestModelEventHandler RequestModel;
+
+        [JsonConverter(typeof(UniquieIDStringJsonConverter))]
+        public UniquieID ID { get; set; } = new();
+        public string Name { get; set; } = string.Empty;
+        public List<int> CollisionPointerDestinations { get; private set; } = new List<int>();
+
+        public CustomModel FindModel()
+        {
+            var args = new RequestModelEventArgs();
+            RequestModel?.Invoke(this, args);
+            return args.Model;
+        }
+
+        internal class RequestModelEventArgs
+        {
+            public CustomModel Model { get; set; }
+        }
+    }
+}

SM64Lib/Configuration/LevelAreaConfig.cs

@@ -0,0 +1,10 @@
+using System.Collections.Generic;
+
+namespace SM64Lib.Configuration
+{
+    public class LevelAreaConfig
+    {
+        public string AreaName { get; set; }
+        public Dictionary<short, string> ScrollingNames { get; set; } = new Dictionary<short, string>();
+    }
+}

SM64Lib/Configuration/LevelConfig.cs

@@ -0,0 +1,26 @@
+using System.Collections.Generic;
+
+namespace SM64Lib.Configuration
+{
+    public class LevelConfig
+    {
+        public string LevelName { get; set; }
+        public bool EnableLocalObjectBank { get; set; } = false;
+        public ObjectModelConfig LocalObjectBank { get; set; } = new ObjectModelConfig();
+        public Dictionary<byte, LevelAreaConfig> AreaConfigs { get; private set; } = new Dictionary<byte, LevelAreaConfig>();
+
+        public LevelAreaConfig GetLevelAreaConfig(byte areaID)
+        {
+            if (AreaConfigs.ContainsKey(areaID))
+            {
+                return AreaConfigs[areaID];
+            }
+            else
+            {
+                var conf = new LevelAreaConfig();
+                AreaConfigs.Add(areaID, conf);
+                return conf;
+            }
+        }
+    }
+}

SM64Lib/Configuration/MusicConfiguration.cs

@@ -0,0 +1,9 @@
+using System.Collections.Generic;
+
+namespace SM64Lib.Configuration
+{
+    public class MusicConfiguration
+    {
+        public List<string> SqeuenceNames { get; private set; } = new List<string>();
+    }
+}

SM64Lib/Configuration/NPCConfig.cs

@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace SM64Lib.Configuration
+{
+    public class NPCConfig
+    {
+        public bool Enabled3DCoins { get; set; } = false;
+    }
+}

SM64Lib/Configuration/ObjectModelConfig.cs

@@ -0,0 +1,20 @@
+using System.Collections.Generic;
+
+namespace SM64Lib.Configuration
+{
+    public class ObjectModelConfig
+    {
+        public Dictionary<int, CustomModelConfig> CustomObjectConfigs { get; private set; } = new Dictionary<int, CustomModelConfig>();
+
+        public CustomModelConfig GetCustomObjectConfig(int id)
+        {
+            CustomModelConfig conf = null;
+            if (!CustomObjectConfigs.TryGetValue(id, out conf))
+            {
+                conf = new CustomModelConfig();
+            }
+
+            return conf;
+        }
+    }
+}

SM64Lib/Configuration/PatchingConfig.cs

@@ -0,0 +1,15 @@
+using Pilz.IO;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace SM64Lib.Configuration
+{
+    public class PatchingConfig
+    {
+        public EmbeddedFilesContainer TweakBackups { get; } = new EmbeddedFilesContainer();
+        public bool Patched2DCamera { get; set; } = false;
+    }
+}

SM64Lib/Configuration/RomConfig.cs

@@ -0,0 +1,78 @@
+using System.Collections.Generic;
+using global::System.IO;
+using Microsoft.VisualBasic.CompilerServices;
+using global::Newtonsoft.Json.Linq;
+using Newtonsoft.Json;
+using SM64Lib.Behaviors;
+using SM64Lib.Objects.ObjectBanks;
+using SM64Lib.ASM;
+using SM64Lib.Objects.ObjectBanks.Data;
+using System;
+
+namespace SM64Lib.Configuration
+{
+    public class RomConfig
+    {
+        // Levels
+        public Dictionary<byte, LevelConfig> LevelConfigs { get; } = new Dictionary<byte, LevelConfig>();
+
+        // Global Banks
+        [JsonProperty("GlobalObjectBankConfig")]
+        public ObjectModelConfig GlobalModelBank { get; } = new ObjectModelConfig();
+        public CustomAsmBankConfig GlobalCustomAsmBank { get; } = new CustomAsmBankConfig();
+        public BehaviorBankConfig GlobalBehaviorBank { get; } = new BehaviorBankConfig();
+        public CustomObjectCollection GlobalObjectBank { get; } = new CustomObjectCollection();
+
+        // Music
+        public MusicConfiguration MusicConfig { get;  } = new MusicConfiguration();
+
+        // Texts
+        public Text.Profiles.TextProfileInfo TextProfileInfo { get; set; } = null;
+
+        // Patching
+        public PatchingConfig PatchingConfig { get; set; } = new PatchingConfig();
+
+        // Other
+        public ScrollTexConfig ScrollTexConfig { get; set; } = new ScrollTexConfig();
+        public ObjectBankDataListCollection ObjectBankInfoData { get; } = new ObjectBankDataListCollection();
+        public NPCConfig NPCConfig { get; } = new NPCConfig();
+        public CollisionBasicConfig CollisionBaseConfig { get; } = new CollisionBasicConfig();
+
+        /// <summary>
+        /// Contains custom configuration that isn't used by SM64Lib. E.g. Extra Object Combos.
+        /// </summary>
+        public Dictionary<string, string> CustomConfigs { get; } = new Dictionary<string, string>();
+
+        // F e a t u r e s
+
+        public LevelConfig GetLevelConfig(ushort levelID)
+        {
+            if (LevelConfigs.ContainsKey(Convert.ToByte(levelID)))
+            {
+                return LevelConfigs[Convert.ToByte(levelID)];
+            }
+            else
+            {
+                var conf = new LevelConfig();
+                LevelConfigs.Add(Convert.ToByte(levelID), conf);
+                return conf;
+            }
+        }
+
+        // L o a d / S a v e
+
+        public static RomConfig Load(string filePath)
+        {
+            var serializer = JsonSerializer.CreateDefault();
+            serializer.PreserveReferencesHandling = PreserveReferencesHandling.All;
+            return JObject.Parse(File.ReadAllText(filePath)).ToObject<RomConfig>(serializer);
+        }
+
+        public void Save(string filePath)
+        {
+            var serializer = JsonSerializer.CreateDefault();
+            serializer.PreserveReferencesHandling = PreserveReferencesHandling.All;
+            File.WriteAllText(filePath, JObject.FromObject(this, serializer).ToString());
+        }
+    }
+}

SM64Lib/Configuration/ScrollTexConfig.cs

@@ -0,0 +1,14 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace SM64Lib.Configuration
+{
+    public class ScrollTexConfig
+    {
+        public bool UseCustomBehavior { get; set; } = false;
+        public int CustomBehaviorAddress { get; set; } = -1;
+    }
+}

SM64Lib/Data/BinaryArrayData.cs

@@ -0,0 +1,28 @@
+using global::System.IO;
+
+namespace SM64Lib.Data
+{
+    public class BinaryArrayData : BinaryStreamData
+    {
+        public FileAccess RomAccess { get; private set; } = FileAccess.Read;
+
+        public BinaryArrayData(byte[] buffer) : base(new MemoryStream(buffer))
+        {
+        }
+
+        // Inherits BinaryData
+
+        // Private ReadOnly myBaseStream As Stream
+
+        // Public ReadOnly Property RomAccess As FileAccess = FileAccess.Read
+
+        // Public Sub New(buffer As Byte())
+        // myBaseStream = New MemoryStream(buffer)
+        // End Sub
+
+        // Protected Overrides Function GetBaseStream() As Stream
+        // Return myBaseStream
+        // End Function
+
+    }
+}

SM64Lib/Data/BinaryData.cs

@@ -0,0 +1,280 @@
+using global::System.IO;
+using SM64Lib.Data.System;
+using System;
+
+namespace SM64Lib.Data
+{
+    public abstract class BinaryData : IDisposable
+    {
+        public delegate void AnyBinaryDataEventHandler(BinaryData data);
+
+        public static event AnyBinaryDataEventHandler AnyBinaryDataOpened;
+        public static event AnyBinaryDataEventHandler AnyBinaryDataClosing;
+        public static event AnyBinaryDataEventHandler AnyBinaryDataClosed;
+        public static event AnyBinaryDataDisposedEventHandler AnyBinaryDataDisposed;
+
+        public delegate void AnyBinaryDataDisposedEventHandler();
+
+        private Stream _BaseStream = null;
+        private BinaryWriter _writer = null;
+        private BinaryReader _reader = null;
+
+        public RomManager RomManager { get; private set; }
+
+        protected abstract Stream GetBaseStream();
+
+        protected BinaryWriter Writer
+        {
+            get
+            {
+                if (_writer is null)
+                {
+                    _writer = new BinaryWriter(BaseStream);
+                }
+
+                return _writer;
+            }
+        }
+
+        protected BinaryReader Reader
+        {
+            get
+            {
+                if (_reader is null)
+                {
+                    _reader = new BinaryReader(BaseStream);
+                }
+
+                return _reader;
+            }
+        }
+
+        public long Position
+        {
+            get
+            {
+                return BaseStream.Position;
+            }
+
+            set
+            {
+                BaseStream.Position = value;
+            }
+        }
+
+        public long Length
+        {
+            get
+            {
+                return BaseStream.Length;
+            }
+        }
+
+        public Stream BaseStream
+        {
+            get
+            {
+                if (_BaseStream is null)
+                {
+                    _BaseStream = GetBaseStream();
+                    RaiseAnyBinaryDataOpened(this);
+                }
+
+                return _BaseStream;
+            }
+        }
+
+        ~BinaryData()
+        {
+            AnyBinaryDataDisposed?.Invoke();
+        }
+
+        public void RoundUpPosition()
+        {
+            Position = General.HexRoundUp1(Position);
+        }
+
+        public void RoundUpPosition(int add)
+        {
+            Position = General.HexRoundUp1(Position + add);
+        }
+
+        protected void SetRomManager(RomManager rommgr)
+        {
+            RomManager = rommgr;
+        }
+
+        public void Write(sbyte value)
+        {
+            Writer.Write(value);
+        }
+
+        public void Write(byte value)
+        {
+            Writer.Write(value);
+        }
+
+        public void WriteByte(byte value)
+        {
+            Write(value);
+        }
+
+        public void Write(short value)
+        {
+            Writer.Write(SwapInts.SwapInt16(value));
+        }
+
+        public void Write(ushort value)
+        {
+            Writer.Write(SwapInts.SwapUInt16(value));
+        }
+
+        public void Write(int value)
+        {
+            Writer.Write(SwapInts.SwapInt32(value));
+        }
+
+        public void Write(uint value)
+        {
+            Writer.Write(SwapInts.SwapUInt32(value));
+        }
+
+        public void Write(long value)
+        {
+            Writer.Write(SwapInts.SwapInt64(value));
+        }
+
+        public void Write(ulong value)
+        {
+            Writer.Write(SwapInts.SwapUInt64(value));
+        }
+
+        public void Write(float value, bool isHalf = false)
+        {
+            if (isHalf)
+                Writer.Write(SwapInts.SwapHalf(value));
+            else
+                Writer.Write(SwapInts.SwapFloat32(value));
+        }
+
+        public void Write(string value)
+        {
+            Writer.Write(value);
+        }
+
+        public void Write(byte[] buffer)
+        {
+            Write(buffer, 0, buffer.Length);
+        }
+
+        public void Write(byte[] buffer, int index, int count)
+        {
+            Writer.Write(buffer, index, count);
+        }
+
+        public byte ReadByte()
+        {
+            return Reader.ReadByte();
+        }
+
+        public sbyte ReadSByte()
+        {
+            return Reader.ReadSByte();
+        }
+
+        public short ReadInt16()
+        {
+            return SwapInts.SwapInt16(Reader.ReadInt16());
+        }
+
+        public ushort ReadUInt16()
+        {
+            return SwapInts.SwapUInt16(Reader.ReadUInt16());
+        }
+
+        public int ReadInt32()
+        {
+            return SwapInts.SwapInt32(Reader.ReadInt32());
+        }
+
+        public uint ReadUInt32()
+        {
+            return SwapInts.SwapUInt32(Reader.ReadUInt32());
+        }
+
+        public long ReadInt64()
+        {
+            return SwapInts.SwapInt64(Reader.ReadInt64());
+        }
+
+        public ulong ReadUInt64()
+        {
+            return SwapInts.SwapUInt64(Reader.ReadUInt64());
+        }
+
+        public float ReadSingle()
+        {
+            return SwapInts.SwapFloat32(Reader.ReadSingle());
+        }
+
+        public string ReadString()
+        {
+            return Reader.ReadString();
+        }
+
+        public void Read(byte[] buffer)
+        {
+            Read(buffer, 0, buffer.Length);
+        }
+
+        public void Read(byte[] buffer, int index, int count)
+        {
+            Reader.Read(buffer, index, count);
+        }
+
+        public byte[] Read(int count)
+        {
+            var buf = new byte[count];
+            Read(buf, 0, count);
+            return buf;
+        }
+
+        public void Close()
+        {
+            AnyBinaryDataClosing?.Invoke(this);
+            BaseStream.Close();
+            AnyBinaryDataClosed?.Invoke(this);
+        }
+
+        public bool CanRead
+        {
+            get
+            {
+                return BaseStream.CanRead;
+            }
+        }
+
+        public bool CanWrite
+        {
+            get
+            {
+                return BaseStream.CanWrite;
+            }
+        }
+
+        public void SetLength(long length)
+        {
+            BaseStream.SetLength(length);
+        }
+
+        internal static void RaiseAnyBinaryDataOpened(BinaryData data)
+        {
+            AnyBinaryDataOpened?.Invoke(data);
+        }
+
+        public void Dispose()
+        {
+            Close();
+        }
+    }
+}

SM64Lib/Data/BinaryFile.cs

@@ -0,0 +1,11 @@
+using global::System.IO;
+
+namespace SM64Lib.Data
+{
+    public class BinaryFile : BinaryStreamData
+    {
+        public BinaryFile(string filePath, FileMode fileMode, FileAccess fileAccess) : base(new FileStream(filePath, fileMode, fileAccess))
+        {
+        }
+    }
+}

SM64Lib/Data/BinaryRom.cs

@@ -0,0 +1,26 @@
+using global::System.IO;
+
+namespace SM64Lib.Data
+{
+    public class BinaryRom : BinaryFile
+    {
+        public BinaryRom(RomManager rommgr, FileAccess romAccess) : base(rommgr.RomFile, FileMode.Open, romAccess)
+        {
+            SetRomManager(rommgr);
+        }
+
+        // Inherits BinaryData
+
+        // Public ReadOnly Property RomAccess As FileAccess = FileAccess.Read
+
+        // Public Sub New(rommgr As RomManager, romAccess As FileAccess)
+        // SetRomManager(rommgr)
+        // Me.RomAccess = romAccess
+        // End Sub
+
+        // Protected Overrides Function GetBaseStream() As Stream
+        // Return RomManager.GetStream(RomAccess)
+        // End Function
+
+    }
+}

SM64Lib/Data/BinarySegBank.cs

@@ -0,0 +1,33 @@
+using global::System.IO;
+using global::SM64Lib.SegmentedBanking;
+
+namespace SM64Lib.Data
+{
+    public class BinarySegBank : BinaryData
+    {
+        public SegmentedBank SegBank { get; private set; }
+
+        public BinarySegBank(SegmentedBank segBank, RomManager rommgr)
+        {
+            SegBank = segBank;
+            SetRomManager(rommgr);
+        }
+
+        public BinarySegBank(SegmentedBank segBank)
+        {
+            SegBank = segBank;
+        }
+
+        protected override Stream GetBaseStream()
+        {
+            if (RomManager is not null)
+            {
+                var s = RomManager.GetBinaryRom(FileAccess.Read);
+                SegBank.ReadDataIfNull(s.BaseStream);
+                s.Close();
+            }
+
+            return SegBank.Data;
+        }
+    }
+}

SM64Lib/Data/BinaryStreamData.cs

@@ -0,0 +1,20 @@
+using global::System.IO;
+
+namespace SM64Lib.Data
+{
+    public class BinaryStreamData : BinaryData
+    {
+        protected readonly Stream myBaseStream;
+
+        public BinaryStreamData(Stream stream)
+        {
+            myBaseStream = stream;
+            //RaiseAnyBinaryDataOpened(this);
+        }
+
+        protected override Stream GetBaseStream()
+        {
+            return myBaseStream;
+        }
+    }
+}

SM64Lib/Data/System/Bits.cs

@@ -0,0 +1,98 @@
+using System;
+using System.Collections;
+using System.Linq;
+using Microsoft.VisualBasic.CompilerServices;
+
+namespace SM64Lib.Data.System
+{
+    public class Bits
+    {
+        public static byte[] ByteToBitArray(byte b)
+        {
+            var bitarray = new BitArray(new[] { b });
+            var temp = new byte[bitarray.Length];
+            for (int i = 0, loopTo = bitarray.Length - 1; i <= loopTo; i++)
+                temp[i] = Convert.ToByte(bitarray[i]);
+            int tindex = 0;
+            var temp2 = new byte[(temp.Count())];
+            for (int i = temp.Length - 1; i >= 0; i += -1)
+            {
+                temp2[tindex] = temp[i];
+                tindex += 1;
+            }
+
+            return temp2;
+        }
+
+        public static bool[] ByteToBoolArray(byte b)
+        {
+            var bitarray = new BitArray(new[] { b });
+            var temp = new bool[bitarray.Length];
+            for (int i = 0, loopTo = bitarray.Length - 1; i <= loopTo; i++)
+                temp[i] = Convert.ToBoolean(bitarray[i]);
+            int tindex = 0;
+            var temp2 = new bool[(temp.Count())];
+            for (int i = temp.Length - 1; i >= 0; i += -1)
+            {
+                temp2[tindex] = temp[i];
+                tindex += 1;
+            }
+
+            return temp2;
+        }
+
+        public static byte ArrayToByte(byte[] ba)
+        {
+            // ODER: BitArray.ToByte()
+
+            byte endval = 0;
+            int index = ba.Count() - 1;
+            foreach (var bit in ba)
+            {
+                endval += (byte)(bit * Math.Pow(2, index));
+                index -= 1;
+            }
+
+            return endval;
+        }
+
+        public static byte ArrayToByte(bool[] ba)
+        {
+            // ODER: BitArray.ToByte()
+
+            byte endval = 0;
+            int index = ba.Count() - 1;
+            foreach (var bit in ba)
+            {
+                endval += (byte)((bit ? 1 : 0) * Math.Pow(2, index));
+                index -= 1;
+            }
+
+            return endval;
+        }
+
+        public static byte SetInByte(byte b, int index, byte value)
+        {
+            var temp = ByteToBitArray(b);
+            temp[index] = value;
+            return ArrayToByte(temp);
+        }
+
+        public static byte SetInByte(byte b, int index, bool value)
+        {
+            var temp = ByteToBoolArray(b);
+            temp[index] = value;
+            return ArrayToByte(temp);
+        }
+
+        public static byte GetBitOfByte(byte b, int index)
+        {
+            return ByteToBitArray(b)[index];
+        }
+
+        public static bool GetBoolOfByte(byte b, int index)
+        {
+            return ByteToBoolArray(b)[index];
+        }
+    }
+}

SM64Lib/Data/System/SwapInts.cs

@@ -0,0 +1,62 @@
+using System;
+
+namespace SM64Lib.Data.System
+{
+    internal static class SwapInts
+    {
+        public static short SwapInt16(short value)
+        {
+            var bytes = BitConverter.GetBytes(value);
+            Array.Reverse(bytes);
+            return BitConverter.ToInt16(bytes, 0);
+        }
+
+        public static ushort SwapUInt16(ushort value)
+        {
+            var bytes = BitConverter.GetBytes(value);
+            Array.Reverse(bytes);
+            return BitConverter.ToUInt16(bytes, 0);
+        }
+
+        public static int SwapInt32(int value)
+        {
+            var bytes = BitConverter.GetBytes(value);
+            Array.Reverse(bytes);
+            return BitConverter.ToInt32(bytes, 0);
+        }
+
+        public static uint SwapUInt32(uint value)
+        {
+            var bytes = BitConverter.GetBytes(value);
+            Array.Reverse(bytes);
+            return BitConverter.ToUInt32(bytes, 0);
+        }
+
+        public static long SwapInt64(long value)
+        {
+            var bytes = BitConverter.GetBytes(value);
+            Array.Reverse(bytes);
+            return BitConverter.ToInt64(bytes, 0);
+        }
+
+        public static ulong SwapUInt64(ulong value)
+        {
+            var bytes = BitConverter.GetBytes(value);
+            Array.Reverse(bytes);
+            return BitConverter.ToUInt64(bytes, 0);
+        }
+
+        public static short SwapHalf(float value)
+        {
+            byte[] bytes = BitConverter.GetBytes(value);
+            return (short)(BitConverter.ToInt32(bytes, 0) >> 16);
+        }
+
+        public static float SwapFloat32(float value)
+        {
+            byte[] bytes = BitConverter.GetBytes(value);
+            Array.Reverse(bytes);
+            return BitConverter.ToSingle(bytes, 0);
+        }
+    }
+}

SM64Lib/Datatypecastes.cs

@@ -0,0 +1,39 @@
+using global::System.Runtime.InteropServices;
+
+namespace SM64Lib
+{
+    static class Datatypecastes
+    {
+        public static short LongToInt16(long value)
+        {
+            var cast = default(CasterLongInt16);
+            cast.LongValue = value;
+            return cast.Int16Value;
+        }
+
+        [StructLayout(LayoutKind.Explicit)]
+        private struct CasterLongInt16
+        {
+            [FieldOffset(0)]
+            public long LongValue;
+            [FieldOffset(0)]
+            public short Int16Value;
+        }
+
+        public static byte LongToByte(long value)
+        {
+            var cast = default(CasterLongByte);
+            cast.LongValue = value;
+            return cast.ByteValue;
+        }
+
+        [StructLayout(LayoutKind.Explicit)]
+        private struct CasterLongByte
+        {
+            [FieldOffset(0)]
+            public long LongValue;
+            [FieldOffset(0)]
+            public byte ByteValue;
+        }
+    }
+}

SM64Lib/EventArguments/GetTextProfileInfoEventArgs.cs

@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace SM64Lib.EventArguments
+{
+    public class GetTextProfileInfoEventArgs : EventArgs
+    {
+        public Text.Profiles.TextProfileInfo ProfileInfo { get; set; }
+    }
+}

SM64Lib/EventArguments/PrepairingRomEventArgs.cs

@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace SM64Lib.EventArguments
+{
+    public class PrepairingRomEventArgs : EventArgs
+    {
+        public IEnumerable<BaseTweakScriptInfo> ScriptInfos { get; set; }
+    }
+}

SM64Lib/EventArguments/RomVersionEventArgs.cs

@@ -0,0 +1,14 @@
+using System;
+
+namespace SM64Lib.EventArguments
+{
+    public class RomVersionEventArgs : EventArgs
+    {
+        public RomVersion RomVersion { get; set; }
+
+        internal RomVersionEventArgs(RomVersion romVersion)
+        {
+            RomVersion = romVersion;
+        }
+    }
+}

SM64Lib/Exceptions/InvalidMD5HashException.cs

@@ -0,0 +1,8 @@
+using System;
+
+namespace SM64Lib.Exceptions
+{
+    public class InvalidMD5HashException : Exception
+    {
+    }
+}

SM64Lib/Exceptions/RomCompatiblityException.cs

@@ -0,0 +1,11 @@
+using System;
+
+namespace SM64Lib.Exceptions
+{
+    public class RomCompatiblityException : Exception
+    {
+        public RomCompatiblityException(string msg) : base(msg)
+        {
+        }
+    }
+}

SM64Lib/ExtensionMethods.cs

@@ -0,0 +1,33 @@
+
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+
+namespace SM64Lib.Extensions
+{
+    public static class Int16Extensions
+    {
+        public static bool IsInRange(this short value, short min, short max)
+        {
+            return value >= min && value <= max;
+        }
+    }
+
+    public static class ObjectExtensions
+    {
+        public static void CloneTo<T>(this T source, T destination) where T : class
+        {
+            var json = JsonSerializer.CreateDefault();
+            var jobj = JObject.FromObject(source);
+            jobj.Populate(destination);
+        }
+    }
+
+    public static class JsonExtensions
+    {
+        public static void Populate(this JToken value, object target)
+        {
+            using (var sr = value.CreateReader())
+                JsonSerializer.CreateDefault().Populate(sr, target);
+        }
+    }
+}

SM64Lib/FilePathsConfiguration.cs

@@ -0,0 +1,49 @@
+using System.Collections.Generic;
+
+namespace SM64Lib
+{
+    public class FilePathsConfiguration
+    {
+
+        // S T A T I C   M E M B E R S
+
+        public static FilePathsConfiguration DefaultConfiguration { get; private set; } = new FilePathsConfiguration();
+
+        public static string[] AllFileKeys
+        {
+            get
+            {
+                return new[] { "rn64crc.exe","ApplyPPF3.exe", "Level Tabel.json", "Update-Patches.json", "Update Patches Folder", "Text Profiles.json", "BaseTweak", "sm64extend.exe", "Original Level Pointers.bin", "armips.exe", "Flips.exe", "nconvert.exe" };
+            }
+        }
+
+        // F I E L D S
+
+        private readonly Dictionary<string, string> dic = new Dictionary<string, string>();
+
+        // P R O P E R T I E S
+
+        public IReadOnlyDictionary<string, string> Files
+        {
+            get
+            {
+                return dic;
+            }
+        }
+
+        // C O N S T R U C T O R
+
+        public FilePathsConfiguration()
+        {
+            foreach (string key in AllFileKeys)
+                dic.Add(key, string.Empty);
+        }
+
+        // M E T H O D S
+
+        public void SetFilePath(string key, string path)
+        {
+            dic[key] = path;
+        }
+    }
+}

SM64Lib/General.cs

@@ -0,0 +1,606 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using global::System.Drawing;
+using System.Linq;
+using Microsoft.VisualBasic.CompilerServices;
+using global::SM64Lib.Patching;
+using System.IO;
+using System.IO.Compression;
+using System.Security.Cryptography;
+using System.Management;
+using System.Text;
+
+namespace SM64Lib
+{
+    public static class General
+    {
+        public static byte[] DisplayListCommandsWithPointerList { get; private set; } = new byte[] { 0x1, 0x3, 0x4, 0x6, 0xFD };
+        public static bool[] ActSelectorDefaultValues { get; private set; } = new bool[] { false, false, false, true, true, false, true, true, true, true, true, true, true, true, true, false, false, false, false, false, false, true, true, true, false, false, false, false, false, false, false, false, false, false, false };
+        public static PatchClass PatchClass { get; private set; } = new PatchClass();
+
+        public static bool IsDebugging
+        {
+            get
+            {
+                return Debugger.IsAttached;
+            }
+        }
+
+        public static short KeepInInt16Range(double value)
+        {
+            if (value > short.MaxValue)
+            {
+                value = short.MaxValue;
+            }
+            else if (value < short.MinValue)
+            {
+                value = short.MinValue;
+            }
+
+            return Convert.ToInt16(value);
+        }
+
+        internal static IReadOnlyDictionary<string, string> MyFilePaths
+        {
+            get
+            {
+                return FilePathsConfiguration.DefaultConfiguration.Files;
+            }
+        }
+
+        public static string ComputeMD5Hash(string filePath)
+        {
+            var md5 = MD5.Create();
+            string res;
+            FileStream fs;
+
+            try
+            {
+                fs = new FileStream(filePath, FileMode.Open, FileAccess.Read);
+                res = BitConverter.ToString(md5.ComputeHash(fs)).Replace("-", string.Empty).ToLowerInvariant();
+            }
+            catch (Exception)
+            {
+                fs = null;
+                res = string.Empty;
+            }
+
+            fs?.Close();
+            md5.Dispose();
+            return res;
+        }
+
+        public static void CopyBitmap(Bitmap src, Bitmap dest)
+        {
+            for (int y = 0, loopTo = src.Height - 1; y <= loopTo; y++)
+            {
+                for (int x = 0, loopTo1 = src.Width - 1; x <= loopTo1; x++)
+                    dest.SetPixel(x, y, src.GetPixel(x, y));
+            }
+        }
+
+        public static Bitmap CopyBitmap(Bitmap src)
+        {
+            return CopyBitmap(src, src.PixelFormat);
+        }
+
+        public static Bitmap CopyBitmap(Bitmap src, System.Drawing.Imaging.PixelFormat pixelFormat)
+        {
+            var dest = new Bitmap(src.Width, src.Height, pixelFormat);
+            CopyBitmap(src, dest);
+            return dest;
+        }
+
+        public static double Round(double d)
+        {
+            return Math.Round(d, MidpointRounding.AwayFromZero);
+        }
+
+        public static bool CompareTwoByteArrays(byte[] arr1, byte[] arr2, uint size = 0)
+        {
+            if (arr2.Length != arr1.Length) return false;
+
+            int loopTo = size != 0 ? (int)size : arr1.Length;
+
+            for (int i = 0; i < loopTo; i++)
+            {
+                if (arr1[i] != arr2[i])
+                    return false;
+            }
+
+            return true;
+        }
+
+        public static byte GetLevelIndexFromID(byte LevelID)
+        {
+            switch (LevelID)
+            {
+                case 0x4:
+                    {
+                        return 0;
+                    }
+
+                case 0x5:
+                    {
+                        return 1;
+                    }
+
+                case 0x6:
+                    {
+                        return 2;
+                    }
+
+                case 0x7:
+                    {
+                        return 3;
+                    }
+
+                case 0x8:
+                    {
+                        return 4;
+                    }
+
+                case 0x9:
+                    {
+                        return 5;
+                    }
+
+                case 0xA:
+                    {
+                        return 6;
+                    }
+
+                case 0xB:
+                    {
+                        return 7;
+                    }
+
+                case 0xC:
+                    {
+                        return 8;
+                    }
+
+                case 0xD:
+                    {
+                        return 9;
+                    }
+
+                case 0xE:
+                    {
+                        return 10;
+                    }
+
+                case 0xF:
+                    {
+                        return 11;
+                    }
+
+                case 0x10:
+                    {
+                        return 12;
+                    }
+
+                case 0x11:
+                    {
+                        return 13;
+                    }
+
+                case 0x12:
+                    {
+                        return 14;
+                    }
+
+                case 0x13:
+                    {
+                        return 15;
+                    }
+
+                case 0x14:
+                    {
+                        return 16;
+                    }
+
+                case 0x15:
+                    {
+                        return 17;
+                    }
+
+                case 0x16:
+                    {
+                        return 18;
+                    }
+
+                case 0x17:
+                    {
+                        return 19;
+                    }
+
+                case 0x18:
+                    {
+                        return 20;
+                    }
+
+                case 0x19:
+                    {
+                        return 21;
+                    }
+
+                case 0x1A:
+                    {
+                        return 22;
+                    }
+
+                case 0x1B:
+                    {
+                        return 23;
+                    }
+
+                case 0x1C:
+                    {
+                        return 24;
+                    }
+
+                case 0x1D:
+                    {
+                        return 25;
+                    }
+
+                case 0x1E:
+                    {
+                        return 26;
+                    }
+
+                case 0x1F:
+                    {
+                        return 27;
+                    }
+
+                case 0x21:
+                    {
+                        return 28;
+                    }
+
+                case 0x22:
+                    {
+                        return 29;
+                    }
+
+                case 0x24:
+                    {
+                        return 30;
+                    }
+
+                default:
+                    {
+                        return 5;
+                    }
+            }
+        }
+
+        public static byte GetLevelIDFromIndex(byte LevelID)
+        {
+            switch (LevelID)
+            {
+                case 0:
+                    {
+                        return 0x4;
+                    }
+
+                case 1:
+                    {
+                        return 0x5;
+                    }
+
+                case 2:
+                    {
+                        return 0x6;
+                    }
+
+                case 3:
+                    {
+                        return 0x7;
+                    }
+
+                case 4:
+                    {
+                        return 0x8;
+                    }
+
+                case 5:
+                    {
+                        return 0x9;
+                    }
+
+                case 6:
+                    {
+                        return 0xA;
+                    }
+
+                case 7:
+                    {
+                        return 0xB;
+                    }
+
+                case 8:
+                    {
+                        return 0xC;
+                    }
+
+                case 9:
+                    {
+                        return 0xD;
+                    }
+
+                case 10:
+                    {
+                        return 0xE;
+                    }
+
+                case 11:
+                    {
+                        return 0xF;
+                    }
+
+                case 12:
+                    {
+                        return 0x10;
+                    }
+
+                case 13:
+                    {
+                        return 0x11;
+                    }
+
+                case 14:
+                    {
+                        return 0x12;
+                    }
+
+                case 15:
+                    {
+                        return 0x13;
+                    }
+
+                case 16:
+                    {
+                        return 0x14;
+                    }
+
+                case 17:
+                    {
+                        return 0x15;
+                    }
+
+                case 18:
+                    {
+                        return 0x16;
+                    }
+
+                case 19:
+                    {
+                        return 0x17;
+                    }
+
+                case 20:
+                    {
+                        return 0x18;
+                    }
+
+                case 21:
+                    {
+                        return 0x19;
+                    }
+
+                case 22:
+                    {
+                        return 0x1A;
+                    }
+
+                case 23:
+                    {
+                        return 0x1B;
+                    }
+
+                case 24:
+                    {
+                        return 0x1C;
+                    }
+
+                case 25:
+                    {
+                        return 0x1D;
+                    }
+
+                case 26:
+                    {
+                        return 0x1E;
+                    }
+
+                case 27:
+                    {
+                        return 0x1F;
+                    }
+
+                case 28:
+                    {
+                        return 0x21;
+                    }
+
+                case 29:
+                    {
+                        return 0x22;
+                    }
+
+                case 30:
+                    {
+                        return 0x24;
+                    }
+
+                default:
+                    {
+                        return 5;
+                    }
+            }
+        }
+
+        public static int HexRoundUp1(int value)
+        {
+            while (value % 0x10 != 0)
+                value += 1;
+            return value;
+        }
+
+        public static long HexRoundUp1(long value)
+        {
+            while (value % 0x10 != 0)
+                value += 1;
+            return value;
+        }
+
+        public static void HexRoundUp2(ref long value)
+        {
+            while (value % 0x10 != 0)
+                value += 1;
+        }
+
+        public static void HexRoundUp2(ref uint value)
+        {
+            while (value % 0x10 != 0)
+                value += 1;
+        }
+
+        public static void HexRoundUp2(ref int value)
+        {
+            while (value % 0x10 != 0)
+                value += 1;
+        }
+
+        public static string FillStrToCharCount(string str, int charCount, string fillVal = "0")
+        {
+            if (fillVal.Count() == 0)
+                return str;
+            if (charCount == 0)
+                return str;
+            while (str.Count() < charCount)
+                str = fillVal + str;
+            return str;
+        }
+
+        public static Geolayout.BackgroundPointers GetBackgroundAddressOfID(Geolayout.BackgroundIDs ID, bool EndAddr)
+        {
+            switch (ID)
+            {
+                case Geolayout.BackgroundIDs.AboveClouds:
+                    {
+                        if (EndAddr)
+                            return Geolayout.BackgroundPointers.AboveCloudsEnd;
+                        return Geolayout.BackgroundPointers.AboveCloudsStart;
+                    }
+
+                case Geolayout.BackgroundIDs.BelowClouds:
+                    {
+                        if (EndAddr)
+                            return Geolayout.BackgroundPointers.BelowCloudsEnd;
+                        return Geolayout.BackgroundPointers.BelowCloudsStart;
+                    }
+
+                case Geolayout.BackgroundIDs.Cavern:
+                    {
+                        if (EndAddr)
+                            return Geolayout.BackgroundPointers.CavernEnd;
+                        return Geolayout.BackgroundPointers.CavernStart;
+                    }
+
+                case Geolayout.BackgroundIDs.Desert:
+                    {
+                        if (EndAddr)
+                            return Geolayout.BackgroundPointers.DesertEnd;
+                        return Geolayout.BackgroundPointers.DesertStart;
+                    }
+
+                case Geolayout.BackgroundIDs.FlamingSky:
+                    {
+                        if (EndAddr)
+                            return Geolayout.BackgroundPointers.FlamingSkyEnd;
+                        return Geolayout.BackgroundPointers.FlamingSkyStart;
+                    }
+
+                case Geolayout.BackgroundIDs.HauntedForest:
+                    {
+                        if (EndAddr)
+                            return Geolayout.BackgroundPointers.HauntedForestEnd;
+                        return Geolayout.BackgroundPointers.HauntedForestStart;
+                    }
+
+                case Geolayout.BackgroundIDs.Ocean:
+                    {
+                        if (EndAddr)
+                            return Geolayout.BackgroundPointers.OceanEnd;
+                        return Geolayout.BackgroundPointers.OceanStart;
+                    }
+
+                case Geolayout.BackgroundIDs.PurpleClouds:
+                    {
+                        if (EndAddr)
+                            return Geolayout.BackgroundPointers.PurpleCloudsEnd;
+                        return Geolayout.BackgroundPointers.PurpleCloudsStart;
+                    }
+
+                case Geolayout.BackgroundIDs.SnowyMountains:
+                    {
+                        if (EndAddr)
+                            return Geolayout.BackgroundPointers.SnowyMountainsEnd;
+                        return Geolayout.BackgroundPointers.SnowyMountainsStart;
+                    }
+
+                case Geolayout.BackgroundIDs.UnderwaterCity:
+                    {
+                        if (EndAddr)
+                            return Geolayout.BackgroundPointers.UnderwaterCityEnd;
+                        return Geolayout.BackgroundPointers.UnderwaterCityStart;
+                    }
+            }
+
+            return EndAddr ? Geolayout.BackgroundPointers.OceanEnd : Geolayout.BackgroundPointers.OceanStart;
+        }
+
+        public static string CommandByteArrayToString(byte[] bytes)
+        {
+            string res = string.Empty;
+            foreach (byte b in bytes)
+            {
+                if (!string.IsNullOrEmpty(res))
+                {
+                    res += " ";
+                }
+
+                res += b.ToString("X2");
+            }
+
+            return res;
+        }
+
+        internal static byte[] CompressData(Stream input, CompressionLevel compressionLevel)
+        {
+            var output = new MemoryStream();
+            input.Position = 0;
+
+            using (var compressor = new DeflateStream(output, compressionLevel, true))
+                input.CopyTo(compressor);
+
+            var res = output.ToArray();
+            output.Close();
+            return res;
+        }
+
+        internal static void DecompressData(byte[] input, Stream output)
+        {
+            using (var sInput = new MemoryStream(input))
+            {
+                using (var decompressor = new DeflateStream(sInput, CompressionMode.Decompress, true))
+                    decompressor.CopyTo(output);
+            }
+        }
+    }
+}

SM64Lib/Geolayout/BackgroundIDs.cs

@@ -0,0 +1,18 @@
+
+namespace SM64Lib.Geolayout
+{
+    public enum BackgroundIDs : byte
+    {
+        HauntedForest = 0x6,
+        SnowyMountains = 0x4,
+        Desert = 0x5,
+        Ocean = 0x0,
+        UnderwaterCity = 0x2,
+        BelowClouds = 0x8,
+        AboveClouds = 0x3,
+        Cavern = 0x7,
+        FlamingSky = 0x1,
+        PurpleClouds = 0x9,
+        Custom = 0xA
+    }
+}

SM64Lib/Geolayout/BackgroundPointers.cs

@@ -0,0 +1,27 @@
+
+namespace SM64Lib.Geolayout
+{
+    public enum BackgroundPointers
+    {
+        HauntedForestStart = 0xC3B030, // &HC3AFD5
+        HauntedForestEnd = 0xC4F970, // &HC4F915
+        SnowyMountainsStart = 0xB5D8B0, // &HB5D855
+        SnowyMountainsEnd = 0xB7D9F0, // &HB7D995
+        DesertStart = 0xC12EF0, // &HC12E95
+        DesertEnd = 0xC33030, // &HC32FD5
+        OceanStart = 0xB35770, // &HB35715
+        OceanEnd = 0xB558B0, // &HB55855
+        UnderwaterCityStart = 0xBC2C70, // &HBC2C15
+        UnderwaterCityEnd = 0xBE2DB0, // &HBE2D55
+        BelowCloudsStart = 0xB859F0, // &HB85995
+        BelowCloudsEnd = 0xB9A330, // &HB9A2D5
+        AboveCloudsStart = 0xBEADB0, // &HBEAD55
+        AboveCloudsEnd = 0xC0AEF0, // &HC0AE95
+        CavernStart = 0xC57970, // &HC57915
+        CavernEnd = 0xC77AB0, // &HC77A55
+        FlamingSkyStart = 0xBA2330, // &HBA22D5
+        FlamingSkyEnd = 0xBBAC70, // &HBBAC15
+        PurpleCloudsStart = 0xC7FAB0, // &HC7FA55
+        PurpleCloudsEnd = 0xC9FBF0 // &HC9FB95
+    }
+}

SM64Lib/Geolayout/CameraFrustrum.cs

@@ -0,0 +1,20 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace SM64Lib.Geolayout
+{
+    public class CameraFrustrum
+    {
+        /// <summary>
+        /// This is essentially render distance of geometry.
+        /// </summary>
+        public short CameraFar { get; set; } = 0x7530;
+        /// <summary>
+        /// Defines how close to the camera geometry will render.
+        /// </summary>
+        public short CameraNear { get; set; } = 0x64;
+    }
+}

SM64Lib/Geolayout/CameraPresets.cs

@@ -0,0 +1,23 @@
+
+namespace SM64Lib.Geolayout
+{
+    public enum CameraPresets
+    {
+        OpenCamera = 0x1,
+        TickTockClock,
+        SecretAquarium,
+        InsideCastle,
+        Unmoving,
+        MarioFacingObject,
+        Unmoving1,
+        UnderwaterCamera,
+        PeachSlideCamera,
+        InsideCannon,
+        BowserFightsDistant,
+        CloseCameraCrashes,
+        FixedReferencePoint,
+        PlattfromLevels,
+        Unmoving2,
+        FreeRoamCamera
+    }
+}

SM64Lib/Geolayout/DefaultGeolayers.cs

@@ -0,0 +1,15 @@
+
+namespace SM64Lib.Geolayout
+{
+    public enum DefaultGeolayers
+    {
+        SolidNoAntiAlias,
+        Solid,
+        SolidDecal,
+        TranslucentDecal,
+        Alpha,
+        Translucent,
+        TranslucentDecal2,
+        TranslucentDecal3
+    }
+}

SM64Lib/Geolayout/EnvironmentEffects.cs

@@ -0,0 +1,14 @@
+
+namespace SM64Lib.Geolayout
+{
+    public enum EnvironmentEffects
+    {
+        NoEffect = 0x0,
+        Snow = 0x1,
+        Bllizard = 0x3,
+        BetaFlower = 0xB,
+        Lava = 0xC,
+        WaterRelated1 = 0xD,
+        WaterRelated2 = 0x2
+    }
+}

SM64Lib/Geolayout/GeoAsmPointer.cs

@@ -0,0 +1,10 @@
+
+namespace SM64Lib.Geolayout
+{
+    public enum GeoAsmPointer : uint
+    {
+        EnvironmentEffect = 0x802761D0,
+        Water = 0x802D104C,
+        Unknown = 0x802CD1E8
+    }
+}

SM64Lib/Geolayout/Geolayout.cs

@@ -0,0 +1,380 @@
+using System.Collections.Generic;
+using global::System.IO;
+using Microsoft.VisualBasic;
+using Microsoft.VisualBasic.CompilerServices;
+using global::SM64Lib.Geolayout.Script;
+using global::SM64Lib.Geolayout.Script.Commands;
+using Newtonsoft.Json;
+using System;
+
+namespace SM64Lib.Geolayout
+{
+    public class Geolayout
+    {
+        [JsonProperty]
+        private int IndexForGeopointers = -1;
+
+        public Geolayoutscript Geolayoutscript { get; set; } = new Geolayoutscript();
+        public CameraPresets CameraPreset { get; set; } = CameraPresets.OpenCamera;
+        public EnvironmentEffects EnvironmentEffect { get; set; } = default;
+        public List<int> GeopointerOffsets { get; set; } = new List<int>();
+        public List<Geopointer> Geopointers { get; set; } = new List<Geopointer>();
+        public int NewGeoOffset { get; set; } = 0;
+        public bool Closed { get; set; } = false;
+        public ObjectShadow ObjectShadow { get; set; } = new ObjectShadow();
+        public CameraFrustrum CameraFrustrum { get; set; } = new CameraFrustrum();
+
+        public int Length
+        {
+            get
+            {
+                int tLength = Geopointers.Count * 8;
+                foreach (var c in Geolayoutscript)
+                    tLength += (int)c.Length;
+                return tLength;
+            }
+        }
+
+        private void RemoveOldGeopointerCommands()
+        {
+            var ToRemove = new List<GeolayoutCommand>();
+            foreach (GeolayoutCommand c in Geolayoutscript)
+            {
+                if (c.CommandType == GeolayoutCommandTypes.LoadDisplaylist)
+                {
+                    ToRemove.Add(c);
+                }
+            }
+
+            foreach (GeolayoutCommand cmd in ToRemove)
+            {
+                Geolayoutscript.Remove(cmd);
+                cmd.Close();
+            }
+        }
+
+        private List<Geopointer> GetGeopointersFromGeolayoutScript(Geolayoutscript script)
+        {
+            List<Geopointer> geopointers = new List<Geopointer>();
+            int geolayoutCommandIndex = 0;
+            var curMdlScale = System.Numerics.Vector3.One;
+            var curMdlOffset = System.Numerics.Vector3.Zero;
+            foreach (GeolayoutCommand geolayoutCommand in script)
+            {
+                var referenceCommand = geolayoutCommand;
+                if (geolayoutCommand.CommandType == GeolayoutCommandTypes.LoadDisplaylist)
+                {
+                    geopointers.Add(new Geopointer(
+                        cgLoadDisplayList.GetDrawingLayer(ref referenceCommand),
+                        cgLoadDisplayList.GetSegGeopointer(ref referenceCommand),
+                        curMdlScale,
+                        curMdlOffset,
+                        geolayoutCommandIndex
+                    ));
+                }
+                geolayoutCommandIndex += 1;
+            }
+            return geopointers;
+        }
+
+        public Geolayout(NewScriptCreationMode mode)
+        {
+            switch (mode)
+            {
+                case NewScriptCreationMode.Level:
+                    {
+                        {
+                            var withBlock = Geolayoutscript;
+                            withBlock.Add(new GeolayoutCommand(new byte[] { 0x8, 0x0, 0x0, 0xA, 0x0, 0xA0, 0x0, 0x78, 0x0, 0xA0, 0x0, 0x78 }));
+                            withBlock.Add(new GeolayoutCommand(new byte[] { 0x4, 0x0, 0x0, 0x0 }));
+                            withBlock.Add(new GeolayoutCommand(new byte[] { 0xC, 0x0, 0x0, 0x0 }));
+                            withBlock.Add(new GeolayoutCommand(new byte[] { 0x4, 0x0, 0x0, 0x0 }));
+                            withBlock.Add(new GeolayoutCommand(new byte[] { 0x9, 0x0, 0x0, 0x64 }));
+                            withBlock.Add(new GeolayoutCommand(new byte[] { 0x4, 0x0, 0x0, 0x0 }));
+                            withBlock.Add(new GeolayoutCommand(new byte[] { 0x19, 0x0, 0x0, 0x0, 0x80, 0x27, 0x63, 0xD4 }));
+                            withBlock.Add(new GeolayoutCommand(new byte[] { 0x5, 0x0, 0x0, 0x0 }));
+                            withBlock.Add(new GeolayoutCommand(new byte[] { 0x5, 0x0, 0x0, 0x0 }));
+                            withBlock.Add(new GeolayoutCommand(new byte[] { 0xC, 0x1, 0x0, 0x0 }));
+                            withBlock.Add(new GeolayoutCommand(new byte[] { 0x4, 0x0, 0x0, 0x0 }));
+                            withBlock.Add(new GeolayoutCommand(new byte[] { 0xA, 0x1, 0x0, 0x2D, 0x0, 0x64, 0x75, 0x30, 0x80, 0x29, 0xAA, 0x3C }));
+                            withBlock.Add(new GeolayoutCommand(new byte[] { 0x4, 0x0, 0x0, 0x0 }));
+                            withBlock.Add(new GeolayoutCommand("0F 00 00 01 00 00 00 00 00 00 00 00 00 00 00 00 80 28 7D 30"));
+                            withBlock.Add(new GeolayoutCommand(new byte[] { 0x4, 0x0, 0x0, 0x0 }));
+                            IndexForGeopointers = 15;
+                            // .Add(New GeolayoutCommand({&H15, &H1, &H0, &H0, &H0, &H0, &H0, &H0}))
+                            withBlock.Add(new GeolayoutCommand(new byte[] { 0x17, 0x0, 0x0, 0x0 }));
+                            withBlock.Add(new GeolayoutCommand(new byte[] { 0x18, 0x0, 0x0, 0x0, 0x80, 0x27, 0x61, 0xD0 }));
+                            withBlock.Add(new GeolayoutCommand(new byte[] { 0x18, 0x0, 0x50, 0x0, 0x80, 0x2D, 0x10, 0x4C })); // Water
+                            withBlock.Add(new GeolayoutCommand(new byte[] { 0x18, 0x0, 0x50, 0x1, 0x80, 0x2D, 0x10, 0x4C })); // Toxic Haze
+                            withBlock.Add(new GeolayoutCommand(new byte[] { 0x18, 0x0, 0x50, 0x2, 0x80, 0x2D, 0x10, 0x4C })); // Mist
+                            withBlock.Add(new GeolayoutCommand(new byte[] { 0x5, 0x0, 0x0, 0x0 }));
+                            withBlock.Add(new GeolayoutCommand(new byte[] { 0x5, 0x0, 0x0, 0x0 }));
+                            withBlock.Add(new GeolayoutCommand(new byte[] { 0x5, 0x0, 0x0, 0x0 }));
+                            withBlock.Add(new GeolayoutCommand(new byte[] { 0xC, 0x0, 0x0, 0x0 }));
+                            withBlock.Add(new GeolayoutCommand(new byte[] { 0x4, 0x0, 0x0, 0x0 }));
+                            withBlock.Add(new GeolayoutCommand(new byte[] { 0x18, 0x0, 0x0, 0x0, 0x80, 0x2C, 0xD1, 0xE8 }));
+                            withBlock.Add(new GeolayoutCommand(new byte[] { 0x5, 0x0, 0x0, 0x0 }));
+                            withBlock.Add(new GeolayoutCommand(new byte[] { 0x5, 0x0, 0x0, 0x0 }));
+                            withBlock.Add(new GeolayoutCommand(new byte[] { 0x1, 0x0, 0x0, 0x0 }));
+                        }
+
+                        break;
+                    }
+
+                case NewScriptCreationMode.Object:
+                    {
+                        {
+                            var withBlock1 = Geolayoutscript;
+                            withBlock1.Add(new GeolayoutCommand("20 00 0F A0"));
+                            withBlock1.Add(new GeolayoutCommand("04 00 00 00"));
+                            IndexForGeopointers = 2;
+                            withBlock1.Add(new GeolayoutCommand("05 00 00 00"));
+                            withBlock1.Add(new GeolayoutCommand("01 00 00 00"));
+                        }
+
+                        break;
+                    }
+            }
+        }
+
+        public void Read(byte[] data, byte bankID)
+        {
+            RenewGeolayout();
+            Geolayoutscript.Read(data, bankID);
+            ParseGeolayout();
+        }
+
+        public void Read(RomManager rommgr, int segAddress)
+        {
+            RenewGeolayout();
+            Geolayoutscript.Read(rommgr, segAddress);
+            ParseGeolayout();
+        }
+
+        private void RenewGeolayout()
+        {
+            if (!Closed) Close();
+            Closed = false;
+            Geolayoutscript.Clear();
+            Geopointers.Clear();
+            GeopointerOffsets.Clear();
+            Geolayoutscript = new Geolayoutscript();
+            ObjectShadow = new ObjectShadow();
+            CameraFrustrum = new CameraFrustrum();
+        }
+
+        public void ParseGeolayout()
+        {
+            var ToRemove = new List<GeolayoutCommand>();
+            int cIndex = 0;
+            var curMdlScale = System.Numerics.Vector3.One;
+            var curMdlOffset = System.Numerics.Vector3.Zero;
+
+            foreach (GeolayoutCommand fec in Geolayoutscript)
+            {
+                var c = fec;
+                var switchExpr = c.CommandType;
+
+                switch (switchExpr)
+                {
+                    case GeolayoutCommandTypes.CameraPreset:
+                        CameraPreset = (CameraPresets)cgCameraPreset.GetCameraPreset(ref c);
+                        break;
+                    case GeolayoutCommandTypes.x18:
+                        var switchExpr1 = (uint)cgx18.GetAsmPointer(ref c);
+                        switch (switchExpr1)
+                        {
+                            case 0x802761D0:
+                                EnvironmentEffect = (EnvironmentEffects)cgx18.GetParam1(ref c);
+                                break;
+                        }
+                        break;
+                    case GeolayoutCommandTypes.LoadDisplaylist:
+                        if (Geopointers.Count == 0)
+                            IndexForGeopointers = cIndex;
+                        Geopointers.Add(new Geopointer(cgLoadDisplayList.GetDrawingLayer(ref c), cgLoadDisplayList.GetSegGeopointer(ref c), curMdlScale, curMdlOffset, cIndex));
+                        break;
+                    case GeolayoutCommandTypes.ObjectShadown:
+                        cgObjectShadow.GetShadow(c, ObjectShadow);
+                        ObjectShadow.Enabled = true;
+                        break;
+                    case GeolayoutCommandTypes.DrawingDistance:
+                        ObjectShadow.Enabled = false;
+                        break;
+                    case GeolayoutCommandTypes.CameraFrustrum:
+                        cgCameraFrustrum.GetCameraFrustrum(c, CameraFrustrum);
+                        break;
+                }
+
+                cIndex += 1;
+            }
+
+            // Remove Geopointercommands
+            RemoveOldGeopointerCommands();
+        }
+
+        public void Write(Stream s, int StartOffset)
+        {
+            NewGeoOffset = StartOffset;
+            var commandsToRemove = new List<GeolayoutCommand>();
+            GeolayoutCommand cmdObjectShadow = null;
+            GeolayoutCommand cmdDrawingDistance = null;
+            int tIndexForGeoPointer = IndexForGeopointers;
+            var isForLevel = false;
+
+            // Einstellungen übernehmen
+            int currentPosition = 0;
+            foreach (GeolayoutCommand fec in Geolayoutscript)
+            {
+                var c = fec;
+                var switchExpr = c.CommandType;
+
+                switch (switchExpr)
+                {
+                    case GeolayoutCommandTypes.CameraPreset:
+                        cgCameraPreset.SetCameraPreset(ref c, Convert.ToByte(CameraPreset));
+                        break;
+                    case GeolayoutCommandTypes.x18:
+                        var switchExpr1 = cgx18.GetAsmPointer(ref c);
+                        switch ((GeoAsmPointer)switchExpr1)
+                        {
+                            case GeoAsmPointer.EnvironmentEffect:
+                                cgx18.SetParam1(ref c, (ushort)EnvironmentEffect);
+                                break;
+                        }
+                        break;
+                    case GeolayoutCommandTypes.ObjectShadown:
+                        if (ObjectShadow.Enabled)
+                            cmdObjectShadow = c;
+                        else
+                            commandsToRemove.Add(c);
+                        break;
+                    case GeolayoutCommandTypes.DrawingDistance:
+                        if (ObjectShadow.Enabled)
+                            commandsToRemove.Add(c);
+                        else
+                            cmdDrawingDistance = c;
+                        break;
+                    case GeolayoutCommandTypes.CameraFrustrum:
+                        cgCameraFrustrum.SetCameraFrustrum(c, CameraFrustrum);
+                        isForLevel = true;
+                        break;
+                    case GeolayoutCommandTypes.SetScreenRenderArea:
+                        isForLevel = true;
+                        break;
+                }
+
+                currentPosition += (int)c.Length;
+            }
+
+            // Insert Geopointers
+            foreach (Geopointer g in Geopointers)
+            {
+                var tcommand = new GeolayoutCommand(new byte[] { 0x15, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 });
+                cgLoadDisplayList.SetDrawingLayer(ref tcommand, g.Layer);
+                cgLoadDisplayList.SetSegGeopointer(ref tcommand, g.SegPointer);
+                if (g.Index == -1)
+                {
+                    Geolayoutscript.Insert(tIndexForGeoPointer, tcommand);
+                }
+                else
+                {
+                    Geolayoutscript.Insert(g.Index, tcommand);
+                }
+                
+                tIndexForGeoPointer += 1;
+            }
+
+            // Remove all other commands to remove
+            foreach (var cmd in commandsToRemove)
+            {
+                Geolayoutscript.Remove(cmd);
+                cmd.Close();
+            }
+
+            // Add Geolayout Start command for non-level geolayouts
+            if (!isForLevel)
+            {
+                if (ObjectShadow.Enabled)
+                {
+                    // Add Object Shadow
+                    if (cmdObjectShadow is null)
+                    {
+                        cmdObjectShadow = new GeolayoutCommand("16 00 00 00 00 00 00 00");
+                        Geolayoutscript.Insert(0, cmdObjectShadow);
+                    }
+                    cgObjectShadow.SetShadow(cmdObjectShadow, ObjectShadow);
+                }
+                else
+                {
+                    if (cmdDrawingDistance == null)
+                        Geolayoutscript.Insert(0, new GeolayoutCommand("20 00 0F A0"));
+                }
+            }
+
+            // Update Geopointer indexes after adding and removing other commands
+            Geopointers = GetGeopointersFromGeolayoutScript(Geolayoutscript);
+
+            // Write Geolayout to ROM
+            Geolayoutscript.Write(s, StartOffset);
+
+            // Remove Geopointercommands again
+            RemoveOldGeopointerCommands();
+        }
+
+        public void Close()
+        {
+            foreach (var c in Geolayoutscript)
+                c.Close();
+        }
+
+        public override string ToString()
+        {
+            string output = "";
+            foreach (var cmd in Geolayoutscript)
+            {
+                string tbytelist = "";
+                foreach (byte b in cmd.ToArray())
+                {
+                    if (tbytelist != string.Empty)
+                        tbytelist += " ";
+                    tbytelist += Conversion.Hex(b);
+                }
+
+                if (output != string.Empty)
+                    output += Environment.NewLine;
+                output += tbytelist;
+            }
+
+            return output;
+        }
+
+        public string ToString(GeolayoutCommandCollection Geolayoutscript)
+        {
+            string output = "";
+            foreach (var cmd in Geolayoutscript)
+            {
+                string tbytelist = "";
+                foreach (byte b in cmd.ToArray())
+                {
+                    if (tbytelist != string.Empty)
+                        tbytelist += " ";
+                    tbytelist += Conversion.Hex(b);
+                }
+
+                if (output != string.Empty)
+                    output += Environment.NewLine;
+                output += tbytelist;
+            }
+
+            return output;
+        }
+
+        public enum NewScriptCreationMode
+        {
+            None,
+            Level,
+            Object
+        }
+    }
+}

SM64Lib/Geolayout/Geopointer.cs

@@ -0,0 +1,42 @@
+
+using Newtonsoft.Json;
+
+namespace SM64Lib.Geolayout
+{
+    public class Geopointer
+    {
+        public byte Layer { get; set; } = default;
+        public int SegPointer { get; set; } = 0;
+        public int Index { get; set; } = -1;
+        public System.Numerics.Vector3 ModelScale { get; set; } = System.Numerics.Vector3.One;
+        public System.Numerics.Vector3 ModelOffset { get; set; } = System.Numerics.Vector3.Zero;
+
+        [JsonConstructor]
+        private Geopointer()
+        {
+        }
+
+        public Geopointer(byte Layer) : this()
+        {
+            this.Layer = Layer;
+        }
+
+        public Geopointer(byte Layer, int SegPointer) : this(Layer)
+        {
+            this.SegPointer = SegPointer;
+        }
+
+        public Geopointer(byte Layer, int SegPointer, System.Numerics.Vector3 mdlscale, System.Numerics.Vector3 mdloffset) : this(Layer, SegPointer)
+        {
+            ModelScale = mdlscale;
+            ModelOffset = mdloffset;
+        }
+
+        public Geopointer(byte Layer, int SegPointer, System.Numerics.Vector3 mdlscale, System.Numerics.Vector3 mdloffset, int index) : this(Layer, SegPointer)
+        {
+            ModelScale = mdlscale;
+            ModelOffset = mdloffset;
+            Index = index;
+        }
+    }
+}

SM64Lib/Geolayout/ObjectShadow.cs

@@ -0,0 +1,16 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace SM64Lib.Geolayout
+{
+    public class ObjectShadow
+    {
+        public bool Enabled { get; set; } = false;
+        public ObjectShadowType Type { get; set; } = ObjectShadowType.Circle_9Verts;
+        public short Scale { get; set; }
+        public byte Solidity { get; set; } = 0xFF;
+    }
+}

SM64Lib/Geolayout/ObjectShadowType.cs

@@ -0,0 +1,24 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace SM64Lib.Geolayout
+{
+    public enum ObjectShadowType
+    {
+        Circle_9Verts = 0,
+        Circle_4Verts = 1,
+        Circle_4Verts_Flat_Unused = 2,
+        SquarePermanent = 10,
+        SquareScaleable = 11,
+        SquareTooglable = 12,
+        /**
+         * This defines an offset after which rectangular shadows with custom
+         * widths and heights can be defined.
+         */
+        RectangleHardcodedOffset = 50,
+        CirclePlayer = 99
+    }
+}

SM64Lib/Geolayout/Script/GeolayoutCommand.cs

@@ -0,0 +1,40 @@
+using global::SM64Lib.Script;
+using Newtonsoft.Json;
+using SM64Lib.Json;
+
+namespace SM64Lib.Geolayout.Script
+{
+    [JsonConverter(typeof(GeolayoutscriptCommandJsonConverter))]
+    public class GeolayoutCommand : BaseCommand<GeolayoutCommandTypes>
+    {
+        public GeolayoutCommand(byte[] bytes) : base(bytes)
+        {
+        }
+
+        public GeolayoutCommand() : base()
+        {
+        }
+
+        public GeolayoutCommand(string bytes, bool enabledHex = true) : base(bytes, enabledHex)
+        {
+        }
+
+        public override GeolayoutCommandTypes CommandType
+        {
+            get
+            {
+                Position = 0;
+                GeolayoutCommandTypes t = (GeolayoutCommandTypes)ReadByte();
+                Position = 0;
+                return t;
+            }
+
+            set
+            {
+                Position = 0;
+                WriteByte((byte)value);
+                Position = 0;
+            }
+        }
+    }
+}

SM64Lib/Geolayout/Script/GeolayoutCommandCollection.cs

@@ -0,0 +1,18 @@
+using global::SM64Lib.Script;
+
+namespace SM64Lib.Geolayout.Script
+{
+    public class GeolayoutCommandCollection : BaseCommandCollection<GeolayoutCommand, GeolayoutCommandTypes>
+    {
+        public int IndexOfFirst(GeolayoutCommandTypes cmdType)
+        {
+            for (int index = 0, loopTo = Count - 1; index <= loopTo; index++)
+            {
+                if (this[index].CommandType == cmdType)
+                    return index;
+            }
+
+            return -1;
+        }
+    }
+}

SM64Lib/Geolayout/Script/GeolayoutCommandFunctions.cs

@@ -0,0 +1,277 @@
+using global::System.Numerics;
+using Microsoft.VisualBasic.CompilerServices;
+using System;
+
+namespace SM64Lib.Geolayout.Script
+{
+    namespace Commands
+    {
+        public class cgBackground
+        {
+            public static short GetBackgroundID(GeolayoutCommand command)
+            {
+                command.Position = 0x2;
+                short value = command.ReadInt16();
+                command.Position = 0;
+                return value;
+            }
+
+            public static void SetBackgroundID(GeolayoutCommand command, short ID)
+            {
+                command.Position = 0x2;
+                command.Write(ID);
+                command.Position = 0;
+            }
+
+            public static int GetBackgroundPointer(GeolayoutCommand command)
+            {
+                command.Position = 0x4;
+                int value = command.ReadInt32();
+                command.Position = 0;
+                return value;
+            }
+
+            public static void SetBackgroundPointer(GeolayoutCommand command, int Pointer)
+            {
+                command.Position = 0x4;
+                command.Write(Pointer);
+                command.Position = 0;
+            }
+
+            public static System.Drawing.Color GetRrgbaColor(GeolayoutCommand command)
+            {
+                command.Position = 0x2;
+                byte b1 = command.ReadByte();
+                byte b2 = command.ReadByte();
+                command.Position = 0;
+                return N64Graphics.N64Graphics.RGBA16Color(b1, b2);
+            }
+
+            public static void SetRgbaColor(GeolayoutCommand command, System.Drawing.Color color)
+            {
+                byte b1, b2;
+                N64Graphics.N64Graphics.ColorRGBA16(color, out b1, out b2);
+                command.Position = 0x2;
+                command.WriteByte(b1);
+                command.WriteByte(b2);
+                command.Position = 0;
+            }
+        }
+
+        public class cgCameraPreset
+        {
+            public static byte GetCameraPreset(ref GeolayoutCommand command)
+            {
+                command.Position = 0x3;
+                byte value = command.ReadByte();
+                command.Position = 0;
+                return value;
+            }
+
+            public static void SetCameraPreset(ref GeolayoutCommand command, byte Preset)
+            {
+                command.Position = 0x3;
+                command.Write(Preset);
+                command.Position = 0;
+            }
+        }
+
+        public class cgx18
+        {
+            public static ushort GetParam1(ref GeolayoutCommand command)
+            {
+                command.Position = 0x2;
+                ushort value = command.ReadUInt16();
+                command.Position = 0;
+                return value;
+            }
+
+            public static void SetParam1(ref GeolayoutCommand command, ushort ID)
+            {
+                command.Position = 0x2;
+                command.Write(ID);
+                command.Position = 0;
+            }
+
+            public static int GetAsmPointer(ref GeolayoutCommand command)
+            {
+                command.Position = 0x4;
+                int value = command.ReadInt32();
+                command.Position = 0;
+                return value;
+            }
+
+            public static void SetAsmPointer(ref GeolayoutCommand command, int AsmPointer)
+            {
+                command.Position = 0x4;
+                command.Write(AsmPointer);
+                command.Position = 0;
+            }
+        }
+
+        public class cgLoadDisplayList
+        {
+            public static byte GetDrawingLayer(ref GeolayoutCommand command)
+            {
+                command.Position = 0x1;
+                byte value = command.ReadByte();
+                command.Position = 0;
+                return value;
+            }
+
+            public static void SetDrawingLayer(ref GeolayoutCommand command, byte Layer)
+            {
+                command.Position = 0x1;
+                command.Write(Layer);
+                command.Position = 0;
+            }
+
+            public static int GetSegGeopointer(ref GeolayoutCommand command)
+            {
+                command.Position = 0x4;
+                int value = command.ReadInt32();
+                command.Position = 0;
+                return value;
+            }
+
+            public static void SetSegGeopointer(ref GeolayoutCommand command, int SegPointer)
+            {
+                command.Position = 0x4;
+                command.Write(SegPointer);
+                command.Position = 0;
+            }
+        }
+
+        public class cgLoadDisplayListWithOffset
+        {
+            public static byte GetDrawingLayer(ref GeolayoutCommand command)
+            {
+                command.Position = 0x1;
+                byte value = command.ReadByte();
+                command.Position = 0;
+                return value;
+            }
+
+            public static void SetDrawingLayer(ref GeolayoutCommand command, byte Layer)
+            {
+                command.Position = 0x1;
+                command.Write(Layer);
+                command.Position = 0;
+            }
+
+            public static Vector3 GetOffset(ref GeolayoutCommand command)
+            {
+                command.Position = 2;
+                var value = new Vector3();
+                value.X = command.ReadInt16();
+                value.Y = command.ReadInt16();
+                value.Z = command.ReadInt16();
+                command.Position = 0;
+                return value;
+            }
+
+            public static void SetOffset(ref GeolayoutCommand Command, Vector3 value)
+            {
+                Command.Position = 2;
+                Command.Write(Convert.ToInt16(value.X));
+                Command.Write(Convert.ToInt16(value.Y));
+                Command.Write(Convert.ToInt16(value.Z));
+                Command.Position = 0;
+            }
+
+            public static void SetOffset(ref GeolayoutCommand Command, int X, int Y, int Z)
+            {
+                SetOffset(ref Command, new Vector3(X, Y, Z));
+            }
+
+            public static uint GetSegGeopointer(ref GeolayoutCommand command)
+            {
+                command.Position = 0x8;
+                uint value = command.ReadUInt32();
+                command.Position = 0;
+                return value;
+            }
+
+            public static void SetSegGeopointer(ref GeolayoutCommand command, uint SegPointer)
+            {
+                command.Position = 0x8;
+                command.Write(SegPointer);
+                command.Position = 0;
+            }
+        }
+
+        public class cgx10
+        {
+            public static Vector3 GetOffset(ref GeolayoutCommand command)
+            {
+                command.Position = 2;
+                var value = new Vector3();
+                value.X = command.ReadInt16();
+                value.Y = command.ReadInt16();
+                command.Position += 2;
+                value.Z = command.ReadInt16();
+                command.Position = 0;
+                return value;
+            }
+        }
+
+        public class cgObjectShadow
+        {
+            /*
+             16 00 00 [AA] 00 [BB] [CC CC]
+             A	Shadow type
+             B	Shadow solidity (00=invisible, FF=black)
+             C	Shadow scale
+             */
+
+            public static void GetShadow(GeolayoutCommand command, ObjectShadow shadow)
+            {
+                command.Position = 3;
+                shadow.Type = (ObjectShadowType)command.ReadByte();
+
+                command.Position = 5;
+                shadow.Solidity = command.ReadByte();
+
+                shadow.Scale = command.ReadInt16();
+
+                command.Position = 0;
+            }
+
+            public static void SetShadow(GeolayoutCommand command, ObjectShadow shadow)
+            {
+                command.Position = 3;
+                command.Write((byte)shadow.Type);
+
+                command.Position = 5;
+                command.Write(shadow.Solidity);
+
+                command.Write(shadow.Scale);
+
+                command.Position = 0;
+            }
+        }
+
+        public class cgCameraFrustrum
+        {
+            public static void GetCameraFrustrum(GeolayoutCommand command, CameraFrustrum frustrum)
+            {
+                command.Position = 4;
+
+                frustrum.CameraNear = command.ReadInt16();
+                frustrum.CameraFar = command.ReadInt16();
+
+                command.Position = 0;
+            }
+
+            public static void SetCameraFrustrum(GeolayoutCommand command, CameraFrustrum frustrum)
+            {
+                command.Position = 4;
+
+                command.Write(frustrum.CameraNear);
+                command.Write(frustrum.CameraFar);
+
+                command.Position = 0;
+            }
+        }
+    }
+}

SM64Lib/Geolayout/Script/GeolayoutCommandTypes.cs

@@ -0,0 +1,37 @@
+
+namespace SM64Lib.Geolayout.Script
+{
+    public enum GeolayoutCommandTypes
+    {
+        BranchAndStore = 0x0,
+        EndOfGeolayout = 0x1,
+        JumpToSegAddr = 0x2,
+        JumpBack = 0x3,
+        StartOfNode = 0x4,
+        EndOfNode = 0x5,
+        SetScreenRenderArea = 0x8,
+        Scale1 = 0x9,
+        CameraFrustrum = 0xA,
+        x0B = 0xB,
+        x0C = 0xC,
+        x0D = 0xD,
+        x0E = 0xE,
+        CameraPreset = 0xF,
+        x10 = 0x10,
+        x11 = 0x11,
+        x12 = 0x12,
+        LoadDisplaylistWithOffset = 0x13,
+        BillboardModel = 0x14,
+        LoadDisplaylist = 0x15,
+        ObjectShadown = 0x16,
+        x17 = 0x17,
+        x18 = 0x18,
+        Background = 0x19,
+        x1A = 0x1A,
+        x1C = 0x1C,
+        Scale2 = 0x1D,
+        x1E = 0xE,
+        x1f = 0xF,
+        DrawingDistance = 0x20
+    }
+}

SM64Lib/Geolayout/Script/Geolayoutscript.cs

@@ -0,0 +1,239 @@
+using System.Collections.Generic;
+using global::System.IO;
+using System.Threading.Tasks;
+using Microsoft.VisualBasic.CompilerServices;
+using global::SM64Lib.Data;
+using SM64Lib.SegmentedBanking;
+using System;
+
+namespace SM64Lib.Geolayout.Script
+{
+    public class Geolayoutscript : GeolayoutCommandCollection
+    {
+        public List<int> GeopointerOffsets = new List<int>();
+
+        public Geolayoutscript()
+        {
+        }
+
+        public Task ReadAsync(RomManager rommgr, int segAddress)
+        {
+            var t = new Task(() => Read(rommgr, segAddress));
+            t.Start();
+            return t;
+        }
+
+        public void Read(byte[] data, byte bankID)
+        {
+            var ms = new MemoryStream(data);
+            var segBank = new SegmentedBank(bankID, ms);
+            Read(segBank, 0);
+        }
+
+        public void Read(RomManager rommgr, int segAddress)
+        {
+            var segBank = rommgr.GetSegBank(Convert.ToByte(segAddress >> 24));
+            segBank.ReadDataIfNull(rommgr.RomFile);
+            Read(segBank, segAddress & 0x00ffffff);
+        }
+
+        public void Read(SegmentedBank segBank, int offset)
+        {
+            Close();
+            Clear();
+            GeopointerOffsets.Clear();
+            if (segBank is null)
+                return;
+            var data = new BinaryStreamData(segBank.Data);
+            data.Position = offset;
+            var tb = new List<byte>();
+            GeolayoutCommandTypes cb = default;
+            int subNodeIndex = 0;
+            bool ende = false;
+            while (!ende)
+            {
+                if (data.Position >= data.Length)
+                    break;
+                cb = (GeolayoutCommandTypes)data.ReadByte();
+                byte lenth = 0;
+                switch (cb)
+                {
+                    case GeolayoutCommandTypes.Background:
+                        lenth = 0x8;
+                        break;
+                    case GeolayoutCommandTypes.CameraPreset:
+                        lenth = 0x14;
+                        break;
+                    case GeolayoutCommandTypes.DrawingDistance:
+                        lenth = 0x4;
+                        break;
+                    case GeolayoutCommandTypes.EndOfGeolayout:
+                        lenth = 0x4;
+                        break;
+                    case GeolayoutCommandTypes.EndOfNode:
+                        lenth = 0x4;
+                        break;
+                    case GeolayoutCommandTypes.JumpBack:
+                        lenth = 0x4;
+                        break;
+                    case GeolayoutCommandTypes.JumpToSegAddr:
+                        lenth = 0x8;
+                        break;
+                    case GeolayoutCommandTypes.LoadDisplaylist:
+                        lenth = 0x8;
+                        break;
+                    case GeolayoutCommandTypes.LoadDisplaylistWithOffset:
+                        lenth = 0xC;
+                        break;
+                    case GeolayoutCommandTypes.ObjectShadown:
+                        lenth = 0x8;
+                        break;
+                    case GeolayoutCommandTypes.Scale1:
+                        lenth = 0x4;
+                        break;
+                    case GeolayoutCommandTypes.Scale2:
+                        lenth = 0x8;
+                        break;
+                    case GeolayoutCommandTypes.StartOfNode:
+                        lenth = 0x4;
+                        break;
+                    case GeolayoutCommandTypes.SetScreenRenderArea:
+                        lenth = 0xC;
+                        break;
+                    case GeolayoutCommandTypes.BillboardModel:
+                        lenth = 0x8;
+                        break;
+                    case GeolayoutCommandTypes.BranchAndStore:
+                        lenth = 0x8;
+                        break;
+                    case GeolayoutCommandTypes.CameraFrustrum:
+                        {
+                            var switchExpr = data.ReadByte();
+                            switch (switchExpr)
+                            {
+                                case 0x1:
+                                    lenth = 0xC;
+                                    break;
+                                default:
+                                    lenth = 0x8;
+                                    break;
+                            }
+
+                            segBank.Data.Position -= 1;
+                            break;
+                        }
+                    case GeolayoutCommandTypes.x0B:
+                        lenth = 0x4;
+                        break;
+                    case GeolayoutCommandTypes.x0C:
+                        lenth = 0x4;
+                        break;
+                    case GeolayoutCommandTypes.x0D:
+                        lenth = 0x8;
+                        break;
+                    case GeolayoutCommandTypes.x0E:
+                        lenth = 0x8;
+                        break;
+                    case GeolayoutCommandTypes.x10:
+                        lenth = 0x10;
+                        break;
+                    case GeolayoutCommandTypes.x11:
+                        lenth = 0x8;
+                        break;
+                    case GeolayoutCommandTypes.x12:
+                        {
+                            var switchExpr = data.ReadByte() >> 4;
+                            switch (switchExpr)
+                            {
+                                case 0x8:
+                                    lenth = 0xC;
+                                    break;
+                                default:
+                                    lenth = 0x8;
+                                    break;
+                            }
+
+                            segBank.Data.Position -= 1;
+                            break;
+                        }
+                    case GeolayoutCommandTypes.x17:
+                        lenth = 0x4;
+                        break;
+                    case GeolayoutCommandTypes.x18:
+                        lenth = 0x8;
+                        break;
+                    case GeolayoutCommandTypes.x1A:
+                        lenth = 0x8;
+                        break;
+                    case GeolayoutCommandTypes.x1C:
+                        lenth = 0xC;
+                        break;
+                    case var @case when @case == GeolayoutCommandTypes.x1E:
+                        lenth = 0x8;
+                        break;
+                    case var case1 when case1 == GeolayoutCommandTypes.x1f:
+                        lenth = 0x10;
+                        break;
+                    default:
+                        break;
+                }
+
+                segBank.Data.Position -= 1;
+                if (lenth == 0 || segBank.Data.Position + lenth > segBank.Data.Length)
+                    break;
+
+                for (int i = 1, loopTo = lenth; i <= loopTo; i++)
+                    tb.Add(data.ReadByte());
+
+                var tCommand = new GeolayoutCommand(tb.ToArray());
+                int bankOffset = (int)(segBank.Data.Position - lenth);
+                tCommand.RomAddress = segBank.RomStart + bankOffset;
+                tCommand.BankAddress = segBank.BankAddress + bankOffset;
+                Add(tCommand);
+                tb.Clear();
+
+                var switchExpr1 = tCommand.CommandType;
+                switch (switchExpr1)
+                {
+                    case GeolayoutCommandTypes.EndOfGeolayout:
+                        ende = true;
+                        break;
+                    case GeolayoutCommandTypes.EndOfNode:
+                        subNodeIndex -= 1;
+                        break;
+                    case GeolayoutCommandTypes.StartOfNode:
+                        subNodeIndex += 1;
+                        break;
+                }
+            }
+        }
+
+        public void Write(Stream s, int GeolayoutStart)
+        {
+            var bw = new BinaryWriter(s);
+
+            // Write new Levelscript
+            s.Position = GeolayoutStart;
+            foreach (GeolayoutCommand c in this)
+            {
+                if (c.CommandType == GeolayoutCommandTypes.LoadDisplaylist)
+                    GeopointerOffsets.Add((int)(s.Position + 0x4));
+                foreach (byte b in c.ToArray())
+                    bw.Write(b);
+            }
+        }
+
+        public GeolayoutCommand GetFirst(GeolayoutCommandTypes cmdType)
+        {
+            foreach (GeolayoutCommand cmd in this)
+            {
+                if (cmd.CommandType == cmdType)
+                {
+                    return cmd;
+                }
+            }
+
+            return null;
+        }
+    }
+}

SM64Lib/Geolayout/TerrainType.cs

@@ -0,0 +1,14 @@
+
+namespace SM64Lib.Geolayout
+{
+    public enum TerrainTypes
+    {
+        NoramlA = 0x0,
+        NoramlB,
+        SnowTerrain,
+        SandTerrain,
+        BigBoosHount,
+        WaterLevels,
+        SlipperySlide
+    }
+}

SM64Lib/Json/ArrayReferencePreservngConverter.cs

@@ -0,0 +1,87 @@
+using Newtonsoft.Json;
+using System;
+using System.Collections.Generic;
+using System.Collections;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Newtonsoft.Json.Linq;
+
+namespace SM64Lib.Json
+{
+    public class ArrayReferencePreservngConverter : JsonConverter
+    {
+        const string refProperty = "$ref";
+        const string idProperty = "$id";
+        const string valuesProperty = "$values";
+
+        public override bool CanConvert(Type objectType)
+        {
+            return objectType.IsArray;
+        }
+
+        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
+        {
+            if (reader.TokenType == JsonToken.Null)
+                return null;
+            else if (reader.TokenType == JsonToken.StartArray)
+            {
+                // No $ref.  Deserialize as a List<T> to avoid infinite recursion and return as an array.
+                var elementType = objectType.GetElementType();
+                var listType = typeof(List<>).MakeGenericType(elementType);
+                var list = (IList)serializer.Deserialize(reader, listType);
+                if (list == null)
+                    return null;
+                var array = Array.CreateInstance(elementType, list.Count);
+                list.CopyTo(array, 0);
+                return array;
+            }
+            else
+            {
+                var obj = JObject.Load(reader);
+                var refId = (string)obj[refProperty];
+                if (refId != null)
+                {
+                    var reference = serializer.ReferenceResolver.ResolveReference(serializer, refId);
+                    if (reference != null)
+                        return reference;
+                }
+                var values = obj[valuesProperty];
+                if (values == null || values.Type == JTokenType.Null)
+                    return null;
+                if (!(values is JArray))
+                {
+                    throw new JsonSerializationException(string.Format("{0} was not an array", values));
+                }
+                var count = ((JArray)values).Count;
+
+                var elementType = objectType.GetElementType();
+                var array = Array.CreateInstance(elementType, count);
+
+                var objId = (string)obj[idProperty];
+                if (objId != null)
+                {
+                    // Add the empty array into the reference table BEFORE poppulating it,
+                    // to handle recursive references.
+                    serializer.ReferenceResolver.AddReference(serializer, objId, array);
+                }
+
+                var listType = typeof(List<>).MakeGenericType(elementType);
+                using (var subReader = values.CreateReader())
+                {
+                    var list = (IList)serializer.Deserialize(subReader, listType);
+                    list.CopyTo(array, 0);
+                }
+
+                return array;
+            }
+        }
+
+        public override bool CanWrite { get { return false; } }
+
+        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
+        {
+            throw new NotImplementedException();
+        }
+    }
+}

SM64Lib/Json/BaseCommandJsonConverter.cs

@@ -0,0 +1,61 @@
+using Newtonsoft.Json;
+using SM64Lib.Behaviors.Script;
+using SM64Lib.Geolayout.Script;
+using SM64Lib.Model.Fast3D;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace SM64Lib.Json
+{
+    internal class BaseCommandJsonConverter : JsonConverter
+    {
+        public override bool CanConvert(Type objectType)
+        {
+            return typeof(GeolayoutscriptCommandJsonConverter).IsAssignableFrom(objectType);
+        }
+
+        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
+        {
+            var export = serializer.Deserialize<CmdExport>(reader);
+            GeolayoutCommand c;
+
+            if (existingValue is not null)
+                c = (GeolayoutCommand)existingValue;
+            else
+                c = new GeolayoutCommand();
+
+            if (export?.Buffer is not null)
+            {
+                c.Position = 0;
+                c.Write(export.Buffer, 0, export.Buffer.Length);
+                c.Position = 0;
+            }
+
+            c.BankAddress = export.BankAddress;
+
+            return c;
+        }
+
+        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
+        {
+            var cmd = (GeolayoutCommand)value;
+
+            var export = new CmdExport
+            {
+                Buffer = cmd.ToArray(),
+                BankAddress = cmd.BankAddress
+            };
+
+            serializer.Serialize(writer, export);
+        }
+
+        private class CmdExport
+        {
+            public byte[] Buffer { get; set; }
+            public int BankAddress { get; set; }
+        }
+    }
+}

SM64Lib/Json/BehaviorscriptCommandJsonConverter.cs

@@ -0,0 +1,60 @@
+using Newtonsoft.Json;
+using SM64Lib.Behaviors.Script;
+using SM64Lib.Model.Fast3D;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace SM64Lib.Json
+{
+    internal class BehaviorscriptCommandJsonConverter : JsonConverter
+    {
+        public override bool CanConvert(Type objectType)
+        {
+            return typeof(BehaviorscriptCommand).IsAssignableFrom(objectType);
+        }
+
+        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
+        {
+            var export = serializer.Deserialize<CmdExport>(reader);
+            BehaviorscriptCommand c;
+
+            if (existingValue is not null)
+                c = (BehaviorscriptCommand)existingValue;
+            else
+                c = new BehaviorscriptCommand();
+
+            if (export?.Buffer is not null)
+            {
+                c.Position = 0;
+                c.Write(export.Buffer, 0, export.Buffer.Length);
+                c.Position = 0;
+            }
+
+            c.BankAddress = export.BankAddress;
+
+            return c;
+        }
+
+        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
+        {
+            var cmd = (BehaviorscriptCommand)value;
+
+            var export = new CmdExport
+            {
+                Buffer = cmd.ToArray(),
+                BankAddress = cmd.BankAddress
+            };
+
+            serializer.Serialize(writer, export);
+        }
+
+        private class CmdExport
+        {
+            public byte[] Buffer { get; set; }
+            public int BankAddress { get; set; }
+        }
+    }
+}

SM64Lib/Json/ComplexDictionarJsonConverter.cs

@@ -0,0 +1,35 @@
+using Newtonsoft.Json;
+using SM64Lib.Model.Fast3D;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Z.Collections.Extensions;
+
+namespace SM64Lib.Json
+{
+    internal class ComplexDictionarJsonConverter<TKey, TValue> : JsonConverter
+    {
+        public override bool CanConvert(Type objectType)
+        {
+            return typeof(List<KeyValuePair<TKey, TValue>>).IsAssignableFrom(objectType);
+        }
+
+        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
+        {
+            var list = serializer.Deserialize<List<KeyValuePair<TKey, TValue>>>(reader);
+            var dic = new Dictionary<TKey, TValue>();
+            dic.AddRange(list.ToArray());
+
+            return dic;
+        }
+
+        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
+        {
+            if (value is Dictionary<TKey, TValue>)
+                serializer.Serialize(writer, ((Dictionary<TKey, TValue>)value).ToArray());
+        }
+    }
+}

SM64Lib/Json/Fast3DBufferJsonConverter.cs

@@ -0,0 +1,71 @@
+using Newtonsoft.Json;
+using SM64Lib.Model.Fast3D;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.IO.Compression;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace SM64Lib.Json
+{
+    internal class Fast3DBufferJsonConverter : JsonConverter
+    {
+        public override bool CanConvert(Type objectType)
+        {
+            return typeof(Fast3DBuffer).IsAssignableFrom(objectType);
+        }
+
+        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
+        {
+            var export = serializer.Deserialize<Fast3DBufferExport>(reader);
+            Fast3DBuffer c;
+
+            if (existingValue is not null)
+                c = (Fast3DBuffer)existingValue;
+            else
+                c = new Fast3DBuffer();
+
+            if (export?.Buffer is not null)
+            {
+                c.Position = 0;
+                
+                if (export.IsDeflateStream)
+                    General.DecompressData(export.Buffer, c);
+                else
+                    c.Write(export.Buffer, 0, export.Buffer.Length);
+
+                c.Position = 0;
+            }
+
+            c.Fast3DBankStart = export.Fast3DBankStart;
+            c.DLPointers = export.DLPointers.ToArray();
+
+            return c;
+        }
+
+        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
+        {
+            var buffer = (Fast3DBuffer)value;
+            var export = new Fast3DBufferExport
+            {
+                Buffer = General.CompressData(buffer, CompressionLevel.Fastest),
+                Fast3DBankStart = buffer.Fast3DBankStart,
+                DLPointers = buffer.DLPointers.ToList(),
+                IsDeflateStream = true
+            };
+            buffer.Position = 0;
+
+            serializer.Serialize(writer, export);
+        }
+
+        private class Fast3DBufferExport
+        {
+            public byte[] Buffer { get; set; }
+            public int Fast3DBankStart { get; set; }
+            public List<Geolayout.Geopointer> DLPointers { get; set; }
+            public bool IsDeflateStream { get; set; } = false;
+        }
+    }
+}

SM64Lib/Json/GeolayoutscriptCommandJsonConverter.cs

@@ -0,0 +1,61 @@
+using Newtonsoft.Json;
+using SM64Lib.Behaviors.Script;
+using SM64Lib.Geolayout.Script;
+using SM64Lib.Model.Fast3D;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace SM64Lib.Json
+{
+    internal class GeolayoutscriptCommandJsonConverter : JsonConverter
+    {
+        public override bool CanConvert(Type objectType)
+        {
+            return typeof(GeolayoutCommand).IsAssignableFrom(objectType);
+        }
+
+        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
+        {
+            var export = serializer.Deserialize<CmdExport>(reader);
+            GeolayoutCommand c;
+
+            if (existingValue is not null)
+                c = (GeolayoutCommand)existingValue;
+            else
+                c = new GeolayoutCommand();
+
+            if (export?.Buffer is not null)
+            {
+                c.Position = 0;
+                c.Write(export.Buffer, 0, export.Buffer.Length);
+                c.Position = 0;
+            }
+
+            c.BankAddress = export.BankAddress;
+
+            return c;
+        }
+
+        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
+        {
+            var cmd = (GeolayoutCommand)value;
+
+            var export = new CmdExport
+            {
+                Buffer = cmd.ToArray(),
+                BankAddress = cmd.BankAddress
+            };
+
+            serializer.Serialize(writer, export);
+        }
+
+        private class CmdExport
+        {
+            public byte[] Buffer { get; set; }
+            public int BankAddress { get; set; }
+        }
+    }
+}

SM64Lib/Json/JsonHelper.cs

@@ -0,0 +1,36 @@
+using Newtonsoft.Json;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace SM64Lib.Json
+{
+    internal class JsonHelper
+    {
+        public static JsonSerializer CreateJsonSerializer(
+            bool allowReferences = false,
+            bool rememberTypeNames = false,
+            bool enableIndentedFormatting = true)
+        {
+            var serializer = JsonSerializer.CreateDefault();
+
+            if (enableIndentedFormatting)
+                serializer.Formatting = Formatting.Indented;
+
+            if (rememberTypeNames)
+                serializer.TypeNameHandling = TypeNameHandling.Auto;
+
+            if (allowReferences)
+            {
+                serializer.PreserveReferencesHandling = PreserveReferencesHandling.All;
+                serializer.ReferenceLoopHandling = ReferenceLoopHandling.Serialize;
+            }
+
+            serializer.Converters.Add(new MemoryStreamJsonConverter());
+
+            return serializer;
+        }
+    }
+}

SM64Lib/Json/LevelscriptCommandJsonConverter.cs

@@ -0,0 +1,62 @@
+using Newtonsoft.Json;
+using SM64Lib.Behaviors.Script;
+using SM64Lib.Geolayout.Script;
+using SM64Lib.Levels.Script;
+using SM64Lib.Model.Fast3D;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace SM64Lib.Json
+{
+    internal class LevelscriptCommandJsonConverter : JsonConverter
+    {
+        public override bool CanConvert(Type objectType)
+        {
+            return typeof(LevelscriptCommand).IsAssignableFrom(objectType);
+        }
+
+        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
+        {
+            var export = serializer.Deserialize<CmdExport>(reader);
+            LevelscriptCommand c;
+
+            if (existingValue is not null)
+                c = (LevelscriptCommand)existingValue;
+            else
+                c = new LevelscriptCommand();
+
+            if (export?.Buffer is not null)
+            {
+                c.Position = 0;
+                c.Write(export.Buffer, 0, export.Buffer.Length);
+                c.Position = 0;
+            }
+
+            c.BankAddress = export.BankAddress;
+
+            return c;
+        }
+
+        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
+        {
+            var cmd = (LevelscriptCommand)value;
+
+            var export = new CmdExport
+            {
+                Buffer = cmd.ToArray(),
+                BankAddress = cmd.BankAddress
+            };
+
+            serializer.Serialize(writer, export);
+        }
+
+        private class CmdExport
+        {
+            public byte[] Buffer { get; set; }
+            public int BankAddress { get; set; }
+        }
+    }
+}

SM64Lib/Json/MemoryStreamJsonConverter.cs

@@ -0,0 +1,37 @@
+using Newtonsoft.Json;
+using SM64Lib.Behaviors.Script;
+using SM64Lib.Geolayout.Script;
+using SM64Lib.Levels.Script;
+using SM64Lib.Model.Fast3D;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace SM64Lib.Json
+{
+    internal class MemoryStreamJsonConverter : JsonConverter
+    {
+        public override bool CanConvert(Type objectType)
+        {
+            return typeof(MemoryStream).IsAssignableFrom(objectType);
+        }
+
+        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
+        {
+            var msData = serializer.Deserialize<byte[]>(reader);
+            var ms = new MemoryStream();
+            ms.Write(msData, 0, msData.Length);
+            ms.Position = 0;
+            return ms;
+        }
+
+        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
+        {
+            var ms = (MemoryStream)value;
+            serializer.Serialize(writer, ms.ToArray());
+        }
+    }
+}

SM64Lib/Level/Area Table.txt

@@ -0,0 +1,12 @@
+Located Bank 0x19.
+Start: 0x19005F00
+End: 0x19006000
+
+One line = one Area
+xx xx xx xx yy yy yy yy 00 00 00 00 00 00 00 ff
+xx = Fast3D Start (ROM Pos)
+zz = Fast3D Length (in Bytes)
+ff = 2D-Camera (0xff = on | 0x0 = off)
+
+How to get to the table entry for the current area:
+Table-Start + AreaID * 0x10

SM64Lib/Level/AreaBG.cs

@@ -0,0 +1,16 @@
+using global::System.Drawing;
+
+namespace SM64Lib.Levels
+{
+    public class AreaBG
+    {
+        public AreaBGs Type { get; set; } = AreaBGs.Levelbackground;
+        public Color Color { get; set; } = Color.Black;
+    }
+
+    public enum AreaBGs
+    {
+        Levelbackground,
+        Color
+    }
+}

SM64Lib/Level/AreaReverbLevel.cs

@@ -0,0 +1,23 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace SM64Lib.Levels
+{
+    public enum AreaReverbLevel : byte
+    {
+        None,
+        Level01 = 0x8,
+        Level02 = 0xC,
+        Level03 = 0x10,
+        Level04 = 0x18,
+        Level05 = 0x20,
+        Level06 = 0x28,
+        Level07 = 0x30,
+        Level08 = 0x38,
+        Level09 = 0x40,
+        Level10 = 0x70
+    }
+}

SM64Lib/Level/Enums.cs

@@ -0,0 +1,123 @@
+
+namespace SM64Lib.Levels
+{
+    public enum ObjectBank0x0C
+    {
+        Disabled,
+        HauntedObjects,
+        SnowObjects,
+        AssortedEnemies1,
+        DesertObjects,
+        BigBobOmbBoss,
+        AssortedEnemies2,
+        WaterObjects,
+        AssortedEnemies3,
+        PeachYoshi,
+        Switches,
+        LavaObjects
+    }
+
+    public enum ObjectBank0x0D
+    {
+        Disabled,
+        AssortedEnemies4,
+        Moneybags,
+        CastleObjects,
+        GroundEnemies,
+        WaterObjects2,
+        Bowser
+    }
+
+    public enum ObjectBank0x0E
+    {
+        Disabled,
+        HaundetHouse,
+        CoolCoolMountain,
+        InsideCastle,
+        HazyMazeCave,
+        ShiftingSandLand,
+        BobOmbBattlefield,
+        SnowandsLand,
+        WetDryWorld,
+        JollyRogerBay,
+        TinyHugeIsland,
+        TickTockClock,
+        RainbowRide,
+        CastleGrounds,
+        Bowser1Course,
+        VanishCap,
+        Bowser2Course,
+        Bowser3Course,
+        LethalLavaLand,
+        DireDireDocks,
+        WhompsFortress,
+        CastleCourtyard,
+        WingCap,
+        Bowser2Battle,
+        Bowser3Battle,
+        TallTallMountain
+    }
+
+    public enum ObjectBanks
+    {
+        Bank0x0C,
+        Bank0x0D,
+        Bank0x0E
+    }
+
+    public enum Levels : byte
+    {
+        HaundetHouse = 0x4,
+        CoolCoolMountain,
+        InsideCastle,
+        HazyMazeCave,
+        ShiftingSandLand,
+        BobOmbsBattlefield,
+        SnowManLand,
+        WetDryWorld,
+        JollyRogerBay,
+        TinyHugeIsland,
+        TickTockClock,
+        RainbowRide,
+        CastleGrounds,
+        Bowser1Course,
+        VanishCap,
+        Bowser2Course,
+        SecretAquarium,
+        Bowser3Course,
+        LethalLavaLand,
+        DireDireDocks,
+        WhompsFortress,
+        EndCakePicture,
+        CastleCourtyard,
+        PeachsSecretSlide,
+        MetalCap,
+        WingCap,
+        Bowser1Battle,
+        RainbowClouds,
+        Bowser2Battle = 0x21,
+        Bowser3Battle,
+        TallTallMountain = 0x24
+    }
+
+    public enum ScrollingTextureAxis
+    {
+        X,
+        Y
+    }
+
+    public enum SpecialBoxType
+    {
+        Water,
+        ToxicHaze,
+        Mist
+    }
+
+    public enum WaterType
+    {
+        Default = 0x0,
+        JRBWater = 0x20000,
+        GreenWater = 0x30000,
+        LavaWater = 0x40000
+    }
+}

SM64Lib/Level/ILevelManager.cs

@@ -0,0 +1,10 @@
+using global::SM64Lib.Data;
+
+namespace SM64Lib.Levels
+{
+    public interface ILevelManager
+    {
+        void LoadLevel(Level lvl, RomManager rommgr, ushort LevelID, uint segAddress);
+        LevelSaveResult SaveLevel(Level lvl, RomManager rommgr, BinaryData output, ref uint curOff);
+    }
+}

SM64Lib/Level/Level.cs

@@ -0,0 +1,329 @@
+using System.Collections.Generic;
+using System.Data;
+using global::System.IO;
+using System.Linq;
+using Microsoft.VisualBasic;
+using Microsoft.VisualBasic.CompilerServices;
+using global::SM64Lib.Levels.Script;
+using global::SM64Lib.Levels.Script.Commands;
+using global::SM64Lib.Objects.ObjectBanks.Data;
+using global::SM64Lib.SegmentedBanking;
+using SM64Lib.Objects.ModelBanks;
+using Newtonsoft.Json;
+using System;
+
+namespace SM64Lib.Levels
+{
+    public abstract class Level
+    {
+
+        // S h a r e d   M e m b e r s
+
+        internal static readonly byte[] LevelscriptStart = new byte[] { 0x80, 0x8, 0x0, 0x0, 0x19, 0x0, 0x0, 0x1C, 0x8, 0x0, 0x0, 0xA, 0x0, 0xA0, 0x0, 0x78, 0x0, 0xA0, 0x0, 0x78, 0x4, 0x0, 0x0, 0x0, 0xC, 0x0, 0x0, 0x0 };
+
+        // F i e l d s
+
+        protected SegmentedBank _Bank0x19 = null;
+
+        // A u t o   P r o p e r t i e s
+
+        internal LevelscriptCommand LastGobCmdSegLoad { get; set; } = null;
+        internal LevelscriptCommand LastLobCmdSegLoad { get; set; } = null;
+        [JsonIgnore]
+        internal Dictionary<byte, ObjectBankData> MyObjectBanks { get; private set; } = new Dictionary<byte, ObjectBankData>();
+        public Levelscript Levelscript { get; set; } = new Levelscript();
+        public List<LevelArea> Areas { get; private set; } = new List<LevelArea>();
+        public ushort LevelID { get; set; } = 0;
+        public LevelBG Background { get; private set; } = new LevelBG();
+        public bool ActSelector { get; set; } = false;
+        public bool HardcodedCameraSettings { get; set; } = false;
+        public bool Closed { get; set; } = false;
+        public int LastRomOffset { get; set; } = -1;
+        public bool NeedToSaveLevelscript { get; set; } = false;
+        public bool NeedToSaveBanks0E { get; set; } = false;
+        public bool OneBank0xESystemEnabled { get; set; } = true;
+        public bool EnableGlobalObjectBank { get; set; } = false;
+        public bool EnableLocalObjectBank { get; set; } = false;
+        public CustomModelBank LocalObjectBank { get; private set; } = new CustomModelBank();
+        [JsonIgnore]
+        public RomManager RomManager { get; set; }
+
+        // O t h e r   P r o p e r t i e s
+
+        [JsonIgnore]
+        public IReadOnlyDictionary<byte, ObjectBankData> LoadedObjectBanks
+        {
+            get
+            {
+                return MyObjectBanks;
+            }
+        }
+
+        [JsonIgnore]
+        public SegmentedBank Bank0x19
+        {
+            get
+            {
+                return _Bank0x19;
+            }
+
+            internal set
+            {
+                _Bank0x19 = value;
+            }
+        }
+
+        [JsonIgnore]
+        public int ObjectsCount
+        {
+            get
+            {
+                int tcount = 0;
+                foreach (var a in Areas)
+                    tcount += a.Objects.Count;
+                return tcount;
+            }
+        }
+
+        [JsonIgnore]
+        public int WarpsCount
+        {
+            get
+            {
+                int tcount = 0;
+                foreach (var a in Areas)
+                    tcount += a.Warps.Count;
+                return tcount;
+            }
+        }      
+
+        [JsonIgnore]
+        public long Length
+        {
+            get
+            {
+                long length = 0;
+
+                if (Bank0x19 is not null)
+                    length += Bank0x19.Length;
+                else
+                    length += RomManagerSettings.DefaultLevelscriptSize;
+
+                if (LocalObjectBank is not null)
+                    length += LocalObjectBank.Length;
+
+                foreach (var area in Areas)
+                {
+                    length += area.AreaModel.Length;
+                    if (OneBank0xESystemEnabled)
+                        length += area.Levelscript.Length;
+                }
+
+                return length;
+            }
+        }
+
+        // C o n s t r u c t o r s
+
+        [JsonConstructor]
+        protected Level(JsonConstructorAttribute attr)
+        {
+        }
+
+        protected Level(ushort LevelID, int LevelIndex, RomManager rommgr) : this(rommgr)
+        {
+            this.LevelID = LevelID;
+            CreateNewLevelscript();
+            HardcodedCameraSettings = false;
+            ActSelector = General.ActSelectorDefaultValues[LevelIndex];
+        }
+
+        protected Level(RomManager rommgr)
+        {
+            RomManager = rommgr;
+        }
+
+        // M e t h o d s
+
+        public void CreateNewLevelscript()
+        {
+            {
+                var withBlock = Levelscript;
+                withBlock.Close();
+                withBlock.Clear();
+
+                // Start Loading Commands
+                withBlock.Add(new LevelscriptCommand(new byte[] { 0x1B, 0x4, 0x0, 0x0 }));
+
+                // Loading Commands
+                withBlock.Add(new LevelscriptCommand(new byte[] { 0x17, 0xC, 0x1, 0xE, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 }));
+
+                // Start Model Commands
+                withBlock.Add(new LevelscriptCommand(new byte[] { 0x1D, 0x4, 0x0, 0x0 }));
+
+                // Load Marios Model
+                withBlock.Add(new LevelscriptCommand(new byte[] { 0x25, 0xC, 0x0, 0x1, 0x0, 0x0, 0x0, 0x1, 0x13, 0x0, 0x2E, 0xC0 }));
+
+                // Start End-Of-Level Commands
+                withBlock.Add(new LevelscriptCommand(new byte[] { 0x1E, 0x4, 0x0, 0x0 }));
+
+                // End-Of-Level Commands
+                withBlock.Add(new LevelscriptCommand(new byte[] { 0x2B, 0xC, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 }));
+                withBlock.Add(new LevelscriptCommand(new byte[] { 0x11, 0x8, 0x0, 0x0, 0x80, 0x24, 0xBC, 0xD8 }));
+                withBlock.Add(new LevelscriptCommand(new byte[] { 0x12, 0x8, 0x0, 0x1, 0x80, 0x24, 0xBC, 0xD8 }));
+                withBlock.Add(new LevelscriptCommand(new byte[] { 0x1C, 0x4, 0x0, 0x0 }));
+                withBlock.Add(new LevelscriptCommand(new byte[] { 0x4, 0x4, 0x0, 0x1 }));
+                withBlock.Add(new LevelscriptCommand(new byte[] { 0x2, 0x4, 0x0, 0x0 }));
+
+                // Add the general object bank
+                ChangeObjectBank(null, RomManager.RomConfig.ObjectBankInfoData[Convert.ToByte(0xB)]?.FirstOrDefault());
+            }
+
+            foreach (LevelscriptCommand c in Levelscript)
+            {
+                if (c.CommandType != LevelscriptCommandTypes.LoadRomToRam)
+                    continue;
+                if (clLoadRomToRam.GetSegmentedID(c) != 0xE)
+                    continue;
+            }
+        }
+
+        public void SetSegmentedBanks(RomManager rommgr)
+        {
+            foreach (LevelscriptCommand cmd in Levelscript)
+            {
+                var switchExpr = cmd.CommandType;
+                switch (switchExpr)
+                {
+                    case LevelscriptCommandTypes.LoadRomToRam:
+                    case LevelscriptCommandTypes.x1A:
+                    case LevelscriptCommandTypes.x18:
+                        {
+                            cmd.Position = 0;
+                            byte bankID = clLoadRomToRam.GetSegmentedID(cmd);
+                            int startAddr = clLoadRomToRam.GetRomStart(cmd);
+                            int endAddr = clLoadRomToRam.GetRomEnd(cmd);
+                            var seg = rommgr.SetSegBank(bankID, startAddr, endAddr);
+                            if (cmd.CommandType == LevelscriptCommandTypes.x1A)
+                                seg.MakeAsMIO0();
+                            break;
+                        }
+                }
+            }
+
+            if (Bank0x19 is not null)
+            {
+                rommgr.SetSegBank(Bank0x19);
+            }
+        }
+
+        public LevelscriptCommand GetDefaultPositionCmd()
+        {
+            return (LevelscriptCommand)Levelscript.FirstOrDefault(n => n.CommandType == LevelscriptCommandTypes.DefaultPosition);
+        }
+
+        public void ChangeObjectBankData(byte bankID, ObjectBankData newObd)
+        {
+            ChangeObjectBank(GetObjectBankData(bankID), newObd);
+            MyObjectBanks[bankID] = newObd;
+        }
+
+        public ObjectBankData GetObjectBankData(byte bankID)
+        {
+            if (MyObjectBanks.ContainsKey(bankID))
+            {
+                return MyObjectBanks[bankID];
+            }
+            else
+            {
+                var obd = FindObjectBankData(bankID);
+                MyObjectBanks.Add(bankID, obd);
+                return obd;
+            }
+        }
+
+        protected void ChangeObjectBank(ObjectBankData oldObd, ObjectBankData newObd)
+        {
+            // Remove old commands
+            if (oldObd is not null)
+            {
+                foreach (ObjectBankDataCommand obdCmd in oldObd.Commands)
+                {
+                    foreach (var cmd in Levelscript.Where(n => General.CompareTwoByteArrays(n.ToArray(), obdCmd.Command)).ToArray())
+                    {
+                        cmd.Close();
+                        Levelscript.Remove(cmd);
+                    }
+                }
+            }
+
+            // Add new commands
+            if (newObd is not null)
+            {
+                foreach (ObjectBankDataCommand obdCmd in newObd.Commands)
+                {
+                    int startIndex = Levelscript.IndexOfFirst(LevelscriptCommandTypes.x1D);
+                    if (!(obdCmd.CommandType == 0x1A || obdCmd.CommandType == 0x17))
+                    {
+                        startIndex += 1;
+                    }
+
+                    var cmd = new LevelscriptCommand(obdCmd.Command);
+                    Levelscript.Insert(startIndex, cmd);
+                    startIndex += 1;
+                }
+            }
+        }
+
+        protected ObjectBankData FindObjectBankData(byte bankID)
+        {
+            var list = RomManager.RomConfig.ObjectBankInfoData[bankID];
+            var Found = new List<bool>();
+            foreach (ObjectBankData obd in list)
+            {
+                foreach (ObjectBankDataCommand obdCmd in obd.Commands)
+                    Found.Add(Levelscript.Where(n => General.CompareTwoByteArrays(n.ToArray(), obdCmd.Command)).Any());
+                if (!Found.Contains(false))
+                {
+                    return obd;
+                }
+
+                Found.Clear();
+            }
+
+            return null;
+        }
+
+        public void Close()
+        {
+            foreach (var c in Levelscript)
+                c.Close();
+            Levelscript.Clear();
+            foreach (var a in Areas)
+                a.Close();
+            Areas.Clear();
+            Closed = true;
+        }
+
+        public override string ToString()
+        {
+            string output = "";
+            foreach (var cmd in Levelscript)
+            {
+                string tbytelist = "";
+                foreach (byte b in cmd.ToArray())
+                {
+                    if (tbytelist != string.Empty)
+                        tbytelist += " ";
+                    tbytelist += Conversion.Hex(b);
+                }
+
+                if (output != string.Empty)
+                    output += Environment.NewLine;
+                output += tbytelist;
+            }
+
+            return output;
+        }
+    }
+}

SM64Lib/Level/LevelArea.cs

@@ -0,0 +1,178 @@
+using System.Collections.Generic;
+using System.Linq;
+using Microsoft.VisualBasic.CompilerServices;
+using global::SM64Lib.Levels.Script;
+using global::SM64Lib.Levels.Script.Commands;
+using global::SM64Lib.Levels.ScrolTex;
+using global::SM64Lib.Model;
+using Newtonsoft.Json;
+using System;
+
+namespace SM64Lib.Levels
+{
+    public abstract class LevelArea
+    {
+
+        // S h a r e d   M e m b e r s
+
+        public static readonly byte[] DefaultNormal3DObject = new byte[] { 0x24, 0x18, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x13, 0x0, 0x0, 0x0 };
+
+        // F i e l d s
+
+        protected bool _GettingAreaCollision = false;
+
+        // A u t o   P r o p e r t i e s
+
+        public SpecialBoxList SpecialBoxes { get; private set; } = new SpecialBoxList();
+        public List<ManagedScrollingTexture> ScrollingTextures { get; private set; } = new List<ManagedScrollingTexture>();
+        public List<LevelscriptCommand> Objects { get; private set; } = new List<LevelscriptCommand>();
+        public List<LevelscriptCommand> MacroObjects { get; private set; } = new List<LevelscriptCommand>();
+        public List<LevelscriptCommand> Warps { get; private set; } = new List<LevelscriptCommand>();
+        public List<LevelscriptCommand> WarpsForGame { get; private set; } = new List<LevelscriptCommand>();
+        public ShowMessage ShowMessage { get; private set; } = new ShowMessage();
+        public AreaBG Background { get; private set; } = new AreaBG();
+        public LevelscriptCommandCollection Levelscript { get; set; } = new LevelscriptCommandCollection();
+        public Geolayout.Geolayout Geolayout { get; set; } = new Geolayout.Geolayout(SM64Lib.Geolayout.Geolayout.NewScriptCreationMode.None);
+        public Geolayout.TerrainTypes TerrainType { get; set; } = SM64Lib.Geolayout.TerrainTypes.NoramlA;
+        public byte BGMusic { get; set; } = 0;
+        public byte AreaID { get; set; } = 0;
+        public uint GeolayoutOffset { get; set; } = 0;
+        public ObjectModel AreaModel { get; set; } = new ObjectModel();
+        public bool Enable2DCamera { get; set; } = false;
+        public uint Bank0x0EOffset { get; set; } = 0;
+        public int Bank0xELength { get; set; }
+
+        // O t h e r   P r o p e r t i e s
+
+        [JsonIgnore]
+        public int Fast3DBankRomStart
+        {
+            get
+            {
+                return Convert.ToInt32(Bank0x0EOffset);
+            }
+        }
+
+        [JsonIgnore]
+        public int Fast3DLength
+        {
+            get
+            {
+                return CollisionPointer - 0xE000000;
+            }
+        }
+
+        [JsonIgnore]
+        public bool IsCamera2D
+        {
+            get
+            {
+                return Enable2DCamera && Geolayout.CameraPreset == SM64Lib.Geolayout.CameraPresets.PlattfromLevels;
+            }
+        }
+
+        [JsonIgnore]
+        public int CollisionPointer
+        {
+            get
+            {
+                int CollisionPointerRet = default;
+                _GettingAreaCollision = true;
+                foreach (var cmd in Levelscript)
+                {
+                    if (cmd.CommandType == LevelscriptCommandTypes.AreaCollision)
+                    {
+                        CollisionPointerRet = Convert.ToInt32(clAreaCollision.GetAreaCollision((LevelscriptCommand)cmd));
+                    }
+                }
+
+                _GettingAreaCollision = false;
+                return CollisionPointerRet;
+            }
+
+            set
+            {
+                if (_GettingAreaCollision)
+                    return;
+                foreach (var cmd in Levelscript)
+                {
+                    if (cmd.CommandType == LevelscriptCommandTypes.AreaCollision)
+                    {
+                        clAreaCollision.SetAreaCollision((LevelscriptCommand)cmd, Convert.ToUInt32(value));
+                    }
+                }
+            }
+        }
+
+        // M e t h o d s
+
+        public void SetSegmentedBanks(RomManager rommgr)
+        {
+            var bank0xE = rommgr.SetSegBank(0xE, Convert.ToInt32(Bank0x0EOffset), (int)(Bank0x0EOffset + Bank0xELength), AreaID);
+            bank0xE.Data = AreaModel.Fast3DBuffer;
+        }
+
+        internal void UpdateScrollingTextureVertexPointer(int offset)
+        {
+            foreach (ManagedScrollingTexture scrollText in ScrollingTextures)
+                scrollText.VertexPointer += offset;
+        }
+
+        public void Close()
+        {
+            Levelscript.Close();
+            Geolayout.Close();
+        }
+
+        // C o n s t r u c t o r s
+
+        protected LevelArea(byte AreaID) : this(AreaID, 9)
+        {
+        }
+
+        protected LevelArea(byte AreaID, byte LevelID) : this(AreaID, LevelID, true, true)
+        {
+        }
+
+        protected LevelArea(byte AreaID, byte LevelID, bool AddWarps, bool AddObjects)
+        {
+            Geolayout = new Geolayout.Geolayout(SM64Lib.Geolayout.Geolayout.NewScriptCreationMode.Level);
+            this.AreaID = AreaID;
+            {
+                var withBlock = Levelscript;
+                withBlock.Add(new LevelscriptCommand(new byte[] { 0x1F, 0x8, AreaID, 0x0, 0x0, 0x0, 0x0, 0x0 }));
+                withBlock.Add(new LevelscriptCommand(new byte[] { 0x2E, 0x8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 }));
+                withBlock.Add(new LevelscriptCommand(new byte[] { 0x36, 0x8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 }));
+                withBlock.Add(new LevelscriptCommand(new byte[] { 0x31, 0x4, 0x0, 0x2 }));
+                withBlock.Add(new LevelscriptCommand(new byte[] { 0x20, 0x4, 0x0, 0x0 }));
+            }
+
+            if (AddWarps)
+            {
+                Objects.Add(new LevelscriptCommand(new byte[] { 0x24, 0x18, 0x1F, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xA, 0x0, 0x0, 0x13, 0x0, 0x2F, 0x74 }));
+                Warps.Add(new LevelscriptCommand(new byte[] { 0x26, 0x8, 0xA, LevelID, AreaID, 0x0, 0x0, 0x0 }));
+                WarpsForGame.Add(new LevelscriptCommand(new byte[] { 0x26, 0x8, 0xF0, 0x6, 0x1, 0x32, 0x0, 0x0 }));
+                WarpsForGame.Add(new LevelscriptCommand(new byte[] { 0x26, 0x8, 0xF1, 0x6, 0x1, 0x64, 0x0, 0x0 }));
+            }
+
+            if (AddObjects)
+            {
+                //for (int i = 1; i <= 15; i++)
+                //{
+                //    var newObj = new LevelscriptCommand(DefaultNormal3DObject);
+                //    Objects.Add(newObj);
+                //}
+            }
+        }
+
+        protected LevelArea()
+        {
+            Geolayout = new Geolayout.Geolayout(SM64Lib.Geolayout.Geolayout.NewScriptCreationMode.Level);
+        }
+
+        [JsonConstructor]
+        protected LevelArea(JsonConstructorAttribute attr)
+        {
+        }
+    }
+}

SM64Lib/Level/LevelBG.cs

@@ -0,0 +1,236 @@
+using global::System.Drawing;
+using global::System.IO;
+using Microsoft.VisualBasic.CompilerServices;
+using SM64Lib.Data.System;
+using global::SM64Lib.Model.Fast3D;
+using Newtonsoft.Json;
+using System;
+
+namespace SM64Lib.Levels
+{
+    public class LevelBG
+    {
+        private Bitmap _Image = null;
+
+        // A u t o   P r o p e r t i e s
+
+        public byte[] ImageData { get; set; } = null;
+        public bool Enabled { get; set; } = true;
+        public bool IsCustom { get; set; } = false;
+        public Geolayout.BackgroundIDs ID { get; set; } = Geolayout.BackgroundIDs.Ocean;
+
+        // A u t o   P r o p e r t i e s
+
+        [JsonIgnore]
+        public Bitmap Image
+        {
+            get
+            {
+                if (_Image is not null)
+                {
+                    return _Image;
+                }
+                else
+                {
+                    var img = GetImage();
+                    _Image = (Bitmap)img;
+                    return (Bitmap)img;
+                }
+            }
+        }
+
+        [JsonIgnore]
+        public int ImageLength
+        {
+            get
+            {
+                return ImageData?.Length ?? 0;
+            }
+        }
+
+        [JsonIgnore]
+        public bool HasImage
+        {
+            get
+            {
+                return ImageData is object;
+            }
+        }
+
+        // C o n s t r c u t o r s
+
+        public LevelBG()
+        {
+        }
+
+        public LevelBG(Geolayout.BackgroundIDs ID)
+        {
+            this.ID = ID;
+        }
+
+        public LevelBG(Image Image)
+        {
+            ID = Geolayout.BackgroundIDs.Custom;
+            SetImage(Image);
+        }
+
+        // M e t h o d s
+
+        public void WriteImage(Stream s, int offset)
+        {
+            // Write Image Data
+            s.Position = offset;
+            if (ImageData is not null)
+            {
+                s.Write(ImageData, 0, ImageData.Length);
+            }
+        }
+
+        public void ReadImage(Stream s, int offset)
+        {
+            // Read Image Data
+            ImageData = new byte[131072];
+            s.Position = offset;
+            s.Read(ImageData, 0, ImageData.Length);
+            _Image = null;
+        }
+
+        public void SetImage(Image image)
+        {
+            SetImage(new Bitmap(image));
+        }
+
+        public void SetImage(Bitmap bmp)
+        {
+            var s = new Size(248, 248); // ((&H20140 - &H140) / 256 / 2 / 32) * 31)
+            if (bmp.Size != s)
+            {
+                bmp = (Bitmap)TextureManager.ResizeImage(bmp, s, false);
+            }
+
+            ImageData = BackgroundImageConverter.GetBytes(bmp);
+            _Image = null;
+        }
+
+        public Image GetImage()
+        {
+            if (ImageData is not null)
+            {
+                var s = new Size(248, 248); // ((_ImageByts.Length - &H140) / 256 / 2 / 32) * 31)
+                var img = BackgroundImageConverter.GetImage(ImageData, s);
+                _Image = img;
+                return img;
+            }
+            else
+            {
+                return null;
+            }
+        }
+
+        public static byte[] GetBackgroundPointerTable()
+        {
+            return new byte[] { 0xA, 0x0, 0x0, 0x0, 0xA, 0x0, 0x8, 0x0, 0xA, 0x0, 0x10, 0x0, 0xA, 0x0, 0x18, 0x0, 0xA, 0x0, 0x20, 0x0, 0xA, 0x0, 0x28, 0x0, 0xA, 0x0, 0x30, 0x0, 0xA, 0x0, 0x38, 0x0, 0xA, 0x0, 0x0, 0x0, 0xA, 0x0, 0x8, 0x0, 0xA, 0x0, 0x40, 0x0, 0xA, 0x0, 0x48, 0x0, 0xA, 0x0, 0x50, 0x0, 0xA, 0x0, 0x58, 0x0, 0xA, 0x0, 0x60, 0x0, 0xA, 0x0, 0x68, 0x0, 0xA, 0x0, 0x70, 0x0, 0xA, 0x0, 0x78, 0x0, 0xA, 0x0, 0x40, 0x0, 0xA, 0x0, 0x48, 0x0, 0xA, 0x0, 0x80, 0x0, 0xA, 0x0, 0x88, 0x0, 0xA, 0x0, 0x90, 0x0, 0xA, 0x0, 0x98, 0x0, 0xA, 0x0, 0xA0, 0x0, 0xA, 0x0, 0xA8, 0x0, 0xA, 0x0, 0xB0, 0x0, 0xA, 0x0, 0xB8, 0x0, 0xA, 0x0, 0x80, 0x0, 0xA, 0x0, 0x88, 0x0, 0xA, 0x0, 0xC0, 0x0, 0xA, 0x0, 0xC8, 0x0, 0xA, 0x0, 0xD0, 0x0, 0xA, 0x0, 0xD8, 0x0, 0xA, 0x0, 0xE0, 0x0, 0xA, 0x0, 0xE8, 0x0, 0xA, 0x0, 0xF0, 0x0, 0xA, 0x0, 0xF8, 0x0, 0xA, 0x0, 0xC0, 0x0, 0xA, 0x0, 0xC8, 0x0, 0xA, 0x1, 0x0, 0x0, 0xA, 0x1, 0x8, 0x0, 0xA, 0x1, 0x10, 0x0, 0xA, 0x1, 0x18, 0x0, 0xA, 0x1, 0x20, 0x0, 0xA, 0x1, 0x28, 0x0, 0xA, 0x1, 0x30, 0x0, 0xA, 0x1, 0x38, 0x0, 0xA, 0x1, 0x0, 0x0, 0xA, 0x1, 0x8, 0x0, 0xA, 0x1, 0x40, 0x0, 0xA, 0x1, 0x48, 0x0, 0xA, 0x1, 0x50, 0x0, 0xA, 0x1, 0x58, 0x0, 0xA, 0x1, 0x60, 0x0, 0xA, 0x1, 0x68, 0x0, 0xA, 0x1, 0x70, 0x0, 0xA, 0x1, 0x78, 0x0, 0xA, 0x1, 0x40, 0x0, 0xA, 0x1, 0x48, 0x0, 0xA, 0x1, 0x80, 0x0, 0xA, 0x1, 0x88, 0x0, 0xA, 0x1, 0x90, 0x0, 0xA, 0x1, 0x98, 0x0, 0xA, 0x1, 0xA0, 0x0, 0xA, 0x1, 0xA8, 0x0, 0xA, 0x1, 0xB0, 0x0, 0xA, 0x1, 0xB8, 0x0, 0xA, 0x1, 0x80, 0x0, 0xA, 0x1, 0x88, 0x0, 0xA, 0x1, 0xC0, 0x0, 0xA, 0x1, 0xC8, 0x0, 0xA, 0x1, 0xD0, 0x0, 0xA, 0x1, 0xD8, 0x0, 0xA, 0x1, 0xE0, 0x0, 0xA, 0x1, 0xE8, 0x0, 0xA, 0x1, 0xF0, 0x0, 0xA, 0x1, 0xF8, 0x0, 0xA, 0x1, 0xC0, 0x0, 0xA, 0x1, 0xC8, 0x0 };
+        }
+
+        // C l a s s e s
+
+        private class BackgroundImageConverter
+        {
+            public static Bitmap GetImage(byte[] data, Size size)
+            {
+                var ms = new MemoryStream(data);
+                var br = new BinaryReader(ms);
+                var img = new Bitmap(size.Width, size.Height);
+                uint current_address = 0;
+                for (int y = 0, loopTo = (int)(size.Height / (double)31 - 1); y <= loopTo; y++)
+                {
+                    for (int x = 0, loopTo1 = (int)(size.Width / (double)31 - 1); x <= loopTo1; x++)
+                    {
+                        ParseBlock(br, img, current_address, new Rectangle(x * 31, y * 31, 31, 31));
+                        current_address += 2048;
+                    }
+                }
+
+                ms.Close();
+                return img;
+            }
+
+            private static void ParseBlock(BinaryReader br, Bitmap map, uint address, Rectangle rect)
+            {
+                for (int yy = 0, loopTo = rect.Height - 1; yy <= loopTo; yy++)
+                {
+                    for (int xx = 0, loopTo1 = rect.Width - 1; xx <= loopTo1; xx++)
+                    {
+                        int offset = (int)(address + (yy * (rect.Width + 1) + xx) * 2);
+                        br.BaseStream.Position = offset;
+                        ushort pixel = SwapInts.SwapUInt16(br.ReadUInt16());
+                        byte red = Convert.ToByte((pixel >> 11 & 0x1F) * 8);
+                        byte green = Convert.ToByte((pixel >> 6 & 0x1F) * 8);
+                        byte blue = Convert.ToByte((pixel >> 1 & 0x1F) * 8);
+                        byte alpha = Convert.ToByte((pixel & 1) > 0 ? 0xFF : 0);
+                        var pixcol = Color.FromArgb(alpha, red, green, blue);
+                        map.SetPixel(rect.X + xx, rect.Y + yy, pixcol);
+                    }
+                }
+            }
+
+            public static byte[] GetBytes(Bitmap img)
+            {
+                var ms = new MemoryStream();
+                var bw = new BinaryWriter(ms);
+                int wTiles = (int)(img.Width / (double)31);
+                int hTiles = (int)(img.Height / (double)31);
+                int current_address = 0;
+                for (int y = 0, loopTo = hTiles - 1; y <= loopTo; y++)
+                {
+                    for (int x = 0, loopTo1 = wTiles - 1; x <= loopTo1; x++)
+                    {
+                        ConvertBlock(bw, img, Convert.ToUInt32(current_address), x * 31, y * 31, 0, 0, 0, 0, 31, 31, 32);
+                        if (x < wTiles - 1)
+                        {
+                            ConvertBlock(bw, img, Convert.ToUInt32(current_address), (x + 1) * 31 - 30, y * 31, 30, 0, 1, 0, 31, 31, 32);
+                            ConvertBlock(bw, img, Convert.ToUInt32(current_address), (x + 1) * 31 - 30, y * 31, 30, 30, 1, 1, 31, 31, 32);
+                        }
+                        else
+                        {
+                            ConvertBlock(bw, img, Convert.ToUInt32(current_address), -30, y * 31, 30, 0, 1, 0, 31, 31, 32);
+                            ConvertBlock(bw, img, Convert.ToUInt32(current_address), -30, y * 31, 30, 30, 1, 1, 31, 31, 32);
+                        }
+
+                        if (y < hTiles - 1)
+                        {
+                            ConvertBlock(bw, img, Convert.ToUInt32(current_address), x * 31, (y + 1) * 31 - 30, 0, 30, 0, 1, 31, 31, 32);
+                        }
+                        else
+                        {
+                            ConvertBlock(bw, img, Convert.ToUInt32(current_address), x * 31, -30, 0, 30, 0, 1, 31, 31, 32);
+                        }
+
+                        current_address += 2048;
+                    }
+                }
+
+                var temp = ms.ToArray();
+                ms.Close();
+                return temp;
+            }
+
+            private static void ConvertBlock(BinaryWriter bw, Bitmap map, uint address, int src_x, int src_y, int start_x, int start_y, int offset_x, int offset_y, int w, int h, int lineWidth)
+            {
+                for (int yy = start_y, loopTo = h - 1; yy <= loopTo; yy++)
+                {
+                    for (int xx = start_x, loopTo1 = w - 1; xx <= loopTo1; xx++)
+                    {
+                        var pixel = map.GetPixel(src_x + xx, src_y + yy);
+                        int r = pixel.R / 8;
+                        int g = pixel.G / 8;
+                        int b = pixel.B / 8;
+                        int a = pixel.A == 0xFF ? 1 : 0;
+                        bw.BaseStream.Position = address + ((yy + offset_y) * lineWidth + xx + offset_x) * 2;
+                        bw.Write(SwapInts.SwapUInt16(Convert.ToUInt16(r << 11 | g << 6 | b << 1 | a)));
+                    }
+                }
+            }
+        }
+    }
+}

SM64Lib/Level/LevelExport.cs

@@ -0,0 +1,79 @@
+using Newtonsoft.Json;
+using SM64Lib.Levels.Script;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.IO.Compression;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace SM64Lib.Levels
+{
+    public class LevelExport
+    {
+        // P r o p e r t i e s
+
+        [JsonProperty]
+        public object Content { get; protected set; }
+        [JsonProperty]
+        public LevelExportContentType ContentType { get; set; }
+
+        // C o n s t r u c t o r s
+
+        private LevelExport(object content, LevelExportContentType type) : this()
+        {
+            Content = content;
+            ContentType = type;
+        }
+
+        public LevelExport(Level level) : this(new  List<Level> { level }) { }
+        public LevelExport(List<Level> levels) : this(levels, LevelExportContentType.Level) { }
+        public LevelExport(LevelArea area) : this(new List<LevelArea> { area }) { }
+        public LevelExport(List<LevelArea> areas) : this(areas, LevelExportContentType.Area) { }
+        public LevelExport(List<LevelscriptCommand> cmds, LevelExportContentType contentType) : this((object)cmds, contentType) { }
+
+        [JsonConstructor]
+        private LevelExport() { }
+
+        // F e a t u r e s
+
+        public void WriteToFile(string filePath, CompressionLevel compressionLevel)
+        {
+            var plainText = compressionLevel == CompressionLevel.NoCompression;
+
+            // Open streams
+            var fs = new FileStream(filePath, FileMode.Create, FileAccess.ReadWrite);
+            var output = new DeflateStream(fs, compressionLevel, true);
+            var sw = new StreamWriter(output);
+
+            // Create serializer
+            var serializer = Json.JsonHelper.CreateJsonSerializer(true, true, plainText);
+
+            // Serialize
+            serializer.Serialize(sw, this);
+
+            sw.Flush();
+            output.Close();
+            fs.Close();
+        }
+
+        public static LevelExport ReadFromFile(string filePath)
+        {
+            // Open streams
+            var fs = new FileStream(filePath, FileMode.Open, FileAccess.Read);
+            var input = new DeflateStream(fs, CompressionMode.Decompress);
+            var sr = new StreamReader(input);
+            
+            // Create serializer
+            var serializer = Json.JsonHelper.CreateJsonSerializer(true, true);
+
+            // Deserialize
+            var export = (LevelExport)serializer.Deserialize(sr, typeof(LevelExport));
+
+            fs.Close();
+
+            return export;
+        }
+    }
+}

SM64Lib/Level/LevelExportContentType.cs

@@ -0,0 +1,17 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace SM64Lib.Levels
+{
+    public enum LevelExportContentType
+    {
+        Unknown,
+        Level,
+        Area,
+        Objects,
+        Warps
+    }
+}

SM64Lib/Level/LevelExportFileFormat.cs

@@ -0,0 +1,14 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace SM64Lib.Levels
+{
+    public enum LevelExportFileFormat
+    {
+        JSON,
+        PlainText
+    }
+}