726 lines
24 KiB
C++
726 lines
24 KiB
C++
/* OpenSceneGraph example, osgterrain.
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
* THE SOFTWARE.
|
|
*/
|
|
|
|
|
|
#include <osgViewer/Viewer>
|
|
#include <osgViewer/ViewerEventHandlers>
|
|
|
|
#include <osgDB/ReadFile>
|
|
#include <osgDB/WriteFile>
|
|
|
|
#include <osgGA/TrackballManipulator>
|
|
#include <osgGA/StateSetManipulator>
|
|
#include <osgGA/TrackballManipulator>
|
|
#include <osgGA/FlightManipulator>
|
|
#include <osgGA/DriveManipulator>
|
|
#include <osgGA/KeySwitchMatrixManipulator>
|
|
#include <osgGA/AnimationPathManipulator>
|
|
#include <osgGA/TerrainManipulator>
|
|
|
|
#include <osgUtil/IncrementalCompileOperation>
|
|
#include <osgUtil/Simplifier>
|
|
#include <osgUtil/MeshOptimizers>
|
|
|
|
class StripStateVisitor : public osg::NodeVisitor
|
|
{
|
|
public:
|
|
StripStateVisitor(bool useStateSets, bool useDisplayLists, bool useVBO):
|
|
osg::NodeVisitor(osg::NodeVisitor::TRAVERSE_ALL_CHILDREN),
|
|
_useStateSets(useStateSets),
|
|
_useDisplayLists(useDisplayLists),
|
|
_useVBO(useVBO) {}
|
|
|
|
bool _useStateSets;
|
|
bool _useDisplayLists;
|
|
bool _useVBO;
|
|
|
|
void apply(osg::Node& node)
|
|
{
|
|
if (!_useStateSets && node.getStateSet()) node.setStateSet(0);
|
|
traverse(node);
|
|
}
|
|
|
|
void apply(osg::Geode& node)
|
|
{
|
|
if (!_useStateSets && node.getStateSet()) node.setStateSet(0);
|
|
for(unsigned int i = 0; i<node.getNumDrawables(); ++i)
|
|
{
|
|
process(*node.getDrawable(i));
|
|
}
|
|
|
|
traverse(node);
|
|
}
|
|
|
|
void process(osg::Drawable& drawable)
|
|
{
|
|
if (!_useStateSets && drawable.getStateSet())
|
|
{
|
|
drawable.setStateSet(0);
|
|
}
|
|
|
|
drawable.setUseDisplayList(_useDisplayLists);
|
|
drawable.setUseVertexBufferObjects(_useVBO);
|
|
}
|
|
};
|
|
|
|
class SwapArrayVisitor : public osg::ArrayVisitor
|
|
{
|
|
public:
|
|
SwapArrayVisitor(osg::Array* array):
|
|
_array(array) {}
|
|
|
|
template <class ARRAY>
|
|
void apply_imp(ARRAY& array)
|
|
{
|
|
if (array.getType()!=_array->getType())
|
|
{
|
|
OSG_NOTICE<<"Arrays incompatible"<<std::endl;
|
|
return;
|
|
}
|
|
OSG_NOTICE<<"Swapping Array"<<std::endl;
|
|
array.swap(*static_cast<ARRAY*>(_array));
|
|
}
|
|
|
|
virtual void apply(osg::ByteArray& ba) { apply_imp(ba); }
|
|
virtual void apply(osg::ShortArray& ba) { apply_imp(ba); }
|
|
virtual void apply(osg::IntArray& ba) { apply_imp(ba); }
|
|
virtual void apply(osg::UByteArray& ba) { apply_imp(ba); }
|
|
virtual void apply(osg::UShortArray& ba) { apply_imp(ba); }
|
|
virtual void apply(osg::UIntArray& ba) { apply_imp(ba); }
|
|
virtual void apply(osg::Vec4ubArray& ba) { apply_imp(ba); }
|
|
virtual void apply(osg::FloatArray& ba) { apply_imp(ba); }
|
|
virtual void apply(osg::Vec2Array& ba) { apply_imp(ba); }
|
|
virtual void apply(osg::Vec3Array& ba) { apply_imp(ba); }
|
|
virtual void apply(osg::Vec4Array& ba) { apply_imp(ba); }
|
|
|
|
osg::Array* _array;
|
|
};
|
|
|
|
class MemoryVisitor : public osg::NodeVisitor
|
|
{
|
|
public:
|
|
MemoryVisitor():
|
|
osg::NodeVisitor(osg::NodeVisitor::TRAVERSE_ALL_CHILDREN) {}
|
|
|
|
|
|
void reset()
|
|
{
|
|
_nodes.clear();
|
|
_geometryMap.clear();
|
|
_arrayMap.clear();
|
|
_primitiveSetMap.clear();
|
|
}
|
|
|
|
void apply(osg::Node& node)
|
|
{
|
|
_nodes.insert(&node);
|
|
traverse(node);
|
|
}
|
|
|
|
void apply(osg::Geode& geode)
|
|
{
|
|
_nodes.insert(&geode);
|
|
for(unsigned int i=0; i<geode.getNumDrawables(); ++i)
|
|
{
|
|
apply(&geode, geode.getDrawable(i));
|
|
}
|
|
}
|
|
|
|
void apply(osg::Geode* geode, osg::Drawable* drawable)
|
|
{
|
|
if (!drawable) return;
|
|
|
|
osg::Geometry* geometry = drawable->asGeometry();
|
|
if (geometry)
|
|
{
|
|
_geometryMap[geometry].insert(geode);
|
|
|
|
apply(geometry, geometry->getVertexArray());
|
|
apply(geometry, geometry->getNormalArray());
|
|
apply(geometry, geometry->getColorArray());
|
|
apply(geometry, geometry->getSecondaryColorArray());
|
|
apply(geometry, geometry->getFogCoordArray());
|
|
|
|
for(unsigned int i=0; i<geometry->getNumTexCoordArrays(); ++i)
|
|
{
|
|
apply(geometry, geometry->getTexCoordArray(i));
|
|
}
|
|
for(unsigned int i=0; i<geometry->getNumVertexAttribArrays(); ++i)
|
|
{
|
|
apply(geometry, geometry->getVertexAttribArray(i));
|
|
}
|
|
|
|
for(unsigned int i=0; i<geometry->getNumPrimitiveSets(); ++i)
|
|
{
|
|
apply(geometry, geometry->getPrimitiveSet(i));
|
|
}
|
|
}
|
|
}
|
|
|
|
void apply(osg::Geometry* geometry, osg::Array* array)
|
|
{
|
|
if (!array) return;
|
|
_arrayMap[array].insert(geometry);
|
|
}
|
|
|
|
void apply(osg::Geometry* geometry, osg::PrimitiveSet* primitiveSet)
|
|
{
|
|
if (!primitiveSet) return;
|
|
_primitiveSetMap[primitiveSet].insert(geometry);
|
|
}
|
|
|
|
void report(std::ostream& out)
|
|
{
|
|
OSG_NOTICE<<"Nodes "<<_nodes.size()<<std::endl;
|
|
OSG_NOTICE<<"Geometries "<<_geometryMap.size()<<std::endl;
|
|
OSG_NOTICE<<"Arrays "<<_arrayMap.size()<<std::endl;
|
|
OSG_NOTICE<<"PrimitiveSets "<<_primitiveSetMap.size()<<std::endl;
|
|
}
|
|
|
|
void reallocate()
|
|
{
|
|
OSG_NOTICE<<"Reallocating Arrays"<<std::endl;
|
|
|
|
typedef std::vector< osg::ref_ptr<osg::Array> > ArrayVector;
|
|
typedef std::vector< osg::ref_ptr<osg::Geometry> > GeometryVector;
|
|
ArrayVector newArrays;
|
|
GeometryVector newGeometries;
|
|
for(GeometryMap::iterator itr = _geometryMap.begin();
|
|
itr != _geometryMap.end();
|
|
++itr)
|
|
{
|
|
osg::Geometry* geometry = itr->first;
|
|
bool useVBO = geometry->getUseVertexBufferObjects();
|
|
osg::Geometry* newGeometry = osg::clone(geometry, osg::CopyOp(osg::CopyOp::DEEP_COPY_ALL));
|
|
newGeometry->setUseVertexBufferObjects(false);
|
|
newGeometry->setUseVertexBufferObjects(useVBO);
|
|
newGeometries.push_back(newGeometry);
|
|
}
|
|
|
|
GeometryVector::iterator geom_itr = newGeometries.begin();
|
|
for(GeometryMap::iterator itr = _geometryMap.begin();
|
|
itr != _geometryMap.end();
|
|
++itr, ++geom_itr)
|
|
{
|
|
osg::Geometry* geometry = itr->first;
|
|
Geodes& geodes = itr->second;
|
|
for(Geodes::iterator gitr = geodes.begin();
|
|
gitr != geodes.end();
|
|
++gitr)
|
|
{
|
|
osg::Geode* geode = const_cast<osg::Geode*>(*gitr);
|
|
geode->replaceDrawable(geometry, geom_itr->get());
|
|
}
|
|
}
|
|
}
|
|
|
|
typedef std::vector< osg::ref_ptr<osg::Geometry> > GeometryVector;
|
|
typedef std::pair<osg::Array*, osg::Array*> ArrayPair;
|
|
typedef std::vector< ArrayPair > ArrayVector;
|
|
typedef std::pair<osg::PrimitiveSet*, osg::PrimitiveSet*> PrimitiveSetPair;
|
|
typedef std::vector< PrimitiveSetPair > PrimitiveSetVector;
|
|
|
|
osg::Array* cloneArray(ArrayVector& arrayVector, osg::Array* array)
|
|
{
|
|
if (!array) return 0;
|
|
osg::Array* newArray = static_cast<osg::Array*>(array->cloneType());
|
|
arrayVector.push_back(ArrayPair(array,newArray));
|
|
return newArray;
|
|
}
|
|
|
|
osg::PrimitiveSet* clonePrimitiveSet(PrimitiveSetVector& psVector, osg::PrimitiveSet* ps)
|
|
{
|
|
if (!ps) return 0;
|
|
osg::PrimitiveSet* newPS = static_cast<osg::PrimitiveSet*>(ps->cloneType());
|
|
psVector.push_back(PrimitiveSetPair(ps,newPS));
|
|
return newPS;
|
|
}
|
|
|
|
void reallocate2()
|
|
{
|
|
OSG_NOTICE<<"Reallocating Arrays"<<std::endl;
|
|
|
|
ArrayVector arrayVector;
|
|
PrimitiveSetVector primitiveSetVector;
|
|
GeometryVector newGeometries;
|
|
|
|
for(GeometryMap::iterator itr = _geometryMap.begin();
|
|
itr != _geometryMap.end();
|
|
++itr)
|
|
{
|
|
osg::Geometry* geometry = itr->first;
|
|
osg::ref_ptr<osg::Geometry> newGeometry = osg::clone(geometry, osg::CopyOp::SHALLOW_COPY);
|
|
newGeometries.push_back(newGeometry.get());
|
|
|
|
newGeometry->setVertexArray(cloneArray(arrayVector, geometry->getVertexArray()));
|
|
newGeometry->setNormalArray(cloneArray(arrayVector, geometry->getNormalArray()));
|
|
newGeometry->setColorArray(cloneArray(arrayVector, geometry->getColorArray()));
|
|
newGeometry->setSecondaryColorArray(cloneArray(arrayVector, geometry->getSecondaryColorArray()));
|
|
newGeometry->setFogCoordArray(cloneArray(arrayVector, geometry->getFogCoordArray()));
|
|
for(unsigned int i=0; i<geometry->getNumTexCoordArrays(); ++i)
|
|
{
|
|
newGeometry->setTexCoordArray(i, cloneArray(arrayVector, geometry->getTexCoordArray(i)));
|
|
}
|
|
for(unsigned int i=0; i<geometry->getNumVertexAttribArrays(); ++i)
|
|
{
|
|
newGeometry->setVertexAttribArray(i, cloneArray(arrayVector, geometry->getVertexAttribArray(i)));
|
|
}
|
|
|
|
for(unsigned int i=0; i<geometry->getNumPrimitiveSets(); ++i)
|
|
{
|
|
newGeometry->setPrimitiveSet(i,clonePrimitiveSet(primitiveSetVector, geometry->getPrimitiveSet(i)));
|
|
}
|
|
}
|
|
|
|
GeometryVector::iterator geom_itr = newGeometries.begin();
|
|
for(GeometryMap::iterator itr = _geometryMap.begin();
|
|
itr != _geometryMap.end();
|
|
++itr, ++geom_itr)
|
|
{
|
|
osg::Geometry* geometry = itr->first;
|
|
Geodes& geodes = itr->second;
|
|
for(Geodes::iterator gitr = geodes.begin();
|
|
gitr != geodes.end();
|
|
++gitr)
|
|
{
|
|
osg::Geode* geode = const_cast<osg::Geode*>(*gitr);
|
|
geode->replaceDrawable(geometry, geom_itr->get());
|
|
}
|
|
}
|
|
}
|
|
|
|
protected:
|
|
|
|
typedef std::set<osg::Node*> Nodes;
|
|
typedef std::set<osg::Geode*> Geodes;
|
|
typedef std::set<osg::Geometry*> Geometries;
|
|
typedef std::map<osg::Geometry*, Geodes> GeometryMap;
|
|
typedef std::map<osg::Array*, Geometries> ArrayMap;
|
|
typedef std::map<osg::PrimitiveSet*, Geometries> PrimitiveSetMap;
|
|
|
|
Nodes _nodes;
|
|
GeometryMap _geometryMap;
|
|
ArrayMap _arrayMap;
|
|
PrimitiveSetMap _primitiveSetMap;
|
|
};
|
|
|
|
class SceneGraphProcessor : public osg::Referenced
|
|
{
|
|
public:
|
|
SceneGraphProcessor()
|
|
{
|
|
_init();
|
|
}
|
|
|
|
SceneGraphProcessor(osg::ArgumentParser& arguments)
|
|
{
|
|
_init();
|
|
|
|
while (arguments.read("--vbo")) { modifyDrawableSettings = true; useVBO = true; }
|
|
while (arguments.read("--dl")) { modifyDrawableSettings = true; useDisplayLists = true; }
|
|
|
|
while (arguments.read("-s", simplificatioRatio)) {}
|
|
while (arguments.read("--tristripper")) { useTriStripVisitor=true; }
|
|
while (arguments.read("--no-tristripper")) { useTriStripVisitor=false; }
|
|
while (arguments.read("--smoother")) { useSmoothingVisitor=true; }
|
|
while (arguments.read("--no-smoother")) { useSmoothingVisitor=false; }
|
|
|
|
while (arguments.read("--remove-duplicate-vertices") || arguments.read("--rdv")) removeDuplicateVertices = true;
|
|
while (arguments.read("--optimize-vertex-cache") || arguments.read("--ovc")) optimizeVertexCache = true;
|
|
while (arguments.read("--optimize-vertex-order") || arguments.read("--ovo")) optimizeVertexOrder = true;
|
|
|
|
while (arguments.read("--build-mipmaps")) { modifyTextureSettings = true; buildImageMipmaps = true; }
|
|
while (arguments.read("--compress")) { modifyTextureSettings = true; compressImages = true; }
|
|
while (arguments.read("--disable-mipmaps")) { modifyTextureSettings = true; disableMipmaps = true; }
|
|
|
|
while (arguments.read("--reallocate") || arguments.read("--ra") ) { reallocateMemory = true; }
|
|
|
|
|
|
OSG_NOTICE<<"simplificatioRatio="<<simplificatioRatio<<std::endl;
|
|
}
|
|
|
|
virtual osg::Node* process(osg::Node* node)
|
|
{
|
|
if (!node)
|
|
{
|
|
OSG_NOTICE<<"SceneGraphProcessor::process(Node*) : error cannot process NULL Node."<<std::endl;
|
|
return 0;
|
|
}
|
|
|
|
OSG_NOTICE<<"SceneGraphProcessor::process("<<node<<") : "<<node->getName()<<std::endl;
|
|
|
|
if (simplificatioRatio < 1.0)
|
|
{
|
|
OSG_NOTICE<<"Running simplifier with simplification ratio="<<simplificatioRatio<<std::endl;
|
|
float maxError = 4.0f;
|
|
osgUtil::Simplifier simplifier(simplificatioRatio, maxError);
|
|
simplifier.setDoTriStrip(useTriStripVisitor);
|
|
simplifier.setSmoothing(useSmoothingVisitor);
|
|
node->accept(simplifier);
|
|
}
|
|
|
|
if (removeDuplicateVertices)
|
|
{
|
|
OSG_NOTICE<<"Running osgUtil::IndexMeshVisitor"<<std::endl;
|
|
osgUtil::IndexMeshVisitor imv;
|
|
node->accept(imv);
|
|
imv.makeMesh();
|
|
}
|
|
|
|
if (optimizeVertexCache)
|
|
{
|
|
OSG_NOTICE<<"Running osgUtil::VertexCacheVisitor"<<std::endl;
|
|
osgUtil::VertexCacheVisitor vcv;
|
|
node->accept(vcv);
|
|
vcv.optimizeVertices();
|
|
}
|
|
|
|
if (optimizeVertexOrder)
|
|
{
|
|
OSG_NOTICE<<"Running osgUtil::VertexAccessOrderVisitor"<<std::endl;
|
|
osgUtil::VertexAccessOrderVisitor vaov;
|
|
node->accept(vaov);
|
|
vaov.optimizeOrder();
|
|
}
|
|
|
|
if (modifyDrawableSettings || modifyTextureSettings)
|
|
{
|
|
OSG_NOTICE<<"Running StripStateVisitor"<<std::endl;
|
|
StripStateVisitor ssv(true, useDisplayLists, useVBO);
|
|
node->accept(ssv);
|
|
}
|
|
|
|
MemoryVisitor mv;
|
|
node->accept(mv);
|
|
mv.report(osg::notify(osg::NOTICE));
|
|
|
|
if (reallocateMemory)
|
|
{
|
|
OSG_NOTICE<<"Running Reallocation of scene graph memory"<<std::endl;
|
|
mv.reallocate();
|
|
}
|
|
|
|
mv.reset();
|
|
node->accept(mv);
|
|
mv.report(osg::notify(osg::NOTICE));
|
|
|
|
return node;
|
|
}
|
|
|
|
protected:
|
|
|
|
void _init()
|
|
{
|
|
modifyDrawableSettings = false;
|
|
useVBO = false;
|
|
useDisplayLists = false;
|
|
|
|
simplificatioRatio = 1.0;
|
|
useTriStripVisitor = false;
|
|
useSmoothingVisitor = false;
|
|
|
|
removeDuplicateVertices = false;
|
|
optimizeVertexCache = false;
|
|
optimizeVertexOrder = false;
|
|
|
|
reallocateMemory = false;
|
|
|
|
modifyTextureSettings = false;
|
|
buildImageMipmaps = false;
|
|
compressImages = false;
|
|
disableMipmaps = false;
|
|
}
|
|
|
|
bool modifyDrawableSettings;
|
|
bool useVBO;
|
|
bool useDisplayLists;
|
|
|
|
float simplificatioRatio;
|
|
bool useTriStripVisitor;
|
|
bool useSmoothingVisitor;
|
|
|
|
bool removeDuplicateVertices;
|
|
bool optimizeVertexCache;
|
|
bool optimizeVertexOrder;
|
|
|
|
bool reallocateMemory;
|
|
|
|
bool modifyTextureSettings;
|
|
bool buildImageMipmaps;
|
|
bool compressImages;
|
|
bool disableMipmaps;
|
|
|
|
};
|
|
|
|
class DatabasePagingOperation : public osg::Operation, public osgUtil::IncrementalCompileOperation::CompileCompletedCallback
|
|
{
|
|
public:
|
|
|
|
DatabasePagingOperation(const std::string& filename,
|
|
const std::string& outputFilename,
|
|
SceneGraphProcessor* sceneGraphProcessor,
|
|
osgUtil::IncrementalCompileOperation* ico):
|
|
Operation("DatabasePaging Operation", false),
|
|
_filename(filename),
|
|
_outputFilename(outputFilename),
|
|
_modelReadyToMerge(false),
|
|
_sceneGraphProcessor(sceneGraphProcessor),
|
|
_incrementalCompileOperation(ico) {}
|
|
|
|
virtual void operator () (osg::Object* object)
|
|
{
|
|
osg::notify(osg::NOTICE)<<"LoadAndCompileOperation "<<_filename<<std::endl;
|
|
|
|
_modelReadyToMerge = false;
|
|
_loadedModel = osgDB::readNodeFile(_filename);
|
|
|
|
if (_loadedModel.valid())
|
|
{
|
|
if (_sceneGraphProcessor.valid())
|
|
{
|
|
_loadedModel = _sceneGraphProcessor->process(_loadedModel.get());
|
|
}
|
|
}
|
|
|
|
if (_loadedModel.valid())
|
|
{
|
|
if (!_outputFilename.empty())
|
|
{
|
|
osgDB::writeNodeFile(*_loadedModel, _outputFilename);
|
|
}
|
|
|
|
if (_incrementalCompileOperation.valid())
|
|
{
|
|
osg::ref_ptr<osgUtil::IncrementalCompileOperation::CompileSet> compileSet =
|
|
new osgUtil::IncrementalCompileOperation::CompileSet(_loadedModel.get());
|
|
|
|
compileSet->_compileCompletedCallback = this;
|
|
|
|
_incrementalCompileOperation->add(compileSet.get());
|
|
}
|
|
else
|
|
{
|
|
_modelReadyToMerge = true;
|
|
}
|
|
}
|
|
|
|
osg::notify(osg::NOTICE)<<"done LoadAndCompileOperation "<<_filename<<std::endl;
|
|
}
|
|
|
|
virtual bool compileCompleted(osgUtil::IncrementalCompileOperation::CompileSet* compileSet)
|
|
{
|
|
OSG_NOTICE<<"compileCompleted"<<std::endl;
|
|
_modelReadyToMerge = true;
|
|
return true;
|
|
}
|
|
|
|
std::string _filename;
|
|
std::string _outputFilename;
|
|
osg::ref_ptr<osg::Node> _loadedModel;
|
|
bool _modelReadyToMerge;
|
|
osg::ref_ptr<SceneGraphProcessor> _sceneGraphProcessor;
|
|
osg::ref_ptr<osgUtil::IncrementalCompileOperation> _incrementalCompileOperation;
|
|
};
|
|
|
|
class TexturePoolHandler : public osgGA::GUIEventHandler
|
|
{
|
|
public:
|
|
virtual bool handle(const osgGA::GUIEventAdapter& ea,osgGA::GUIActionAdapter& aa)
|
|
{
|
|
if (ea.getEventType() == osgGA::GUIEventAdapter::KEYUP)
|
|
{
|
|
if (ea.getKey()=='r')
|
|
{
|
|
osg::Texture::getTextureObjectManager(0)->reportStats();
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
};
|
|
|
|
|
|
int main(int argc, char** argv)
|
|
{
|
|
osg::ArgumentParser arguments(&argc, argv);
|
|
|
|
// construct the viewer.
|
|
osgViewer::Viewer viewer(arguments);
|
|
|
|
// set up camera manipulators
|
|
{
|
|
osg::ref_ptr<osgGA::KeySwitchMatrixManipulator> keyswitchManipulator = new osgGA::KeySwitchMatrixManipulator;
|
|
|
|
keyswitchManipulator->addMatrixManipulator( '1', "Trackball", new osgGA::TrackballManipulator() );
|
|
keyswitchManipulator->addMatrixManipulator( '2', "Flight", new osgGA::FlightManipulator() );
|
|
keyswitchManipulator->addMatrixManipulator( '3', "Drive", new osgGA::DriveManipulator() );
|
|
keyswitchManipulator->addMatrixManipulator( '4', "Terrain", new osgGA::TerrainManipulator() );
|
|
|
|
std::string pathfile;
|
|
char keyForAnimationPath = '8';
|
|
while (arguments.read("-p",pathfile))
|
|
{
|
|
osgGA::AnimationPathManipulator* apm = new osgGA::AnimationPathManipulator(pathfile);
|
|
if (apm || !apm->valid())
|
|
{
|
|
unsigned int num = keyswitchManipulator->getNumMatrixManipulators();
|
|
keyswitchManipulator->addMatrixManipulator( keyForAnimationPath, "Path", apm );
|
|
keyswitchManipulator->selectMatrixManipulator(num);
|
|
++keyForAnimationPath;
|
|
}
|
|
}
|
|
|
|
viewer.setCameraManipulator( keyswitchManipulator.get() );
|
|
}
|
|
|
|
// set up event handlers
|
|
{
|
|
viewer.addEventHandler( new osgViewer::StatsHandler());
|
|
viewer.addEventHandler( new osgViewer::WindowSizeHandler() );
|
|
viewer.addEventHandler( new osgGA::StateSetManipulator(viewer.getCamera()->getOrCreateStateSet()) );
|
|
viewer.addEventHandler( new TexturePoolHandler() );
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// IncrementalCompileOperation settings
|
|
//
|
|
osg::ref_ptr<osgUtil::IncrementalCompileOperation> incrementalCompile = new osgUtil::IncrementalCompileOperation;
|
|
viewer.setIncrementalCompileOperation(incrementalCompile.get());
|
|
|
|
if (arguments.read("--force") || arguments.read("-f"))
|
|
{
|
|
incrementalCompile->assignForceTextureDownloadGeometry();
|
|
}
|
|
|
|
if (arguments.read("-a"))
|
|
{
|
|
incrementalCompile->setMinimumTimeAvailableForGLCompileAndDeletePerFrame(1);
|
|
incrementalCompile->setConservativeTimeRatio(1);
|
|
incrementalCompile->setMaximumNumOfObjectsToCompilePerFrame(100);
|
|
}
|
|
else if (arguments.read("-c"))
|
|
{
|
|
incrementalCompile->setMinimumTimeAvailableForGLCompileAndDeletePerFrame(0.0001);
|
|
incrementalCompile->setConservativeTimeRatio(0.01);
|
|
incrementalCompile->setMaximumNumOfObjectsToCompilePerFrame(1);
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// SceneGraph processing setup
|
|
//
|
|
osg::ref_ptr<SceneGraphProcessor> sceneGraphProcessor = new SceneGraphProcessor(arguments);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Database settings
|
|
//
|
|
double timeBetweenMerges = 2.0;
|
|
while(arguments.read("--interval",timeBetweenMerges)) {}
|
|
|
|
std::string outputPostfix;
|
|
while (arguments.read("-o",outputPostfix)) {}
|
|
|
|
|
|
typedef std::vector< std::string > FileNames;
|
|
FileNames fileNames;
|
|
for(int pos=1;pos<arguments.argc();++pos)
|
|
{
|
|
if (!arguments.isOption(pos))
|
|
{
|
|
fileNames.push_back(arguments[pos]);
|
|
}
|
|
}
|
|
|
|
if (fileNames.empty())
|
|
{
|
|
OSG_NOTICE<<"No files loaded, please specify files on commandline."<<std::endl;
|
|
return 1;
|
|
}
|
|
|
|
// load the models using a paging thread and use the incremental compile operation to
|
|
// manage the compilation of GL objects without breaking frame.
|
|
|
|
unsigned int modelIndex = 0;
|
|
|
|
osg::ref_ptr<osg::OperationThread> databasePagingThread;
|
|
osg::ref_ptr<DatabasePagingOperation> databasePagingOperation;
|
|
|
|
databasePagingThread = new osg::OperationThread;
|
|
databasePagingThread->startThread();
|
|
|
|
std::string filename = fileNames[modelIndex++];
|
|
std::string outputFilename = outputPostfix.empty() ? std::string() : filename+outputPostfix;
|
|
|
|
databasePagingOperation = new DatabasePagingOperation(
|
|
filename,
|
|
outputFilename,
|
|
sceneGraphProcessor.get(),
|
|
incrementalCompile.get());
|
|
|
|
databasePagingThread->add(databasePagingOperation.get());
|
|
|
|
osg::ref_ptr<osg::Group> group = new osg::Group;
|
|
viewer.setSceneData(group.get());
|
|
|
|
viewer.realize();
|
|
|
|
double timeOfLastMerge = viewer.getFrameStamp()->getReferenceTime();
|
|
|
|
while(!viewer.done())
|
|
{
|
|
viewer.frame();
|
|
|
|
double currentTime = viewer.getFrameStamp()->getReferenceTime();
|
|
|
|
if (!databasePagingOperation &&
|
|
modelIndex<fileNames.size() &&
|
|
(currentTime-timeOfLastMerge)>timeBetweenMerges)
|
|
{
|
|
std::string filename = fileNames[modelIndex++];
|
|
std::string outputFilename = outputPostfix.empty() ? std::string() : filename+outputPostfix;
|
|
|
|
databasePagingOperation = new DatabasePagingOperation(
|
|
filename,
|
|
outputFilename,
|
|
sceneGraphProcessor.get(),
|
|
incrementalCompile.get());
|
|
|
|
databasePagingThread->add(databasePagingOperation.get());
|
|
}
|
|
|
|
if (databasePagingOperation.get() && databasePagingOperation->_modelReadyToMerge)
|
|
{
|
|
timeOfLastMerge = currentTime;
|
|
|
|
group->removeChildren(0,group->getNumChildren());
|
|
|
|
group->addChild(databasePagingOperation->_loadedModel.get());
|
|
|
|
viewer.home();
|
|
|
|
// we no longer need the paging operation as it's done it's job.
|
|
databasePagingOperation = 0;
|
|
|
|
viewer.home();
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|