Question

I’m trying to use gluProject with my game. I’ve found a way to use it but I don’t know how to deal with rotation.

Here is the code I made:

public static Vector2 getScreenCoordinates(float x, float y, float z, int height, int width)
{
    FloatBuffer screen_coords = GLAllocation.createDirectFloatBuffer(4);
    IntBuffer viewport = GLAllocation.createDirectIntBuffer(16);
    FloatBuffer modelview = GLAllocation.createDirectFloatBuffer(16);
    FloatBuffer projection = GLAllocation.createDirectFloatBuffer(16);

    GL11.glGetFloat(2982, modelview);
    GL11.glGetFloat(2983, projection);
    GL11.glGetInteger(2978, viewport);

    boolean result = GLU.gluProject(x, y, z, modelview, projection, viewport, screen_coords);
    if (result)
    {
        float screen_x = screen_coords.get(0);
        float screen_y = screen_coords.get(1);
        float scrren_z = screen_coords.get(2);

        screen_y -= height / 2;
        screen_y = -screen_y;
        screen_y += height / 2;

        return new Vector2(screen_x, screen_y);
    }
    else
    {
         System.out.printf("Failed to convert 3D coords to 2D screen coords");
         return null;
    }
}

So x, y and z are coords in my 3D map. height and width are my window size.

How can I modify it to deal with rotation (yaw and pitch)?

Thanks.

---

Here is my new code:

public Vector2 worldToScreen(double x, double y, double z, int yaw, int pitch)
{   
    // Initialize the result buffer
    FloatBuffer screen_coords = GLAllocation.createDirectFloatBuffer(4);

    // Init the OpenGL buffers
    IntBuffer viewport = GLAllocation.createDirectIntBuffer(16);
    FloatBuffer modelview = GLAllocation.createDirectFloatBuffer(16);
    FloatBuffer projection = GLAllocation.createDirectFloatBuffer(16);

    // Add the rotation
    GL11.glRotatef(yaw, 0, 0, 1);
    GL11.glRotatef(pitch, 1, 0, 0);

    // Get the OpenGL data
    GL11.glGetFloat(2982, modelview);
    GL11.glGetFloat(2983, projection);
    GL11.glGetInteger(2978, viewport);

    // Remove the rotation
    GL11.glRotatef(-yaw, 0, 0, 1);
    GL11.glRotatef(-pitch, 1, 0, 0);

    // Calculate the screen position
    boolean result = GLU.gluProject(x, y, z, modelview, projection, viewport, screen_coords);

    if (result)
    {
        if ( (screen_coords.get(0) < -1.0f) || (screen_coords.get(0) > 1.0f) || (screen_coords.get(1) < -1.0f) || (screen_coords.get(1) > 1.0f) )
            return null;

        int window_half_width = getWidth() / 2;
        int window_half_height = getHeight() / 2;

        int screen_x = window_half_width + (window_half_width * -screen_coords.get(0));
        int screen_y = window_half_height + (window_half_height * screen_coords.get(1));

        System.out.printf("(Full Screen / No bounds) [" +x+ ", " +y+ ", " +z+ "] gives [" +screen_coords.get(0)+ ", " +screen_coords.get(1)+ "]");
        System.out.printf("(Every Time) [" +x+ ", " +y+ ", " +z+ "] gives [" +screen_x+ ", " +screen_y+ "]");
        return new Vector2(screen_x, screen_y);
    }
    else
    {
        System.out.printf("Failed to convert 3D coords to 2D screen coords");
        return null;
    }
}

Is that correct?

Answer 1

Yaw is a rotation about the y axis (pointing upwards), and pitch is a rotation about the x axis.

GL11.glRotatef(pitch, 1, 0, 0);
GL11.glRotatef(yaw, 0, 1, 0);

It may also be faster to push/pop the the projection matrix, and you should be in the correct matrix mode. (Both your model-view matrix and your projection matrix have to be correct).

GL11.glPushMatrix();
// Camera rotations
GL11.glPopMatrix();

But it’s questionable as to why you need to undo the camera tranformations. You should probably just apply them once per frame or viewport. Render your scene with that view, then get the projected coordinate and then change to your 2D rendering mode.

Update

I’d prefer it if you used roll, pitch and yaw of the camera to mean what they actually mean in OpenGL’s coordinate system – with respect to the camera. The point is, as long as you have the camera model-view and projection matrices setup correctly, you can project the point. You must already be setting up the camera somewhere. You will be able to see if this is correct, because you can SEE the results. Apply that transformation and you will know it’s correct.

Is this correct? It might be? You have to apply all of the transformations. The exact same transformations that give you the camera view you see in game. This includes all translations and rotations. You will know if you are right, because you should already be applying these transformations in-game.

However, What you need to think about is what is the camera projection matrix before hand? If you don’t know, call glLoadIdentity() to clear it, and then call your camera transformation logic. You need an accurate model-view and projection matrix – the exact same camera setup you are using in-game. If your model-view or projection matrices are in the wrong state, it just won’t work.