zmath.quaternion

A Quaternion it's used to store a space orientation / rotation, and makes easy to interpolate rotations, at same time that avoid grimbal locks that have using Euler angles

  • Qua_f

    Declaration

    alias Qua_f = Quaternion!float.Quaternion;

    Alias of a Quaternion with floats

  • Qua_d

    Declaration

    alias Qua_d = Quaternion!double.Quaternion;

    Alias of a Quaternion with doubles

  • Qua_r

    Declaration

    alias Qua_r = Quaternion!real.Quaternion;

    Alias of a Quaternion with reals

  • Quaternion

    Declaration

    struct Quaternion(T = floatt) if (__traits(isFloating, T));

    Quaternion over a FloatPoint type,

    • dim

      Declaration

      static enum size_t dim;

      Quaternion Dimension

    • i

      Declaration

      T i;

      i complex component

    • j

      Declaration

      T j;

      j complex component

    • k

      Declaration

      T k;

      k complex component

    • w

      Declaration

      T w;

      w real component

    • x

      Declaration

      T x;

      alias of i component

    • y

      Declaration

      T y;

      alias of j component

    • z

      Declaration

      T z;

      alias of k component

    • this

      Declaration

      this(in T i, in T j, in T k, in T w);

      Build a new Quaternion from a set of initial values

      Parameters

      T i

      i imaginary component

      T j

      j imaginary component

      T k

      k imaginary component

      T w

      i real component

    • this

      Declaration

      this(in T[] xs);

      Build a new Quaternion from a array If no there values for j, and k, will be set to 0. w is set to 1

      Parameters

      T[] xs

      Array with coords

    • this

      Declaration

      pure @nogc this(in Vector!(T, 3) vec);

      Build a new Quaternion from a 3D Vector w will be set to 1

      Parameters

      Vector!(T, 3) vec

      Vector 3d

    • this

      Declaration

      pure @nogc this(in Vector!(T, 4) vec);

      Build a new Quaternion from a 4D Vector

      Parameters

      Vector!(T, 4) vec

      Vector 4d

    • this

      Declaration

      @nogc this(U)(Vector!(T, 3) v, U angle) if (is(U : real));

      Creates a Quaternion from a 3d Vector and angle

      Parameters

      Vector!(T, 3) v

      Rotation axis

      U angle

      Rotation angle in radians

      Return Value

      Quaternion that represents a rotation

    • this

      Declaration

      @nogc this(U)(U roll, U pitch, U yaw) if (__traits(isFloating, U));

      Creates a new Quaternion from Euler angles Params : roll = Rotation around X axis in radians (aka bank) pitch = Rotation around Y axis in radians (aka attitude) yaw = Rotation around Z axis in radians (aka heading)

      Return Value

      Quaternion that represents a rotation

    • opIndex

      Declaration

      const pure @nogc T opIndex(size_t i);

      Returns i coord of this vector

    • opIndexAssign

      Declaration

      @nogc void opIndexAssign(T c, size_t i);

      Assigns a value to a coord

    • length

      Declaration

      const pure @nogc @property T length();

      Returns the actual length of this quaternion

    • sq_length

      Declaration

      const pure @nogc @property T sq_length();

      Returns the actual squared length of this quaternion

    • opEquals

      Declaration

      const pure @nogc bool opEquals()(auto ref const Quaternion rhs);

      Define Equality

    • approxEqual

      Declaration

      const pure @nogc bool approxEqual()(auto ref const Quaternion rhs, T maxRelDiff = 0.01, T maxAbsDiff = 1e-05);

      Approximated equality with controlable precision

    • opUnary

      Declaration

      const pure @nogc Quaternion opUnary(string op)() if (op == "+" || op == "-");

      Define unary operators + and -

    • opBinary

      Declaration

      const pure @nogc Quaternion opBinary(string op)(auto ref const Quaternion rhs) if (op == "+" || op == "-");

      Define binary operator + and -

    • opBinary

      Declaration

      const pure @nogc Quaternion opBinary(string op)(in T rhs) if (op == "*");

      Define Scalar multiplication

    • opBinary

      Declaration

      const pure @nogc Quaternion opBinary(string op)(auto ref const Quaternion rhs) if (op == "*");

      Defines Hamilton product for Quaternions

      Parameters

      Quaternion rhs

      Quaternion at rigth of operation

      Return: Quaternion result of hamilton product of this and rhs (this rhs)

    • conj

      Declaration

      const pure @nogc Quaternion conj();

      Obtain conjugate of a Quaternion

    • isUnit

      Declaration

      const pure @nogc @property bool isUnit();

      It's a unitary Quaternion (length == 1)

    • normalize

      Declaration

      pure @nogc void normalize();

      Normalize this Quaternion

    • rotate

      Declaration

      const pure V rotate(V)(auto ref const V v) if (isVector!V && (V.dim >= 3));

      Apply a 3d rotation Quaternion over a 3d/4d Vector

    • toAxisAngle

      Declaration

      const pure @nogc Vector!(T, 3) toAxisAngle(out T angle);

      Calc the Axis and angle of rotation of this Quaternion

      Parameters

      T angle

      Set to angle of rotation

      Return Value

      Axis of rotation vector

    • toEuler

      Declaration

      const pure @nogc Vector!(T, 3) toEuler();

      Returns a Vector with euler's angles

      Return Value

      Vector with Euler angles of rotation in radians

      TODO: Improve using code from here to avoid requiring pre-normalize the quaternion http://www.euclideanspace.com/maths/geometry/rotations/conversions/quaternionToEuler/

    • opCast

      Declaration

      const pure @nogc Tout opCast(Tout)() if (isQuaternion!Tout);

      Casting for convert between Quaternions

    • opCast

      Declaration

      const pure @nogc Tout opCast(Tout)() if (isMatrix!Tout && (Tout.dim >= 3));

      Casting to rotation Matrix

    • toString

      Declaration

      string toString();

      Returns a string representation of this Quaternion

  • isQuaternion

    Declaration

    immutable bool isQuaternion(T);

    Say if a thing it's a Quaternion