QuatE | Pytorch implementation of Quaternion Knowledge Graph | Machine Learning library

Some of the more practical ways of clamping a quaternion can easily done once it is broken down to angle/axis form, then clamping those as desired:

I found the answer thanks to @Sleepyhead on discord. It's close to the Unity code but 3 lines because you can't read and update on the same line.

Bevy only has transform.forward() (suggested by @Sleepyhead) which goes into the Z direction: https://docs.rs/bevy/0.4.0/bevy/prelude/struct.Transform.html#method.forward

While calculating the front vector, you are applying the orientation to the z axis. The bold part is the vector that is being rotated:

qlm::quat(0, 0, 0, 1)

So, to find any other vector like right, left, bottom or top, you just need to rotate the correct axis. Try changing this quaternion to some of the following, and pick the ones you need:

qlm::quat(0, 1, 0, 0)

qlm::quat(0, 0, 1, 0)

qlm::quat(0, -1, 0, 0)

qlm::quat(0, 0, -1, 0)

My guess is that y axis is the up direction, so I would try 0, 1, 0 first.

Once you have the up vector, you can also calculate the right vector using a cross-product (or vice versa):

Nice description of usage of equation rotation about axis set as quaterion can be found here:
http://wiki.alioth.net/index.php/Quaternion

quote

The nature of unit quaternions and the way they map to 3D rotations means they can describe each 3D rotation value in two ways - as q(r, v') and as q(-r, -v') (imagine them as axis-angle rotations - inverting both the axis and the angle leads to the same 3D rotation).

Quaternions are actually points on a 4D unit spherical surface, and these two values represent anti-podal points on that sphere.

For a slerp (or nlerp) of two quaternions to follow the shortest path, the corresponding 4D points have to lie on the same hemisphere of the 4D sphere (this is also the reason why a weighted average of more than 2 quaternions doesn't have a unique solution). This maps to a non-negative dot product, and is usually something tested for in the interpolation code.

Simply negating one of the source quaternions will give you a point "on the opposite side of the 4D sphere", and lead to interpolation "the long way around" (and explains why negating the interpolation parameter leads to the same result).

You can apply the following code to get the specific joint and then apply the quaternion as so:

One "fast" way to do the rotation calculation itself would be to turn your quaternion into a 3x3 direction cosine matrix, have your vectors in a single 3xN contiguous matrix, and then call a BLAS library routine (e.g., dgemm) to do a standard matrix multiply. A good BLAS library with large N would do this calculation multi-threaded.

You are asking GLM to create a quaternion that will make the Z direction (0, -1, 0) (the direction vector) and the Y direction also (0, 1, 0) (the up vector).

This is impossible. No amount of rotation will make the Y and Z axes point in opposite directions from each other. You need to specify a different up vector.

Note that the up vector doesn't have to be perpendicular to the direction vector, because GLM will ignore the part that isn't perpendicular. But it has to be at least a little bit perpendicular.

That first link looks like it is a "scalar first" convention (i.e., w is the first element). So you should be looking at the cos(phi/2)*cos(psi/2) term for the angle. Then everything works out for you as expected when phi=0 and when psi=0.

angle = 2 * cos^-1(w) = 2 * cos^-1( cos(phi/2)cos(psi/2) )