Picking and 3D Selection

• Pick: Select an object by positioning mouse over it and clicking.
• Question: How do we decide what was picked?
  • We could do the work ourselves:
    • Map selection point to a ray;
    • Intersect with all objects in scene.
  • Let OpenGL/graphics hardware do the work.
• Idea: Draw entire scene, and ``pick'' anything drawn near the cursor.
  • Only ``draw'' in a small viewport near the cursor.
  • Just do clipping, no shading or rasterization.
  • Need a method of identifying ``hits''.
  • OpenGL uses a name stack managed by
    glInitNames(), glLoadName(), glPushName(), and glPopName().
  • ``Names'' are unsigned integers
  • When hit occurs, copy entire contents of stack to output buffer.
• Process:
  • Set up pick buffer
  • Initialize name stack

    May need pushName(-1);

  • Save old projective transformation and set up a new one
  • Draw your scene with appropriate use of name stack
  • Restore projective transformation
  • Query for number of hits and process them
• A hit occurs if a draw occurs in the (small) viewport
• All information (except 'hits') is stored in buffer given with glSelectBuffer
• Example:
  • Two objects
  • Might pick none
  • Might pick either one
  • Might pick both

      glSelectBuffer(size, buffer);      /* initialize */
      glRenderMode(GL_SELECT);           
      glInitNames();
      glPushName(-1);
      glGetIntegerv(GL_VIEWPORT,viewport);    /* set up pick view */
      glMatrixMode(GL_PROJECTION);
      glPushMatrix();
      glIdentity();
      gluPickMatrix(x,y,w,h,viewport);
      glMatrixMode(GL_MODELVIEW);
  
      ViewMatrix();
      glLoadName(1);
      Draw1();
      glLoadName(2);
      Draw2();
  
      glMatrixMode(GL_PROJECTION);
      glPopMatrix();
      glMatrixMode(GL_MODELVIEW);
      hits = glRenderMode(GL_RENDER);

• Hits stored consequetively in array
• In general, if h is the number of hits, the following is returned.
  • hits = h.
  • h hit records, each with four parts:
    1. The number of items q on the name stack at the time of the hit (1 int).
    2. The minimum z value amoung the primitives hit (1 int).
    3. The maximum z value amoung the primitives hit (1 int).
    4. The contents of the hit stack, deepest element first (q ints).
• At most one hit between each call glRenderMode or a change to name stack
• In our example, you get back the following:
  • If you click on Item 1 only:
    hits = 1,
    buffer = 1, min(z1), max(z1), 1.
  • If you click on Item 2 only:
    hits = 1,
    buffer = 1, min(z2), max(z2), 2.
  • If you click over both Item 1 and Item 2:
    hits = 2,
    buffer = 1, min(z1), max(z1), 1, 1, min(z2), max(z2), 2.
• More complex example:

      /* initialization stuff goes here */
      glPushName(1);
          Draw1();        /* stack: 1 */
          glPushName(1);
              Draw1_1();      /* stack: 1 1 */
              glPushName(1);
                  Draw1_1_1();    /* stack: 1 1 1 */
              glPopName();   
              glPushName(2);
                  Draw1_1_2();    /* stack: 1 1 2 */
              glPopName();   
          glPopName();   
          glPushName(2);  /* stack: 1 2 */
              Draw1_2();
          glPopName();   
      glPopName();   
      glPushName(2);
          Draw2();        /* stack: 2 */
      glPopName();   
      /* wrap-up stuff here */

• What you get back:
  • If you click on Item 1:
    hits = 1,
    buffer = 1, min(z1), max(z1), 1.
  • If you click on Items 1:1:1 and 1:2:
    hits = 2,
    buffer = 3, min(z111), max(z111), 1, 1, 1, 2, min(z12), max(z12), 1, 2.
  • If you click on Items 1:1:2, 1:2, and 2:
    hits = 3,
    buffer = 3, min(z112), max(z112), 1, 1, 2, 2, min(z12), max(z12), 1, 2, 1, min(z2), max(z2), 2.
• Important Details:
  • Make sure that projection matrix is saved with a glPushMatrix() and restored with a glPopMatrix().
  • glRenderMode(GL_RENDER) returns negative if buffer not big enough.
  • When a hit occurs, a flag is set.
  • Entry to name stack only made at next gl*Name(s) or glRenderMode call. So, each draw block can only generate at most one hit.

Readings: GL Programming Manual, Chapter 12