# include <simgear_config.h>
#endif
+#include <algorithm>
+//yuck
+#include <cstring>
+
+#include <boost/bind.hpp>
+
+#include <osg/Geode>
#include <osg/MatrixTransform>
#include <osgDB/WriteFile>
#include <osgDB/Registry>
#include "animation.hxx"
#include "particles.hxx"
#include "model.hxx"
+#include "SGText.hxx"
+#include "SGMaterialAnimation.hxx"
-#include "SGReaderWriterXMLOptions.hxx"
-#include "SGReaderWriterXML.hxx"
-
+using namespace std;
using namespace simgear;
+using namespace osg;
static osg::Node *
-sgLoad3DModel_internal(const string &path,
- SGPropertyNode *prop_root,
- SGModelData *data = 0,
- osg::Node *(*load_panel)(SGPropertyNode *) = 0,
+sgLoad3DModel_internal(const std::string& path,
+ const osgDB::ReaderWriter::Options* options,
SGPropertyNode *overlay = 0);
SGReaderWriterXML::readNode(const std::string& fileName,
const osgDB::ReaderWriter::Options* options) const
{
- // SG_LOG(SG_GENERAL, SG_ALERT, "SGReaderWriterXML::readNode(" << fileName << ")");
-
- const SGReaderWriterXMLOptions* xmlOptions
- = dynamic_cast<const SGReaderWriterXMLOptions*>(options);
-
- SGSharedPtr<SGPropertyNode> prop_root;
- osg::Node *(*load_panel)(SGPropertyNode *)=0;
- SGModelData *model_data=0;
-
- if (xmlOptions) {
- prop_root = xmlOptions->getPropRoot();
- load_panel = xmlOptions->getLoadPanel();
- model_data = xmlOptions->getModelData();
- }
- if (!prop_root) {
- prop_root = new SGPropertyNode;
- }
-
osg::Node *result=0;
-
try {
- result=sgLoad3DModel_internal(fileName, prop_root, model_data, load_panel);
+ result=sgLoad3DModel_internal(fileName, options);
} catch (const sg_throwable &t) {
SG_LOG(SG_INPUT, SG_ALERT, "Failed to load model: " << t.getFormattedMessage());
result=new osg::Node;
SGSharedPtr<SGCondition> mCondition;
};
+
+// Little helper class that holds an extra reference to a
+// loaded 3d model.
+// Since we clone all structural nodes from our 3d models,
+// the database pager will only see one single reference to
+// top node of the model and expire it relatively fast.
+// We attach that extra reference to every model cloned from
+// a base model in the pager. When that cloned model is deleted
+// this extra reference is deleted too. So if there are no
+// cloned models left the model will expire.
+namespace {
+class SGDatabaseReference : public osg::Observer
+{
+public:
+ SGDatabaseReference(osg::Referenced* referenced) :
+ mReferenced(referenced)
+ { }
+ virtual void objectDeleted(void*)
+ {
+ mReferenced = 0;
+ }
+private:
+ osg::ref_ptr<osg::Referenced> mReferenced;
+};
+
+void makeEffectAnimations(PropertyList& animation_nodes,
+ PropertyList& effect_nodes)
+{
+ for (PropertyList::iterator itr = animation_nodes.begin();
+ itr != animation_nodes.end();
+ ++itr) {
+ SGPropertyNode_ptr effectProp;
+ SGPropertyNode* animProp = itr->ptr();
+ SGPropertyNode* typeProp = animProp->getChild("type");
+ if (!typeProp)
+ continue;
+ const char* typeString = typeProp->getStringValue();
+ if (!strcmp(typeString, "material")) {
+ effectProp
+ = SGMaterialAnimation::makeEffectProperties(animProp);
+ } else if (!strcmp(typeString, "shader")) {
+
+ SGPropertyNode* shaderProp = animProp->getChild("shader");
+ if (!shaderProp || strcmp(shaderProp->getStringValue(), "chrome"))
+ continue;
+ *itr = 0; // effect replaces animation
+ SGPropertyNode* textureProp = animProp->getChild("texture");
+ if (!textureProp)
+ continue;
+ effectProp = new SGPropertyNode();
+ makeChild(effectProp.ptr(), "inherits-from")
+ ->setValue("Effects/chrome");
+ SGPropertyNode* paramsProp = makeChild(effectProp.get(), "parameters");
+ makeChild(paramsProp, "chrome-texture")
+ ->setValue(textureProp->getStringValue());
+ }
+ if (effectProp.valid()) {
+ PropertyList objectNameNodes = animProp->getChildren("object-name");
+ for (PropertyList::iterator objItr = objectNameNodes.begin(),
+ end = objectNameNodes.end();
+ objItr != end;
+ ++objItr)
+ effectProp->addChild("object-name")
+ ->setStringValue((*objItr)->getStringValue());
+ effect_nodes.push_back(effectProp);
+
+ }
+ }
+ animation_nodes.erase(remove_if(animation_nodes.begin(),
+ animation_nodes.end(),
+ !boost::bind(&SGPropertyNode_ptr::valid,
+ _1)),
+ animation_nodes.end());
+}
+}
+
static osg::Node *
sgLoad3DModel_internal(const string &path,
- SGPropertyNode *prop_root,
- SGModelData *data,
- osg::Node *(*load_panel)(SGPropertyNode *),
+ const osgDB::ReaderWriter::Options* options_,
SGPropertyNode *overlay)
{
- if ( !prop_root ) {
- SG_LOG(SG_GENERAL, SG_ALERT, "prop_root NULL: " << path);
+ const SGReaderWriterXMLOptions* xmlOptions;
+ xmlOptions = dynamic_cast<const SGReaderWriterXMLOptions*>(options_);
+
+ SGSharedPtr<SGPropertyNode> prop_root;
+ osg::Node *(*load_panel)(SGPropertyNode *)=0;
+ osg::ref_ptr<SGModelData> data;
+
+ if (xmlOptions) {
+ prop_root = xmlOptions->getPropRoot();
+ load_panel = xmlOptions->getLoadPanel();
+ data = xmlOptions->getModelData();
+ }
+ if (!prop_root) {
+ prop_root = new SGPropertyNode;
}
osgDB::FilePathList filePathList;
filePathList = osgDB::Registry::instance()->getDataFilePathList();
- filePathList.push_front(osgDB::convertFileNameToNativeStyle("/"));
+ filePathList.push_front(std::string());
SGPath modelpath = osgDB::findFileInPath(path, filePathList);
if (modelpath.str().empty()) {
SGPropertyNode *mp = props->getNode("multiplay");
if (mp && prop_root && prop_root->getParent())
copyProperties(mp, prop_root);
+ } else {
+ SG_LOG(SG_INPUT, SG_DEBUG, "model without wrapper: "
+ << modelpath.str());
}
osg::ref_ptr<SGReaderWriterXMLOptions> options
- = new SGReaderWriterXMLOptions(*osgDB::Registry::instance()->getOptions());
+ = new SGReaderWriterXMLOptions(*options_);
+ options->setPropRoot(prop_root);
+ options->setLoadPanel(load_panel);
// Assume that textures are in
// the same location as the XML file.
if (!model) {
- if (texturepath.extension() != "")
+ if (!texturepath.extension().empty())
texturepath = texturepath.dir();
options->setDatabasePath(texturepath.str());
- model = osgDB::readNodeFile(modelpath.str(), options.get());
- if (model == 0)
+ osgDB::ReaderWriter::ReadResult modelResult
+ = osgDB::Registry::instance()->readNode(modelpath.str(),
+ options.get());
+ if (!modelResult.validNode())
throw sg_io_exception("Failed to load 3D model",
sg_location(modelpath.str()));
+ model = copyModel(modelResult.getNode());
+ // Add an extra reference to the model stored in the database.
+ // That is 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(modelResult.getNode());
+ model->addObserver(databaseReference);
+
+ // Update liveries
+ TextureUpdateVisitor liveryUpdate(options->getDatabasePathList());
+ model->accept(liveryUpdate);
+
+ // Copy the userdata fields, still sharing the boundingvolumes,
+ // but introducing new data for velocities.
+ UserDataCopyVisitor userDataCopyVisitor;
+ model->accept(userDataCopyVisitor);
}
model->setName(modelpath.str());
if (offsets) {
needTransform=true;
osg::MatrixTransform *alignmainmodel = new osg::MatrixTransform;
+ alignmainmodel->setDataVariance(osg::Object::STATIC);
osg::Matrix res_matrix;
res_matrix.makeRotate(
offsets->getFloatValue("pitch-deg", 0.0)*SG_DEGREES_TO_RADIANS,
SGPath submodelpath;
osg::ref_ptr<osg::Node> submodel;
string submodelFileName = sub_props->getStringValue("path");
- if ( submodelFileName.size() > 2 && submodelFileName.substr( 0, 2 ) == "./" ) {
+ if (submodelFileName.size() > 2
+ && !submodelFileName.compare(0, 2, "./" )) {
submodelpath = modelpath.dir();
submodelpath.append( submodelFileName.substr( 2 ) );
} else {
submodelpath = submodelFileName;
}
+ osg::ref_ptr<SGReaderWriterXMLOptions> options;
+ options = new SGReaderWriterXMLOptions(*options_);
+ options->setPropRoot(prop_root);
+ options->setLoadPanel(load_panel);
try {
- submodel = sgLoad3DModel_internal(submodelpath.str(), prop_root, 0, load_panel,
+ submodel = sgLoad3DModel_internal(submodelpath.str(), options.get(),
sub_props->getNode("overlay"));
} catch (const sg_throwable &t) {
SG_LOG(SG_INPUT, SG_ALERT, "Failed to load submodel: " << t.getFormattedMessage());
throw;
}
- osg::ref_ptr<osg::Node> submodel_final=submodel.get();
+ osg::ref_ptr<osg::Node> submodel_final = submodel;
SGPropertyNode *offs = sub_props->getNode("offsets", false);
if (offs) {
osg::Matrix res_matrix;
osg::ref_ptr<osg::MatrixTransform> align = new osg::MatrixTransform;
+ align->setDataVariance(osg::Object::STATIC);
res_matrix.makeIdentity();
res_matrix.makeRotate(
offs->getDoubleValue("pitch-deg", 0.0)*SG_DEGREES_TO_RADIANS,
offs->getDoubleValue("z-m", 0));
align->setMatrix(res_matrix*tmat);
align->addChild(submodel.get());
- submodel_final=align.get();
+ submodel_final = align;
}
submodel_final->setName(sub_props->getStringValue("name", ""));
SG_LOG(SG_INPUT, SG_DEBUG, "Loading a panel");
osg::ref_ptr<osg::Node> panel = load_panel(panel_nodes[i]);
if (panel_nodes[i]->hasValue("name"))
- panel->setName((char *)panel_nodes[i]->getStringValue("name"));
+ panel->setName(panel_nodes[i]->getStringValue("name"));
group->addChild(panel.get());
}
}
particle_nodes = props->getChildren("particlesystem");
for (unsigned i = 0; i < particle_nodes.size(); ++i) {
if (i==0) {
- if (texturepath.extension() != "")
+ if (!texturepath.extension().empty())
texturepath = texturepath.dir();
options->setDatabasePath(texturepath.str());
options.get()));
}
- if (data) {
- options->setModelData(data);
+ std::vector<SGPropertyNode_ptr> text_nodes;
+ text_nodes = props->getChildren("text");
+ for (unsigned i = 0; i < text_nodes.size(); ++i) {
+ group->addChild(SGText::appendText(text_nodes[i],
+ prop_root,
+ options.get()));
+ }
+ PropertyList effect_nodes = props->getChildren("effect");
+ PropertyList animation_nodes = props->getChildren("animation");
+ // Some material animations (eventually all) are actually effects.
+ makeEffectAnimations(animation_nodes, effect_nodes);
+ {
+ ref_ptr<Node> modelWithEffects
+ = instantiateEffects(group.get(), effect_nodes, options.get());
+ group = static_cast<Group*>(modelWithEffects.get());
}
-
- std::vector<SGPropertyNode_ptr> animation_nodes;
- animation_nodes = props->getChildren("animation");
for (unsigned i = 0; i < animation_nodes.size(); ++i)
/// OSGFIXME: duh, why not only model?????
SGAnimation::animate(group.get(), animation_nodes[i], prop_root,
options.get());
- if (props->hasChild("debug-outfile")) {
- std::string outputfile = props->getStringValue("debug-outfile",
- "debug-model.osg");
- osgDB::writeNodeFile(*group, outputfile);
- }
if (!needTransform && group->getNumChildren() < 2) {
model = group->getChild(0);
group->removeChild(model.get());
- model->setUserData(group->getUserData());
+ if (data.valid())
+ data->modelLoaded(modelpath.str(), props, model.get());
return model.release();
}
+ if (data.valid())
+ data->modelLoaded(modelpath.str(), props, group.get());
+ if (props->hasChild("debug-outfile")) {
+ std::string outputfile = props->getStringValue("debug-outfile",
+ "debug-model.osg");
+ osgDB::writeNodeFile(*group, outputfile);
+ }
return group.release();
}
projects / simgear.git / blobdiff