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

Revision 11864, 22.2 kB (checked in by robert, 3 years ago)
Line 
1/* OpenSceneGraph example, osgterrain.
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
26#include <osgGA/TrackballManipulator>
27#include <osgGA/StateSetManipulator>
28
29#include <osgUtil/IncrementalCompileOperation>
30#include <osgUtil/Simplifier>
31#include <osgUtil/MeshOptimizers>
32
33class StripStateVisitor : public osg::NodeVisitor
34{
35public:
36    StripStateVisitor(bool useStateSets, bool useDisplayLists, bool useVBO):
37        osg::NodeVisitor(osg::NodeVisitor::TRAVERSE_ALL_CHILDREN),
38        _useStateSets(useStateSets),
39        _useDisplayLists(useDisplayLists),
40        _useVBO(useVBO) {}
41
42    bool _useStateSets;
43    bool _useDisplayLists;
44    bool _useVBO;
45
46    void apply(osg::Node& node)
47    {
48        if (!_useStateSets && node.getStateSet()) node.setStateSet(0);
49        traverse(node);
50    }
51
52    void apply(osg::Geode& node)
53    {
54        if (!_useStateSets && node.getStateSet()) node.setStateSet(0);
55        for(unsigned int i = 0; i<node.getNumDrawables(); ++i)
56        {
57            process(*node.getDrawable(i));
58        }
59
60        traverse(node);
61    }
62
63    void process(osg::Drawable& drawable)
64    {
65        if (!_useStateSets && drawable.getStateSet())
66        {
67            drawable.setStateSet(0);
68        }
69
70        drawable.setUseDisplayList(_useDisplayLists);
71        drawable.setUseVertexBufferObjects(_useVBO);
72    }
73};
74
75class SwapArrayVisitor : public osg::ArrayVisitor
76{
77public:
78    SwapArrayVisitor(osg::Array* array):
79        _array(array) {}
80
81    template <class ARRAY>
82    void apply_imp(ARRAY& array)
83    {
84        if (array.getType()!=_array->getType())
85        {
86            OSG_NOTICE<<"Arrays incompatible"<<std::endl;
87            return;
88        }
89        OSG_NOTICE<<"Swapping Array"<<std::endl;
90        array.swap(*static_cast<ARRAY*>(_array));
91    }
92
93    virtual void apply(osg::ByteArray& ba) { apply_imp(ba); }
94    virtual void apply(osg::ShortArray& ba) { apply_imp(ba); }
95    virtual void apply(osg::IntArray& ba) { apply_imp(ba); }
96    virtual void apply(osg::UByteArray& ba) { apply_imp(ba); }
97    virtual void apply(osg::UShortArray& ba) { apply_imp(ba); }
98    virtual void apply(osg::UIntArray& ba) { apply_imp(ba); }
99    virtual void apply(osg::Vec4ubArray& ba) { apply_imp(ba); }
100    virtual void apply(osg::FloatArray& ba) { apply_imp(ba); }
101    virtual void apply(osg::Vec2Array& ba) { apply_imp(ba); }
102    virtual void apply(osg::Vec3Array& ba) { apply_imp(ba); }
103    virtual void apply(osg::Vec4Array& ba) { apply_imp(ba); }
104
105    osg::Array* _array;
106};
107
108class MemoryVisitor : public osg::NodeVisitor
109{
110public:
111     MemoryVisitor():
112         osg::NodeVisitor(osg::NodeVisitor::TRAVERSE_ALL_CHILDREN) {}
113
114
115    void reset()
116    {
117         _nodes.clear();
118         _geometryMap.clear();
119         _arrayMap.clear();
120         _primitiveSetMap.clear();
121    }
122
123    void apply(osg::Node& node)
124    {
125        _nodes.insert(&node);
126        traverse(node);
127    }
128
129    void apply(osg::Geode& geode)
130    {
131        _nodes.insert(&geode);
132        for(unsigned int i=0; i<geode.getNumDrawables(); ++i)
133        {
134            apply(&geode, geode.getDrawable(i));
135        }
136    }
137
138    void apply(osg::Geode* geode, osg::Drawable* drawable)
139    {
140        if (!drawable) return;
141
142        osg::Geometry* geometry = drawable->asGeometry();
143        if (geometry)
144        {
145            _geometryMap[geometry].insert(geode);
146
147            apply(geometry, geometry->getVertexArray());
148            apply(geometry, geometry->getNormalArray());
149            apply(geometry, geometry->getColorArray());
150            apply(geometry, geometry->getSecondaryColorArray());
151            apply(geometry, geometry->getFogCoordArray());
152
153            for(unsigned int i=0; i<geometry->getNumTexCoordArrays(); ++i)
154            {
155                apply(geometry, geometry->getTexCoordArray(i));
156            }
157            for(unsigned int i=0; i<geometry->getNumVertexAttribArrays(); ++i)
158            {
159                apply(geometry, geometry->getVertexAttribArray(i));
160            }
161
162            for(unsigned int i=0; i<geometry->getNumPrimitiveSets(); ++i)
163            {
164                apply(geometry, geometry->getPrimitiveSet(i));
165            }
166        }
167    }
168
169    void apply(osg::Geometry* geometry, osg::Array* array)
170    {
171        if (!array) return;
172        _arrayMap[array].insert(geometry);
173    }
174
175    void apply(osg::Geometry* geometry, osg::PrimitiveSet* primitiveSet)
176    {
177        if (!primitiveSet) return;
178        _primitiveSetMap[primitiveSet].insert(geometry);
179    }
180
181    void report(std::ostream& out)
182    {
183        OSG_NOTICE<<"Nodes "<<_nodes.size()<<std::endl;
184        OSG_NOTICE<<"Geometries "<<_geometryMap.size()<<std::endl;
185        OSG_NOTICE<<"Arrays "<<_arrayMap.size()<<std::endl;
186        OSG_NOTICE<<"PrimitiveSets "<<_primitiveSetMap.size()<<std::endl;
187    }
188
189    void reallocate()
190    {
191        OSG_NOTICE<<"Reallocating Arrays"<<std::endl;
192
193        typedef std::vector< osg::ref_ptr<osg::Array> > ArrayVector;
194        typedef std::vector< osg::ref_ptr<osg::Geometry> > GeometryVector;
195        ArrayVector newArrays;
196        GeometryVector newGeometries;
197        for(GeometryMap::iterator itr = _geometryMap.begin();
198            itr != _geometryMap.end();
199            ++itr)
200        {
201            osg::Geometry* geometry = itr->first;
202            bool useVBO = geometry->getUseVertexBufferObjects();
203            osg::Geometry* newGeometry = osg::clone(geometry, osg::CopyOp(osg::CopyOp::DEEP_COPY_ALL));
204            newGeometry->setUseVertexBufferObjects(false);
205            newGeometry->setUseVertexBufferObjects(useVBO);
206            newGeometries.push_back(newGeometry);
207        }
208
209        GeometryVector::iterator geom_itr = newGeometries.begin();
210        for(GeometryMap::iterator itr = _geometryMap.begin();
211            itr != _geometryMap.end();
212            ++itr, ++geom_itr)
213        {
214            osg::Geometry* geometry = itr->first;
215            Geodes& geodes = itr->second;
216            for(Geodes::iterator gitr = geodes.begin();
217                gitr != geodes.end();
218                ++gitr)
219            {
220                osg::Geode* geode = const_cast<osg::Geode*>(*gitr);
221                geode->replaceDrawable(geometry, geom_itr->get());
222            }
223        }
224    }
225
226    typedef std::vector< osg::ref_ptr<osg::Geometry> > GeometryVector;
227    typedef std::pair<osg::Array*, osg::Array*> ArrayPair;
228    typedef std::vector< ArrayPair > ArrayVector;
229    typedef std::pair<osg::PrimitiveSet*, osg::PrimitiveSet*> PrimitiveSetPair;
230    typedef std::vector< PrimitiveSetPair > PrimitiveSetVector;
231
232    osg::Array* cloneArray(ArrayVector& arrayVector, osg::Array* array)
233    {
234        if (!array) return 0;
235        osg::Array* newArray = static_cast<osg::Array*>(array->cloneType());
236        arrayVector.push_back(ArrayPair(array,newArray));
237        return newArray;
238    }
239
240    osg::PrimitiveSet* clonePrimitiveSet(PrimitiveSetVector& psVector, osg::PrimitiveSet* ps)
241    {
242        if (!ps) return 0;
243        osg::PrimitiveSet* newPS = static_cast<osg::PrimitiveSet*>(ps->cloneType());
244        psVector.push_back(PrimitiveSetPair(ps,newPS));
245        return newPS;
246    }
247
248    void reallocate2()
249    {
250        OSG_NOTICE<<"Reallocating Arrays"<<std::endl;
251
252        ArrayVector arrayVector;
253        PrimitiveSetVector primitiveSetVector;
254        GeometryVector newGeometries;
255
256        for(GeometryMap::iterator itr = _geometryMap.begin();
257            itr != _geometryMap.end();
258            ++itr)
259        {
260            osg::Geometry* geometry = itr->first;
261            osg::ref_ptr<osg::Geometry> newGeometry = osg::clone(geometry, osg::CopyOp::SHALLOW_COPY);
262            newGeometries.push_back(newGeometry.get());
263
264            newGeometry->setVertexArray(cloneArray(arrayVector, geometry->getVertexArray()));
265            newGeometry->setNormalArray(cloneArray(arrayVector, geometry->getNormalArray()));
266            newGeometry->setColorArray(cloneArray(arrayVector, geometry->getColorArray()));
267            newGeometry->setSecondaryColorArray(cloneArray(arrayVector, geometry->getSecondaryColorArray()));
268            newGeometry->setFogCoordArray(cloneArray(arrayVector, geometry->getFogCoordArray()));
269            for(unsigned int i=0; i<geometry->getNumTexCoordArrays(); ++i)
270            {
271                newGeometry->setTexCoordArray(i, cloneArray(arrayVector, geometry->getTexCoordArray(i)));
272            }
273            for(unsigned int i=0; i<geometry->getNumVertexAttribArrays(); ++i)
274            {
275                newGeometry->setVertexAttribArray(i, cloneArray(arrayVector, geometry->getVertexAttribArray(i)));
276            }
277
278            for(unsigned int i=0; i<geometry->getNumPrimitiveSets(); ++i)
279            {
280                newGeometry->setPrimitiveSet(i,clonePrimitiveSet(primitiveSetVector, geometry->getPrimitiveSet(i)));
281            }
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
301protected:
302
303     typedef std::set<osg::Node*>  Nodes;
304     typedef std::set<osg::Geode*>  Geodes;
305     typedef std::set<osg::Geometry*>  Geometries;
306     typedef std::map<osg::Geometry*, Geodes> GeometryMap;
307     typedef std::map<osg::Array*, Geometries> ArrayMap;
308     typedef std::map<osg::PrimitiveSet*, Geometries> PrimitiveSetMap;
309
310     Nodes              _nodes;
311     GeometryMap        _geometryMap;
312     ArrayMap           _arrayMap;
313     PrimitiveSetMap    _primitiveSetMap;
314};
315
316class SceneGraphProcessor : public osg::Referenced
317{
318public:
319    SceneGraphProcessor()
320    {
321        _init();
322    }
323
324    SceneGraphProcessor(osg::ArgumentParser& arguments)
325    {
326        _init();
327
328        while (arguments.read("--vbo")) { modifyDrawableSettings = true; useVBO = true;  }
329        while (arguments.read("--dl")) { modifyDrawableSettings = true; useDisplayLists = true;  }
330
331        while (arguments.read("-s", simplificatioRatio)) {}
332        while (arguments.read("--tristripper")) { useTriStripVisitor=true; }
333        while (arguments.read("--no-tristripper")) { useTriStripVisitor=false; }
334        while (arguments.read("--smoother")) {  useSmoothingVisitor=true; }
335        while (arguments.read("--no-smoother")) {  useSmoothingVisitor=false; }
336
337        while (arguments.read("--remove-duplicate-vertices") || arguments.read("--rdv")) removeDuplicateVertices = true;
338        while (arguments.read("--optimize-vertex-cache") || arguments.read("--ovc")) optimizeVertexCache = true;
339        while (arguments.read("--optimize-vertex-order") || arguments.read("--ovo")) optimizeVertexOrder = true;
340
341        while (arguments.read("--build-mipmaps")) { modifyTextureSettings = true; buildImageMipmaps = true; }
342        while (arguments.read("--compress")) { modifyTextureSettings = true; compressImages = true; }
343        while (arguments.read("--disable-mipmaps")) { modifyTextureSettings = true; disableMipmaps = true; }
344
345        while (arguments.read("--reallocate") || arguments.read("--ra") ) { reallocateMemory = true; }
346
347
348        OSG_NOTICE<<"simplificatioRatio="<<simplificatioRatio<<std::endl;
349    }
350
351    virtual osg::Node* process(osg::Node* node)
352    {
353        if (!node)
354        {
355            OSG_NOTICE<<"SceneGraphProcessor::process(Node*) : error cannot process NULL Node."<<std::endl;
356            return 0;
357        }
358
359        OSG_NOTICE<<"SceneGraphProcessor::process("<<node<<") : "<<node->getName()<<std::endl;
360
361        if (simplificatioRatio < 1.0)
362        {
363            OSG_NOTICE<<"Running simplifier with simplification ratio="<<simplificatioRatio<<std::endl;
364            float maxError = 4.0f;
365            osgUtil::Simplifier simplifier(simplificatioRatio, maxError);
366            simplifier.setDoTriStrip(useTriStripVisitor);
367            simplifier.setSmoothing(useSmoothingVisitor);
368            node->accept(simplifier);
369        }
370
371        if (removeDuplicateVertices)
372        {
373            OSG_NOTICE<<"Running osgUtil::IndexMeshVisitor"<<std::endl;
374            osgUtil::IndexMeshVisitor imv;
375            node->accept(imv);
376            imv.makeMesh();
377        }
378
379        if (optimizeVertexCache)
380        {
381            OSG_NOTICE<<"Running osgUtil::VertexCacheVisitor"<<std::endl;
382            osgUtil::VertexCacheVisitor vcv;
383            node->accept(vcv);
384            vcv.optimizeVertices();
385        }
386
387        if (optimizeVertexOrder)
388        {
389            OSG_NOTICE<<"Running osgUtil::VertexAccessOrderVisitor"<<std::endl;
390            osgUtil::VertexAccessOrderVisitor vaov;
391            node->accept(vaov);
392            vaov.optimizeOrder();
393        }
394
395        if (modifyDrawableSettings || modifyTextureSettings)
396        {
397            OSG_NOTICE<<"Running StripStateVisitor"<<std::endl;
398            StripStateVisitor ssv(true, useDisplayLists, useVBO);
399            node->accept(ssv);
400        }
401
402        MemoryVisitor mv;
403        node->accept(mv);
404        mv.report(osg::notify(osg::NOTICE));
405
406        if (reallocateMemory)
407        {
408            OSG_NOTICE<<"Running Reallocation of scene graph memory"<<std::endl;
409            mv.reallocate();
410        }
411
412        mv.reset();
413        node->accept(mv);
414        mv.report(osg::notify(osg::NOTICE));
415
416        return node;
417    }
418
419protected:
420
421    void _init()
422    {
423        modifyDrawableSettings = false;
424        useVBO = false;
425        useDisplayLists = false;
426
427        simplificatioRatio = 1.0;
428        useTriStripVisitor = false;
429        useSmoothingVisitor = false;
430
431        removeDuplicateVertices = false;
432        optimizeVertexCache = false;
433        optimizeVertexOrder = false;
434
435        reallocateMemory = false;
436       
437        modifyTextureSettings = false;
438        buildImageMipmaps = false;
439        compressImages = false;
440        disableMipmaps = false;
441    }
442
443    bool modifyDrawableSettings;
444    bool useVBO;
445    bool useDisplayLists;
446
447    float simplificatioRatio;
448    bool useTriStripVisitor;
449    bool useSmoothingVisitor;
450
451    bool removeDuplicateVertices;
452    bool optimizeVertexCache;
453    bool optimizeVertexOrder;
454
455    bool reallocateMemory;
456   
457    bool modifyTextureSettings;
458    bool buildImageMipmaps;
459    bool compressImages;
460    bool disableMipmaps;
461
462};
463
464class DatabasePagingOperation : public osg::Operation, public osgUtil::IncrementalCompileOperation::CompileCompletedCallback
465{
466public:
467
468    DatabasePagingOperation(const std::string& filename,
469                            const std::string& outputFilename,
470                             SceneGraphProcessor* sceneGraphProcessor,
471                             osgUtil::IncrementalCompileOperation* ico):
472        Operation("DatabasePaging Operation", false),
473        _filename(filename),
474        _outputFilename(outputFilename),
475        _modelReadyToMerge(false),
476        _sceneGraphProcessor(sceneGraphProcessor),
477        _incrementalCompileOperation(ico) {}
478
479    virtual void operator () (osg::Object* object)
480    {
481        osg::notify(osg::NOTICE)<<"LoadAndCompileOperation "<<_filename<<std::endl;
482
483        _modelReadyToMerge = false;
484        _loadedModel = osgDB::readNodeFile(_filename);
485
486        if (_loadedModel.valid())
487        {
488            if (_sceneGraphProcessor.valid())
489            {
490                _loadedModel = _sceneGraphProcessor->process(_loadedModel.get());
491            }
492        }
493
494        if (_loadedModel.valid())
495        {
496            if (!_outputFilename.empty())
497            {
498                osgDB::writeNodeFile(*_loadedModel, _outputFilename);
499            }
500
501            if (_incrementalCompileOperation.valid())
502            {
503                osg::ref_ptr<osgUtil::IncrementalCompileOperation::CompileSet> compileSet =
504                    new osgUtil::IncrementalCompileOperation::CompileSet(_loadedModel.get());
505
506                compileSet->_compileCompletedCallback = this;
507
508                _incrementalCompileOperation->add(compileSet.get());
509            }
510            else
511            {
512                _modelReadyToMerge = true;
513            }
514        }
515
516        osg::notify(osg::NOTICE)<<"done LoadAndCompileOperation "<<_filename<<std::endl;
517    }
518
519    virtual bool compileCompleted(osgUtil::IncrementalCompileOperation::CompileSet* compileSet)
520    {
521        OSG_NOTICE<<"compileCompleted"<<std::endl;
522        _modelReadyToMerge = true;
523        return true;
524    }
525
526    std::string                                         _filename;
527    std::string                                         _outputFilename;
528    osg::ref_ptr<osg::Node>                             _loadedModel;
529    bool                                                _modelReadyToMerge;
530    osg::ref_ptr<SceneGraphProcessor>                   _sceneGraphProcessor;
531    osg::ref_ptr<osgUtil::IncrementalCompileOperation>  _incrementalCompileOperation;
532};
533
534
535int main(int argc, char** argv)
536{
537    osg::ArgumentParser arguments(&argc, argv);
538
539    // construct the viewer.
540    osgViewer::Viewer viewer(arguments);
541
542    viewer.setCameraManipulator( new osgGA::TrackballManipulator() );
543    viewer.addEventHandler( new osgViewer::StatsHandler());
544    viewer.addEventHandler( new osgViewer::WindowSizeHandler() );
545    viewer.addEventHandler( new osgGA::StateSetManipulator(viewer.getCamera()->getOrCreateStateSet()) );
546
547    /////////////////////////////////////////////////////////////////////////////////
548    //
549    // IncrementalCompileOperation settings
550    //
551    osg::ref_ptr<osgUtil::IncrementalCompileOperation> incrementalCompile = new osgUtil::IncrementalCompileOperation;
552    viewer.setIncrementalCompileOperation(incrementalCompile.get());
553
554    if (arguments.read("--force") || arguments.read("-f"))
555    {
556        incrementalCompile->assignForceTextureDownloadGeometry();
557    }
558
559    if (arguments.read("-a"))
560    {
561        incrementalCompile->setMinimumTimeAvailableForGLCompileAndDeletePerFrame(1);
562        incrementalCompile->setConservativeTimeRatio(1);
563        incrementalCompile->setMaximumNumOfObjectsToCompilePerFrame(100);
564    }
565    else if (arguments.read("-c"))
566    {
567        incrementalCompile->setMinimumTimeAvailableForGLCompileAndDeletePerFrame(0.0001);
568        incrementalCompile->setConservativeTimeRatio(0.01);
569        incrementalCompile->setMaximumNumOfObjectsToCompilePerFrame(1);
570    }
571
572    /////////////////////////////////////////////////////////////////////////////////
573    //
574    // SceneGraph processing setup
575    //
576    osg::ref_ptr<SceneGraphProcessor> sceneGraphProcessor = new SceneGraphProcessor(arguments);
577
578    /////////////////////////////////////////////////////////////////////////////////
579    //
580    // Database settings
581    //
582    double timeBetweenMerges = 2.0;
583    while(arguments.read("--interval",timeBetweenMerges)) {}
584
585    std::string outputPostfix;
586    while (arguments.read("-o",outputPostfix)) {}
587
588
589    typedef std::vector< std::string > FileNames;
590    FileNames fileNames;
591    for(int pos=1;pos<arguments.argc();++pos)
592    {
593        if (!arguments.isOption(pos))
594        {
595            fileNames.push_back(arguments[pos]);
596        }
597    }
598
599    if (fileNames.empty())
600    {
601        OSG_NOTICE<<"No files loaded, please specifies files on commandline."<<std::endl;
602        return 1;
603    }
604
605    // load the models using a paging thread and use the incremental compile operation to
606    // manage the compilation of GL objects without breaking frame.
607
608    unsigned int modelIndex = 0;
609
610    osg::ref_ptr<osg::OperationThread> databasePagingThread;
611    osg::ref_ptr<DatabasePagingOperation> databasePagingOperation;
612
613    databasePagingThread = new osg::OperationThread;
614    databasePagingThread->startThread();
615
616    std::string filename = fileNames[modelIndex++];
617    std::string outputFilename = outputPostfix.empty() ? std::string() : filename+outputPostfix;
618
619    databasePagingOperation = new DatabasePagingOperation(
620        filename,
621        outputFilename,
622        sceneGraphProcessor.get(),
623        incrementalCompile.get());
624
625    databasePagingThread->add(databasePagingOperation.get());
626
627    osg::ref_ptr<osg::Group> group = new osg::Group;
628    viewer.setSceneData(group);
629
630    viewer.realize();
631
632    double timeOfLastMerge = viewer.getFrameStamp()->getReferenceTime();
633
634    while(!viewer.done())
635    {
636        viewer.frame();
637
638        double currentTime = viewer.getFrameStamp()->getReferenceTime();
639
640        if (!databasePagingOperation &&
641            modelIndex<fileNames.size() &&
642            (currentTime-timeOfLastMerge)>timeBetweenMerges)
643        {
644            std::string filename = fileNames[modelIndex++];
645            std::string outputFilename = outputPostfix.empty() ? std::string() : filename+outputPostfix;
646
647            databasePagingOperation = new DatabasePagingOperation(
648                filename,
649                outputFilename,
650                sceneGraphProcessor.get(),
651                incrementalCompile.get());
652
653            databasePagingThread->add(databasePagingOperation.get());
654        }
655
656        if (databasePagingOperation.get() && databasePagingOperation->_modelReadyToMerge)
657        {
658            timeOfLastMerge = currentTime;
659
660            group->removeChildren(0,group->getNumChildren());
661
662            group->addChild(databasePagingOperation->_loadedModel.get());
663
664            viewer.home();
665
666            // we no longer need the paging operation as it's done it's job.
667            databasePagingOperation = 0;
668
669            viewer.home();
670        }
671    }
672
673    return 0;
674}
Note: See TracBrowser for help on using the browser.