---

sglPick.hpp

/*****************************************************************************
 * SGL: A Scene Graph Library
 *
 * Copyright (C) 1997-2001  Scott McMillan   All Rights Reserved.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the Free
 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *****************************************************************************
 *     File: sglPick.hpp
 *  Created: 18 April 2001
 *  Summary: stores the probe traversal state (very similar to cull traversal)
 *****************************************************************************/

#ifndef __SGL_PICK_HPP
#define __SGL_PICK_HPP

#include <sgl.h>
#include <sglProbe.hpp>

#include <vector>

class sglNode;

//----------------------------------------------------------------------------

template <class T>
class SGL_DLL_API sglPick : public sglProbeTemplate<T>
{
public: // Sub types
   class SGL_DLL_API PickResult : public sglProbeTemplate<T>::ProbeResult
   {
   public:
      vector<sglNode*>     m_path;  // path to picked geoset

   public:
      PickResult() : sglProbeTemplate<T>::ProbeResult() {}
      virtual ~PickResult() { reset(); }  // necessary?

      virtual void reset()
         {
            m_path.clear();
            resetInternal();
         }
   };

public:
   sglPick(vector<PickResult*> *result_pool = NULL);

   virtual ~sglPick();

   void setPickFrustum(const sglMat4<T>    &pick_matrix,
                       const sglFrustum<T> &pick_frustum);

   virtual void reset();

   vector<sglNode*> &getPath() { return m_path; }

   sglFrustum<T> &getOrigPickFrustum() { return m_orig_pick_frustum; }
   sglFrustum<T> &getPickFrustum()     { return m_current_pick_frustum; }

   void addHit(const sglGeode *geode, const sglDrawable *geometry);

   const vector<PickResult*> &getResults() const { return m_results; }

   // -------- push/pop transform functions (used internally) ---------
   template <class S>
   void pushScale(S scale,
                  S inv_scale,
                  sglFrustum<T> &old_pick_frustum,
                  sglMat4<T>    &old_matrix,
                  sglFrustum<T> &old_view_frustum)
      {
         if (m_mode & (eTRANSFORM|eUNSCALE_VIEW|eUNPROJECT_VIEW|
                       eLOD_VIEW|eBILLBOARD_VIEW))
         {
            // save the original view matrix
            old_matrix = m_modelview_matrix;

            // compute the new view matrix
            m_modelview_matrix.scale(old_matrix, scale, scale, scale);

            // compute a new view frustum
            if (m_mode & eUNPROJECT_VIEW) // |eUNSCALE_VIEW
            {
               old_view_frustum = m_current_view_frustum;
               m_current_view_frustum.scale(old_view_frustum, inv_scale);
            }
         }

         // store the original pick frustum so that i don't have to inverse
         // transform it during the pop
         old_pick_frustum = m_current_pick_frustum;

         // scale the original pick frustum
         m_current_pick_frustum.scale(old_pick_frustum, inv_scale);
      }

   template <class S>
   void pushTranslate(S tx, S ty, S tz,
                      sglFrustum<T> &old_pick_frustum,
                      sglMat4<T>    &old_matrix,
                      sglFrustum<T> &old_view_frustum)
      {
         if (m_mode & (eTRANSFORM|eUNSCALE_VIEW|eUNPROJECT_VIEW|
                       eLOD_VIEW|eBILLBOARD_VIEW))
         {
            // save the original view matrix
            old_matrix = m_modelview_matrix;

            // compute the new view matrix
            m_modelview_matrix.translate(old_matrix, tx, ty, tz);

            // compute a new view frustum
            if (m_mode & eUNPROJECT_VIEW)
            {
               old_view_frustum = m_current_view_frustum;
               m_current_view_frustum.translate(old_view_frustum,
                                                -tx, -ty, -tz);
            }
         }

         // store the original pick frustum so that i don't have to inverse
         // transform it during the pop
         old_pick_frustum = m_current_pick_frustum;

         // translate the original pick frustum
         m_current_pick_frustum.translate(old_pick_frustum, -tx, -ty, -tz);
      }

   // transform - HACK Windoze could not deal with the following function
   // being called push() when compiling sglTransform
   template <class S>
   void pushTransform(const sglMat4<S> &xform,
                      const sglMat4<S> &inv_xform,
                      sglFrustum<T> &old_pick_frustum,
                      sglMat4<T>    &old_matrix,
                      sglFrustum<T> &old_view_frustum)
      {
         if (m_mode & (eTRANSFORM|eUNSCALE_VIEW|eUNPROJECT_VIEW|
                       eLOD_VIEW|eBILLBOARD_VIEW))
         {
            // save the original view matrix
            old_matrix = m_modelview_matrix;

            // compute the new view matrix
            m_modelview_matrix.mul(xform, old_matrix);

            // compute a new view frustum
            if (m_mode & eUNPROJECT_VIEW)
            {
               old_view_frustum = m_current_view_frustum;
               m_current_view_frustum.mul(old_view_frustum, inv_xform);
            }
         }

         // store the original pick frustum so that i don't have to inverse
         // transform it during the pop
         old_pick_frustum = m_current_pick_frustum;

         // transform the original pick frustum
         m_current_pick_frustum.mul(old_pick_frustum, inv_xform);
      }

   // pop the transform (restore the old values).
   void pop(sglFrustum<T> &old_pick_frustum,
            sglMat4<T>    &old_matrix,
            sglFrustum<T> &old_view_frustum)
      {
         m_current_pick_frustum = old_pick_frustum;

         if (m_mode & (eTRANSFORM|eUNSCALE_VIEW|eUNPROJECT_VIEW|
                       eLOD_VIEW|eBILLBOARD_VIEW))
         {
            m_modelview_matrix = old_matrix;

            // restore the old view frustum
            if (m_mode & eUNPROJECT_VIEW) // |eUNSCALE_VIEW)
            {
               m_current_view_frustum = old_view_frustum;
            }
         }
      }

private: // not implemented
   sglPick(const sglPick &);
   sglPick& operator=(const sglPick &);

protected:
   sglFrustum<T>        m_orig_pick_frustum;
   sglFrustum<T>        m_current_pick_frustum;

   vector<PickResult*>  m_results;
   vector<PickResult*> *m_result_pool;

   vector<sglNode*>     m_path;              // current pick path
};

//----------------------------------------------------------------------------
// convenience types:
//    template class 'should' only be float or double

typedef sglPick<float>  sglPickf;
typedef sglPick<double> sglPickd;

#endif

---