add a function to apply affine transforms to vectors

[jimy-byerley]

Hello !
here is the issue for one of the specific suggesions from #139

Half the operations I do with mat4 is transforming a vec3, I suppose that's the same for many users.
But as mat4 and vec3 are not dimensionally compatible for matrix product, there is always the need to convert them. Could it be possible to have a function doing this multiplication ?

motivation

# this is the current way to apply an affine transformation
>>> vec3(matrix * vec4(v,1))    # many conversions and parenthesis for just one vector

# this could be a nicer way, at least more efficient
>>> hmul(matrix, v)   # all conversions made in C code, so much more efficient

(I thought to name it hmul as in Homogeneous Multiplication because affineMul in the spirit of affineInverse seemed too cumbersome)

I suspect having such a function dedicated to mat4 * vec3 operation would be more efficient than the current way because there is currently 2 conversions (vec3->vec4 before and then after operation again vec4->vec3) thus 2 object allocation; where a c++ function would optimize all this in jsut the product.

feature

The following could be the overloaded functions corresponding to the need I describe here:

hmul(mat4, vec3) -> vec3   # shorthand for  vec3(mat * vec4(vec,1))
hmul(mat3, vec2) -> vec2   # shorthand for vec2(mat * vec3(vec,1))
hmul(mat2, vec1) -> vec1   # etc

Do you think it could play well with the philosophy of pyglm ?

[Zuzu-Typ]

Hey there (:
I actually found it to be a lot easier to just add this to the existing matrix multiplication.
For example:

>>> translate(mat4(), (1,2,3)) * vec3()
vec3( 1, 2, 3 )

That should improve readability too.

[jimy-byerley]

I improves readability A LOT !! I love it :)
I hesitated to propose this in the first time but I was a bit scared about proposing such a thing ;)

I was just concerned about the meaning behind it:

• GLSL (which seems to be the reference API for GLM) forbid multiplication with different dimensions, even when it's for affine transformations (I'm a bit sad about this every time I write a shader, but it's the way it is ...). So is it a good choice to add in pyglm a behavior that is not allowed in glsl ? 🤔

• if for some reason one writes a code and mix its matrices, there won't be any warning about the mismatching dimensions. I'm not a fan at all of "prefer explicit over implicit" (depending on circumstances, I would say I'm even sometimes opposed to it) but I wonder in this case if it's good to have that implicit change of behavior

Though, if you say those points are not important I would be very happy with such extension of the matrix multiplication !

[Zuzu-Typ]

• GLSL (which seems to be the reference API for GLM) forbid multiplication with different dimensions, even when it's for affine transformations (I'm a bit sad about this every time I write a shader, but it's the way it is ...). So is it a good choice to add in pyglm a behavior that is not allowed in glsl

I do prefer staying as close to glm as possible, so that anyone who knows GLSL or glm will also be able to write PyGLM code.
However, I've already diverged from glm many times, adding a few features here and there, because I found them to be necessary or helpful, with little to no drawbacks.

Thus I decided to add this feature as well (: