root/OpenSceneGraph/trunk/examples/osganalysis/osganalysis.cpp @ 13276

Revision 12697, 27.4 kB (checked in by robert, 3 years ago)

From Alberto Luacas, typo fixes

  • Property svn:eol-style set to native
Line 
1/* OpenSceneGraph example, osganalysis.
2*
3*  Permission is hereby granted, free of charge, to any person obtaining a copy
4*  of this software and associated documentation files (the "Software"), to deal
5*  in the Software without restriction, including without limitation the rights
6*  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
7*  copies of the Software, and to permit persons to whom the Software is
8*  furnished to do so, subject to the following conditions:
9*
10*  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
11*  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
12*  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
13*  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
14*  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
15*  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
16*  THE SOFTWARE.
17*/
18
19
20#include <osgViewer/Viewer>
21#include <osgViewer/ViewerEventHandlers>
22
23#include <osgDB/ReadFile>
24#include <osgDB/WriteFile>
25#include <osgDB/FileNameUtils>
26
27#include <osgGA/TrackballManipulator>
28#include <osgGA/StateSetManipulator>
29#include <osgGA/TrackballManipulator>
30#include <osgGA/FlightManipulator>
31#include <osgGA/DriveManipulator>
32#include <osgGA/KeySwitchMatrixManipulator>
33#include <osgGA/AnimationPathManipulator>
34#include <osgGA/TerrainManipulator>
35
36#include <osgUtil/IncrementalCompileOperation>
37#include <osgUtil/Simplifier>
38#include <osgUtil/MeshOptimizers>
39
40class StripStateVisitor : public osg::NodeVisitor
41{
42public:
43    StripStateVisitor(bool useStateSets, bool useDisplayLists, bool useVBO):
44        osg::NodeVisitor(osg::NodeVisitor::TRAVERSE_ALL_CHILDREN),
45        _useStateSets(useStateSets),
46        _useDisplayLists(useDisplayLists),
47        _useVBO(useVBO) {}
48
49    bool _useStateSets;
50    bool _useDisplayLists;
51    bool _useVBO;
52
53    void apply(osg::Node& node)
54    {
55        if (!_useStateSets && node.getStateSet()) node.setStateSet(0);
56        traverse(node);
57    }
58
59    void apply(osg::Geode& node)
60    {
61        if (!_useStateSets && node.getStateSet()) node.setStateSet(0);
62        for(unsigned int i = 0; i<node.getNumDrawables(); ++i)
63        {
64            process(*node.getDrawable(i));
65        }
66
67        traverse(node);
68    }
69
70    void process(osg::Drawable& drawable)
71    {
72        if (!_useStateSets && drawable.getStateSet())
73        {
74            drawable.setStateSet(0);
75        }
76
77        drawable.setUseDisplayList(_useDisplayLists);
78        drawable.setUseVertexBufferObjects(_useVBO);
79    }
80};
81
82class OptimizeImageVisitor : public osg::NodeVisitor
83{
84public:
85    OptimizeImageVisitor(osgDB::ImageProcessor* imageProcessor, bool compressImages, bool generateMipmaps):
86        osg::NodeVisitor(osg::NodeVisitor::TRAVERSE_ALL_CHILDREN),
87        _imageProcessor(imageProcessor),
88        _compressImages(compressImages),
89        _generateMipmaps(generateMipmaps) {}
90
91    osg::ref_ptr<osgDB::ImageProcessor> _imageProcessor;
92    bool _compressImages;
93    bool _generateMipmaps;
94
95    void apply(osg::Node& node)
96    {
97        processStateSet(node.getStateSet());
98        traverse(node);
99    }
100
101    void apply(osg::Geode& node)
102    {
103        processStateSet(node.getStateSet());
104        for(unsigned int i = 0; i<node.getNumDrawables(); ++i)
105        {
106            processStateSet(node.getDrawable(i)->getStateSet());
107        }
108
109        traverse(node);
110    }
111
112    void processStateSet(osg::StateSet* stateset)
113    {
114        if (!stateset) return;
115
116        for(unsigned int i=0; i<stateset->getNumTextureAttributeLists(); ++i)
117        {
118            osg::StateAttribute* sa = stateset->getTextureAttribute(i, osg::StateAttribute::TEXTURE);
119            osg::Texture* texture = dynamic_cast<osg::Texture*>(sa);
120            if (texture)
121            {
122                for(unsigned int i=0; i<texture->getNumImages(); ++i)
123                {
124                    proccessImage(texture->getImage(i));
125                }
126            }
127        };
128    }
129
130
131    void proccessImage(osg::Image* image)
132    {
133        if (!image) return;
134
135        if (_imageProcessor.valid())
136        {
137            OSG_NOTICE<<"Will be using ImageProcessor to process image "<<image->getFileName()<<std::endl;
138        }
139        else
140        {
141            OSG_NOTICE<<"No ImageProcessor to process image "<<image->getFileName()<<std::endl;
142        }
143            OSG_NOTICE<<"   compressImage "<<_compressImages<<std::endl;
144            OSG_NOTICE<<"   generateMipmaps "<<_generateMipmaps<<std::endl;
145    }
146
147};
148
149
150class SwapArrayVisitor : public osg::ArrayVisitor
151{
152public:
153    SwapArrayVisitor(osg::Array* array):
154        _array(array) {}
155
156    template <class ARRAY>
157    void apply_imp(ARRAY& array)
158    {
159        if (array.getType()!=_array->getType())
160        {
161            OSG_NOTICE<<"Arrays incompatible"<<std::endl;
162            return;
163        }
164        OSG_NOTICE<<"Swapping Array"<<std::endl;
165        array.swap(*static_cast<ARRAY*>(_array));
166    }
167
168    virtual void apply(osg::ByteArray& ba) { apply_imp(ba); }
169    virtual void apply(osg::ShortArray& ba) { apply_imp(ba); }
170    virtual void apply(osg::IntArray& ba) { apply_imp(ba); }
171    virtual void apply(osg::UByteArray& ba) { apply_imp(ba); }
172    virtual void apply(osg::UShortArray& ba) { apply_imp(ba); }
173    virtual void apply(osg::UIntArray& ba) { apply_imp(ba); }
174    virtual void apply(osg::Vec4ubArray& ba) { apply_imp(ba); }
175    virtual void apply(osg::FloatArray& ba) { apply_imp(ba); }
176    virtual void apply(osg::Vec2Array& ba) { apply_imp(ba); }
177    virtual void apply(osg::Vec3Array& ba) { apply_imp(ba); }
178    virtual void apply(osg::Vec4Array& ba) { apply_imp(ba); }
179
180    osg::Array* _array;
181};
182
183class MemoryVisitor : public osg::NodeVisitor
184{
185public:
186     MemoryVisitor():
187         osg::NodeVisitor(osg::NodeVisitor::TRAVERSE_ALL_CHILDREN) {}
188
189
190    void reset()
191    {
192         _nodes.clear();
193         _geometryMap.clear();
194         _arrayMap.clear();
195         _primitiveSetMap.clear();
196    }
197
198    void apply(osg::Node& node)
199    {
200        _nodes.insert(&node);
201        traverse(node);
202    }
203
204    void apply(osg::Geode& geode)
205    {
206        _nodes.insert(&geode);
207        for(unsigned int i=0; i<geode.getNumDrawables(); ++i)
208        {
209            apply(&geode, geode.getDrawable(i));
210        }
211    }
212
213    void apply(osg::Geode* geode, osg::Drawable* drawable)
214    {
215        if (!drawable) return;
216
217        osg::Geometry* geometry = drawable->asGeometry();
218        if (geometry)
219        {
220            _geometryMap[geometry].insert(geode);
221
222            apply(geometry, geometry->getVertexArray());
223            apply(geometry, geometry->getNormalArray());
224            apply(geometry, geometry->getColorArray());
225            apply(geometry, geometry->getSecondaryColorArray());
226            apply(geometry, geometry->getFogCoordArray());
227
228            for(unsigned int i=0; i<geometry->getNumTexCoordArrays(); ++i)
229            {
230                apply(geometry, geometry->getTexCoordArray(i));
231            }
232            for(unsigned int i=0; i<geometry->getNumVertexAttribArrays(); ++i)
233            {
234                apply(geometry, geometry->getVertexAttribArray(i));
235            }
236
237            for(unsigned int i=0; i<geometry->getNumPrimitiveSets(); ++i)
238            {
239                apply(geometry, geometry->getPrimitiveSet(i));
240            }
241        }
242    }
243
244    void apply(osg::Geometry* geometry, osg::Array* array)
245    {
246        if (!array) return;
247        _arrayMap[array].insert(geometry);
248    }
249
250    void apply(osg::Geometry* geometry, osg::PrimitiveSet* primitiveSet)
251    {
252        if (!primitiveSet) return;
253        _primitiveSetMap[primitiveSet].insert(geometry);
254    }
255
256    void report(std::ostream& out)
257    {
258        out<<"Nodes "<<_nodes.size()<<std::endl;
259        out<<"Geometries "<<_geometryMap.size()<<std::endl;
260        out<<"Arrays "<<_arrayMap.size()<<std::endl;
261        out<<"PrimitiveSets "<<_primitiveSetMap.size()<<std::endl;
262    }
263
264    void reallocate()
265    {
266        OSG_NOTICE<<"Reallocating Arrays"<<std::endl;
267
268        typedef std::vector< osg::ref_ptr<osg::Array> > ArrayVector;
269        typedef std::vector< osg::ref_ptr<osg::Geometry> > GeometryVector;
270        ArrayVector newArrays;
271        GeometryVector newGeometries;
272        for(GeometryMap::iterator itr = _geometryMap.begin();
273            itr != _geometryMap.end();
274            ++itr)
275        {
276            osg::Geometry* geometry = itr->first;
277            bool useVBO = geometry->getUseVertexBufferObjects();
278            osg::Geometry* newGeometry = osg::clone(geometry, osg::CopyOp(osg::CopyOp::DEEP_COPY_ALL));
279            newGeometry->setUseVertexBufferObjects(false);
280            newGeometry->setUseVertexBufferObjects(useVBO);
281            newGeometries.push_back(newGeometry);
282        }
283
284        GeometryVector::iterator geom_itr = newGeometries.begin();
285        for(GeometryMap::iterator itr = _geometryMap.begin();
286            itr != _geometryMap.end();
287            ++itr, ++geom_itr)
288        {
289            osg::Geometry* geometry = itr->first;
290            Geodes& geodes = itr->second;
291            for(Geodes::iterator gitr = geodes.begin();
292                gitr != geodes.end();
293                ++gitr)
294            {
295                osg::Geode* geode = const_cast<osg::Geode*>(*gitr);
296                geode->replaceDrawable(geometry, geom_itr->get());
297            }
298        }
299    }
300
301    typedef std::vector< osg::ref_ptr<osg::Geometry> > GeometryVector;
302    typedef std::pair<osg::Array*, osg::Array*> ArrayPair;
303    typedef std::vector< ArrayPair > ArrayVector;
304    typedef std::pair<osg::PrimitiveSet*, osg::PrimitiveSet*> PrimitiveSetPair;
305    typedef std::vector< PrimitiveSetPair > PrimitiveSetVector;
306
307    osg::Array* cloneArray(ArrayVector& arrayVector, osg::Array* array)
308    {
309        if (!array) return 0;
310        osg::Array* newArray = static_cast<osg::Array*>(array->cloneType());
311        arrayVector.push_back(ArrayPair(array,newArray));
312        return newArray;
313    }
314
315    osg::PrimitiveSet* clonePrimitiveSet(PrimitiveSetVector& psVector, osg::PrimitiveSet* ps)
316    {
317        if (!ps) return 0;
318        osg::PrimitiveSet* newPS = static_cast<osg::PrimitiveSet*>(ps->cloneType());
319        psVector.push_back(PrimitiveSetPair(ps,newPS));
320        return newPS;
321    }
322
323    void reallocate2()
324    {
325        OSG_NOTICE<<"Reallocating Arrays"<<std::endl;
326
327        ArrayVector arrayVector;
328        PrimitiveSetVector primitiveSetVector;
329        GeometryVector newGeometries;
330
331        for(GeometryMap::iterator itr = _geometryMap.begin();
332            itr != _geometryMap.end();
333            ++itr)
334        {
335            osg::Geometry* geometry = itr->first;
336            osg::ref_ptr<osg::Geometry> newGeometry = osg::clone(geometry, osg::CopyOp::SHALLOW_COPY);
337            newGeometries.push_back(newGeometry.get());
338
339            newGeometry->setVertexArray(cloneArray(arrayVector, geometry->getVertexArray()));
340            newGeometry->setNormalArray(cloneArray(arrayVector, geometry->getNormalArray()));
341            newGeometry->setColorArray(cloneArray(arrayVector, geometry->getColorArray()));
342            newGeometry->setSecondaryColorArray(cloneArray(arrayVector, geometry->getSecondaryColorArray()));
343            newGeometry->setFogCoordArray(cloneArray(arrayVector, geometry->getFogCoordArray()));
344            for(unsigned int i=0; i<geometry->getNumTexCoordArrays(); ++i)
345            {
346                newGeometry->setTexCoordArray(i, cloneArray(arrayVector, geometry->getTexCoordArray(i)));
347            }
348            for(unsigned int i=0; i<geometry->getNumVertexAttribArrays(); ++i)
349            {
350                newGeometry->setVertexAttribArray(i, cloneArray(arrayVector, geometry->getVertexAttribArray(i)));
351            }
352
353            for(unsigned int i=0; i<geometry->getNumPrimitiveSets(); ++i)
354            {
355                newGeometry->setPrimitiveSet(i,clonePrimitiveSet(primitiveSetVector, geometry->getPrimitiveSet(i)));
356            }
357        }
358
359        GeometryVector::iterator geom_itr = newGeometries.begin();
360        for(GeometryMap::iterator itr = _geometryMap.begin();
361            itr != _geometryMap.end();
362            ++itr, ++geom_itr)
363        {
364            osg::Geometry* geometry = itr->first;
365            Geodes& geodes = itr->second;
366            for(Geodes::iterator gitr = geodes.begin();
367                gitr != geodes.end();
368                ++gitr)
369            {
370                osg::Geode* geode = const_cast<osg::Geode*>(*gitr);
371                geode->replaceDrawable(geometry, geom_itr->get());
372            }
373        }
374    }
375
376protected:
377
378     typedef std::set<osg::Node*>  Nodes;
379     typedef std::set<osg::Geode*>  Geodes;
380     typedef std::set<osg::Geometry*>  Geometries;
381     typedef std::map<osg::Geometry*, Geodes> GeometryMap;
382     typedef std::map<osg::Array*, Geometries> ArrayMap;
383     typedef std::map<osg::PrimitiveSet*, Geometries> PrimitiveSetMap;
384
385     Nodes              _nodes;
386     GeometryMap        _geometryMap;
387     ArrayMap           _arrayMap;
388     PrimitiveSetMap    _primitiveSetMap;
389};
390
391class SceneGraphProcessor : public osg::Referenced
392{
393public:
394    SceneGraphProcessor()
395    {
396        _init();
397    }
398
399    SceneGraphProcessor(osg::ArgumentParser& arguments)
400    {
401        _init();
402
403        while (arguments.read("--vbo")) { modifyDrawableSettings = true; useVBO = true;  }
404        while (arguments.read("--dl")) { modifyDrawableSettings = true; useDisplayLists = true;  }
405
406        while (arguments.read("-s", simplificatioRatio)) {}
407        while (arguments.read("--tristripper")) { useTriStripVisitor=true; }
408        while (arguments.read("--no-tristripper")) { useTriStripVisitor=false; }
409        while (arguments.read("--smoother")) {  useSmoothingVisitor=true; }
410        while (arguments.read("--no-smoother")) {  useSmoothingVisitor=false; }
411
412        while (arguments.read("--remove-duplicate-vertices") || arguments.read("--rdv")) removeDuplicateVertices = true;
413        while (arguments.read("--optimize-vertex-cache") || arguments.read("--ovc")) optimizeVertexCache = true;
414        while (arguments.read("--optimize-vertex-order") || arguments.read("--ovo")) optimizeVertexOrder = true;
415
416        while (arguments.read("--build-mipmaps")) { modifyTextureSettings = true; buildImageMipmaps = true; }
417        while (arguments.read("--compress")) { modifyTextureSettings = true; compressImages = true; }
418        while (arguments.read("--disable-mipmaps")) { modifyTextureSettings = true; disableMipmaps = true; }
419
420        while (arguments.read("--reallocate") || arguments.read("--ra") ) { reallocateMemory = true; }
421
422        OSG_NOTICE<<"simplificatioRatio="<<simplificatioRatio<<std::endl;
423    }
424
425    virtual osg::Node* process(osg::Node* node)
426    {
427        if (!node)
428        {
429            OSG_NOTICE<<"SceneGraphProcessor::process(Node*) : error cannot process NULL Node."<<std::endl;
430            return 0;
431        }
432
433        OSG_NOTICE<<"SceneGraphProcessor::process("<<node<<") : "<<node->getName()<<std::endl;
434
435        if (simplificatioRatio < 1.0)
436        {
437            OSG_NOTICE<<"Running simplifier with simplification ratio="<<simplificatioRatio<<std::endl;
438            float maxError = 4.0f;
439            osgUtil::Simplifier simplifier(simplificatioRatio, maxError);
440            simplifier.setDoTriStrip(useTriStripVisitor);
441            simplifier.setSmoothing(useSmoothingVisitor);
442            node->accept(simplifier);
443        }
444
445
446        if (modifyTextureSettings)
447        {
448            OptimizeImageVisitor oiv(osgDB::Registry::instance()->getImageProcessor(), compressImages, buildImageMipmaps);
449            node->accept(oiv);
450        }
451
452
453        if (removeDuplicateVertices)
454        {
455            OSG_NOTICE<<"Running osgUtil::IndexMeshVisitor"<<std::endl;
456            osgUtil::IndexMeshVisitor imv;
457            node->accept(imv);
458            imv.makeMesh();
459        }
460
461        if (optimizeVertexCache)
462        {
463            OSG_NOTICE<<"Running osgUtil::VertexCacheVisitor"<<std::endl;
464            osgUtil::VertexCacheVisitor vcv;
465            node->accept(vcv);
466            vcv.optimizeVertices();
467        }
468
469        if (optimizeVertexOrder)
470        {
471            OSG_NOTICE<<"Running osgUtil::VertexAccessOrderVisitor"<<std::endl;
472            osgUtil::VertexAccessOrderVisitor vaov;
473            node->accept(vaov);
474            vaov.optimizeOrder();
475        }
476
477        if (modifyDrawableSettings)
478        {
479            OSG_NOTICE<<"Running StripStateVisitor"<<std::endl;
480            StripStateVisitor ssv(true, useDisplayLists, useVBO);
481            node->accept(ssv);
482        }
483
484        MemoryVisitor mv;
485        node->accept(mv);
486        mv.report(osg::notify(osg::NOTICE));
487
488        if (reallocateMemory)
489        {
490            OSG_NOTICE<<"Running Reallocation of scene graph memory"<<std::endl;
491            mv.reallocate();
492        }
493
494        mv.reset();
495        node->accept(mv);
496        mv.report(osg::notify(osg::NOTICE));
497
498        return node;
499    }
500
501protected:
502
503    void _init()
504    {
505        modifyDrawableSettings = false;
506        useVBO = false;
507        useDisplayLists = false;
508
509        simplificatioRatio = 1.0;
510        useTriStripVisitor = false;
511        useSmoothingVisitor = false;
512
513        removeDuplicateVertices = false;
514        optimizeVertexCache = false;
515        optimizeVertexOrder = false;
516
517        reallocateMemory = false;
518       
519        modifyTextureSettings = false;
520        buildImageMipmaps = false;
521        compressImages = false;
522        disableMipmaps = false;
523    }
524
525    bool modifyDrawableSettings;
526    bool useVBO;
527    bool useDisplayLists;
528
529    float simplificatioRatio;
530    bool useTriStripVisitor;
531    bool useSmoothingVisitor;
532
533    bool removeDuplicateVertices;
534    bool optimizeVertexCache;
535    bool optimizeVertexOrder;
536
537    bool reallocateMemory;
538   
539    bool modifyTextureSettings;
540    bool buildImageMipmaps;
541    bool compressImages;
542    bool disableMipmaps;
543
544};
545//
546class DatabasePagingOperation : public osg::Operation, public osgUtil::IncrementalCompileOperation::CompileCompletedCallback
547{
548public:
549
550    DatabasePagingOperation(const std::string& filename,
551                            const std::string& outputFilename,
552                             SceneGraphProcessor* sceneGraphProcessor,
553                             osgUtil::IncrementalCompileOperation* ico):
554        Operation("DatabasePaging Operation", false),
555        _filename(filename),
556        _outputFilename(outputFilename),
557        _modelReadyToMerge(false),
558        _sceneGraphProcessor(sceneGraphProcessor),
559        _incrementalCompileOperation(ico)
560        {
561        }
562
563    virtual void operator () (osg::Object* object)
564    {
565        osg::notify(osg::NOTICE)<<"LoadAndCompileOperation "<<_filename<<std::endl;
566
567        _modelReadyToMerge = false;
568        _loadedModel = osgDB::readNodeFile(_filename);
569
570        if (_loadedModel.valid())
571        {
572            if (_sceneGraphProcessor.valid())
573            {
574                _loadedModel = _sceneGraphProcessor->process(_loadedModel.get());
575            }
576        }
577
578        if (_loadedModel.valid())
579        {
580            if (!_outputFilename.empty())
581            {
582                OSG_NOTICE<<"Writing out file "<<_outputFilename<<std::endl;
583               
584                osgDB::writeNodeFile(*_loadedModel, _outputFilename);
585            }
586
587            if (_incrementalCompileOperation.valid())
588            {
589                OSG_NOTICE<<"Registering with ICO "<<_outputFilename<<std::endl;
590
591                osg::ref_ptr<osgUtil::IncrementalCompileOperation::CompileSet> compileSet =
592                    new osgUtil::IncrementalCompileOperation::CompileSet(_loadedModel.get());
593
594                compileSet->_compileCompletedCallback = this;
595
596                _incrementalCompileOperation->add(compileSet.get());
597            }
598            else
599            {
600                _modelReadyToMerge = true;
601            }
602        }
603
604        osg::notify(osg::NOTICE)<<"done LoadAndCompileOperation "<<_filename<<std::endl;
605    }
606
607    virtual bool compileCompleted(osgUtil::IncrementalCompileOperation::CompileSet* compileSet)
608    {
609        OSG_NOTICE<<"compileCompleted"<<std::endl;
610        _modelReadyToMerge = true;
611        return true;
612    }
613
614    std::string                                         _filename;
615    std::string                                         _outputFilename;
616    osg::ref_ptr<osg::Node>                             _loadedModel;
617    bool                                                _modelReadyToMerge;
618    osg::ref_ptr<SceneGraphProcessor>                   _sceneGraphProcessor;
619    osg::ref_ptr<osgUtil::IncrementalCompileOperation>  _incrementalCompileOperation;
620};
621
622class TexturePoolHandler : public osgGA::GUIEventHandler
623{
624public:
625    virtual bool handle(const osgGA::GUIEventAdapter& ea,osgGA::GUIActionAdapter& aa)
626    {
627        if (ea.getEventType() == osgGA::GUIEventAdapter::KEYUP)
628        {
629            if (ea.getKey()=='r')
630            {
631                osg::Texture::getTextureObjectManager(0)->reportStats(osg::notify(osg::NOTICE));
632                osg::GLBufferObjectManager::getGLBufferObjectManager(0)->reportStats(osg::notify(osg::NOTICE));
633            }
634        }
635        return false;
636    }
637};
638
639struct ReportStatsAnimationCompletedCallback : public osgGA::AnimationPathManipulator::AnimationCompletedCallback
640{
641    virtual void completed(const osgGA::AnimationPathManipulator*)
642    {
643        OSG_NOTICE<<"Animation completed"<<std::endl;
644        osg::Texture::getTextureObjectManager(0)->reportStats(osg::notify(osg::NOTICE));
645        osg::GLBufferObjectManager::getGLBufferObjectManager(0)->reportStats(osg::notify(osg::NOTICE));
646    }
647};
648
649int main(int argc, char** argv)
650{
651    osg::ArgumentParser arguments(&argc, argv);
652
653    // construct the viewer.
654    osgViewer::Viewer viewer(arguments);
655
656    // set up camera manipulators
657    {
658        osg::ref_ptr<osgGA::KeySwitchMatrixManipulator> keyswitchManipulator = new osgGA::KeySwitchMatrixManipulator;
659
660        keyswitchManipulator->addMatrixManipulator( '1', "Trackball", new osgGA::TrackballManipulator() );
661        keyswitchManipulator->addMatrixManipulator( '2', "Flight", new osgGA::FlightManipulator() );
662        keyswitchManipulator->addMatrixManipulator( '3', "Drive", new osgGA::DriveManipulator() );
663        keyswitchManipulator->addMatrixManipulator( '4', "Terrain", new osgGA::TerrainManipulator() );
664
665        char keyForAnimationPath = '8';
666        double animationSpeed = 1.0;
667        while(arguments.read("--speed",animationSpeed) ) {}
668
669        std::string pathfile;
670        while (arguments.read("-p",pathfile))
671        {
672            osgGA::AnimationPathManipulator* apm = new osgGA::AnimationPathManipulator(pathfile);
673            if (apm || !apm->valid())
674            {
675                apm->setTimeScale(animationSpeed);
676                apm->setAnimationCompletedCallback(new ReportStatsAnimationCompletedCallback());
677               
678                unsigned int num = keyswitchManipulator->getNumMatrixManipulators();
679                keyswitchManipulator->addMatrixManipulator( keyForAnimationPath, "Path", apm );
680                keyswitchManipulator->selectMatrixManipulator(num);
681                ++keyForAnimationPath;
682            }
683        }
684
685        viewer.setCameraManipulator( keyswitchManipulator.get() );
686    }
687
688    // set up event handlers
689    {
690        viewer.addEventHandler( new osgViewer::StatsHandler());
691        viewer.addEventHandler( new osgViewer::WindowSizeHandler() );
692        viewer.addEventHandler( new osgGA::StateSetManipulator(viewer.getCamera()->getOrCreateStateSet()) );
693        viewer.addEventHandler( new TexturePoolHandler() );
694    }
695
696    /////////////////////////////////////////////////////////////////////////////////
697    //
698    // IncrementalCompileOperation settings
699    //
700    osg::ref_ptr<osgUtil::IncrementalCompileOperation> incrementalCompile = new osgUtil::IncrementalCompileOperation;
701    viewer.setIncrementalCompileOperation(incrementalCompile.get());
702
703    if (arguments.read("--force") || arguments.read("-f"))
704    {
705        incrementalCompile->assignForceTextureDownloadGeometry();
706    }
707
708    if (arguments.read("-a"))
709    {
710        incrementalCompile->setMinimumTimeAvailableForGLCompileAndDeletePerFrame(1);
711        incrementalCompile->setConservativeTimeRatio(1);
712        incrementalCompile->setMaximumNumOfObjectsToCompilePerFrame(100);
713    }
714    else if (arguments.read("-c"))
715    {
716        incrementalCompile->setMinimumTimeAvailableForGLCompileAndDeletePerFrame(0.0001);
717        incrementalCompile->setConservativeTimeRatio(0.01);
718        incrementalCompile->setMaximumNumOfObjectsToCompilePerFrame(1);
719    }
720
721    /////////////////////////////////////////////////////////////////////////////////
722    //
723    // SceneGraph processing setup
724    //
725    osg::ref_ptr<SceneGraphProcessor> sceneGraphProcessor = new SceneGraphProcessor(arguments);
726
727    /////////////////////////////////////////////////////////////////////////////////
728    //
729    // Database settings
730    //
731    double timeBetweenMerges = 2.0;
732    while(arguments.read("--interval",timeBetweenMerges)) {}
733
734    std::string outputPostfix;
735    while (arguments.read("-o",outputPostfix)) { OSG_NOTICE<<"Set ouputPostfix to "<<outputPostfix<<std::endl; }
736
737
738    typedef std::vector< std::string > FileNames;
739    FileNames fileNames;
740    for(int pos=1;pos<arguments.argc();++pos)
741    {
742        if (!arguments.isOption(pos))
743        {
744            fileNames.push_back(arguments[pos]);
745        }
746    }
747
748    if (fileNames.empty())
749    {
750        OSG_NOTICE<<"No files loaded, please specify files on commandline."<<std::endl;
751        return 1;
752    }
753
754    // load the models using a paging thread and use the incremental compile operation to
755    // manage the compilation of GL objects without breaking frame.
756
757    unsigned int modelIndex = 0;
758
759    osg::ref_ptr<osg::OperationThread> databasePagingThread;
760    osg::ref_ptr<DatabasePagingOperation> databasePagingOperation;
761
762    databasePagingThread = new osg::OperationThread;
763    databasePagingThread->startThread();
764
765
766    osg::ref_ptr<osg::Group> group = new osg::Group;
767    viewer.setSceneData(group.get());
768
769    viewer.realize();
770
771    std::string filename = fileNames[modelIndex++];
772    std::string outputFilename = outputPostfix.empty() ? std::string() : osgDB::getStrippedName(filename)+outputPostfix;
773
774    databasePagingOperation = new DatabasePagingOperation(
775        filename,
776        outputFilename,
777        sceneGraphProcessor.get(),
778        incrementalCompile.get());
779
780    databasePagingThread->add(databasePagingOperation.get());
781
782
783    double timeOfLastMerge = viewer.getFrameStamp()->getReferenceTime();
784
785    while(!viewer.done())
786    {
787        viewer.frame();
788
789        double currentTime = viewer.getFrameStamp()->getReferenceTime();
790
791        if (!databasePagingOperation &&
792            modelIndex<fileNames.size() &&
793            (currentTime-timeOfLastMerge)>timeBetweenMerges)
794        {
795            std::string filename = fileNames[modelIndex++];
796            std::string outputFilename = outputPostfix.empty() ? std::string() : osgDB::getStrippedName(filename)+outputPostfix;
797
798            databasePagingOperation = new DatabasePagingOperation(
799                filename,
800                outputFilename,
801                sceneGraphProcessor.get(),
802                incrementalCompile.get());
803
804            databasePagingThread->add(databasePagingOperation.get());
805        }
806
807        if (databasePagingOperation.get() && databasePagingOperation->_modelReadyToMerge)
808        {
809            OSG_NOTICE<<"Merging subgraph"<<std::endl;
810           
811            timeOfLastMerge = currentTime;
812
813            group->removeChildren(0,group->getNumChildren());
814
815            group->addChild(databasePagingOperation->_loadedModel.get());
816
817            viewer.home();
818
819            // we no longer need the paging operation as it's done it's job.
820            databasePagingOperation = 0;
821
822            viewer.home();
823        }
824    }
825
826    return 0;
827}
Note: See TracBrowser for help on using the browser.