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

Revision 10601, 37.2 kB (checked in by robert, 5 years ago)

Introduced new GLBufferObject pool for managing the memory footprint taken up by VertexBufferObejct?, ElementBufferObject? and PixelBufferObject?.

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