icon2d.C

Go to the documentation of this file.

/*************************************************************************
 *    FILE: ICON2d.C
 *************************************************************************/

#include "std/support.H"
#include "glew/glew.H"

#include "disp/colors.H"
#include "geom/icon2d.H"

using namespace mlib;

static int tm=DECODER_ADD(ICON2D);

static bool debug = Config::get_var_bool("DEBUG_ICON2D",false);

DLhandler ICON2D::_dl;

void 
ICON2D::recompute_xform() 
{
   // If this ICON is attached to a 3D point, project it to screen space
   if (!_is2d) 
      _pt2d = xform().origin();
   else _pt2d = XYpt(xform().origin()[0], xform().origin()[1]);
}

ICON2D::ICON2D(Cstr_ptr &n, Cstr_ptr &filename, int num, bool tog, const mlib::PIXEL &p) :
   GEOM(n),
   _is2d(0),
   _center(0),
   _can_intersect(1),
   _show_boxes(0),
   _filename(Config::JOT_ROOT() + filename),
   _cam(num),
   _suppress_draw(false),
   _active(false),
   _toggle(false),
   _hide(false)
{  

   if (debug)
      cerr << "ICON2D::ICON2D: loading file: " << _filename << endl;
   
   //load "normal" state texture  
   _texture.push(new TEXTUREgl(_filename + ".png")); 
   assert(_texture[0]);
   _texture[0]->set_tex_unit(GL_TEXTURE0);
   _texture[0]->set_mipmap(false);
   _texture[0]->set_tex_fn(GL_REPLACE);

   if (_texture[0]->load_image()) {
      _suppress_draw = false;
   } else {
      cerr << "ICON2D error : texture not loaded" << endl;
      _suppress_draw = true;
   }

   //load "active" state texture
   if(tog)
   {
   _act_tex = new TEXTUREgl(_filename + "_active.png"); 
   assert(_act_tex);
   _act_tex->set_mipmap(false);
   _act_tex->set_tex_fn(GL_REPLACE);
   
   if (_act_tex->load_image()) {
      _suppress_draw = false;
   } else {
      cerr << "ICON2D error : active texture not loaded" << endl;
      _suppress_draw = true;
   }
   }
   //icon location
   _name = n;
   _toggle = tog;
   _pix = p;
   _currentTex = 0;
   _skins.push(_filename); //add the first skin to the array
}

/*************************************************************************
 * Function Name: ICON2D::draw
 * Parameters: 
 * Returns: int
 * Effects: 
 *************************************************************************/
int
ICON2D::draw(
   CVIEWptr &view
   )
{
   // leave the ID reference image alone,
   // and don't draw ICON into screen grabs:
   if (_suppress_draw || view->grabbing_screen() || _hide)
      return 0;
    
   assert(_texture[_currentTex]);
      
   //load identity for model view
   glMatrixMode(GL_MODELVIEW);
   glPushMatrix();
   glLoadIdentity();

   // Setup projection for drawing in PIXEL coords
   glMatrixMode(GL_PROJECTION);
   glPushMatrix();
   glLoadMatrixd(view->pix_proj().transpose().matrix());
   
   //set up needed attributes
   glPushAttrib(GL_ENABLE_BIT | GL_CURRENT_BIT);
   glDisable(GL_LIGHTING);      // GL_ENABLE_BIT
   
   // activate texture
   if(_toggle && _active)
      _act_tex->apply_texture();   // apply "active" state texture
   else
      _texture[_currentTex]->apply_texture();   // apply "normal" state texture

   // draw a textured quad in pixel space for the icon:
   glBegin(GL_QUADS);
   glTexCoord2f(0.0, 0.0); glVertex2d(_pix[0],_pix[1]);
   glTexCoord2f(1.0, 0.0); glVertex2d(_pix[0] + 32.0,_pix[1]);
   glTexCoord2f(1.0, 1.0); glVertex2d(_pix[0] + 32.0,_pix[1] + 32.0);
   glTexCoord2f(0.0, 1.0); glVertex2d(_pix[0],_pix[1] + 32.0);
   glEnd();

   //restore attributes
   glPopAttrib();

   glMatrixMode(GL_PROJECTION);
   glPopMatrix(); // unloads our projection matrix

   glMatrixMode(GL_MODELVIEW);
   glPopMatrix(); // unloads model matrix
   
   return 0; 
}

RAYhit &
ICON2D::intersect(
   RAYhit   &r,
   CWtransf &m,
   int       //uv
   ) const
{
        
   // Only pick ICON when it is associated w/ a 3D point and we know
   // the window size
   if (_can_intersect && !_suppress_draw) {
           
      //((ICON2D *)this)->recompute_xform(); // Update ICON location
      BBOX2D bbox(bbox2d(0,0));            // Get bounding box 


      //CXYpt pick_pt(r.point() + r.vec());
      PIXEL pick_pt(r.point() + r.vec());
      if (bbox.contains(pick_pt)) {  // picked!
         Wvec ray(r.point() - xform().origin());
         // assume ICON is always close to the camera
         // for now, that means 0.1 distance along viewing vector
         r.check(0, 0, 0, (ICON2D *)this, ray.normalized(), 
                 r.point() + r.vec()*0.1, Wpt::Origin(),
                 (APPEAR *) this, PIXEL());

         return r;
     }
   }


   GEOM::intersect(r,m); // Check if children were intersected
   return r;
}


/*************************************************************************
 * Function Name: icon2d::bbox
 * Effects: 
 *************************************************************************/

BBOX2D
ICON2D::bbox2d(
   int       border, 
   char     *s,
   int       force
   ) const
{
   PIXEL start, endpt;

   start = _pix;
   endpt = PIXEL(_pix[0] + 32.0,_pix[1] + 32.0);

   return BBOX2D(start, endpt);
}


   void 
   ICON2D::add_skin(Cstr_ptr &n)
   {
   _texture.push(new TEXTUREgl(_filename + ".png")); 
   assert(_texture[0]);
   _texture[0]->set_tex_unit(GL_TEXTURE0);
   _texture[0]->set_mipmap(false);
   _texture[0]->set_tex_fn(GL_REPLACE);

   if (_texture[0]->load_image()) {
      _suppress_draw = false;
   } else {
      cerr << "ICON2D error : texture not loaded" << endl;
      _suppress_draw = true;
   }
   _currentTex++;
   //_skins.push(n);
   }

   void 
   ICON2D::update_skin()
   {
   _currentTex++;
   if(_currentTex >= _texture.num())
      _currentTex = 0;
/*
   _texture = new TEXTUREgl(_skins[_current_skin] + ".png"); 
   assert(_texture);
   _texture->set_tex_unit(GL_TEXTURE0);
   _texture->set_mipmap(false);
   _texture->set_tex_fn(GL_REPLACE);

   if (_texture->load_image()) {
      _suppress_draw = false;
   } else {
      cerr << "ICON2D error : texture not loaded" << endl;
      _suppress_draw = true;
   }
   */
   }

---