+// ModelRegistry.hxx -- interface to the OSG model registry
+//
+// Copyright (C) 2005-2007 Mathias Froehlich
+// Copyright (C) 2007 Tim Moore <timoore@redhat.com>
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 2 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+
+#ifdef HAVE_CONFIG_H
+# include <simgear_config.h>
+#endif
+
#include "ModelRegistry.hxx"
-#include <osg/observer_ptr>
+#include <algorithm>
+#include <utility>
+#include <vector>
+
+#include <OpenThreads/ScopedLock>
+
#include <osg/ref_ptr>
#include <osg/Group>
#include <osg/NodeCallback>
#include <simgear/scene/util/SGSceneFeatures.hxx>
#include <simgear/scene/util/SGStateAttributeVisitor.hxx>
#include <simgear/scene/util/SGTextureStateAttributeVisitor.hxx>
+#include <simgear/scene/util/NodeAndDrawableVisitor.hxx>
#include <simgear/structure/exception.hxx>
#include <simgear/props/props.hxx>
#include <simgear/props/props_io.hxx>
#include <simgear/props/condition.hxx>
+#include "BoundingVolumeBuildVisitor.hxx"
+#include "model.hxx"
+#include "SGReaderWriterXMLOptions.hxx"
+
using namespace std;
using namespace osg;
+using namespace osgUtil;
using namespace osgDB;
using namespace simgear;
ref_ptr<Referenced> mReferenced;
};
-// Visitor for
-class SGTextureUpdateVisitor : public SGTextureStateAttributeVisitor {
+// Set the name of a Texture to the simple name of its image
+// file. This can be used to do livery substitution after the image
+// has been deallocated.
+class TextureNameVisitor : public NodeAndDrawableVisitor {
public:
- SGTextureUpdateVisitor(const FilePathList& pathList) :
- mPathList(pathList)
- { }
- Texture2D* textureReplace(int unit,
- StateSet::RefAttributePair& refAttr)
- {
- Texture2D* texture;
- texture = dynamic_cast<Texture2D*>(refAttr.first.get());
- if (!texture)
- return 0;
-
- ref_ptr<Image> image = texture->getImage(0);
- if (!image)
- return 0;
-
- // The currently loaded file name
- string fullFilePath = image->getFileName();
- // The short name
- string fileName = getSimpleFileName(fullFilePath);
- // The name that should be found with the current database path
- string fullLiveryFile = findFileInPath(fileName, mPathList);
- // If they are identical then there is nothing to do
- if (fullLiveryFile == fullFilePath)
- return 0;
-
- image = readImageFile(fullLiveryFile);
- if (!image)
- return 0;
+ TextureNameVisitor(NodeVisitor::TraversalMode tm = NodeVisitor::TRAVERSE_ALL_CHILDREN) :
+ NodeAndDrawableVisitor(tm)
+ {
+ }
- CopyOp copyOp(CopyOp::DEEP_COPY_ALL & ~CopyOp::DEEP_COPY_IMAGES);
- texture = static_cast<Texture2D*>(copyOp(texture));
- if (!texture)
- return 0;
- texture->setImage(image.get());
- return texture;
- }
- virtual void apply(StateSet* stateSet)
- {
- if (!stateSet)
- return;
+ virtual void apply(Node& node)
+ {
+ nameTextures(node.getStateSet());
+ traverse(node);
+ }
- // get a copy that we can safely modify the statesets values.
- StateSet::TextureAttributeList attrList;
- attrList = stateSet->getTextureAttributeList();
- for (unsigned unit = 0; unit < attrList.size(); ++unit) {
- StateSet::AttributeList::iterator i = attrList[unit].begin();
- while (i != attrList[unit].end()) {
- Texture2D* texture = textureReplace(unit, i->second);
- if (texture) {
- stateSet->removeTextureAttribute(unit, i->second.first.get());
- stateSet->setTextureAttribute(unit, texture, i->second.second);
- stateSet->setTextureMode(unit, GL_TEXTURE_2D, StateAttribute::ON);
+ virtual void apply(Drawable& drawable)
+ {
+ nameTextures(drawable.getStateSet());
+ }
+protected:
+ void nameTextures(StateSet* stateSet)
+ {
+ if (!stateSet)
+ return;
+ int numUnits = stateSet->getTextureAttributeList().size();
+ for (int i = 0; i < numUnits; ++i) {
+ StateAttribute* attr
+ = stateSet->getTextureAttribute(i, StateAttribute::TEXTURE);
+ Texture2D* texture = dynamic_cast<Texture2D*>(attr);
+ if (!texture || !texture->getName().empty())
+ continue;
+ const Image *image = texture->getImage();
+ if (!image)
+ continue;
+ texture->setName(image->getFileName());
}
- ++i;
- }
}
- }
-
-private:
- FilePathList mPathList;
};
+
class SGTexCompressionVisitor : public SGTextureStateAttributeVisitor {
public:
virtual void apply(int, StateSet::RefAttributePair& refAttr)
if (!texture)
return;
- // Hmm, true??
- texture->setDataVariance(osg::Object::STATIC);
+ // Do not touch dynamically generated textures.
+ if (texture->getReadPBuffer())
+ return;
+ if (texture->getDataVariance() == osg::Object::DYNAMIC)
+ return;
+ // If no image attached, we assume this one is dynamically generated
Image* image = texture->getImage(0);
if (!image)
return;
texture = dynamic_cast<Texture*>(refAttr.first.get());
if (!texture)
return;
+
+ // Cannot be static if this is a render to texture thing
+ if (texture->getReadPBuffer())
+ return;
+ if (texture->getDataVariance() == osg::Object::DYNAMIC)
+ return;
+ // If no image attached, we assume this one is dynamically generated
+ Image* image = texture->getImage(0);
+ if (!image)
+ return;
texture->setDataVariance(Object::STATIC);
}
-};
-class SGAcMaterialCrippleVisitor : public SGStateAttributeVisitor {
-public:
- virtual void apply(StateSet::RefAttributePair& refAttr)
+ virtual void apply(StateSet* stateSet)
{
- Material* material;
- material = dynamic_cast<Material*>(refAttr.first.get());
- if (!material)
+ if (!stateSet)
return;
- material->setColorMode(Material::AMBIENT_AND_DIFFUSE);
+ stateSet->setDataVariance(Object::STATIC);
+ SGTextureStateAttributeVisitor::apply(stateSet);
}
};
+
} // namespace
+Node* DefaultProcessPolicy::process(Node* node, const string& filename,
+ const ReaderWriter::Options* opt)
+{
+ TextureNameVisitor nameVisitor;
+ node->accept(nameVisitor);
+ return node;
+}
+
ReaderWriter::ReadResult
ModelRegistry::readImage(const string& fileName,
const ReaderWriter::Options* opt)
{
CallbackMap::iterator iter
= imageCallbackMap.find(getFileExtension(fileName));
- if (iter != imageCallbackMap.end() && iter->second.valid())
- return iter->second->readImage(fileName, opt);
- string absFileName = findDataFile(fileName);
- if (!fileExists(absFileName)) {
- SG_LOG(SG_IO, SG_ALERT, "Cannot find image file \""
- << fileName << "\"");
- return ReaderWriter::ReadResult::FILE_NOT_FOUND;
+ {
+ if (iter != imageCallbackMap.end() && iter->second.valid())
+ return iter->second->readImage(fileName, opt);
+ string absFileName = SGModelLib::findDataFile(fileName, opt);
+ if (!fileExists(absFileName)) {
+ SG_LOG(SG_IO, SG_ALERT, "Cannot find image file \""
+ << fileName << "\"");
+ return ReaderWriter::ReadResult::FILE_NOT_FOUND;
+ }
+
+ Registry* registry = Registry::instance();
+ ReaderWriter::ReadResult res;
+ res = registry->readImageImplementation(absFileName, opt);
+ if (!res.success()) {
+ SG_LOG(SG_IO, SG_WARN, "Image loading failed:" << res.message());
+ return res;
+ }
+
+ if (res.loadedFromCache())
+ SG_LOG(SG_IO, SG_BULK, "Returning cached image \""
+ << res.getImage()->getFileName() << "\"");
+ else
+ SG_LOG(SG_IO, SG_BULK, "Reading image \""
+ << res.getImage()->getFileName() << "\"");
+
+ return res;
}
+}
+
+osg::Node* DefaultCachePolicy::find(const string& fileName,
+ const ReaderWriter::Options* opt)
+{
Registry* registry = Registry::instance();
- ReaderWriter::ReadResult res;
- res = registry->readImageImplementation(absFileName, opt);
- if (res.loadedFromCache())
- SG_LOG(SG_IO, SG_INFO, "Returning cached image \""
- << res.getImage()->getFileName() << "\"");
+ osg::Node* cached
+ = dynamic_cast<Node*>(registry->getFromObjectCache(fileName));
+ if (cached)
+ SG_LOG(SG_IO, SG_BULK, "Got cached model \""
+ << fileName << "\"");
else
- SG_LOG(SG_IO, SG_INFO, "Reading image \""
- << res.getImage()->getFileName() << "\"");
+ SG_LOG(SG_IO, SG_BULK, "Reading model \""
+ << fileName << "\"");
+ return cached;
+}
- return res;
+void DefaultCachePolicy::addToCache(const string& fileName,
+ osg::Node* node)
+{
+ Registry::instance()->addEntryToObjectCache(fileName, node);
}
-ReaderWriter::ReadResult
-ModelRegistry::readNode(const string& fileName,
- const ReaderWriter::Options* opt)
+// Optimizations we don't use:
+// Don't use this one. It will break animation names ...
+// opts |= osgUtil::Optimizer::REMOVE_REDUNDANT_NODES;
+//
+// opts |= osgUtil::Optimizer::REMOVE_LOADED_PROXY_NODES;
+// opts |= osgUtil::Optimizer::COMBINE_ADJACENT_LODS;
+// opts |= osgUtil::Optimizer::CHECK_GEOMETRY;
+// opts |= osgUtil::Optimizer::SPATIALIZE_GROUPS;
+// opts |= osgUtil::Optimizer::COPY_SHARED_NODES;
+// opts |= osgUtil::Optimizer::TESSELATE_GEOMETRY;
+// opts |= osgUtil::Optimizer::OPTIMIZE_TEXTURE_SETTINGS;
+
+OptimizeModelPolicy::OptimizeModelPolicy(const string& extension) :
+ _osgOptions(Optimizer::SHARE_DUPLICATE_STATE
+ | Optimizer::MERGE_GEOMETRY
+ | Optimizer::FLATTEN_STATIC_TRANSFORMS
+ | Optimizer::TRISTRIP_GEOMETRY)
{
- Registry* registry = Registry::instance();
- ReaderWriter::ReadResult res;
- Node* cached = 0;
- CallbackMap::iterator iter
- = nodeCallbackMap.find(getFileExtension(fileName));
- if (iter != nodeCallbackMap.end() && iter->second.valid())
- return iter->second->readNode(fileName, opt);
- // First, look for a file with the same name, and the extension
- // ".osg" and, if it exists, load it instead. This allows for
- // substitution of optimized models for ones named in the scenery.
- bool optimizeModel = true;
- string fileSansExtension = getNameLessExtension(fileName);
- string osgFileName = fileSansExtension + ".osg";
- string absFileName = findDataFile(osgFileName);
- // The absolute file name is passed to the reader plugin, which
- // calls findDataFile again... but that's OK, it should find the
- // file by its absolute path straight away.
- if (fileExists(absFileName)) {
- optimizeModel = false;
- } else {
- absFileName = findDataFile(fileName);
- }
- if (!fileExists(absFileName)) {
- SG_LOG(SG_IO, SG_ALERT, "Cannot find model file \""
- << fileName << "\"");
- return ReaderWriter::ReadResult::FILE_NOT_FOUND;
- }
- cached
- = dynamic_cast<Node*>(registry->getFromObjectCache(absFileName));
- if (cached) {
- SG_LOG(SG_IO, SG_INFO, "Got cached model \""
- << absFileName << "\"");
- } else {
- SG_LOG(SG_IO, SG_INFO, "Reading model \""
- << absFileName << "\"");
- res = registry->readNodeImplementation(absFileName, opt);
- if (!res.validNode())
- return res;
-
- bool needTristrip = true;
- if (getLowerCaseFileExtension(fileName) == "ac") {
- // we get optimal geometry from the loader.
- needTristrip = false;
- Matrix m(1, 0, 0, 0,
- 0, 0, 1, 0,
- 0, -1, 0, 0,
- 0, 0, 0, 1);
-
- ref_ptr<Group> root = new Group;
- MatrixTransform* transform = new MatrixTransform;
- root->addChild(transform);
-
- transform->setDataVariance(Object::STATIC);
- transform->setMatrix(m);
- transform->addChild(res.getNode());
-
- res = ReaderWriter::ReadResult(0);
-
- if (optimizeModel) {
- osgUtil::Optimizer optimizer;
- unsigned opts = osgUtil::Optimizer::FLATTEN_STATIC_TRANSFORMS;
- optimizer.optimize(root.get(), opts);
- }
-
- // strip away unneeded groups
- if (root->getNumChildren() == 1 && root->getName().empty()) {
- res = ReaderWriter::ReadResult(root->getChild(0));
- } else
- res = ReaderWriter::ReadResult(root.get());
-
- // Ok, this step is questionable.
- // It is there to have the same visual appearance of ac objects for the
- // first cut. Osg's ac3d loader will correctly set materials from the
- // ac file. But the old plib loader used GL_AMBIENT_AND_DIFFUSE for the
- // materials that in effect igored the ambient part specified in the
- // file. We emulate that for the first cut here by changing all
- // ac models here. But in the long term we should use the
- // unchanged model and fix the input files instead ...
- SGAcMaterialCrippleVisitor matCriple;
- res.getNode()->accept(matCriple);
- }
+}
- if (optimizeModel) {
- osgUtil::Optimizer optimizer;
- unsigned opts = 0;
- // Don't use this one. It will break animation names ...
- // opts |= osgUtil::Optimizer::REMOVE_REDUNDANT_NODES;
-
- // opts |= osgUtil::Optimizer::REMOVE_LOADED_PROXY_NODES;
- // opts |= osgUtil::Optimizer::COMBINE_ADJACENT_LODS;
- // opts |= osgUtil::Optimizer::SHARE_DUPLICATE_STATE;
- opts |= osgUtil::Optimizer::MERGE_GEOMETRY;
- // opts |= osgUtil::Optimizer::CHECK_GEOMETRY;
- // opts |= osgUtil::Optimizer::SPATIALIZE_GROUPS;
- // opts |= osgUtil::Optimizer::COPY_SHARED_NODES;
- opts |= osgUtil::Optimizer::FLATTEN_STATIC_TRANSFORMS;
- if (needTristrip)
- opts |= osgUtil::Optimizer::TRISTRIP_GEOMETRY;
- // opts |= osgUtil::Optimizer::TESSELATE_GEOMETRY;
- // opts |= osgUtil::Optimizer::OPTIMIZE_TEXTURE_SETTINGS;
- optimizer.optimize(res.getNode(), opts);
- }
- // Make sure the data variance of sharable objects is set to STATIC ...
- SGTexDataVarianceVisitor dataVarianceVisitor;
- res.getNode()->accept(dataVarianceVisitor);
- // ... so that textures are now globally shared
- registry->getSharedStateManager()->share(res.getNode());
-
- SGTexCompressionVisitor texComp;
- res.getNode()->accept(texComp);
- cached = res.getNode();
- registry->addEntryToObjectCache(absFileName, cached);
- }
- // Add an extra reference to the model stored in the database.
- // That it to avoid expiring the object from the cache even if it is still
- // in use. Note that the object cache will think that a model is unused
- // if the reference count is 1. If we clone all structural nodes here
- // we need that extra reference to the original object
- SGDatabaseReference* databaseReference;
- databaseReference = new SGDatabaseReference(cached);
- CopyOp::CopyFlags flags = CopyOp::DEEP_COPY_ALL;
- flags &= ~CopyOp::DEEP_COPY_TEXTURES;
- flags &= ~CopyOp::DEEP_COPY_IMAGES;
- flags &= ~CopyOp::DEEP_COPY_ARRAYS;
- flags &= ~CopyOp::DEEP_COPY_PRIMITIVES;
- // This will safe display lists ...
- flags &= ~CopyOp::DEEP_COPY_DRAWABLES;
- flags &= ~CopyOp::DEEP_COPY_SHAPES;
- res = ReaderWriter::ReadResult(CopyOp(flags)(cached));
- res.getNode()->addObserver(databaseReference);
-
- // Update liveries
- SGTextureUpdateVisitor liveryUpdate(getDataFilePathList());
- res.getNode()->accept(liveryUpdate);
-
- // Make sure the data variance of sharable objects is set to STATIC ...
+osg::Node* OptimizeModelPolicy::optimize(osg::Node* node,
+ const string& fileName,
+ const osgDB::ReaderWriter::Options* opt)
+{
+ osgUtil::Optimizer optimizer;
+ optimizer.optimize(node, _osgOptions);
+
+ // Make sure the data variance of sharable objects is set to
+ // STATIC so that textures will be globally shared.
SGTexDataVarianceVisitor dataVarianceVisitor;
- res.getNode()->accept(dataVarianceVisitor);
- // ... so that textures are now globally shared
- registry->getOrCreateSharedStateManager()->share(res.getNode(), 0);
+ node->accept(dataVarianceVisitor);
+
+ SGTexCompressionVisitor texComp;
+ node->accept(texComp);
+ return node;
+}
+
+string OSGSubstitutePolicy::substitute(const string& name,
+ const ReaderWriter::Options* opt)
+{
+ string fileSansExtension = getNameLessExtension(name);
+ string osgFileName = fileSansExtension + ".osg";
+ string absFileName = SGModelLib::findDataFile(osgFileName, opt);
+ return absFileName;
+}
+
+
+void
+BuildLeafBVHPolicy::buildBVH(const std::string& fileName, osg::Node* node)
+{
+ SG_LOG(SG_IO, SG_BULK, "Building leaf attached boundingvolume tree for \""
+ << fileName << "\".");
+ BoundingVolumeBuildVisitor bvBuilder(true);
+ node->accept(bvBuilder);
+}
+
+void
+BuildGroupBVHPolicy::buildBVH(const std::string& fileName, osg::Node* node)
+{
+ SG_LOG(SG_IO, SG_BULK, "Building group attached boundingvolume tree for \""
+ << fileName << "\".");
+ BoundingVolumeBuildVisitor bvBuilder(false);
+ node->accept(bvBuilder);
+}
- return res;
+void
+NoBuildBVHPolicy::buildBVH(const std::string& fileName, osg::Node*)
+{
+ SG_LOG(SG_IO, SG_BULK, "Omitting boundingvolume tree for \""
+ << fileName << "\".");
+}
+
+ModelRegistry::ModelRegistry() :
+ _defaultCallback(new DefaultCallback(""))
+{
}
void
nodeCallbackMap.insert(CallbackMap::value_type(extension, callback));
}
-ref_ptr<ModelRegistry> ModelRegistry::instance;
-
-ModelRegistry* ModelRegistry::getInstance()
-
+ReaderWriter::ReadResult
+ModelRegistry::readNode(const string& fileName,
+ const ReaderWriter::Options* opt)
{
- if (!instance.valid())
- instance = new ModelRegistry;
- return instance.get();
+ ReaderWriter::ReadResult res;
+ CallbackMap::iterator iter
+ = nodeCallbackMap.find(getFileExtension(fileName));
+ ReaderWriter::ReadResult result;
+ if (iter != nodeCallbackMap.end() && iter->second.valid())
+ result = iter->second->readNode(fileName, opt);
+ else
+ result = _defaultCallback->readNode(fileName, opt);
+
+ return result;
}
class SGReadCallbackInstaller {
Registry* registry = Registry::instance();
ReaderWriter::Options* options = new ReaderWriter::Options;
- // We manage node caching ourselves
- int cacheOptions = ReaderWriter::Options::CACHE_ALL
- & ~ReaderWriter::Options::CACHE_NODES;
+ int cacheOptions = ReaderWriter::Options::CACHE_ALL;
options->
setObjectCacheHint((ReaderWriter::Options::CacheHintOptions)cacheOptions);
registry->setOptions(options);
registry->getOrCreateSharedStateManager()->
- setShareMode(SharedStateManager::SHARE_TEXTURES);
- registry->setReadFileCallback(ModelRegistry::getInstance());
+ setShareMode(SharedStateManager::SHARE_STATESETS);
+ registry->setReadFileCallback(ModelRegistry::instance());
}
};
static SGReadCallbackInstaller readCallbackInstaller;
-ReaderWriter::ReadResult
-OSGFileCallback::readImage(const string& fileName,
- const ReaderWriter::Options* opt)
-{
- return Registry::instance()->readImageImplementation(fileName, opt);
-}
+// we get optimal geometry from the loader (Hah!).
+struct ACOptimizePolicy : public OptimizeModelPolicy {
+ ACOptimizePolicy(const string& extension) :
+ OptimizeModelPolicy(extension)
+ {
+ _osgOptions &= ~Optimizer::TRISTRIP_GEOMETRY;
+ }
+ Node* optimize(Node* node, const string& fileName,
+ const ReaderWriter::Options* opt)
+ {
+ ref_ptr<Node> optimized
+ = OptimizeModelPolicy::optimize(node, fileName, opt);
+ Group* group = dynamic_cast<Group*>(optimized.get());
+ MatrixTransform* transform
+ = dynamic_cast<MatrixTransform*>(optimized.get());
+ if (((transform && transform->getMatrix().isIdentity()) || group)
+ && group->getName().empty()
+ && group->getNumChildren() == 1) {
+ optimized = static_cast<Node*>(group->getChild(0));
+ group = dynamic_cast<Group*>(optimized.get());
+ if (group && group->getName().empty()
+ && group->getNumChildren() == 1)
+ optimized = static_cast<Node*>(group->getChild(0));
+ }
+ const SGReaderWriterXMLOptions* sgopt
+ = dynamic_cast<const SGReaderWriterXMLOptions*>(opt);
+ if (sgopt && sgopt->getInstantiateEffects())
+ optimized = instantiateEffects(optimized.get(), sgopt);
+ return optimized.release();
+ }
+};
-ReaderWriter::ReadResult
-OSGFileCallback::readNode(const string& fileName,
- const ReaderWriter::Options* opt)
+struct ACProcessPolicy {
+ ACProcessPolicy(const string& extension) {}
+ Node* process(Node* node, const string& filename,
+ const ReaderWriter::Options* opt)
+ {
+ Matrix m(1, 0, 0, 0,
+ 0, 0, 1, 0,
+ 0, -1, 0, 0,
+ 0, 0, 0, 1);
+ // XXX Does there need to be a Group node here to trick the
+ // optimizer into optimizing the static transform?
+ osg::Group* root = new Group;
+ MatrixTransform* transform = new MatrixTransform;
+ root->addChild(transform);
+
+ transform->setDataVariance(Object::STATIC);
+ transform->setMatrix(m);
+ transform->addChild(node);
+
+ return root;
+ }
+};
+
+typedef ModelRegistryCallback<ACProcessPolicy, DefaultCachePolicy,
+ ACOptimizePolicy,
+ OSGSubstitutePolicy, BuildLeafBVHPolicy>
+ACCallback;
+
+namespace
{
- return Registry::instance()->readNodeImplementation(fileName, opt);
+ModelRegistryCallbackProxy<ACCallback> g_acRegister("ac");
}
projects / simgear.git / blobdiff