/Users/barrand/private/dev/softinex/old/inexlib-1.2/inlib/inlib/sg/pick_action

Go to the documentation of this file.

// Copyright (C) 2010, Guy Barrand. All rights reserved.
// See the file inlib.license for terms.

#ifndef inlib_sg_pick_action
#define inlib_sg_pick_action

// inheritance :
#include "mtx_action"

//#include "../cast"
#include "../mat4f"
#include "../vec2f"
//#include "cbk"

namespace inlib {
namespace sg {
  class node;
}}

namespace inlib {
namespace sg {

class pick_action : public mtx_action {
//public:
  //static const std::string& s_class() {
  //  static const std::string s_v("inlib::sg::pick_action");
  //  return s_v;
  //}
public:
/*
  virtual void* cast(const std::string& a_class) const {
    if(void* p = inlib::cmp_cast<pick_action>(this,a_class)) {return p;}
    if(void* p = inlib::cmp_cast<action>(this,a_class)) {return p;}
    return 0;
  }
*/
public:
  pick_action(std::ostream& a_out,
                     unsigned int a_ww,unsigned int a_wh,
                     float a_l,float a_r,
                     float a_b,float a_t)
  : mtx_action(a_out,a_ww,a_wh)
  ,m_l(a_l)
  ,m_r(a_r)
  ,m_b(a_b)
  ,m_t(a_t)
  ,m_done(false)
  ,m_node(0)
  {
    set_to_pick_ndc(); //OPTIMIZATION
  }
  virtual ~pick_action(){
    //clear_cbks();
  }
private:
  pick_action(const inlib::sg::pick_action& a_from)
  : mtx_action(a_from)
  {}
  inlib::sg::pick_action& operator=(const inlib::sg::pick_action& a_from){
    mtx_action::operator=(a_from);
    return *this;
  }
public:
  void reset() {
    mtx_action::reset();
    m_done = false;
    m_node = 0;
    //clear_cbks();
  }

  void set_done(bool a_value) {m_done = a_value;}
  bool done() const {return m_done;}

  void set_node(inlib::sg::node* a_node) {m_node = a_node;}
  inlib::sg::node* node() const {return m_node;}

/*
  void add_cbk(inlib::sg::cbk* a_cbk) {
    //we take ownership of a_cbk
    m_cbks.push_back(a_cbk);
  }
  bool has_cbks() {return m_cbks.empty()?false:true;}
  const std::vector<inlib::sg::cbk*>& cbks() const {return m_cbks;}

  //void exec_cbks() {
  //  std::vector<inlib::sg::cbk*>::iterator it;
  //  for(it=m_cbks.begin();it!=m_cbks.end();++it) {
  //    (*it)->action();
  //  }
  //}

  void clear_cbks() {
    std::vector<inlib::sg::cbk*>::iterator it;
    for(it=m_cbks.begin();it!=m_cbks.end();) {
      inlib::sg::cbk* cbk = *it;
      it = m_cbks.erase(it);        
      delete cbk;
    }    
    m_cbks.clear();
  }
*/

  void set_area(float a_l,float a_r,
                       float a_b,float a_t) {
    // a_l,a_r,a_b,a_t are in window coordinates (pixels)
    // but handled in floats for intersection computation precision.
    // WARNING : we must have a_t>a_b and a_r>a_l. No check is done for that. 
    m_l = a_l;
    m_r = a_r;
    m_b = a_b;
    m_t = a_t;
    set_to_pick_ndc(); //OPTIMIZATION
  }

  bool is_inside(float a_x,float a_y) const {
    //std::cout << "debug : inlib::sg::pick_action::is_inside :"
    //      << " x " << a_x
    //      << " y " << a_y
    //      << std::endl;

    // In principle we should receive (because of proj x model matrix
    // mult of world coord points) point in [-1,1]x[-1,1].

    float x,y;
    to_pick_ndc(a_x,a_y,x,y);

    if(x<-1) return false;
    if(1<x) return false;
    if(y<-1) return false;
    if(1<y) return false;

    //std::cout << "debug : inlib::sg::pick_action::is_inside :"
    //      << " inside !"
    //      << std::endl;

    return true;
  }
  bool intersect(float a_bx,float a_by,
                        float a_ex,float a_ey) const {

    // ortho_clip_line works by testing against a [-1,1]x[-1,1] box.
    // In principle we should receive (because of proj x model matrix
    // mult of world coord points) points in [-1,1]x[-1,1] too.

    float bx,by;
    to_pick_ndc(a_bx,a_by,bx,by);

    float ex,ey;
    to_pick_ndc(a_ex,a_ey,ex,ey);

    //no check on z is done.
    float bz = 0;
    float ez = 0;

    bool toggle;
    bool status = ortho_clip_line(bx,by,bz,ex,ey,ez,false,toggle);

    //if(status) {
    //  std::cout << "debug : inlib::sg::pick_action::intersect :"
    //        << " intersect !"
    //        << std::endl;
    //}

    return status;
  }

