ref_img_client.H

Go to the documentation of this file.

/**********************************************************************
 * ref_img_client.H
 **********************************************************************/
#ifndef REF_IMG_CLIENT_IS_INCLUDED
#define REF_IMG_CLIENT_IS_INCLUDED

#include "net/data_item.H"

#define CVIEWptr const VIEWptr
class VIEWptr;

/*****************************************************************
 * RefImageClient:
 *
 *    An abstract base class that can make approprite drawing
 *    calls for creating various types of reference images.
 *
 *    (A reference image is an image read from the frame buffer
 *    into main memory so that it can be used by the program for
 *    some purpose.)
 *****************************************************************/
class RefImageClient {
 public:
   //******** ENUMS ********
   enum ref_img_t {
      REF_IMG_NONE    = 0,    // Should be
      REF_IMG_ID      = 1,    // powers of 2
      REF_IMG_COLOR   = 2,    // (after the first one)
      REF_IMG_COLOR_2 = 4,

      REF_IMG_ID_PRE1 = 8,    // Not really distinct images.
      REF_IMG_ID_PRE2 = 16,   // These are just additional
      REF_IMG_ID_PRE3 = 32,   // pre-passes of REF_IMG_ID.
      REF_IMG_ID_PRE4 = 64,   // No image should claim to be
                              // of these types.
      REF_IMG_TEX_MEM = 128
   };

   //******** MANAGERS ********
   RefImageClient() {}
   virtual ~RefImageClient() {}

   //******** RUN-TIME TYPE ID ********
   static  STAT_STR_RET static_name() { RET_STAT_STR("RefImageClient"); } 

   //******** DRAWING ********

   virtual int draw(CVIEWptr&) = 0;

   virtual int draw_id_ref()            { return 0; }
   virtual int draw_id_ref_pre1()       { return 0; }
   virtual int draw_id_ref_pre2()       { return 0; }
   virtual int draw_id_ref_pre3()       { return 0; }
   virtual int draw_id_ref_pre4()       { return 0; }
   virtual int draw_color_ref()         { return 0; }
   virtual int draw_color_ref_2()       { return 0; }
   virtual int draw_tex_mem_ref()       { return draw_color_ref(); }
   
   // Answers the question: what ref images does this client need?
   virtual ref_img_t use_ref_image() { return REF_IMG_NONE; }

   // The visibility reference image is used for O(1) picking 
   // (not counting the cost of preparing the image). Only invisible
   // objects should do nothing for this call ... other objects that
   // can't or won't do picking via the visibility reference image
   // should draw in solid black to cover up any objects occluded by
   // them:
   virtual int draw_vis_ref() { return 0; }

   // The ID reference image is a lot like the visibility reference
   // image, except for how it is used: to aid in some cases in
   // supporting sophisticated rendering. Thus the question of how to
   // draw it may depend on whether and how it will be used. Even if
   // it won't be used by this RefImageClient we should still draw
   // black (unless we're invisible), as explained above. A reasonable
   // default implementation is thus to draw the same way as for the
   // visibility reference image (e.g., invisible or solid black).
   // Other reference images are wholly optional:
   /*virtual int draw_ref_img(ref_img_t t) {
      return (t == REF_IMG_ID) ? draw_vis_ref() : 0;
   }*/
   virtual int draw_ref_img(ref_img_t t) {
      switch (t) {
       case   REF_IMG_ID:         return draw_id_ref();
       brcase REF_IMG_ID_PRE1:    return draw_id_ref_pre1();
       brcase REF_IMG_ID_PRE2:    return draw_id_ref_pre2();
       brcase REF_IMG_ID_PRE3:    return draw_id_ref_pre3();
       brcase REF_IMG_ID_PRE4:    return draw_id_ref_pre4();
       brcase REF_IMG_COLOR:      return draw_color_ref();
       brcase REF_IMG_COLOR_2:    return draw_color_ref_2();
       brcase REF_IMG_TEX_MEM:    return draw_tex_mem_ref();
       brdefault:                 return 0;
      }
      return 0;
   } 

   // Final pass rendering call, ignored by most, can be used to
   // draw strokes after visibility determination has been made:
   // (The return value doesn't mean anything.)
   virtual int draw_final(CVIEWptr &) { return 0; }
};
typedef const RefImageClient CRefImageClient;

/*****************************************************************
 * RefImageClient_array:
 *
 *   An ARRAY of RefImageClients with convenience methods
 *   for passing calls to all the items in the array.
 *
 *   We start with a generic templated ARRAY class RIC_array
 *   (and a parallel LIST class RIC_list) to allow arrays to
 *   be built for types DERIVED FROM RefImageClients.
 *
 *   E.g., if 'Bcurve' is a class derived from RefImageClient,
 *   we might like to have a Bcurve_array with these same
 *   convenience methods, but still be able to work with
 *   actual Bcurve* pointers. We could do so using:
 *
 *     typedef RIC_array<Bcurve> Bcurve_array;
 *
 *   If we wanted additional convenience methods specific to
 *   Bcurves, we would define the Bcurve_array type through
 *   subclassing.
 *****************************************************************/
template <class T>
class RIC_array : public ARRAY<T*> {
 public:

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

   RIC_array(int n=0)            : ARRAY<T*>(n) {}
   RIC_array(const ARRAY<T*>& l) : ARRAY<T*>(l) {}

   //******** CONVENIENCE ********

