This file is indexed.

/usr/include/osgViewer/ViewerBase is in libopenscenegraph-dev 3.2.0~rc1-4.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield
 *
 * This library is open source and may be redistributed and/or modified under
 * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
 * (at your option) any later version.  The full license is in LICENSE file
 * included with this distribution, and on the openscenegraph.org website.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * OpenSceneGraph Public License for more details.
*/

#ifndef OSGVIEWER_VIEWERBASE
#define OSGVIEWER_VIEWERBASE 1

#include <osg/Stats>

#include <osgUtil/UpdateVisitor>
#include <osgUtil/IncrementalCompileOperation>

#include <osgGA/EventVisitor>
#include <osgGA/EventQueue>

#include <osgViewer/Scene>
#include <osgViewer/GraphicsWindow>

namespace osgViewer {

#define USE_REFERENCE_TIME DBL_MAX

class View;

/** ViewerBase is the view base class that is inherited by both Viewer and CompositeViewer.*/
class OSGVIEWER_EXPORT ViewerBase : public virtual osg::Object
{
    public:

        ViewerBase();
        ViewerBase(const ViewerBase& vb);


        /** Set the Stats object used for collect various frame related timing and scene graph stats.*/
        virtual void setViewerStats(osg::Stats* stats) = 0;

        /** Get the Viewers Stats object.*/
        virtual osg::Stats* getViewerStats() = 0;

        /** Get the Viewers Stats object.*/
        virtual const osg::Stats* getViewerStats() const = 0;


         /** read the viewer configuration from a configuration file.*/
        virtual bool readConfiguration(const std::string& filename) = 0;

        /** Get whether at least of one of this viewers windows are realized.*/
        virtual bool isRealized() const = 0;

        /** set up windows and associated threads.*/
        virtual void realize() = 0;

        enum ThreadingModel
        {
            SingleThreaded,
            CullDrawThreadPerContext,
            ThreadPerContext = CullDrawThreadPerContext,
            DrawThreadPerContext,
            CullThreadPerCameraDrawThreadPerContext,
            ThreadPerCamera = CullThreadPerCameraDrawThreadPerContext,
            AutomaticSelection
        };

        /** Set the threading model the rendering traversals will use.*/
        virtual void setThreadingModel(ThreadingModel threadingModel);

        /** Get the threading model the rendering traversals will use.*/
        ThreadingModel getThreadingModel() const { return _threadingModel; }

        /** Let the viewer suggest the best threading model for the viewers camera/window setup and the hardware available.*/
        virtual ThreadingModel suggestBestThreadingModel();

        /** Set up the threading and processor affinity as per the viewers threading model.*/
        virtual void setUpThreading();

        /** Return true if viewer threads are running. */
        bool areThreadsRunning() const { return _threadsRunning; }

        /** Stop any threads begin run by viewer.*/
        virtual void stopThreading();

        /** Start any threads required by the viewer.*/
        virtual void startThreading();

        enum BarrierPosition
        {
            BeforeSwapBuffers,
            AfterSwapBuffers
        };

         /** Set the position of the end barrier.
          * AfterSwapBuffers may result in slightly higher framerates, but may
          * lead to inconsistent swapping between different windows.
          * BeforeSwapBuffers may lead to slightly lower framerate, but improve consistency in timing of swap buffers,
          * especially important if you are likely to consistently break frame.*/
        void setEndBarrierPosition(BarrierPosition bp);

        /** Get the end barrier position.*/
        BarrierPosition getEndBarrierPosition() const { return _endBarrierPosition; }

        /** Set the end barrier operation. \c op may be one of GL_FLUSH, GL_FINISH,
         * or NO_OPERATION. NO_OPERATION is the default. Per BarrierOperation::operator()(),
         * a glFlush() command, glFinish() command, or no additional OpenGL command will be
         * issued before entering the end barrier. */
        void setEndBarrierOperation(osg::BarrierOperation::PreBlockOp op);

        /** Get the end barrier operation. */
        osg::BarrierOperation::PreBlockOp getEndBarrierOperation() const { return _endBarrierOperation; }


        /** Set the done flag to signal the viewer's work is done and should exit the frame loop.*/
        void setDone(bool done) { _done = done; }

        /** Return true if  viewer's work is done and should exit the frame loop.*/
        bool done() const { return _done; }

        /** Set the EventVisitor. */
        void setEventVisitor(osgGA::EventVisitor* eventVisitor) { _eventVisitor = eventVisitor; }

