src/Main/model.cxx

   1 // model.cxx - manage a 3D aircraft model.
   2 // Written by David Megginson, started 2002.
   3 //
   4 // This file is in the Public Domain, and comes with no warranty.
   5
   6 #ifdef HAVE_CONFIG_H
   7 #  include <config.h>
   8 #endif
   9
  10 #include <plib/sg.h>
  11 #include <plib/ssg.h>
  12
  13 #include <simgear/compiler.h>
  14 #include <simgear/debug/logstream.hxx>
  15 #include <simgear/misc/exception.hxx>
  16 #include <simgear/misc/sg_path.hxx>
  17
  18 #include "globals.hxx"
  19 #include "fg_props.hxx"
  20 #include "viewmgr.hxx"
  21 #include "model.hxx"
  22
  23 extern unsigned long int fgSimTime; // FIXME: this is ugly
  24
  25 extern ssgRoot * scene;         // FIXME: from main.cxx
  26
  27 FGAircraftModel current_model;  // FIXME: add to globals
  28
  29
  30 static ssgEntity *
  31 find_named_node (ssgEntity * node, const string &name)
  32 {
  33   char * node_name = node->getName();
  34   if (node_name != 0 && name == node_name)
  35     return node;
  36   else if (node->isAKindOf(ssgTypeBranch())) {
  37     int nKids = node->getNumKids();
  38     for (int i = 0; i < nKids; i++) {
  39       ssgEntity * result =
  40         find_named_node(((ssgBranch*)node)->getKid(i), name);
  41       if (result != 0)
  42         return result;
  43     }
  44   }
  45   return 0;
  46 }
  47
  48 FGAircraftModel::FGAircraftModel ()
  49   : _model(0),
  50     _selector(new ssgSelector),
  51     _position(new ssgTransform)
  52 {
  53 }
  54
  55 FGAircraftModel::~FGAircraftModel ()
  56 {
  57   // since the nodes are attached to the scene graph, they'll be
  58   // deleted automatically
  59 }
  60
  61 void
  62 FGAircraftModel::init ()
  63 {
  64   // TODO: optionally load an XML file with a pointer to the 3D object
  65   // and placement and animation info
  66
  67   SGPropertyNode props;
  68
  69   SG_LOG(SG_INPUT, SG_INFO, "Initializing aircraft 3D model");
  70
  71                                 // Load the 3D aircraft object itself
  72   SGPath path = globals->get_fg_root();
  73   path.append(fgGetString("/sim/model/path", "Models/Geometry/glider.ac"));
  74
  75   if (path.str().substr(path.str().size() - 4, 4) == ".xml") {
  76     readProperties(path.str(), &props);
  77     if (props.hasValue("/path")) {
  78       path = path.dir();;
  79       path.append(props.getStringValue("/path"));
  80     } else {
  81       path = globals->get_fg_root();
  82       path.append("Models/Geometry/glider.ac");
  83     }
  84   }
  85
  86   ssgTexturePath((char *)path.dir().c_str());
  87   _model = ssgLoad((char *)path.c_str());
  88   if (_model == 0) {
  89     _model = ssgLoad((char *)"Models/Geometry/glider.ac");
  90     if (_model == 0)
  91       throw sg_exception("Failed to load an aircraft model");
  92   }
  93
  94                                 // Load animations
  95   vector<SGPropertyNode *> animation_nodes =
  96     props.getChildren("animation");
  97   for (unsigned int i = 0; i < animation_nodes.size(); i++) {
  98     vector<SGPropertyNode *> name_nodes =
  99       animation_nodes[i]->getChildren("object-name");
 100     if (name_nodes.size() < 1) {
 101       SG_LOG(SG_INPUT, SG_ALERT, "No object-name given for transformation");
 102     } else {
 103       for (unsigned int j = 0; j < name_nodes.size(); j++) {
 104         _animations.push_back(read_animation(name_nodes[j]->getStringValue(),
 105                                              animation_nodes[i]));
 106       }
 107     }
 108   }
 109
 110                                 // Set up the alignment node
 111   ssgTransform * align = new ssgTransform;
 112   align->addKid(_model);
 113   sgMat4 rot_matrix;
 114   sgMat4 off_matrix;
 115   sgMat4 res_matrix;
 116   float h_rot = props.getFloatValue("/offsets/heading-deg", 0.0);
 117   float p_rot = props.getFloatValue("/offsets/roll-deg", 0.0);
 118   float r_rot = props.getFloatValue("/offsets/pitch-deg", 0.0);
 119   float x_off = props.getFloatValue("/offsets/x-m", 0.0);
 120   float y_off = props.getFloatValue("/offsets/y-m", 0.0);
 121   float z_off = props.getFloatValue("/offsets/z-m", 0.0);
 122   sgMakeRotMat4(rot_matrix, h_rot, p_rot, r_rot);
 123   sgMakeTransMat4(off_matrix, x_off, y_off, z_off);
 124   sgMultMat4(res_matrix, off_matrix, rot_matrix);
 125   align->setTransform(res_matrix);
 126
 127                                 // Set up the position node
 128   _position->addKid(align);
 129
 130                                 // Set up the selector node
 131   _selector->addKid(_position);
 132   _selector->clrTraversalMaskBits(SSGTRAV_HOT);
 133   scene->addKid(_selector);
 134 }
 135
 136 void
 137 FGAircraftModel::bind ()
 138 {
 139 }
 140
 141 void
 142 FGAircraftModel::unbind ()
 143 {
 144 }
 145
 146 void
 147 FGAircraftModel::update (int dt)
 148 {
 149   _current_timestamp.stamp();
 150   long elapsed_ms = (_current_timestamp - _last_timestamp) / 1000;
 151   _last_timestamp.stamp();
 152
 153   if (globals->get_viewmgr()->get_current() == 0) {
 154     _selector->select(false);
 155   } else {
 156     for (unsigned int i = 0; i < _animations.size(); i++)
 157       do_animation(_animations[i], elapsed_ms);
 158
 159     _selector->select(true);
 160     FGViewerRPH *pilot_view =
 161       (FGViewerRPH *)globals->get_viewmgr()->get_view( 0 );
 162
 163     sgMat4 sgTRANS;
 164     sgMakeTransMat4( sgTRANS, pilot_view->get_view_pos() );
 165
 166     sgVec3 ownship_up;
 167     sgSetVec3( ownship_up, 0.0, 0.0, 1.0);
 168
 169     sgMat4 sgROT;
 170     sgMakeRotMat4( sgROT, -90.0, ownship_up );
 171
 172     sgMat4 sgTUX;
 173     sgCopyMat4( sgTUX, sgROT );
 174     sgPostMultMat4( sgTUX, pilot_view->get_VIEW_ROT() );
 175     sgPostMultMat4( sgTUX, sgTRANS );
 176
 177     sgCoord tuxpos;
 178     sgSetCoord( &tuxpos, sgTUX );
 179     _position->setTransform( &tuxpos );
 180   }
 181
 182 }
 183
 184 FGAircraftModel::Animation
 185 FGAircraftModel::read_animation (const string &object_name,
 186                                  const SGPropertyNode * node)
 187 {
 188   Animation animation;
 189
 190                                 // Find the object to be animated
 191   ssgEntity * target = find_named_node(_model, object_name);
 192   if (target != 0) {
 193     SG_LOG(SG_INPUT, SG_INFO, "  Target object is " << object_name);
 194   } else {
 195     animation.type = Animation::None;
 196     SG_LOG(SG_INPUT, SG_ALERT, "Object " << object_name
 197            << " not found in model");
 198     return animation;
 199   }
 200
 201                                 // Figure out the animation type
 202   string type_name = node->getStringValue("type");
 203   if (type_name == "spin") {
 204     SG_LOG(SG_INPUT, SG_INFO, "Reading spin animation");
 205     animation.type = Animation::Spin;
 206   } else if (type_name == "rotate") {
 207     SG_LOG(SG_INPUT, SG_INFO, "Reading rotate animation");
 208     animation.type = Animation::Rotate;
 209   } else if (type_name == "none") {
 210     SG_LOG(SG_INPUT, SG_INFO, "Reading disabled animation");
 211     animation.type = Animation::None;
 212     return animation;
 213   } else {
 214     animation.type = Animation::None;
 215     SG_LOG(SG_INPUT, SG_ALERT, "Unknown animation type " << type_name);
 216     return animation;
 217   }
 218
 219                                 // Splice a transform node into the tree
 220   animation.transform = new ssgTransform;
 221   int nParents = target->getNumParents();
 222   animation.transform->addKid(target);
 223   for (int i = 0; i < nParents; i++) {
 224     ssgBranch * parent = target->getParent(i);
 225     parent->replaceKid(target, animation.transform);
 226   }
 227
 228                                 // Get the node
 229   animation.prop =
 230     fgGetNode(node->getStringValue("property", "/null"), true);
 231
 232   animation.position = node->getFloatValue("initial-position", 0);
 233   animation.offset = node->getFloatValue("offset", 0);
 234   if (node->hasValue("min")) {
 235     animation.has_min = true;
 236     animation.min = node->getFloatValue("min");
 237   } else {
 238     animation.has_min = false;
 239   }
 240   if (node->hasValue("max")) {
 241     animation.has_max = true;
 242     animation.max = node->getFloatValue("max");
 243   } else {
 244     animation.has_max = false;
 245   }
 246   animation.factor = node->getFloatValue("factor", 1);
 247
 248                                 // Get the center and axis
 249   animation.center[0] = node->getFloatValue("center/x-m", 0);
 250   animation.center[1] = node->getFloatValue("center/y-m", 0);
 251   animation.center[2] = node->getFloatValue("center/z-m", 0);
 252   animation.axis[0] = node->getFloatValue("axis/x", 0);
 253   animation.axis[1] = node->getFloatValue("axis/y", 0);
 254   animation.axis[2] = node->getFloatValue("axis/z", 0);
 255
 256   sgNormalizeVec3(animation.axis);
 257
 258   return animation;
 259 }
 260
 261 void
 262 FGAircraftModel::do_animation (Animation &animation, long elapsed_ms)
 263 {
 264   switch (animation.type) {
 265   case Animation::None:
 266     return;
 267   case Animation::Spin:
 268   {
 269     float velocity_rpms = (animation.prop->getDoubleValue()
 270                            * animation.factor / 60000.0);
 271     animation.position += (elapsed_ms * velocity_rpms * 360);
 272     animation.setRotation();
 273     return;
 274   }
 275   case Animation::Rotate: {
 276     animation.position = ((animation.prop->getFloatValue()
 277                            + animation.offset)
 278                           * animation.factor);
 279     if (animation.has_min && animation.position < animation.min)
 280       animation.position = animation.min;
 281     if (animation.has_max && animation.position > animation.max)
 282       animation.position = animation.max;
 283     animation.setRotation();
 284     return;
 285   }
 286   default:
 287     return;
 288   }
 289 }
 290
 291 /*
 292  * Transform to rotate an object around its local axis
 293  * from a relative frame of reference at center -- NHV
 294  */
 295 void
 296 FGAircraftModel::Animation::setRotation()
 297 {
 298  float temp_angle = -position * SG_DEGREES_TO_RADIANS ;
 299
 300  float s = (float) sin ( temp_angle ) ;
 301  float c = (float) cos ( temp_angle ) ;
 302  float t = SG_ONE - c ;
 303
 304  // axis was normalized at load time
 305  // hint to the compiler to put these into FP registers
 306  float x = axis[0];
 307  float y = axis[1];
 308  float z = axis[2];
 309
 310  sgMat4 matrix;
 311  matrix[0][0] = t * x * x + c ;
 312  matrix[0][1] = t * y * x - s * z ;
 313  matrix[0][2] = t * z * x + s * y ;
 314  matrix[0][3] = SG_ZERO;
 315
 316  matrix[1][0] = t * x * y + s * z ;
 317  matrix[1][1] = t * y * y + c ;
 318  matrix[1][2] = t * z * y - s * x ;
 319  matrix[1][3] = SG_ZERO;
 320
 321  matrix[2][0] = t * x * z - s * y ;
 322  matrix[2][1] = t * y * z + s * x ;
 323  matrix[2][2] = t * z * z + c ;
 324  matrix[2][3] = SG_ZERO;
 325
 326   // hint to the compiler to put these into FP registers
 327  x = center[0];
 328  y = center[1];
 329  z = center[2];
 330
 331  matrix[3][0] = x - x*matrix[0][0] - y*matrix[1][0] - z*matrix[2][0];
 332  matrix[3][1] = y - x*matrix[0][1] - y*matrix[1][1] - z*matrix[2][1];
 333  matrix[3][2] = z - x*matrix[0][2] - y*matrix[1][2] - z*matrix[2][2];
 334  matrix[3][3] = SG_ONE;
 335
 336  transform->setTransform(matrix);
 337 }
 338
 339
 340 // end of model.cxx