OpenGL ES Picking using Ray-BoundingBox Intersection

One way to determine which object a player has picked, be it via mouseclick or finger tap, is to generate a pick ray relative to the player's eye, and transform it by the inverse of the openGL ModelView matrix. This is true for any openGL 3d 4x4modelview including the iphone's.

Example:


In eye coordinates, the pick ray origin is simply (0, 0, 0). You can build the pick ray vector from the perspective projection parameters, for example, by setting up your perspective projection this way

// assuming you created your own frustum setting function with a
// similar signature to this for the camera position.
void Set(float fFov, float fAspect, float fNear, float fFar)
// and you are familiar with the following camera settings.
#define SCREEN_WIDTH 320
#define SCREEN_HEIGHT 480
#define NEAR 1
#define FAR 100
#define FOV SCREEN_HEIGHT
#define ASPECT  float(SCREEN_WIDTH)/float(SCREEN_HEIGHT)

Now make your x and y coordinates relative to the center of the screen and get the x and y components of the ray.

float centered_y = (SCREEN_HEIGHT - y) - SCREEN_HEIGHT/2;
float centered_x = x - SCREEN_WIDTH/2;
float unit_x = centered_x/(SCREEN_WIDTH/2);
float unit_y = centered_y/(SCREEN_HEIGHT/2);

The variables unit_x and unit_y are scaled between -1.0 and 1.0. Use them to find the mouse location on your zNear clipping plane like so:

Now your pick ray vector is (x, y, -zNear, 0).

float near_height = NEAR * float(tan( FOV * PI / 360.0 ));
float ray[4] ={ unit_x*near_height*ASPECT, unit_y*near_height, 1, 0 };
float ray_start_point[4] = {0.f, 0.f, 0.f, 1.f};

To transform this eye coordinate pick-ray into object coordinates we multiply it by the inverse of the ModelView matrix. Since the pick ray is made up of a vector and a point, and that vectors and points transform differently. You can translate and rotate points, but vectors only rotate. The way to guarantee that this is working correctly is to define your point and vector as four-element arrays. The one and zero in the last element determines whether an array transforms as a point or a vector when multiplied by the inverse of the ModelView matrix.

Since my modelview matrix is built dynamically using something like gluLookAt or a sequence of glTranslate, glRotate, and glScale calls, I can use glGetFloatv to retrieve the current modelview matrix.

GLfloat the_modelview[16];
//Read the current modelview matrix into the array the_modelview
glGetFloatv(GL_MODELVIEW_MATRIX, the_modelview);

Given our initial modelview matrix M, consisting of a 3x3 rotation submatrix R and a 3-element translation vector t we can construct the inverse modelview using the transpose of the rotation submatrix and the camera's translation vector:

M = {
{R11, R12, R13, 0},
{R21, R22, R23, 0},
{R31, R32, R33, 0},
{tx, ty, tz, 1},
};

Rt = {
{R11, R21, R31},
{R12, R22, R32},
{R13, R23, R33}
}

Rt*t = t'

M-1 = {
{R11, R21, R31, 0},
{R12, R22, R32, 0},
{R13, R23, R33, 0},
{-t'x, -t'y, -t'z, 1},
};

Now that we have the inverse modelview matrix we can use it to transform our view coordinate into world space:

M-1*ray = ray';
M-1*ray_start_point = ray_start_point'

Yeah cool, now iterate down this ray for a fixed distance no larger than your zFar value creating a small bounding box and testing for collisions as you usually do in your game to find out what it is the player has clicked or tapped on.