1 // ModelRegistry.hxx -- interface to the OSG model registry
3 // Copyright (C) 2005-2007 Mathias Froehlich
4 // Copyright (C) 2007 Tim Moore <timoore@redhat.com>
6 // This program is free software; you can redistribute it and/or
7 // modify it under the terms of the GNU General Public License as
8 // published by the Free Software Foundation; either version 2 of the
9 // License, or (at your option) any later version.
11 // This program is distributed in the hope that it will be useful, but
12 // WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 // General Public License for more details.
16 // You should have received a copy of the GNU General Public License
17 // along with this program; if not, write to the Free Software
18 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
21 # include <simgear_config.h>
24 #include "ModelRegistry.hxx"
30 #include <OpenThreads/ScopedLock>
32 #include <osg/observer_ptr>
33 #include <osg/ref_ptr>
35 #include <osg/NodeCallback>
37 #include <osg/Material>
38 #include <osg/MatrixTransform>
39 #include <osgDB/Archive>
40 #include <osgDB/FileNameUtils>
41 #include <osgDB/FileUtils>
42 #include <osgDB/ReadFile>
43 #include <osgDB/WriteFile>
44 #include <osgDB/Registry>
45 #include <osgDB/SharedStateManager>
46 #include <osgUtil/Optimizer>
48 #include <simgear/scene/util/SGSceneFeatures.hxx>
49 #include <simgear/scene/util/SGStateAttributeVisitor.hxx>
50 #include <simgear/scene/util/SGTextureStateAttributeVisitor.hxx>
51 #include <simgear/scene/util/NodeAndDrawableVisitor.hxx>
53 #include <simgear/structure/exception.hxx>
54 #include <simgear/props/props.hxx>
55 #include <simgear/props/props_io.hxx>
56 #include <simgear/props/condition.hxx>
58 #include "BoundingVolumeBuildVisitor.hxx"
62 using namespace osgUtil;
63 using namespace osgDB;
64 using namespace simgear;
66 using OpenThreads::ReentrantMutex;
67 using OpenThreads::ScopedLock;
69 // Little helper class that holds an extra reference to a
71 // Since we clone all structural nodes from our 3d models,
72 // the database pager will only see one single reference to
73 // top node of the model and expire it relatively fast.
74 // We attach that extra reference to every model cloned from
75 // a base model in the pager. When that cloned model is deleted
76 // this extra reference is deleted too. So if there are no
77 // cloned models left the model will expire.
79 class SGDatabaseReference : public Observer {
81 SGDatabaseReference(Referenced* referenced) :
82 mReferenced(referenced)
84 virtual void objectDeleted(void*)
89 ref_ptr<Referenced> mReferenced;
92 // Set the name of a Texture to the simple name of its image
93 // file. This can be used to do livery substitution after the image
94 // has been deallocated.
95 class TextureNameVisitor : public NodeAndDrawableVisitor {
97 TextureNameVisitor(NodeVisitor::TraversalMode tm = NodeVisitor::TRAVERSE_ALL_CHILDREN) :
98 NodeAndDrawableVisitor(tm)
102 virtual void apply(Node& node)
104 nameTextures(node.getStateSet());
108 virtual void apply(Drawable& drawable)
110 nameTextures(drawable.getStateSet());
113 void nameTextures(StateSet* stateSet)
117 int numUnits = stateSet->getTextureAttributeList().size();
118 for (int i = 0; i < numUnits; ++i) {
120 = stateSet->getTextureAttribute(i, StateAttribute::TEXTURE);
121 Texture2D* texture = dynamic_cast<Texture2D*>(attr);
122 if (!texture || !texture->getName().empty())
124 const Image *image = texture->getImage();
127 texture->setName(image->getFileName());
132 // Change the StateSets of a model to hold different textures based on
135 class TextureUpdateVisitor : public NodeAndDrawableVisitor {
137 TextureUpdateVisitor(const FilePathList& pathList) :
138 NodeAndDrawableVisitor(NodeVisitor::TRAVERSE_ALL_CHILDREN),
143 virtual void apply(Node& node)
145 StateSet* stateSet = cloneStateSet(node.getStateSet());
147 node.setStateSet(stateSet);
151 virtual void apply(Drawable& drawable)
153 StateSet* stateSet = cloneStateSet(drawable.getStateSet());
155 drawable.setStateSet(stateSet);
157 // Copied from Mathias' earlier SGTextureUpdateVisitor
159 Texture2D* textureReplace(int unit, const StateAttribute* attr)
161 const Texture2D* texture = dynamic_cast<const Texture2D*>(attr);
166 const Image* image = texture->getImage();
167 const string* fullFilePath = 0;
169 // The currently loaded file name
170 fullFilePath = &image->getFileName();
173 fullFilePath = &texture->getName();
176 string fileName = getSimpleFileName(*fullFilePath);
177 if (fileName.empty())
179 // The name that should be found with the current database path
180 string fullLiveryFile = findFileInPath(fileName, _pathList);
181 // If it is empty or they are identical then there is nothing to do
182 if (fullLiveryFile.empty() || fullLiveryFile == *fullFilePath)
184 Image* newImage = readImageFile(fullLiveryFile);
187 CopyOp copyOp(CopyOp::DEEP_COPY_ALL & ~CopyOp::DEEP_COPY_IMAGES);
188 Texture2D* newTexture = static_cast<Texture2D*>(copyOp(texture));
192 newTexture->setImage(newImage);
197 StateSet* cloneStateSet(const StateSet* stateSet)
199 typedef pair<int, Texture2D*> Tex2D;
200 vector<Tex2D> newTextures;
201 StateSet* result = 0;
205 int numUnits = stateSet->getTextureAttributeList().size();
207 for (int i = 0; i < numUnits; ++i) {
208 const StateAttribute* attr
209 = stateSet->getTextureAttribute(i, StateAttribute::TEXTURE);
210 Texture2D* newTexture = textureReplace(i, attr);
212 newTextures.push_back(Tex2D(i, newTexture));
214 if (!newTextures.empty()) {
215 result = static_cast<StateSet*>(stateSet->clone(CopyOp()));
216 for (vector<Tex2D>::iterator i = newTextures.begin();
217 i != newTextures.end();
219 result->setTextureAttribute(i->first, i->second);
226 FilePathList _pathList;
229 // Create new userdata structs in a copied model.
230 // The BVH trees are shared with the original model, but the velocity fields
231 // should usually be distinct fields for distinct models.
232 class UserDataCopyVisitor : public osg::NodeVisitor {
234 UserDataCopyVisitor() :
235 osg::NodeVisitor(osg::NodeVisitor::NODE_VISITOR,
236 osg::NodeVisitor::TRAVERSE_ALL_CHILDREN)
239 virtual void apply(osg::Node& node)
241 osg::ref_ptr<SGSceneUserData> userData;
242 userData = SGSceneUserData::getSceneUserData(&node);
243 if (userData.valid()) {
244 SGSceneUserData* newUserData = new SGSceneUserData(*userData);
245 newUserData->setVelocity(0);
246 node.setUserData(newUserData);
248 node.traverse(*this);
252 class SGTexCompressionVisitor : public SGTextureStateAttributeVisitor {
254 virtual void apply(int, StateSet::RefAttributePair& refAttr)
257 texture = dynamic_cast<Texture2D*>(refAttr.first.get());
262 texture->setDataVariance(osg::Object::STATIC);
264 Image* image = texture->getImage(0);
271 if (s <= t && 32 <= s) {
272 SGSceneFeatures::instance()->setTextureCompression(texture);
273 } else if (t < s && 32 <= t) {
274 SGSceneFeatures::instance()->setTextureCompression(texture);
279 class SGTexDataVarianceVisitor : public SGTextureStateAttributeVisitor {
281 virtual void apply(int, StateSet::RefAttributePair& refAttr)
284 texture = dynamic_cast<Texture*>(refAttr.first.get());
288 texture->setDataVariance(Object::STATIC);
291 virtual void apply(StateSet* stateSet)
295 SGTextureStateAttributeVisitor::apply(stateSet);
296 stateSet->setDataVariance(Object::STATIC);
300 class SGAcMaterialCrippleVisitor : public SGStateAttributeVisitor {
302 virtual void apply(StateSet::RefAttributePair& refAttr)
305 material = dynamic_cast<Material*>(refAttr.first.get());
308 material->setColorMode(Material::AMBIENT_AND_DIFFUSE);
314 Node* DefaultProcessPolicy::process(Node* node, const string& filename,
315 const ReaderWriter::Options* opt)
317 TextureNameVisitor nameVisitor;
318 node->accept(nameVisitor);
322 ReaderWriter::ReadResult
323 ModelRegistry::readImage(const string& fileName,
324 const ReaderWriter::Options* opt)
326 ScopedLock<ReentrantMutex> lock(readerMutex);
327 CallbackMap::iterator iter
328 = imageCallbackMap.find(getFileExtension(fileName));
329 // XXX Workaround for OSG plugin bug
331 if (iter != imageCallbackMap.end() && iter->second.valid())
332 return iter->second->readImage(fileName, opt);
333 string absFileName = findDataFile(fileName, opt);
334 if (!fileExists(absFileName)) {
335 SG_LOG(SG_IO, SG_ALERT, "Cannot find image file \""
336 << fileName << "\"");
337 return ReaderWriter::ReadResult::FILE_NOT_FOUND;
340 Registry* registry = Registry::instance();
341 ReaderWriter::ReadResult res;
342 res = registry->readImageImplementation(absFileName, opt);
343 if (!res.success()) {
344 SG_LOG(SG_IO, SG_WARN, "Image loading failed:" << res.message());
348 if (res.loadedFromCache())
349 SG_LOG(SG_IO, SG_INFO, "Returning cached image \""
350 << res.getImage()->getFileName() << "\"");
352 SG_LOG(SG_IO, SG_INFO, "Reading image \""
353 << res.getImage()->getFileName() << "\"");
360 osg::Node* DefaultCachePolicy::find(const string& fileName,
361 const ReaderWriter::Options* opt)
363 Registry* registry = Registry::instance();
365 = dynamic_cast<Node*>(registry->getFromObjectCache(fileName));
367 SG_LOG(SG_IO, SG_INFO, "Got cached model \""
368 << fileName << "\"");
370 SG_LOG(SG_IO, SG_INFO, "Reading model \""
371 << fileName << "\"");
375 void DefaultCachePolicy::addToCache(const string& fileName,
378 Registry::instance()->addEntryToObjectCache(fileName, node);
381 // Optimizations we don't use:
382 // Don't use this one. It will break animation names ...
383 // opts |= osgUtil::Optimizer::REMOVE_REDUNDANT_NODES;
385 // opts |= osgUtil::Optimizer::REMOVE_LOADED_PROXY_NODES;
386 // opts |= osgUtil::Optimizer::COMBINE_ADJACENT_LODS;
387 // opts |= osgUtil::Optimizer::CHECK_GEOMETRY;
388 // opts |= osgUtil::Optimizer::SPATIALIZE_GROUPS;
389 // opts |= osgUtil::Optimizer::COPY_SHARED_NODES;
390 // opts |= osgUtil::Optimizer::TESSELATE_GEOMETRY;
391 // opts |= osgUtil::Optimizer::OPTIMIZE_TEXTURE_SETTINGS;
393 OptimizeModelPolicy::OptimizeModelPolicy(const string& extension) :
394 _osgOptions(Optimizer::SHARE_DUPLICATE_STATE
395 | Optimizer::MERGE_GEOMETRY
396 | Optimizer::FLATTEN_STATIC_TRANSFORMS
397 | Optimizer::TRISTRIP_GEOMETRY)
401 osg::Node* OptimizeModelPolicy::optimize(osg::Node* node,
402 const string& fileName,
403 const osgDB::ReaderWriter::Options* opt)
405 osgUtil::Optimizer optimizer;
406 optimizer.optimize(node, _osgOptions);
408 // Make sure the data variance of sharable objects is set to
409 // STATIC so that textures will be globally shared.
410 SGTexDataVarianceVisitor dataVarianceVisitor;
411 node->accept(dataVarianceVisitor);
413 SGTexCompressionVisitor texComp;
414 node->accept(texComp);
418 osg::Node* DefaultCopyPolicy::copy(osg::Node* model, const string& fileName,
419 const osgDB::ReaderWriter::Options* opt)
421 /// Crude hack for the bounding volume sharing problem.
422 /// Better solution this week.
423 /// Note that this does not really build in the case we come here
424 /// the second time for the same node
425 BoundingVolumeBuildVisitor bvBuilder;
426 model->accept(bvBuilder);
428 // Add an extra reference to the model stored in the database.
429 // That it to avoid expiring the object from the cache even if it is still
430 // in use. Note that the object cache will think that a model is unused
431 // if the reference count is 1. If we clone all structural nodes here
432 // we need that extra reference to the original object
433 SGDatabaseReference* databaseReference;
434 databaseReference = new SGDatabaseReference(model);
435 CopyOp::CopyFlags flags = CopyOp::DEEP_COPY_ALL;
436 flags &= ~CopyOp::DEEP_COPY_TEXTURES;
437 flags &= ~CopyOp::DEEP_COPY_IMAGES;
438 flags &= ~CopyOp::DEEP_COPY_STATESETS;
439 flags &= ~CopyOp::DEEP_COPY_STATEATTRIBUTES;
440 flags &= ~CopyOp::DEEP_COPY_ARRAYS;
441 flags &= ~CopyOp::DEEP_COPY_PRIMITIVES;
442 // This will safe display lists ...
443 flags &= ~CopyOp::DEEP_COPY_DRAWABLES;
444 flags &= ~CopyOp::DEEP_COPY_SHAPES;
445 osg::Node* res = CopyOp(flags)(model);
446 res->addObserver(databaseReference);
449 TextureUpdateVisitor liveryUpdate(opt->getDatabasePathList());
450 res->accept(liveryUpdate);
452 // Copy the userdata fields, still sharing the boundingvolumes,
453 // but introducing new data for velocities.
454 UserDataCopyVisitor userDataCopyVisitor;
455 res->accept(userDataCopyVisitor);
460 string OSGSubstitutePolicy::substitute(const string& name,
461 const ReaderWriter::Options* opt)
463 string fileSansExtension = getNameLessExtension(name);
464 string osgFileName = fileSansExtension + ".osg";
465 string absFileName = findDataFile(osgFileName, opt);
469 ModelRegistry::ModelRegistry() :
470 _defaultCallback(new DefaultCallback("")),
476 ModelRegistry::addImageCallbackForExtension(const string& extension,
477 Registry::ReadFileCallback* callback)
479 imageCallbackMap.insert(CallbackMap::value_type(extension, callback));
483 ModelRegistry::addNodeCallbackForExtension(const string& extension,
484 Registry::ReadFileCallback* callback)
486 nodeCallbackMap.insert(CallbackMap::value_type(extension, callback));
489 ReaderWriter::ReadResult
490 ModelRegistry::readNode(const string& fileName,
491 const ReaderWriter::Options* opt)
493 ScopedLock<ReentrantMutex> lock(readerMutex);
496 // XXX Workaround for OSG plugin bug.
497 Registry* registry = Registry::instance();
498 ReaderWriter::ReadResult res;
499 CallbackMap::iterator iter
500 = nodeCallbackMap.find(getFileExtension(fileName));
501 ReaderWriter::ReadResult result;
502 if (iter != nodeCallbackMap.end() && iter->second.valid())
503 result = iter->second->readNode(fileName, opt);
505 result = _defaultCallback->readNode(fileName, opt);
507 if (0 == --_nestingLevel) {
508 SG_LOG(SG_IO, SG_INFO, "Building boundingvolume tree for \""
509 << fileName << "\".");
510 BoundingVolumeBuildVisitor bvBuilder;
511 result.getNode()->accept(bvBuilder);
513 SG_LOG(SG_IO, SG_INFO, "Defering boundingvolume tree built for \""
514 << fileName << "\" to parent.");
519 class SGReadCallbackInstaller {
521 SGReadCallbackInstaller()
523 // XXX I understand why we want this, but this seems like a weird
524 // place to set this option.
525 Referenced::setThreadSafeReferenceCounting(true);
527 Registry* registry = Registry::instance();
528 ReaderWriter::Options* options = new ReaderWriter::Options;
529 int cacheOptions = ReaderWriter::Options::CACHE_ALL;
531 setObjectCacheHint((ReaderWriter::Options::CacheHintOptions)cacheOptions);
532 registry->setOptions(options);
533 registry->getOrCreateSharedStateManager()->
534 setShareMode(SharedStateManager::SHARE_STATESETS);
535 registry->setReadFileCallback(ModelRegistry::instance());
539 static SGReadCallbackInstaller readCallbackInstaller;
541 // we get optimal geometry from the loader.
542 struct ACOptimizePolicy : public OptimizeModelPolicy {
543 ACOptimizePolicy(const string& extension) :
544 OptimizeModelPolicy(extension)
546 _osgOptions &= ~Optimizer::TRISTRIP_GEOMETRY;
548 Node* optimize(Node* node, const string& fileName,
549 const ReaderWriter::Options* opt)
551 ref_ptr<Node> optimized
552 = OptimizeModelPolicy::optimize(node, fileName, opt);
553 Group* group = dynamic_cast<Group*>(optimized.get());
554 MatrixTransform* transform
555 = dynamic_cast<MatrixTransform*>(optimized.get());
556 if (((transform && transform->getMatrix().isIdentity()) || group)
557 && group->getName().empty()
558 && group->getNumChildren() == 1) {
559 optimized = static_cast<Node*>(group->getChild(0));
560 group = dynamic_cast<Group*>(optimized.get());
561 if (group && group->getName().empty()
562 && group->getNumChildren() == 1)
563 optimized = static_cast<Node*>(group->getChild(0));
565 return optimized.release();
569 struct ACProcessPolicy {
570 ACProcessPolicy(const string& extension) {}
571 Node* process(Node* node, const string& filename,
572 const ReaderWriter::Options* opt)
578 // XXX Does there need to be a Group node here to trick the
579 // optimizer into optimizing the static transform?
580 osg::Group* root = new Group;
581 MatrixTransform* transform = new MatrixTransform;
582 root->addChild(transform);
584 transform->setDataVariance(Object::STATIC);
585 transform->setMatrix(m);
586 transform->addChild(node);
587 // Ok, this step is questionable.
588 // It is there to have the same visual appearance of ac objects for the
589 // first cut. Osg's ac3d loader will correctly set materials from the
590 // ac file. But the old plib loader used GL_AMBIENT_AND_DIFFUSE for the
591 // materials that in effect igored the ambient part specified in the
592 // file. We emulate that for the first cut here by changing all
593 // ac models here. But in the long term we should use the
594 // unchanged model and fix the input files instead ...
595 SGAcMaterialCrippleVisitor matCriple;
596 root->accept(matCriple);
601 typedef ModelRegistryCallback<ACProcessPolicy, DefaultCachePolicy,
602 ACOptimizePolicy, DefaultCopyPolicy,
603 OSGSubstitutePolicy> ACCallback;
607 ModelRegistryCallbackProxy<ACCallback> g_acRegister("ac");