simgear/scene/model/SGReaderWriterXML.cxx

   1 // Copyright (C) 2007 Tim Moore timoore@redhat.com
   2 // Copyright (C) 2008 Till Busch buti@bux.at
   3 //
   4 // This program is free software; you can redistribute it and/or
   5 // modify it under the terms of the GNU General Public License as
   6 // published by the Free Software Foundation; either version 2 of the
   7 // License, or (at your option) any later version.
   8 //
   9 // This program is distributed in the hope that it will be useful, but
  10 // WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12 // General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU General Public License
  15 // along with this program; if not, write to the Free Software
  16 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  17 //
  18
  19 #ifdef HAVE_CONFIG_H
  20 #  include <simgear_config.h>
  21 #endif
  22
  23 #include <algorithm>
  24 //yuck
  25 #include <cstring>
  26 #include <cassert>
  27
  28 #include <boost/bind.hpp>
  29
  30 #include <osg/Geode>
  31 #include <osg/MatrixTransform>
  32 #include <osgDB/ReadFile>
  33 #include <osgDB/WriteFile>
  34 #include <osgDB/Registry>
  35 #include <osg/Switch>
  36 #include <osgDB/FileNameUtils>
  37
  38 #include <simgear/compiler.h>
  39 #include <simgear/structure/exception.hxx>
  40 #include <simgear/props/props.hxx>
  41 #include <simgear/props/props_io.hxx>
  42 #include <simgear/props/condition.hxx>
  43 #include <simgear/scene/util/SGNodeMasks.hxx>
  44 #include <simgear/scene/util/SGReaderWriterOptions.hxx>
  45
  46 #include "modellib.hxx"
  47 #include "SGReaderWriterXML.hxx"
  48
  49 #include "animation.hxx"
  50 #include "particles.hxx"
  51 #include "model.hxx"
  52 #include "SGText.hxx"
  53 #include "SGMaterialAnimation.hxx"
  54
  55 using namespace std;
  56 using namespace simgear;
  57 using namespace osg;
  58
  59 static osg::Node *
  60 sgLoad3DModel_internal(const SGPath& path,
  61                        const osgDB::Options* options,
  62                        SGPropertyNode *overlay = 0);
  63
  64
  65 SGReaderWriterXML::SGReaderWriterXML()
  66 {
  67     supportsExtension("xml", "SimGear xml database format");
  68 }
  69
  70 SGReaderWriterXML::~SGReaderWriterXML()
  71 {
  72 }
  73
  74 const char* SGReaderWriterXML::className() const
  75 {
  76     return "XML database reader";
  77 }
  78
  79 osgDB::ReaderWriter::ReadResult
  80 SGReaderWriterXML::readNode(const std::string& fileName,
  81                             const osgDB::Options* options) const
  82 {
  83     osg::Node *result=0;
  84     try {
  85         SGPath p = SGModelLib::findDataFile(fileName);
  86         if (!p.exists()) {
  87           return ReadResult::FILE_NOT_FOUND;
  88         }
  89
  90         result=sgLoad3DModel_internal(p, options);
  91     } catch (const sg_exception &t) {
  92         SG_LOG(SG_INPUT, SG_ALERT, "Failed to load model: " << t.getFormattedMessage()
  93           << "\n\tfrom:" << fileName);
  94         result=new osg::Node;
  95     }
  96     if (result)
  97         return result;
  98     else
  99         return ReadResult::FILE_NOT_HANDLED;
 100 }
 101
 102 class SGSwitchUpdateCallback : public osg::NodeCallback
 103 {
 104 public:
 105     SGSwitchUpdateCallback(SGCondition* condition) :
 106             mCondition(condition) {}
 107     virtual void operator()(osg::Node* node, osg::NodeVisitor* nv) {
 108         assert(dynamic_cast<osg::Switch*>(node));
 109         osg::Switch* s = static_cast<osg::Switch*>(node);
 110
 111         if (mCondition && mCondition->test()) {
 112             s->setAllChildrenOn();
 113             // note, callback is responsible for scenegraph traversal so
 114             // should always include call traverse(node,nv) to ensure
 115             // that the rest of cullbacks and the scene graph are traversed.
 116             traverse(node, nv);
 117         } else
 118             s->setAllChildrenOff();
 119     }
 120
 121 private:
 122     SGSharedPtr<SGCondition> mCondition;
 123 };
 124
 125
 126 // Little helper class that holds an extra reference to a
 127 // loaded 3d model.
 128 // Since we clone all structural nodes from our 3d models,
 129 // the database pager will only see one single reference to
 130 // top node of the model and expire it relatively fast.
 131 // We attach that extra reference to every model cloned from
 132 // a base model in the pager. When that cloned model is deleted
 133 // this extra reference is deleted too. So if there are no
 134 // cloned models left the model will expire.
 135 namespace {
 136 class SGDatabaseReference : public osg::Observer
 137 {
 138 public:
 139     SGDatabaseReference(osg::Referenced* referenced) :
 140         mReferenced(referenced)
 141     { }
 142     virtual void objectDeleted(void*)
 143     {
 144         mReferenced = 0;
 145     }
 146 private:
 147     osg::ref_ptr<osg::Referenced> mReferenced;
 148 };
 149
 150 void makeEffectAnimations(PropertyList& animation_nodes,
 151                           PropertyList& effect_nodes)
 152 {
 153     for (PropertyList::iterator itr = animation_nodes.begin();
 154          itr != animation_nodes.end();
 155          ++itr) {
 156         SGPropertyNode_ptr effectProp;
 157         SGPropertyNode* animProp = itr->ptr();
 158         SGPropertyNode* typeProp = animProp->getChild("type");
 159         if (!typeProp)
 160             continue;
 161         const char* typeString = typeProp->getStringValue();
 162         if (!strcmp(typeString, "material")) {
 163             effectProp
 164                 = SGMaterialAnimation::makeEffectProperties(animProp);
 165         } else if (!strcmp(typeString, "shader")) {
 166
 167             SGPropertyNode* shaderProp = animProp->getChild("shader");
 168             if (!shaderProp || strcmp(shaderProp->getStringValue(), "chrome"))
 169                 continue;
 170             *itr = 0;           // effect replaces animation
 171             SGPropertyNode* textureProp = animProp->getChild("texture");
 172             if (!textureProp)
 173                 continue;
 174             effectProp = new SGPropertyNode();
 175             makeChild(effectProp.ptr(), "inherits-from")
 176                 ->setValue("Effects/chrome");
 177             SGPropertyNode* paramsProp = makeChild(effectProp.get(), "parameters");
 178             makeChild(paramsProp, "chrome-texture")
 179                 ->setValue(textureProp->getStringValue());
 180         }
 181         if (effectProp.valid()) {
 182             PropertyList objectNameNodes = animProp->getChildren("object-name");
 183             for (PropertyList::iterator objItr = objectNameNodes.begin(),
 184                      end = objectNameNodes.end();
 185                  objItr != end;
 186                  ++objItr)
 187                 effectProp->addChild("object-name")
 188                     ->setStringValue((*objItr)->getStringValue());
 189             effect_nodes.push_back(effectProp);
 190
 191         }
 192     }
 193     animation_nodes.erase(remove_if(animation_nodes.begin(),
 194                                     animation_nodes.end(),
 195                                     !boost::bind(&SGPropertyNode_ptr::valid,
 196                                                  _1)),
 197                           animation_nodes.end());
 198 }
 199 }
 200
 201 static osg::Node *
 202 sgLoad3DModel_internal(const SGPath& path,
 203                        const osgDB::Options* options_,
 204                        SGPropertyNode *overlay)
 205 {
 206     if (!path.exists()) {
 207       SG_LOG(SG_INPUT, SG_ALERT, "Failed to load file: \"" << path.str() << "\"");
 208       return NULL;
 209     }
 210
 211     const SGReaderWriterOptions* xmlOptions;
 212     xmlOptions = dynamic_cast<const SGReaderWriterOptions*>(options_);
 213
 214     SGSharedPtr<SGPropertyNode> prop_root;
 215     osg::Node *(*load_panel)(SGPropertyNode *)=0;
 216     osg::ref_ptr<SGModelData> data;
 217     SGPath modelpath(path);
 218     SGPath texturepath(path);
 219     SGPath modelDir(modelpath.dir());
 220
 221     if (xmlOptions) {
 222         prop_root = xmlOptions->getPropertyNode();
 223         load_panel = xmlOptions->getLoadPanel();
 224         data = xmlOptions->getModelData();
 225     }
 226
 227     if (!prop_root) {
 228         prop_root = new SGPropertyNode;
 229     }
 230
 231     osg::ref_ptr<osg::Node> model;
 232     osg::ref_ptr<osg::Group> group;
 233     SGPropertyNode_ptr props = new SGPropertyNode;
 234
 235     // Check for an XML wrapper
 236     if (modelpath.extension() == "xml") {
 237        try {
 238             readProperties(modelpath.str(), props);
 239         } catch (const sg_exception &t) {
 240             SG_LOG(SG_INPUT, SG_ALERT, "Failed to load xml: "
 241                    << t.getFormattedMessage());
 242             throw;
 243         }
 244         if (overlay)
 245             copyProperties(overlay, props);
 246
 247         if (props->hasValue("/path")) {
 248             string modelPathStr = props->getStringValue("/path");
 249             modelpath = SGModelLib::findDataFile(modelPathStr, NULL, modelDir);
 250             if (modelpath.isNull())
 251                 throw sg_io_exception("Model file not found: '" + modelPathStr + "'",
 252                         path.str());
 253
 254             if (props->hasValue("/texture-path")) {
 255                 string texturePathStr = props->getStringValue("/texture-path");
 256                 texturepath = SGModelLib::findDataFile(texturePathStr, NULL, modelDir);
 257                 if (texturepath.isNull())
 258                     throw sg_io_exception("Texture file not found: '" + texturePathStr + "'",
 259                             path.str());
 260             }
 261         } else {
 262             model = new osg::Node;
 263         }
 264
 265         SGPropertyNode *mp = props->getNode("multiplay");
 266         if (mp && prop_root && prop_root->getParent())
 267             copyProperties(mp, prop_root);
 268     } else {
 269         // model without wrapper
 270     }
 271
 272     osg::ref_ptr<SGReaderWriterOptions> options
 273     = new SGReaderWriterOptions(*options_);
 274     options->setPropertyNode(prop_root);
 275     options->setLoadPanel(load_panel);
 276
 277     // Assume that textures are in
 278     // the same location as the XML file.
 279     if (!model) {
 280         if (!texturepath.extension().empty())
 281             texturepath = texturepath.dir();
 282
 283         options->setDatabasePath(texturepath.str());
 284         osgDB::ReaderWriter::ReadResult modelResult;
 285         modelResult = osgDB::readNodeFile(modelpath.str(), options.get());
 286         if (!modelResult.validNode())
 287             throw sg_io_exception("Failed to load 3D model:" + modelResult.message(),
 288                                   modelpath.str());
 289         model = copyModel(modelResult.getNode());
 290         // Add an extra reference to the model stored in the database.
 291         // That is to avoid expiring the object from the cache even if
 292         // it is still in use. Note that the object cache will think
 293         // that a model is unused if the reference count is 1. If we
 294         // clone all structural nodes here we need that extra
 295         // reference to the original object
 296         SGDatabaseReference* databaseReference;
 297         databaseReference = new SGDatabaseReference(modelResult.getNode());
 298         model->addObserver(databaseReference);
 299
 300         // Update liveries
 301         TextureUpdateVisitor liveryUpdate(options->getDatabasePathList());
 302         model->accept(liveryUpdate);
 303
 304         // Copy the userdata fields, still sharing the boundingvolumes,
 305         // but introducing new data for velocities.
 306         UserDataCopyVisitor userDataCopyVisitor;
 307         model->accept(userDataCopyVisitor);
 308     }
 309     model->setName(modelpath.str());
 310
 311     bool needTransform=false;
 312     // Set up the alignment node if needed
 313     SGPropertyNode *offsets = props->getNode("offsets", false);
 314     if (offsets) {
 315         needTransform=true;
 316         osg::MatrixTransform *alignmainmodel = new osg::MatrixTransform;
 317         alignmainmodel->setDataVariance(osg::Object::STATIC);
 318         osg::Matrix res_matrix;
 319         res_matrix.makeRotate(
 320             offsets->getFloatValue("pitch-deg", 0.0)*SG_DEGREES_TO_RADIANS,
 321             osg::Vec3(0, 1, 0),
 322             offsets->getFloatValue("roll-deg", 0.0)*SG_DEGREES_TO_RADIANS,
 323             osg::Vec3(1, 0, 0),
 324             offsets->getFloatValue("heading-deg", 0.0)*SG_DEGREES_TO_RADIANS,
 325             osg::Vec3(0, 0, 1));
 326
 327         osg::Matrix tmat;
 328         tmat.makeTranslate(offsets->getFloatValue("x-m", 0.0),
 329                            offsets->getFloatValue("y-m", 0.0),
 330                            offsets->getFloatValue("z-m", 0.0));
 331         alignmainmodel->setMatrix(res_matrix*tmat);
 332         group = alignmainmodel;
 333     }
 334     if (!group) {
 335         group = new osg::Group;
 336     }
 337     group->addChild(model.get());
 338
 339     // Load sub-models
 340     vector<SGPropertyNode_ptr> model_nodes = props->getChildren("model");
 341     for (unsigned i = 0; i < model_nodes.size(); i++) {
 342         SGPropertyNode_ptr sub_props = model_nodes[i];
 343
 344         SGPath submodelpath;
 345         osg::ref_ptr<osg::Node> submodel;
 346
 347         string subPathStr = sub_props->getStringValue("path");
 348         SGPath submodelPath = SGModelLib::findDataFile(subPathStr,
 349           NULL, modelDir);
 350
 351         if (submodelPath.isNull()) {
 352           SG_LOG(SG_INPUT, SG_ALERT, "Failed to load file: \"" << subPathStr << "\"");
 353           continue;
 354         }
 355
 356         osg::ref_ptr<SGReaderWriterOptions> options;
 357         options = new SGReaderWriterOptions(*options_);
 358         options->setPropertyNode(prop_root);
 359         options->setLoadPanel(load_panel);
 360
 361         try {
 362             submodel = sgLoad3DModel_internal(submodelPath, options.get(),
 363                                               sub_props->getNode("overlay"));
 364         } catch (const sg_exception &t) {
 365             SG_LOG(SG_INPUT, SG_ALERT, "Failed to load submodel: " << t.getFormattedMessage()
 366               << "\n\tfrom:" << t.getOrigin());
 367             continue;
 368         }
 369
 370         osg::ref_ptr<osg::Node> submodel_final = submodel;
 371         SGPropertyNode *offs = sub_props->getNode("offsets", false);
 372         if (offs) {
 373             osg::Matrix res_matrix;
 374             osg::ref_ptr<osg::MatrixTransform> align = new osg::MatrixTransform;
 375             align->setDataVariance(osg::Object::STATIC);
 376             res_matrix.makeIdentity();
 377             res_matrix.makeRotate(
 378                 offs->getDoubleValue("pitch-deg", 0.0)*SG_DEGREES_TO_RADIANS,
 379                 osg::Vec3(0, 1, 0),
 380                 offs->getDoubleValue("roll-deg", 0.0)*SG_DEGREES_TO_RADIANS,
 381                 osg::Vec3(1, 0, 0),
 382                 offs->getDoubleValue("heading-deg", 0.0)*SG_DEGREES_TO_RADIANS,
 383                 osg::Vec3(0, 0, 1));
 384
 385             osg::Matrix tmat;
 386             tmat.makeIdentity();
 387             tmat.makeTranslate(offs->getDoubleValue("x-m", 0),
 388                                offs->getDoubleValue("y-m", 0),
 389                                offs->getDoubleValue("z-m", 0));
 390             align->setMatrix(res_matrix*tmat);
 391             align->addChild(submodel.get());
 392             submodel_final = align;
 393         }
 394         submodel_final->setName(sub_props->getStringValue("name", ""));
 395
 396         SGPropertyNode *cond = sub_props->getNode("condition", false);
 397         if (cond) {
 398             osg::ref_ptr<osg::Switch> sw = new osg::Switch;
 399             sw->setUpdateCallback(new SGSwitchUpdateCallback(sgReadCondition(prop_root, cond)));
 400             group->addChild(sw.get());
 401             sw->addChild(submodel_final.get());
 402             sw->setName("submodel condition switch");
 403         } else {
 404             group->addChild(submodel_final.get());
 405         }
 406     } // end of submodel loading
 407
 408     if ( load_panel ) {
 409         // Load panels
 410         vector<SGPropertyNode_ptr> panel_nodes = props->getChildren("panel");
 411         for (unsigned i = 0; i < panel_nodes.size(); i++) {
 412             SG_LOG(SG_INPUT, SG_DEBUG, "Loading a panel");
 413             osg::ref_ptr<osg::Node> panel = load_panel(panel_nodes[i]);
 414             if (panel_nodes[i]->hasValue("name"))
 415                 panel->setName(panel_nodes[i]->getStringValue("name"));
 416             group->addChild(panel.get());
 417         }
 418     }
 419
 420     std::vector<SGPropertyNode_ptr> particle_nodes;
 421     particle_nodes = props->getChildren("particlesystem");
 422     for (unsigned i = 0; i < particle_nodes.size(); ++i) {
 423         if (i==0) {
 424             if (!texturepath.extension().empty())
 425                 texturepath = texturepath.dir();
 426
 427             options->setDatabasePath(texturepath.str());
 428         }
 429         group->addChild(Particles::appendParticles(particle_nodes[i],
 430                         prop_root,
 431                         options.get()));
 432     }
 433
 434     std::vector<SGPropertyNode_ptr> text_nodes;
 435     text_nodes = props->getChildren("text");
 436     for (unsigned i = 0; i < text_nodes.size(); ++i) {
 437         group->addChild(SGText::appendText(text_nodes[i],
 438                         prop_root,
 439                         options.get()));
 440     }
 441     PropertyList effect_nodes = props->getChildren("effect");
 442     PropertyList animation_nodes = props->getChildren("animation");
 443     // Some material animations (eventually all) are actually effects.
 444     makeEffectAnimations(animation_nodes, effect_nodes);
 445     {
 446         ref_ptr<Node> modelWithEffects
 447             = instantiateEffects(group.get(), effect_nodes, options.get());
 448         group = static_cast<Group*>(modelWithEffects.get());
 449     }
 450     for (unsigned i = 0; i < animation_nodes.size(); ++i)
 451         /// OSGFIXME: duh, why not only model?????
 452         SGAnimation::animate(group.get(), animation_nodes[i], prop_root,
 453                              options.get());
 454
 455     if (!needTransform && group->getNumChildren() < 2) {
 456         model = group->getChild(0);
 457         group->removeChild(model.get());
 458         if (data.valid())
 459             data->modelLoaded(modelpath.str(), props, model.get());
 460         return model.release();
 461     }
 462     if (data.valid())
 463         data->modelLoaded(modelpath.str(), props, group.get());
 464     if (props->hasChild("debug-outfile")) {
 465         std::string outputfile = props->getStringValue("debug-outfile",
 466                                  "debug-model.osg");
 467         osgDB::writeNodeFile(*group, outputfile);
 468     }
 469
 470     return group.release();
 471 }
 472