patch.H

Go to the documentation of this file.

#ifndef PATCH_H_IS_INCLUDED
#define PATCH_H_IS_INCLUDED

/*!
 *  \file patch.H
 *  \brief Contains the definition of the Patch class and related classes.
 *
 *  \sa patch.C
 *
 */

#include "geom/appear.H"        // base class of Patch

#include "bmesh.H"              // meshes
#include "tex_coord_gen.H"      // for generating tex coords
#include <vector>

class GTexture;
typedef const GTexture CGTexture;
/*!
 *  \brief Convenience methods defined in gtexture.H
 *
 */
class GTexture_list : public BMD_array<GTexture> {
   
 public:
      
   //******** MANAGERS ********
   GTexture_list(int n=0)                   : BMD_array<GTexture>(n)    {}
   GTexture_list(const GTexture_list& list) : BMD_array<GTexture>(list) {}
   GTexture_list(GTexture* g) : BMD_array<GTexture>(1) {
      add(g);
   }
   GTexture_list(GTexture* g1, GTexture* g2) : BMD_array<GTexture>(2) {
      add(g1);
      add(g2);
   }
   GTexture_list(GTexture* g1, GTexture* g2, GTexture* g3) :
      BMD_array<GTexture>(3) {
      add(g1);
      add(g2);
      add(g3);
   }
   GTexture_list(GTexture* g1, GTexture* g2, GTexture* g3, GTexture* g4) :
      BMD_array<GTexture>(4) {
      add(g1);
      add(g2);
      add(g3);
      add(g4);
   }
   GTexture_list(GTexture* g1, GTexture* g2, GTexture* g3, GTexture* g4,
                 GTexture* g5) :
      BMD_array<GTexture>(5) {
      add(g1);
      add(g2);
      add(g3);
      add(g4);
      add(g5);
   }
   GTexture_list(GTexture* g1, GTexture* g2, GTexture* g3, GTexture* g4,
                 GTexture* g5, GTexture* g6) :
      BMD_array<GTexture>(6) {
      add(g1);
      add(g2);
      add(g3);
      add(g4);
      add(g5);
      add(g6);
   }
   GTexture_list(GTexture* g1, GTexture* g2, GTexture* g3, GTexture* g4,
                 GTexture* g5, GTexture* g6, GTexture* g7) :
      BMD_array<GTexture>(6) {
      add(g1);
      add(g2);
      add(g3);
      add(g4);
      add(g5);
      add(g6);
      add(g7);
   }
   GTexture_list(GTexture* g1, GTexture* g2, GTexture* g3, GTexture* g4,
                 GTexture* g5, GTexture* g6, GTexture* g7, GTexture* g8) :
      BMD_array<GTexture>(6) {
      add(g1);
      add(g2);
      add(g3);
      add(g4);
      add(g5);
      add(g6);
      add(g7);
      add(g8);
   }

   //******** CONVENIENCE ********
      
   void write_stream(ostream& os) const;
   void delete_all();

   void set_patch(Patch* p)     const;

   void push_alpha(double a)    const;
   void pop_alpha()             const;
};
typedef const GTexture_list CGTexture_list;

typedef void (*init_fade_func_t)(GTexture*, GTexture*, double, double);

class PatchData;
typedef const PatchData CPatchData;

/*!
 *  \brief Base class for application-specific, custom data attached to the
 *   patch.
 *
 */
class PatchData {
   
 public:
   
   virtual ~PatchData() {}
      
   //! \name RTTI Methods
   //@{
      
   DEFINE_RTTI_METHODS_BASE("PatchData", CPatchData*);
      
   //@}

};

/*!
 *  \brief DynamicSample is used as a sampel point for Dynamic Hatching 
 *
 */

class DynamicSample;
typedef const DynamicSample CDynamicSample;

class DynamicSample {
   
