here's a hint:
screenX(), screenY(), screenZ() in the complete reference.

I've just been experimenting with a couple of implementations of 3D picking for simple scenes composed of triangles -

http://www.tom-carden.co.uk/p5/picking_with_buffer/applet/

This one is really simple, and can be pixel-accurate (but isn't in this case because I reduced the picking resolution for speed reasons).  It requires you to draw your scene twice... once as you normally would, and once to an offscreen buffer using the triangle index as the fill colour.  You then look at the colour of the object under mouseX/Y in the buffer to get the index of the picked object.  It's a bit slow, but it works accurately even in this random-triangle scene.

http://www.tom-carden.co.uk/p5/picking_with_projection/applet/

This one projects all the triangles to screen space, depth sorts them, and checks if any of the projected triangles contains the mouse point.  It's not 100% accurate, but for scenes without intersecting triangles it will be fine, and it's faster than the buffer-based method.

A "picking_with_rays" applet is planned, but I'm not going to get to it until next week.  The idea is to make an imaginary line between the mouseX/Y on the screen (near clipping plane) and the equivalent point on the far clipping plane.  You then test for intersections with this line and your scene.  That check involves first testing if the ray intersects the plane containing the triangle, and then projecting the triangle and intersection point to one of the x/y/z planes and testing if the point is inside the triangle - I think it will actually be slightly slower than the projected triangles method above, but it's more accurate and it could be speeded up by using a spatial partition or testing object bounding box intersection first.

Hope that helps.

Yep, that's a good tutorial, thanks!

A helpful reference for me finishing off the picking with rays example

Also, marquee selection is a nice touch, I'll have to try that one.

I've heard that the select method isn't used much even professionally.  I personally find it much easier (and more intuitive) to simply render the whole scene in a false-color mode in a backbuffer, then use the color as a form of "id" into what was actually selected.

This can be optimized a couple of ways.  If the scene doesn't change significantly, you can cache the whole false-color image.  Otherwise, you can simply crop and render the scene so that it's clipped immediately (would use something like gluPickMatrix as with the other method) around the coordinate you are trying to check so hidden surface removal can be performed on 99% of the image.

Alright, I implemented a simple picking method for OpenGL mode using the false color mode as described above.

public int pick(int _x, int _y) {
 gl = ((PGraphicsGL)g).gl;
 gl.glDrawBuffer(GL.GL_FRONT);
 draw();
 gl.glReadBuffer(GL.GL_FRONT);
 byte[] pickedPixel = new byte[4];
 gl.glReadPixels(_x, height-_y, 1, 1,
   GL.GL_RGBA, GL.GL_UNSIGNED_BYTE, pickedPixel);
 gl.glDrawBuffer(GL.GL_BACK);
 return new Color(pickedPixel[0],pickedPixel[1],pickedPixel[2]).getRGB();
}

I tried it with several buffers, it only worked well with the front buffer. You can call this method from mousePressed() etc., anywhere, where you're officially allowed to draw.