root/OpenSceneGraph/trunk/src/osgViewer/CompositeViewer.cpp @ 9868

Revision 9868, 35.0 kB (checked in by robert, 5 years ago)

Preliminary work on general purpose incremental compile support in osgViewer.

  • 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
14#include <osg/GLExtensions>
15#include <osgUtil/GLObjectsVisitor>
16#include <osgGA/TrackballManipulator>
17#include <osgViewer/CompositeViewer>
18#include <osgViewer/Renderer>
19#include <osgDB/Registry>
20
21#include <osg/io_utils>
22
23using namespace osgViewer;
24
25CompositeViewer::CompositeViewer()
26{
27    constructorInit();
28}
29
30CompositeViewer::CompositeViewer(const CompositeViewer& cv,const osg::CopyOp& copyop):
31    ViewerBase()
32{
33    constructorInit();
34}
35
36CompositeViewer::CompositeViewer(osg::ArgumentParser& arguments)
37{
38    constructorInit();
39   
40    std::string filename;
41    bool readConfig = false;
42    while (arguments.read("-c",filename))
43    {
44        readConfig = readConfiguration(filename) || readConfig;
45    }
46
47    while (arguments.read("--SingleThreaded")) setThreadingModel(SingleThreaded);
48    while (arguments.read("--CullDrawThreadPerContext")) setThreadingModel(CullDrawThreadPerContext);
49    while (arguments.read("--DrawThreadPerContext")) setThreadingModel(DrawThreadPerContext);
50    while (arguments.read("--CullThreadPerCameraDrawThreadPerContext")) setThreadingModel(CullThreadPerCameraDrawThreadPerContext);
51
52    osg::DisplaySettings::instance()->readCommandLine(arguments);
53    osgDB::readCommandLine(arguments);
54}
55
56void CompositeViewer::constructorInit()
57{
58    _endBarrierPosition = AfterSwapBuffers;
59    _startTick = 0;
60
61    // make sure View is safe to reference multi-threaded.
62    setThreadSafeRefUnref(true);
63
64    _frameStamp = new osg::FrameStamp;
65    _frameStamp->setFrameNumber(0);
66    _frameStamp->setReferenceTime(0);
67    _frameStamp->setSimulationTime(0);
68   
69    _eventVisitor = new osgGA::EventVisitor;
70    _eventVisitor->setFrameStamp(_frameStamp.get());
71   
72    _updateVisitor = new osgUtil::UpdateVisitor;
73    _updateVisitor->setFrameStamp(_frameStamp.get());
74
75    setViewerStats(new osg::Stats("CompsiteViewer"));
76}
77
78CompositeViewer::~CompositeViewer()
79{
80    osg::notify(osg::INFO)<<"CompositeViewer::~CompositeViewer()"<<std::endl;
81
82    stopThreading();
83   
84    Scenes scenes;
85    getScenes(scenes);
86   
87    for(Scenes::iterator sitr = scenes.begin();
88        sitr != scenes.end();
89        ++sitr)
90    {
91        Scene* scene = *sitr;
92        if (scene->getDatabasePager())
93        {
94            scene->getDatabasePager()->cancel();
95            scene->setDatabasePager(0);
96        }
97    }
98
99    Contexts contexts;
100    getContexts(contexts);
101
102    // clear out all the previously assigned operations
103    for(Contexts::iterator citr = contexts.begin();
104        citr != contexts.end();
105        ++citr)
106    {
107        (*citr)->close();
108    }
109
110    osg::notify(osg::INFO)<<"finished CompositeViewer::~CompsiteViewer()"<<std::endl;
111}
112
113bool CompositeViewer::readConfiguration(const std::string& filename)
114{
115    osg::notify(osg::NOTICE)<<"CompositeViewer::readConfiguration("<<filename<<")"<<std::endl;
116    return false;
117}
118
119
120void CompositeViewer::addView(osgViewer::View* view)
121{
122    if (!view) return;
123
124    bool alreadyRealized = isRealized();
125   
126    bool threadsWereRuinning = _threadsRunning;
127    if (threadsWereRuinning) stopThreading();
128
129    _views.push_back(view);
130   
131    view->_viewerBase = this;
132   
133    if (view->getSceneData())
134    {       
135        // make sure that existing scene graph objects are allocated with thread safe ref/unref
136        if (getThreadingModel()!=ViewerBase::SingleThreaded)
137        {
138            view->getSceneData()->setThreadSafeRefUnref(true);
139        }
140       
141        // update the scene graph so that it has enough GL object buffer memory for the graphics contexts that will be using it.
142        view->getSceneData()->resizeGLObjectBuffers(osg::DisplaySettings::instance()->getMaxNumberOfGraphicsContexts());
143    }
144
145    view->setFrameStamp(_frameStamp.get());
146   
147    if (alreadyRealized)
148    {
149        Contexts contexts;
150        if (view->getCamera()->getGraphicsContext())
151        {
152            contexts.push_back(view->getCamera()->getGraphicsContext());
153        }
154        for(unsigned int i=0; i<view->getNumSlaves(); ++i)
155        {
156            if (view->getSlave(i)._camera->getGraphicsContext())
157            {
158                contexts.push_back(view->getSlave(i)._camera->getGraphicsContext());
159            }
160        }
161
162        for(Contexts::iterator itr = contexts.begin();
163            itr != contexts.end();
164            ++itr)
165        {
166            if (!((*itr)->isRealized()))
167            {
168                (*itr)->realize();
169            }
170        }
171
172    }
173   
174    if (threadsWereRuinning) startThreading();
175}
176
177void CompositeViewer::removeView(osgViewer::View* view)
178{
179    for(RefViews::iterator itr = _views.begin();
180        itr != _views.end();
181        ++itr)
182    {
183        if (*itr == view)
184        {
185            bool threadsWereRuinning = _threadsRunning;
186            if (threadsWereRuinning) stopThreading();
187
188            view->_viewerBase = 0;
189
190            _views.erase(itr);
191
192            if (threadsWereRuinning) startThreading();
193
194            return;
195        }
196    }
197}
198
199bool CompositeViewer::isRealized() const
200{
201    Contexts contexts;
202    const_cast<CompositeViewer*>(this)->getContexts(contexts);
203
204    unsigned int numRealizedWindows = 0;
205
206    // clear out all the previously assigned operations
207    for(Contexts::iterator citr = contexts.begin();
208        citr != contexts.end();
209        ++citr)
210    {
211        if ((*citr)->isRealized()) ++numRealizedWindows;
212    }
213   
214    return numRealizedWindows > 0;
215}
216
217int CompositeViewer::run()
218{
219    for(RefViews::iterator itr = _views.begin();
220        itr != _views.end();
221        ++itr)
222    {
223        osgViewer::View* view = itr->get();
224        if ((view->getCameraManipulator()==0) && view->getCamera()->getAllowEventFocus())
225        {
226            view->setCameraManipulator(new osgGA::TrackballManipulator());
227        }
228    }
229       
230    setReleaseContextAtEndOfFrameHint(false);
231
232    return ViewerBase::run();
233}
234
235void CompositeViewer::setStartTick(osg::Timer_t tick)
236{
237    _startTick = tick;
238   
239    for(RefViews::iterator vitr = _views.begin();
240        vitr != _views.end();
241        ++vitr)
242    {
243        (*vitr)->setStartTick(tick);
244    }
245   
246    Contexts contexts;
247    getContexts(contexts,false);
248
249    for(Contexts::iterator citr = contexts.begin();
250        citr != contexts.end();
251        ++citr)
252    {
253        osgViewer::GraphicsWindow* gw = dynamic_cast<osgViewer::GraphicsWindow*>(*citr);
254        if (gw)
255        {
256            gw->getEventQueue()->setStartTick(_startTick);
257        }
258    }
259}
260
261
262void CompositeViewer::setReferenceTime(double time)
263{
264    osg::Timer_t tick = osg::Timer::instance()->tick();
265    double currentTime = osg::Timer::instance()->delta_s(_startTick, tick);
266    double delta_ticks = (time-currentTime)*(osg::Timer::instance()->getSecondsPerTick());
267    if (delta_ticks>=0) tick += osg::Timer_t(delta_ticks);
268    else tick -= osg::Timer_t(-delta_ticks);
269
270    // assign the new start tick
271    setStartTick(tick);
272}
273
274
275
276void CompositeViewer::viewerInit()
277{
278    osg::notify(osg::INFO)<<"CompositeViewer::init()"<<std::endl;
279
280    for(RefViews::iterator itr = _views.begin();
281        itr != _views.end();
282        ++itr)
283    {
284        (*itr)->init();
285    }
286}
287
288void CompositeViewer::getContexts(Contexts& contexts, bool onlyValid)
289{
290    typedef std::set<osg::GraphicsContext*> ContextSet;
291    ContextSet contextSet;
292
293    contexts.clear();
294
295    for(RefViews::iterator vitr = _views.begin();
296        vitr != _views.end();
297        ++vitr)
298    {
299        osgViewer::View* view = vitr->get();
300        osg::GraphicsContext* gc = view->getCamera() ? view->getCamera()->getGraphicsContext() : 0;
301        if (gc && (gc->valid() || !onlyValid))
302        {
303            if (contextSet.count(gc)==0)
304            {
305                contextSet.insert(gc);
306                contexts.push_back(gc);
307            }
308        }
309
310        for(unsigned int i=0; i<view->getNumSlaves(); ++i)
311        {
312            View::Slave& slave = view->getSlave(i);
313            osg::GraphicsContext* sgc = slave._camera.valid() ? slave._camera->getGraphicsContext() : 0;
314            if (sgc && (sgc->valid() || !onlyValid))
315            {
316                if (contextSet.count(sgc)==0)
317                {
318                    contextSet.insert(sgc);
319                    contexts.push_back(sgc);
320                }
321            }
322        }
323    }
324}
325
326void CompositeViewer::getCameras(Cameras& cameras, bool onlyActive)
327{
328    cameras.clear();
329   
330    for(RefViews::iterator vitr = _views.begin();
331        vitr != _views.end();
332        ++vitr)
333    {
334        View* view = vitr->get();
335
336        if (view->getCamera() &&
337            (!onlyActive || (view->getCamera()->getGraphicsContext() && view->getCamera()->getGraphicsContext()->valid())) ) cameras.push_back(view->getCamera());
338
339        for(View::Slaves::iterator itr = view->_slaves.begin();
340            itr != view->_slaves.end();
341            ++itr)
342        {
343            if (itr->_camera.valid() &&
344                (!onlyActive || (itr->_camera->getGraphicsContext() && itr->_camera->getGraphicsContext()->valid())) ) cameras.push_back(itr->_camera.get());
345        }
346    }
347}
348 
349void CompositeViewer::getScenes(Scenes& scenes, bool onlyValid)
350{
351    typedef std::set<osgViewer::Scene*> SceneSet;
352    SceneSet sceneSet;
353
354    for(RefViews::iterator vitr = _views.begin();
355        vitr != _views.end();
356        ++vitr)
357    {
358        osgViewer::View* view = vitr->get();
359        if (view->getScene() && (!onlyValid || view->getScene()->getSceneData()))
360        {
361            if (sceneSet.count(view->getScene())==0)
362            {
363                sceneSet.insert(view->getScene());
364                scenes.push_back(view->getScene());
365            }
366        }
367    }
368}
369
370void CompositeViewer::getViews(Views& views, bool onlyValid)
371{
372    for(RefViews::iterator vitr = _views.begin();
373        vitr != _views.end();
374        ++vitr)
375    {
376        views.push_back(vitr->get());
377    }
378}
379
380void CompositeViewer::getAllThreads(Threads& threads, bool onlyActive)
381{
382    OperationThreads operationThreads;
383    getOperationThreads(operationThreads);
384   
385    for(OperationThreads::iterator itr = operationThreads.begin();
386        itr != operationThreads.end();
387        ++itr)
388    {
389        threads.push_back(*itr);
390    }
391
392    Scenes scenes;
393    getScenes(scenes);
394   
395    for(Scenes::iterator sitr = scenes.begin();
396        sitr != scenes.end();
397        ++sitr)
398    {
399        Scene* scene = *sitr;
400        osgDB::DatabasePager* dp = scene->getDatabasePager();
401        if (dp)
402        {
403            for(unsigned int i=0; i<dp->getNumDatabaseThreads(); ++i)
404            {
405                osgDB::DatabasePager::DatabaseThread* dt = dp->getDatabaseThread(i);
406                if (!onlyActive || dt->isRunning())
407                {
408                    threads.push_back(dt);
409                }
410            }
411        }
412    }
413}
414
415
416void CompositeViewer::getOperationThreads(OperationThreads& threads, bool onlyActive)
417{
418    threads.clear();
419   
420    Contexts contexts;
421    getContexts(contexts);
422    for(Contexts::iterator gcitr = contexts.begin();
423        gcitr != contexts.end();
424        ++gcitr)
425    {
426        osg::GraphicsContext* gc = *gcitr;
427        if (gc->getGraphicsThread() &&
428            (!onlyActive || gc->getGraphicsThread()->isRunning()) )
429        {
430            threads.push_back(gc->getGraphicsThread());
431        }
432    }
433   
434    Cameras cameras;
435    getCameras(cameras);
436    for(Cameras::iterator citr = cameras.begin();
437        citr != cameras.end();
438        ++citr)
439    {
440        osg::Camera* camera = *citr;
441        if (camera->getCameraThread() &&
442            (!onlyActive || camera->getCameraThread()->isRunning()) )
443        {
444            threads.push_back(camera->getCameraThread());
445        }
446    }
447   
448}
449
450void CompositeViewer::realize()
451{
452    //osg::notify(osg::INFO)<<"CompositeViewer::realize()"<<std::endl;
453   
454    setCameraWithFocus(0);
455
456    if (_views.empty())
457    {
458        osg::notify(osg::NOTICE)<<"CompositeViewer::realize() - not views to realize."<<std::endl;
459        _done = true;
460        return;
461    }
462
463    Contexts contexts;
464    getContexts(contexts);
465   
466    if (contexts.empty())
467    {
468        osg::notify(osg::INFO)<<"CompositeViewer::realize() - No valid contexts found, setting up view across all screens."<<std::endl;
469   
470        // no windows are already set up so set up a default view       
471        _views[0]->setUpViewAcrossAllScreens();
472       
473        getContexts(contexts);
474    }
475
476    if (contexts.empty())
477    {
478        osg::notify(osg::NOTICE)<<"CompositeViewer::realize() - failed to set up any windows"<<std::endl;
479        _done = true;
480        return;
481    }
482   
483    for(Contexts::iterator citr = contexts.begin();
484        citr != contexts.end();
485        ++citr)
486    {
487        osg::GraphicsContext* gc = *citr;
488        gc->realize();
489       
490        if (_realizeOperation.valid() && gc->valid())
491        {
492            gc->makeCurrent();
493           
494            (*_realizeOperation)(gc);
495           
496            gc->releaseContext();
497        }
498    }
499   
500    // attach contexts to _incrementalCompileOperation if attached.
501    if (_incrementalCompileOperation) _incrementalCompileOperation->assignContexts(contexts);
502
503
504    bool grabFocus = true;
505    if (grabFocus)
506    {
507        for(Contexts::iterator citr = contexts.begin();
508            citr != contexts.end();
509            ++citr)
510        {
511            osgViewer::GraphicsWindow* gw = dynamic_cast<osgViewer::GraphicsWindow*>(*citr);
512            if (gw)
513            {
514                gw->grabFocusIfPointerInWindow();   
515            }
516        }
517    }
518   
519   
520    startThreading();
521
522    // initialize the global timer to be relative to the current time.
523    osg::Timer::instance()->setStartTick();
524
525    // pass on the start tick to all the associated eventqueues
526    setStartTick(osg::Timer::instance()->getStartTick());
527
528    if (osg::DisplaySettings::instance()->getCompileContextsHint())
529    {
530        int numProcessors = OpenThreads::GetNumberOfProcessors();
531        int processNum = 0;
532
533        for(unsigned int i=0; i<= osg::GraphicsContext::getMaxContextID(); ++i)
534        {
535            osg::GraphicsContext* gc = osg::GraphicsContext::getOrCreateCompileContext(i);
536
537            if (gc)
538            {
539                gc->createGraphicsThread();
540                gc->getGraphicsThread()->setProcessorAffinity(processNum % numProcessors);
541                gc->getGraphicsThread()->startThread();
542               
543                ++processNum;
544            }
545        }
546    }
547
548}
549
550void CompositeViewer::advance(double simulationTime)
551{
552    if (_done) return;
553   
554    double prevousReferenceTime = _frameStamp->getReferenceTime();
555    int previousFrameNumber = _frameStamp->getFrameNumber();
556
557
558    _frameStamp->setFrameNumber(_frameStamp->getFrameNumber()+1);
559
560    _frameStamp->setReferenceTime( osg::Timer::instance()->delta_s(_startTick, osg::Timer::instance()->tick()) );
561
562    if (simulationTime==USE_REFERENCE_TIME)
563    {
564        _frameStamp->setSimulationTime(_frameStamp->getReferenceTime());
565    }
566    else
567    {
568        _frameStamp->setSimulationTime(simulationTime);
569    }
570   
571    if (getViewerStats() && getViewerStats()->collectStats("frame_rate"))
572    {
573        // update previous frame stats
574        double deltaFrameTime = _frameStamp->getReferenceTime() - prevousReferenceTime;
575        getViewerStats()->setAttribute(previousFrameNumber, "Frame duration", deltaFrameTime);
576        getViewerStats()->setAttribute(previousFrameNumber, "Frame rate", 1.0/deltaFrameTime);
577
578        // update current frames stats
579        getViewerStats()->setAttribute(_frameStamp->getFrameNumber(), "Reference time", _frameStamp->getReferenceTime());
580    }
581
582}
583
584void CompositeViewer::setCameraWithFocus(osg::Camera* camera)
585{
586    _cameraWithFocus = camera;
587
588    if (camera)
589    {
590        for(RefViews::iterator vitr = _views.begin();
591            vitr != _views.end();
592            ++vitr)
593        {
594            View* view = vitr->get();
595            if (view->containsCamera(camera))
596            {
597                _viewWithFocus = view;
598                return;
599            }
600        }
601    }
602
603    _viewWithFocus = 0;
604}
605
606void CompositeViewer::eventTraversal()
607{
608    if (_done) return;
609   
610    if (_views.empty()) return;
611   
612    double beginEventTraversal = osg::Timer::instance()->delta_s(_startTick, osg::Timer::instance()->tick());
613
614    // osg::notify(osg::NOTICE)<<"CompositeViewer::frameEventTraversal()."<<std::endl;
615   
616    // need to copy events from the GraphicsWindow's into local EventQueue;
617   
618    typedef std::map<osgViewer::View*, osgGA::EventQueue::Events> ViewEventsMap;
619    ViewEventsMap viewEventsMap;
620   
621    Contexts contexts;
622    getContexts(contexts);
623
624    Scenes scenes;
625    getScenes(scenes);
626
627    osgViewer::View* masterView = getViewWithFocus() ? getViewWithFocus() : _views[0].get();
628   
629    osg::Camera* masterCamera = masterView->getCamera();
630    osgGA::GUIEventAdapter* eventState = masterView->getEventQueue()->getCurrentEventState();
631    osg::Matrix masterCameraVPW = masterCamera->getViewMatrix() * masterCamera->getProjectionMatrix();
632    if (masterCamera->getViewport())
633    {
634        osg::Viewport* viewport = masterCamera->getViewport();
635        masterCameraVPW *= viewport->computeWindowMatrix();
636    }
637
638    for(Contexts::iterator citr = contexts.begin();
639        citr != contexts.end();
640        ++citr)
641    {
642        osgViewer::GraphicsWindow* gw = dynamic_cast<osgViewer::GraphicsWindow*>(*citr);
643        if (gw)
644        {
645            gw->checkEvents();
646           
647            osgGA::EventQueue::Events gw_events;
648            gw->getEventQueue()->takeEvents(gw_events);
649           
650            osgGA::EventQueue::Events::iterator itr;
651            for(itr = gw_events.begin();
652                itr != gw_events.end();
653                ++itr)
654            {
655                osgGA::GUIEventAdapter* event = itr->get();
656               
657                //osg::notify(osg::NOTICE)<<"event->getGraphicsContext()="<<event->getGraphicsContext()<<std::endl;
658               
659                bool pointerEvent = false;
660
661                float x = event->getX();
662                float y = event->getY();
663               
664                bool invert_y = event->getMouseYOrientation()==osgGA::GUIEventAdapter::Y_INCREASING_DOWNWARDS;
665                if (invert_y && gw->getTraits()) y = gw->getTraits()->height - y;
666               
667                switch(event->getEventType())
668                {
669                    case(osgGA::GUIEventAdapter::RESIZE):
670                        setCameraWithFocus(0);
671                        break;
672                    case(osgGA::GUIEventAdapter::PUSH):
673                    case(osgGA::GUIEventAdapter::RELEASE):
674                    case(osgGA::GUIEventAdapter::DRAG):
675                    case(osgGA::GUIEventAdapter::MOVE):
676                    {
677                        pointerEvent = true;
678                       
679                        if (event->getEventType()!=osgGA::GUIEventAdapter::DRAG || !getCameraWithFocus())
680                        {
681                            osg::GraphicsContext::Cameras& cameras = gw->getCameras();
682                            for(osg::GraphicsContext::Cameras::iterator citr = cameras.begin();
683                                citr != cameras.end();
684                                ++citr)
685                            {
686                                osg::Camera* camera = *citr;
687                                if (camera->getView() &&
688                                    camera->getAllowEventFocus() &&
689                                    camera->getRenderTargetImplementation()==osg::Camera::FRAME_BUFFER)
690                                {
691                                    osg::Viewport* viewport = camera ? camera->getViewport() : 0;
692                                    if (viewport &&
693                                        x >= viewport->x() && y >= viewport->y() &&
694                                        x <= (viewport->x()+viewport->width()) && y <= (viewport->y()+viewport->height()) )
695                                    {
696                                        setCameraWithFocus(camera);
697
698                                        // If this camera is not a slave camera
699                                        if (camera->getView()->getCamera() == camera)
700                                        {
701                                            eventState->setGraphicsContext(gw);
702                                            eventState->setInputRange( viewport->x(), viewport->y(),
703                                                                       viewport->x()+viewport->width(),
704                                                                       viewport->y()+viewport->height());
705
706                                        }
707                                        else
708                                        {
709                                            eventState->setInputRange(-1.0, -1.0, 1.0, 1.0);
710                                        }
711
712                                        if (getViewWithFocus()!=masterView)
713                                        {
714                                            // need to reset the masterView
715                                            masterView = getViewWithFocus();
716                                            masterCamera = masterView->getCamera();
717                                            eventState = masterView->getEventQueue()->getCurrentEventState();
718                                            masterCameraVPW = masterCamera->getViewMatrix() * masterCamera->getProjectionMatrix();
719
720                                            if (masterCamera->getViewport())
721                                            {
722                                                osg::Viewport* viewport = masterCamera->getViewport();
723                                                masterCameraVPW *= viewport->computeWindowMatrix();
724                                            }
725                                        }
726
727                                        // If this camera is not a slave camera
728                                        if (camera->getView()->getCamera() == camera)
729                                        {
730                                            eventState->setGraphicsContext(gw);
731                                            eventState->setInputRange( viewport->x(), viewport->y(),
732                                                                       viewport->x()+viewport->width(),
733                                                                       viewport->y()+viewport->height());
734
735                                        }
736                                        else
737                                        {
738                                            eventState->setInputRange(-1.0, -1.0, 1.0, 1.0);
739                                        }
740                                    }
741                                }
742                            }
743                        }
744                       
745                        break;
746                    }
747                    default:
748                        break;
749                }
750               
751                if (pointerEvent)
752                {
753                    if (getCameraWithFocus())
754                    {
755                        osg::Viewport* viewport = getCameraWithFocus()->getViewport();
756                        osg::Matrix localCameraVPW = getCameraWithFocus()->getViewMatrix() * getCameraWithFocus()->getProjectionMatrix();
757                        if (viewport) localCameraVPW *= viewport->computeWindowMatrix();
758
759                        osg::Matrix matrix( osg::Matrix::inverse(localCameraVPW) * masterCameraVPW );
760
761                        osg::Vec3d new_coord = osg::Vec3d(x,y,0.0) * matrix;
762
763                        x = new_coord.x();
764                        y = new_coord.y();                               
765
766                        event->setInputRange(eventState->getXmin(), eventState->getYmin(), eventState->getXmax(), eventState->getYmax());
767                        event->setX(x);
768                        event->setY(y);
769                        event->setMouseYOrientation(osgGA::GUIEventAdapter::Y_INCREASING_UPWARDS);
770
771                    }
772                    // pass along the new pointer events details to the eventState of the viewer
773                    eventState->setX(x);
774                    eventState->setY(y);
775                    eventState->setButtonMask(event->getButtonMask());
776                    eventState->setMouseYOrientation(osgGA::GUIEventAdapter::Y_INCREASING_UPWARDS);
777
778                }
779                else
780                {
781                    event->setInputRange(eventState->getXmin(), eventState->getYmin(), eventState->getXmax(), eventState->getYmax());
782                    event->setX(eventState->getX());
783                    event->setY(eventState->getY());
784                    event->setButtonMask(eventState->getButtonMask());
785                    event->setMouseYOrientation(eventState->getMouseYOrientation());
786                }
787            }
788
789            for(itr = gw_events.begin();
790                itr != gw_events.end();
791                ++itr)
792            {
793                osgGA::GUIEventAdapter* event = itr->get();
794                switch(event->getEventType())
795                {
796                    case(osgGA::GUIEventAdapter::CLOSE_WINDOW):
797                    {
798                        bool wasThreading = areThreadsRunning();
799                        if (wasThreading) stopThreading();
800                       
801                        gw->close();
802
803                        if (wasThreading) startThreading();
804
805                        break;
806                    }
807                    default:
808                        break;
809                }
810            }
811
812            viewEventsMap[masterView].insert( viewEventsMap[masterView].end(), gw_events.begin(), gw_events.end() );
813
814        }
815    }
816   
817
818    // osg::notify(osg::NOTICE)<<"mouseEventState Xmin = "<<eventState->getXmin()<<" Ymin="<<eventState->getYmin()<<" xMax="<<eventState->getXmax()<<" Ymax="<<eventState->getYmax()<<std::endl;
819
820
821    for(RefViews::iterator vitr = _views.begin();
822        vitr != _views.end();
823        ++vitr)
824    {
825        View* view = vitr->get();
826        view->getEventQueue()->frame( getFrameStamp()->getReferenceTime() );
827        view->getEventQueue()->takeEvents(viewEventsMap[view]);
828    }
829   
830
831    // osg::notify(osg::NOTICE)<<"Events "<<events.size()<<std::endl;
832   
833    if ((_keyEventSetsDone!=0) || _quitEventSetsDone)
834    {
835        for(ViewEventsMap::iterator veitr = viewEventsMap.begin();
836            veitr != viewEventsMap.end();
837            ++veitr)
838        {
839            for(osgGA::EventQueue::Events::iterator itr = veitr->second.begin();
840                itr != veitr->second.end();
841                ++itr)
842            {
843                osgGA::GUIEventAdapter* event = itr->get();
844                switch(event->getEventType())
845                {
846                    case(osgGA::GUIEventAdapter::KEYUP):
847                        if (_keyEventSetsDone && event->getKey()==_keyEventSetsDone) _done = true;
848                        break;
849
850                    case(osgGA::GUIEventAdapter::QUIT_APPLICATION):
851                        if (_quitEventSetsDone) _done = true;
852                        break;
853
854                    default:
855                        break;
856                }
857            }
858        }
859    }
860       
861    if (_done) return;
862
863    if (_eventVisitor.valid())
864    {
865        _eventVisitor->setFrameStamp(getFrameStamp());
866        _eventVisitor->setTraversalNumber(getFrameStamp()->getFrameNumber());
867
868        for(ViewEventsMap::iterator veitr = viewEventsMap.begin();
869            veitr != viewEventsMap.end();
870            ++veitr)
871        {
872            View* view = veitr->first;
873            _eventVisitor->setActionAdapter(view);
874           
875            if (view->getSceneData())
876            {           
877                for(osgGA::EventQueue::Events::iterator itr = veitr->second.begin();
878                    itr != veitr->second.end();
879                    ++itr)
880                {
881                    osgGA::GUIEventAdapter* event = itr->get();
882
883                    _eventVisitor->reset();
884                    _eventVisitor->addEvent( event );
885
886                    view->getSceneData()->accept(*_eventVisitor);
887
888                    // call any camera update callbacks, but only traverse that callback, don't traverse its subgraph
889                    // leave that to the scene update traversal.
890                    osg::NodeVisitor::TraversalMode tm = _eventVisitor->getTraversalMode();
891                    _eventVisitor->setTraversalMode(osg::NodeVisitor::TRAVERSE_NONE);
892
893                    if (view->getCamera() && view->getCamera()->getEventCallback()) view->getCamera()->accept(*_eventVisitor);
894
895                    for(unsigned int i=0; i<view->getNumSlaves(); ++i)
896                    {
897                        osg::Camera* camera = view->getSlave(i)._camera.get();
898                        if (camera && camera->getEventCallback()) camera->accept(*_eventVisitor);
899                    }
900
901                    _eventVisitor->setTraversalMode(tm);
902
903                }
904            }
905        }
906       
907    }
908
909    for(ViewEventsMap::iterator veitr = viewEventsMap.begin();
910        veitr != viewEventsMap.end();
911        ++veitr)
912    {
913        View* view = veitr->first;
914       
915        for(osgGA::EventQueue::Events::iterator itr = veitr->second.begin();
916            itr != veitr->second.end();
917            ++itr)
918        {
919            osgGA::GUIEventAdapter* event = itr->get();
920
921            for(View::EventHandlers::iterator hitr = view->getEventHandlers().begin();
922                hitr != view->getEventHandlers().end();
923                ++hitr)
924            {
925                (*hitr)->handleWithCheckAgainstIgnoreHandledEventsMask( *event, *view, 0, 0);
926            }
927        }
928    }
929
930    for(ViewEventsMap::iterator veitr = viewEventsMap.begin();
931        veitr != viewEventsMap.end();
932        ++veitr)
933    {
934        View* view = veitr->first;
935       
936        for(osgGA::EventQueue::Events::iterator itr = veitr->second.begin();
937            itr != veitr->second.end();
938            ++itr)
939        {
940            osgGA::GUIEventAdapter* event = itr->get();
941
942            if (view->getCameraManipulator())
943            {
944                view->getCameraManipulator()->handleWithCheckAgainstIgnoreHandledEventsMask( *event, *view);
945            }
946        }
947    }
948
949   
950
951    if (getViewerStats() && getViewerStats()->collectStats("event"))
952    {
953        double endEventTraversal = osg::Timer::instance()->delta_s(_startTick, osg::Timer::instance()->tick());
954
955        // update current frames stats
956        getViewerStats()->setAttribute(_frameStamp->getFrameNumber(), "Event traversal begin time", beginEventTraversal);
957        getViewerStats()->setAttribute(_frameStamp->getFrameNumber(), "Event traversal end time", endEventTraversal);
958        getViewerStats()->setAttribute(_frameStamp->getFrameNumber(), "Event traversal time taken", endEventTraversal-beginEventTraversal);
959    }
960}
961
962
963void CompositeViewer::updateTraversal()
964{
965    if (_done) return;
966   
967    double beginUpdateTraversal = osg::Timer::instance()->delta_s(_startTick, osg::Timer::instance()->tick());
968
969    _updateVisitor->reset();
970    _updateVisitor->setFrameStamp(getFrameStamp());
971    _updateVisitor->setTraversalNumber(getFrameStamp()->getFrameNumber());
972
973    Scenes scenes;
974    getScenes(scenes);
975    for(Scenes::iterator sitr = scenes.begin();
976        sitr != scenes.end();
977        ++sitr)
978    {
979        Scene* scene = *sitr;
980        if (scene->getSceneData())
981        {
982            _updateVisitor->setImageRequestHandler(scene->getImagePager());
983           
984            scene->getSceneData()->accept(*_updateVisitor);
985        }
986
987        if (scene->getDatabasePager())
988        {   
989            // synchronize changes required by the DatabasePager thread to the scene graph
990            scene->getDatabasePager()->updateSceneGraph(*_frameStamp);
991        }
992
993        if (scene->getImagePager())
994        {   
995            // synchronize changes required by the DatabasePager thread to the scene graph
996            scene->getImagePager()->updateSceneGraph(*_frameStamp);
997        }
998
999    }
1000
1001    if (_incrementalCompileOperation.valid())
1002    {
1003        // merge subgraphs that have been compiled by the incremental compiler operation.
1004        _incrementalCompileOperation->mergeCompiledSubgraphs();
1005    }
1006
1007    if (_updateOperations.valid())
1008    {
1009        _updateOperations->runOperations(this);
1010    }
1011
1012    for(RefViews::iterator vitr = _views.begin();
1013        vitr != _views.end();
1014        ++vitr)
1015    {
1016        View* view = vitr->get();
1017
1018        {
1019            // call any camera update callbacks, but only traverse that callback, don't traverse its subgraph
1020            // leave that to the scene update traversal.
1021            osg::NodeVisitor::TraversalMode tm = _updateVisitor->getTraversalMode();
1022            _updateVisitor->setTraversalMode(osg::NodeVisitor::TRAVERSE_NONE);
1023
1024            if (view->getCamera() && view->getCamera()->getUpdateCallback()) view->getCamera()->accept(*_updateVisitor);
1025
1026            for(unsigned int i=0; i<view->getNumSlaves(); ++i)
1027            {
1028                osg::Camera* camera = view->getSlave(i)._camera.get();
1029                if (camera && camera->getUpdateCallback()) camera->accept(*_updateVisitor);
1030            }
1031
1032            _updateVisitor->setTraversalMode(tm);
1033        }
1034
1035
1036        if (view->getCameraManipulator())
1037        {
1038            view->setFusionDistance( view->getCameraManipulator()->getFusionDistanceMode(),
1039                                     view->getCameraManipulator()->getFusionDistanceValue() );
1040                                     
1041            view->getCamera()->setViewMatrix( view->getCameraManipulator()->getInverseMatrix());
1042        }
1043        view->updateSlaves();
1044
1045    }
1046   
1047    if (getViewerStats() && getViewerStats()->collectStats("update"))
1048    {
1049        double endUpdateTraversal = osg::Timer::instance()->delta_s(_startTick, osg::Timer::instance()->tick());
1050
1051        // update current frames stats
1052        getViewerStats()->setAttribute(_frameStamp->getFrameNumber(), "Update traversal begin time", beginUpdateTraversal);
1053        getViewerStats()->setAttribute(_frameStamp->getFrameNumber(), "Update traversal end time", endUpdateTraversal);
1054        getViewerStats()->setAttribute(_frameStamp->getFrameNumber(), "Update traversal time taken", endUpdateTraversal-beginUpdateTraversal);
1055    }
1056
1057}
1058
1059double CompositeViewer::elapsedTime()
1060{
1061    return osg::Timer::instance()->delta_s(_startTick, osg::Timer::instance()->tick());
1062}
1063
1064void CompositeViewer::getUsage(osg::ApplicationUsage& usage) const
1065{
1066    for(RefViews::const_iterator vitr = _views.begin();
1067        vitr != _views.end();
1068        ++vitr)
1069    {
1070        const View* view = vitr->get();
1071        if (view->getCameraManipulator())
1072        {
1073            view->getCameraManipulator()->getUsage(usage);
1074        }
1075
1076        for(View::EventHandlers::const_iterator hitr = view->_eventHandlers.begin();
1077            hitr != view->_eventHandlers.end();
1078            ++hitr)
1079        {
1080            (*hitr)->getUsage(usage);
1081        }
1082    }
1083}
Note: See TracBrowser for help on using the browser.