diff --git a/AssetStudio.sln b/AssetStudio.sln
index ed5e94f..6d5b1fe 100644
--- a/AssetStudio.sln
+++ b/AssetStudio.sln
@@ -1,20 +1,39 @@
 
-Microsoft Visual Studio Solution File, Format Version 11.00
-# Visual Studio 2010
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 16
+VisualStudioVersion = 16.0.30611.23
+MinimumVisualStudioVersion = 10.0.40219.1
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "AssetStudio", "AssetStudio\AssetStudio.csproj", "{24551E2D-E9B6-4CD6-8F2A-D9F4A13E7853}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "SystemHalf", "thirdparty\SystemHalf\SystemHalf.csproj", "{8E79039E-85DD-4ED4-9C3C-2FB2D8CB8324}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
 		Debug|x86 = Debug|x86
+		Release|Any CPU = Release|Any CPU
 		Release|x86 = Release|x86
 	EndGlobalSection
 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{24551E2D-E9B6-4CD6-8F2A-D9F4A13E7853}.Debug|Any CPU.ActiveCfg = Debug|x86
 		{24551E2D-E9B6-4CD6-8F2A-D9F4A13E7853}.Debug|x86.ActiveCfg = Debug|x86
 		{24551E2D-E9B6-4CD6-8F2A-D9F4A13E7853}.Debug|x86.Build.0 = Debug|x86
+		{24551E2D-E9B6-4CD6-8F2A-D9F4A13E7853}.Release|Any CPU.ActiveCfg = Release|x86
 		{24551E2D-E9B6-4CD6-8F2A-D9F4A13E7853}.Release|x86.ActiveCfg = Release|x86
 		{24551E2D-E9B6-4CD6-8F2A-D9F4A13E7853}.Release|x86.Build.0 = Release|x86
+		{8E79039E-85DD-4ED4-9C3C-2FB2D8CB8324}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{8E79039E-85DD-4ED4-9C3C-2FB2D8CB8324}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{8E79039E-85DD-4ED4-9C3C-2FB2D8CB8324}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{8E79039E-85DD-4ED4-9C3C-2FB2D8CB8324}.Debug|x86.Build.0 = Debug|Any CPU
+		{8E79039E-85DD-4ED4-9C3C-2FB2D8CB8324}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{8E79039E-85DD-4ED4-9C3C-2FB2D8CB8324}.Release|Any CPU.Build.0 = Release|Any CPU
+		{8E79039E-85DD-4ED4-9C3C-2FB2D8CB8324}.Release|x86.ActiveCfg = Release|Any CPU
+		{8E79039E-85DD-4ED4-9C3C-2FB2D8CB8324}.Release|x86.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
 	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {08189501-F88C-4EE0-AB61-D84C344075C3}
+	EndGlobalSection
 EndGlobal
diff --git a/AssetStudio/7zip/7z.dll b/AssetStudio/7z.dll
similarity index 100%
rename from AssetStudio/7zip/7z.dll
rename to AssetStudio/7z.dll
diff --git a/AssetStudio/AssetStudio.csproj b/AssetStudio/AssetStudio.csproj
index f03acc9..2c42d93 100644
--- a/AssetStudio/AssetStudio.csproj
+++ b/AssetStudio/AssetStudio.csproj
@@ -55,9 +55,6 @@
   <ItemGroup>
     <Reference Include="System" />
     <Reference Include="System.Core" />
-    <Reference Include="System.Half">
-      <HintPath>..\..\..\..\..\Tools\LIBRARIES\csharp-half-code-2\System.Half\bin\Release\System.Half.dll</HintPath>
-    </Reference>
     <Reference Include="System.Web.Extensions" />
     <Reference Include="System.Xml.Linq" />
     <Reference Include="System.Data.DataSetExtensions" />
@@ -67,9 +64,8 @@
     <Reference Include="System.Drawing" />
     <Reference Include="System.Windows.Forms" />
     <Reference Include="System.Xml" />
-    <Reference Include="Tao.DevIl, Version=1.6.8.3, Culture=neutral, PublicKeyToken=7ec4053013524957, processorArchitecture=MSIL">
-      <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\..\..\..\Tools\SDK\taoframework-2.1.0\taoframework-2.1.0\bin\Tao.DevIl.dll</HintPath>
+    <Reference Include="Tao.DevIl">
+      <HintPath>..\thirdparty\Tao.DevIl.dll</HintPath>
     </Reference>
   </ItemGroup>
   <ItemGroup>
@@ -219,15 +215,21 @@
     </BootstrapperPackage>
   </ItemGroup>
   <ItemGroup>
-    <Content Include="7zip\7z.dll">
+    <Content Include="7z.dll">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </Content>
-    <Content Include="FMOD Studio API\fmod.dll">
+    <Content Include="DevIL.dll" />
+    <Content Include="fmod.dll">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </Content>
     <Content Include="Resources\reverse.ico" />
   </ItemGroup>
-  <ItemGroup />
+  <ItemGroup>
+    <ProjectReference Include="..\thirdparty\SystemHalf\SystemHalf.csproj">
+      <Project>{8e79039e-85dd-4ed4-9c3c-2fb2d8cb8324}</Project>
+      <Name>SystemHalf</Name>
+    </ProjectReference>
+  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
diff --git a/AssetStudio/Classes/Mesh.cs b/AssetStudio/Classes/Mesh.cs
index f42133a..df7728a 100644
--- a/AssetStudio/Classes/Mesh.cs
+++ b/AssetStudio/Classes/Mesh.cs
@@ -36,6 +36,7 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 using System.Text;
 using System.IO;
 using System.Collections;