 public:
   DynamicSample() {}
   DynamicSample(CBsimplex* s, Wvec bc, PIXEL pix, double weight)
      : _s(s),
        _bc(bc),
        _pix(pix),
        _weight(weight)
   {}
   virtual ~DynamicSample() {}
   CBsimplex* get_simplex() const { return _s; }
   Wvec      get_bc()      const { return _bc;}
   double    get_weight()  const { return _weight; }
   PIXEL     get_pix()     const { return _pix; }   
   Wpt       get_pos(CWtransf& tr)  const { return tr*_s->bc2pos(_bc); }
   //! \name RTTI Methods
   //@{      
   DEFINE_RTTI_METHODS_BASE("DynamicSample", CDynamicSample*);
   //@}
 public:
    CBsimplex* _s;
    Wvec      _bc;
    PIXEL     _pix;
    double    _weight;

};

class Patch;
typedef const Patch CPatch;

/*!
 *  \brief A region of a BMESH that can be textured individually.
 *
 */
class Patch : public DATA_ITEM, public APPEAR, public BMESHdrawable {
   
 protected:

   //******** MANAGERS ********
   Patch(BMESH* = 0);
   friend class BMESH;
   
 public:
   
   virtual ~Patch();

   //! \name Accessors
   //@{
      
   BMESH*       mesh ()                 const      { return _mesh; }
   void         set_mesh(BMESH* m)                 { _mesh = m; changed(); }
   Cstr_ptr&    name ()                 const      { return _name;}
   void         set_name(Cstr_ptr &str)            { _name = str;}
   Cstr_ptr&    texture_file ()         const      { return _texture_file;}
   void         set_texture_file(Cstr_ptr &str)    { _texture_file = str;}
   TexCoordGen* tex_coord_gen()         const      { return _tex_coord_gen; }
   void         set_tex_coord_gen(TexCoordGen* tg) { _tex_coord_gen = tg; }
      
   CARRAY<uint>& pixels()               const      { return _pixels; }
   void          add_pixel(uint p)                 { _pixels += p; }
      
   int num_vert_strips() const { return _vert_strips.num(); }
   int num_edge_strips() const { return _edge_strips.num(); }
   int num_tri_strips()  const { return _tri_strips.num(); }
      
   virtual void          set_data(PatchData *d)     { _data = d; }
   virtual PatchData*    get_data()                 { return _data; }
      
   int stencil_id() {
      if (!_stencil_id)
         _stencil_id = ++_next_stencil_id;
      return _stencil_id;
   }
      
   // List of Gtextures:
   const GTexture_list& gtextures() const { return _textures; }
      
   //@}

   //! \name Accessing Patch Geometry
   //@{
   
   //! \brief Lightweight: returns reference to existing face list:
   CBface_list& faces() const   { return _faces; }
   
   //! \brief Heavyweight: builds the lists and returns by copying
   //! (returns vertices and edges of this patch).
   Bvert_list   verts() const;
   //! \copydoc Patch::verts()
   Bedge_list   edges() const;
      
   //@}

   //! \name Silhouettes, Creases, Etc.
   //@{
   
   //! \brief Generates (if needed) and returns the requested silhouettes,
   //! creases, etc.  Operates on the CURRENT subdivision Patch.
   EdgeStrip&   cur_sils()
      { return cur_patch()->build_sils(); }
   //! \copydoc Patch::cur_sils()
   ZcrossPath&  cur_zx_sils()
      { return cur_patch()->build_zx_sils(); }

   EdgeStrip*   cur_creases()
      { return cur_patch()->build_creases(); }
   //! \copydoc Patch::cur_sils()
   EdgeStrip*   cur_borders()
      { return cur_patch()->build_borders(); }
      
 protected:
   
   //! \brief Generates (if needed) and returns the requested silhouettes,
   //! creases, etc. Operates on *this* Patch as opposed to the current
   //! subdivision Patch.
   EdgeStrip&   build_sils();
   //! \copydoc Patch::build_sils()
   ZcrossPath&  build_zx_sils();
   //! \copydoc Patch::build_sils()
   EdgeStrip*   build_creases();
   //! \copydoc Patch::build_sils()
   EdgeStrip*   build_borders();

 public:

 protected:
   
   //! \brief Simple accessor -- no checks for updating.
   //! \note May be phased out because it appears to be unused.
   EdgeStrip&   sils()          { return _sils; }
   //! \copydoc Patch::sils()
   ZcrossPath&  zx_sils()       { return _zx_sils; }
   //! \copydoc Patch::sils()
   EdgeStrip*   creases()       { return _creases; }
   //! \copydoc Patch::sils()
   EdgeStrip*   borders()       { return _borders; }
      
   //@}
   
 public:

   //! \name Subdivision
   //! Redefined by Lpatch (subdivision patches).
   //@{
      
   //! \brief Returns the corresponding patch at the "current"
   //! subdivision level.
   virtual Patch* cur_patch() { return this; }
      
   //! \brief Convenience: the mesh of the current subdivision patch.
   BMESH* cur_mesh() { return cur_patch()->mesh(); }
      
   //! \brief The level of this Patch in the subdivision hierarchy
   //! (control mesh is 0, next level is 1, etc.).
   int subdiv_level() const { return _mesh ? _mesh->subdiv_level() : 0; }
      
   //! \brief The level of this Patch relative to its control Patch
   //! (filled in by Lpatch).
   virtual int rel_subdiv_level() { return 0; }
      
   //! \brief The mesh edit level, relative to this patch
   //! (filled in by Lpatch).
   virtual int rel_edit_level()
      { return _mesh ? (_mesh->edit_level() - subdiv_level()) : 0; }
      
   //! \brief Returns mesh faces at current subdivision level.
   virtual CBface_list& cur_faces()     const   { return _faces; }
   //! \brief Returns mesh vertices at current subdivision level.
   virtual Bvert_list   cur_verts()     const   { return verts(); }
   //! \brief Returns mesh edges at current subdivision level.
   virtual Bedge_list   cur_edges()     const   { return edges(); }
      
   //! For BMESH patch: returns number of faces in patch.
   //! For LMESH patch: returns number of faces at current subdiv level.
   //! \remark Popular with Gtextures to report on how many faces they rendered.
   virtual int          num_faces()     const    { return _faces.num();}
      
   //! \brief Used by Lpatch to produce a child patch
   //! at the next subdivision level.
   virtual Patch* get_child() { return 0; }
      
   //! \brief Returns the highest-level parent Patch of this one.
   //!
   //! \note NB. the control patch may not belong to the control mesh,
   //! in the case that a patch has been added at a level > 0.
   virtual Patch* ctrl_patch() const { return (Patch*)this; }
      
   //@}

   //! \name Convenience - Mesh Accessors
   //@{
   
   CWtransf& xform()      const   { return _mesh->xform(); }
   CWtransf& inv_xform()  const   { return _mesh->inv_xform(); }
   CWtransf& obj_to_ndc() const   { return _mesh->obj_to_ndc(); }
   CWpt&     eye_local()  const   { return _mesh->eye_local(); }
   double    pix_size()   const   { return _mesh->pix_size(); }
      
   //@}

   //! \name Building
   //@{
      
   void add(Bface* f);
   void remove(Bface* f);
   
   void add(VertStrip*);
   void remove(VertStrip*);
   
   void add(EdgeStrip*);
   void remove(EdgeStrip*);
   
   void build_tri_strips();
   virtual double tris_per_strip() const {
      return _tri_strips.empty() ? 0.0 :
         double(_faces.num())/_tri_strips.num();
   }
      
   //@}

   //! \name Versioning/Caching
   //! used by textures to tell if they are up-to-date
   //! (e.g., display lists may be out of date).
   //@{
      
   virtual void changed() { _stamp++; }
      
   virtual uint stamp() {
      if (_mesh && _mesh->version() != _mesh_version) {
         _mesh_version = _mesh->version();
         changed();
      }
      return _stamp;
   }
      
   //@}

   //! \name Notification
   //@{
   
   virtual void triangulation_changed();
   
   void creases_changed();
   void borders_changed();
      
   //@}

   //! \name BMESHdrawable Methods
   //@{
      
   virtual int draw(CVIEWptr&);
      
   //@}

   //! \name Drawing
   //@{
   
   // XXX - in transition.
   virtual int  draw_tri_strips(StripCB *);
   virtual int  draw_sil_strips(StripCB *);
   
   int          draw_crease_strips(StripCB *);
   int          draw_border_strips(StripCB *);
   int          draw_edge_strips(StripCB *);
   int          draw_vert_strips(StripCB *);
      
   //@}
   
   //! \name Procedural Textures
   //@{
      
   void      set_texture(GTexture* gtex);
   void      set_texture(Cstr_ptr& style);
   void      next_texture();
   
   //! \brief Returns an existing texture of the given type, or nil.
   GTexture* find_tex(Cstr_ptr& tex_name) const;
   
   //! \brief Same as find_tex() but makes a new GTexture if needed.
   GTexture* get_tex(Cstr_ptr& tex_name);
   
   //! \brief Returns an index for a texture.
   int get_tex_index(Cstr_ptr& tex_name) {
      return _textures.get_index(get_tex(tex_name));
   }
   
   //! \brief Return "current" GTexture, based on the mesh's render style
   //! if it has one, or based on the view's render style.
   virtual GTexture* cur_tex(CVIEWptr& v);
   
   //! \brief Texture to use according to the "current texture index".
   GTexture* cur_tex() const {
      return _textures.valid_index(_cur_tex_i) ? _textures[_cur_tex_i] : 0;
   }
      
   //@}
   
   //! \name I/O Functions
   //@{
      
   virtual int write_stream     (ostream &os);
   virtual int read_stream      (istream &is, str_list &leftover);
   virtual int read_texture     (istream &is, str_list &leftover);
   virtual int read_color       (istream &is, str_list &leftover);
   virtual int read_texture_map (istream &is, str_list &leftover);
   virtual int read_patchname   (istream &is, str_list &leftover);
      
   //@}

   //! \name RefImageClient Methods
   //@{
      
   virtual ref_img_t    use_ref_image();
      
   virtual int draw_vis_ref();
   virtual int draw_ref_img(ref_img_t);
   virtual int draw_final(CVIEWptr &v);
      
   //@}
      
   //! \name RTTI Methods
   //@{
      
   DEFINE_RTTI_METHODS3("Patch", Patch*, DATA_ITEM, Patch *);
      
   //@}
      
   //! \name DATA_ITEM Methods
   //@{
      
   virtual CTAGlist    &tags()  const;
   virtual DATA_ITEM  *dup  ()  const;
      
   //@}
      
   //! \name Appear Methods
   //@{
      
   virtual CCOLOR&   color         ()                const;
   virtual bool      has_color     ()                const;
   virtual void      set_color     (CCOLOR& c);
   virtual void      unset_color   ();
      
   virtual double    transp        ()                const;
   virtual bool      has_transp    ()                const;
   virtual void      set_transp(double t);
   virtual void      unset_transp();
      
   //! \brief Set normal texture map.
   virtual void      set_texture   (CTEXTUREptr& t);
   //! \brief Unset normal texture map.
   virtual void      unset_texture ();
      
   //! \brief convenience
   void apply_texture() {
      if (has_texture()) {
         _texture->apply_texture(&_tex_xform);
      }
   }
      
   //! \brief Function to use for initializing a fade from one GTexture
   //! to another.
   static init_fade_func_t _init_fade;
   
