Xune/UIX.RenderApi.Skia/Microsoft/Iris/Render/Quaternion.cs

// Decompiled with JetBrains decompiler
// Type: Microsoft.Iris.Render.Quaternion
// Assembly: UIX.RenderApi, Version=4.8.0.0, Culture=neutral, PublicKeyToken=ddd0da4d3e678217
// MVID: D47658B8-A8EA-43D6-8837-ECE823BFFFC1
// Assembly location: C:\Program Files\Zune\UIX.RenderApi.dll

using Microsoft.Iris.Render.Internal;
using System;
using System.Runtime.InteropServices;

namespace Microsoft.Iris.Render
{
  [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
  public struct Quaternion
  {
    private float m_x;
    private float m_y;
    private float m_z;
    private float m_w;
    public static readonly Quaternion Identity = new Quaternion(0.0f, 0.0f, 0.0f, 1f);

    public Quaternion(float x, float y, float z, float w)
    {
      this.m_x = x;
      this.m_y = y;
      this.m_z = z;
      this.m_w = w;
    }

    public Quaternion(Vector3 vAxis, float flAngle)
    {
      vAxis.Normalize();
      float num1 = (float) Math.Sin(0.5 * (double) flAngle);
      float num2 = (float) Math.Cos(0.5 * (double) flAngle);
      this.m_x = vAxis.X * num1;
      this.m_y = vAxis.Y * num1;
      this.m_z = vAxis.Z * num1;
      this.m_w = num2;
    }

    public Quaternion(AxisAngle axisAngle)
      : this(axisAngle.Axis, axisAngle.Angle)
    {
    }

    public float X
    {
      get => this.m_x;
      set => this.m_x = value;
    }

    public float Y
    {
      get => this.m_y;
      set => this.m_y = value;
    }

    public float Z
    {
      get => this.m_z;
      set => this.m_z = value;
    }

    public float W
    {
      get => this.m_w;
      set => this.m_w = value;
    }

    public bool IsIdentity => object.Equals((object) this, (object) Quaternion.Identity);

    public static Quaternion operator *(Quaternion q1, Quaternion q2) => new Quaternion()
    {
      m_x = (float) ((double) q2.m_w * (double) q1.m_x + (double) q2.m_x * (double) q1.m_w + (double) q2.m_y * (double) q1.m_z - (double) q2.m_z * (double) q1.m_y),
      m_y = (float) ((double) q2.m_w * (double) q1.m_y - (double) q2.m_x * (double) q1.m_z + (double) q2.m_y * (double) q1.m_w + (double) q2.m_z * (double) q1.m_x),
      m_z = (float) ((double) q2.m_w * (double) q1.m_z + (double) q2.m_x * (double) q1.m_y - (double) q2.m_y * (double) q1.m_x + (double) q2.m_z * (double) q1.m_w),
      m_w = (float) ((double) q2.m_w * (double) q1.m_w - (double) q2.m_x * (double) q1.m_x - (double) q2.m_y * (double) q1.m_y - (double) q2.m_z * (double) q1.m_z)
    };

    public static Quaternion Multiply(Quaternion qLeft, Quaternion qRight) => qLeft * qRight;

    public override bool Equals(object obj) => obj is Quaternion quaternion && this == quaternion;

    public static bool operator ==(Quaternion left, Quaternion right) => Math2.WithinEpsilon(left.X, right.X) && Math2.WithinEpsilon(left.Y, right.Y) && Math2.WithinEpsilon(left.Z, right.Z) && Math2.WithinEpsilon(left.W, right.W);

    public static bool operator !=(Quaternion left, Quaternion right) => !(left == right);

    public AxisAngle ToAxisAngle()
    {
      this.Normalize();
      Vector3 vAxis;
      float flAngle;
      this.ToAxisAngle(out vAxis, out flAngle);
      return vAxis.IsApproximate(Vector3.Zero) ? AxisAngle.Identity : new AxisAngle(vAxis, flAngle);
    }

    internal void Normalize()
    {
      float flValue1 = (float) ((double) this.m_x * (double) this.m_x + (double) this.m_y * (double) this.m_y + (double) this.m_z * (double) this.m_z + (double) this.m_w * (double) this.m_w);
      if (Math2.WithinEpsilon(flValue1, 1f))
        return;
      if ((double) flValue1 > 1.40129846432482E-45)
      {
        float num = (float) Math.Sqrt((double) flValue1);
        this.m_x /= num;
        this.m_y /= num;
        this.m_z /= num;
        this.m_w /= num;
      }
      else
      {
        this.m_x = 0.0f;
        this.m_y = 0.0f;
        this.m_z = 0.0f;
        this.m_w = 0.0f;
      }
    }

    public override int GetHashCode() => this.X.GetHashCode() ^ this.Y.GetHashCode() ^ this.Z.GetHashCode() ^ this.W.GetHashCode();

    public override string ToString() => base.ToString();

    public void ToAxisAngle(out Vector3 vAxis, out float flAngle)
    {
      vAxis = new Vector3(this.m_x, this.m_y, this.m_z);
      flAngle = (float) (2.0 * Math.Acos((double) this.m_w));
    }

    public bool IsApproximate(Quaternion q) => Math2.WithinEpsilon(this.m_x, q.m_x) && Math2.WithinEpsilon(this.m_y, q.m_y) && Math2.WithinEpsilon(this.m_z, q.m_z) && Math2.WithinEpsilon(this.m_w, q.m_w);
  }
}