OpenGL Car wheel rotation issue

[Archive]

Hello, so I’m having a tough time figuring out how to make my car’s wheel rotate properly. When I rotate it in one axis, it works fine, however once I rotate it around another axis as well, the wheel behaves funny. I read up a little on this issue, and it seems to be because the axes of rotation are rotated with the object when GL.glRotatef() is called.

This is the code I use to transform the wheel before I render it.

GL.glScalef(scale, scale, scale);
		if (centered) {
			GL.glTranslatef(-center[0] + translation[0], -center[1] + translation[1], -center[2] + translation[2]);
		} else {
			GL.glTranslatef(translation[0], translation[1], translation[2]);
		}
                // i read somewhere that z x y is the proper rotation order, however this hasn't helped.
		if (rotation[2] != 0) {
			GL.glRotatef(rotation[2], 0.0f, 0.0f, 1.0f);
		}
		if (rotation[0] != 0) {
			GL.glRotatef(rotation[0], 1.0f, 0.0f, 0.0f);
		}
		if (rotation[1] != 0) {
			GL.glRotatef(rotation[1], 0.0f, 1.0f, 0.0f);
		}

I’m just trying to make the wheel on the car rotate forward on the x axis (when the car moves forward) and turning on the y axis (when the car turns)

EDIT: dug around some more and found this on https://www.opengl.org/archives/resources/faq/technical/transformations.htm#tran0070

9.070 How do I transform my objects around a fixed coordinate system rather than the object’s local coordinate system?

If you rotate an object around its Y-axis, you’ll find that the X- and Z-axes rotate with the object. A subsequent rotation around one of these axes rotates around the newly transformed axis and not the original axis. It’s often desirable to perform transformations in a fixed coordinate system rather than the object’s local coordinate system.

The root cause of the problem is that OpenGL matrix operations postmultiply onto the matrix stack, thus causing transformations to occur in object space. To affect screen space transformations, you need to premultiply. OpenGL doesn’t provide a mode switch for the order of matrix multiplication, so you need to premultiply by hand. An application might implement this by retrieving the current matrix after each frame. The application multiplies new transformations for the next frame on top of an identity matrix and multiplies the accumulated current transformations (from the last frame) onto those transformations using glMultMatrix().

You need to be aware that retrieving the ModelView matrix once per frame might have a detrimental impact on your application’s performance. However, you need to benchmark this operation, because the performance will vary from one implementation to the next.