Do we need the overloaded C++ functions? about handmademath

[bvisness]

@Nairou That's an interesting case I hadn't thought of. And to @RandyGaul's point, if you want to use the mul style of math, the function names are probably so verbose that you would have to #define mul HMM_Multiply anyway, just to make them tolerable.

My biggest issue with the overloaded versions is that they don't really give you anything beyond the operator overloads (besides a more visible order of operations, I guess). If someone wants to take the @RandyGaul approach, I would rather just let them create mul in their own project with all the overloads they want. That way they can extend it to other things outside of Handmade Math.

[StrangeZak]

I could imagine some C++ like this feature of just being able to call HMM_Multiply with whatever data types and not have to call the explicit functions for that data type. Either way I’m not torn on keeping them or not

[RandyGaul]

Personally I prefer mul kind of function in C++.

The reason is if we concatenate a few matrices like so:

D = A * B * C
D = C * B * A

It isn't extremely clear what the order of intended operations is just by looking at the * operator. This is a problem when someone opens up the math header and wants to create a transform hierarchy, but isn't sure what semantic ordering to apply until they see someone else using the header as an example. But, if there is a mul function people can use either ordering however they like, explicitly, and don't need to see sample code to figure out how to use the header.

D = mul(mul(A, B), C);
D = mul(mul(B, C), A);

I overload this mul function for matrix to matrix, matrix to vector, quaternion to vector, axis-angle to vector, and so-on, transform to transform, transform to vector, and so on.

One more advantage is a transposed multiply can be implemented, and can be potentially easier to on the compiler's optimizer. Compare the two options below for multiplying a tranposed matrix with another matrix.

C = transpose(A) * B;
C = mul_transposed(A, B);

The mul_transposed function can directly implement the operations in-line for transposed multiplication, without making a transposed copy of A.

The final reason, is adding more mul functions is really easy. I have similar mul functions (in my own code) for transforming shapes like planes and rays, or even arrays of vectors.

[Nairou]

I no longer use the overloaded functions either. I have also been tripped up in the past by reading two versions of each operation in the documentation (usually via search), trying one, and learning it was just an overload of something else.

[bvisness]

HMM 2.0 preserves the C++ overloads.