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

Revision 13376, 44.6 kB (checked in by robert, 2 days ago)

Added shaders to support experimental shader based displacement mapping technique osgTerrain::ShaderTerrain?.

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