mirror of
https://github.com/aharabada/glitchy-engine-beef.git
synced 2026-09-05 13:01:52 +00:00
285 lines
11 KiB
C#
285 lines
11 KiB
C#
// using System;
|
|
// using System.Runtime.CompilerServices;
|
|
//
|
|
// namespace GlitchyEngine.Math;
|
|
//
|
|
// /// <summary>
|
|
// /// Represents a 16-bit (half-precision) floating point number. (aka. IEEE 754 half-precision binary floating-point (binary16))
|
|
// /// </summary>
|
|
// /// <remarks>
|
|
// /// Even though it is possible, it's not recommended to perform large calculations using this type directly because most operators will simply cast the operands to <see cref="float"/> and cast the result back to <see cref="Half"/>.
|
|
// /// If you need to do larger calculations consider casting to <see cref="float"/> once and cast the result back to <see cref="Half"/> afterwards. This will not only have better performance, but will also increase the accuracy of the result.
|
|
// /// </remarks>
|
|
// public struct Half : IComparable , IComparable<Half>, IConvertible, IEquatable<Half>, IFormattable
|
|
// {
|
|
// public static readonly Half MinValue = new(-65504); // Should be 0xFBFF
|
|
// public static readonly Half MaxValue = new(65504); // Should be 0x7BFF
|
|
//
|
|
// // The numbers for Infinity, NaN and Zero need to be hardcoded as binaries,
|
|
// // because the conversion itself relies on them.
|
|
//
|
|
// public static readonly Half PositiveInfinity = new(0x7C00);
|
|
// public static readonly Half NegativeInfinity = new(0xFC00);
|
|
// public static readonly Half NaN = new(0x7CFF);
|
|
//
|
|
// public static readonly Half Zero = new(0x0000);
|
|
// public static readonly Half NegativeZero = new(0x8000);
|
|
//
|
|
// private ushort _data;
|
|
//
|
|
// public bool IsNegative => IsNegative_Impl(this);
|
|
//
|
|
// public bool IsFinite => IsFinite_Impl(this);
|
|
// public bool IsInfinity => IsInfinity_Impl(this);
|
|
// public bool IsPositiveInfinity => _data == PositiveInfinity._data;
|
|
// public bool IsNegativeInfinity => _data == NegativeInfinity._data;
|
|
// public bool IsNaN => IsNan_Impl(this);
|
|
//
|
|
// public bool IsSubnormal => IsSubnormal_Impl(this);
|
|
//
|
|
// public Half(float value)
|
|
// {
|
|
// FromFloat32(value, out Half halfValue);
|
|
// this = halfValue;
|
|
// }
|
|
//
|
|
// private Half(ushort data)
|
|
// {
|
|
// _data = data;
|
|
// }
|
|
//
|
|
// public static explicit operator float(Half value)
|
|
// {
|
|
// ToFloat32(value, out float floatValue);
|
|
// return floatValue;
|
|
// }
|
|
//
|
|
// public static explicit operator Half(float value)
|
|
// {
|
|
// FromFloat32(value, out Half halfValue);
|
|
// return halfValue;
|
|
// }
|
|
//
|
|
// /// <summary>Converts the numeric value of this instance to its equivalent string representation.</summary>
|
|
// /// <returns>The string representation of the value of this instance.</returns>
|
|
// public override string ToString() => ((float)this).ToString();
|
|
//
|
|
// public int CompareTo(object obj)
|
|
// {
|
|
// if (obj == null)
|
|
// return 1;
|
|
//
|
|
// if (obj is not Half value)
|
|
// throw new ArgumentException($"Object must be of type {typeof(Half)}");
|
|
//
|
|
// return CompareTo(value);
|
|
// }
|
|
//
|
|
// public int CompareTo(Half other)
|
|
// {
|
|
// return ((float)this).CompareTo((float)other);
|
|
// }
|
|
//
|
|
// public TypeCode GetTypeCode() => TypeCode.Object;
|
|
//
|
|
// public bool ToBoolean(IFormatProvider provider) => Convert.ToBoolean((float)this, provider);
|
|
//
|
|
// public byte ToByte(IFormatProvider provider) => Convert.ToByte((float)this, provider);
|
|
//
|
|
// public char ToChar(IFormatProvider provider) => Convert.ToChar((float)this, provider);
|
|
//
|
|
// public DateTime ToDateTime(IFormatProvider provider) => Convert.ToDateTime((float)this, provider);
|
|
//
|
|
// public decimal ToDecimal(IFormatProvider provider) => Convert.ToDecimal((float)this, provider);
|
|
//
|
|
// public double ToDouble(IFormatProvider provider) => Convert.ToDouble((float)this, provider);
|
|
//
|
|
// public short ToInt16(IFormatProvider provider) => Convert.ToInt16((float)this, provider);
|
|
//
|
|
// public int ToInt32(IFormatProvider provider) => Convert.ToInt32((float)this, provider);
|
|
//
|
|
// public long ToInt64(IFormatProvider provider) => Convert.ToInt64((float)this, provider);
|
|
//
|
|
// public sbyte ToSByte(IFormatProvider provider) => Convert.ToSByte((float)this, provider);
|
|
//
|
|
// public float ToSingle(IFormatProvider provider) => Convert.ToSingle((float)this, provider);
|
|
//
|
|
// /// <summary>Converts the numeric value of this instance to its equivalent string representation using the specified culture-specific format information.</summary>
|
|
// /// <param name="provider">An object that supplies culture-specific formatting information.</param>
|
|
// /// <returns>The string representation of the value of this instance as specified by <paramref name="provider">provider</paramref>.</returns>
|
|
// public string ToString(IFormatProvider provider) => ((float)this).ToString(provider);
|
|
//
|
|
// /// <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 <paramref name="format">format</paramref>.</returns>
|
|
// /// <exception cref="T:System.FormatException"><paramref name="format">format</paramref> is invalid.</exception>
|
|
// public string ToString(string format) => ((float)this).ToString(format);
|
|
//
|
|
// /// <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="provider">An object that supplies culture-specific formatting information.</param>
|
|
// /// <returns>The string representation of the value of this instance as specified by <paramref name="format">format</paramref> and <paramref name="provider">provider</paramref>.</returns>
|
|
// public string ToString(string format, IFormatProvider provider) => ((float)this).ToString(format, provider);
|
|
//
|
|
// public object ToType(Type conversionType, IFormatProvider provider) => ((IConvertible)(float)this).ToType(conversionType, provider);
|
|
//
|
|
// public ushort ToUInt16(IFormatProvider provider) => Convert.ToUInt16((float)this, provider);
|
|
//
|
|
// public uint ToUInt32(IFormatProvider provider) => Convert.ToUInt32((float)this, provider);
|
|
//
|
|
// public ulong ToUInt64(IFormatProvider provider) => Convert.ToUInt64((float)this, provider);
|
|
//
|
|
// public bool Equals(Half other)
|
|
// {
|
|
// return _data == other._data;
|
|
// }
|
|
//
|
|
// public override bool Equals(object obj)
|
|
// {
|
|
// return obj is Half other && Equals(other);
|
|
// }
|
|
//
|
|
// public override int GetHashCode()
|
|
// {
|
|
// return _data.GetHashCode();
|
|
// }
|
|
//
|
|
// #region Operators
|
|
//
|
|
// public static bool operator ==(Half left, Half right) => left._data == right._data;
|
|
//
|
|
// public static bool operator !=(Half left, Half right) => left._data != right._data;
|
|
//
|
|
// public static bool operator <(Half left, Half right)
|
|
// {
|
|
// LessThan_Impl(left, right, out bool result);
|
|
// return result;
|
|
// }
|
|
//
|
|
// public static bool operator <=(Half left, Half right)
|
|
// {
|
|
// LessThanOrEqual_Impl(left, right, out bool result);
|
|
// return result;
|
|
// }
|
|
// public static bool operator >(Half left, Half right)
|
|
// {
|
|
// GreaterThan_Impl(left, right, out bool result);
|
|
// return result;
|
|
// }
|
|
//
|
|
// public static bool operator >=(Half left, Half right)
|
|
// {
|
|
// GreaterThanOrEqual_Impl(left, right, out bool result);
|
|
// return result;
|
|
// }
|
|
//
|
|
// public static Half operator +(Half value) => value;
|
|
//
|
|
// public static Half operator -(Half value)
|
|
// {
|
|
// Negate_Impl(value, out Half result);
|
|
// return result;
|
|
// }
|
|
//
|
|
// public static Half operator +(Half left, Half right)
|
|
// {
|
|
// Add_Impl(left, right, out Half result);
|
|
// return result;
|
|
// }
|
|
//
|
|
// public static Half operator -(Half left, Half right)
|
|
// {
|
|
// Subtract_Impl(left, right, out Half result);
|
|
// return result;
|
|
// }
|
|
//
|
|
// public static Half operator *(Half left, Half right)
|
|
// {
|
|
// Multiply_Impl(left, right, out Half result);
|
|
// return result;
|
|
// }
|
|
//
|
|
// public static Half operator /(Half left, Half right)
|
|
// {
|
|
// Divide_Impl(left, right, out Half result);
|
|
// return result;
|
|
// }
|
|
//
|
|
// public static Half operator %(Half left, Half right)
|
|
// {
|
|
// Modulo_Impl(left, right, out Half result);
|
|
// return result;
|
|
// }
|
|
//
|
|
// public static Half operator ++(Half value)
|
|
// {
|
|
// Increment_Impl(value, out Half result);
|
|
// return result;
|
|
// }
|
|
//
|
|
// public static Half operator --(Half value)
|
|
// {
|
|
// Decrement_Impl(value, out Half result);
|
|
// return result;
|
|
// }
|
|
//
|
|
// [MethodImpl(MethodImplOptions.InternalCall)]
|
|
// private static extern void LessThan_Impl(Half left, Half right, out bool result);
|
|
// [MethodImpl(MethodImplOptions.InternalCall)]
|
|
// private static extern void LessThanOrEqual_Impl(Half left, Half right, out bool result);
|
|
// [MethodImpl(MethodImplOptions.InternalCall)]
|
|
// private static extern void GreaterThan_Impl(Half left, Half right, out bool result);
|
|
// [MethodImpl(MethodImplOptions.InternalCall)]
|
|
// private static extern void GreaterThanOrEqual_Impl(Half left, Half right, out bool result);
|
|
//
|
|
// // Externe Methoden hier als Platzhalter
|
|
// [MethodImpl(MethodImplOptions.InternalCall)]
|
|
// private static extern void Add_Impl(Half left, Half right, out Half result);
|
|
//
|
|
// [MethodImpl(MethodImplOptions.InternalCall)]
|
|
// private static extern void Subtract_Impl(Half left, Half right, out Half result);
|
|
//
|
|
// [MethodImpl(MethodImplOptions.InternalCall)]
|
|
// private static extern void Multiply_Impl(Half left, Half right, out Half result);
|
|
//
|
|
// [MethodImpl(MethodImplOptions.InternalCall)]
|
|
// private static extern void Divide_Impl(Half left, Half right, out Half result);
|
|
//
|
|
// [MethodImpl(MethodImplOptions.InternalCall)]
|
|
// private static extern void Modulo_Impl(Half left, Half right, out Half result);
|
|
//
|
|
// [MethodImpl(MethodImplOptions.InternalCall)]
|
|
// private static extern void Negate_Impl(Half value, out Half result);
|
|
//
|
|
// [MethodImpl(MethodImplOptions.InternalCall)]
|
|
// private static extern void Increment_Impl(Half value, out Half result);
|
|
//
|
|
// [MethodImpl(MethodImplOptions.InternalCall)]
|
|
// private static extern void Decrement_Impl(Half value, out Half result);
|
|
//
|
|
// #endregion
|
|
//
|
|
// #region Bindings
|
|
//
|
|
// [MethodImpl(MethodImplOptions.InternalCall)]
|
|
// private static extern void FromFloat32(float value, out Half halfValue);
|
|
//
|
|
// [MethodImpl(MethodImplOptions.InternalCall)]
|
|
// private static extern void ToFloat32(Half value, out float floatValue);
|
|
//
|
|
// [MethodImpl(MethodImplOptions.InternalCall)]
|
|
// private static extern bool IsNegative_Impl(Half self);
|
|
//
|
|
// [MethodImpl(MethodImplOptions.InternalCall)]
|
|
// private static extern bool IsFinite_Impl(Half self);
|
|
// [MethodImpl(MethodImplOptions.InternalCall)]
|
|
// private static extern bool IsInfinity_Impl(Half self);
|
|
//
|
|
// [MethodImpl(MethodImplOptions.InternalCall)]
|
|
// private static extern bool IsNan_Impl(Half self);
|
|
// [MethodImpl(MethodImplOptions.InternalCall)]
|
|
// private static extern bool IsSubnormal_Impl(Half self);
|
|
//
|
|
// #endregion
|
|
// }
|