1 // Copyright (C) 2007 Tim Moore timoore@redhat.com
2 // Copyright (C) 2008 Till Busch buti@bux.at
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.
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.
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.
20 # include <simgear_config.h>
23 #include <osg/MatrixTransform>
24 #include <osgDB/WriteFile>
25 #include <osgDB/Registry>
27 #include <osgDB/FileNameUtils>
29 #include <simgear/compiler.h>
30 #include <simgear/structure/exception.hxx>
31 #include <simgear/props/props.hxx>
32 #include <simgear/props/props_io.hxx>
33 #include <simgear/props/condition.hxx>
34 #include <simgear/scene/util/SGNodeMasks.hxx>
36 #include "modellib.hxx"
37 #include "SGPagedLOD.hxx"
38 #include "SGReaderWriterXML.hxx"
39 #include "SGReaderWriterXMLOptions.hxx"
41 #include "animation.hxx"
42 #include "particles.hxx"
45 #include "SGReaderWriterXMLOptions.hxx"
46 #include "SGReaderWriterXML.hxx"
48 using namespace simgear;
51 sgLoad3DModel_internal(const string &path,
52 SGPropertyNode *prop_root,
53 SGModelData *data = 0,
54 osg::Node *(*load_panel)(SGPropertyNode *) = 0,
55 SGPropertyNode *overlay = 0);
57 const char* SGReaderWriterXML::className() const
59 return "XML database reader";
62 bool SGReaderWriterXML::acceptsExtension(const std::string& extension) const
64 return (osgDB::equalCaseInsensitive(extension, "xml"));
67 osgDB::ReaderWriter::ReadResult
68 SGReaderWriterXML::readNode(const std::string& fileName,
69 const osgDB::ReaderWriter::Options* options) const
71 // SG_LOG(SG_GENERAL, SG_ALERT, "SGReaderWriterXML::readNode(" << fileName << ")");
73 std::string ext = osgDB::getLowerCaseFileExtension(fileName);
74 if (!acceptsExtension(ext))
75 return ReadResult::FILE_NOT_HANDLED;
77 const SGReaderWriterXMLOptions* xmlOptions
78 = dynamic_cast<const SGReaderWriterXMLOptions*>(options);
81 SGPropertyNode *prop_root=0;
82 osg::Node *(*load_panel)(SGPropertyNode *)=0;
83 SGModelData *model_data=0;
84 SGPath externalTexturePath;
87 prop_root = xmlOptions->getPropRoot();
88 load_panel = xmlOptions->getLoadPanel();
89 model_data = xmlOptions->getModelData();
92 fg_root=osgDB::Registry::instance()->getDataFilePathList().front();
97 result=sgLoad3DModel_internal(fileName, prop_root, model_data, load_panel);
98 } catch (const sg_throwable &t) {
99 SG_LOG(SG_INPUT, SG_ALERT, "Failed to load model: " << t.getFormattedMessage());
100 result=new osg::Node;
105 return ReadResult::FILE_NOT_HANDLED;
108 class SGSwitchUpdateCallback : public osg::NodeCallback
111 SGSwitchUpdateCallback(SGCondition* condition) :
112 mCondition(condition) {}
113 virtual void operator()(osg::Node* node, osg::NodeVisitor* nv) {
114 assert(dynamic_cast<osg::Switch*>(node));
115 osg::Switch* s = static_cast<osg::Switch*>(node);
117 if (mCondition && mCondition->test()) {
118 s->setAllChildrenOn();
119 // note, callback is responsible for scenegraph traversal so
120 // should always include call traverse(node,nv) to ensure
121 // that the rest of cullbacks and the scene graph are traversed.
124 s->setAllChildrenOff();
128 SGSharedPtr<SGCondition> mCondition;
132 sgLoad3DModel_internal(const string &path,
133 SGPropertyNode *prop_root,
135 osg::Node *(*load_panel)(SGPropertyNode *),
136 SGPropertyNode *overlay)
139 SG_LOG(SG_GENERAL, SG_ALERT, "prop_root NULL: " << path);
142 string fg_root=osgDB::Registry::instance()->getDataFilePathList().front();
143 osg::ref_ptr<osg::Node> model;
144 osg::ref_ptr<osg::Group> group;
145 SGPropertyNode_ptr props = new SGPropertyNode;
147 // Load the 3D object itself
148 SGPath modelpath = path, texturepath = path;
149 if ( !ulIsAbsolutePathName( path.c_str() ) ) {
150 SGPath tmp = fg_root;
151 tmp.append(modelpath.str());
152 modelpath = texturepath = tmp;
155 // Check for an XML wrapper
156 if (modelpath.str().substr(modelpath.str().size() - 4, 4) == ".xml") {
158 readProperties(modelpath.str(), props);
159 } catch (const sg_throwable &t) {
160 SG_LOG(SG_INPUT, SG_ALERT, "Failed to load xml: " << t.getFormattedMessage());
164 copyProperties(overlay, props);
166 if (props->hasValue("/path")) {
167 modelpath = modelpath.dir();
168 modelpath.append(props->getStringValue("/path"));
169 if (props->hasValue("/texture-path")) {
170 texturepath = texturepath.dir();
171 texturepath.append(props->getStringValue("/texture-path"));
174 model = new osg::Node;
177 SGPropertyNode *mp = props->getNode("multiplay");
178 if (mp && prop_root && prop_root->getParent())
179 copyProperties(mp, prop_root);
182 osg::ref_ptr<SGReaderWriterXMLOptions> options
183 = new SGReaderWriterXMLOptions(*osgDB::Registry::instance()->getOptions());
185 // Assume that textures are in
186 // the same location as the XML file.
188 if (texturepath.extension() != "")
189 texturepath = texturepath.dir();
191 options->setDatabasePath(texturepath.str());
192 model = osgDB::readNodeFile(modelpath.str(), options.get());
194 throw sg_io_exception("Failed to load 3D model",
195 sg_location(modelpath.str()));
197 model->setName(modelpath.str());
199 bool needTransform=false;
200 // Set up the alignment node if needed
201 SGPropertyNode *offsets = props->getNode("offsets", false);
204 osg::MatrixTransform *alignmainmodel = new osg::MatrixTransform;
205 osg::Matrix res_matrix;
206 res_matrix.makeRotate(
207 offsets->getFloatValue("pitch-deg", 0.0)*SG_DEGREES_TO_RADIANS,
209 offsets->getFloatValue("roll-deg", 0.0)*SG_DEGREES_TO_RADIANS,
211 offsets->getFloatValue("heading-deg", 0.0)*SG_DEGREES_TO_RADIANS,
215 tmat.makeTranslate(offsets->getFloatValue("x-m", 0.0),
216 offsets->getFloatValue("y-m", 0.0),
217 offsets->getFloatValue("z-m", 0.0));
218 alignmainmodel->setMatrix(res_matrix*tmat);
219 group = alignmainmodel;
222 group = new osg::Group;
224 group->addChild(model.get());
227 vector<SGPropertyNode_ptr> model_nodes = props->getChildren("model");
228 for (unsigned i = 0; i < model_nodes.size(); i++) {
229 SGPropertyNode_ptr sub_props = model_nodes[i];
232 osg::ref_ptr<osg::Node> submodel;
233 string submodelFileName = sub_props->getStringValue("path");
234 if ( submodelFileName.size() > 2 && submodelFileName.substr( 0, 2 ) == "./" ) {
235 submodelpath = modelpath.dir();
236 submodelpath.append( submodelFileName.substr( 2 ) );
238 submodelpath = submodelFileName;
241 submodel = sgLoad3DModel_internal(submodelpath.str(), prop_root, 0, load_panel,
242 sub_props->getNode("overlay"));
243 } catch (const sg_throwable &t) {
244 SG_LOG(SG_INPUT, SG_ALERT, "Failed to load submodel: " << t.getFormattedMessage());
248 osg::ref_ptr<osg::Node> submodel_final=submodel.get();
249 SGPropertyNode *offs = sub_props->getNode("offsets", false);
251 osg::Matrix res_matrix;
252 osg::ref_ptr<osg::MatrixTransform> align = new osg::MatrixTransform;
253 res_matrix.makeIdentity();
254 res_matrix.makeRotate(
255 offs->getDoubleValue("pitch-deg", 0.0)*SG_DEGREES_TO_RADIANS,
257 offs->getDoubleValue("roll-deg", 0.0)*SG_DEGREES_TO_RADIANS,
259 offs->getDoubleValue("heading-deg", 0.0)*SG_DEGREES_TO_RADIANS,
264 tmat.makeTranslate(offs->getDoubleValue("x-m", 0),
265 offs->getDoubleValue("y-m", 0),
266 offs->getDoubleValue("z-m", 0));
267 align->setMatrix(res_matrix*tmat);
268 align->addChild(submodel.get());
269 submodel_final=align.get();
271 submodel_final->setName(sub_props->getStringValue("name", ""));
273 SGPropertyNode *cond = sub_props->getNode("condition", false);
275 osg::ref_ptr<osg::Switch> sw = new osg::Switch;
276 sw->setUpdateCallback(new SGSwitchUpdateCallback(sgReadCondition(prop_root, cond)));
277 group->addChild(sw.get());
278 sw->addChild(submodel_final.get());
279 sw->setName("submodel condition switch");
281 group->addChild(submodel_final.get());
283 } // end of submodel loading
287 vector<SGPropertyNode_ptr> panel_nodes = props->getChildren("panel");
288 for (unsigned i = 0; i < panel_nodes.size(); i++) {
289 SG_LOG(SG_INPUT, SG_DEBUG, "Loading a panel");
290 osg::ref_ptr<osg::Node> panel = load_panel(panel_nodes[i]);
291 if (panel_nodes[i]->hasValue("name"))
292 panel->setName((char *)panel_nodes[i]->getStringValue("name"));
293 group->addChild(panel.get());
297 std::vector<SGPropertyNode_ptr> particle_nodes;
298 particle_nodes = props->getChildren("particlesystem");
299 for (unsigned i = 0; i < particle_nodes.size(); ++i) {
301 if (texturepath.extension() != "")
302 texturepath = texturepath.dir();
304 options->setDatabasePath(texturepath.str());
306 group->addChild(Particles::appendParticles(particle_nodes[i],
312 data->setProps(props);
313 options->setModelData(data);
316 std::vector<SGPropertyNode_ptr> animation_nodes;
317 animation_nodes = props->getChildren("animation");
318 for (unsigned i = 0; i < animation_nodes.size(); ++i)
319 /// OSGFIXME: duh, why not only model?????
320 SGAnimation::animate(group.get(), animation_nodes[i], prop_root,
323 if (props->hasChild("debug-outfile")) {
324 std::string outputfile = props->getStringValue("debug-outfile",
326 osgDB::writeNodeFile(*group, outputfile);
328 if (!needTransform && group->getNumChildren() < 2) {
329 model = group->getChild(0);
330 group->removeChild(model.get());
331 model->setUserData(group->getUserData());
332 return model.release();
335 return group.release();