Conjugate # function

function : Conjugate(q:Float[]) ~ Float[]

Parameters

Return

ConjugateInto # function

The opposite rotation, written into a buffer the caller owns. For a unit rotation this is also the inverse, which is why there is no separate Inverse: negating the vector part is correct and cheap, and an inverse that silently assumed unit length would be a trap.

function : ConjugateInto(out:Float[], q:Float[]) ~ Nil

Parameters

Dot # function

function : Dot(a:Float[], b:Float[]) ~ Float

Parameters

Return

FromAxisAngle # function

A rotation of 'angle' radians about an axis. The axis is normalised here, so it does not have to arrive that way -- passing (0, 2, 0) and (0, 1, 0) give the same rotation. A zero-length axis has no direction to turn about and yields identity rather than a quaternion full of NaN.

function : FromAxisAngle(x:Float, y:Float, z:Float, angle:Float) ~ Float[]

Parameters

Return

FromAxisAngleInto # function

Axis-angle, written into a buffer the caller owns.

function : FromAxisAngleInto(out:Float[], x:Float, y:Float, z:Float, angle:Float) ~ Nil

Parameters

FromEuler # function

The rotation Transform already means by (pitch, yaw, roll). Matches Matrix4->RotationYXZ exactly -- yaw, then pitch, then roll -- so converting a Transform's angles here and building a matrix from the result gives the same matrix Transform would have built itself. That equivalence is what makes it safe to move between the two.

function : FromEuler(yaw:Float, pitch:Float, roll:Float) ~ Float[]

Parameters

Return

FromEulerInto # function

Euler angles, written into a buffer the caller owns.

function : FromEulerInto(out:Float[], yaw:Float, pitch:Float, roll:Float) ~ Nil

Parameters

Identity # function

function : Identity() ~ Float[]

Return

IdentityInto # function

Identity, written into a buffer the caller owns.

function : IdentityInto(out:Float[]) ~ Nil

Parameters

Length # function

function : Length(q:Float[]) ~ Float

Parameters

Return

Multiply # function

Rotation product: rhs first, then lhs. The same argument order as Matrix4->Multiply, deliberately, so the two read alike at a call site.

function : Multiply(lhs:Float[], rhs:Float[]) ~ Float[]

Parameters

Return

MultiplyInto # function

Rotation product, written into a buffer the caller owns. Safe to alias: reads both inputs into locals before writing, so MultiplyInto(q, q, r) does what it looks like it does.

function : MultiplyInto(out:Float[], lhs:Float[], rhs:Float[]) ~ Nil

Parameters

NormalizeInto # function

Unit length, written into a buffer the caller owns. Repeatedly multiplying rotations accumulates floating-point drift, so anything doing that should normalise every so often. A zero-length input yields identity rather than NaN.

function : NormalizeInto(out:Float[], q:Float[]) ~ Nil

Parameters

Normalized # function

function : Normalized(q:Float[]) ~ Float[]

Parameters

Return

Rotate # function

Turn a vector by a rotation. Uses the expanded form rather than q * v * conjugate(q), which would need two quaternion products and a temporary.

function : Rotate(q:Float[], v:Vector3) ~ Vector3

Parameters

Return

Slerp # function

function : Slerp(a:Float[], b:Float[], t:Float) ~ Float[]

Parameters

Return

SlerpInto # function

Spherical linear interpolation: the shortest turn from 'a' to 'b'. This is the reason the class exists. It travels the short way round -- if the two are more than half a turn apart, 'b' is negated first, which is the same rotation reached the other way -- and it moves at a constant angular rate, so an object turning under it does not speed up in the middle. Falls back to a straight lerp when the two are very close, because the sine of a tiny angle divides badly.

function : SlerpInto(out:Float[], a:Float[], b:Float[], t:Float) ~ Nil

Parameters

ToMatrix # function

function : ToMatrix(q:Float[]) ~ Float[]

Parameters

Return

ToMatrixInto # function

The rotation as a 4x4 matrix, written into a buffer the caller owns. Column-major and right-handed, the same as everything Matrix4 produces, so the result can be multiplied straight into a model matrix.

function : ToMatrixInto(out:Float[], q:Float[]) ~ Nil

Parameters