OpenGL中的3D拾取

Question

Is there a "standard" method for 3d picking? What do most game companies do? (for accurate picking)

I thought the fastest way is to use the gpu and render every object with an "color index", and then to use glReadPixels() , but then I heard that it's considered slow because of glFlush() , glFinish() calls.

There's also this ray casting approach, which is nice but isn't accurate because of the spheres/AABBs approximations.

Answer 1

Any question about what is "standard" is probably going to invoke some opinionated responses, but I would suggest that the closest to "standard" here is raycasting.

Take your watertight ray/triangle intersection function and test a ray that is unprojected from your mouse cursor position against the triangles in your scene.

Normally this would be quite slow, requiring linear complexity. So the next step is to accelerate it to something better, like logarithmic time. This is typically achieved with a data structure such as an octree, BVH, KD tree, or BSP. Sometimes people skip this step and just try to make the ray/tri intersection really fast and really parallel, possibly even using GPGPU.

It takes a lot more work upfront than framebuffer-based solutions, but complex applications tend to go this route probably because:

1. Portability: it's decoupled from the rendering engine. It doesn't have to be tied to OpenGL or DirectX, eg, and that improves portability.
2. Generality: typically the accelerator and associated queries are needed for other things. For example, an FPS game might have players and enemies constantly shooting at each other. Figuring out what projectiles hit what tends to require these kinds of intersection queries occurring constantly, and not just from a uniform viewing angle.
3. Simplicity: the developers can afford the extra work upfront to simplify things later on.

There's also this ray casting approach, which is nice but isn't accurate because of the spheres/AABBs approximations.

There should be nothing inaccurate about using AABBs or bounding spheres for acceleration purposes. Those are purely to accelerate the tests and quickly reduce the number of the more costly ray/triangle intersections that need to occur by doing cheaper tests and ones that eliminate large batches of triangles to check in bulk. Normally they should be constructed to encompass the elements in the scene. If you do a ray/AABB intersection first, eg, and if that hits, test the elements encompassed within the AABB. Any acceleration structure that doesn't give the same results without the accelerator would typically be a glitchy one.

For example, a very basic form of acceleration is just put a bounding box around one mesh element in a scene, like a character, and sometimes this basic form without involving a full-blown accelerator might be useful for very dynamic elements in the scene (to avoid the cost of constantly updating the accelerator). If the ray intersects the character's bounding box, then check all the triangles making up the character. As long as you check the triangles within the AABB afterwards, it becomes about acceleration rather than approximation. Of course if you only checked the AABB and nothing else, then it would be a crude approximation.