root/OpenSceneGraph/trunk/src/osgUtil/IntersectVisitor.cpp @ 13041

Revision 13041, 22.2 kB (checked in by robert, 3 years ago)

Ran script to remove trailing spaces and tabs

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
Line 
1/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield
2 *
3 * This library is open source and may be redistributed and/or modified under
4 * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
5 * (at your option) any later version.  The full license is in LICENSE file
6 * included with this distribution, and on the openscenegraph.org website.
7 *
8 * This library is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11 * OpenSceneGraph Public License for more details.
12*/
13#include <osgUtil/IntersectVisitor>
14#include <osg/Transform>
15#include <osg/Geode>
16#include <osg/LOD>
17#include <osg/Billboard>
18#include <osg/Notify>
19#include <osg/TriangleFunctor>
20#include <osg/Geometry>
21#include <osg/Projection>
22#include <osg/Camera>
23#include <osg/io_utils>
24
25#include <float.h>
26#include <algorithm>
27#include <map>
28
29using namespace osg;
30using namespace osgUtil;
31
32
33
34Hit::Hit():
35        _ratio(0.0f),
36        _primitiveIndex(0)
37{
38}
39
40
41Hit::Hit(const Hit& hit)
42{
43    // copy data across.
44    _ratio = hit._ratio;
45    _originalLineSegment = hit._originalLineSegment;
46    _localLineSegment = hit._localLineSegment;
47    _nodePath = hit._nodePath;
48    _geode = hit._geode;
49    _drawable = hit._drawable;
50    _matrix = hit._matrix;
51    _inverse = hit._inverse;
52
53    _vecIndexList = hit._vecIndexList;
54    _primitiveIndex = hit._primitiveIndex;
55    _intersectPoint = hit._intersectPoint;
56    _intersectNormal = hit._intersectNormal;
57}
58
59
60Hit::~Hit()
61{
62}
63
64
65Hit& Hit::operator = (const Hit& hit)
66{
67    if (&hit==this) return *this;
68
69    _matrix = hit._matrix;
70    _inverse = hit._inverse;
71    _originalLineSegment = hit._originalLineSegment;
72    _localLineSegment = hit._localLineSegment;
73
74    // copy data across.
75    _ratio = hit._ratio;
76    _nodePath = hit._nodePath;
77    _geode = hit._geode;
78    _drawable = hit._drawable;
79
80    _vecIndexList = hit._vecIndexList;
81    _primitiveIndex = hit._primitiveIndex;
82    _intersectPoint = hit._intersectPoint;
83    _intersectNormal = hit._intersectNormal;
84
85    return *this;
86}
87
88const osg::Vec3 Hit::getWorldIntersectNormal() const
89{
90    if (_inverse.valid())
91    {
92        osg::Vec3 norm = osg::Matrix::transform3x3(*_inverse,_intersectNormal);
93        norm.normalize();
94        return norm;
95    }
96    else return _intersectNormal;
97}
98
99
100
101IntersectVisitor::IntersectState::IntersectState()
102{
103    _segmentMaskStack.push_back(0xffffffff);
104}
105
106
107IntersectVisitor::IntersectState::~IntersectState()
108{
109}
110
111
112bool IntersectVisitor::IntersectState::isCulled(const BoundingSphere& bs,LineSegmentMask& segMaskOut)
113{
114    bool hit = false;
115    LineSegmentMask mask = 0x00000001;
116    segMaskOut = 0x00000000;
117    LineSegmentMask segMaskIn = _segmentMaskStack.back();
118    for(IntersectState::LineSegmentList::iterator sitr=_segList.begin();
119        sitr!=_segList.end();
120        ++sitr)
121    {
122        if ((segMaskIn & mask) && (sitr->second)->intersect(bs))
123        {
124            segMaskOut = segMaskOut| mask;
125            hit = true;
126        }
127        mask = mask << 1;
128    }
129    return !hit;
130}
131
132bool IntersectVisitor::IntersectState::isCulled(const BoundingBox& bb,LineSegmentMask& segMaskOut)
133{
134    bool hit = false;
135    LineSegmentMask mask = 0x00000001;
136    segMaskOut = 0x00000000;
137    LineSegmentMask segMaskIn = _segmentMaskStack.back();
138    for(IntersectState::LineSegmentList::iterator sitr=_segList.begin();
139        sitr!=_segList.end();
140        ++sitr)
141    {
142        if ((segMaskIn & mask) && (sitr->second)->intersect(bb))
143        {
144            segMaskOut = segMaskOut| mask;
145            hit = true;
146        }
147        mask = mask << 1;
148    }
149    return !hit;
150}
151
152void IntersectVisitor::IntersectState::addLineSegment(osg::LineSegment* seg)
153{
154    // create a new segment transformed to local coordintes.
155    LineSegment* ns = new LineSegment;
156
157    if (_model_inverse.valid())
158    {
159        if (_view_inverse.valid())
160        {
161            osg::Matrix matrix = (*(_view_inverse)) * (*(_model_inverse));
162            ns->mult(*seg,matrix);
163        }
164        else
165        {
166            ns->mult(*seg,*(_model_inverse));
167        }
168    }
169    else if (_view_inverse.valid())
170    {
171        ns->mult(*seg,*(_view_inverse));
172    }
173    else
174    {
175        *ns = *seg;
176    }
177
178    _segList.push_back(LineSegmentPair(seg,ns));
179}
180
181
182IntersectVisitor::IntersectVisitor()
183{
184
185    // override the default node visitor mode.
186    setTraversalMode(NodeVisitor::TRAVERSE_ACTIVE_CHILDREN);
187
188    // Initialize eyepoint to 0,0,0
189    setEyePoint(Vec3(0.0f,0.0f,0.0f));
190
191    setLODSelectionMode(USE_HIGHEST_LEVEL_OF_DETAIL); // original IntersectVisitor behavior
192    //setLODSelectionMode(USE_SEGMENT_START_POINT_AS_EYE_POINT_FOR_LOD_LEVEL_SELECTION);
193
194    reset();
195}
196
197
198IntersectVisitor::~IntersectVisitor()
199{
200}
201
202
203void IntersectVisitor::reset()
204{
205    _intersectStateStack.clear();
206
207    // create a empty IntersectState on the the intersectStateStack.
208    _intersectStateStack.push_back(new IntersectState);
209
210    _segHitList.clear();
211
212}
213
214float IntersectVisitor::getDistanceToEyePoint(const Vec3& pos, bool /*withLODScale*/) const
215{
216    if (_lodSelectionMode==USE_SEGMENT_START_POINT_AS_EYE_POINT_FOR_LOD_LEVEL_SELECTION)
217    {
218        // OSG_NOTICE<<"IntersectVisitor::getDistanceToEyePoint)"<<(pos-getEyePoint()).length()<<std::endl;
219        // LODScale is not available to IntersectVisitor, so we ignore the withLODScale argument
220        //if (withLODScale) return (pos-getEyePoint()).length()*getLODScale();
221        //else return (pos-getEyePoint()).length();
222        return (pos-getEyePoint()).length();
223    }
224    else
225    {
226        return 0.0f;
227    }
228}
229
230
231bool IntersectVisitor::hits()
232{
233    for(LineSegmentHitListMap::iterator itr = _segHitList.begin();
234        itr != _segHitList.end();
235        ++itr)
236    {
237        if (!(itr->second.empty())) return true;
238    }
239    return false;
240}
241
242osg::Vec3 IntersectVisitor::getEyePoint() const
243{
244    const IntersectState* cis = _intersectStateStack.empty() ? 0 : _intersectStateStack.back().get();
245    if (cis && (cis->_model_inverse.valid() || cis->_view_inverse.valid()))
246    {
247
248        osg::Vec3 eyePoint = _pseudoEyePoint;
249        if (cis->_view_inverse.valid()) eyePoint = eyePoint * (*(cis->_view_inverse));
250        if (cis->_model_inverse.valid()) eyePoint = eyePoint * (*(cis->_model_inverse));
251
252        //OSG_NOTICE<<"IntersectVisitor::getEyePoint()"<<eyePoint<<std::endl;
253
254        return eyePoint;
255    }
256    else
257    {
258        return _pseudoEyePoint;
259    }
260}
261
262void IntersectVisitor::addLineSegment(LineSegment* seg)
263{
264    if (!seg) return;
265
266    if (!seg->valid())
267    {
268        OSG_WARN<<"Warning: invalid line segment passed to IntersectVisitor::addLineSegment(..)"<<std::endl;
269        OSG_WARN<<"         "<<seg->start()<<" "<<seg->end()<<" segment ignored.."<< std::endl;
270        return;
271    }
272
273    IntersectState* cis = _intersectStateStack.back().get();
274
275    if (cis->_segList.size()>=32)
276    {
277        OSG_WARN<<"Warning: excessive number of line segmenets passed to IntersectVisitor::addLineSegment(..), maximum permitted is 32 line segments."<<std::endl;
278        OSG_WARN<<"         "<<seg->start()<<" "<<seg->end()<<" segment ignored.."<< std::endl;
279        return;
280    }
281
282    setEyePoint(seg->start()); // set start of line segment to be pseudo EyePoint for billboarding and LOD purposes
283
284    // first check to see if segment has already been added.
285    for(IntersectState::LineSegmentList::iterator itr = cis->_segList.begin();
286        itr != cis->_segList.end();
287        ++itr)
288    {
289        if (itr->first == seg) return;
290    }
291
292    cis->addLineSegment(seg);
293
294}
295
296
297void IntersectVisitor::pushMatrix(RefMatrix* matrix, osg::Transform::ReferenceFrame rf)
298{
299    IntersectState* nis = new IntersectState;
300
301    IntersectState* cis = _intersectStateStack.back().get();
302
303    if (rf == osg::Transform::RELATIVE_RF)
304    {
305        // share the original view matrix
306        nis->_view_matrix = cis->_view_matrix;
307        nis->_view_inverse = cis->_view_inverse;
308
309        // set up new model matrix
310        nis->_model_matrix = matrix;
311        if (cis->_model_matrix.valid())
312        {
313            nis->_model_matrix->postMult(*(cis->_model_matrix));
314        }
315
316        RefMatrix* inverse_world = new RefMatrix;
317        inverse_world->invert(*(nis->_model_matrix));
318        nis->_model_inverse = inverse_world;
319    }
320    else
321    {
322        // set a new view matrix
323        nis->_view_matrix = matrix;
324
325        RefMatrix* inverse_world = new RefMatrix;
326        inverse_world->invert(*(nis->_view_matrix));
327        nis->_view_inverse = inverse_world;
328
329        // model matrix now blank.
330        nis->_model_matrix = 0;
331        nis->_model_inverse = 0;
332    }
333
334
335    IntersectState::LineSegmentMask segMaskIn = cis->_segmentMaskStack.back();
336    IntersectState::LineSegmentMask mask = 0x00000001;
337    for(IntersectState::LineSegmentList::iterator sitr=cis->_segList.begin();
338        sitr!=cis->_segList.end();
339        ++sitr)
340    {
341        if ((segMaskIn & mask))
342        {
343            nis->addLineSegment(sitr->first.get());
344        }
345        mask = mask << 1;
346    }
347
348    _intersectStateStack.push_back(nis);
349}
350
351
352void IntersectVisitor::popMatrix()
353{
354    if (!_intersectStateStack.empty())
355    {
356        _intersectStateStack.pop_back();
357    }
358}
359
360
361bool IntersectVisitor::enterNode(Node& node)
362{
363    const BoundingSphere& bs = node.getBound();
364    if (bs.valid() && node.isCullingActive())
365    {
366        IntersectState* cis = _intersectStateStack.back().get();
367        IntersectState::LineSegmentMask sm=0xffffffff;
368        if (cis->isCulled(bs,sm)) return false;
369        cis->_segmentMaskStack.push_back(sm);
370        return true;
371    }
372    else
373    {
374        IntersectState* cis = _intersectStateStack.back().get();
375        if (!cis->_segmentMaskStack.empty())
376            cis->_segmentMaskStack.push_back(cis->_segmentMaskStack.back());
377        else
378            cis->_segmentMaskStack.push_back(0xffffffff);
379
380        return true;
381    }
382}
383
384
385void IntersectVisitor::leaveNode()
386{
387    IntersectState* cis = _intersectStateStack.back().get();
388    cis->_segmentMaskStack.pop_back();
389}
390
391
392
393void IntersectVisitor::apply(Node& node)
394{
395    if (!enterNode(node)) return;
396
397    traverse(node);
398
399    leaveNode();
400}
401
402
403struct TriangleHit
404{
405    TriangleHit(unsigned int index, const osg::Vec3& normal, float r1, const osg::Vec3* v1, float r2, const osg::Vec3* v2, float r3, const osg::Vec3* v3):
406        _index(index),
407        _normal(normal),
408        _r1(r1),
409        _v1(v1),
410        _r2(r2),
411        _v2(v2),
412        _r3(r3),
413        _v3(v3) {}
414
415    unsigned int        _index;
416    const osg::Vec3     _normal;
417    float               _r1;
418    const osg::Vec3*    _v1;
419    float               _r2;
420    const osg::Vec3*    _v2;
421    float               _r3;
422    const osg::Vec3*    _v3;
423
424protected:
425
426    TriangleHit& operator = (const TriangleHit&) { return *this; }
427
428};
429
430
431struct TriangleIntersect
432{
433    osg::ref_ptr<LineSegment> _seg;
434
435    Vec3    _s;
436    Vec3    _d;
437    float   _length;
438
439    int _index;
440    float _ratio;
441    bool _hit;
442
443
444
445    typedef std::multimap<float,TriangleHit> TriangleHitList;
446
447    TriangleHitList _thl;
448
449    TriangleIntersect():
450        _length(0.0f),
451        _index(0),
452        _ratio(0.0f),
453        _hit(false)
454    {
455    }
456
457    TriangleIntersect(const LineSegment& seg,float ratio=FLT_MAX)
458    {
459        set(seg,ratio);
460    }
461
462    void set(const LineSegment& seg,float ratio=FLT_MAX)
463    {
464        _seg=new LineSegment(seg);
465        _hit=false;
466        _index = 0;
467        _ratio = ratio;
468
469        _s = _seg->start();
470        _d = _seg->end()-_seg->start();
471        _length = _d.length();
472        _d /= _length;
473    }
474
475    //   bool intersect(const Vec3& v1,const Vec3& v2,const Vec3& v3,float& r)
476    inline void operator () (const Vec3& v1,const Vec3& v2,const Vec3& v3, bool treatVertexDataAsTemporary)
477    {
478        ++_index;
479
480        if (v1==v2 || v2==v3 || v1==v3) return;
481
482        Vec3 v12 = v2-v1;
483        Vec3 n12 = v12^_d;
484        float ds12 = (_s-v1)*n12;
485        float d312 = (v3-v1)*n12;
486        if (d312>=0.0f)
487        {
488            if (ds12<0.0f) return;
489            if (ds12>d312) return;
490        }
491        else                     // d312 < 0
492        {
493            if (ds12>0.0f) return;
494            if (ds12<d312) return;
495        }
496
497        Vec3 v23 = v3-v2;
498        Vec3 n23 = v23^_d;
499        float ds23 = (_s-v2)*n23;
500        float d123 = (v1-v2)*n23;
501        if (d123>=0.0f)
502        {
503            if (ds23<0.0f) return;
504            if (ds23>d123) return;
505        }
506        else                     // d123 < 0
507        {
508            if (ds23>0.0f) return;
509            if (ds23<d123) return;
510        }
511
512        Vec3 v31 = v1-v3;
513        Vec3 n31 = v31^_d;
514        float ds31 = (_s-v3)*n31;
515        float d231 = (v2-v3)*n31;
516        if (d231>=0.0f)
517        {
518            if (ds31<0.0f) return;
519            if (ds31>d231) return;
520        }
521        else                     // d231 < 0
522        {
523            if (ds31>0.0f) return;
524            if (ds31<d231) return;
525        }
526
527
528        float r3;
529        if (ds12==0.0f) r3=0.0f;
530        else if (d312!=0.0f) r3 = ds12/d312;
531        else return; // the triangle and the line must be parallel intersection.
532
533        float r1;
534        if (ds23==0.0f) r1=0.0f;
535        else if (d123!=0.0f) r1 = ds23/d123;
536        else return; // the triangle and the line must be parallel intersection.
537
538        float r2;
539        if (ds31==0.0f) r2=0.0f;
540        else if (d231!=0.0f) r2 = ds31/d231;
541        else return; // the triangle and the line must be parallel intersection.
542
543        float total_r = (r1+r2+r3);
544        if (total_r!=1.0f)
545        {
546            if (total_r==0.0f) return; // the triangle and the line must be parallel intersection.
547            float inv_total_r = 1.0f/total_r;
548            r1 *= inv_total_r;
549            r2 *= inv_total_r;
550            r3 *= inv_total_r;
551        }
552
553        Vec3 in = v1*r1+v2*r2+v3*r3;
554        if (!in.valid())
555        {
556            OSG_WARN<<"Warning:: Picked up error in TriangleIntersect"<<std::endl;
557            OSG_WARN<<"   ("<<v1<<",\t"<<v2<<",\t"<<v3<<")"<<std::endl;
558            OSG_WARN<<"   ("<<r1<<",\t"<<r2<<",\t"<<r3<<")"<<std::endl;
559            return;
560        }
561
562        float d = (in-_s)*_d;
563
564        if (d<0.0f) return;
565        if (d>_length) return;
566
567        osg::Vec3 normal = v12^v23;
568        normal.normalize();
569
570        float r = d/_length;
571
572
573        if (treatVertexDataAsTemporary)
574        {
575            _thl.insert(std::pair<const float,TriangleHit>(r,TriangleHit(_index-1,normal,r1,0,r2,0,r3,0)));
576        }
577        else
578        {
579            _thl.insert(std::pair<const float,TriangleHit>(r,TriangleHit(_index-1,normal,r1,&v1,r2,&v2,r3,&v3)));
580        }
581        _hit = true;
582
583    }
584
585};
586
587bool IntersectVisitor::intersect(Drawable& drawable)
588{
589    bool hitFlag = false;
590
591    IntersectState* cis = _intersectStateStack.back().get();
592
593    const BoundingBox& bb = drawable.getBound();
594
595    for(IntersectState::LineSegmentList::iterator sitr=cis->_segList.begin();
596        sitr!=cis->_segList.end();
597        ++sitr)
598    {
599        if (sitr->second->intersect(bb))
600        {
601
602            TriangleFunctor<TriangleIntersect> ti;
603            ti.set(*sitr->second);
604            drawable.accept(ti);
605            if (ti._hit)
606            {
607
608                osg::Geometry* geometry = drawable.asGeometry();
609
610
611                for(TriangleIntersect::TriangleHitList::iterator thitr=ti._thl.begin();
612                    thitr!=ti._thl.end();
613                    ++thitr)
614                {
615
616                    Hit hit;
617                    hit._nodePath = _nodePath;
618                    hit._matrix = cis->_model_matrix;
619                    hit._inverse = cis->_model_inverse;
620                    hit._drawable = &drawable;
621                    if (_nodePath.empty()) hit._geode = NULL;
622                    else hit._geode = dynamic_cast<Geode*>(_nodePath.back());
623
624                    TriangleHit& triHit = thitr->second;
625
626                    hit._ratio = thitr->first;
627                    hit._primitiveIndex = triHit._index;
628                    hit._originalLineSegment = sitr->first;
629                    hit._localLineSegment = sitr->second;
630
631                    hit._intersectPoint = sitr->second->start()*(1.0f-hit._ratio)+
632                        sitr->second->end()*hit._ratio;
633
634                    hit._intersectNormal = triHit._normal;
635
636                    if (geometry)
637                    {
638                        osg::Vec3Array* vertices = dynamic_cast<osg::Vec3Array*>(geometry->getVertexArray());
639                        if (vertices)
640                        {
641                            osg::Vec3* first = &(vertices->front());
642                            if (triHit._v1) hit._vecIndexList.push_back(triHit._v1-first);
643                            if (triHit._v2) hit._vecIndexList.push_back(triHit._v2-first);
644                            if (triHit._v3) hit._vecIndexList.push_back(triHit._v3-first);
645                        }
646                    }
647
648
649                    _segHitList[sitr->first.get()].push_back(hit);
650
651                    std::sort(_segHitList[sitr->first.get()].begin(),_segHitList[sitr->first.get()].end());
652
653                    hitFlag = true;
654
655                }
656            }
657        }
658    }
659
660    return hitFlag;
661
662}
663
664void IntersectVisitor::apply(Geode& geode)
665{
666    if (!enterNode(geode)) return;
667
668    for(unsigned int i = 0; i < geode.getNumDrawables(); i++ )
669    {
670        intersect(*geode.getDrawable(i));
671    }
672
673    leaveNode();
674}
675
676
677void IntersectVisitor::apply(Billboard& node)
678{
679    if (!enterNode(node)) return;
680
681    // IntersectVisitor doesn't have getEyeLocal(), can we use NodeVisitor::getEyePoint()?
682    const Vec3& eye_local = getEyePoint();
683
684    for(unsigned int i = 0; i < node.getNumDrawables(); i++ )
685    {
686        const Vec3& pos = node.getPosition(i);
687        osg::ref_ptr<RefMatrix> billboard_matrix = new RefMatrix;
688        node.computeMatrix(*billboard_matrix,eye_local,pos);
689
690        pushMatrix(billboard_matrix.get(), osg::Transform::RELATIVE_RF);
691
692        intersect(*node.getDrawable(i));
693
694        popMatrix();
695
696    }
697
698    leaveNode();
699}
700
701
702void IntersectVisitor::apply(Group& node)
703{
704    if (!enterNode(node)) return;
705
706    traverse(node);
707
708    leaveNode();
709}
710
711
712void IntersectVisitor::apply(Transform& node)
713{
714    if (!enterNode(node)) return;
715
716    osg::ref_ptr<RefMatrix> matrix = new RefMatrix;
717    node.computeLocalToWorldMatrix(*matrix,this);
718
719    pushMatrix(matrix.get(), node.getReferenceFrame());
720
721    traverse(node);
722
723    popMatrix();
724
725    leaveNode();
726}
727
728
729void IntersectVisitor::apply(Switch& node)
730{
731    apply((Group&)node);
732}
733
734
735void IntersectVisitor::apply(LOD& node)
736{
737    apply((Group&)node);
738}
739
740PickVisitor::PickVisitor(const osg::Viewport* viewport, const osg::Matrixd& proj, const osg::Matrixd& view, float mx, float my):
741    _mx(mx),
742    _my(my),
743    _lastViewport(viewport),
744    _lastProjectionMatrix(proj),
745    _lastViewMatrix(view)
746{
747    setLODSelectionMode(USE_SEGMENT_START_POINT_AS_EYE_POINT_FOR_LOD_LEVEL_SELECTION);
748
749    if (viewport &&
750        mx >= static_cast<float>(viewport->x()) &&
751        my >= static_cast<float>(viewport->y()) &&
752        mx < static_cast<float>(viewport->x()+viewport->width()) &&
753        my < static_cast<float>(viewport->y()+viewport->height()))
754    {
755
756        // mouse pointer intersect viewport so we can proceed to set up a line segment
757        osg::Matrix MVPW = proj * viewport->computeWindowMatrix();
758        osg::Matrixd inverseMVPW;
759        inverseMVPW.invert(MVPW);
760
761        osg::Vec3 nearPoint = osg::Vec3(mx,my,0.0f) * inverseMVPW;
762        osg::Vec3 farPoint = osg::Vec3(mx,my,1.0f) * inverseMVPW;
763        osg::LineSegment* lineSegment = new osg::LineSegment;
764        lineSegment->set(nearPoint, farPoint);
765
766        IntersectState* cis = !_intersectStateStack.empty() ? _intersectStateStack.back().get() : 0;
767        if (cis)
768        {
769            cis->_view_matrix = new RefMatrix(view);
770            cis->_view_inverse = new RefMatrix;
771            cis->_view_inverse->invert(*(cis->_view_matrix));
772
773            cis->_model_matrix = 0;
774            cis->_model_inverse = 0;
775        }
776        else
777        {
778            OSG_NOTICE<<"Warning: PickVisitor not set up correctly, picking errors likely"<<std::endl;
779        }
780
781
782        addLineSegment(lineSegment);
783    }
784}
785
786void PickVisitor::runNestedPickVisitor(osg::Node& node, const osg::Viewport* viewport, const osg::Matrix& proj, const osg::Matrix& view, float mx, float my)
787{
788
789    PickVisitor newPickVisitor( viewport, proj, view, mx, my );
790    newPickVisitor.setTraversalMask(getTraversalMask());
791
792    newPickVisitor.getNodePath() = getNodePath();
793
794    // the new pickvisitor over the nodes children.
795    node.traverse( newPickVisitor );
796
797    for(LineSegmentHitListMap::iterator itr = newPickVisitor._segHitList.begin();
798        itr != newPickVisitor._segHitList.end();
799        ++itr)
800    {
801        _segHitList.insert(*itr);
802    }
803}
804
805void PickVisitor::apply(osg::Projection& projection)
806{
807    runNestedPickVisitor( projection,
808                          _lastViewport.get(),
809                          projection.getMatrix(),
810                          _lastViewMatrix,
811                          _mx, _my );
812}
813
814void PickVisitor::apply(osg::Camera& camera)
815{
816    if (!camera.isRenderToTextureCamera())
817    {
818        if (camera.getReferenceFrame()==osg::Camera::RELATIVE_RF)
819        {
820            if (camera.getTransformOrder()==osg::Camera::POST_MULTIPLY)
821            {
822                runNestedPickVisitor( camera,
823                                      camera.getViewport() ? camera.getViewport() : _lastViewport.get(),
824                                      _lastProjectionMatrix * camera.getProjectionMatrix(),
825                                      _lastViewMatrix * camera.getViewMatrix(),
826                                      _mx, _my );
827            }
828            else // PRE_MULTIPLY
829            {
830                runNestedPickVisitor( camera,
831                                      camera.getViewport() ? camera.getViewport() : _lastViewport.get(),
832                                      camera.getProjectionMatrix() * _lastProjectionMatrix,
833                                      camera.getViewMatrix() * _lastViewMatrix,
834                                      _mx, _my );
835            }
836        }
837        else
838        {
839            runNestedPickVisitor( camera,
840                                  camera.getViewport() ? camera.getViewport() : _lastViewport.get(),
841                                  camera.getProjectionMatrix(),
842                                  camera.getViewMatrix(),
843                                  _mx, _my );
844        }
845    }
846}
Note: See TracBrowser for help on using the browser.