        /** Get the EventVisitor. */
        osgGA::EventVisitor* getEventVisitor() { return _eventVisitor.get(); }

        /** Get the const EventVisitor. */
        const osgGA::EventVisitor* getEventVisitor() const { return _eventVisitor.get(); }

        /** Set the key event that the viewer checks on each frame to see if the viewer's done flag should be set to
          * signal end of viewers main loop.
          * Default value is Escape (osgGA::GUIEVentAdapter::KEY_Escape).
          * Setting to 0 switches off the feature.*/
        void setKeyEventSetsDone(int key) { _keyEventSetsDone = key; }

        /** get the key event that the viewer checks on each frame to see if the viewer's done flag.*/
        int getKeyEventSetsDone() const { return _keyEventSetsDone; }

        /** if the flag is true, the viewer set its done flag when a QUIT_APPLICATION is received, false disables this feature */
        void setQuitEventSetsDone(bool flag) { _quitEventSetsDone = flag; }

        /** @return true if the viewer respond to the QUIT_APPLICATION-event */
        bool getQuitEventSetsDone() const { return _quitEventSetsDone; }


        /** Hint to tell the renderingTraversals() method whether to call relaseContext() on the last
          * context that was made current by the thread calling renderingTraverals().  Note, when
          * running multi-threaded viewer no threads will be made current or release current.
          * Setting this hint to false can enable the frame loop to be lazy about calling makeCurrent
          * and releaseContext on each new frame, helping performance.  However, if you frame loop
          * is managing multiple graphics context all from the main frame thread then this hint must
          * be left on, otherwise the wrong context could be left active, introducing errors in rendering.*/
        void setReleaseContextAtEndOfFrameHint(bool hint) { _releaseContextAtEndOfFrameHint = hint; }

        /** Hint to tell the renderingTraversals() method whether to call relaseContext().*/
        bool getReleaseContextAtEndOfFrameHint() const { return _releaseContextAtEndOfFrameHint; }


        /** Set the UpdateVisitor. */
        void setUpdateVisitor(osgUtil::UpdateVisitor* updateVisitor) { _updateVisitor = updateVisitor; }

        /** Get the UpdateVisitor. */
        osgUtil::UpdateVisitor* getUpdateVisitor() { return _updateVisitor.get(); }

        /** Get the const UpdateVisitor. */
        const osgUtil::UpdateVisitor* getUpdateVisitor() const { return _updateVisitor.get(); }


        /** Set the Update OperationQueue. */
        void setUpdateOperations(osg::OperationQueue* operations) { _updateOperations = operations; }

        /** Get the Update OperationQueue. */
        osg::OperationQueue* getUpdateOperations() { return _updateOperations.get(); }

        /** Get the const Update OperationQueue. */
        const osg::OperationQueue* getUpdateOperations() const { return _updateOperations.get(); }

        /** Add an update operation.*/
        void addUpdateOperation(osg::Operation* operation);

        /** Remove an update operation.*/
        void removeUpdateOperation(osg::Operation* operation);


        /** Set the graphics operation to call on realization of the viewers graphics windows.*/
        void setRealizeOperation(osg::Operation* op) { _realizeOperation = op; }

        /** Get the graphics operation to call on realization of the viewers graphics windows.*/
        osg::Operation* getRealizeOperation() { return _realizeOperation.get(); }


        /** Set the incremental compile operation.
          * Used to manage the OpenGL object compilation and merging of subgraphs in a way that avoids overloading
          * the rendering of frame with too many new objects in one frame. */
        void setIncrementalCompileOperation(osgUtil::IncrementalCompileOperation* ico);

        /** Get the incremental compile operation. */
        osgUtil::IncrementalCompileOperation* getIncrementalCompileOperation() { return _incrementalCompileOperation.get(); }


        enum FrameScheme
        {
            ON_DEMAND,
            CONTINUOUS
        };

        void setRunFrameScheme(FrameScheme fs) { _runFrameScheme = fs; }
        FrameScheme getRunFrameScheme() const { return _runFrameScheme; }

        void setRunMaxFrameRate(double frameRate) { _runMaxFrameRate = frameRate; }
        double getRunMaxFrameRate() const { return _runMaxFrameRate; }

        /** Execute a main frame loop.
          * Equivalent to while (!viewer.done()) viewer.frame();
          * Also calls realize() if the viewer is not already realized,
          * and installs trackball manipulator if one is not already assigned.
          */
        virtual int run();

