Pick.h

Go to the documentation of this file.

//------------------------------------------------------------------------
//C++ 
//                   ________    ____   ___ 
//                  |        \  /    | /  /
//                  +---+     \/     |/  /
//                  +--+|  |\    /|     < 
//                  |  ||  | \  / |  |\  \ 
//                  |      |  \/  |  | \  \ 
//                   \_____|      |__|  \__\
//                       Copyright  2003 
//                      Joe Michael Kniss
//               "All Your Base are Belong to Us"
//-------------------------------------------------------------------------

/// Pick.h


#ifndef __GL_PICK_DOT_H
#define __GL_PICK_DOT_H

#include <vector>

////////////////////////////////////////////////////////////////
/// PickInfo, contains the information related to a particular
///  object that was under the mouse during a pick. 
///  a vector of these are created by the "Pick" object 
///    specified below. \n
///  TODO: maybe make this counted and have the PickInfoVec hold
///    smartptrs so we aren't copying the data so much.
class PickInfo {
public:
   ~PickInfo() 
   {
      if(data) delete[] data;
   }

   ///@name Z values from/on the picked object
   ///@{
   ///  these will be in [0-1] range, where 0=near clip, 1=far clip
   double z1;  //< nearest z value (likely what you care about)
   double z2;  //< farthes z value
   ///@}

   ///@name data pushed on the gl name stack
   ///   -when object was rendered
   ///@{
   int dataSize;       //< how many names were associated with this pick
   unsigned int *data; //< the name data vector, lenght = dataSize
   ///@}

public: 
   /// a user should "rarely" have to create one of these!
   /// normal usage of "Pick" will handle creation of the PickInfo
   ///   for you.  You might, however, need to copy this for later use.

   PickInfo() : data(0), dataSize(0), z1(0xffffffff), z2(0xffffffff) {}
   PickInfo(double Z1, double Z2, unsigned int *pbuf, unsigned int num)
      : z1(Z1), z2(Z2), data(0), dataSize(num)
   {
      if(num)
      {
         data = new unsigned int[num+1];
         for(unsigned int i=0; i<num; ++i) data[i] = pbuf[i];
      }
   }
   PickInfo(const PickInfo &p)
      : z1(p.z1), z2(p.z2), data(0), dataSize(p.dataSize)
   {
      if(p.dataSize && p.data)
      {
         data = new unsigned int[p.dataSize];
         for(int i=0; i<p.dataSize; ++i) data[i] = p.data[i];
      }
   }
   PickInfo &operator=(const PickInfo &p)
   {
      if(data) delete[] data;
      data = 0;
      if(p.dataSize && p.data)
      {
         data = new unsigned int[p.dataSize];
         for(int i=0; i<p.dataSize; ++i) data[i] = p.data[i];
      }
      return *this;
   }

};

////////////////////////////////////////////////////////////////
/// a standard vector of PickInfos
///
typedef std::vector<PickInfo>  PickInfoVec;
///
////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////
/// Pick, 
///   creates a PickInfoVec in sorted order from least 
///   to greatest z1 when "endPick()" is called:
/// Here's how it works:
///  - You get a mouse event with an x,y screen space position 
///  - You determine if it warents a pick
///  - If it does, create a Pick object
///  - call Pick::startPickGL()
///  - call your draw function
///  - call Pick::endPickGL() & capture PickInfoVec
///
///  The PickInfoVec is now filled with the pick info.
///    This info is sorted based on z1 in increasing order.
///    Use this info to handle picking how ever you like.
///
///  If you are doing a whole lot of picking, you may want
///  to create a single pick object and keep it around so you
///  aren't creating and deleating the pick buffer so much.
///
///  Here is an example:
/// \code
///  ... in a mouse-down function (double/int x, double/int y)
///  Pick p();
///  p.startPickGL(x,y,4); // starting picking
///  {  /// I use brackets to keep the code clean :)
///     draw();          // my draw function
///  }
///  PickInfoVec pinfo = p.endPickGL();
///  if(pinfo.size())
///     myTopObjId0  = pinfo[0].data[0];
/// \endcode
///  You might need to flip the y, ie. p.startPickGL(x,height-y-1,4);..
///
/// Note: This class sets the "GL_PROJECTION" matrix, so if
///   you are setting it every render pass, you need make sure
///   that you don't while picking is going on.  Once Pick::endPickGL()
///   has been called, the projection matrix will be reset to
///   what it was before Pick::startPickGL() was called.  Just make
///   sure that you don't modify the projection matrix between
///   these calls, or you will get some strange picking behavior.
///   The projection matrix that you are using for rendering should
///   be the current projection matrix when you call Pick::startPickGL().
////////////////////////////////////////////////////////////////

class Pick {
public:
   ////////////////////////////////////////////////////////////////
   /// how big do you want the pick buffer to be?
   ///  depends on how much data you will be pushing on the 
   ///  gl name stack, and the depth complexity of the scene;
   ///  1024 is probably ample.
   Pick(int pickBufferSize = 1024)
      : _pickBuffer(new unsigned int[pickBufferSize]), 
        _pbSize(pickBufferSize),
        _picking(false)
   {}
   Pick(const Pick &p)
      : _pickBuffer(new unsigned int[p._pbSize]),
        _pbSize(p._pbSize),
        _picking(false)
   {}
   Pick &operator=(const Pick &p)
   {
      if(_pickBuffer) delete[] _pickBuffer;
      _pickBuffer = new unsigned int[p._pbSize];
      _pbSize = p._pbSize;
      return *this;
   }
   ~Pick() { if(_pickBuffer) delete[] _pickBuffer; }

   ////////////////////////////////////////////////////////////////
   /// begin a pick, you need to call your draw loop and then
   ///   endPick when you are done.
   ///
   void        startPickGL(double x, double y, double pickWin = 4);
   ///
   ////////////////////////////////////////////////////////////////

   ////////////////////////////////////////////////////////////////
   /// you should render all "pickable" objects between these calls
   ////////////////////////////////////////////////////////////////
   
   ////////////////////////////////////////////////////////////////
   /// end a pick, creates a pick information vector
   ///
   PickInfoVec endPickGL();
   ///
   ////////////////////////////////////////////////////////////////

protected:
   unsigned int *_pickBuffer;
   int           _pbSize;
   bool          _picking;
};


#endif

---

Send questions, comments, and bug reports to: