gtexture.H

Go to the documentation of this file.

/**********************************************************************
 * gtexture.H
 **********************************************************************/
#ifndef GTEXTURE_H_IS_INCLUDED
#define GTEXTURE_H_IS_INCLUDED

#include "patch.H"
#include "stripcb.H"

/**********************************************************************
 * GTexture:
 *
 *      Base class for a procedural texture associated w/ a patch.
 *      Simple examples include procedures that just implement Gouraud
 *      shading or other conventional rendering styles. More inter-
 *      esting examples include "Graftal textures," as described in:
 *
 *        Michael A. Kowalski, Lee Markosian, J. D. Northrup, Lubomir
 *        Bourdev, Ronen Barzel, Loring S. Holden and John
 *        Hughes. Art-Based Rendering of Fur, Grass, and Trees,
 *        Proceedings of SIGGRAPH 99, Computer Graphics Proceedings,
 *        Annual Conference Series, pp. 433-438 (August 1999, Los
 *        Angeles, California). Addison Wesley Longman. Edited by Alyn
 *        Rockwood. ISBN 0-20148-560-5.
 **********************************************************************/
class GTexture : public DATA_ITEM, public BMESHdrawable {
 public:

   //******** MANAGERS ********

   GTexture(Patch* p = 0, StripCB* cb=0);
   virtual ~GTexture() { delete _cb; }  

   //******** RUN-TIME TYPE ID ********

   DEFINE_RTTI_METHODS3("Textured patch", GTexture*, DATA_ITEM, CDATA_ITEM *);
   STAT_STR_RET type() const { return class_name(); }

   //******** ACCESSORS ********

   Patch*       patch()         const   { return _patch; }
   BMESH*       mesh()          const   { return _patch ? _patch->mesh() : 0; }

   StripCB*     cb()            const   { return _cb; }
   void         set_cb(StripCB* cb)     { delete _cb; _cb = cb; } 

   GTexture*    ctrl()          const   { return _ctrl; }
   void         set_ctrl(GTexture* c)   { _ctrl = c; }

   //******** VIRTUAL METHODS ********

   virtual int  set_color(CCOLOR&)              { return 0; }
   virtual void changed()                       {}

   // Optional list of GTextures owned by this GTexture.
   // E.g., HiddenLineTexture owns a SolidColorTexture and
   // a WireframeTexture that do all the actual work.
   virtual GTexture_list gtextures() const { return GTexture_list(); }

   virtual void set_patch(Patch* p) {
      _patch = p;
      gtextures().set_patch(p);
      changed();
   }

   //******** FADING STUFF ********
   // XXX - under construction -- documentation pending
   //
   // these methods relate to fading between GTextures when
   // switching:
   //
   // push_alpha() and pop_alpha() exist as an alternative to adding
   // an alpha parameter to the regular draw() method:
   virtual void push_alpha(double a)  {
      _alphas += a;
      gtextures().push_alpha(a);
   }
   virtual void pop_alpha () {
      _alphas.pop();
      gtextures().pop_alpha();
   }
   double alpha() const {
      // include alpha from the patch, if any:
      double a = (_patch && _patch->has_transp()) ? _patch->transp() : 1.0;
      return a * (_alphas.empty() ? 1.0 : _alphas.last());
   }

   // The following is used for fading between GTextures when
   // switching. If the newly introduced GTexture knows the
   // outgoing one draws filled triangles of the Patch, then the
   // new one can draw first with alpha = 1, and the outgoing
   // GTexture can draw on top of it using an alpha corresponding
   // to how faded it is. If the outgoing GTexture doesn't draw
   // filled, the new one has to fade itself in.
   virtual bool draws_filled() const  { return true; }

   virtual void draw_with_alpha(double alpha) {
      push_alpha(alpha);
      draw(VIEW::peek());
      pop_alpha();
   }

   // The next 2 methods are given default implementations for
   // convenience. They work for simple GTextures like smooth
   // shading or wireframe. Compound GTextures like hidden
   // line have to override these. I.e., if the implementation
   // of hidden line style draws solid colored triangles with
   // wireframe over them, then in draw_filled_tris() it
   // should just draw the solid colored part, and in
   // draw_non_filled_tris() it should draw just the wireframe
   // part.
   virtual void draw_filled_tris(double alpha) {
      if (draws_filled())
         draw_with_alpha(alpha);
   }
   virtual void draw_non_filled_tris(double alpha) {
      if (!draws_filled())
         draw_with_alpha(alpha);
   }

   //******** I/O FUNCTIONS ********

   virtual int read_stream (istream &, str_list &)              { return 1;}
   virtual int write_data  (ostream &)                  const   { return 0;};
   virtual int write_stream(ostream &os) const {
      os << _begin_tag << class_name() << endl;
      write_data(os);
      os << _end_tag << endl; return 1;
   }

   //******** DATA_ITEM VIRTUAL FUNCTIONS ********

   virtual DATA_ITEM   *dup()        const { return 0; }
   virtual CTAGlist    &tags()       const;

 //*******************************************************
 // PROTECTED
 //*******************************************************
 protected:
   Patch*       _patch; // patch that owns this
   StripCB*     _cb;    // used for rendering tri strips etc.

   // for drawing the texture with a specified amount of
   // transparency thrown in:
   ARRAY<double> _alphas;

   // optional (usually nil) "controlling" texture that this one
   // defers to:
   GTexture*    _ctrl;

   // for I/O:
   static Cstr_ptr      _type_name;
   static Cstr_ptr      _begin_tag;
   static Cstr_ptr      _end_tag;
};

/*****************************************************************
 * GTexture_list
 *
 *   Defined in patch.H, inlined convenience methods defined here.
 *****************************************************************/

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

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

inline void
GTexture_list::set_patch(Patch* p) const
{
   for (int k=0; k<_num; k++)
      _array[k]->set_patch(p);
}

inline void
GTexture_list::push_alpha(double a) const
{
   for (int k=0; k<_num; k++)
      _array[k]->push_alpha(a);
}

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

// Given a Patch, return a particular type of texture (class G)
// to render the Patch. Create the texture if needed:
template <class G>
inline G*
get_tex(Patch* p)
{
   return p ? G::upcast(p->get_tex(G::static_name())) : 0;
}

#endif // GTEXTURE_H_IS_INCLUDED

// end of file gtexture.H

---