I am reading and trying to better understand transformation in 3d space. Just curious to know if it would be better on performance Multiply scaling , rotation, and translation first before multiplying by the vertices of an object. Also, I would like to know if video games usually cache a full rotation for better performance.

I am not sure if I was clear, I meant, if it would be better to multiply the rotation, translation, scaling matrices together before multiplying an objects vertices.

Lets say you have m many matrices and n many vertices, and the costs for a 4D matrix - vector product is C. A 4D matrix - matrix multiplication needs 4 times as many operations as a 4D matrix - vector product needs. So you have to compare
4 C ( m - 1 ) + C n ~ ( C n ) m
where C can be eliminated
4 m + n - 4 ~ n m
Checking m==1 gives n ~ n what seems okay.

Now, for m==2 you get 4 ~ n so that already 5 vertices are sufficient to let the costs of the non-composed method exceed those of the composed method in that case.

Collecting m on the left and n on the right gives you
4 ( m - 1 ) ~ n ( m - 1 ) == 4 ~ n
so that the relation is independent on m.

So, for any non-trivial case, composing transformations is better than applying the matrices one-by-one.

Quote:
Ok, if I'm reading that right, you're saying that Matrix-Matrix multiplication is four times slower than Matrix-Vector multiplication, so it's better to do Matrix-Matrix multiplication than Matrix-Vector multiplication?

He's saying that multiplying a 4x4 and a 4x4 matrix takes more operations than multiplying 1x4 and 4x4 (or 4x4 and 4x1).

Quote:
so it's better to do Matrix-Matrix multiplication than Matrix-Vector multiplication?

No, some times you don't have choice. However, if you do have a choice between doing three matrix-matrix multiplications plus one matrix-vector multiplication per iteration of some loop (such as one over all objects in your scene) or doing those three matrix-matrix out of the loop and doing them once, thus only performing a matrix-vector operation in the loop, then that is obviously vastly more efficient.

In practice of course, the world transform of every object differs and you can't pull all three matrix-matrix operations out in general. But you can still pull two of them out for improved efficiently.

He's saying that concatenating transforms together is generally more optimal. In fact, the earlier you can do so during scene processing, the better.

Quote:
Also, I would like to know if video games usually cache a full rotation for better performance.

That depends very much on the game and what, precisely, you mean by 'cache.' It is almost never the case that the results of applying a transformation to vertices are cached, for example, as that is useless and inefficient. Similarly, base transformation properties (translation, rotation, scale) are usually not stored as matrices but rather turned into matrices as late as possible. This is more efficient in space -- although these days that matters much less, but then again most of the performance impacts of this discussion will be trivial -- but more importantly prevents you from accumulating floating point error bias into your transformation, which can result in undesired scaling or squishing of geometry transformed by said matrix.

Quote:Original post by Narf the Mouse
Ok, if I'm reading that right, you're saying that Matrix-Matrix multiplication is four times slower than Matrix-Vector multiplication, so it's better to do Matrix-Matrix multiplication than Matrix-Vector multiplication?

Josh has answered already, but I want to clarify it:

I've shown that
( M1 * M2 ) * v
is more efficient than
M1 * ( M2 * v )
already for small numbers of vertices. Something like the above happens often, especially because of animations or object parenting (forward kinematics, skeletons).

Your objection was that a homogeneous transformation
M * v
is less efficient than its affine counterpart
t + R * v
(for position vectors) or
R * v
(for direction vectors) because the participants have one less dimension compared to the homogeneous version. This requires that the transformation is ready-to-use.

Both statements are okay.