Because i've pulled it just out of my head ignoring any conventions. Better do it like Wikipedia says, so you do it like everybody else as well. (In practice it can only mean their rotations go into the other direction, so sign of angle causes opposite results) There are many related convention issues. Some people use column major matrices, some major column; there is left handed or right handed coordinate systems; even multiplication order is not consistent.
> How can we rotate in the opposite direction?
Make 3 more matrices with negative angle.
It makes sense to write helper functions e.g. void MakeRotationX,Y and Z (vec3[3] matrix, float angle);
Also, make helper function like vec3 RotateVector (vec3[3] matrix, vec3 *vec);
For a "diagonal" rotation (like in the video), I find the effect strange. Is it normal? If not, how can we fix it?
Somehow video runs with 1 fps for me, but it may be caused by the up vector orientation construction.
So, next you should try to replace the single normal per object with ‘vec3 orientation[3]’. Then you can control exact orientation from keyboard entry. Having RotateVector() function becomes handy because you have to rotate all 3 of them each time.
In your intersection function, you then use those two new axis to define width and length directions of the square. (Same can be used later to orient any other shape ofc.)
So that's some work for you : ) After this works (or not) post code so we can introduce matrix multiply to reduce lines of code even more and make your basic 3D rotations toolbox complete ; )
Yes, because every time I press a button I redraw the picture.
I understand what needs to be done: we need to rotate all 3 axes at the same time rather than rotating one and recalculating the other two.
I don't understand exactly what the two functions do: vec3 RotateVector(matrix vec3 [3], vec3 * vec); and void MakeRotationX,Y and Z(matrix vec3 [3], floating angle);
Math guys would say this is a ‘matrix x vector multiplication’
Often matrices use data structure like float m[3][3], if you look up some example implementations. But the math is the same, using 3 vector is convenient to get the axis, and following the code you can imagine what happens geometrically.
ellenature said: void MakeRotationX,Y and Z(matrix vec3 [3], floating angle);
Again, imagine how it works. If angle is zero, we get the identity matrix:
1,0,0
0,1,0
0,0,1
If you do the rotation math from above with any vector in your mind, you see it does not change. From there it is easy to imagine how a small angle slightly rotates the axis of the matrix, and how this same rotation then happens to the input vector.
I did that. In particular, I changed the prototypes of the functions you suggested I do. Does that seem right to you ?
Now I just have to correct the problem of the up axis that gives this weird effect when rotating "diagonally" or is there something else I need to do ?
ellenature said: Now I just have to correct the problem of the up axis that gives this weird effect when rotating
Yeah, but make sure to replace object.vec with orientation matrix, so array of 3 vectors. Then rotate all 3 of them as you did and use then to construct the quad in intersection.
To initialize this matrix (so it all starts with a proper orientation) there are some options:
Set matrix to identity
Use your make_rotation functions
construct it manually, e.g. using the up vector method and cross products
Notice the last option has the risk of mirroring, which happens when one vector has opposite direction than any following code assumes. For example if you end up with a matrix like this:
1,0,0
0,1,0
0,0,-1
This can make unexpected problems. Most code may work as expected, but some will not (e.g. conversion to quaternion).
ellenature said: if (!(rot_x = malloc(sizeof(*rot_x) * 3))) return (NULL);
Why do you allocate memory for each matrix? This is very bad practice, because frequent allocations can cause huge slow downs and memory fragmentation. You should never do this without a real reason. Just declare the arrays in place so they live in the stack memory without a need for allocations.
We rotate all three axes together. I realized something: when I rotate first on one axis it works but after a second rotation on another axis it doesn't match.
For example, I rotate on the X axis (it's good) then on the y axis and there I have the impression that the rotation is made around the axis (0,1,0) instead of the modified y axis.
Example (video) with a square (0,0,1). I have defined the up (0, 1, 0) and right (-1, 0, 0) vectors without the calculations of the intersection function. By displaying in the terminal each rotation, I can see that the 3 vectors are modified correctly.
ellenature said: I realized something: when I rotate first on one axis it works but after a second rotation on another axis it doesn't match.
Video looks good. What you describe is ‘Gimbal Lock’. This is because we do 3 rotations after each other ('Euler Angles'). You could change this order by swapping code blocks to rotate in x, y and z. Currently your order is yxz. Maybe zxy would feel more intuitive to you, or any other order.
You see this code repeats often. It would be worth to add a function to rotate all 3 axis vectors at once, and you could store the 3 axis in an array of 3 vectors just like the other matrices.
Yes good idea for the function to avoid repetition of the code. For now, I don't store the 3 vectors in an array, maybe I'll do it later.
Concerning the rotation order, the code blocks are not executed in sequence but only if I press the key (if condition). That is to say that according to the keys I press I can do :
only x,
or only y,
or only z,
but also x then y,
x then z,
y then x,
y then z,
z then x,
z then y,
or again x then y then z,
x then z then y,
y then x then z,
y then z then x,
z then x then y,
z then y then x.
So I don't necessarily do 3 rotations one after the other.
Your'e right, and i think i can imagine how it behaves / what you want.
Actually you do: object = rotation x object.
And what you want is maybe (hopefully): object = object x rotation.
So the order of multiplication / rotation reverses. Makes no difference for 2D rotation, but for 3D it does (multiplication is not commutative).
But to try this quickly, you had to store object rotation as matrix right now already. (Multiplication is the proposed rotation function as said above)
Wooowww it's working!!!! That's awesome! Thank you so much JoeJ !
I used the same functions for the cylinder and the camera and it works too.
I use malloc because I couldn't pass as argument a t_vec3 *[3] to the void function apply_rotation_y(t_vec3 **orientation, float angle); which expects a t_vec3 ** (by declaring t_vec3 orientation[3]).
What do you think about the way I move objects (KEY_UP, KEY_DOWN, KEY_LEFT, KEY_RIGHT, KEY_CTRL, KEY_SHIFT in the if) ?