   //! \name Dynamic Samples
   //@{
   //! \brief center of the samples from last frame
   PIXEL    get_old_sample_center()  { return _old_center; }
   //! \brief center of the samples
   PIXEL    get_sample_center()  { return _new_center; }
   //! \brief Non-accumulated z
   VEXEL    get_z()              { return _z; }

   PIXEL    get_patch_center()  { return _patch_center; }


   bool     get_do_dynamic_stuff() const { return _do_dynamic_stuff; }
   void     do_dynamic_stuff(bool d)     { _do_dynamic_stuff = d; }
   void     set_do_lod(bool d)           { _do_lod = d; }
   bool     get_do_lod()                 { return _do_lod; }
  
   PIXEL    sample_origin()     const   { return _o; }
   VEXEL    sample_u_vec()      const   { return (_u_o - _o); }
   VEXEL    sample_v_vec()      const   { return (_v_o - _o); }
   double   sample_scale()      const   { return _scale; }
   const vector<DynamicSample>&  get_samples() const{ return _old_samples; }

   double lod_t() const { return _lod_t; }
   VEXEL  lod_u() const { return _lod_u; }
   VEXEL  lod_v() const { return _lod_v; }

   void update_dynamic_samples();  
   void reset_dynamic_samples();  

 private:
   void     create_dynamic_samples();  
   //@}

 protected:
   
   BMESH*            _mesh;             //!< owner
   
   Bface_list        _faces;            //!< unordered faces
   ARRAY<TriStrip*>  _tri_strips;       //!< faces organized into tri strips
   
   EdgeStrip         _sils;             //!< silhouette edges (as strip)
   ZcrossPath        _zx_sils;          //!< zero_crossing sils
   EdgeStrip*        _creases;          //!< crease edges (maybe derived type)
   EdgeStrip*        _borders;          //!< border edges (maybe derived type)
   ARRAY<EdgeStrip*> _edge_strips;      //!< edges to be rendered as line strips
   ARRAY<VertStrip*> _vert_strips;      //!< vertices to be rendered as points
      
   GTexture_list     _textures;         //!< list of textures
   int               _cur_tex_i;        //!< index of current texture
   int               _non_tex_i;
   
   GTexture*         _prev_tex;         //!< last GTexture used
   
   ARRAY<uint>       _pixels;           //!< pixels on patch
   uint              _stamp;            //!< version number
   uint              _mesh_version;     //!< last recorded mesh version
   bool              _tri_strips_dirty; //!< used to rebuild _tri_strips
   
   str_ptr           _name;             //!< name
   str_ptr           _texture_file;     //!< name of texture map image file
   
   TexCoordGen*      _tex_coord_gen;    //!< for generating texture coordinates
   PatchData*        _data;             //!< optional custom data
   
   int          _stencil_id;
   static int   _next_stencil_id;
   
   //! \name Dynamic Samples Variables
   //@{
   vector<DynamicSample>  _old_samples;     //!< old sample positions (in pixel space)  
   
   PIXEL                  _old_center;   //!< sample's center in the last frame
   PIXEL                  _new_center;   //!< sample's center in the current frame
   VEXEL                  _z;            //!< non-accumulated z
   double                 _scale;        //!< total accumulated scale...
   PIXEL                  _patch_center; //!< XXX testing...
   
   //! These are used when growing new faces, chaced values of the first quad, so that 
   //! given a new UV point can figure out new location of the points
   PIXEL                  _o;
   PIXEL                  _u_o;        
   PIXEL                  _v_o;
   uint                   _dynamic_stamp;
   bool                   _do_dynamic_stuff;
   bool                   _do_lod;
   double                 _lod_t; // interpolation parameter between 2 LOD scales
   VEXEL                  _lod_u; // u vector to use when doing LOD
   VEXEL                  _lod_v; // v vector to use when doing LOD
   //@}

   //! \name Serialization Methods
   //@{
      
