src/Scripting/NasalModelData.cxx

   1
   2 #include "NasalModelData.hxx"
   3 #include "NasalSys.hxx"
   4 #include <Main/fg_props.hxx>
   5 #include <Main/globals.hxx>
   6
   7 #include <simgear/math/SGMath.hxx>
   8 #include <simgear/nasal/cppbind/Ghost.hxx>
   9 #include <simgear/scene/util/OsgDebug.hxx>
  10 #include <simgear/scene/util/OsgMath.hxx>
  11 #include <simgear/debug/logstream.hxx>
  12
  13 #include <osg/Transform>
  14
  15 #include <boost/bind.hpp>
  16
  17 #include <algorithm>
  18 #include <cstring> // for strlen
  19
  20 // FGNasalModelData class.  If sgLoad3DModel() is called with a pointer to
  21 // such a class, then it lets modelLoaded() run the <load> script, and the
  22 // destructor the <unload> script. The latter happens when the model branch
  23 // is removed from the scene graph.
  24
  25 unsigned int FGNasalModelData::_max_module_id = 0;
  26 FGNasalModelDataList FGNasalModelData::_loaded_models;
  27
  28 typedef osg::ref_ptr<osg::Node> NodeRef;
  29 typedef nasal::Ghost<NodeRef> NasalNode;
  30
  31 /**
  32  * Get position (lat, lon, elevation) and orientation (heading, pitch, roll) of
  33  * model.
  34  */
  35 static naRef f_node_getPose( const osg::Node& node,
  36                              const nasal::CallContext& ctx )
  37 {
  38   osg::NodePathList parent_paths = node.getParentalNodePaths();
  39   for( osg::NodePathList::const_iterator path = parent_paths.begin();
  40                                          path != parent_paths.end();
  41                                        ++path )
  42   {
  43     osg::Matrix local_to_world = osg::computeLocalToWorld(*path);
  44     if( !local_to_world.valid() )
  45       continue;
  46
  47     SGGeod coord = SGGeod::fromCart( toSG(local_to_world.getTrans()) );
  48     if( !coord.isValid() )
  49       continue;
  50
  51     osg::Matrix local_frame = makeZUpFrameRelative(coord),
  52                 inv_local;
  53     inv_local.invert_4x3(local_frame);
  54     local_to_world.postMult(inv_local);
  55
  56     SGQuatd rotate = toSG(local_to_world.getRotate());
  57     double hdg, pitch, roll;
  58     rotate.getEulerDeg(hdg, pitch, roll);
  59
  60     nasal::Hash pose(ctx.to_nasal(coord), ctx.c);
  61     pose.set("heading", hdg);
  62     pose.set("pitch", pitch);
  63     pose.set("roll", roll);
  64     return pose.get_naRef();
  65   }
  66
  67   return naNil();
  68 }
  69
  70 //------------------------------------------------------------------------------
  71 FGNasalModelData::FGNasalModelData( SGPropertyNode *root,
  72                                     const std::string& path,
  73                                     SGPropertyNode *prop,
  74                                     SGPropertyNode* load,
  75                                     SGPropertyNode* unload,
  76                                     osg::Node* branch ):
  77   _path(path),
  78   _root(root), _prop(prop),
  79   _load(load), _unload(unload),
  80   _branch(branch),
  81   _module_id( _max_module_id++ )
  82 {
  83   _loaded_models.push_back(this);
  84
  85   SG_LOG
  86   (
  87     SG_NASAL,
  88     SG_INFO,
  89     "New model with attached script(s) "
  90     "(branch = " << branch << ","
  91     " path = " << simgear::getNodePathString(branch) << ")"
  92   );
  93 }
  94
  95 //------------------------------------------------------------------------------
  96 FGNasalModelData::~FGNasalModelData()
  97 {
  98   _loaded_models.remove(this);
  99
 100   SG_LOG
 101   (
 102     SG_NASAL,
 103     SG_INFO,
 104     "Removed model with script(s) (branch = " << _branch.get() << ")"
 105   );
 106 }
 107
 108 //------------------------------------------------------------------------------
 109 void FGNasalModelData::load()
 110 {
 111   std::stringstream m;
 112   m << "__model" << _module_id;
 113   _module = m.str();
 114
 115   SG_LOG(SG_NASAL, SG_DEBUG, "Loading nasal module " << _module.c_str());
 116
 117   const char *s = _load ? _load->getStringValue() : "";
 118   FGNasalSys* nasalSys = (FGNasalSys*) globals->get_subsystem("nasal");
 119
 120   // Add _module_id to script local hash to allow placing canvasses on objects
 121   // inside the model.
 122   nasal::Hash module = nasalSys->getGlobals().createHash(_module);
 123   module.set("_module_id", _module_id);
 124
 125   if( !NasalNode::isInit() )
 126   {
 127     NasalNode::init("osg.Node")
 128       .method("getPose", &f_node_getPose);
 129   }
 130
 131   module.set("_model", _branch);
 132
 133   naRef arg[2];
 134   arg[0] = nasalSys->propNodeGhost(_root);
 135   arg[1] = nasalSys->propNodeGhost(_prop);
 136   nasalSys->createModule(_module.c_str(), _path.c_str(), s, strlen(s),
 137                          _root, 2, arg);
 138 }
 139
 140 //------------------------------------------------------------------------------
 141 void FGNasalModelData::unload()
 142 {
 143     if (_module.empty())
 144         return;
 145
 146     FGNasalSys* nasalSys = (FGNasalSys*) globals->get_subsystem("nasal");
 147     if(!nasalSys) {
 148         SG_LOG(SG_NASAL, SG_WARN, "Trying to run an <unload> script "
 149                "without Nasal subsystem present.");
 150         return;
 151     }
 152
 153     SG_LOG(SG_NASAL, SG_DEBUG, "Unloading nasal module " << _module.c_str());
 154
 155     if (_unload)
 156     {
 157         const char *s = _unload->getStringValue();
 158         nasalSys->createModule(_module.c_str(), _module.c_str(), s, strlen(s), _root);
 159     }
 160
 161     nasalSys->deleteModule(_module.c_str());
 162 }
 163
 164 //------------------------------------------------------------------------------
 165 osg::Node* FGNasalModelData::getNode()
 166 {
 167   return _branch.get();
 168 }
 169
 170 //------------------------------------------------------------------------------
 171 FGNasalModelData* FGNasalModelData::getByModuleId(unsigned int id)
 172 {
 173   FGNasalModelDataList::iterator it = std::find_if
 174   (
 175     _loaded_models.begin(),
 176     _loaded_models.end(),
 177     boost::bind(&FGNasalModelData::_module_id, _1) == id
 178   );
 179
 180   if( it != _loaded_models.end() )
 181     return *it;
 182
 183   return 0;
 184 }
 185
 186 //------------------------------------------------------------------------------
 187 FGNasalModelDataProxy::~FGNasalModelDataProxy()
 188 {
 189     FGNasalSys* nasalSys = (FGNasalSys*) globals->get_subsystem("nasal");
 190     // when necessary, register Nasal module to be destroyed/unloaded
 191     // in the main thread.
 192     if ((_data.valid())&&(nasalSys))
 193         nasalSys->registerToUnload(_data);
 194 }
 195
 196 //------------------------------------------------------------------------------
 197 void FGNasalModelDataProxy::modelLoaded( const std::string& path,
 198                                          SGPropertyNode *prop,
 199                                          osg::Node *branch )
 200 {
 201     if( fgGetBool("/sim/disable-embedded-nasal") )
 202         return;
 203
 204     if(!prop)
 205         return;
 206
 207     SGPropertyNode *nasal = prop->getNode("nasal");
 208     if(!nasal)
 209         return;
 210
 211     FGNasalSys* nasalSys = (FGNasalSys*) globals->get_subsystem("nasal");
 212     if(!nasalSys)
 213     {
 214         SG_LOG
 215         (
 216           SG_NASAL,
 217           SG_WARN,
 218           "Can not load model script(s) (Nasal subsystem not available)."
 219         );
 220         return;
 221     }
 222
 223     SGPropertyNode* load   = nasal->getNode("load");
 224     SGPropertyNode* unload = nasal->getNode("unload");
 225
 226     if ((!load) && (!unload))
 227         return;
 228
 229     _data = new FGNasalModelData(_root, path, prop, load, unload, branch);
 230
 231     // register Nasal module to be created and loaded in the main thread.
 232     nasalSys->registerToLoad(_data);
 233 }