As you may know, I am working on a 3D graphing utility for the Casio Prizm graphing calculator. I have it working nicely, short of a few features. Notably, I've been using a camera rotation system whereby pressing one set of arrows adds/subtracts to/from the absolute theta_y, and pressing the other set adds/subtracts to/from the absolute theta_z. For correct rotation, the change in [theta_x, theta_y, theta_z] needs to depend on the current [theta_x, theta_y, theta_z], and I am having a hard time deriving the correct math for it. First, a bit of background:

:: I am defining the rotation for the graph with three angles, theta_x, theta_y, theta_z (or XYZ), applied in order of X, Y, Z. The transform I'm using is called the camera transform (using the camera transform). It's a left-handed transform, with, as I said, an angle order of X, Y, then Z. My code to calculate the camera position looks like this (remember, I want to keep it pointing at the center of the graph, which is usually the three-dimensional origin (0,0,0).):

Code:


Next, the math that I use to apply the camera transform to 3D points to be drawn to account for the camera position and heading. (dx, dy, dz) are the remapped coordinates in 3-space:

Code:


However, adjusting the camera rotation is proving to be a real problem. I've considered several different approaches:

1. Simply add/subtract pi/8 to/from theta_y/theta_z. This does rotation, but not intuitively.
   
2. Use the camera transform to transform delta theta_y or delta theta_z values into delta_x/y/z angles, and add those to theta_x/y/z. This appears not to work.
   
3. Use the camera cx/cy/cz coordinates, and apply a camera transform of +/- pi/8 in either theta_y or theta_z. Then, use the resulting new coordinates for the camera to work backwards and get the XYZ angles for the vector that joins the origin to that point.
   

The code for the last approach is here. It sadly does not work. Any assistance would be greatly appreciated. matan2f is a custom atan2() implementation.

Code:

I should mention that I found the algorithm at the end of that here:
http://stackoverflow.com/questions/1251828/calculate-rotations-to-look-at-a-3d-point. Again, thanks in advance for any help, large or small.

... Matrix math, anyone?

(still trying to read your post )

Yes, it does indeed apply a fair deal of matrix math. The Wikipedia page I linked shows the three rotation matrices that make up the camera transform that I'm using.

Did I point you at ZPR already and did you already explain why it wouldn't work? If not, you should look here: http://www.nigels.com/glt/gltzpr/

I'm reading through that source now, and it looks to me as if it rotates through an angle in a given direction. I suppose that actually is what I want, but the tricky thing is that it appears to perform rotation/scaling of all point/polygons/whatevers right there. With my system, I maintain the originals, and rotate them for the current camera position and heading each time I re-draw the frame (which incidentally is when the camera moves).

I mentioned to Kerm on IRC that using Euler angles to represent combined rotations can be a little unintuitive and tricky to work with - quaternions tend to be favoured for representing rotations.

I'm pretty sure it doesn't rescale the input data, since I rewrote the core of the library in Python for use with PyOpenGL, and I don't remember it doing that.

Since benryves is widely considered to be extremely awesome, and I'm frustrated with Euler angles, I'm going to try playing with quaternions. Firstly, I wrote myself a little tiny 3-vector / 4-quaternion library that does things like multiply quaternions, normalize vectors and quaternions, perform quaternion rotations given an axis vector and a rotation angle, and a few other miscellaneous things. I implemented my quaternion math based on this tutorial:

http://www.gamedev.net/page/resources/_/technical/math-and-physics/a-simple-quaternion-based-camera-r1997

Next, before I start worrying about rotating my camera, I need to do simple scene rendering with a camera transform. I have defined my camera as follows:

Code:
where struct vector is basically just three floats, x, y, and z. It seems to me that gluLookAt() pretty much does the camera transform that I want, so I read this page:

http://pyopengl.sourceforge.net/documentation/manual/gluLookAt.3G.html

I turned the math that they describe into this code:

Code:
The linked gluLookAt page says: The translation is fine, and what I'd expect, but the glMultMatrixf is confusing me. M is 4x4, but all of my points to be transformed are 3x1 vectors. Help, and thanks in advance.

Edit: I missed that glMatrixMultf actually does C = C*M, where C is some internal "current [transform] matrix" for OpenGL, which makes sense, but in my case it doesn't make a difference. This is the only transform, so it's just C=I*M=M anyway. I'm still trying to work out if the point vectors v[] are quaternions, if [x y z 0] is a reasonable translation, or if there's something else I need to do.