        /** check to see if the new frame is required, called by run(..) when FrameScheme is set to ON_DEMAND.*/
        virtual bool checkNeedToDoFrame() = 0;
        
        /** check to see if events have been received, return true if events are now available.*/
        virtual bool checkEvents() = 0;

        /** Render a complete new frame.
          * Calls advance(), eventTraversal(), updateTraversal(), renderingTraversals(). */
        virtual void frame(double simulationTime=USE_REFERENCE_TIME);

        virtual void advance(double simulationTime=USE_REFERENCE_TIME) = 0;

        virtual void eventTraversal() = 0;

        virtual void updateTraversal() = 0;

        virtual void renderingTraversals();

        typedef std::vector<osg::Camera*> Cameras;
        virtual void getCameras(Cameras& cameras, bool onlyActive=true) = 0;

        typedef std::vector<osg::GraphicsContext*> Contexts;
        virtual void getContexts(Contexts& contexts, bool onlyValid=true) = 0;

        typedef std::vector<osgViewer::GraphicsWindow*> Windows;
        virtual void getWindows(Windows& windows, bool onlyValid=true);

        typedef std::vector<OpenThreads::Thread*> Threads;
        virtual void getAllThreads(Threads& threads, bool onlyActive=true) = 0;

        typedef std::vector<osg::OperationThread*> OperationThreads;
        virtual void getOperationThreads(OperationThreads& threads, bool onlyActive=true) = 0;

        typedef std::vector<osgViewer::Scene*> Scenes;
        virtual void getScenes(Scenes& scenes, bool onlyValid=true) = 0;

        typedef std::vector<osgViewer::View*> Views;
        virtual void getViews(Views& views, bool onlyValid=true) = 0;

        /** Check to see if any windows are still open. If not, set viewer done to true. */
        void checkWindowStatus();

        /** Check to see if windows are still open using the list of contexts given as a parameter.
         *  If no windows are open, stop rendering threads and set viewer done to true.
         *  This function is more effective than checkWindowStatus() as it does not query
         *  the context list and should be used whenever context list is already available in your code.*/
        void checkWindowStatus(const Contexts& contexts);

        virtual double elapsedTime() = 0;

        virtual osg::FrameStamp* getViewerFrameStamp() = 0;

        /** Get the keyboard and mouse usage of this viewer.*/
        virtual void getUsage(osg::ApplicationUsage& usage) const = 0;

    protected:

        void viewerBaseInit();

        friend class osgViewer::View;

        inline void makeCurrent(osg::GraphicsContext* gc)
        {
            if (_currentContext==gc) return;

            releaseContext();

            if (gc && gc->valid() && gc->makeCurrent()) _currentContext = gc;
        }

        inline void releaseContext()
        {
            if (_currentContext.valid() && _currentContext->valid())
            {
                _currentContext->releaseContext();
            }
            _currentContext = 0;
        }

        virtual void viewerInit() = 0;

        bool                                                _firstFrame;
        bool                                                _done;
        int                                                 _keyEventSetsDone;
        bool                                                _quitEventSetsDone;
        bool                                                _releaseContextAtEndOfFrameHint;

        ThreadingModel                                      _threadingModel;
        bool                                                _threadsRunning;

        bool                                                _requestRedraw;
        bool                                                _requestContinousUpdate;

        FrameScheme                                         _runFrameScheme;
        double                                              _runMaxFrameRate;


        BarrierPosition                                     _endBarrierPosition;
        osg::BarrierOperation::PreBlockOp                   _endBarrierOperation;

        osg::ref_ptr<osg::BarrierOperation>                 _startRenderingBarrier;
        osg::ref_ptr<osg::BarrierOperation>                 _endRenderingDispatchBarrier;
        osg::ref_ptr<osg::EndOfDynamicDrawBlock>            _endDynamicDrawBlock;

        osg::ref_ptr<osgGA::EventVisitor>                   _eventVisitor;

        osg::ref_ptr<osg::OperationQueue>                   _updateOperations;
        osg::ref_ptr<osgUtil::UpdateVisitor>                _updateVisitor;

        osg::ref_ptr<osg::Operation>                        _realizeOperation;
        osg::ref_ptr<osgUtil::IncrementalCompileOperation>  _incrementalCompileOperation;

        osg::observer_ptr<osg::GraphicsContext>             _currentContext;
};

}

#endif