root/OpenSceneGraph/trunk/src/osgViewer/Viewer.cpp @ 13429

Revision 13429, 45.6 kB (checked in by robert, 39 hours ago)

Fixed comment

  • 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 <stdio.h>
15#include <stdlib.h>
16
17#include <osg/DeleteHandler>
18#include <osg/io_utils>
19#include <osg/TextureRectangle>
20#include <osg/TextureCubeMap>
21
22#include <osgDB/Registry>
23#include <osgDB/ReadFile>
24#include <osgDB/WriteFile>
25#include <osgGA/TrackballManipulator>
26
27#include <osgViewer/Viewer>
28#include <osgViewer/Renderer>
29#include <osgViewer/CompositeViewer>
30
31#include <osgViewer/config/SphericalDisplay>
32#include <osgViewer/config/PanoramicSphericalDisplay>
33#include <osgViewer/config/WoWVxDisplay>
34
35#include <sstream>
36#include <string.h>
37
38using namespace osgViewer;
39
40
41Viewer::Viewer()
42{
43    _viewerBase = this;
44
45    constructorInit();
46}
47
48Viewer::Viewer(osg::ArgumentParser& arguments)
49{
50    _viewerBase = this;
51
52    constructorInit();
53
54    // Add help for command-line options read here
55    arguments.getApplicationUsage()->addCommandLineOption("--SingleThreaded","Select SingleThreaded threading model for viewer.");
56    arguments.getApplicationUsage()->addCommandLineOption("--CullDrawThreadPerContext","Select CullDrawThreadPerContext threading model for viewer.");
57    arguments.getApplicationUsage()->addCommandLineOption("--DrawThreadPerContext","Select DrawThreadPerContext threading model for viewer.");
58    arguments.getApplicationUsage()->addCommandLineOption("--CullThreadPerCameraDrawThreadPerContext","Select CullThreadPerCameraDrawThreadPerContext threading model for viewer.");
59    arguments.getApplicationUsage()->addCommandLineOption("--clear-color <color>","Set the background color of the viewer in the form \"r,g,b[,a]\".");
60    arguments.getApplicationUsage()->addCommandLineOption("--screen <num>","Set the screen to use when multiple screens are present.");
61    arguments.getApplicationUsage()->addCommandLineOption("--window <x y w h>","Set the position (x,y) and size (w,h) of the viewer window.");
62
63    arguments.getApplicationUsage()->addCommandLineOption("--run-on-demand","Set the run methods frame rate management to only rendering frames when required.");
64    arguments.getApplicationUsage()->addCommandLineOption("--run-continuous","Set the run methods frame rate management to rendering frames continuously.");
65    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.");
66    arguments.getApplicationUsage()->addCommandLineOption("--enable-object-cache","Enable caching of objects, images, etc.");
67
68    // FIXME: Uncomment these lines when the options have been documented properly
69    //arguments.getApplicationUsage()->addCommandLineOption("--3d-sd","");
70    //arguments.getApplicationUsage()->addCommandLineOption("--panoramic-sd","");
71    //arguments.getApplicationUsage()->addCommandLineOption("--radius","");
72    //arguments.getApplicationUsage()->addCommandLineOption("--collar","");
73    //arguments.getApplicationUsage()->addCommandLineOption("--im","");
74
75    if (arguments.read("--ico"))
76    {
77        setIncrementalCompileOperation(new osgUtil::IncrementalCompileOperation());
78    }
79
80    std::string filename;
81    bool readConfig = false;
82    while (arguments.read("-c",filename))
83    {
84        readConfig = readConfiguration(filename) || readConfig;
85    }
86
87    // Enable caching?
88    while (arguments.read("--enable-object-cache"))
89    {
90        if (osgDB::Registry::instance()->getOptions()==0) osgDB::Registry::instance()->setOptions(new osgDB::Options());
91        osgDB::Registry::instance()->getOptions()->setObjectCacheHint(osgDB::Options::CACHE_ALL);
92    }
93
94    while (arguments.read("--SingleThreaded")) setThreadingModel(SingleThreaded);
95    while (arguments.read("--CullDrawThreadPerContext")) setThreadingModel(CullDrawThreadPerContext);
96    while (arguments.read("--DrawThreadPerContext")) setThreadingModel(DrawThreadPerContext);
97    while (arguments.read("--CullThreadPerCameraDrawThreadPerContext")) setThreadingModel(CullThreadPerCameraDrawThreadPerContext);
98
99    osg::DisplaySettings::instance()->readCommandLine(arguments);
100    osgDB::readCommandLine(arguments);
101
102    std::string colorStr;
103    while (arguments.read("--clear-color",colorStr))
104    {
105        float r, g, b;
106        float a = 1.0f;
107        int cnt = sscanf( colorStr.c_str(), "%f,%f,%f,%f", &r, &g, &b, &a );
108        if( cnt==3 || cnt==4 )
109        {
110            getCamera()->setClearColor( osg::Vec4(r,g,b,a) );
111        }
112        else
113        {
114            OSG_WARN<<"Invalid clear color \""<<colorStr<<"\""<<std::endl;
115        }
116    }
117
118
119    while(arguments.read("--run-on-demand")) { setRunFrameScheme(ON_DEMAND); }
120    while(arguments.read("--run-continuous")) { setRunFrameScheme(CONTINUOUS); }
121
122    double runMaxFrameRate;
123    while(arguments.read("--run-max-frame-rate", runMaxFrameRate)) { setRunMaxFrameRate(runMaxFrameRate); }
124
125
126    int screenNum = -1;
127    while (arguments.read("--screen",screenNum)) {}
128
129    int x = -1, y = -1, width = -1, height = -1;
130    while (arguments.read("--window",x,y,width,height)) {}
131
132    bool ss3d = false;
133    bool wowvx20 = false;
134    bool wowvx42 = false;
135    if ((wowvx20=arguments.read("--wowvx-20")) || (wowvx42=arguments.read("--wowvx-42")) || arguments.read("--wowvx"))
136    {
137        osg::ref_ptr<WoWVxDisplay> wow = new WoWVxDisplay;
138
139        if (screenNum>=0) wow->setScreenNum(screenNum);
140        if (wowvx20) wow->WoWVx20();
141        if (wowvx42) wow->WoWVx42();
142
143        unsigned int c;
144        float v;
145        while (arguments.read("--wow-content",c)) { wow->setContent(c); }
146        while (arguments.read("--wow-factor",c)) { wow->setFactor(c); }
147        while (arguments.read("--wow-offset",c)) { wow->setOffset(c); }
148        while (arguments.read("--wow-zd",v)) { wow->setDisparityZD(v); }
149        while (arguments.read("--wow-vz",v)) { wow->setDisparityVZ(v); }
150        while (arguments.read("--wow-M",v)) { wow->setDisparityM(v); }
151        while (arguments.read("--wow-C",v)) { wow->setDisparityC(v); }
152
153        apply(wow.get());
154    }
155    else if ((ss3d=arguments.read("--3d-sd")) || arguments.read("--panoramic-sd"))
156    {
157        double radius = 1.0;
158        while (arguments.read("--radius",radius)) {}
159
160        double collar = 0.45;
161        while (arguments.read("--collar",collar)) {}
162
163        std::string intensityMapFilename;
164        while (arguments.read("--im",intensityMapFilename)) {}
165
166        osg::ref_ptr<osg::Image> intensityMap = intensityMapFilename.empty() ? 0 : osgDB::readImageFile(intensityMapFilename);
167
168        if (screenNum<0) screenNum = 0;
169
170        if (ss3d)
171        {
172            setThreadingModel(SingleThreaded);
173            setUpViewFor3DSphericalDisplay(radius, collar, screenNum, intensityMap.get());
174        }
175        else
176        {
177            setThreadingModel(SingleThreaded);
178            setUpViewForPanoramicSphericalDisplay(radius, collar, screenNum, intensityMap.get());
179        }
180    }
181    else if (width>0 && height>0)
182    {
183        if (screenNum>=0) setUpViewInWindow(x, y, width, height, screenNum);
184        else setUpViewInWindow(x,y,width,height);
185
186    }
187    else if (screenNum>=0)
188    {
189        setUpViewOnSingleScreen(screenNum);
190    }
191
192}
193
194Viewer::Viewer(const osgViewer::Viewer& viewer, const osg::CopyOp& copyop):
195    osg::Object(true),
196    ViewerBase(viewer),
197    View(viewer,copyop)
198{
199    _viewerBase = this;
200}
201
202void Viewer::constructorInit()
203{
204    _eventVisitor = new osgGA::EventVisitor;
205    _eventVisitor->setActionAdapter(this);
206    _eventVisitor->setFrameStamp(_frameStamp.get());
207
208    _updateVisitor = new osgUtil::UpdateVisitor;
209    _updateVisitor->setFrameStamp(_frameStamp.get());
210
211    setViewerStats(new osg::Stats("Viewer"));
212}
213
214Viewer::~Viewer()
215{
216    //OSG_NOTICE<<"Viewer::~Viewer()"<<std::endl;
217
218    Threads threads;
219    getAllThreads(threads);
220
221    OSG_INFO<<"Viewer::~Viewer():: start destructor getThreads = "<<threads.size()<<std::endl;
222
223    stopThreading();
224
225    if (_scene.valid() && _scene->getDatabasePager())
226    {
227        _scene->getDatabasePager()->cancel();
228        _scene->setDatabasePager(0);
229    }
230
231    Contexts contexts;
232    getContexts(contexts);
233
234    // clear out all the previously assigned operations
235    for(Contexts::iterator citr = contexts.begin();
236        citr != contexts.end();
237        ++citr)
238    {
239        (*citr)->close();
240    }
241
242    //OSG_NOTICE<<"finish Viewer::~Viewer()"<<std::endl;
243
244    getAllThreads(threads);
245
246    OSG_INFO<<"Viewer::~Viewer() end destructor getThreads = "<<threads.size()<<std::endl;
247}
248
249void Viewer::take(osg::View& rhs)
250{
251    osgViewer::View::take(rhs);
252
253#if 1
254    osgViewer::Viewer* rhs_viewer = dynamic_cast<osgViewer::Viewer*>(&rhs);
255    if (rhs_viewer)
256    {
257        // variables left to take.
258        _done = rhs_viewer->_done;
259        _keyEventSetsDone = rhs_viewer->_keyEventSetsDone;
260        _quitEventSetsDone = rhs_viewer->_quitEventSetsDone;
261        _threadingModel = rhs_viewer->_threadingModel;
262        _threadsRunning = rhs_viewer->_threadsRunning;
263        _endBarrierPosition = rhs_viewer->_endBarrierPosition;
264        _startRenderingBarrier = rhs_viewer->_startRenderingBarrier;
265        _endRenderingDispatchBarrier = rhs_viewer->_endRenderingDispatchBarrier;
266        _endDynamicDrawBlock = rhs_viewer->_endDynamicDrawBlock;
267        _eventVisitor = rhs_viewer->_eventVisitor;
268        _updateOperations = rhs_viewer->_updateOperations;
269        _updateVisitor = rhs_viewer->_updateVisitor;
270        _realizeOperation = rhs_viewer->_realizeOperation;
271        _currentContext = rhs_viewer->_currentContext;
272
273
274        // objects to clear
275        rhs_viewer->_done = true;
276        rhs_viewer->_startRenderingBarrier = 0;
277        rhs_viewer->_endRenderingDispatchBarrier = 0;
278        rhs_viewer->_endDynamicDrawBlock = 0;
279        rhs_viewer->_eventVisitor = 0;
280        rhs_viewer->_updateOperations = 0;
281        rhs_viewer->_updateVisitor = 0;
282        rhs_viewer->_realizeOperation = 0;
283        rhs_viewer->_currentContext = 0;
284    }
285#endif
286}
287
288bool Viewer::readConfiguration(const std::string& filename)
289{
290    OSG_INFO<<"Viewer::readConfiguration("<<filename<<")"<<std::endl;
291
292    osg::ref_ptr<osg::Object> object = osgDB::readObjectFile(filename);
293    if (!object)
294    {
295        //OSG_NOTICE<<"Error: Unable to load configuration file \""<<filename<<"\""<<std::endl;
296        return false;
297    }
298   
299    ViewConfig* config = dynamic_cast<ViewConfig*>(object.get());
300    if (config)
301    {
302        OSG_NOTICE<<"Using osgViewer::Config : "<<config->className()<<std::endl;
303        config->configure(*this);
304       
305        osgDB::writeObjectFile(*config,"test.osgt");
306       
307        return true;
308    }
309   
310
311    CompositeViewer* compositeViewer = dynamic_cast<CompositeViewer*>(object.get());
312    if (compositeViewer)
313    {
314        OSG_NOTICE<<"Error: Config file \""<<filename<<"\" containing CompositeViewer cannot be loaded by Viewer."<<std::endl;
315        return false;
316    }
317
318    View* view = dynamic_cast<osgViewer::View*>(object.get());
319    if (view)
320    {
321        take(*view);
322
323        return true;
324    }
325    else
326    {
327        OSG_NOTICE<<"Error: Config file \""<<filename<<"\" does not contain a valid Viewer configuration."<<std::endl;
328        return false;
329    }
330}
331
332bool Viewer::isRealized() const
333{
334    Contexts contexts;
335    const_cast<Viewer*>(this)->getContexts(contexts);
336
337    unsigned int numRealizedWindows = 0;
338
339    // clear out all the previously assigned operations
340    for(Contexts::iterator citr = contexts.begin();
341        citr != contexts.end();
342        ++citr)
343    {
344        if ((*citr)->isRealized()) ++numRealizedWindows;
345    }
346
347    return numRealizedWindows > 0;
348}
349
350bool Viewer::checkNeedToDoFrame()
351{
352    if (_requestRedraw) return true;
353    if (_requestContinousUpdate) return true;
354
355
356    // If the database pager is going to update the scene the render flag is
357    // set so that the updates show up
358    if(getDatabasePager()->requiresUpdateSceneGraph() || getDatabasePager()->getRequestsInProgress()) return true;
359
360    // if there update callbacks then we need to do frame.
361    if (_camera->getUpdateCallback()) return true;
362    if (getSceneData()!=0 && getSceneData()->getNumChildrenRequiringUpdateTraversal()>0) return true;
363
364    // check if events are available and need processing
365    if (checkEvents()) return true;
366   
367    // now check if any of the event handles have prompted a redraw.
368    if (_requestRedraw) return true;
369    if (_requestContinousUpdate) return true;
370
371    return false;
372}
373
374bool Viewer::checkEvents()
375{
376    // check events from any attached sources
377    for(Devices::iterator eitr = _eventSources.begin();
378        eitr != _eventSources.end();
379        ++eitr)
380    {
381        osgGA::Device* es = eitr->get();
382        if (es->getCapabilities() & osgGA::Device::RECEIVE_EVENTS)
383        {
384            if (es->checkEvents()) return true;
385        }
386
387    }
388
389    // get events from all windows attached to Viewer.
390    Windows windows;
391    getWindows(windows);
392    for(Windows::iterator witr = windows.begin();
393        witr != windows.end();
394        ++witr)
395    {
396        if ((*witr)->checkEvents()) return true;
397    }
398   
399    return false;
400}
401
402int Viewer::run()
403{
404    if (!getCameraManipulator() && getCamera()->getAllowEventFocus())
405    {
406        setCameraManipulator(new osgGA::TrackballManipulator());
407    }
408
409    setReleaseContextAtEndOfFrameHint(false);
410
411    return ViewerBase::run();
412}
413
414void Viewer::setStartTick(osg::Timer_t tick)
415{
416    View::setStartTick(tick);
417
418    Contexts contexts;
419    getContexts(contexts,false);
420
421    getEventQueue()->setStartTick(_startTick);
422    for(Contexts::iterator citr = contexts.begin();
423        citr != contexts.end();
424        ++citr)
425    {
426        osgViewer::GraphicsWindow* gw = dynamic_cast<osgViewer::GraphicsWindow*>(*citr);
427        if (gw)
428        {
429            gw->getEventQueue()->setStartTick(_startTick);
430        }
431    }
432}
433
434void Viewer::setReferenceTime(double time)
435{
436    osg::Timer_t tick = osg::Timer::instance()->tick();
437    double currentTime = osg::Timer::instance()->delta_s(_startTick, tick);
438    double delta_ticks = (time-currentTime)*(osg::Timer::instance()->getSecondsPerTick());
439    if (delta_ticks>=0) tick += osg::Timer_t(delta_ticks);
440    else tick -= osg::Timer_t(-delta_ticks);
441
442    // assign the new start tick
443    setStartTick(tick);
444}
445
446
447void Viewer::setSceneData(osg::Node* node)
448{
449    setReferenceTime(0.0);
450
451    View::setSceneData(node);
452}
453
454GraphicsWindowEmbedded* Viewer::setUpViewerAsEmbeddedInWindow(int x, int y, int width, int height)
455{
456    setThreadingModel(SingleThreaded);
457    osgViewer::GraphicsWindowEmbedded* gw = new osgViewer::GraphicsWindowEmbedded(x,y,width,height);
458    getCamera()->setViewport(new osg::Viewport(0,0,width,height));
459    getCamera()->setProjectionMatrixAsPerspective(30.0f, static_cast<double>(width)/static_cast<double>(height), 1.0f, 10000.0f);
460    getCamera()->setGraphicsContext(gw);
461    return gw;
462}
463
464void Viewer::realize()
465{
466    //OSG_INFO<<"Viewer::realize()"<<std::endl;
467
468    Contexts contexts;
469    getContexts(contexts);
470
471    if (contexts.empty())
472    {
473        OSG_INFO<<"Viewer::realize() - No valid contexts found, setting up view across all screens."<<std::endl;
474
475        // no windows are already set up so set up a default view
476
477        const char* ptr = 0;
478        if ((ptr = getenv("OSG_CONFIG_FILE")) != 0)
479        {
480            readConfiguration(ptr);
481        }
482        else
483        {
484            int screenNum = -1;
485            if ((ptr = getenv("OSG_SCREEN")) != 0)
486            {
487                if (strlen(ptr)!=0) screenNum = atoi(ptr);
488                else screenNum = -1;
489            }
490
491            int x = -1, y = -1, width = -1, height = -1;
492            if ((ptr = getenv("OSG_WINDOW")) != 0)
493            {
494                std::istringstream iss(ptr);
495                iss >> x >> y >> width >> height;
496            }
497
498            if (width>0 && height>0)
499            {
500                if (screenNum>=0) setUpViewInWindow(x, y, width, height, screenNum);
501                else setUpViewInWindow(x,y,width,height);
502            }
503            else if (screenNum>=0)
504            {
505                setUpViewOnSingleScreen(screenNum);
506            }
507            else
508            {
509                setUpViewAcrossAllScreens();
510            }
511        }
512
513        getContexts(contexts);
514    }
515
516    if (contexts.empty())
517    {
518        OSG_NOTICE<<"Viewer::realize() - failed to set up any windows"<<std::endl;
519        _done = true;
520        return;
521    }
522
523    unsigned int maxTexturePoolSize = osg::DisplaySettings::instance()->getMaxTexturePoolSize();
524    if (_camera->getDisplaySettings()) maxTexturePoolSize = std::max(maxTexturePoolSize, _camera->getDisplaySettings()->getMaxTexturePoolSize());
525    if (_displaySettings.valid()) maxTexturePoolSize = std::max(maxTexturePoolSize, _displaySettings->getMaxTexturePoolSize());
526
527    unsigned int maxBufferObjectPoolSize = osg::DisplaySettings::instance()->getMaxBufferObjectPoolSize();
528    if (_displaySettings.valid()) maxBufferObjectPoolSize = std::max(maxBufferObjectPoolSize, _displaySettings->getMaxBufferObjectPoolSize());
529    if (_camera->getDisplaySettings()) maxBufferObjectPoolSize = std::max(maxBufferObjectPoolSize, _camera->getDisplaySettings()->getMaxBufferObjectPoolSize());
530
531    for(Contexts::iterator citr = contexts.begin();
532        citr != contexts.end();
533        ++citr)
534    {
535        osg::GraphicsContext* gc = *citr;
536
537        // set the pool sizes, 0 the default will result in no GL object pools.
538        gc->getState()->setMaxTexturePoolSize(maxTexturePoolSize);
539        gc->getState()->setMaxBufferObjectPoolSize(maxBufferObjectPoolSize);
540
541        gc->realize();
542
543        if (_realizeOperation.valid() && gc->valid())
544        {
545            gc->makeCurrent();
546
547            (*_realizeOperation)(gc);
548
549            gc->releaseContext();
550        }
551    }
552
553    // attach contexts to _incrementalCompileOperation if attached.
554    if (_incrementalCompileOperation) _incrementalCompileOperation->assignContexts(contexts);
555
556    bool grabFocus = true;
557    if (grabFocus)
558    {
559        for(Contexts::iterator citr = contexts.begin();
560            citr != contexts.end();
561            ++citr)
562        {
563            osgViewer::GraphicsWindow* gw = dynamic_cast<osgViewer::GraphicsWindow*>(*citr);
564            if (gw)
565            {
566                gw->grabFocusIfPointerInWindow();
567            }
568        }
569    }
570
571    // initialize the global timer to be relative to the current time.
572    osg::Timer::instance()->setStartTick();
573
574    // pass on the start tick to all the associated event queues
575    setStartTick(osg::Timer::instance()->getStartTick());
576
577    setUpThreading();
578
579    if (osg::DisplaySettings::instance()->getCompileContextsHint())
580    {
581        int numProcessors = OpenThreads::GetNumberOfProcessors();
582        int processNum = 0;
583
584        for(unsigned int i=0; i<= osg::GraphicsContext::getMaxContextID(); ++i)
585        {
586            osg::GraphicsContext* gc = osg::GraphicsContext::getOrCreateCompileContext(i);
587
588            if (gc)
589            {
590                gc->createGraphicsThread();
591                gc->getGraphicsThread()->setProcessorAffinity(processNum % numProcessors);
592                gc->getGraphicsThread()->startThread();
593
594                ++processNum;
595            }
596        }
597    }
598#if 0
599    osgGA::GUIEventAdapter* eventState = getEventQueue()->getCurrentEventState();
600    if (getCamera()->getViewport())
601    {
602        osg::Viewport* viewport = getCamera()->getViewport();
603        eventState->setInputRange( viewport->x(), viewport->y(), viewport->x() + viewport->width(), viewport->y() + viewport->height());
604    }
605    else
606    {
607        eventState->setInputRange(-1.0, -1.0, 1.0, 1.0);
608    }
609#endif
610}
611
612
613
614void Viewer::advance(double simulationTime)
615{
616    if (_done) return;
617
618    double previousReferenceTime = _frameStamp->getReferenceTime();
619    unsigned int previousFrameNumber = _frameStamp->getFrameNumber();
620
621    _frameStamp->setFrameNumber(_frameStamp->getFrameNumber()+1);
622
623    _frameStamp->setReferenceTime( osg::Timer::instance()->delta_s(_startTick, osg::Timer::instance()->tick()) );
624
625    if (simulationTime==USE_REFERENCE_TIME)
626    {
627        _frameStamp->setSimulationTime(_frameStamp->getReferenceTime());
628    }
629    else
630    {
631        _frameStamp->setSimulationTime(simulationTime);
632    }
633
634    if (getViewerStats() && getViewerStats()->collectStats("frame_rate"))
635    {
636        // update previous frame stats
637        double deltaFrameTime = _frameStamp->getReferenceTime() - previousReferenceTime;
638        getViewerStats()->setAttribute(previousFrameNumber, "Frame duration", deltaFrameTime);
639        getViewerStats()->setAttribute(previousFrameNumber, "Frame rate", 1.0/deltaFrameTime);
640
641        // update current frames stats
642        getViewerStats()->setAttribute(_frameStamp->getFrameNumber(), "Reference time", _frameStamp->getReferenceTime());
643    }
644
645
646    if (osg::Referenced::getDeleteHandler())
647    {
648        osg::Referenced::getDeleteHandler()->flush();
649        osg::Referenced::getDeleteHandler()->setFrameNumber(_frameStamp->getFrameNumber());
650    }
651
652}
653
654void Viewer::generateSlavePointerData(osg::Camera* camera, osgGA::GUIEventAdapter& event)
655{
656    osgViewer::GraphicsWindow* gw = dynamic_cast<osgViewer::GraphicsWindow*>(event.getGraphicsContext());
657    if (!gw) return;
658
659    // What type of Camera is it?
660    // 1) Master Camera : do nothin extra
661    // 2) Slave Camera, Relative RF, Same scene graph as master : transform coords into Master Camera and add to PointerData list
662    // 3) Slave Camera, Relative RF, Different scene graph from master : do nothing extra?
663    // 4) Slave Camera, Absolute RF, Same scene graph as master : do nothing extra?
664    // 5) Slave Camera, Absolute RF, Different scene graph : do nothing extra?
665    // 6) Slave Camera, Absolute RF, Different scene graph but a distortion correction subgraph depending upon RTT Camera (slave or master)
666    //                              : project ray into RTT Camera's clip space, and RTT Camera's is Relative RF and sharing same scene graph as master then transform coords.
667
668    // if camera isn't the master it must be a slave and could need reprojecting.
669    if (camera!=getCamera())
670    {
671        float x = event.getX();
672        float y = event.getY();
673
674        bool invert_y = event.getMouseYOrientation()==osgGA::GUIEventAdapter::Y_INCREASING_DOWNWARDS;
675        if (invert_y && gw->getTraits()) y = gw->getTraits()->height - y;
676
677        osg::Matrix masterCameraVPW = getCamera()->getViewMatrix() * getCamera()->getProjectionMatrix();
678        if (getCamera()->getViewport())
679        {
680            osg::Viewport* viewport = getCamera()->getViewport();
681            masterCameraVPW *= viewport->computeWindowMatrix();
682        }
683
684        // slave Camera tahnks to sharing the same View
685        osg::View::Slave* slave = findSlaveForCamera(camera);
686        if (slave)
687        {
688            if (camera->getReferenceFrame()==osg::Camera::RELATIVE_RF && slave->_useMastersSceneData)
689            {
690                osg::Viewport* viewport = camera->getViewport();
691                osg::Matrix localCameraVPW = camera->getViewMatrix() * camera->getProjectionMatrix();
692                if (viewport) localCameraVPW *= viewport->computeWindowMatrix();
693
694                osg::Matrix matrix( osg::Matrix::inverse(localCameraVPW) * masterCameraVPW );
695                osg::Vec3d new_coord = osg::Vec3d(x,y,0.0) * matrix;
696                //OSG_NOTICE<<"    pointer event new_coord.x()="<<new_coord.x()<<" new_coord.y()="<<new_coord.y()<<std::endl;
697                event.addPointerData(new osgGA::PointerData(getCamera(), new_coord.x(), -1.0, 1.0,
698                                                                         new_coord.y(), -1.0, 1.0));
699            }
700            else if (!slave->_useMastersSceneData)
701            {
702                // Are their any RTT Camera's that this Camera depends upon for textures?
703
704                osg::ref_ptr<osgUtil::LineSegmentIntersector> ray = new osgUtil::LineSegmentIntersector(osgUtil::Intersector::WINDOW, x,y);
705                osgUtil::IntersectionVisitor iv(ray.get());
706                camera->accept(iv);
707                if (ray->containsIntersections())
708                {
709                    osg::Vec3 tc;
710                    osg::Texture* texture = ray->getFirstIntersection().getTextureLookUp(tc);
711                    if (texture)
712                    {
713                        // look up Texture in RTT Camera's.
714                        for(unsigned int i=0; i<getNumSlaves();++i)
715                        {
716                            osg::Camera* slave_camera = getSlave(i)._camera.get();
717                            if (slave_camera)
718                            {
719                                osg::Camera::BufferAttachmentMap::const_iterator ba_itr = slave_camera->getBufferAttachmentMap().find(osg::Camera::COLOR_BUFFER);
720                                if (ba_itr != slave_camera->getBufferAttachmentMap().end())
721                                {
722                                    if (ba_itr->second._texture == texture)
723                                    {
724                                        osg::TextureRectangle* tr = dynamic_cast<osg::TextureRectangle*>(ba_itr->second._texture.get());
725                                        osg::TextureCubeMap* tcm = dynamic_cast<osg::TextureCubeMap*>(ba_itr->second._texture.get());
726                                        if (tr)
727                                        {
728                                            event.addPointerData(new osgGA::PointerData(slave_camera, tc.x(), 0.0f, static_cast<float>(tr->getTextureWidth()),
729                                                                                                      tc.y(), 0.0f, static_cast<float>(tr->getTextureHeight())));
730                                        }
731                                        else if (tcm)
732                                        {
733                                            OSG_NOTICE<<"  Slave has matched texture cubemap"<<ba_itr->second._texture.get()<<", "<<ba_itr->second._face<<std::endl;
734                                        }
735                                        else
736                                        {
737                                            event.addPointerData(new osgGA::PointerData(slave_camera, tc.x(), 0.0f, 1.0f,
738                                                                                                      tc.y(), 0.0f, 1.0f));
739                                        }
740                                    }
741                                }
742                            }
743                        }
744                    }
745                }
746            }
747        }
748    }
749}
750   
751   
752void Viewer::generatePointerData(osgGA::GUIEventAdapter& event)
753{
754    osgViewer::GraphicsWindow* gw = dynamic_cast<osgViewer::GraphicsWindow*>(event.getGraphicsContext());
755    if (!gw) return;
756
757    float x = event.getX();
758    float y = event.getY();
759
760    bool invert_y = event.getMouseYOrientation()==osgGA::GUIEventAdapter::Y_INCREASING_DOWNWARDS;
761    if (invert_y && gw->getTraits()) y = gw->getTraits()->height - y;
762   
763    event.addPointerData(new osgGA::PointerData(gw, x, 0, gw->getTraits()->width,
764                                                    y, 0, gw->getTraits()->height));
765
766    // new code for populating the PointerData
767    osgViewer::View* this_view = dynamic_cast<osgViewer::View*>(this);
768    osg::GraphicsContext::Cameras& cameras = gw->getCameras();
769    for(osg::GraphicsContext::Cameras::iterator citr = cameras.begin();
770        citr != cameras.end();
771        ++citr)
772    {
773        osg::Camera* camera = *citr;
774        if (camera->getView()==this_view &&
775            camera->getAllowEventFocus() &&
776            camera->getRenderTargetImplementation()==osg::Camera::FRAME_BUFFER)
777        {
778            osg::Viewport* viewport = camera ? camera->getViewport() : 0;
779            if (viewport &&
780                x >= viewport->x() && y >= viewport->y() &&
781                x <= (viewport->x()+viewport->width()) && y <= (viewport->y()+viewport->height()) )
782            {
783                event.addPointerData(new osgGA::PointerData(camera, (x-viewport->x())/viewport->width()*2.0f-1.0f, -1.0, 1.0,
784                                                                    (y-viewport->y())/viewport->height()*2.0f-1.0f, -1.0, 1.0));
785
786                // if camera isn't the master it must be a slave and could need reprojecting.
787                if (camera!=getCamera())
788                {
789                    generateSlavePointerData(camera, event);
790                }
791            }
792        }
793    }
794}
795
796void Viewer::reprojectPointerData(osgGA::GUIEventAdapter& source_event, osgGA::GUIEventAdapter& dest_event)
797{
798    osgViewer::GraphicsWindow* gw = dynamic_cast<osgViewer::GraphicsWindow*>(dest_event.getGraphicsContext());
799    if (!gw) return;
800
801    float x = dest_event.getX();
802    float y = dest_event.getY();
803
804    bool invert_y = dest_event.getMouseYOrientation()==osgGA::GUIEventAdapter::Y_INCREASING_DOWNWARDS;
805    if (invert_y && gw->getTraits()) y = gw->getTraits()->height - y;
806
807    dest_event.addPointerData(new osgGA::PointerData(gw, x, 0, gw->getTraits()->width,
808                                                         y, 0, gw->getTraits()->height));
809
810    osg::Camera* camera = (source_event.getNumPointerData()>=2) ? dynamic_cast<osg::Camera*>(source_event.getPointerData(1)->object.get()) : 0;
811    osg::Viewport* viewport = camera ? camera->getViewport() : 0;
812
813    if (!viewport) return;
814   
815    dest_event.addPointerData(new osgGA::PointerData(camera, (x-viewport->x())/viewport->width()*2.0f-1.0f, -1.0, 1.0,
816                                                             (y-viewport->y())/viewport->height()*2.0f-1.0f, -1.0, 1.0));
817
818    // if camera isn't the master it must be a slave and could need reprojecting.
819    if (camera!=getCamera())
820    {
821        generateSlavePointerData(camera, dest_event);
822    }
823}
824
825void Viewer::eventTraversal()
826{
827    if (_done) return;
828
829#if 1
830    double cutOffTime = _frameStamp->getReferenceTime();
831#else   
832    double cutOffTime = (_runFrameScheme==ON_DEMAND) ? DBL_MAX : _frameStamp->getReferenceTime();
833#endif
834   
835    double beginEventTraversal = osg::Timer::instance()->delta_s(_startTick, osg::Timer::instance()->tick());
836
837    // OSG_NOTICE<<"Viewer::frameEventTraversal()."<<std::endl;
838
839    // need to copy events from the GraphicsWindow's into local EventQueue;
840    osgGA::EventQueue::Events events;
841
842    Contexts contexts;
843    getContexts(contexts);
844
845    // set done if there are no windows
846    checkWindowStatus(contexts);
847    if (_done) return;
848
849    osgGA::GUIEventAdapter* eventState = getEventQueue()->getCurrentEventState();
850
851    // get events from user Devices attached to Viewer.
852    for(Devices::iterator eitr = _eventSources.begin();
853        eitr != _eventSources.end();
854        ++eitr)
855    {
856        osgGA::Device* es = eitr->get();
857        if (es->getCapabilities() & osgGA::Device::RECEIVE_EVENTS)
858            es->checkEvents();
859
860        // open question, will we need to reproject mouse coordinates into current view's coordinate frame as is down for GraphicsWindow provided events?
861        // for now assume now and just get the events directly without any reprojection.
862        es->getEventQueue()->takeEvents(events, cutOffTime);
863    }
864
865    // get events from all windows attached to Viewer.
866    for(Contexts::iterator citr = contexts.begin();
867        citr != contexts.end();
868        ++citr)
869    {
870        osgViewer::GraphicsWindow* gw = dynamic_cast<osgViewer::GraphicsWindow*>(*citr);
871        if (gw)
872        {
873            gw->checkEvents();
874
875            osgGA::EventQueue::Events gw_events;
876            gw->getEventQueue()->takeEvents(gw_events, cutOffTime);
877
878            osgGA::EventQueue::Events::iterator itr;
879            for(itr = gw_events.begin();
880                itr != gw_events.end();
881                ++itr)
882            {
883                osgGA::GUIEventAdapter* event = itr->get();
884
885                event->setGraphicsContext(gw);
886
887                switch(event->getEventType())
888                {
889                    case(osgGA::GUIEventAdapter::PUSH):
890                    case(osgGA::GUIEventAdapter::RELEASE):
891                    case(osgGA::GUIEventAdapter::DOUBLECLICK):
892                    case(osgGA::GUIEventAdapter::MOVE):
893                    case(osgGA::GUIEventAdapter::DRAG):
894                    {
895                        if (event->getEventType()!=osgGA::GUIEventAdapter::DRAG ||
896                            eventState->getGraphicsContext()!=event->getGraphicsContext() ||
897                            eventState->getNumPointerData()<2)
898                        {
899                            generatePointerData(*event);
900                        }
901                        else
902                        {
903                            reprojectPointerData(*eventState, *event);
904                        }
905
906#if 0
907                        // assign topmost PointeData settings as the events X,Y and InputRange
908                        osgGA::PointerData* pd = event->getPointerData(event->getNumPointerData()-1);
909                        event->setX(pd->x);
910                        event->setY(pd->y);
911                        event->setInputRange(pd->xMin, pd->yMin, pd->xMax, pd->yMax);
912                        event->setMouseYOrientation(osgGA::GUIEventAdapter::Y_INCREASING_UPWARDS);
913#else
914                        if (event->getMouseYOrientation()!=osgGA::GUIEventAdapter::Y_INCREASING_UPWARDS)
915                        {
916                            event->setY((event->getYmax()-event->getY())+event->getYmin());
917                            event->setMouseYOrientation(osgGA::GUIEventAdapter::Y_INCREASING_UPWARDS);
918                        }
919#endif
920
921                        eventState->copyPointerDataFrom(*event);
922                       
923                        break;
924                    }
925                    default:
926                        event->copyPointerDataFrom(*eventState);
927                        break;
928                }
929               
930                events.push_back(event);
931            }
932           
933            for(itr = gw_events.begin();
934                itr != gw_events.end();
935                ++itr)
936            {
937                osgGA::GUIEventAdapter* event = itr->get();
938                switch(event->getEventType())
939                {
940                    case(osgGA::GUIEventAdapter::CLOSE_WINDOW):
941                    {
942                        bool wasThreading = areThreadsRunning();
943                        if (wasThreading) stopThreading();
944
945                        gw->close();
946                        _currentContext = NULL;
947
948                        if (wasThreading) startThreading();
949
950                        break;
951                    }
952                    default:
953                        break;
954                }
955            }
956
957        }
958    }
959
960    // create a frame event for the new frame.
961    _eventQueue->frame( getFrameStamp()->getReferenceTime() );
962
963    // OSG_NOTICE<<"mouseEventState Xmin = "<<eventState->getXmin()<<" Ymin="<<eventState->getYmin()<<" xMax="<<eventState->getXmax()<<" Ymax="<<eventState->getYmax()<<std::endl;
964
965    _eventQueue->takeEvents(events, cutOffTime);
966
967    // OSG_NOTICE<<"Events "<<events.size()<<std::endl;
968
969    if ((_keyEventSetsDone!=0) || _quitEventSetsDone)
970    {
971        for(osgGA::EventQueue::Events::iterator itr = events.begin();
972            itr != events.end();
973            ++itr)
974        {
975            osgGA::GUIEventAdapter* event = itr->get();
976            switch(event->getEventType())
977            {
978                case(osgGA::GUIEventAdapter::KEYUP):
979                    if (_keyEventSetsDone && event->getKey()==_keyEventSetsDone) _done = true;
980                    break;
981
982                case(osgGA::GUIEventAdapter::QUIT_APPLICATION):
983                    if (_quitEventSetsDone) _done = true;
984                    break;
985
986                default:
987                    break;
988            }
989        }
990    }
991
992    if (_done) return;
993
994    if (_eventVisitor.valid() && getSceneData())
995    {
996        _eventVisitor->setFrameStamp(getFrameStamp());
997        _eventVisitor->setTraversalNumber(getFrameStamp()->getFrameNumber());
998
999        for(osgGA::EventQueue::Events::iterator itr = events.begin();
1000            itr != events.end();
1001            ++itr)
1002        {
1003            osgGA::GUIEventAdapter* event = itr->get();
1004
1005            _eventVisitor->reset();
1006            _eventVisitor->addEvent( event );
1007
1008            getSceneData()->accept(*_eventVisitor);
1009
1010            // Do EventTraversal for slaves with their own subgraph
1011            for(unsigned int i=0; i<getNumSlaves(); ++i)
1012            {
1013                osg::View::Slave& slave = getSlave(i);
1014                osg::Camera* camera = slave._camera.get();
1015                if(camera && !slave._useMastersSceneData)
1016                {
1017                    camera->accept(*_eventVisitor);
1018                }
1019            }
1020
1021
1022            // call any camera event callbacks, but only traverse that callback, don't traverse its subgraph
1023            // leave that to the scene update traversal.
1024            osg::NodeVisitor::TraversalMode tm = _eventVisitor->getTraversalMode();
1025            _eventVisitor->setTraversalMode(osg::NodeVisitor::TRAVERSE_NONE);
1026
1027            if (_camera.valid() && _camera->getEventCallback()) _camera->accept(*_eventVisitor);
1028
1029            for(unsigned int i=0; i<getNumSlaves(); ++i)
1030            {
1031                osg::View::Slave& slave = getSlave(i);
1032                osg::Camera* camera = slave._camera.get();
1033                if (camera && slave._useMastersSceneData && camera->getEventCallback())
1034                {
1035                    camera->accept(*_eventVisitor);
1036                }
1037            }
1038
1039            _eventVisitor->setTraversalMode(tm);
1040
1041        }
1042    }
1043
1044
1045    for(osgGA::EventQueue::Events::iterator itr = events.begin();
1046        itr != events.end();
1047        ++itr)
1048    {
1049        osgGA::GUIEventAdapter* event = itr->get();
1050
1051        for(EventHandlers::iterator hitr = _eventHandlers.begin();
1052            hitr != _eventHandlers.end();
1053            ++hitr)
1054        {
1055            (*hitr)->handleWithCheckAgainstIgnoreHandledEventsMask( *event, *this, 0, _eventVisitor.get());
1056        }
1057
1058    }
1059
1060    for(osgGA::EventQueue::Events::iterator itr = events.begin();
1061        itr != events.end();
1062        ++itr)
1063    {
1064        osgGA::GUIEventAdapter* event = itr->get();
1065        if (_cameraManipulator.valid())
1066        {
1067            _cameraManipulator->handleWithCheckAgainstIgnoreHandledEventsMask( *event, *this);
1068        }
1069    }
1070
1071    if (getViewerStats() && getViewerStats()->collectStats("event"))
1072    {
1073        double endEventTraversal = osg::Timer::instance()->delta_s(_startTick, osg::Timer::instance()->tick());
1074
1075        // update current frames stats
1076        getViewerStats()->setAttribute(_frameStamp->getFrameNumber(), "Event traversal begin time", beginEventTraversal);
1077        getViewerStats()->setAttribute(_frameStamp->getFrameNumber(), "Event traversal end time", endEventTraversal);
1078        getViewerStats()->setAttribute(_frameStamp->getFrameNumber(), "Event traversal time taken", endEventTraversal-beginEventTraversal);
1079    }
1080
1081}
1082
1083void Viewer::updateTraversal()
1084{
1085    if (_done) return;
1086
1087    double beginUpdateTraversal = osg::Timer::instance()->delta_s(_startTick, osg::Timer::instance()->tick());
1088
1089    _updateVisitor->reset();
1090    _updateVisitor->setFrameStamp(getFrameStamp());
1091    _updateVisitor->setTraversalNumber(getFrameStamp()->getFrameNumber());
1092
1093    _scene->updateSceneGraph(*_updateVisitor);
1094
1095    // if we have a shared state manager prune any unused entries
1096    if (osgDB::Registry::instance()->getSharedStateManager())
1097        osgDB::Registry::instance()->getSharedStateManager()->prune();
1098
1099    // update the Registry object cache.
1100    osgDB::Registry::instance()->updateTimeStampOfObjectsInCacheWithExternalReferences(*getFrameStamp());
1101    osgDB::Registry::instance()->removeExpiredObjectsInCache(*getFrameStamp());
1102
1103
1104    if (_updateOperations.valid())
1105    {
1106        _updateOperations->runOperations(this);
1107    }
1108
1109    if (_incrementalCompileOperation.valid())
1110    {
1111        // merge subgraphs that have been compiled by the incremental compiler operation.
1112        _incrementalCompileOperation->mergeCompiledSubgraphs(getFrameStamp());
1113    }
1114
1115    {
1116        // Do UpdateTraversal for slaves with their own subgraph
1117        for(unsigned int i=0; i<getNumSlaves(); ++i)
1118        {
1119            osg::View::Slave& slave = getSlave(i);
1120            osg::Camera* camera = slave._camera.get();
1121            if(camera && !slave._useMastersSceneData)
1122            {
1123                camera->accept(*_updateVisitor);
1124            }
1125        }
1126    }
1127
1128    {
1129        // call any camera update callbacks, but only traverse that callback, don't traverse its subgraph
1130        // leave that to the scene update traversal.
1131        osg::NodeVisitor::TraversalMode tm = _updateVisitor->getTraversalMode();
1132        _updateVisitor->setTraversalMode(osg::NodeVisitor::TRAVERSE_NONE);
1133
1134        if (_camera.valid() && _camera->getUpdateCallback()) _camera->accept(*_updateVisitor);
1135
1136        for(unsigned int i=0; i<getNumSlaves(); ++i)
1137        {
1138            osg::View::Slave& slave = getSlave(i);
1139            osg::Camera* camera = slave._camera.get();
1140            if (camera && slave._useMastersSceneData && camera->getUpdateCallback())
1141            {
1142                camera->accept(*_updateVisitor);
1143            }
1144        }
1145
1146        _updateVisitor->setTraversalMode(tm);
1147    }
1148
1149    if (_cameraManipulator.valid())
1150    {
1151        setFusionDistance( getCameraManipulator()->getFusionDistanceMode(),
1152                            getCameraManipulator()->getFusionDistanceValue() );
1153
1154        _cameraManipulator->updateCamera(*_camera);
1155    }
1156
1157    updateSlaves();
1158
1159    if (getViewerStats() && getViewerStats()->collectStats("update"))
1160    {
1161        double endUpdateTraversal = osg::Timer::instance()->delta_s(_startTick, osg::Timer::instance()->tick());
1162
1163        // update current frames stats
1164        getViewerStats()->setAttribute(_frameStamp->getFrameNumber(), "Update traversal begin time", beginUpdateTraversal);
1165        getViewerStats()->setAttribute(_frameStamp->getFrameNumber(), "Update traversal end time", endUpdateTraversal);
1166        getViewerStats()->setAttribute(_frameStamp->getFrameNumber(), "Update traversal time taken", endUpdateTraversal-beginUpdateTraversal);
1167    }
1168}
1169
1170void Viewer::getScenes(Scenes& scenes, bool onlyValid)
1171{
1172    scenes.clear();
1173    scenes.push_back(_scene.get());
1174}
1175
1176void Viewer::getViews(Views& views, bool onlyValid)
1177{
1178    views.clear();
1179    views.push_back(this);
1180}
1181
1182void Viewer::getAllThreads(Threads& threads, bool onlyActive)
1183{
1184    threads.clear();
1185
1186    OperationThreads operationThreads;
1187    getOperationThreads(operationThreads);
1188
1189    for(OperationThreads::iterator itr = operationThreads.begin();
1190        itr != operationThreads.end();
1191        ++itr)
1192    {
1193        threads.push_back(*itr);
1194    }
1195
1196
1197    if (_scene.valid())
1198    {
1199        osgDB::DatabasePager* dp = _scene->getDatabasePager();
1200        if (dp)
1201        {
1202            for(unsigned int i=0; i<dp->getNumDatabaseThreads(); ++i)
1203            {
1204                osgDB::DatabasePager::DatabaseThread* dt = dp->getDatabaseThread(i);
1205                if (!onlyActive || dt->isRunning())
1206                {
1207                    threads.push_back(dt);
1208                }
1209            }
1210        }
1211    }
1212}
1213
1214
1215void Viewer::getOperationThreads(OperationThreads& threads, bool onlyActive)
1216{
1217    threads.clear();
1218
1219    Contexts contexts;
1220    getContexts(contexts);
1221    for(Contexts::iterator gcitr = contexts.begin();
1222        gcitr != contexts.end();
1223        ++gcitr)
1224    {
1225        osg::GraphicsContext* gc = *gcitr;
1226        if (gc->getGraphicsThread() &&
1227            (!onlyActive || gc->getGraphicsThread()->isRunning()) )
1228        {
1229            threads.push_back(gc->getGraphicsThread());
1230        }
1231    }
1232
1233    Cameras cameras;
1234    getCameras(cameras);
1235    for(Cameras::iterator citr = cameras.begin();
1236        citr != cameras.end();
1237        ++citr)
1238    {
1239        osg::Camera* camera = *citr;
1240        if (camera->getCameraThread() &&
1241            (!onlyActive || camera->getCameraThread()->isRunning()) )
1242        {
1243            threads.push_back(camera->getCameraThread());
1244        }
1245    }
1246
1247}
1248
1249void Viewer::getContexts(Contexts& contexts, bool onlyValid)
1250{
1251    typedef std::set<osg::GraphicsContext*> ContextSet;
1252    ContextSet contextSet;
1253
1254    contexts.clear();
1255
1256    if (_camera.valid() &&
1257        _camera->getGraphicsContext() &&
1258        (_camera->getGraphicsContext()->valid() || !onlyValid))
1259    {
1260        contextSet.insert(_camera->getGraphicsContext());
1261        contexts.push_back(_camera->getGraphicsContext());
1262    }
1263
1264    for(unsigned int i=0; i<getNumSlaves(); ++i)
1265    {
1266        Slave& slave = getSlave(i);
1267        osg::GraphicsContext* sgc = slave._camera.valid() ? slave._camera->getGraphicsContext() : 0;
1268        if (sgc && (sgc->valid() || !onlyValid))
1269        {
1270            if (contextSet.count(sgc)==0)
1271            {
1272                contextSet.insert(sgc);
1273                contexts.push_back(sgc);
1274            }
1275        }
1276    }
1277}
1278
1279void Viewer::getCameras(Cameras& cameras, bool onlyActive)
1280{
1281    cameras.clear();
1282
1283    if (_camera.valid() &&
1284        (!onlyActive || (_camera->getGraphicsContext() && _camera->getGraphicsContext()->valid())) ) cameras.push_back(_camera.get());
1285
1286    for(Slaves::iterator itr = _slaves.begin();
1287        itr != _slaves.end();
1288        ++itr)
1289    {
1290        if (itr->_camera.valid() &&
1291            (!onlyActive || (itr->_camera->getGraphicsContext() && itr->_camera->getGraphicsContext()->valid())) ) cameras.push_back(itr->_camera.get());
1292    }
1293}
1294
1295
1296double Viewer::elapsedTime()
1297{
1298    return osg::Timer::instance()->delta_s(_startTick, osg::Timer::instance()->tick());
1299}
1300
1301
1302void Viewer::getUsage(osg::ApplicationUsage& usage) const
1303{
1304    if (_cameraManipulator.valid())
1305    {
1306        _cameraManipulator->getUsage(usage);
1307    }
1308
1309    for(EventHandlers::const_iterator hitr = _eventHandlers.begin();
1310        hitr != _eventHandlers.end();
1311        ++hitr)
1312    {
1313        (*hitr)->getUsage(usage);
1314    }
1315}
Note: See TracBrowser for help on using the browser.