+using SystemHalf;
 
 /*Notes about handedness
 Converting from left-handed to right-handed and vice versa requires either:
diff --git a/AssetStudio/DevIL.dll b/AssetStudio/DevIL.dll
new file mode 100644
index 0000000..3fbab0c
Binary files /dev/null and b/AssetStudio/DevIL.dll differ
diff --git a/AssetStudio/fmod.dll b/AssetStudio/fmod.dll
new file mode 100644
index 0000000..64e485b
Binary files /dev/null and b/AssetStudio/fmod.dll differ
diff --git a/thirdparty/SystemHalf/Half.cs b/thirdparty/SystemHalf/Half.cs
new file mode 100644
index 0000000..c84def2
--- /dev/null
+++ b/thirdparty/SystemHalf/Half.cs
@@ -0,0 +1,1093 @@
+/// ================ Half.cs ====================
+/// The code is free to use for any reason without any restrictions.
+/// Ladislav Lang (2009), Joannes Vermorel (2017)
+/// https://gist.github.com/vermorel/1d5c0212752b3e611faf84771ad4ff0d
+
+using System;
+using System.Diagnostics;
+using System.Globalization;
+
+namespace SystemHalf
+{
+    /// <summary>
+    /// Represents a half-precision floating point number. 
+    /// </summary>
+    /// <remarks>
+    /// Note:
+    ///     Half is not fast enought and precision is also very bad, 
+    ///     so is should not be used for mathematical computation (use Single instead).
+    ///     The main advantage of Half type is lower memory cost: two bytes per number. 
+    ///     Half is typically used in graphical applications.
+    ///     
+    /// Note: 
+    ///     All functions, where is used conversion half->float/float->half, 
+    ///     are approx. ten times slower than float->double/double->float, i.e. ~3ns on 2GHz CPU.
+    ///
+    /// References:
+    ///     - Code retrieved from http://sourceforge.net/p/csharp-half/code/HEAD/tree/ on 2015-12-04
+    ///     - Fast Half Float Conversions, Jeroen van der Zijp, link: http://www.fox-toolkit.org/ftp/fasthalffloatconversion.pdf
+    ///     - IEEE 754 revision, link: http://grouper.ieee.org/groups/754/
+    /// </remarks>
+    [Serializable]
+    public struct Half : IComparable, IFormattable, IConvertible, IComparable<Half>, IEquatable<Half>
+    {
+        /// <summary>
+        /// Internal representation of the half-precision floating-point number.
+        /// </summary>
+        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+        internal ushort Value;
+
+        #region Constants
+        /// <summary>
+        /// Represents the smallest positive System.Half value greater than zero. This field is constant.
+        /// </summary>
+        public static readonly Half Epsilon = ToHalf(0x0001);
+        /// <summary>
+        /// Represents the largest possible value of System.Half. This field is constant.
+        /// </summary>
+        public static readonly Half MaxValue = ToHalf(0x7bff);
+        /// <summary>
+        /// Represents the smallest possible value of System.Half. This field is constant.
+        /// </summary>
+        public static readonly Half MinValue = ToHalf(0xfbff);
+        /// <summary>
+        /// Represents not a number (NaN). This field is constant.
+        /// </summary>
+        public static readonly Half NaN = ToHalf(0xfe00);
+        /// <summary>
+        /// Represents negative infinity. This field is constant.
+        /// </summary>
+        public static readonly Half NegativeInfinity = ToHalf(0xfc00);
+        /// <summary>
+        /// Represents positive infinity. This field is constant.
+        /// </summary>
+        public static readonly Half PositiveInfinity = ToHalf(0x7c00);
+        #endregion
+
+        #region Constructors
+        /// <summary>
+        /// Initializes a new instance of System.Half to the value of the specified single-precision floating-point number.
+        /// </summary>
+        /// <param name="value">The value to represent as a System.Half.</param>
+        public Half(float value) { this = HalfHelper.SingleToHalf(value); }
+        /// <summary>
+        /// Initializes a new instance of System.Half to the value of the specified 32-bit signed integer.
+        /// </summary>
+        /// <param name="value">The value to represent as a System.Half.</param>
+        public Half(int value) : this((float)value) { }
+        /// <summary>
+        /// Initializes a new instance of System.Half to the value of the specified 64-bit signed integer.
+        /// </summary>
+        /// <param name="value">The value to represent as a System.Half.</param>
+        public Half(long value) : this((float)value) { }
+        /// <summary>
+        /// Initializes a new instance of System.Half to the value of the specified double-precision floating-point number.
+        /// </summary>
+        /// <param name="value">The value to represent as a System.Half.</param>
+        public Half(double value) : this((float)value) { }
+        /// <summary>
+        /// Initializes a new instance of System.Half to the value of the specified decimal number.
+        /// </summary>
+        /// <param name="value">The value to represent as a System.Half.</param>
+        public Half(decimal value) : this((float)value) { }
+        /// <summary>
+        /// Initializes a new instance of System.Half to the value of the specified 32-bit unsigned integer.
+        /// </summary>
+        /// <param name="value">The value to represent as a System.Half.</param>
+        public Half(uint value) : this((float)value) { }
+        /// <summary>
+        /// Initializes a new instance of System.Half to the value of the specified 64-bit unsigned integer.
+        /// </summary>
+        /// <param name="value">The value to represent as a System.Half.</param>
+        public Half(ulong value) : this((float)value) { }
+        #endregion
+
+        #region Numeric operators
+
+        /// <summary>
+        /// Returns the result of multiplying the specified System.Half value by negative one.
+        /// </summary>
+        /// <param name="half">A System.Half.</param>
+        /// <returns>A System.Half with the value of half, but the opposite sign. -or- Zero, if half is zero.</returns>
+        public static Half Negate(Half half) { return -half; }
+        /// <summary>
+        /// Adds two specified System.Half values.
+        /// </summary>
+        /// <param name="half1">A System.Half.</param>
+        /// <param name="half2">A System.Half.</param>
+        /// <returns>A System.Half value that is the sum of half1 and half2.</returns>
+        public static Half Add(Half half1, Half half2) { return half1 + half2; }
+        /// <summary>
+        /// Subtracts one specified System.Half value from another.
+        /// </summary>
+        /// <param name="half1">A System.Half (the minuend).</param>
+        /// <param name="half2">A System.Half (the subtrahend).</param>
+        /// <returns>The System.Half result of subtracting half2 from half1.</returns>
+        public static Half Subtract(Half half1, Half half2) { return half1 - half2; }
+        /// <summary>
+        /// Multiplies two specified System.Half values.
+        /// </summary>
+        /// <param name="half1">A System.Half (the multiplicand).</param>
+        /// <param name="half2">A System.Half (the multiplier).</param>
+        /// <returns>A System.Half that is the result of multiplying half1 and half2.</returns>
+        public static Half Multiply(Half half1, Half half2) { return half1 * half2; }
+        /// <summary>
+        /// Divides two specified System.Half values.
+        /// </summary>
+        /// <param name="half1">A System.Half (the dividend).</param>
+        /// <param name="half2">A System.Half (the divisor).</param>
+        /// <returns>The System.Half that is the result of dividing half1 by half2.</returns>
+        /// <exception cref="System.DivideByZeroException">half2 is zero.</exception>
+        public static Half Divide(Half half1, Half half2) { return half1 / half2; }
+
+        /// <summary>
+        /// Returns the value of the System.Half operand (the sign of the operand is unchanged).
+        /// </summary>
+        /// <param name="half">The System.Half operand.</param>
+        /// <returns>The value of the operand, half.</returns>
+        public static Half operator +(Half half) { return half; }
+        /// <summary>
+        /// Negates the value of the specified System.Half operand.
+        /// </summary>
+        /// <param name="half">The System.Half operand.</param>
+        /// <returns>The result of half multiplied by negative one (-1).</returns>
+        public static Half operator -(Half half) { return HalfHelper.Negate(half); }
+        /// <summary>
+        /// Increments the System.Half operand by 1.
+        /// </summary>
+        /// <param name="half">The System.Half operand.</param>
+        /// <returns>The value of half incremented by 1.</returns>
+        public static Half operator ++(Half half) { return (Half)(half + 1f); }
+        /// <summary>
+        /// Decrements the System.Half operand by one.
+        /// </summary>
+        /// <param name="half">The System.Half operand.</param>
+        /// <returns>The value of half decremented by 1.</returns>
+        public static Half operator --(Half half) { return (Half)(half - 1f); }
+        /// <summary>
+        /// Adds two specified System.Half values.
+        /// </summary>
+        /// <param name="half1">A System.Half.</param>
+        /// <param name="half2">A System.Half.</param>
+        /// <returns>The System.Half result of adding half1 and half2.</returns>
+        public static Half operator +(Half half1, Half half2) { return (Half)(half1 + (float)half2); }
+        /// <summary>
+        /// Subtracts two specified System.Half values.
+        /// </summary>
+        /// <param name="half1">A System.Half.</param>
+        /// <param name="half2">A System.Half.</param>
+        /// <returns>The System.Half result of subtracting half1 and half2.</returns>        
+        public static Half operator -(Half half1, Half half2) { return (Half)(half1 - (float)half2); }
+        /// <summary>
+        /// Multiplies two specified System.Half values.
+        /// </summary>
+        /// <param name="half1">A System.Half.</param>
+        /// <param name="half2">A System.Half.</param>
+        /// <returns>The System.Half result of multiplying half1 by half2.</returns>
+        public static Half operator *(Half half1, Half half2) { return (Half)(half1 * (float)half2); }
+        /// <summary>
+        /// Divides two specified System.Half values.
+        /// </summary>
+        /// <param name="half1">A System.Half (the dividend).</param>
+        /// <param name="half2">A System.Half (the divisor).</param>
+        /// <returns>The System.Half result of half1 by half2.</returns>
+        public static Half operator /(Half half1, Half half2) { return (Half)(half1 / (float)half2); }
+        /// <summary>
+        /// Returns a value indicating whether two instances of System.Half are equal.
+        /// </summary>
+        /// <param name="half1">A System.Half.</param>
+        /// <param name="half2">A System.Half.</param>
+        /// <returns>true if half1 and half2 are equal; otherwise, false.</returns>
+        public static bool operator ==(Half half1, Half half2) { return (!IsNaN(half1) && (half1.Value == half2.Value)); }
+        /// <summary>
+        /// Returns a value indicating whether two instances of System.Half are not equal.
+        /// </summary>
+        /// <param name="half1">A System.Half.</param>
+        /// <param name="half2">A System.Half.</param>
+        /// <returns>true if half1 and half2 are not equal; otherwise, false.</returns>
+        public static bool operator !=(Half half1, Half half2) { return half1.Value != half2.Value; }
+        /// <summary>
+        /// Returns a value indicating whether a specified System.Half is less than another specified System.Half.
+        /// </summary>
+        /// <param name="half1">A System.Half.</param>
+        /// <param name="half2">A System.Half.</param>
+        /// <returns>true if half1 is less than half1; otherwise, false.</returns>
+        public static bool operator <(Half half1, Half half2) { return half1 < (float)half2; }
+        /// <summary>
+        /// Returns a value indicating whether a specified System.Half is greater than another specified System.Half.
+        /// </summary>
+        /// <param name="half1">A System.Half.</param>
+        /// <param name="half2">A System.Half.</param>
+        /// <returns>true if half1 is greater than half2; otherwise, false.</returns>
+        public static bool operator >(Half half1, Half half2) { return half1 > (float)half2; }
+        /// <summary>
+        /// Returns a value indicating whether a specified System.Half is less than or equal to another specified System.Half.
+        /// </summary>
+        /// <param name="half1">A System.Half.</param>
+        /// <param name="half2">A System.Half.</param>
+        /// <returns>true if half1 is less than or equal to half2; otherwise, false.</returns>
+        public static bool operator <=(Half half1, Half half2) { return (half1 == half2) || (half1 < half2); }
+        /// <summary>
+        /// Returns a value indicating whether a specified System.Half is greater than or equal to another specified System.Half.
+        /// </summary>
+        /// <param name="half1">A System.Half.</param>
+        /// <param name="half2">A System.Half.</param>
+        /// <returns>true if half1 is greater than or equal to half2; otherwise, false.</returns>
+        public static bool operator >=(Half half1, Half half2) { return (half1 == half2) || (half1 > half2); }
+        #endregion
+
+        #region Type casting operators
+        /// <summary>
+        /// Converts an 8-bit unsigned integer to a System.Half.
+        /// </summary>
+        /// <param name="value">An 8-bit unsigned integer.</param>
+        /// <returns>A System.Half that represents the converted 8-bit unsigned integer.</returns>
+        public static implicit operator Half(byte value) { return new Half((float)value); }
+        /// <summary>
+        /// Converts a 16-bit signed integer to a System.Half.
+        /// </summary>
+        /// <param name="value">A 16-bit signed integer.</param>
+        /// <returns>A System.Half that represents the converted 16-bit signed integer.</returns>
+        public static implicit operator Half(short value) { return new Half((float)value); }
+        /// <summary>
+        /// Converts a Unicode character to a System.Half.
+        /// </summary>
+        /// <param name="value">A Unicode character.</param>
+        /// <returns>A System.Half that represents the converted Unicode character.</returns>
+        public static implicit operator Half(char value) { return new Half((float)value); }
+        /// <summary>
+        /// Converts a 32-bit signed integer to a System.Half.
+        /// </summary>
+        /// <param name="value">A 32-bit signed integer.</param>
+        /// <returns>A System.Half that represents the converted 32-bit signed integer.</returns>
+        public static implicit operator Half(int value) { return new Half((float)value); }
+        /// <summary>
+        /// Converts a 64-bit signed integer to a System.Half.
+        /// </summary>
+        /// <param name="value">A 64-bit signed integer.</param>
+        /// <returns>A System.Half that represents the converted 64-bit signed integer.</returns>
+        public static implicit operator Half(long value) { return new Half((float)value); }
+        /// <summary>
+        /// Converts a single-precision floating-point number to a System.Half.
+        /// </summary>
+        /// <param name="value">A single-precision floating-point number.</param>
+        /// <returns>A System.Half that represents the converted single-precision floating point number.</returns>
+        public static explicit operator Half(float value) { return new Half(value); }
+        /// <summary>
+        /// Converts a double-precision floating-point number to a System.Half.
+        /// </summary>
+        /// <param name="value">A double-precision floating-point number.</param>
+        /// <returns>A System.Half that represents the converted double-precision floating point number.</returns>
+        public static explicit operator Half(double value) { return new Half((float)value); }
+        /// <summary>
+        /// Converts a decimal number to a System.Half.
+        /// </summary>
+        /// <param name="value">decimal number</param>
+        /// <returns>A System.Half that represents the converted decimal number.</returns>
+        public static explicit operator Half(decimal value) { return new Half((float)value); }
+        /// <summary>
+        /// Converts a System.Half to an 8-bit unsigned integer.
+        /// </summary>
+        /// <param name="value">A System.Half to convert.</param>
+        /// <returns>An 8-bit unsigned integer that represents the converted System.Half.</returns>
+        public static explicit operator byte (Half value) { return (byte)(float)value; }
+        /// <summary>
+        /// Converts a System.Half to a Unicode character.
+        /// </summary>
+        /// <param name="value">A System.Half to convert.</param>
+        /// <returns>A Unicode character that represents the converted System.Half.</returns>
+        public static explicit operator char (Half value) { return (char)(float)value; }
+        /// <summary>
+        /// Converts a System.Half to a 16-bit signed integer.
+        /// </summary>
+        /// <param name="value">A System.Half to convert.</param>
+        /// <returns>A 16-bit signed integer that represents the converted System.Half.</returns>
+        public static explicit operator short (Half value) { return (short)(float)value; }
+        /// <summary>
+        /// Converts a System.Half to a 32-bit signed integer.
+        /// </summary>
+        /// <param name="value">A System.Half to convert.</param>
+        /// <returns>A 32-bit signed integer that represents the converted System.Half.</returns>
+        public static explicit operator int (Half value) { return (int)(float)value; }
+        /// <summary>
+        /// Converts a System.Half to a 64-bit signed integer.
+        /// </summary>
+        /// <param name="value">A System.Half to convert.</param>
+        /// <returns>A 64-bit signed integer that represents the converted System.Half.</returns>
+        public static explicit operator long (Half value) { return (long)(float)value; }
+        /// <summary>
+        /// Converts a System.Half to a single-precision floating-point number.
+        /// </summary>
+        /// <param name="value">A System.Half to convert.</param>
+        /// <returns>A single-precision floating-point number that represents the converted System.Half.</returns>
+        public static implicit operator float (Half value) { return HalfHelper.HalfToSingle(value); }
+        /// <summary>
+        /// Converts a System.Half to a double-precision floating-point number.
+        /// </summary>
+        /// <param name="value">A System.Half to convert.</param>
+        /// <returns>A double-precision floating-point number that represents the converted System.Half.</returns>
+        public static implicit operator double (Half value) { return (float)value; }
+        /// <summary>
+        /// Converts a System.Half to a decimal number.
+        /// </summary>
+        /// <param name="value">A System.Half to convert.</param>
+        /// <returns>A decimal number that represents the converted System.Half.</returns>
+        public static explicit operator decimal (Half value) { return (decimal)(float)value; }
+        /// <summary>
+        /// Converts an 8-bit signed integer to a System.Half.
+        /// </summary>
+        /// <param name="value">An 8-bit signed integer.</param>
+        /// <returns>A System.Half that represents the converted 8-bit signed integer.</returns>
+        public static implicit operator Half(sbyte value) { return new Half((float)value); }
+        /// <summary>
+        /// Converts a 16-bit unsigned integer to a System.Half.
+        /// </summary>
+        /// <param name="value">A 16-bit unsigned integer.</param>
+        /// <returns>A System.Half that represents the converted 16-bit unsigned integer.</returns>
+        public static implicit operator Half(ushort value) { return new Half((float)value); }
+        /// <summary>
+        /// Converts a 32-bit unsigned integer to a System.Half.
+        /// </summary>
+        /// <param name="value">A 32-bit unsigned integer.</param>
+        /// <returns>A System.Half that represents the converted 32-bit unsigned integer.</returns>
+        public static implicit operator Half(uint value) { return new Half((float)value); }
+        /// <summary>
+        /// Converts a 64-bit unsigned integer to a System.Half.
+        /// </summary>
+        /// <param name="value">A 64-bit unsigned integer.</param>
+        /// <returns>A System.Half that represents the converted 64-bit unsigned integer.</returns>
+        public static implicit operator Half(ulong value) { return new Half((float)value); }
+        /// <summary>
+        /// Converts a System.Half to an 8-bit signed integer.
+        /// </summary>
+        /// <param name="value">A System.Half to convert.</param>
+        /// <returns>An 8-bit signed integer that represents the converted System.Half.</returns>
+        public static explicit operator sbyte (Half value) { return (sbyte)(float)value; }
+        /// <summary>
+        /// Converts a System.Half to a 16-bit unsigned integer.
+        /// </summary>
+        /// <param name="value">A System.Half to convert.</param>
+        /// <returns>A 16-bit unsigned integer that represents the converted System.Half.</returns>
+        public static explicit operator ushort (Half value) { return (ushort)(float)value; }
+        /// <summary>
+        /// Converts a System.Half to a 32-bit unsigned integer.
+        /// </summary>
+        /// <param name="value">A System.Half to convert.</param>
+        /// <returns>A 32-bit unsigned integer that represents the converted System.Half.</returns>
+        public static explicit operator uint (Half value) { return (uint)(float)value; }
+        /// <summary>
+        /// Converts a System.Half to a 64-bit unsigned integer.
+        /// </summary>
+        /// <param name="value">A System.Half to convert.</param>
+        /// <returns>A 64-bit unsigned integer that represents the converted System.Half.</returns>
+        public static explicit operator ulong (Half value) { return (ulong)(float)value; }
+        #endregion
+
+        /// <summary>
+        /// Compares this instance to a specified System.Half object.
+        /// </summary>
+        /// <param name="other">A System.Half object.</param>
+        /// <returns>
+        /// A signed number indicating the relative values of this instance and value.
+        /// Return Value Meaning Less than zero This instance is less than value. Zero
+        /// This instance is equal to value. Greater than zero This instance is greater than value.
+        /// </returns>
+        public int CompareTo(Half other)
+        {
+            int result = 0;
+            if (this < other)
+            {
+                result = -1;
+            }
+            else if (this > other)
+            {
+                result = 1;
+            }
+            else if (this != other)
+            {
+                if (!IsNaN(this))
+                {
+                    result = 1;
+                }
+                else if (!IsNaN(other))
+                {
+                    result = -1;
+                }
+            }
+
+            return result;
+        }
+        /// <summary>
+        /// Compares this instance to a specified System.Object.
+        /// </summary>
+        /// <param name="obj">An System.Object or null.</param>
+        /// <returns>
+        /// A signed number indicating the relative values of this instance and value.
+        /// Return Value Meaning Less than zero This instance is less than value. Zero
+        /// This instance is equal to value. Greater than zero This instance is greater
+        /// than value. -or- value is null.
+        /// </returns>
+        /// <exception cref="System.ArgumentException">value is not a System.Half</exception>
+        public int CompareTo(object obj)
+        {
+            int result = 0;
+            if (obj == null)
+            {
+                result = 1;
+            }
+            else
+            {
+                if (obj is Half)
+                {
+                    result = CompareTo((Half)obj);
+                }
+                else
+                {
+                    throw new ArgumentException("Object must be of type Half.");
+                }
+            }
+
+            return result;
+        }
+        /// <summary>
+        /// Returns a value indicating whether this instance and a specified System.Half object represent the same value.
+        /// </summary>
+        /// <param name="other">A System.Half object to compare to this instance.</param>
+        /// <returns>true if value is equal to this instance; otherwise, false.</returns>
+        public bool Equals(Half other)
+        {
+            return ((other == this) || (IsNaN(other) && IsNaN(this)));
+        }
+        /// <summary>
+        /// Returns a value indicating whether this instance and a specified System.Object
+        /// represent the same type and value.
+        /// </summary>
+        /// <param name="obj">An System.Object.</param>
+        /// <returns>true if value is a System.Half and equal to this instance; otherwise, false.</returns>
+        public override bool Equals(object obj)
+        {
+            bool result = false;
+            if (obj is Half)
+            {
+                Half half = (Half)obj;
+                if ((half == this) || (IsNaN(half) && IsNaN(this)))
+                {
+                    result = true;
+                }
+            }
+
+            return result;
+        }
+        /// <summary>
+        /// Returns the hash code for this instance.
+        /// </summary>
+        /// <returns>A 32-bit signed integer hash code.</returns>
+        public override int GetHashCode()
+        {
+            return Value.GetHashCode();
+        }
+        /// <summary>
+        /// Returns the System.TypeCode for value type System.Half.
+        /// </summary>
+        /// <returns>The enumerated constant (TypeCode)255.</returns>
+        public TypeCode GetTypeCode()
+        {
+            return (TypeCode)255;
+        }
+
+        #region BitConverter & Math methods for Half
+        /// <summary>
+        /// Returns the specified half-precision floating point value as an array of bytes.
+        /// </summary>
+        /// <param name="value">The number to convert.</param>
+        /// <returns>An array of bytes with length 2.</returns>
+        public static byte[] GetBytes(Half value)
+        {
+            return BitConverter.GetBytes(value.Value);
+        }
+        /// <summary>
+        /// Converts the value of a specified instance of System.Half to its equivalent binary representation.
+        /// </summary>
+        /// <param name="value">A System.Half value.</param>
+        /// <returns>A 16-bit unsigned integer that contain the binary representation of value.</returns>        
+        public static ushort GetBits(Half value)
+        {
+            return value.Value;
+        }
+        /// <summary>
+        /// Returns a half-precision floating point number converted from two bytes
+        /// at a specified position in a byte array.
+        /// </summary>
+        /// <param name="value">An array of bytes.</param>
+        /// <param name="startIndex">The starting position within value.</param>
+        /// <returns>A half-precision floating point number formed by two bytes beginning at startIndex.</returns>
+        /// <exception cref="System.ArgumentException">
+        /// startIndex is greater than or equal to the length of value minus 1, and is
+        /// less than or equal to the length of value minus 1.
+        /// </exception>
+        /// <exception cref="System.ArgumentNullException">value is null.</exception>
+        /// <exception cref="System.ArgumentOutOfRangeException">startIndex is less than zero or greater than the length of value minus 1.</exception>
+        public static Half ToHalf(byte[] value, int startIndex)
+        {
+            return ToHalf((ushort)BitConverter.ToInt16(value, startIndex));
+        }
+        /// <summary>
+        /// Returns a half-precision floating point number converted from its binary representation.
+        /// </summary>
+        /// <param name="bits">Binary representation of System.Half value</param>
+        /// <returns>A half-precision floating point number formed by its binary representation.</returns>
+        public static Half ToHalf(ushort bits)
+        {
+            return new Half { Value = bits };
+        }
+
+        /// <summary>
+        /// Returns a value indicating the sign of a half-precision floating-point number.
+        /// </summary>
+        /// <param name="value">A signed number.</param>
+        /// <returns>
+        /// A number indicating the sign of value. Number Description -1 value is less
+        /// than zero. 0 value is equal to zero. 1 value is greater than zero.
+        /// </returns>
+        /// <exception cref="System.ArithmeticException">value is equal to System.Half.NaN.</exception>
+        public static int Sign(Half value)
+        {
+            if (value < 0)
+            {
+                return -1;
+            }
+            else if (value > 0)
+            {
+                return 1;
+            }
+            else
+            {
+                if (value != 0)
+                {
+                    throw new ArithmeticException("Function does not accept floating point Not-a-Number values.");
+                }
+            }
+
+            return 0;
+        }
+        /// <summary>
+        /// Returns the absolute value of a half-precision floating-point number.
+        /// </summary>
+        /// <param name="value">A number in the range System.Half.MinValue ≤ value ≤ System.Half.MaxValue.</param>
+        /// <returns>A half-precision floating-point number, x, such that 0 ≤ x ≤System.Half.MaxValue.</returns>
+        public static Half Abs(Half value)
+        {
+            return HalfHelper.Abs(value);
+        }
+        /// <summary>
+        /// Returns the larger of two half-precision floating-point numbers.
+        /// </summary>
+        /// <param name="value1">The first of two half-precision floating-point numbers to compare.</param>
+        /// <param name="value2">The second of two half-precision floating-point numbers to compare.</param>
+        /// <returns>
+        /// Parameter value1 or value2, whichever is larger. If value1, or value2, or both val1
+        /// and value2 are equal to System.Half.NaN, System.Half.NaN is returned.
+        /// </returns>
+        public static Half Max(Half value1, Half value2)
+        {
+            return (value1 < value2) ? value2 : value1;
+        }
+        /// <summary>
+        /// Returns the smaller of two half-precision floating-point numbers.
+        /// </summary>
+        /// <param name="value1">The first of two half-precision floating-point numbers to compare.</param>
+        /// <param name="value2">The second of two half-precision floating-point numbers to compare.</param>
+        /// <returns>
+        /// Parameter value1 or value2, whichever is smaller. If value1, or value2, or both val1
+        /// and value2 are equal to System.Half.NaN, System.Half.NaN is returned.
+        /// </returns>
+        public static Half Min(Half value1, Half value2)
+        {
+            return (value1 < value2) ? value1 : value2;
+        }
+        #endregion
+
+        /// <summary>
+        /// Returns a value indicating whether the specified number evaluates to not a number (System.Half.NaN).
+        /// </summary>
+        /// <param name="half">A half-precision floating-point number.</param>
+        /// <returns>true if value evaluates to not a number (System.Half.NaN); otherwise, false.</returns>
+        public static bool IsNaN(Half half)
+        {
+            return HalfHelper.IsNaN(half);
+        }
+        /// <summary>
+        /// Returns a value indicating whether the specified number evaluates to negative or positive infinity.
+        /// </summary>
+        /// <param name="half">A half-precision floating-point number.</param>
+        /// <returns>true if half evaluates to System.Half.PositiveInfinity or System.Half.NegativeInfinity; otherwise, false.</returns>
+        public static bool IsInfinity(Half half)
+        {
+            return HalfHelper.IsInfinity(half);
+        }
+        /// <summary>
+        /// Returns a value indicating whether the specified number evaluates to negative infinity.
+        /// </summary>
+        /// <param name="half">A half-precision floating-point number.</param>
+        /// <returns>true if half evaluates to System.Half.NegativeInfinity; otherwise, false.</returns>
+        public static bool IsNegativeInfinity(Half half)
+        {
+            return HalfHelper.IsNegativeInfinity(half);
+        }
+        /// <summary>
+        /// Returns a value indicating whether the specified number evaluates to positive infinity.
+        /// </summary>
+        /// <param name="half">A half-precision floating-point number.</param>
+        /// <returns>true if half evaluates to System.Half.PositiveInfinity; otherwise, false.</returns>
+        public static bool IsPositiveInfinity(Half half)
+        {
+            return HalfHelper.IsPositiveInfinity(half);
+        }
+
+        #region String operations (Parse and ToString)
+        /// <summary>
+        /// Converts the string representation of a number to its System.Half equivalent.
+        /// </summary>
+        /// <param name="value">The string representation of the number to convert.</param>
+        /// <returns>The System.Half number equivalent to the number contained in value.</returns>
+        /// <exception cref="System.ArgumentNullException">value is null.</exception>
+        /// <exception cref="System.FormatException">value is not in the correct format.</exception>
+        /// <exception cref="System.OverflowException">value represents a number less than System.Half.MinValue or greater than System.Half.MaxValue.</exception>
+        public static Half Parse(string value)
+        {
+            return (Half)float.Parse(value, CultureInfo.InvariantCulture);
+        }
+        /// <summary>
+        /// Converts the string representation of a number to its System.Half equivalent 
+        /// using the specified culture-specific format information.
+        /// </summary>
+        /// <param name="value">The string representation of the number to convert.</param>
+        /// <param name="provider">An System.IFormatProvider that supplies culture-specific parsing information about value.</param>
+        /// <returns>The System.Half number equivalent to the number contained in s as specified by provider.</returns>
+        /// <exception cref="System.ArgumentNullException">value is null.</exception>
+        /// <exception cref="System.FormatException">value is not in the correct format.</exception>
+        /// <exception cref="System.OverflowException">value represents a number less than System.Half.MinValue or greater than System.Half.MaxValue.</exception>
+        public static Half Parse(string value, IFormatProvider provider)
+        {
+            return (Half)float.Parse(value, provider);
+        }
+        /// <summary>
+        /// Converts the string representation of a number in a specified style to its System.Half equivalent.
+        /// </summary>
+        /// <param name="value">The string representation of the number to convert.</param>
+        /// <param name="style">
+        /// A bitwise combination of System.Globalization.NumberStyles values that indicates
+        /// the style elements that can be present in value. A typical value to specify is
+        /// System.Globalization.NumberStyles.Number.
+        /// </param>
+        /// <returns>The System.Half number equivalent to the number contained in s as specified by style.</returns>
+        /// <exception cref="System.ArgumentNullException">value is null.</exception>
+        /// <exception cref="System.ArgumentException">
+        /// style is not a System.Globalization.NumberStyles value. -or- style is the
+        /// System.Globalization.NumberStyles.AllowHexSpecifier value.
+        /// </exception>
+        /// <exception cref="System.FormatException">value is not in the correct format.</exception>
+        /// <exception cref="System.OverflowException">value represents a number less than System.Half.MinValue or greater than System.Half.MaxValue.</exception>
+        public static Half Parse(string value, NumberStyles style)
+        {
+            return (Half)float.Parse(value, style, CultureInfo.InvariantCulture);
+        }
+        /// <summary>
+        /// Converts the string representation of a number to its System.Half equivalent 
+        /// using the specified style and culture-specific format.
+        /// </summary>
+        /// <param name="value">The string representation of the number to convert.</param>
+        /// <param name="style">
+        /// A bitwise combination of System.Globalization.NumberStyles values that indicates
+        /// the style elements that can be present in value. A typical value to specify is 
+        /// System.Globalization.NumberStyles.Number.
+        /// </param>
+        /// <param name="provider">An System.IFormatProvider object that supplies culture-specific information about the format of value.</param>
+        /// <returns>The System.Half number equivalent to the number contained in s as specified by style and provider.</returns>
+        /// <exception cref="System.ArgumentNullException">value is null.</exception>
+        /// <exception cref="System.ArgumentException">
+        /// style is not a System.Globalization.NumberStyles value. -or- style is the
+        /// System.Globalization.NumberStyles.AllowHexSpecifier value.
+        /// </exception>
+        /// <exception cref="System.FormatException">value is not in the correct format.</exception>
+        /// <exception cref="System.OverflowException">value represents a number less than System.Half.MinValue or greater than System.Half.MaxValue.</exception>
+        public static Half Parse(string value, NumberStyles style, IFormatProvider provider)
+        {
+            return (Half)float.Parse(value, style, provider);
+        }
+        /// <summary>
+        /// Converts the string representation of a number to its System.Half equivalent.
+        /// A return value indicates whether the conversion succeeded or failed.
+        /// </summary>
+        /// <param name="value">The string representation of the number to convert.</param>
+        /// <param name="result">
+        /// When this method returns, contains the System.Half number that is equivalent
+        /// to the numeric value contained in value, if the conversion succeeded, or is zero
+        /// if the conversion failed. The conversion fails if the s parameter is null,
+        /// is not a number in a valid format, or represents a number less than System.Half.MinValue
+        /// or greater than System.Half.MaxValue. This parameter is passed uninitialized.
+        /// </param>
+        /// <returns>true if s was converted successfully; otherwise, false.</returns>
+        public static bool TryParse(string value, out Half result)
+        {
+            float f;
+            if (float.TryParse(value, out f))
+            {
+                result = (Half)f;
+                return true;
+            }
+
+            result = new Half();
+            return false;
+        }
+        /// <summary>
+        /// Converts the string representation of a number to its System.Half equivalent
+        /// using the specified style and culture-specific format. A return value indicates
+        /// whether the conversion succeeded or failed.
+        /// </summary>
+        /// <param name="value">The string representation of the number to convert.</param>
+        /// <param name="style">
+        /// A bitwise combination of System.Globalization.NumberStyles values that indicates
+        /// the permitted format of value. A typical value to specify is System.Globalization.NumberStyles.Number.
+        /// </param>
+        /// <param name="provider">An System.IFormatProvider object that supplies culture-specific parsing information about value.</param>
+        /// <param name="result">
+        /// When this method returns, contains the System.Half number that is equivalent
+        /// to the numeric value contained in value, if the conversion succeeded, or is zero
+        /// if the conversion failed. The conversion fails if the s parameter is null,
+        /// is not in a format compliant with style, or represents a number less than
+        /// System.Half.MinValue or greater than System.Half.MaxValue. This parameter is passed uninitialized.
+        /// </param>
+        /// <returns>true if s was converted successfully; otherwise, false.</returns>
+        /// <exception cref="System.ArgumentException">
+        /// style is not a System.Globalization.NumberStyles value. -or- style 
+        /// is the System.Globalization.NumberStyles.AllowHexSpecifier value.
+        /// </exception>
+        public static bool TryParse(string value, NumberStyles style, IFormatProvider provider, out Half result)
+        {
+            bool parseResult = false;
+            float f;
+            if (float.TryParse(value, style, provider, out f))
+            {
+                result = (Half)f;
+                parseResult = true;
+            }
+            else
+            {
+                result = new Half();
+            }
+
+            return parseResult;
+        }
+        /// <summary>
+        /// Converts the numeric value of this instance to its equivalent string representation.
+        /// </summary>
+        /// <returns>A string that represents the value of this instance.</returns>
+        public override string ToString()
+        {
+            return ((float)this).ToString(CultureInfo.InvariantCulture);
+        }
+        /// <summary>
+        /// Converts the numeric value of this instance to its equivalent string representation
+        /// using the specified culture-specific format information.
+        /// </summary>
+        /// <param name="formatProvider">An System.IFormatProvider that supplies culture-specific formatting information.</param>
+        /// <returns>The string representation of the value of this instance as specified by provider.</returns>
+        public string ToString(IFormatProvider formatProvider)
+        {
+            return ((float)this).ToString(formatProvider);
+        }
+        /// <summary>
+        /// Converts the numeric value of this instance to its equivalent string representation, using the specified format.
+        /// </summary>
+        /// <param name="format">A numeric format string.</param>
+        /// <returns>The string representation of the value of this instance as specified by format.</returns>
+        public string ToString(string format)
+        {
+            return ((float)this).ToString(format, CultureInfo.InvariantCulture);
+        }
+        /// <summary>
+        /// Converts the numeric value of this instance to its equivalent string representation 
+        /// using the specified format and culture-specific format information.
+        /// </summary>
+        /// <param name="format">A numeric format string.</param>
+        /// <param name="formatProvider">An System.IFormatProvider that supplies culture-specific formatting information.</param>
+        /// <returns>The string representation of the value of this instance as specified by format and provider.</returns>
+        /// <exception cref="System.FormatException">format is invalid.</exception>
+        public string ToString(string format, IFormatProvider formatProvider)
+        {
+            return ((float)this).ToString(format, formatProvider);
+        }
+        #endregion
+
+        #region IConvertible Members
+        float IConvertible.ToSingle(IFormatProvider provider)
+        {
+            return this;
+        }
+        TypeCode IConvertible.GetTypeCode()
+        {
+            return GetTypeCode();
+        }
+        bool IConvertible.ToBoolean(IFormatProvider provider)
+        {
+            return Convert.ToBoolean(this);
+        }
+        byte IConvertible.ToByte(IFormatProvider provider)
+        {
+            return Convert.ToByte(this);
+        }
+        char IConvertible.ToChar(IFormatProvider provider)
+        {
+            throw new InvalidCastException(string.Format(CultureInfo.CurrentCulture, "Invalid cast from '{0}' to '{1}'.", "Half", "Char"));
+        }
+        DateTime IConvertible.ToDateTime(IFormatProvider provider)
+        {
+            throw new InvalidCastException(string.Format(CultureInfo.CurrentCulture, "Invalid cast from '{0}' to '{1}'.", "Half", "DateTime"));
+        }
+        decimal IConvertible.ToDecimal(IFormatProvider provider)
+        {
+            return Convert.ToDecimal(this);
+        }
+        double IConvertible.ToDouble(IFormatProvider provider)
+        {
+            return Convert.ToDouble(this);
+        }
+        short IConvertible.ToInt16(IFormatProvider provider)
+        {
+            return Convert.ToInt16(this);
+        }
+        int IConvertible.ToInt32(IFormatProvider provider)
+        {
+            return Convert.ToInt32(this);
+        }
+        long IConvertible.ToInt64(IFormatProvider provider)
+        {
+            return Convert.ToInt64(this);
+        }
+        sbyte IConvertible.ToSByte(IFormatProvider provider)
+        {
+            return Convert.ToSByte(this);
+        }
+        string IConvertible.ToString(IFormatProvider provider)
+        {
+            return Convert.ToString(this, CultureInfo.InvariantCulture);
+        }
+        object IConvertible.ToType(Type conversionType, IFormatProvider provider)
+        {
+            return (((float)this) as IConvertible).ToType(conversionType, provider);
+        }
+        ushort IConvertible.ToUInt16(IFormatProvider provider)
+        {
+            return Convert.ToUInt16(this);
+        }
+        uint IConvertible.ToUInt32(IFormatProvider provider)
+        {
+            return Convert.ToUInt32(this);
+        }
+        ulong IConvertible.ToUInt64(IFormatProvider provider)
+        {
+            return Convert.ToUInt64(this);
+        }
+        #endregion
+    }
+}
+
+/// ================ HalfHelper.cs ====================
+
+namespace SystemHalf
+{
+    /// <summary>
+    /// Helper class for Half conversions and some low level operations.
+    /// This class is internally used in the Half class.
+    /// </summary>
+    /// <remarks>
+    /// References:
+    ///     - Code retrieved from http://sourceforge.net/p/csharp-half/code/HEAD/tree/ on 2015-12-04
+    ///     - Fast Half Float Conversions, Jeroen van der Zijp, link: http://www.fox-toolkit.org/ftp/fasthalffloatconversion.pdf
+    /// </remarks>
+    internal static class HalfHelper
+    {
+        private static readonly uint[] MantissaTable = GenerateMantissaTable();
+        private static readonly uint[] ExponentTable = GenerateExponentTable();
+        private static readonly ushort[] OffsetTable = GenerateOffsetTable();
+        private static readonly ushort[] BaseTable = GenerateBaseTable();
+        private static readonly sbyte[] ShiftTable = GenerateShiftTable();
+
+        // Transforms the subnormal representation to a normalized one. 
+        private static uint ConvertMantissa(int i)
+        {
+            uint m = (uint)(i << 13); // Zero pad mantissa bits
+            uint e = 0; // Zero exponent
+
+            // While not normalized
+            while ((m & 0x00800000) == 0)
+            {
+                e -= 0x00800000; // Decrement exponent (1<<23)
+                m <<= 1; // Shift mantissa                
+            }
+            m &= unchecked((uint)~0x00800000); // Clear leading 1 bit
+            e += 0x38800000; // Adjust bias ((127-14)<<23)
+            return m | e; // Return combined number
+        }
+
+        private static uint[] GenerateMantissaTable()
+        {
+            uint[] mantissaTable = new uint[2048];
+            mantissaTable[0] = 0;
+            for (int i = 1; i < 1024; i++)
+            {
+                mantissaTable[i] = ConvertMantissa(i);
+            }
+            for (int i = 1024; i < 2048; i++)
+            {
+                mantissaTable[i] = (uint)(0x38000000 + ((i - 1024) << 13));
+            }
+
+            return mantissaTable;
+        }
+        private static uint[] GenerateExponentTable()
+        {
+            uint[] exponentTable = new uint[64];
+            exponentTable[0] = 0;
+            for (int i = 1; i < 31; i++)
+            {
+                exponentTable[i] = (uint)(i << 23);
+            }
+            exponentTable[31] = 0x47800000;
+            exponentTable[32] = 0x80000000;
+            for (int i = 33; i < 63; i++)
+            {
+                exponentTable[i] = (uint)(0x80000000 + ((i - 32) << 23));
+            }
+            exponentTable[63] = 0xc7800000;
+
+            return exponentTable;
+        }
+        private static ushort[] GenerateOffsetTable()
+        {
+            ushort[] offsetTable = new ushort[64];
+            offsetTable[0] = 0;
+            for (int i = 1; i < 32; i++)
+            {
+                offsetTable[i] = 1024;
+            }
+            offsetTable[32] = 0;
+            for (int i = 33; i < 64; i++)
+            {
+                offsetTable[i] = 1024;
+            }
+
+            return offsetTable;
+        }
+        private static ushort[] GenerateBaseTable()
+        {
+            ushort[] baseTable = new ushort[512];
+            for (int i = 0; i < 256; ++i)
+            {
+                sbyte e = (sbyte)(127 - i);
+                if (e > 24)
+                { // Very small numbers map to zero
+                    baseTable[i | 0x000] = 0x0000;
+                    baseTable[i | 0x100] = 0x8000;
+                }
+                else if (e > 14)
+                { // Small numbers map to denorms
+                    baseTable[i | 0x000] = (ushort)(0x0400 >> (18 + e));
+                    baseTable[i | 0x100] = (ushort)((0x0400 >> (18 + e)) | 0x8000);
+                }
+                else if (e >= -15)
+                { // Normal numbers just lose precision
+                    baseTable[i | 0x000] = (ushort)((15 - e) << 10);
+                    baseTable[i | 0x100] = (ushort)(((15 - e) << 10) | 0x8000);
+                }
+                else if (e > -128)
+                { // Large numbers map to Infinity
+                    baseTable[i | 0x000] = 0x7c00;
+                    baseTable[i | 0x100] = 0xfc00;
+                }
+                else
+                { // Infinity and NaN's stay Infinity and NaN's
+                    baseTable[i | 0x000] = 0x7c00;
+                    baseTable[i | 0x100] = 0xfc00;
+                }
+            }
+
+            return baseTable;
+        }
+        private static sbyte[] GenerateShiftTable()
+        {
+            sbyte[] shiftTable = new sbyte[512];
+            for (int i = 0; i < 256; ++i)
+            {
+                sbyte e = (sbyte)(127 - i);
+                if (e > 24)
+                { // Very small numbers map to zero
+                    shiftTable[i | 0x000] = 24;
+                    shiftTable[i | 0x100] = 24;
+                }
+                else if (e > 14)
+                { // Small numbers map to denorms
+                    shiftTable[i | 0x000] = (sbyte)(e - 1);
+                    shiftTable[i | 0x100] = (sbyte)(e - 1);
+                }
+                else if (e >= -15)
+                { // Normal numbers just lose precision
+                    shiftTable[i | 0x000] = 13;
+                    shiftTable[i | 0x100] = 13;
+                }
+                else if (e > -128)
+                { // Large numbers map to Infinity
+                    shiftTable[i | 0x000] = 24;
+                    shiftTable[i | 0x100] = 24;
+                }
+                else
+                { // Infinity and NaN's stay Infinity and NaN's
+                    shiftTable[i | 0x000] = 13;
+                    shiftTable[i | 0x100] = 13;
+                }
+            }
+
+            return shiftTable;
+        }
+
+        public static unsafe float HalfToSingle(Half half)
+        {
+            uint result = MantissaTable[OffsetTable[half.Value >> 10] + (half.Value & 0x3ff)] + ExponentTable[half.Value >> 10];
+            return *(float*)&result;
+        }
+        public static unsafe Half SingleToHalf(float single)
+        {
+            uint value = *(uint*)&single;
+
+            ushort result = (ushort)(BaseTable[(value >> 23) & 0x1ff] + ((value & 0x007fffff) >> ShiftTable[value >> 23]));
+            return Half.ToHalf(result);
+        }
+
+        public static Half Negate(Half half)
+        {
+            return Half.ToHalf((ushort)(half.Value ^ 0x8000));
+        }
+        public static Half Abs(Half half)
+        {
+            return Half.ToHalf((ushort)(half.Value & 0x7fff));
+        }
+
+        public static bool IsNaN(Half half)
+        {
+            return (half.Value & 0x7fff) > 0x7c00;
+        }
+        public static bool IsInfinity(Half half)
+        {
+            return (half.Value & 0x7fff) == 0x7c00;
+        }
+        public static bool IsPositiveInfinity(Half half)
+        {
+            return half.Value == 0x7c00;
+        }
+        public static bool IsNegativeInfinity(Half half)
+        {
+            return half.Value == 0xfc00;
+        }
+    }
+}
diff --git a/thirdparty/SystemHalf/Properties/AssemblyInfo.cs b/thirdparty/SystemHalf/Properties/AssemblyInfo.cs
new file mode 100644
index 0000000..bb0b747
--- /dev/null
+++ b/thirdparty/SystemHalf/Properties/AssemblyInfo.cs
@@ -0,0 +1,36 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("SystemHalf")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("SystemHalf")]
+[assembly: AssemblyCopyright("Copyright ©  2020")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible
+// to COM components.  If you need to access a type in this assembly from
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("8e79039e-85dd-4ed4-9c3c-2fb2d8cb8324")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]
diff --git a/thirdparty/SystemHalf/SystemHalf.csproj b/thirdparty/SystemHalf/SystemHalf.csproj
new file mode 100644
index 0000000..c1dc6fd
--- /dev/null
+++ b/thirdparty/SystemHalf/SystemHalf.csproj
@@ -0,0 +1,48 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{8E79039E-85DD-4ED4-9C3C-2FB2D8CB8324}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>SystemHalf</RootNamespace>
+    <AssemblyName>SystemHalf</AssemblyName>
+    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <Deterministic>true</Deterministic>
+    <NuGetPackageImportStamp>
+    </NuGetPackageImportStamp>
+    <TargetFrameworkProfile />
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="Microsoft.CSharp" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Half.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+</Project>
\ No newline at end of file
diff --git a/thirdparty/taoframework-2.1.0/Tao.DevIl.License.txt b/thirdparty/taoframework-2.1.0/Tao.DevIl.License.txt
new file mode 100644
index 0000000..8cce3b5
--- /dev/null
+++ b/thirdparty/taoframework-2.1.0/Tao.DevIl.License.txt
@@ -0,0 +1,22 @@
+MIT License
+Copyright ©2003-2006 Tao Framework Team
+http://www.taoframework.com
+All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/thirdparty/taoframework-2.1.0/bin/Tao.DevIl.dll b/thirdparty/taoframework-2.1.0/bin/Tao.DevIl.dll
new file mode 100644
index 0000000..32d624c
Binary files /dev/null and b/thirdparty/taoframework-2.1.0/bin/Tao.DevIl.dll differ
diff --git a/thirdparty/taoframework-2.1.0/lib/DevIL.dll b/thirdparty/taoframework-2.1.0/lib/DevIL.dll
new file mode 100644
index 0000000..3fbab0c
Binary files /dev/null and b/thirdparty/taoframework-2.1.0/lib/DevIL.dll differ