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

Revision 9554, 34.6 kB (checked in by robert, 5 years ago)

Refactored the view stats.

  • 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    bool grabFocus = true;
501    if (grabFocus)
502    {
503        for(Contexts::iterator citr = contexts.begin();
504            citr != contexts.end();
505            ++citr)
506        {
507            osgViewer::GraphicsWindow* gw = dynamic_cast<osgViewer::GraphicsWindow*>(*citr);
508            if (gw)
509            {
510                gw->grabFocusIfPointerInWindow();   
511            }
512        }
513    }
514   
515   
516    startThreading();
517
518    // initialize the global timer to be relative to the current time.
519    osg::Timer::instance()->setStartTick();
520
521    // pass on the start tick to all the associated eventqueues
522    setStartTick(osg::Timer::instance()->getStartTick());
523
524    if (osg::DisplaySettings::instance()->getCompileContextsHint())
525    {
526        int numProcessors = OpenThreads::GetNumberOfProcessors();
527        int processNum = 0;
528
529        for(unsigned int i=0; i<= osg::GraphicsContext::getMaxContextID(); ++i)
530        {
531            osg::GraphicsContext* gc = osg::GraphicsContext::getOrCreateCompileContext(i);
532
533            if (gc)
534            {
535                gc->createGraphicsThread();
536                gc->getGraphicsThread()->setProcessorAffinity(processNum % numProcessors);
537                gc->getGraphicsThread()->startThread();
538               
539                ++processNum;
540            }
541        }
542    }
543
544}
545
546void CompositeViewer::advance(double simulationTime)
547{
548    if (_done) return;
549   
550    double prevousReferenceTime = _frameStamp->getReferenceTime();
551    int previousFrameNumber = _frameStamp->getFrameNumber();
552
553
554    _frameStamp->setFrameNumber(_frameStamp->getFrameNumber()+1);
555
556    _frameStamp->setReferenceTime( osg::Timer::instance()->delta_s(_startTick, osg::Timer::instance()->tick()) );
557
558    if (simulationTime==USE_REFERENCE_TIME)
559    {
560        _frameStamp->setSimulationTime(_frameStamp->getReferenceTime());
561    }
562    else
563    {
564        _frameStamp->setSimulationTime(simulationTime);
565    }
566   
567    if (getViewerStats() && getViewerStats()->collectStats("frame_rate"))
568    {
569        // update previous frame stats
570        double deltaFrameTime = _frameStamp->getReferenceTime() - prevousReferenceTime;
571        getViewerStats()->setAttribute(previousFrameNumber, "Frame duration", deltaFrameTime);
572        getViewerStats()->setAttribute(previousFrameNumber, "Frame rate", 1.0/deltaFrameTime);
573
574        // update current frames stats
575        getViewerStats()->setAttribute(_frameStamp->getFrameNumber(), "Reference time", _frameStamp->getReferenceTime());
576    }
577
578}
579
580void CompositeViewer::setCameraWithFocus(osg::Camera* camera)
581{
582    _cameraWithFocus = camera;
583
584    if (camera)
585    {
586        for(RefViews::iterator vitr = _views.begin();
587            vitr != _views.end();
588            ++vitr)
589        {
590            View* view = vitr->get();
591            if (view->containsCamera(camera))
592            {
593                _viewWithFocus = view;
594                return;
595            }
596        }
597    }
598
599    _viewWithFocus = 0;
600}
601
602void CompositeViewer::eventTraversal()
603{
604    if (_done) return;
605   
606    if (_views.empty()) return;
607   
608    double beginEventTraversal = osg::Timer::instance()->delta_s(_startTick, osg::Timer::instance()->tick());
609
610    // osg::notify(osg::NOTICE)<<"CompositeViewer::frameEventTraversal()."<<std::endl;
611   
612    // need to copy events from the GraphicsWindow's into local EventQueue;
613   
614    typedef std::map<osgViewer::View*, osgGA::EventQueue::Events> ViewEventsMap;
615    ViewEventsMap viewEventsMap;
616   
617    Contexts contexts;
618    getContexts(contexts);
619
620    Scenes scenes;
621    getScenes(scenes);
622
623    osgViewer::View* masterView = getViewWithFocus() ? getViewWithFocus() : _views[0].get();
624   
625    osg::Camera* masterCamera = masterView->getCamera();
626    osgGA::GUIEventAdapter* eventState = masterView->getEventQueue()->getCurrentEventState();
627    osg::Matrix masterCameraVPW = masterCamera->getViewMatrix() * masterCamera->getProjectionMatrix();
628    if (masterCamera->getViewport())
629    {
630        osg::Viewport* viewport = masterCamera->getViewport();
631        masterCameraVPW *= viewport->computeWindowMatrix();
632    }
633
634    for(Contexts::iterator citr = contexts.begin();
635        citr != contexts.end();
636        ++citr)
637    {
638        osgViewer::GraphicsWindow* gw = dynamic_cast<osgViewer::GraphicsWindow*>(*citr);
639        if (gw)
640        {
641            gw->checkEvents();
642           
643            osgGA::EventQueue::Events gw_events;
644            gw->getEventQueue()->takeEvents(gw_events);
645           
646            osgGA::EventQueue::Events::iterator itr;
647            for(itr = gw_events.begin();
648                itr != gw_events.end();
649                ++itr)
650            {
651                osgGA::GUIEventAdapter* event = itr->get();
652               
653                //osg::notify(osg::NOTICE)<<"event->getGraphicsContext()="<<event->getGraphicsContext()<<std::endl;
654               
655                bool pointerEvent = false;
656
657                float x = event->getX();
658                float y = event->getY();
659               
660                bool invert_y = event->getMouseYOrientation()==osgGA::GUIEventAdapter::Y_INCREASING_DOWNWARDS;
661                if (invert_y && gw->getTraits()) y = gw->getTraits()->height - y;
662               
663                switch(event->getEventType())
664                {
665                    case(osgGA::GUIEventAdapter::RESIZE):
666                        setCameraWithFocus(0);
667                        break;
668                    case(osgGA::GUIEventAdapter::PUSH):
669                    case(osgGA::GUIEventAdapter::RELEASE):
670                    case(osgGA::GUIEventAdapter::DRAG):
671                    case(osgGA::GUIEventAdapter::MOVE):
672                    {
673                        pointerEvent = true;
674                       
675                        if (event->getEventType()!=osgGA::GUIEventAdapter::DRAG || !getCameraWithFocus())
676                        {
677                            osg::GraphicsContext::Cameras& cameras = gw->getCameras();
678                            for(osg::GraphicsContext::Cameras::iterator citr = cameras.begin();
679                                citr != cameras.end();
680                                ++citr)
681                            {
682                                osg::Camera* camera = *citr;
683                                if (camera->getView() &&
684                                    camera->getAllowEventFocus() &&
685                                    camera->getRenderTargetImplementation()==osg::Camera::FRAME_BUFFER)
686                                {
687                                    osg::Viewport* viewport = camera ? camera->getViewport() : 0;
688                                    if (viewport &&
689                                        x >= viewport->x() && y >= viewport->y() &&
690                                        x <= (viewport->x()+viewport->width()) && y <= (viewport->y()+viewport->height()) )
691                                    {
692                                        setCameraWithFocus(camera);
693
694                                        // If this camera is not a slave camera
695                                        if (camera->getView()->getCamera() == camera)
696                                        {
697                                            eventState->setGraphicsContext(gw);
698                                            eventState->setInputRange( viewport->x(), viewport->y(),
699                                                                       viewport->x()+viewport->width(),
700                                                                       viewport->y()+viewport->height());
701
702                                        }
703                                        else
704                                        {
705                                            eventState->setInputRange(-1.0, -1.0, 1.0, 1.0);
706                                        }
707
708                                        if (getViewWithFocus()!=masterView)
709                                        {
710                                            // need to reset the masterView
711                                            masterView = getViewWithFocus();
712                                            masterCamera = masterView->getCamera();
713                                            eventState = masterView->getEventQueue()->getCurrentEventState();
714                                            masterCameraVPW = masterCamera->getViewMatrix() * masterCamera->getProjectionMatrix();
715
716                                            if (masterCamera->getViewport())
717                                            {
718                                                osg::Viewport* viewport = masterCamera->getViewport();
719                                                masterCameraVPW *= viewport->computeWindowMatrix();
720                                            }
721                                        }
722
723                                        // If this camera is not a slave camera
724                                        if (camera->getView()->getCamera() == camera)
725                                        {
726                                            eventState->setGraphicsContext(gw);
727                                            eventState->setInputRange( viewport->x(), viewport->y(),
728                                                                       viewport->x()+viewport->width(),
729                                                                       viewport->y()+viewport->height());
730
731                                        }
732                                        else
733                                        {
734                                            eventState->setInputRange(-1.0, -1.0, 1.0, 1.0);
735                                        }
736                                    }
737                                }
738                            }
739                        }
740                       
741                        break;
742                    }
743                    default:
744                        break;
745                }
746               
747                if (pointerEvent)
748                {
749                    if (getCameraWithFocus())
750                    {
751                        osg::Viewport* viewport = getCameraWithFocus()->getViewport();
752                        osg::Matrix localCameraVPW = getCameraWithFocus()->getViewMatrix() * getCameraWithFocus()->getProjectionMatrix();
753                        if (viewport) localCameraVPW *= viewport->computeWindowMatrix();
754
755                        osg::Matrix matrix( osg::Matrix::inverse(localCameraVPW) * masterCameraVPW );
756
757                        osg::Vec3d new_coord = osg::Vec3d(x,y,0.0) * matrix;
758
759                        x = new_coord.x();
760                        y = new_coord.y();                               
761
762                        event->setInputRange(eventState->getXmin(), eventState->getYmin(), eventState->getXmax(), eventState->getYmax());
763                        event->setX(x);
764                        event->setY(y);
765                        event->setMouseYOrientation(osgGA::GUIEventAdapter::Y_INCREASING_UPWARDS);
766
767                    }
768                    // pass along the new pointer events details to the eventState of the viewer
769                    eventState->setX(x);
770                    eventState->setY(y);
771                    eventState->setButtonMask(event->getButtonMask());
772                    eventState->setMouseYOrientation(osgGA::GUIEventAdapter::Y_INCREASING_UPWARDS);
773
774                }
775                else
776                {
777                    event->setInputRange(eventState->getXmin(), eventState->getYmin(), eventState->getXmax(), eventState->getYmax());
778                    event->setX(eventState->getX());
779                    event->setY(eventState->getY());
780                    event->setButtonMask(eventState->getButtonMask());
781                    event->setMouseYOrientation(eventState->getMouseYOrientation());
782                }
783            }
784
785            for(itr = gw_events.begin();
786                itr != gw_events.end();
787                ++itr)
788            {
789                osgGA::GUIEventAdapter* event = itr->get();
790                switch(event->getEventType())
791                {
792                    case(osgGA::GUIEventAdapter::CLOSE_WINDOW):
793                    {
794                        bool wasThreading = areThreadsRunning();
795                        if (wasThreading) stopThreading();
796                       
797                        gw->close();
798
799                        if (wasThreading) startThreading();
800
801                        break;
802                    }
803                    default:
804                        break;
805                }
806            }
807
808            viewEventsMap[masterView].insert( viewEventsMap[masterView].end(), gw_events.begin(), gw_events.end() );
809
810        }
811    }
812   
813
814    // osg::notify(osg::NOTICE)<<"mouseEventState Xmin = "<<eventState->getXmin()<<" Ymin="<<eventState->getYmin()<<" xMax="<<eventState->getXmax()<<" Ymax="<<eventState->getYmax()<<std::endl;
815
816
817    for(RefViews::iterator vitr = _views.begin();
818        vitr != _views.end();
819        ++vitr)
820    {
821        View* view = vitr->get();
822        view->getEventQueue()->frame( getFrameStamp()->getReferenceTime() );
823        view->getEventQueue()->takeEvents(viewEventsMap[view]);
824    }
825   
826
827    // osg::notify(osg::NOTICE)<<"Events "<<events.size()<<std::endl;
828   
829    if ((_keyEventSetsDone!=0) || _quitEventSetsDone)
830    {
831        for(ViewEventsMap::iterator veitr = viewEventsMap.begin();
832            veitr != viewEventsMap.end();
833            ++veitr)
834        {
835            for(osgGA::EventQueue::Events::iterator itr = veitr->second.begin();
836                itr != veitr->second.end();
837                ++itr)
838            {
839                osgGA::GUIEventAdapter* event = itr->get();
840                switch(event->getEventType())
841                {
842                    case(osgGA::GUIEventAdapter::KEYUP):
843                        if (_keyEventSetsDone && event->getKey()==_keyEventSetsDone) _done = true;
844                        break;
845
846                    case(osgGA::GUIEventAdapter::QUIT_APPLICATION):
847                        if (_quitEventSetsDone) _done = true;
848                        break;
849
850                    default:
851                        break;
852                }
853            }
854        }
855    }
856       
857    if (_done) return;
858
859    if (_eventVisitor.valid())
860    {
861        _eventVisitor->setFrameStamp(getFrameStamp());
862        _eventVisitor->setTraversalNumber(getFrameStamp()->getFrameNumber());
863
864        for(ViewEventsMap::iterator veitr = viewEventsMap.begin();
865            veitr != viewEventsMap.end();
866            ++veitr)
867        {
868            View* view = veitr->first;
869            _eventVisitor->setActionAdapter(view);
870           
871            if (view->getSceneData())
872            {           
873                for(osgGA::EventQueue::Events::iterator itr = veitr->second.begin();
874                    itr != veitr->second.end();
875                    ++itr)
876                {
877                    osgGA::GUIEventAdapter* event = itr->get();
878
879                    _eventVisitor->reset();
880                    _eventVisitor->addEvent( event );
881
882                    view->getSceneData()->accept(*_eventVisitor);
883
884                    // call any camera update callbacks, but only traverse that callback, don't traverse its subgraph
885                    // leave that to the scene update traversal.
886                    osg::NodeVisitor::TraversalMode tm = _eventVisitor->getTraversalMode();
887                    _eventVisitor->setTraversalMode(osg::NodeVisitor::TRAVERSE_NONE);
888
889                    if (view->getCamera() && view->getCamera()->getEventCallback()) view->getCamera()->accept(*_eventVisitor);
890
891                    for(unsigned int i=0; i<view->getNumSlaves(); ++i)
892                    {
893                        osg::Camera* camera = view->getSlave(i)._camera.get();
894                        if (camera && camera->getEventCallback()) camera->accept(*_eventVisitor);
895                    }
896
897                    _eventVisitor->setTraversalMode(tm);
898
899                }
900            }
901        }
902       
903    }
904
905    for(ViewEventsMap::iterator veitr = viewEventsMap.begin();
906        veitr != viewEventsMap.end();
907        ++veitr)
908    {
909        View* view = veitr->first;
910       
911        for(osgGA::EventQueue::Events::iterator itr = veitr->second.begin();
912            itr != veitr->second.end();
913            ++itr)
914        {
915            osgGA::GUIEventAdapter* event = itr->get();
916
917            for(View::EventHandlers::iterator hitr = view->getEventHandlers().begin();
918                hitr != view->getEventHandlers().end();
919                ++hitr)
920            {
921                (*hitr)->handleWithCheckAgainstIgnoreHandledEventsMask( *event, *view, 0, 0);
922            }
923        }
924    }
925
926    for(ViewEventsMap::iterator veitr = viewEventsMap.begin();
927        veitr != viewEventsMap.end();
928        ++veitr)
929    {
930        View* view = veitr->first;
931       
932        for(osgGA::EventQueue::Events::iterator itr = veitr->second.begin();
933            itr != veitr->second.end();
934            ++itr)
935        {
936            osgGA::GUIEventAdapter* event = itr->get();
937
938            if (view->getCameraManipulator())
939            {
940                view->getCameraManipulator()->handleWithCheckAgainstIgnoreHandledEventsMask( *event, *view);
941            }
942        }
943    }
944
945   
946
947    if (getViewerStats() && getViewerStats()->collectStats("event"))
948    {
949        double endEventTraversal = osg::Timer::instance()->delta_s(_startTick, osg::Timer::instance()->tick());
950
951        // update current frames stats
952        getViewerStats()->setAttribute(_frameStamp->getFrameNumber(), "Event traversal begin time", beginEventTraversal);
953        getViewerStats()->setAttribute(_frameStamp->getFrameNumber(), "Event traversal end time", endEventTraversal);
954        getViewerStats()->setAttribute(_frameStamp->getFrameNumber(), "Event traversal time taken", endEventTraversal-beginEventTraversal);
955    }
956}
957
958
959void CompositeViewer::updateTraversal()
960{
961    if (_done) return;
962   
963    double beginUpdateTraversal = osg::Timer::instance()->delta_s(_startTick, osg::Timer::instance()->tick());
964
965    _updateVisitor->reset();
966    _updateVisitor->setFrameStamp(getFrameStamp());
967    _updateVisitor->setTraversalNumber(getFrameStamp()->getFrameNumber());
968
969    Scenes scenes;
970    getScenes(scenes);
971    for(Scenes::iterator sitr = scenes.begin();
972        sitr != scenes.end();
973        ++sitr)
974    {
975        Scene* scene = *sitr;
976        if (scene->getSceneData())
977        {
978            _updateVisitor->setImageRequestHandler(scene->getImagePager());
979           
980            scene->getSceneData()->accept(*_updateVisitor);
981        }
982
983        if (scene->getDatabasePager())
984        {   
985            // synchronize changes required by the DatabasePager thread to the scene graph
986            scene->getDatabasePager()->updateSceneGraph(*_frameStamp);
987        }
988
989        if (scene->getImagePager())
990        {   
991            // synchronize changes required by the DatabasePager thread to the scene graph
992            scene->getImagePager()->updateSceneGraph(*_frameStamp);
993        }
994
995    }
996
997    if (_updateOperations.valid())
998    {
999        _updateOperations->runOperations(this);
1000    }
1001
1002    for(RefViews::iterator vitr = _views.begin();
1003        vitr != _views.end();
1004        ++vitr)
1005    {
1006        View* view = vitr->get();
1007
1008        {
1009            // call any camera update callbacks, but only traverse that callback, don't traverse its subgraph
1010            // leave that to the scene update traversal.
1011            osg::NodeVisitor::TraversalMode tm = _updateVisitor->getTraversalMode();
1012            _updateVisitor->setTraversalMode(osg::NodeVisitor::TRAVERSE_NONE);
1013
1014            if (view->getCamera() && view->getCamera()->getUpdateCallback()) view->getCamera()->accept(*_updateVisitor);
1015
1016            for(unsigned int i=0; i<view->getNumSlaves(); ++i)
1017            {
1018                osg::Camera* camera = view->getSlave(i)._camera.get();
1019                if (camera && camera->getUpdateCallback()) camera->accept(*_updateVisitor);
1020            }
1021
1022            _updateVisitor->setTraversalMode(tm);
1023        }
1024
1025
1026        if (view->getCameraManipulator())
1027        {
1028            view->setFusionDistance( view->getCameraManipulator()->getFusionDistanceMode(),
1029                                     view->getCameraManipulator()->getFusionDistanceValue() );
1030                                     
1031            view->getCamera()->setViewMatrix( view->getCameraManipulator()->getInverseMatrix());
1032        }
1033        view->updateSlaves();
1034
1035    }
1036   
1037    if (getViewerStats() && getViewerStats()->collectStats("update"))
1038    {
1039        double endUpdateTraversal = osg::Timer::instance()->delta_s(_startTick, osg::Timer::instance()->tick());
1040
1041        // update current frames stats
1042        getViewerStats()->setAttribute(_frameStamp->getFrameNumber(), "Update traversal begin time", beginUpdateTraversal);
1043        getViewerStats()->setAttribute(_frameStamp->getFrameNumber(), "Update traversal end time", endUpdateTraversal);
1044        getViewerStats()->setAttribute(_frameStamp->getFrameNumber(), "Update traversal time taken", endUpdateTraversal-beginUpdateTraversal);
1045    }
1046
1047}
1048
1049double CompositeViewer::elapsedTime()
1050{
1051    return osg::Timer::instance()->delta_s(_startTick, osg::Timer::instance()->tick());
1052}
1053
1054void CompositeViewer::getUsage(osg::ApplicationUsage& usage) const
1055{
1056    for(RefViews::const_iterator vitr = _views.begin();
1057        vitr != _views.end();
1058        ++vitr)
1059    {
1060        const View* view = vitr->get();
1061        if (view->getCameraManipulator())
1062        {
1063            view->getCameraManipulator()->getUsage(usage);
1064        }
1065
1066        for(View::EventHandlers::const_iterator hitr = view->_eventHandlers.begin();
1067            hitr != view->_eventHandlers.end();
1068            ++hitr)
1069        {
1070            (*hitr)->getUsage(usage);
1071        }
1072    }
1073}
Note: See TracBrowser for help on using the browser.