This directly translates to matrices when you multiply two matrices, you can think of this multiplication as transforming one matrix to the space of the other matrix. Meaning that rotation around the first axis, will make next rotation be relative to the first original rotation, hence you cannot independently rotate a vector around each of the 3 axis using Euler angles. Yet most people forget the point that Euler angles are three sequential angles. The problem with rotations, is that, most people think of it in terms of Euler angles, since they are easy to understand. But the physically correct rule for combining two sequential rotations, each represented as Euler angles, into a single rotation is rather complicated, and essentially amounts to converting the rotations into matrices / quaternions, multiplying them, and then converting the result back into Euler angles.) (Technically, since any rotation matrix or quaternion can be represented as a set of Euler angles, it is possible to use them to store the orientation of the object. Matrix = object.orientation // already in matrix form! If (axis = AXIS_X) object.orientation *= eulerAnglesToMatrix(dir, 0, 0) Įlse if (axis = AXIS_Y) object.orientation *= eulerAnglesToMatrix(0, dir, 0) Įlse if (axis = AXIS_Z) object.orientation *= eulerAnglesToMatrix(0, 0, dir) That is, instead of the pseudocode above, you'd do something like this: // in player input handling:
#Rotate objects in game corp dx update#
The solution, as you note in your own answer, is to store the orientation of the object as a rotation matrix (or a quaternion), and update that matrix based on user input. In the real world, this does not happen - if you don't believe me, grab a six-sided die or a Rubik's cube, let x = y = 90°, and try it out yourself! In the naïve Euler angle representation, as implemented in the pseudocode above, these rotations will cancel out and the object will return to its original orientation. rotate object by − y degrees around the Y axis.rotate object by − x degrees around the X axis.rotate object by y degrees around the Y axis.rotate object by x degrees around the X axis.In particular, consider the following sequence of rotations: Matrix = eulerAnglesToMatrix(object.angleX, object.angleY, object.angleZ) Īs Charles Beattie notes, because rotations don't commute, this won't work as expected unless the player rotates the object in the same order in which the eulerAnglesToMatrix() applies the rotations. If (axis = AXIS_X) object.angleX += dir Įlse if (axis = AXIS_Y) object.angleY += dir Įlse if (axis = AXIS_Z) object.angleZ += dir That is, you have something like this pseudocode: // in player input handling: Based on you comments, it seems that you're storing the orientation of the object as a set of Euler angles, and in/decrementing the angles when the player rotates the object.
0 kommentar(er)
