# struct Quat

Quaternions are efficient and robust mathematical objects for representing rotations! Understanding the details of how a quaternion works is not generally necessary for using them effectively, so don’t worry too much if they seem weird to you. They’re weird to me too.

If you’re interested in learning the details though, 3Blue1Brown and Ben Eater have an excellent interactive lesson about them!

## Instance Fields and Properties

Quat Inverse The reverse rotation! If this quat goes from A to B, the inverse will go from B to A.
Quat Normalized A normalized quaternion has the same orientation, and a length of 1.
Quaternion q The internal, wrapped System.Numerics type. This can be nice to have around so you can pass its fields as ‘ref’, which you can’t do with properties. You won’t often need this, as implicit conversions to System.Numerics types are also provided.
Vec4 Vec4 Sometimes you want to do weird stuff with your Quaternions. I won’t judge. This just turns the Quat into a Vec4, makes some types of math easier!
float w W component.
float x X component. Sometimes known as I.
float y Y component. Sometimes known as J.
float z Z component. Sometimes known as K.

## Instance Methods

Quat You may want to use static creation methods, like Quat.LookAt, or Quat.Identity instead of this one! Unless you know what you’re doing.
Invert Makes this Quat the reverse rotation! If this quat goes from A to B, the inverse will go from B to A.
Normalize A normalized quaternion has the same orientation, and a length of 1.
Relative Rotates a quaternion making it relative to another rotation while preserving it’s “Length”!
Rotate This rotates a point around the origin by the Quat.
ToString Mostly for debug purposes, this is a decent way to log or inspect the quaternion in debug mode. Looks like “[x, y, z, w]”

## Static Fields and Properties

Quat Identity This is the ‘multiply by one!’ of the quaternion rotation world. It’s basically a default, no rotation quaternion.

## Static Methods

Delta Creates a quaternion that goes from one rotation to another.
Difference This gives a relative rotation between the first and second quaternion rotations. Remember that order is important here!
FromAngles Creates a Roll/Pitch/Yaw rotation (applied in that order) from the provided angles in degrees!
LookAt Creates a rotation that describes looking from a point, to another point! This is a great function for camera style rotation, or other facing behavior when you know where an object is, and where you want it to look at. This rotation works best when applied to objects that face Vec3.Forward in their resting/model space pose.
LookDir Creates a rotation that describes looking towards a direction. This is great for quickly describing facing behavior! This rotation works best when applied to objects that face Vec3.Forward in their resting/model space pose.
Slerp Spherical Linear intERPolation. Interpolates between two quaternions! Both Quats should be normalized/unit quaternions, or you may get unexpected results.

## Operators

Implicit Conversions Allows implicit conversion from System.Numerics.Quaternion to StereoKit.Quat.
* This is the combination of rotations `a` and `b`. Note that order matters here.
- Gets a Quat representing the rotation from `a` to `b`.

## Examples

Quat.LookAt and LookDir are probably one of the easiest ways to work with quaternions in StereoKit! They’re handy functions to have a good understanding of. Here’s an example of how you might use them.

``````// Draw a box that always rotates to face the user
Vec3 boxPos = new Vec3(1,0,1);
Mesh.Cube.Draw(Material.Default, Matrix.TR(boxPos, boxRot));

// Make a Window that faces a user that enters the app looking
// Forward.
Pose winPose = new Pose(0,0,-0.5f, Quat.LookDir(0,0,1));
UI.WindowBegin("Posed Window", ref winPose);
UI.WindowEnd();

``````

Found an issue with these docs, or have some additional questions? Create an Issue on Github!