Record TQuaternion

Quaternion representing "no rotation". Note: this is not a quaternion filled with zeros (the Data.Real component is 1.0), instead this is a unit quaternion that correctly represents "rotation by zero degrees/radians".

Calculate axis (will be normalized) and angle (will be in radians) of rotation encoded in unit quaternion Q. This is the reverse of QuatFromAxisAngle.

Convert quaternion to a rotation axis and angle encoded in 4D vector. Axis is normalized if quaternion was also normalized (which is true if working with rotation quaternions). Angle is in radians.

Calculate matrix doing rotation described by unit quaternion.

Rotate a point, treating this quaternion as a representation of 3D rotation. For this operation to make sense in 3D, this must be a "unit" quaternion (which is created by a function like QuatFromAxisAngle).

You can pass here TVector4, which is then understood to be a 3D position in homogeneous coordinates.

Quaternion conjugation. This is just a fancy name for negating Data.Vector.

Warning: this symbol is deprecated: use Q := Q.Conjugate

Make the quaternion normalized.

Warning: this symbol is deprecated: use Q := Q.Normalize

Perform normalization but only if the quaternion is detected to be "significantly unnormalized". It checks if the quaternion needs normalization using fast VectorLenSqr, that is quaternion length is not needed for the check (sqrt not needed). Only if it's significantly different that 1.0, sqrt is done and quaternion is normalized.

This may be useful if you fear of eventual errors because of floating-point error cumulations, e.g. when you repeatedly multiply one quaternion by another, and yet another, and yet another etc. Calling this will trigger normalization from time to time (although will tolerate very small, epsilon-like, differences that are normal). Thus it prevents the quaternion from getting "too unnormalized".

Generally, this is not needed, as quaternions are nicely numerically stable (which means that quaternion "very slightly unnormalized" will only generate "very slightly wrong" results, so it's not that bad). And no, I didn't actually observe the need for this in my programs. But you can see it actually called when you use TMatrixExaminer and deliberately cause spinning by very very large value (e.g. run view3dscene and press and hold right key, this will cause model spinning very fast, which causes quat multiplication every frame). So possibly this would trigger incorrect quaternions at some point.

Anyway, this remains mostly a paranoid correctness measure.

Warning: this symbol is deprecated: use LazyNormalizeMe

Multiply two quaternions.

Geometric interpretation: If these are unit quaternions representing rotations, multiplying them calculates one rotation that has the same effect as rotating by Q2 and then by Q1.

Normal of result is equal to norm of Q1 * norm of Q2 (in particular, multiplying unit quaternions (used for rotations) yields another unit quaternion for sure).