SurfaceWidget.h

Go to the documentation of this file.

//------------------------------------------------------------------------
//
//   Joe Kniss
//     9-9-03
//                   ________    ____   ___ 
//                  |        \  /    | /  /
//                  +---+     \/     |/  /
//                  +--+|  |\    /|     < 
//                  |  ||  | \  / |  |\  \ 
//                  |      |  \/  |  | \  \ 
//                   \_____|      |__|  \__\
//                       Copyright  2003 
//                      Joe Michael Kniss
//                   <<< jmk@cs.utah.edu >>>
//               "All Your Base are Belong to Us"
//-------------------------------------------------------------------------

/// SurfaceWidget.h

#ifndef __SURFACE_WIDGET_DOT_H
#define __SURFACE_WIDGET_DOT_H

#include <signalGutz.h>
#include "WidgetBase.h"

///////////////////////////////////////////////////////////////////////////
/// SurfaceWidget, fully constrained to 4 points.
/// Be sure that your concrete implementation checks if
///  the gutz::RenderEvent is in pick mode, gutz::RenderEvent::picking().
///  This is important if you are rendering an "invisible" plane
///  that can be selected, you need to make it visible while picking 
///  is happening.
/// \code
///  drawDef(const gutz::RenderEvent &re)
///  {
///     if(re.picking())
///        drawThePlane(...);
///     else
///        /// maybe do nothing if invisible
///  }
/// \endcode
/// You can also optimize the pick procedure, by turning off complicated
///   shaders and stuff, since it isn't a visible render pass when picking;
///   you only need to render the surface of the plane.
class SurfaceWidget : public WidgetItem {
public:
   
   enum SURFACE_W_BEHAVIORS {
      PICK = WB_LAST + 1,   ///< only behavior defined is pick (default left mouse)
      SW_LAST
   };

   SurfaceWidget(WidgetItem *parent, float border = 0, bool drawBorder = false);
   virtual ~SurfaceWidget() {}

   ////////////////////////////////////////////
   ///@name Clones
   ///@{

   /// WidgetItem::clone definition
   WidgetItem *clone() const
   {  return cloneSurface(); }

   /// Pure virtual cloneSurface(), must be defined in 
   ///   (all) concrete SurfaceWidget classes
   virtual SurfaceWidget *cloneSurface() const = 0;

   ///@}
   ////////////////////////////////////////////

   /// object changed
   virtual void setChanged()
   {
      for(int i=0; i<NODE_LAST; ++i)
         pointChanged(i,_corners[i]);
   }

   /// assignment operator, just copys position information
   SurfaceWidget &operator=(const SurfaceWidget &sw)
   {  
      for(int i=0; i<NODE_LAST; ++i) setPoint(i,sw.getPoint(i));
      return *this;
   }

   /// points corresponding to a frame (4point) surface
   enum SURFACE_POINTS {
      LL,       ///< Lower Left
      LR,       ///< Lower Right
      UL,       ///< Upper Left
      UR,       ///< Upper Right
      NODE_LAST ///< also the number of points/nodes
   };

   HAS_SLOTS;

   ////////////////////////////////////////////
   ///@name set/get Points
   ///@{
   gutz::vec3f  getPoint(int ptIdx) const                 
   { return _manip->getWorldPosLocal(_corners[ptIdx]); }
   void         setPoint(int ptIdx, const gutz::vec3f &pt) 
   {
      _invalidate();
      {
         _corners[ptIdx] = _manip->getLocalPosWorld(pt); 
      }
      _update();
      pointChanged(ptIdx, getPoint(ptIdx));
   }
   ///get the plane that defines the surface, see gutz::plane
   gutz::planef getPlane() const 
   { return gutz::planef(getPoint(LL),
                         getPoint(LR),
                         getPoint(UL));
   }
   ///@}
   ////////////////////////////////////////////

   ////////////////////////////////////////////
   /// @name set specific points (slots):
   ///@{
   void   setLL(const gutz::vec3f &ll) { setPoint(LL,ll); }
   void   setLR(const gutz::vec3f &lr) { setPoint(LR,lr); }
   void   setUL(const gutz::vec3f &ul) { setPoint(UL,ul); }
   void   setUR(const gutz::vec3f &ur) { setPoint(UR,ur); }
   ///@}
   ////////////////////////////////////////////

   ////////////////////////////////////////////
   ///@name Signals
   ///@{

   /// pointChanged(int,vec3f), point index & the point itself
   gutz::Signal<int, const gutz::vec3f &> pointChanged;

   /// signal: surfacePicked(const vec3f &pt);
   gutz::Signal<const gutz::vec3f &> surfacePicked;

   /// signal: surfacePickMoved(const vec3f &)
   gutz::Signal<const gutz::vec3f &> surfacePickMoved;

   ///@}
   ////////////////////////////////////////////

   ////////////////////////////////////////////
   ///@name Transform Widget
   ///@{
   virtual void    applyXform(gutz::mat4f xf)
   { for(int i=0; i<NODE_LAST; ++i) _corners[i] = xf * _corners[i]; }
   ///@}

   /////////////////////////////////////////////////////
   ///@name Behaviors from WidgetItem
   ///@{
   virtual bool mouseDef(const gutz::MouseEvent &me);
   virtual bool moveDef(const gutz::MouseMoveEvent &mme);
   ///@}
   /////////////////////////////////////////////////////

protected:
   gutz::vec3f intersectPlane(const gutz::MouseEvent &me) const;

   /// Copy does not copy/clone content, you need to handle that
   ///  yourself.  Do you need to copy signals too? There are a number of
   ///  things that make copying content unique, resolve those outside this
   ///  class.
   SurfaceWidget(const SurfaceWidget &sw)
      : WidgetItem(sw)
   {
      for(int i=0; i<NODE_LAST; ++i)
         _corners[i] = sw._corners[i];
   }

   /// These points are in LOCAL space
   gutz::vec3f  _corners[NODE_LAST];

   /// This point is in WORLD space!!
   gutz::vec3f  _lastPick;

};
typedef gutz::SmartPtr<SurfaceWidget> SurfaceWidgetSP;


#endif

---

Send questions, comments, and bug reports to: