   SQT Quaternions
  Does anyone know some good resources on how to make/use combined rotation and translation quaternions?The book Game Engine Architecture calls them SQT transforms, but nothing really comes up when I search for this.   
  I don't know of any good resources, but I think it's a pretty simple idea: You are interested in representing affine transformations that preserve distances and orientation, which is to say a rotation followed by a translation. You can represent the rotation using a quaternion and the translation using a vector. So you can create a class SQT that contains just that, and you can do the usual operations with them: Apply the transformation to a point, apply it to a vector, compose with another SQT...Do you need help writing the basic code, or do you have any less trivial questions?   ;  You just store the three transformation individually in a class, e.g.struct SQT{float scale;Vector3 translation;Quaternion rotation;}The in order to transform a vector you apply it like this: v' = q * ( s * v ) * qc + t   // qc is the conjugate of q "Essential Math For Game Developers" handles this in large extent. I recommend this book quite often. You can also find a lot  of free stuff on the associated website.   ;  Oh, "scale". That's what the "S" was for!   ;You just store the three transformation individually in a class, e.g.struct SQT{float scale;Vector3 translation;Quaternion rotation;}The in order to transform a vector you apply it like this: v' = q * ( s * v ) * qc + t   // qc is the conjugate of q "Essential Math For Game Developers" handles this in large extent. I recommend this book quite often. You can also find a lot  of free stuff on the associated website.Ah ok, for some reason I was thinking it was a specific matrix, thanks for the help.;  Why not get rid of the scale parameter and just use a denormalized quaternion?  After all, s * (q * v * qc) = (sqrt(s) * q) * v * (sqrt(s) * qc).   ;  Because you probably don't want the sqrt() for every transformation   ;Because you probably don't want the sqrt() for every transformationNo, you are misunderstanding me.  What I am saying is that instead of storing a separate float for the scale, you precalculate that guy and store it inside the quaternion.  That way you don't have to do the extra 3 multiplies per vector.  The new class would work like this:struct SQTTransform{ Vec3  translation; Quat  q; float get_scale() const { return dot(q, q); } void set_scale(float s) { q *= sqrt(s); }};That way, you only need to deal with the square root once; which is whenever you are setting up the transformation.  Not when you are transforming the vectors.EDIT:  Changed the wording of the last sentence to make it clear that I am not talking about transforming vectors with the square root.   ;  That is exactly what I was thinking. You don't want any square root operation when you are transforming a vector.   ;  You would only pay the sqrt when you are setting up the transformation. The problem I see with the suggestion of incorporating the scale into the quaternion is that now you can't renormalize the quaternion after applying a rotation.I would get rid of the scale for different reasons: Perhaps people with more practical experience can let us know otherwise, but I don't think the scale functionality is all that useful. Most objects involved in a game rotate and translate all the time, but they usually don't shrink.[Edit: typo]   