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.
19 #include "ModelRegistry.hxx"
25 #include <OpenThreads/ScopedLock>
27 #include <osg/observer_ptr>
28 #include <osg/ref_ptr>
30 #include <osg/NodeCallback>
32 #include <osg/Material>
33 #include <osg/MatrixTransform>
34 #include <osgDB/Archive>
35 #include <osgDB/FileNameUtils>
36 #include <osgDB/FileUtils>
37 #include <osgDB/ReadFile>
38 #include <osgDB/WriteFile>
39 #include <osgDB/Registry>
40 #include <osgDB/SharedStateManager>
41 #include <osgUtil/Optimizer>
43 #include <simgear/scene/util/SGSceneFeatures.hxx>
44 #include <simgear/scene/util/SGStateAttributeVisitor.hxx>
45 #include <simgear/scene/util/SGTextureStateAttributeVisitor.hxx>
46 #include <simgear/scene/util/NodeAndDrawableVisitor.hxx>
48 #include <simgear/structure/exception.hxx>
49 #include <simgear/props/props.hxx>
50 #include <simgear/props/props_io.hxx>
51 #include <simgear/props/condition.hxx>
55 using namespace osgUtil;
56 using namespace osgDB;
57 using namespace simgear;
59 using OpenThreads::ReentrantMutex;
60 using OpenThreads::ScopedLock;
62 // Little helper class that holds an extra reference to a
64 // Since we clone all structural nodes from our 3d models,
65 // the database pager will only see one single reference to
66 // top node of the model and expire it relatively fast.
67 // We attach that extra reference to every model cloned from
68 // a base model in the pager. When that cloned model is deleted
69 // this extra reference is deleted too. So if there are no
70 // cloned models left the model will expire.
72 class SGDatabaseReference : public Observer {
74 SGDatabaseReference(Referenced* referenced) :
75 mReferenced(referenced)
77 virtual void objectDeleted(void*)
82 ref_ptr<Referenced> mReferenced;
85 // Set the name of a Texture to the simple name of its image
86 // file. This can be used to do livery substitution after the image
87 // has been deallocated.
88 class TextureNameVisitor : public NodeAndDrawableVisitor {
90 TextureNameVisitor(NodeVisitor::TraversalMode tm = NodeVisitor::TRAVERSE_ALL_CHILDREN) :
91 NodeAndDrawableVisitor(tm)
95 virtual void apply(Node& node)
97 nameTextures(node.getStateSet());
101 virtual void apply(Drawable& drawable)
103 nameTextures(drawable.getStateSet());
106 void nameTextures(StateSet* stateSet)
110 int numUnits = stateSet->getTextureAttributeList().size();
111 for (int i = 0; i < numUnits; ++i) {
113 = stateSet->getTextureAttribute(i, StateAttribute::TEXTURE);
114 Texture2D* texture = dynamic_cast<Texture2D*>(attr);
115 if (!texture || !texture->getName().empty())
117 const Image *image = texture->getImage();
120 texture->setName(image->getFileName());
125 // Change the StateSets of a model to hold different textures based on
128 class TextureUpdateVisitor : public NodeAndDrawableVisitor {
130 TextureUpdateVisitor(const FilePathList& pathList) :
131 NodeAndDrawableVisitor(NodeVisitor::TRAVERSE_ALL_CHILDREN),
136 virtual void apply(Node& node)
138 StateSet* stateSet = cloneStateSet(node.getStateSet());
140 node.setStateSet(stateSet);
144 virtual void apply(Drawable& drawable)
146 StateSet* stateSet = cloneStateSet(drawable.getStateSet());
148 drawable.setStateSet(stateSet);
150 // Copied from Mathias' earlier SGTextureUpdateVisitor
152 Texture2D* textureReplace(int unit, const StateAttribute* attr)
154 const Texture2D* texture = dynamic_cast<const Texture2D*>(attr);
159 const Image* image = texture->getImage();
160 const string* fullFilePath = 0;
162 // The currently loaded file name
163 fullFilePath = &image->getFileName();
166 fullFilePath = &texture->getName();
169 string fileName = getSimpleFileName(*fullFilePath);
170 if (fileName.empty())
172 // The name that should be found with the current database path
173 string fullLiveryFile = findFileInPath(fileName, _pathList);
174 // If it is empty or they are identical then there is nothing to do
175 if (fullLiveryFile.empty() || fullLiveryFile == *fullFilePath)
177 Image* newImage = readImageFile(fullLiveryFile);
180 CopyOp copyOp(CopyOp::DEEP_COPY_ALL & ~CopyOp::DEEP_COPY_IMAGES);
181 Texture2D* newTexture = static_cast<Texture2D*>(copyOp(texture));
185 newTexture->setImage(newImage);
190 StateSet* cloneStateSet(const StateSet* stateSet)
192 typedef pair<int, Texture2D*> Tex2D;
193 vector<Tex2D> newTextures;
194 StateSet* result = 0;
198 int numUnits = stateSet->getTextureAttributeList().size();
200 for (int i = 0; i < numUnits; ++i) {
201 const StateAttribute* attr
202 = stateSet->getTextureAttribute(i, StateAttribute::TEXTURE);
203 Texture2D* newTexture = textureReplace(i, attr);
205 newTextures.push_back(Tex2D(i, newTexture));
207 if (!newTextures.empty()) {
208 result = static_cast<StateSet*>(stateSet->clone(CopyOp()));
209 for (vector<Tex2D>::iterator i = newTextures.begin();
210 i != newTextures.end();
212 result->setTextureAttribute(i->first, i->second);
219 FilePathList _pathList;
223 class SGTexCompressionVisitor : public SGTextureStateAttributeVisitor {
225 virtual void apply(int, StateSet::RefAttributePair& refAttr)
228 texture = dynamic_cast<Texture2D*>(refAttr.first.get());
233 texture->setDataVariance(osg::Object::STATIC);
235 Image* image = texture->getImage(0);
242 if (s <= t && 32 <= s) {
243 SGSceneFeatures::instance()->setTextureCompression(texture);
244 } else if (t < s && 32 <= t) {
245 SGSceneFeatures::instance()->setTextureCompression(texture);
250 class SGTexDataVarianceVisitor : public SGTextureStateAttributeVisitor {
252 virtual void apply(int, StateSet::RefAttributePair& refAttr)
255 texture = dynamic_cast<Texture*>(refAttr.first.get());
259 texture->setDataVariance(Object::STATIC);
262 virtual void apply(StateSet* stateSet)
266 SGTextureStateAttributeVisitor::apply(stateSet);
267 stateSet->setDataVariance(Object::STATIC);
271 class SGAcMaterialCrippleVisitor : public SGStateAttributeVisitor {
273 virtual void apply(StateSet::RefAttributePair& refAttr)
276 material = dynamic_cast<Material*>(refAttr.first.get());
279 material->setColorMode(Material::AMBIENT_AND_DIFFUSE);
283 // Work around an OSG bug - the file loaders don't use the file path
284 // in options while the file is being loaded.
286 struct OptionsPusher {
287 FilePathList localPathList;
289 OptionsPusher(const ReaderWriter::Options* options):
294 Registry* registry = Registry::instance();
295 localPathList = registry->getDataFilePathList();
296 const FilePathList& regPathList = registry->getDataFilePathList();
297 const FilePathList& optionsPathList = options->getDatabasePathList();
298 for (FilePathList::const_iterator iter = optionsPathList.begin();
299 iter != optionsPathList.end();
301 if (find(regPathList.begin(), regPathList.end(), *iter)
302 == regPathList.end())
303 localPathList.push_back(*iter);
305 // Save the current Registry path list and install the augmented one.
306 localPathList.swap(registry->getDataFilePathList());
311 // Restore the old path list
313 localPathList.swap(Registry::instance()->getDataFilePathList());
318 Node* DefaultProcessPolicy::process(Node* node, const string& filename,
319 const ReaderWriter::Options* opt)
321 TextureNameVisitor nameVisitor;
322 node->accept(nameVisitor);
326 ReaderWriter::ReadResult
327 ModelRegistry::readImage(const string& fileName,
328 const ReaderWriter::Options* opt)
330 ScopedLock<ReentrantMutex> lock(readerMutex);
331 CallbackMap::iterator iter
332 = imageCallbackMap.find(getFileExtension(fileName));
333 // XXX Workaround for OSG plugin bug
335 OptionsPusher pusher(opt);
336 if (iter != imageCallbackMap.end() && iter->second.valid())
337 return iter->second->readImage(fileName, opt);
338 string absFileName = findDataFile(fileName);
339 if (!fileExists(absFileName)) {
340 SG_LOG(SG_IO, SG_ALERT, "Cannot find image file \""
341 << fileName << "\"");
342 return ReaderWriter::ReadResult::FILE_NOT_FOUND;
345 Registry* registry = Registry::instance();
346 ReaderWriter::ReadResult res;
347 res = registry->readImageImplementation(absFileName, opt);
348 if (!res.success()) {
349 SG_LOG(SG_IO, SG_WARN, "Image loading failed:" << res.message());
353 if (res.loadedFromCache())
354 SG_LOG(SG_IO, SG_INFO, "Returning cached image \""
355 << res.getImage()->getFileName() << "\"");
357 SG_LOG(SG_IO, SG_INFO, "Reading image \""
358 << res.getImage()->getFileName() << "\"");
365 osg::Node* DefaultCachePolicy::find(const string& fileName,
366 const ReaderWriter::Options* opt)
368 Registry* registry = Registry::instance();
370 = dynamic_cast<Node*>(registry->getFromObjectCache(fileName));
372 SG_LOG(SG_IO, SG_INFO, "Got cached model \""
373 << fileName << "\"");
375 SG_LOG(SG_IO, SG_INFO, "Reading model \""
376 << fileName << "\"");
380 void DefaultCachePolicy::addToCache(const string& fileName,
383 Registry::instance()->addEntryToObjectCache(fileName, node);
386 // Optimizations we don't use:
387 // Don't use this one. It will break animation names ...
388 // opts |= osgUtil::Optimizer::REMOVE_REDUNDANT_NODES;
390 // opts |= osgUtil::Optimizer::REMOVE_LOADED_PROXY_NODES;
391 // opts |= osgUtil::Optimizer::COMBINE_ADJACENT_LODS;
392 // opts |= osgUtil::Optimizer::CHECK_GEOMETRY;
393 // opts |= osgUtil::Optimizer::SPATIALIZE_GROUPS;
394 // opts |= osgUtil::Optimizer::COPY_SHARED_NODES;
395 // opts |= osgUtil::Optimizer::TESSELATE_GEOMETRY;
396 // opts |= osgUtil::Optimizer::OPTIMIZE_TEXTURE_SETTINGS;
398 OptimizeModelPolicy::OptimizeModelPolicy(const string& extension) :
399 _osgOptions(Optimizer::SHARE_DUPLICATE_STATE
400 | Optimizer::MERGE_GEOMETRY
401 | Optimizer::FLATTEN_STATIC_TRANSFORMS
402 | Optimizer::TRISTRIP_GEOMETRY)
406 osg::Node* OptimizeModelPolicy::optimize(osg::Node* node,
407 const string& fileName,
408 const osgDB::ReaderWriter::Options* opt)
410 osgUtil::Optimizer optimizer;
411 optimizer.optimize(node, _osgOptions);
413 // Make sure the data variance of sharable objects is set to
414 // STATIC so that textures will be globally shared.
415 SGTexDataVarianceVisitor dataVarianceVisitor;
416 node->accept(dataVarianceVisitor);
418 SGTexCompressionVisitor texComp;
419 node->accept(texComp);
423 osg::Node* DefaultCopyPolicy::copy(osg::Node* model, const string& fileName,
424 const osgDB::ReaderWriter::Options* opt)
426 // Add an extra reference to the model stored in the database.
427 // That it to avoid expiring the object from the cache even if it is still
428 // in use. Note that the object cache will think that a model is unused
429 // if the reference count is 1. If we clone all structural nodes here
430 // we need that extra reference to the original object
431 SGDatabaseReference* databaseReference;
432 databaseReference = new SGDatabaseReference(model);
433 CopyOp::CopyFlags flags = CopyOp::DEEP_COPY_ALL;
434 flags &= ~CopyOp::DEEP_COPY_TEXTURES;
435 flags &= ~CopyOp::DEEP_COPY_IMAGES;
436 flags &= ~CopyOp::DEEP_COPY_STATESETS;
437 flags &= ~CopyOp::DEEP_COPY_STATEATTRIBUTES;
438 flags &= ~CopyOp::DEEP_COPY_ARRAYS;
439 flags &= ~CopyOp::DEEP_COPY_PRIMITIVES;
440 // This will safe display lists ...
441 flags &= ~CopyOp::DEEP_COPY_DRAWABLES;
442 flags &= ~CopyOp::DEEP_COPY_SHAPES;
443 osg::Node* res = CopyOp(flags)(model);
444 res->addObserver(databaseReference);
447 TextureUpdateVisitor liveryUpdate(opt->getDatabasePathList());
448 res->accept(liveryUpdate);
453 string OSGSubstitutePolicy::substitute(const string& name,
454 const ReaderWriter::Options* opt)
456 string fileSansExtension = getNameLessExtension(name);
457 string osgFileName = fileSansExtension + ".osg";
458 string absFileName = findDataFile(osgFileName, opt);
462 ModelRegistry::ModelRegistry() :
463 _defaultCallback(new DefaultCallback(""))
468 ModelRegistry::addImageCallbackForExtension(const string& extension,
469 Registry::ReadFileCallback* callback)
471 imageCallbackMap.insert(CallbackMap::value_type(extension, callback));
475 ModelRegistry::addNodeCallbackForExtension(const string& extension,
476 Registry::ReadFileCallback* callback)
478 nodeCallbackMap.insert(CallbackMap::value_type(extension, callback));
481 ReaderWriter::ReadResult
482 ModelRegistry::readNode(const string& fileName,
483 const ReaderWriter::Options* opt)
485 ScopedLock<ReentrantMutex> lock(readerMutex);
486 // XXX Workaround for OSG plugin bug.
487 OptionsPusher pusher(opt);
488 Registry* registry = Registry::instance();
489 ReaderWriter::ReadResult res;
491 CallbackMap::iterator iter
492 = nodeCallbackMap.find(getFileExtension(fileName));
493 if (iter != nodeCallbackMap.end() && iter->second.valid())
494 return iter->second->readNode(fileName, opt);
495 return _defaultCallback->readNode(fileName, opt);
498 class SGReadCallbackInstaller {
500 SGReadCallbackInstaller()
502 // XXX I understand why we want this, but this seems like a weird
503 // place to set this option.
504 Referenced::setThreadSafeReferenceCounting(true);
506 Registry* registry = Registry::instance();
507 ReaderWriter::Options* options = new ReaderWriter::Options;
508 int cacheOptions = ReaderWriter::Options::CACHE_ALL;
510 setObjectCacheHint((ReaderWriter::Options::CacheHintOptions)cacheOptions);
511 registry->setOptions(options);
512 registry->getOrCreateSharedStateManager()->
513 setShareMode(SharedStateManager::SHARE_STATESETS);
514 registry->setReadFileCallback(ModelRegistry::instance());
518 static SGReadCallbackInstaller readCallbackInstaller;
520 // we get optimal geometry from the loader.
521 struct ACOptimizePolicy : public OptimizeModelPolicy {
522 ACOptimizePolicy(const string& extension) :
523 OptimizeModelPolicy(extension)
525 _osgOptions &= ~Optimizer::TRISTRIP_GEOMETRY;
527 Node* optimize(Node* node, const string& fileName,
528 const ReaderWriter::Options* opt)
530 ref_ptr<Node> optimized
531 = OptimizeModelPolicy::optimize(node, fileName, opt);
532 MatrixTransform* transform
533 = dynamic_cast<MatrixTransform*>(optimized.get());
534 if (transform && transform->getMatrix().isIdentity()
535 && transform->getName().empty()
536 && transform->getNumChildren() == 1) {
537 optimized = static_cast<Node*>(transform->getChild(0));
538 Group* group = dynamic_cast<Group*>(optimized.get());
539 if (group && group->getName().empty()
540 && group->getNumChildren() == 1)
541 optimized = static_cast<Node*>(group->getChild(0));
543 return optimized.release();
547 struct ACProcessPolicy {
548 ACProcessPolicy(const string& extension) {}
549 Node* process(Node* node, const string& filename,
550 const ReaderWriter::Options* opt)
556 // XXX Does there need to be a Group node here to trick the
557 // optimizer into optimizing the static transform?
558 osg::Group* root = new Group;
559 MatrixTransform* transform = new MatrixTransform;
560 root->addChild(transform);
562 transform->setDataVariance(Object::STATIC);
563 transform->setMatrix(m);
564 transform->addChild(node);
565 // Ok, this step is questionable.
566 // It is there to have the same visual appearance of ac objects for the
567 // first cut. Osg's ac3d loader will correctly set materials from the
568 // ac file. But the old plib loader used GL_AMBIENT_AND_DIFFUSE for the
569 // materials that in effect igored the ambient part specified in the
570 // file. We emulate that for the first cut here by changing all
571 // ac models here. But in the long term we should use the
572 // unchanged model and fix the input files instead ...
573 SGAcMaterialCrippleVisitor matCriple;
574 root->accept(matCriple);
579 typedef ModelRegistryCallback<ACProcessPolicy, DefaultCachePolicy,
580 ACOptimizePolicy, DefaultCopyPolicy,
581 OSGSubstitutePolicy> ACCallback;
585 ModelRegistryCallbackProxy<ACCallback> g_acRegister("ac");