Warning, /include/Geant4/tools/sg/pick_action is written in an unsupported language. File is not indexed.
0001 // Copyright (C) 2010, Guy Barrand. All rights reserved.
0002 // See the file tools.license for terms.
0003
0004 #ifndef tools_sg_pick_action
0005 #define tools_sg_pick_action
0006
0007 #include "matrix_action"
0008 #include "primitive_visitor"
0009
0010 #include "../lina/plane"
0011 #include "../vmanip"
0012
0013 #include "node"
0014
0015 namespace tools {
0016 namespace sg {
0017
0018 class pick_element {
0019 public:
0020 pick_element(sg::node& a_node,const std::vector<float>& a_zs,const std::vector<float>& a_ws,const sg::state& a_state)
0021 :m_node(a_node)
0022 ,m_zs(a_zs)
0023 ,m_ws(a_ws)
0024 ,m_state(a_state)
0025 {}
0026 virtual ~pick_element(){}
0027 public:
0028 pick_element(const pick_element& a_from)
0029 :m_node(a_from.m_node)
0030 ,m_zs(a_from.m_zs)
0031 ,m_ws(a_from.m_ws)
0032 ,m_state(a_from.m_state)
0033 {}
0034 pick_element& operator=(const pick_element& a_from){
0035 m_zs = a_from.m_zs;
0036 m_ws = a_from.m_ws;
0037 m_state = a_from.m_state;
0038 return *this;
0039 }
0040 public:
0041 const sg::node& node() const {return m_node;}
0042 sg::node& node() {return m_node;}
0043
0044 const std::vector<float>& zs() const {return m_zs;}
0045 std::vector<float>& zs() {return m_zs;}
0046
0047 const std::vector<float>& ws() const {return m_ws;}
0048 std::vector<float>& ws() {return m_ws;}
0049
0050 const sg::state& state() const {return m_state;}
0051 sg::state& state() {return m_state;}
0052 protected:
0053 sg::node& m_node;
0054 std::vector<float> m_zs;
0055 std::vector<float> m_ws;
0056 sg::state m_state;
0057 };
0058
0059 class pick_action : public matrix_action, public primitive_visitor {
0060 TOOLS_ACTION(pick_action,tools::sg::pick_action,matrix_action)
0061 protected:
0062
0063 virtual bool project(float& a_x,float& a_y,float& a_z,float& a_w) {
0064 return parent::project_point(a_x,a_y,a_z,a_w);
0065 }
0066
0067 virtual bool add_point(float a_x,float a_y,float a_z,float a_w) {
0068 if(is_inside(a_x,a_y,a_z,a_w)) { //we have a pick.
0069 m_done = true;
0070 return false; //to stop
0071 }
0072 return true; //continue.
0073 }
0074
0075 virtual bool add_point(float a_x,float a_y,float a_z,float a_w,
0076 float,float,float,float) {
0077 return pick_action::add_point(a_x,a_y,a_z,a_w);
0078 }
0079
0080 virtual bool add_line(float a_bx,float a_by,float a_bz,float a_bw,
0081 float a_ex,float a_ey,float a_ez,float a_ew) {
0082 if(is_inside(a_bx,a_by,a_bz,a_bw)) {
0083 m_done = true;
0084 return false;
0085 }
0086 if(is_inside(a_ex,a_ey,a_ez,a_ew)) {
0087 m_done = true;
0088 return false;
0089 }
0090 if(intersect_line(a_bx,a_by,a_bz,a_bw,
0091 a_ex,a_ey,a_ez,a_ew)) {
0092 m_done = true;
0093 return false;
0094 }
0095 return true;
0096 }
0097
0098 virtual bool add_line(float a_bx,float a_by,float a_bz,float a_bw,
0099 float,float,float,float,
0100 float a_ex,float a_ey,float a_ez,float a_ew,
0101 float,float,float,float){
0102 return pick_action::add_line(a_bx,a_by,a_bz,a_bw,a_ex,a_ey,a_ez,a_ew);
0103 }
0104
0105 virtual bool add_triangle(float a_p1x,float a_p1y,float a_p1z,float a_p1w,
0106 float a_p2x,float a_p2y,float a_p2z,float a_p2w,
0107 float a_p3x,float a_p3y,float a_p3z,float a_p3w){
0108 if(intersect_triangle(a_p1x,a_p1y,a_p1z,a_p1w,
0109 a_p2x,a_p2y,a_p2z,a_p2w,
0110 a_p3x,a_p3y,a_p3z,a_p3w)) {
0111 m_done = true;
0112 return false;
0113 }
0114 return true;
0115 }
0116
0117 virtual bool add_triangle(float a_p1x,float a_p1y,float a_p1z,float a_p1w,
0118 float,float,float,float,
0119 float a_p2x,float a_p2y,float a_p2z,float a_p2w,
0120 float,float,float,float,
0121 float a_p3x,float a_p3y,float a_p3z,float a_p3w,
0122 float,float,float,float){
0123 return pick_action::add_triangle(a_p1x,a_p1y,a_p1z,a_p1w,
0124 a_p2x,a_p2y,a_p2z,a_p2w,
0125 a_p3x,a_p3y,a_p3z,a_p3w);
0126 }
0127
0128 virtual bool project_normal(float&,float&,float&) {return true;}
0129 virtual bool add_point_normal(float a_x,float a_y,float a_z,float a_w,
0130 float,float,float) {
0131 return pick_action::add_point(a_x,a_y,a_z,a_w);
0132 }
0133
0134 virtual bool add_point_normal(float a_x,float a_y,float a_z,float a_w,
0135 float,float,float,
0136 float,float,float,float) {
0137 return pick_action::add_point(a_x,a_y,a_z,a_w);
0138 }
0139
0140 virtual bool add_line_normal(float a_bx,float a_by,float a_bz,float a_bw, float,float,float,
0141 float a_ex,float a_ey,float a_ez,float a_ew, float,float,float) {
0142 return pick_action::add_line(a_bx,a_by,a_bz,a_bw,a_ex,a_ey,a_ez,a_ew);
0143 }
0144 virtual bool add_line_normal(float a_bx,float a_by,float a_bz,float a_bw, float,float,float, float,float,float,float,
0145 float a_ex,float a_ey,float a_ez,float a_ew, float,float,float, float,float,float,float) {
0146 return pick_action::add_line(a_bx,a_by,a_bz,a_bw,a_ex,a_ey,a_ez,a_ew);
0147 }
0148
0149 virtual bool add_triangle_normal(float a_p1x,float a_p1y,float a_p1z,float a_p1w, float,float,float,
0150 float a_p2x,float a_p2y,float a_p2z,float a_p2w, float,float,float,
0151 float a_p3x,float a_p3y,float a_p3z,float a_p3w, float,float,float) {
0152 return pick_action::add_triangle(a_p1x,a_p1y,a_p1z,a_p1w,
0153 a_p2x,a_p2y,a_p2z,a_p2w,
0154 a_p3x,a_p3y,a_p3z,a_p3w);
0155 }
0156 virtual bool add_triangle_normal(float a_p1x,float a_p1y,float a_p1z,float a_p1w,
0157 float,float,float, float,float,float,float,
0158 float a_p2x,float a_p2y,float a_p2z,float a_p2w,
0159 float,float,float, float,float,float,float,
0160 float a_p3x,float a_p3y,float a_p3z,float a_p3w,
0161 float,float,float, float,float,float,float) {
0162 return pick_action::add_triangle(a_p1x,a_p1y,a_p1z,a_p1w,
0163 a_p2x,a_p2y,a_p2z,a_p2w,
0164 a_p3x,a_p3y,a_p3z,a_p3w);
0165 }
0166 public:
0167 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)
0168 :parent(a_out,a_ww,a_wh)
0169 ,m_l(a_l)
0170 ,m_r(a_r)
0171 ,m_b(a_b)
0172 ,m_t(a_t)
0173 ,m_stop_at_first(false) //same as selection
0174 ,m_done(false)
0175 ,m_node(0)
0176 {
0177 set_to_pick_ndc(); //OPTIMIZATION
0178 }
0179 virtual ~pick_action(){}
0180 public:
0181 pick_action(const pick_action& a_from)
0182 :parent(a_from)
0183 ,primitive_visitor(a_from)
0184 ,m_l(a_from.m_l)
0185 ,m_r(a_from.m_r)
0186 ,m_b(a_from.m_b)
0187 ,m_t(a_from.m_t)
0188 ,m_stop_at_first(a_from.m_stop_at_first)
0189 ,m_done(false)
0190 ,m_node(0)
0191 {
0192 set_to_pick_ndc(); //OPTIMIZATION
0193 }
0194 pick_action& operator=(const pick_action& a_from){
0195 parent::operator=(a_from);
0196 primitive_visitor::operator=(a_from);
0197 m_l = a_from.m_l;
0198 m_r = a_from.m_r;
0199 m_b = a_from.m_b;
0200 m_t = a_from.m_t;
0201 m_stop_at_first = a_from.m_stop_at_first;
0202 m_done = false;
0203 m_node = 0;
0204 m_zs.clear();
0205 m_ws.clear();
0206 m_picks.clear();
0207 set_to_pick_ndc(); //OPTIMIZATION
0208 return *this;
0209 }
0210 public:
0211 void reset() {
0212 parent::reset();
0213 m_done = false;
0214 m_node = 0;
0215 m_zs.clear();
0216 m_ws.clear();
0217 m_picks.clear();
0218 }
0219
0220 void set_win_size(unsigned a_ww,unsigned int a_wh) {
0221 m_ww = a_ww;
0222 m_wh = a_wh;
0223 sg::state& _state = state();
0224 _state.m_ww = a_ww;
0225 _state.m_wh = a_wh;
0226 m_states.clear();
0227 reset();
0228 }
0229
0230 void set_area(float a_l,float a_r,float a_b,float a_t) {
0231 // a_l,a_r,a_b,a_t are in window coordinates (pixels)
0232 // but handled in floats for intersection computation precision.
0233 // WARNING : we must have a_t>a_b and a_r>a_l. No check is done for that.
0234 m_l = a_l;
0235 m_r = a_r;
0236 m_b = a_b;
0237 m_t = a_t;
0238 set_to_pick_ndc(); //OPTIMIZATION
0239 }
0240
0241 void get_area(float& a_l,float& a_r,float& a_b,float& a_t) const {
0242 a_l = m_l;
0243 a_r = m_r;
0244 a_b = m_b;
0245 a_t = m_t;
0246 }
0247
0248 /////////////////////////////////////////////
0249 /////////////////////////////////////////////
0250 /////////////////////////////////////////////
0251 void set_stop_at_first(bool a_value) {m_stop_at_first = a_value;}
0252 bool stop_at_first() const {return m_stop_at_first;}
0253
0254 void set_done(bool a_value) {m_done = a_value;}
0255 bool done() const {return m_done;}
0256
0257 void set_node(sg::node* a_node) {m_node = a_node;}
0258 sg::node* node() const {return m_node;}
0259
0260 /////////////////////////////////////////////
0261 /////////////////////////////////////////////
0262 /////////////////////////////////////////////
0263 typedef pick_element pick_t;
0264
0265 void add_pick(sg::node& a_node,
0266 const std::vector<float>& a_zs,
0267 const std::vector<float>& a_ws,
0268 const sg::state& a_state) {
0269 m_picks.push_back(pick_t(a_node,a_zs,a_ws,a_state));
0270 }
0271 const std::vector<pick_t>& picks() const {return m_picks;}
0272
0273 void dump_picks() {
0274 m_out << "tools::sg::pick_action :"
0275 << " number of picks " << m_picks.size()
0276 << std::endl;
0277 std::vector<pick_t>::const_iterator it;
0278 for(it=m_picks.begin();it!=m_picks.end();++it) {
0279 m_out << " " << (*it).node().s_cls();
0280
0281 std::vector<float>::const_iterator itz;
0282 for(itz=(*it).zs().begin();itz!=(*it).zs().end();++itz) {
0283 m_out << " " << *itz;
0284 }
0285
0286 m_out << std::endl;
0287 }
0288 }
0289
0290 pick_t* closest_pick() {
0291 if(m_picks.empty()) return 0;
0292 //closest point is minimum z !
0293 // near -> -1
0294 // far -> 1
0295
0296 // find first pick_t with not empty zs :
0297 pick_t* pck = 0;
0298 float z;
0299 std::vector<pick_t>::const_iterator it;
0300 for(it=m_picks.begin();it!=m_picks.end();++it) {
0301 if(minimum((*it).zs(),z)) {
0302 pck = (pick_t*)&(*it);
0303 break;
0304 }
0305 }
0306 if(!pck) return 0;
0307 it++;
0308 for(;it!=m_picks.end();++it) {
0309 float zi;
0310 if(minimum((*it).zs(),zi)) {
0311 if(zi<=z) {
0312 pck = (pick_t*)&(*it);
0313 z = zi;
0314 }
0315 }
0316 }
0317 return pck;
0318 }
0319
0320 const std::vector<float>& zs() const {return m_zs;}
0321 std::vector<float>& zs() {return m_zs;}
0322
0323 const std::vector<float>& ws() const {return m_ws;}
0324 std::vector<float>& ws() {return m_ws;}
0325
0326 void set_matrices_to_identity() {
0327 projection_matrix() = m_identity;
0328 model_matrix() = m_identity;
0329 }
0330 void set_matrices_from_state() {
0331 const sg::state& _state = state();
0332 projection_matrix() = _state.m_proj;
0333 model_matrix() = _state.m_model;
0334 }
0335 public:
0336 bool add__primitive_xy(sg::node& a_node,
0337 gl::mode_t a_mode,
0338 size_t a_floatn,const float* a_xys,
0339 bool a_stop = false,
0340 bool a_triangle_revert = false){
0341 if(!a_floatn) return false;
0342 if(m_stop_at_first){
0343 add_primitive_xy(a_mode,a_floatn,a_xys,a_stop,a_triangle_revert);
0344 if(m_done) {
0345 m_node = &a_node;
0346 return true;
0347 }
0348 } else {
0349 m_done = false;
0350 m_zs.clear();
0351 add_primitive_xy(a_mode,a_floatn,a_xys,a_stop,a_triangle_revert);
0352 if(m_done) {
0353 add_pick(a_node,m_zs,m_ws,state());
0354 m_done = false;
0355 return true;
0356 }
0357 }
0358 return false;
0359 }
0360
0361 bool add__primitive_xy(sg::node& a_node,
0362 gl::mode_t a_mode,
0363 const std::vector<float>& a_xys,
0364 bool a_stop = false,
0365 bool a_triangle_revert = false){
0366 if(a_xys.empty()) return false;
0367 if(m_stop_at_first){
0368 add_primitive_xy(a_mode,a_xys,a_stop,a_triangle_revert);
0369 if(m_done) {
0370 m_node = &a_node;
0371 return true;
0372 }
0373 } else {
0374 m_done = false;
0375 m_zs.clear();
0376 add_primitive_xy(a_mode,a_xys,a_stop,a_triangle_revert);
0377 if(m_done) {
0378 add_pick(a_node,m_zs,m_ws,state());
0379 m_done = false;
0380 return true;
0381 }
0382 }
0383 return false;
0384 }
0385
0386 bool add__line_strip_xy(sg::node& a_node,size_t a_floatn,const float* a_xys,bool a_stop = false){
0387 if(!a_floatn) return false;
0388 if(m_stop_at_first){
0389 add_line_strip_xy(a_floatn,a_xys,a_stop);
0390 if(m_done) {
0391 m_node = &a_node;
0392 return true;
0393 }
0394 } else {
0395 m_done = false;
0396 m_zs.clear();
0397 add_line_strip_xy(a_floatn,a_xys,a_stop);
0398 if(m_done) {
0399 add_pick(a_node,m_zs,m_ws,state());
0400 m_done = false;
0401 return true;
0402 }
0403 }
0404 return false;
0405 }
0406
0407 bool add__lines_xy(sg::node& a_node,
0408 const std::vector<float>& a_xys,
0409 bool a_stop = false) {
0410 if(a_xys.empty()) return false;
0411 if(m_stop_at_first){
0412 add_lines_xy(a_xys,a_stop);
0413 if(m_done) {
0414 m_node = &a_node;
0415 return true;
0416 }
0417 } else {
0418 m_done = false;
0419 m_zs.clear();
0420 add_lines_xy(a_xys,a_stop);
0421 if(m_done) {
0422 add_pick(a_node,m_zs,m_ws,state());
0423 m_done = false;
0424 return true;
0425 }
0426 }
0427 return false;
0428 }
0429
0430 public:
0431 bool add__primitive(sg::node& a_node,gl::mode_t a_mode,size_t a_floatn,const float* a_xyzs,bool a_stop = false){
0432 if(!a_floatn) return false;
0433 if(m_stop_at_first){
0434 add_primitive(a_mode,a_floatn,a_xyzs,a_stop);
0435 if(m_done) {
0436 m_node = &a_node;
0437 return true;
0438 }
0439 } else {
0440 m_done = false;
0441 m_zs.clear();
0442 add_primitive(a_mode,a_floatn,a_xyzs,a_stop);
0443 if(m_done) {
0444 add_pick(a_node,m_zs,m_ws,state());
0445 m_done = false;
0446 return true;
0447 }
0448 }
0449 return false;
0450 }
0451
0452 bool add__primitive(sg::node& a_node,gl::mode_t a_mode,const std::vector<float>& a_xyzs,bool a_stop = false) {
0453 if(a_xyzs.empty()) return false;
0454 if(m_stop_at_first){
0455 add_primitive(a_mode,a_xyzs,a_stop);
0456 if(m_done) {
0457 m_node = &a_node;
0458 return true;
0459 }
0460 } else {
0461 m_done = false;
0462 m_zs.clear();
0463 add_primitive(a_mode,a_xyzs,a_stop);
0464 if(m_done) {
0465 add_pick(a_node,m_zs,m_ws,state());
0466 m_done = false;
0467 return true;
0468 }
0469 }
0470 return false;
0471 }
0472
0473 bool add__line_strip(sg::node& a_node,size_t a_floatn,const float* a_xyzs,bool a_stop = false){
0474 if(!a_floatn) return false;
0475 if(m_stop_at_first){
0476 add_line_strip(a_floatn,a_xyzs,a_stop);
0477 if(m_done) {
0478 m_node = &a_node;
0479 return true;
0480 }
0481 } else {
0482 m_done = false;
0483 m_zs.clear();
0484 add_line_strip(a_floatn,a_xyzs,a_stop);
0485 if(m_done) {
0486 add_pick(a_node,m_zs,m_ws,state());
0487 m_done = false;
0488 return true;
0489 }
0490 }
0491 return false;
0492 }
0493
0494 bool add__triangles(sg::node& a_node,
0495 size_t a_floatn,
0496 const float* a_xyzs,
0497 bool a_stop = false){
0498 if(!a_floatn) return false;
0499 if(m_stop_at_first){
0500 add_triangles(a_floatn,a_xyzs,a_stop);
0501 if(m_done) {
0502 m_node = &a_node;
0503 return true;
0504 }
0505 } else {
0506 m_done = false;
0507 m_zs.clear();
0508 add_triangles(a_floatn,a_xyzs,a_stop);
0509 if(m_done) {
0510 add_pick(a_node,m_zs,m_ws,state());
0511 m_done = false;
0512 return true;
0513 }
0514 }
0515 return false;
0516 }
0517
0518 bool add__lines(sg::node& a_node,
0519 const std::vector<float>& a_xyzs,
0520 bool a_stop = false){
0521 if(a_xyzs.empty()) return false;
0522 if(m_stop_at_first){
0523 add_lines(a_xyzs,a_stop);
0524 if(m_done) {
0525 m_node = &a_node;
0526 return true;
0527 }
0528 } else {
0529 m_done = false;
0530 m_zs.clear();
0531 add_lines(a_xyzs,a_stop);
0532 if(m_done) {
0533 add_pick(a_node,m_zs,m_ws,state());
0534 m_done = false;
0535 return true;
0536 }
0537 }
0538 return false;
0539 }
0540
0541 public: //for markers
0542 bool is_inside(float a_x,float a_y,float a_z,float a_w) {
0543 // In principle we should receive (because of proj x model matrix
0544 // mult of world coord points) point in [-1,1]x[-1,1].
0545
0546 float x,y;
0547 to_pick_ndc(a_x,a_y,x,y);
0548
0549 if(x<-1) return false;
0550 if(1<x) return false;
0551 if(y<-1) return false;
0552 if(1<y) return false;
0553
0554 m_zs.push_back(a_z);
0555 m_ws.push_back(a_w);
0556
0557 return true;
0558 }
0559 bool intersect_line(float a_bx,float a_by,float a_bz,float a_bw,
0560 float a_ex,float a_ey,float a_ez,float a_ew) {
0561
0562 // a_bz, a_ez are used only to compute the intersection point.
0563
0564 float bx,by;
0565 to_pick_ndc(a_bx,a_by,bx,by);
0566 float ex,ey;
0567 to_pick_ndc(a_ex,a_ey,ex,ey);
0568
0569 //no check on z is done.
0570 float bz = a_bz;
0571 float bw = a_bw;
0572 float ez = a_ez;
0573 float ew = a_ew;
0574
0575 bool toggle;
0576 if(!ortho_clip_line(bx,by,bz,bw, ex,ey,ez,ew, toggle)) return false;
0577
0578 m_zs.push_back(bz);
0579 m_ws.push_back(bw);
0580
0581 return true;
0582 }
0583
0584 protected:
0585 bool intersect_triangle(float a_1x,float a_1y,float a_1z,float a_1w,
0586 float a_2x,float a_2y,float a_2z,float a_2w,
0587 float a_3x,float a_3y,float a_3z,float a_3w) {
0588 //test a triangle.
0589
0590 if(is_inside(a_1x,a_1y,a_1z,a_1w)) return true;
0591 if(is_inside(a_2x,a_2y,a_2z,a_2w)) return true;
0592 if(is_inside(a_3x,a_3y,a_3z,a_3w)) return true;
0593
0594 // alll points are outside.
0595
0596 float x1,y1;
0597 to_pick_ndc(a_1x,a_1y,x1,y1);
0598 float x2,y2;
0599 to_pick_ndc(a_2x,a_2y,x2,y2);
0600
0601 bool toggle;
0602 float bx,by,bz,bw,ex,ey,ez,ew;
0603
0604 bx = x1;
0605 by = y1;
0606 bz = a_1z;
0607 bw = a_1w;
0608
0609 ex = x2;
0610 ey = y2;
0611 ez = a_2z;
0612 ew = a_2w;
0613 if(ortho_clip_line(bx,by,bz,bw, ex,ey,ez,ew, toggle)) {
0614 m_zs.push_back(bz);
0615 m_ws.push_back(bw);
0616 return true;
0617 }
0618
0619 float x3,y3;
0620 to_pick_ndc(a_3x,a_3y,x3,y3);
0621
0622 bx = x2;
0623 by = y2;
0624 bz = a_2z;
0625 bw = a_2w;
0626
0627 ex = x3;
0628 ey = y3;
0629 ez = a_3z;
0630 ew = a_3w;
0631 if(ortho_clip_line(bx,by,bz,bw, ex,ey,ez,ew, toggle)) {
0632 m_zs.push_back(bz);
0633 m_ws.push_back(bw);
0634 return true;
0635 }
0636
0637 bx = x1;
0638 by = y1;
0639 bz = a_1z;
0640 bw = a_1w;
0641
0642 ex = x3;
0643 ey = y3;
0644 ez = a_3z;
0645 ew = a_3w;
0646 if(ortho_clip_line(bx,by,bz,bw, ex,ey,ez,ew, toggle)) {
0647 m_zs.push_back(bz);
0648 m_ws.push_back(bw);
0649 return true;
0650 }
0651
0652 // no intersection with edges.
0653 // but the triangle may surround [-1,1]x[-1,1] !
0654
0655 // test if O=(0,0) is inside the triangle :
0656
0657 float xo = 0;
0658 float yo = 0;
0659
0660 {float cp2 = (x2-x1)*(y3-y1)-(y2-y1)*(x3-x1); //(2-1).cross(3-1)
0661 if(cp2==0) return false; // (1,2,3) aligned points.
0662 float cp1 = (x2-x1)*(yo-y1)-(y2-y1)*(xo-x1);
0663 if(cp1==0) { // O on (1,2). We can't pass here.
0664 return false;
0665 }
0666 if((cp1*cp2)<0) return false;} // O 3 not on same side than (1,2)
0667
0668 {float cp2 = (x3-x2)*(y1-y2)-(y3-y2)*(x1-x2); //(3-2).cross(1-2)
0669 if(cp2==0) return false; // (1,2,3) aligned points.
0670 float cp1 = (x3-x2)*(yo-y2)-(y3-y2)*(xo-x2);
0671 if(cp1==0) { // O on (2,3). We can't pass here.
0672 return false;
0673 }
0674 if((cp1*cp2)<0) return false;} // O 1 not on same side than (2,3)
0675
0676 {float cp2 = (x1-x3)*(y2-y3)-(y1-y3)*(x2-x3); //(1-3).cross(2-3)
0677 if(cp2==0) return false; // (1,2,3) aligned points.
0678 float cp1 = (x1-x3)*(yo-y3)-(y1-y3)*(xo-x3);
0679 if(cp1==0) { // O on (3,1). We can't pass here.
0680 return false;
0681 }
0682 if((cp1*cp2)<0) return false;} // O 2 not on same side than (3,1)
0683
0684 //get z of O=(0,0) on the triangle :
0685
0686 //NOTE : optimize ?
0687
0688 vec3f O(0,0,0);
0689 line<vec3f> ln(O,O+vec3f(0,0,1));
0690
0691 vec3f pz;
0692 {vec3f p1(x1,y1,a_1z);
0693 vec3f p2(x2,y2,a_2z);
0694 vec3f p3(x3,y3,a_3z);
0695 plane<vec3f> pl(p1,p2,p3);
0696 if(!pl.intersect(ln,pz)) {
0697 m_out << "pick_action::intersect_triangle :"
0698 << " z plane/line intersection failed."
0699 << std::endl;
0700 return false;
0701 }}
0702
0703 // we can get w by the same plane intersection by changing the zs to ws :
0704 // (in the xy plane, 1,2,3 points have same projection, then the
0705 // z axis intersection with the triangle hits the same point done with zs
0706 // than with ws).
0707 vec3f pw;
0708 {vec3f p1(x1,y1,a_1w);
0709 vec3f p2(x2,y2,a_2w);
0710 vec3f p3(x3,y3,a_3w);
0711 plane<vec3f> pl(p1,p2,p3);
0712 if(!pl.intersect(ln,pw)) {
0713 m_out << "pick_action::intersect_triangle :"
0714 << " plane/line intersection failed."
0715 << std::endl;
0716 return false;
0717 }}
0718
0719 m_zs.push_back(pz[2]);
0720 m_ws.push_back(pw[2]);
0721
0722 return true;
0723 }
0724 protected:
0725 void set_to_pick_ndc() { //OPTIMIZATION
0726 float cx = (m_l+m_r)/2;
0727 cx /= float(m_ww);
0728 cx *= 2;
0729 float cy = (m_b+m_t)/2;
0730 cy /= float(m_wh);
0731 cy *= 2;
0732
0733 float sx = m_r-m_l;
0734 sx /= float(m_ww);
0735 sx *= 2;
0736 float sy = m_t-m_b;
0737 sy /= float(m_wh);
0738 sy *= 2;
0739
0740 //then now cx,cy,sx,sw in [0,2]x[0,2] coords.
0741 cx -= 1;
0742 cy -= 1;
0743 //then now cx,cy,sx,sw in [-1,1]x[-1,1] coords.
0744 m_cx = cx;
0745 m_cy = cy;
0746 m_sx = sx;
0747 m_sy = sy;
0748 }
0749 void to_pick_ndc(const float& a_fx,const float& a_fy,float& a_x,float& a_y) const {
0750 a_x = 2*(a_fx-m_cx)/m_sx;
0751 a_y = 2*(a_fy-m_cy)/m_sy;
0752 }
0753 protected:
0754 static bool ortho_clip_line(float& a_bx,float& a_by,float& a_bz,float& a_bw,
0755 float& a_ex,float& a_ey,float& a_ez,float& a_ew,
0756 /*bool a_doz,*/bool& a_toggle) {
0757 // it tests against a [-1,1]x[-1,1] box.
0758
0759 // toggle means that at return begin contains end and end contains begin).
0760 //
0761 // begin out, end out
0762 // output : a_toggle = false, return false.
0763 // begin in, end in
0764 // output : a_toggle = false, return true.
0765 // begin in, end out
0766 // output : a_toggle = true, begin = clipping point, return true.
0767 // begin out, end in
0768 // output : a_toggle = false, begin = clipping point, return true.
0769
0770 a_toggle = false;
0771
0772 const unsigned int FILTER__NOZ = 0xf; //4 left right bits set to 1.
0773
0774 bool accept = false;
0775 bool done = false;
0776 do {
0777 unsigned int bout = ortho_out(a_bx,a_by/*,a_bz,a_doz*/);
0778 unsigned int eout = ortho_out(a_ex,a_ey/*,a_ez,a_doz*/);
0779 bool reject = ( (bout & eout & FILTER__NOZ) !=0 ? true : false);
0780 if(reject) { //begin and end have a common "outside bit" raised.
0781 done = true;
0782 } else {
0783 accept = !bout && !eout;
0784 if(accept) { //begin and end have all outside-bits to zero.
0785 done = true;
0786 } else {
0787 if(!bout) { // begin inside. toggle begin and end.
0788 unsigned int tout = eout;
0789 float tx = a_ex;
0790 float ty = a_ey;
0791 float tz = a_ez;
0792 float tw = a_ew;
0793
0794 eout = bout;
0795 a_ex = a_bx;
0796 a_ey = a_by;
0797 a_ez = a_bz;
0798 a_ew = a_bw;
0799
0800 bout = tout;
0801 a_bx = tx;
0802 a_by = ty;
0803 a_bz = tz;
0804 a_bw = tw;
0805
0806 a_toggle = true;
0807 }
0808 if(bout & (1<<0)) { // by > 1
0809 float t = a_ey - a_by;
0810 t = (1 - a_by)/t;
0811 a_bx += (a_ex - a_bx) * t;
0812 a_by = 1;
0813 a_bz += (a_ez - a_bz) * t;
0814 a_bw += (a_ew - a_bw) * t;
0815 } else if(bout & (1<<1)) { // by < -1
0816 float t = a_ey-a_by;
0817 t = (-1 - a_by)/t;
0818 a_bx += (a_ex - a_bx) * t;
0819 a_by = -1;
0820 a_bz += (a_ez - a_bz) * t;
0821 a_bw += (a_ew - a_bw) * t;
0822 } else if(bout & (1<<2)) { // bx > 1
0823 float t = a_ex-a_bx;
0824 t = (1 - a_bx)/t;
0825 a_bx = 1;
0826 a_by += (a_ey - a_by) * t;
0827 a_bz += (a_ez - a_bz) * t;
0828 a_bw += (a_ew - a_bw) * t;
0829 } else if(bout & (1<<3)) { // bx < -1
0830 float t = a_ex-a_bx;
0831 t = (-1 - a_bx)/t;
0832 a_bx = -1;
0833 a_by += (a_ey - a_by) * t;
0834 a_bz += (a_ez - a_bz) * t;
0835 a_bw += (a_ew - a_bw) * t;
0836 }
0837 }
0838 }
0839 } while (!done);
0840 return accept;
0841 }
0842
0843 static unsigned int ortho_out(float a_x,float a_y/*,float a_z,bool a_doz*/){
0844 unsigned int out = 0;
0845 if(a_y> 1) out |= (1<<0);
0846 if(a_y<-1) out |= (1<<1);
0847 if(a_x> 1) out |= (1<<2);
0848 if(a_x<-1) out |= (1<<3);
0849 return out;
0850 }
0851
0852 protected:
0853 // picking region (in window coordinates, (0,0) = bottom-left ) :
0854 float m_l;
0855 float m_r;
0856 float m_b;
0857 float m_t;
0858
0859 bool m_stop_at_first;
0860
0861 bool m_done;
0862 sg::node* m_node;
0863
0864 std::vector<float> m_zs;
0865 std::vector<float> m_ws;
0866 std::vector<pick_t> m_picks;
0867
0868 //OPTIMIZATION:
0869 float m_cx,m_cy,m_sx,m_sy;
0870 };
0871
0872 }}
0873
0874 #endif