   static TAGlist      *_patch_tags;
   COLOR   &color_    () { return _color;}
   str_ptr &name_     () { return _name;}
   int     &cur_tex_i_() { return _cur_tex_i;}
   virtual void get_faces(TAGformat &d);
   virtual void put_faces(TAGformat &d) const;
   virtual void get_color  (TAGformat &d)       { COLOR c; *d >> c; set_color(c); }
   virtual void put_color  (TAGformat &d) const {
      if (has_color())
         d.id() << color();
   }
   virtual void get_texture (TAGformat &d);
   virtual void put_textures(TAGformat &d) const;
   virtual void recompute();
      
   //@}
   
   //! \brief Fill the given edge strip with edges of a given type that
   //! belong to this patch.
   EdgeStrip* build_edge_strip(EdgeStrip* strip, CSimplexFilter& filter);

};

/*****************************************************************
 * inline convenience methods
 *****************************************************************/

//! \brief Returns the Patch of a Bface.
//! \relates Patch
//! \relatesalso Bface
inline Patch* 
get_patch(CBface* f) 
{
   return f ? f->patch() : 0; 
}

//! \brief Returns the Patch of a Bsimplex.
//! \note If you know it's actually a Bface, get_patch(CBface*) is faster.
//! \relates Patch
//! \relatesalso Bsimplex
inline Patch*
get_patch(CBsimplex* s)
{
   // For an edge, prefer the patch of the front-facing Bface.
   // For a face return its own patch.
   // For a vertex just return any adjacent patch.

   return is_edge(s) ? ((CBedge*)s)->patch() : get_patch(get_bface(s));
}

//! \brief Similar to get_patch(CBface*), but returns the control Patch.
//! \relates Patch
//! \relatesalso Bface
inline Patch*
get_ctrl_patch(CBface* f)
{
   Patch* p = get_patch(f);
   return p ? p->ctrl_patch() : 0;
}

//! \brief Similar to get_patch(CBsimplex*), but returns the control Patch.
//! \relates Patch
//! \relatesalso Bsimplex
inline Patch*
get_ctrl_patch(CBsimplex* s)
{
   Patch* p = get_patch(s);
   return p ? p->ctrl_patch() : 0;
}

/*****************************************************************
 * PatchEdgeFilter:
 *****************************************************************/
class PatchEdgeFilter : public SimplexFilter {
 public:
   PatchEdgeFilter(Patch* p) : _patch(p) {}

   virtual bool accept(CBsimplex* s) const {
      if (!is_edge(s))
         return false;
      Bedge* e = (Bedge*)s;
      return (
         !_patch                      ||
         get_patch(e->f1()) == _patch ||
         get_patch(e->f2()) == _patch
         );
   }

 protected:
   Patch*  _patch;
};

/*****************************************************************
 * PatchFaceFilter:
 *****************************************************************/
class PatchFaceFilter : public SimplexFilter {
 public:
   PatchFaceFilter(Patch* p) : _patch(p) {}

   virtual bool accept(CBsimplex* s) const {
      if (!is_face(s))
         return false;
      return ((Bface*)s)->patch() == _patch;
   }

 protected:
   Patch*  _patch;
};

/*****************************************************************
 * Patch_list
 *
 *   Defined in bmesh.H, inlined convenience methods defined here.
 *****************************************************************/
inline void
Patch_list::creases_changed() const
{
   for (int k=0; k<_num; k++)
      _array[k]->creases_changed();
}

inline void
Patch_list::triangulation_changed() const
{
   for (int k=0; k<_num; k++)
      _array[k]->triangulation_changed();
}

inline void
Patch_list::write_stream(ostream& os) const
{
   for (int k=0; k<_num; k++)
      _array[k]->write_stream(os);
}

inline void
Patch_list::delete_all()
{
   while (!empty())
      delete pop();
}

inline double 
Patch_list::min_alpha() const
{
   double ret=1;
   for (int k=0; k<_num; k++)
      ret = min(ret, _array[k]->transp());
   return ret;
}

#endif // PATCH_H_IS_INCLUDED

// end of file patch.H

---