   int draw(CVIEWptr& v) const {
      int ret = 0;
      for (int i=0; i<num(); i++)
         ret += (*this)[i]->draw(v);
      return ret;
   }
   int draw_vis_ref() const {
      int ret = 0;
      for (int i=0; i<num(); i++)
         ret += (*this)[i]->draw_vis_ref();
      return ret;
   }
   int draw_id_ref() const {
      int ret = 0;
      for (int i=0; i<num(); i++)
         ret += (*this)[i]->draw_id_ref();
      return ret;
   }
   int draw_id_ref_pre1() const {
      int ret = 0;
      for (int i=0; i<num(); i++)
         ret += (*this)[i]->draw_id_ref_pre1();
      return ret;
   }
   int draw_id_ref_pre2() const {
      int ret = 0;
      for (int i=0; i<num(); i++)
         ret += (*this)[i]->draw_id_ref_pre2();
      return ret;
   }
   int draw_id_ref_pre3() const {
      int ret = 0;
      for (int i=0; i<num(); i++)
         ret += (*this)[i]->draw_id_ref_pre3();
      return ret;
   }
   int draw_id_ref_pre4() const {
      int ret = 0;
      for (int i=0; i<num(); i++)
         ret += (*this)[i]->draw_id_ref_pre4();
      return ret;
   }


   int draw_color_ref() const {
      int ret = 0;
      for (int i=0; i<num(); i++)
         ret += (*this)[i]->draw_color_ref();
      return ret;
   }
   int draw_color_ref_2() const {
      int ret = 0;
      for (int i=0; i<num(); i++)
         ret += (*this)[i]->draw_color_ref_2();
      return ret;
   }
   int draw_tex_mem_ref() const {
      int ret = 0;
      for (int i=0; i<num(); i++)
         ret += (*this)[i]->draw_tex_mem_ref();
      return ret;
   }
   int draw_ref_img(RefImageClient::ref_img_t t) const {
      int ret = 0;
      for (int i=0; i<num(); i++)
         ret += (*this)[i]->draw_ref_img(t);
      return ret;
   }
   int draw_final(CVIEWptr &v) const {
      int ret = 0;
      for (int i=0; i<num(); i++)
         ret += (*this)[i]->draw_final(v);
      return ret;
   }
   RefImageClient::ref_img_t use_ref_image() const {
      int ret = RefImageClient::REF_IMG_NONE;
      for (int i=0; i<num(); i++)
         ret |= (*this)[i]->use_ref_image();
      return (RefImageClient::ref_img_t) ret;
   }
   
   using ARRAY<T*>::num;
};

// Now we do it all over for LIST
//   XXX - How could we avoid this copied code?
template <class T>
class RIC_list : public LIST<T> {
 public:

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

   RIC_list(int n=0)            : LIST<T>(n) {}
   RIC_list(const LIST<T>& l)   : LIST<T>(l) {}

   //******** CONVENIENCE ********
   int draw(CVIEWptr& v) const {
      int ret = 0;
      for (int i=0; i<num(); i++)
         ret += (*this)[i]->draw(v);
      return ret;
   }
   int draw_vis_ref() const {
      int ret = 0;
      for (int i=0; i<num(); i++)
         ret += (*this)[i]->draw_vis_ref();
      return ret;
   }
   int draw_id_ref() const {
      int ret = 0;
      for (int i=0; i<num(); i++)
         ret += (*this)[i]->draw_id_ref();
      return ret;
   }

   int draw_id_ref_pre1() const {
      int ret = 0;
      for (int i=0; i<num(); i++)
         ret += (*this)[i]->draw_id_ref_pre1();
      return ret;
   }
   int draw_id_ref_pre2() const {
      int ret = 0;
      for (int i=0; i<num(); i++)
         ret += (*this)[i]->draw_id_ref_pre2();
      return ret;
   }
   int draw_id_ref_pre3() const {
      int ret = 0;
      for (int i=0; i<num(); i++)
         ret += (*this)[i]->draw_id_ref_pre3();
      return ret;
   }
   int draw_id_ref_pre4() const {
      int ret = 0;
      for (int i=0; i<num(); i++)
         ret += (*this)[i]->draw_id_ref_pre4();
      return ret;
   }

   int draw_color_ref() const {
      int ret = 0;
      for (int i=0; i<num(); i++)
         ret += (*this)[i]->draw_color_ref();
      return ret;
   }
   int draw_color_ref_2() const {
      int ret = 0;
      for (int i=0; i<num(); i++)
         ret += (*this)[i]->draw_color_ref_2();
      return ret;
   }
   int draw_tex_mem_ref() const {
      int ret = 0;
      for (int i=0; i<num(); i++)
         ret += (*this)[i]->draw_tex_mem_ref();
      return ret;
   }
   int draw_final(CVIEWptr &v) const {
      int ret = 0;
      for (int i=0; i<num(); i++)
         ret += (*this)[i]->draw_final(v);
      return ret;
   }
   int draw_ref_img(RefImageClient::ref_img_t t) const {
      int ret = 0;
      for (int i=0; i<num(); i++)
         ret += (*this)[i]->draw_ref_img(t);
      return ret;
   }
   RefImageClient::ref_img_t use_ref_image() const {
      int ret = RefImageClient::REF_IMG_NONE;
      for (int i=0; i<num(); i++)
         ret |= (*this)[i]->use_ref_image();
      return (RefImageClient::ref_img_t) ret;
   }

   using LIST<T>::num;
};

// Here we define a form of the array based on
// RefImageClient pointers:
typedef RIC_array<RefImageClient> RefImageClient_array;

#endif // REF_IMG_CLIENT_IS_INCLUDED

/* end of file ref_img_client.H */

---