First Person Camera rotation in 3D

I have written a first person camera class for android.

The class is really simple , the camera object has its three axes X,y and Z

and there are functions to create the ModelView matrix ( i.e. calculateModelViewMatrix() ), rotate the camera along its X and Y axis and Translate the camera along its Z-axis.

I think that my ModelViewMatrix calulation is correct and i can also translate the camera along the Z-axis.

Rotation along x-axis seems to work but along Y-axis it gives strange results. Also another problem with the rotation seems to be that instead of the camera being rotated, my 3d model starts to rotate instead along its axis.

I have written another implementation based on the look at point and using the openGL ES's GLU.gluLookAt( ) function to obtain the ModelView matrix but that too seems to suffer from the exactly the same problems.

EDIT

First of all thanks for your reply.

I have actually made a second implementation of the Camera class, this time using the rotation functions provided in android.opengl.Matrix class as you said. I have provided the code below, which is much simpler.

To my surprise, the results are "Exactly" the same. This means that my rotation functions and Android's rotation functions are producing the same results.

I did a simple test and looked at my data. I just rotated the LookAt point 1-dgree at a time around Y-axis and looked at the coordinates. I开发者_C百科t seems that my LookAt point is lagging behind the exact rotation angle e.g. at 20-deg it has only roatated 10 to 12 degree. And after 45-degrees it starts reversing back

There is a class android.opengl.Matrix which is a collection of static methods which do everything you need on a float[16] you pass in. I highly recommend you use those functions instead of rolling your own. You'd probably want either setLookAtM with the lookat point calculated from your camera angles (using sin, cos as you are doing in your code - I assume you know how to do this.)

-- edit in response to new answer --

(you should probably have edited your original question, by the way - your answer as another question confused me for a bit)

Ok, so here's one way of doing it. This is uncompiled and untested. I decided to build the matrix manually instead; perhaps that'll give a bit more information about what's going on...

class TomCamera {
     // These are our inputs - eye position, and the orientation of the camera.
     public float mEyeX, mEyeY, mEyeZ; // position
     public float mYaw, mPitch, mRoll; // euler angles.

     // this is the outputted matrix to pass to OpenGL.
     public float mCameraMatrix[] = new float [16];

     // convert inputs to outputs.
     public void createMatrix() {
         // create a camera matrix (YXZ order is pretty standard)
         // you may want to negate some of these constant 1s to match expectations.
         Matrix.setRotateM(mCameraMatrix, 0, mYaw, 0, 1, 0);
         Matrix.rotateM(mCameraMatrix, 0, mPitch, 1, 0, 0);
         Matrix.rotateM(mCameraMatrix, 0, mRoll, 0, 0, 1);
         Matrix.translateM(mCameraMatrix, 0, -mEyeX, -mEyeY, -mEyeZ);
     }
}