  bool intersect(float a_1x,float a_1y,
                        float a_2x,float a_2y,
                        float a_3x,float a_3y) const {
    //test a triangle.

    if(is_inside(a_1x,a_1y)) return true;
    if(is_inside(a_2x,a_2y)) return true;
    if(is_inside(a_3x,a_3y)) return true;
    
    // alll points are outside. 

    if(intersect(a_1x,a_1y, a_2x,a_2y)) return true;
    if(intersect(a_2x,a_2y, a_3x,a_3y)) return true;
    if(intersect(a_1x,a_1y, a_3x,a_3y)) return true;

    // no intersection with edges.
    // but the triangle may surround [-1,1]x[-1,1] !

    float x1,y1;
    to_pick_ndc(a_1x,a_1y,x1,y1);
    float x2,y2;
    to_pick_ndc(a_2x,a_2y,x2,y2);
    float x3,y3;
    to_pick_ndc(a_3x,a_3y,x3,y3);

    // test if (0,0) is inside the triangle :    
    inlib::vec2f p1(x1,y1);
    inlib::vec2f p2(x2,y2);
    inlib::vec2f p3(x3,y3);

    //std::cout << "pick_action::intersect : " << std::endl;
    //std::cout << " p1 " << p1[0] << " " << p1[1] << std::endl;
    //std::cout << " p2 " << p2[0] << " " << p2[1] << std::endl;
    //std::cout << " p3 " << p3[0] << " " << p3[1] << std::endl;

    inlib::vec2f o(0,0);

   {float cp2 = (p2-p1).cross(p3-p1);
    if(cp2==0) return false;       // (p1,p2,p3) aligned points.
    float cp1 = (p2-p1).cross( o-p1);
    if(cp1==0) return true;        // o on (p1,p2). We can't pass here.
    if((cp1*cp2)<0) return false;} // o p3 not on same side than (p1,p2)

   {float cp2 = (p3-p2).cross(p1-p2);
    if(cp2==0) return false;       // (p1,p2,p3) aligned points.
    float cp1 = (p3-p2).cross( o-p2);
    if(cp1==0) return true;        // o on (p2,p3). We can't pass here.
    if((cp1*cp2)<0) return false;} // o p1 not on same side than (p2,p3)

   {float cp2 = (p1-p3).cross(p2-p3);
    if(cp2==0) return false;       // (p1,p2,p3) aligned points.
    float cp1 = (p1-p3).cross( o-p3);
    if(cp1==0) return true;        // o on (p3,p1). We can't pass here.
    if((cp1*cp2)<0) return false;} // o p2 not on same side than (p3,p1)

    //std::cout << " (0,0) inside. " << std::endl;

    return true;
  }
private:
  void set_to_pick_ndc() { //OPTIMIZATION
    float cx = (m_l+m_r)/2;
    cx /= float(m_ww);
    cx *= 2;
    float cy = (m_b+m_t)/2;
    cy /= float(m_wh);
    cy *= 2;

    float sx = m_r-m_l;
    sx /= float(m_ww);
    sx *= 2;
    float sy = m_t-m_b;
    sy /= float(m_wh);
    sx *= 2;

    //then now cx,cy,sx,sw in [0,2]x[0,2] coords.
    cx -= 1;
    cy -= 1;
    //then now cx,cy,sx,sw in [-1,1]x[-1,1] coords.

    m_cx = cx;
    m_cy = cy;
    m_sx = sx;
    m_sy = sy;
  }
  void to_pick_ndc(const float& a_fx,const float& a_fy,
                     float& a_x,float& a_y) const {
    a_x = 2*(a_fx-m_cx)/m_sx;
    a_y = 2*(a_fy-m_cy)/m_sy;
  }
private:
  static bool ortho_clip_line(float& a_bx,float& a_by,float& a_bz,
                              float& a_ex,float& a_ey,float& a_ez,
                              bool a_doz,bool& a_toggle) {

    // toggle means that at return begin contains end and end contains begin).
    //
    // begin out, end out
    //   output : a_toggle = false, return false.
    // begin in, end  in
    //   output : a_toggle = false, return true.
    // begin in, end out
    //   output : a_toggle = true, begin = clipping point, return true.
    // begin out, end  in
    //   output : a_toggle = false, begin = clipping point, return true.

    a_toggle = false;

    const unsigned int FILTER__NOZ = 0xf;   //4 left right bits set to 1.
    //const unsigned int FILTER__Z = 0x3f;  //6 left right bits set to 1.

    bool accept = false;
    bool done = false;
    do {
      unsigned int bout = ortho_out(a_bx,a_by,a_bz,a_doz);
      unsigned int eout = ortho_out(a_ex,a_ey,a_ez,a_doz);
      bool reject = ( (bout & eout & FILTER__NOZ) !=0  ? true : false);
      if(reject) { //begin and end have a common "outside bit" raised.
        done = true;
      } else {
        accept = !bout && !eout;
        if(accept) { //begin and end have all outside-bits to zero.
          done = true;
        } else {
          if(!bout) { // begin inside. toggle begin and end.
            unsigned int tout = eout;
            float tx = a_ex;
            float ty = a_ey;
            float tz = a_ez;

            eout = bout;
            a_ex = a_bx;
            a_ey = a_by;
            a_ez = a_bz;

            bout = tout;
            a_bx = tx;
            a_by = ty;
            a_bz = tz;

            a_toggle = true;
          }
          if(bout & (1<<0)) { // by > 1
            float t = a_ey - a_by;
            //CHECK_DIV(t,"ClipLineParallel")
            t = (1 - a_by)/t;
            a_bx += (a_ex - a_bx) * t;
            a_by  = 1;
            a_bz += (a_ez - a_bz) * t;
          } else if(bout & (1<<1)) { // by < -1
            float t = a_ey-a_by;
            //CHECK_DIV(t,"ClipLineParallel")
            t = (-1 - a_by)/t;
            a_bx += (a_ex - a_bx) * t;
            a_by  = -1;
            a_bz += (a_ez - a_bz) * t;
          } else if(bout & (1<<2)) { // bx > 1
            float t = a_ex-a_bx;
            //CHECK_DIV    (t,"ClipLineParallel")
            t = (1 - a_bx)/t;
            a_bx  = 1;
            a_by += (a_ey - a_by) * t;
            a_bz += (a_ez - a_bz) * t;
          } else if(bout & (1<<3)) { // bx < -1
            float t = a_ex-a_bx;
            //CHECK_DIV    (t,"ClipLineParallel")
            t = (-1 - a_bx)/t;
            a_bx  = -1;
            a_by += (a_ey - a_by) * t;
            a_bz += (a_ez - a_bz) * t;
          }
          // z = -1.
          // z =  0.
          // G.Barrand : do not do z clipping
       /* else if(a_doz && (bout & (1<<4)) ) { //bz < -1 
            float t = a_ez-a_bz;
            //CHECK_DIV    (t,"ClipLineParallel")
            t = (-1 - a_z)/t;
            a_bx += (a_ex - a_bx) * t;
            a_by += (a_ey - a_by) * t;
            a_bz  = -1;
          } else if(a_doz && (bout & (1<<5)) ) { //bz > 0
            t = a_ez - a_bz;
            //CHECK_DIV    (t,"ClipLineParallel")
            t = (- a_bz)/t;
            a_bx += (a_ex - a_bx) * t;
            a_by += (a_ey - a_by) * t;
            a_bz  = 0;
          } */
        }
      }
    } while (!done);
    return accept;
  }

  static unsigned int ortho_out(float a_x,float a_y,float a_z,bool a_doz){
    unsigned int out = 0;
    if(a_y> 1) out |= (1<<0);
    if(a_y<-1) out |= (1<<1);
    if(a_x> 1) out |= (1<<2);
    if(a_x<-1) out |= (1<<3);
    if(!a_doz) return out;
    if(a_z<-1) out |= (1<<4);
    if(a_z> 0) out |= (1<<5);
    return out;
  }

private:
  // picking region (in window coordinates, (0,0) = bottom-left ) :
  float m_l;
  float m_r;
  float m_b;
  float m_t;
  
  bool m_done;
  inlib::sg::node* m_node;
  //std::vector<inlib::sg::cbk*> m_cbks;

  //OPTIMIZATION:
  float m_cx,m_cy,m_sx,m_sy;
};

}}

#endif