src/Model/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 <string.h>             // for strcmp()
  11
  12 #include <plib/sg.h>
  13 #include <plib/ssg.h>
  14
  15 #include <simgear/compiler.h>
  16 #include <simgear/debug/logstream.hxx>
  17 #include <simgear/math/point3d.hxx>
  18 #include <simgear/math/sg_geodesy.hxx>
  19 #include <simgear/misc/exception.hxx>
  20 #include <simgear/misc/sg_path.hxx>
  21
  22 #include <Main/globals.hxx>
  23 #include <Main/location.hxx>
  24 #include <Scenery/scenery.hxx>
  25
  26 #include "model.hxx"
  27
  28
  29 \f
  30 ////////////////////////////////////////////////////////////////////////
  31 // Static utility functions.
  32 ////////////////////////////////////////////////////////////////////////
  33
  34 /**
  35  * Locate a named SSG node in a branch.
  36  */
  37 static ssgEntity *
  38 find_named_node (ssgEntity * node, const char * name)
  39 {
  40   char * node_name = node->getName();
  41   if (node_name != 0 && !strcmp(name, node_name))
  42     return node;
  43   else if (node->isAKindOf(ssgTypeBranch())) {
  44     int nKids = node->getNumKids();
  45     for (int i = 0; i < nKids; i++) {
  46       ssgEntity * result =
  47         find_named_node(((ssgBranch*)node)->getKid(i), name);
  48       if (result != 0)
  49         return result;
  50     }
  51   }
  52   return 0;
  53 }
  54
  55 /**
  56  * Splice a branch in between all child nodes and their parents.
  57  */
  58 static void
  59 splice_branch (ssgBranch * branch, ssgEntity * child)
  60 {
  61   int nParents = child->getNumParents();
  62   branch->addKid(child);
  63   for (int i = 0; i < nParents; i++) {
  64     ssgBranch * parent = child->getParent(i);
  65     parent->replaceKid(child, branch);
  66   }
  67 }
  68
  69 /**
  70  * Set up the transform matrix for a spin or rotation.
  71  */
  72 static void
  73 set_rotation (sgMat4 &matrix, double position_deg,
  74               sgVec3 &center, sgVec3 &axis)
  75 {
  76  float temp_angle = -position_deg * SG_DEGREES_TO_RADIANS ;
  77
  78  float s = (float) sin ( temp_angle ) ;
  79  float c = (float) cos ( temp_angle ) ;
  80  float t = SG_ONE - c ;
  81
  82  // axis was normalized at load time
  83  // hint to the compiler to put these into FP registers
  84  float x = axis[0];
  85  float y = axis[1];
  86  float z = axis[2];
  87
  88  matrix[0][0] = t * x * x + c ;
  89  matrix[0][1] = t * y * x - s * z ;
  90  matrix[0][2] = t * z * x + s * y ;
  91  matrix[0][3] = SG_ZERO;
  92
  93  matrix[1][0] = t * x * y + s * z ;
  94  matrix[1][1] = t * y * y + c ;
  95  matrix[1][2] = t * z * y - s * x ;
  96  matrix[1][3] = SG_ZERO;
  97
  98  matrix[2][0] = t * x * z - s * y ;
  99  matrix[2][1] = t * y * z + s * x ;
 100  matrix[2][2] = t * z * z + c ;
 101  matrix[2][3] = SG_ZERO;
 102
 103   // hint to the compiler to put these into FP registers
 104  x = center[0];
 105  y = center[1];
 106  z = center[2];
 107
 108  matrix[3][0] = x - x*matrix[0][0] - y*matrix[1][0] - z*matrix[2][0];
 109  matrix[3][1] = y - x*matrix[0][1] - y*matrix[1][1] - z*matrix[2][1];
 110  matrix[3][2] = z - x*matrix[0][2] - y*matrix[1][2] - z*matrix[2][2];
 111  matrix[3][3] = SG_ONE;
 112 }
 113
 114 /**
 115  * Set up the transform matrix for a translation.
 116  */
 117 static void
 118 set_translation (sgMat4 &matrix, double position_m, sgVec3 &axis)
 119 {
 120   sgVec3 xyz;
 121   sgScaleVec3(xyz, axis, position_m);
 122   sgMakeTransMat4(matrix, xyz);
 123 }
 124
 125
 126 \f
 127 ////////////////////////////////////////////////////////////////////////
 128 // Implementation of FG3DModel
 129 ////////////////////////////////////////////////////////////////////////
 130
 131 FG3DModel::FG3DModel ()
 132   : _model(0),
 133     _selector(new ssgSelector),
 134     _position(new ssgTransform)
 135 {
 136 }
 137
 138 FG3DModel::~FG3DModel ()
 139 {
 140   // since the nodes are attached to the scene graph, they'll be
 141   // deleted automatically
 142
 143   for (int i = 0; i < _animations.size(); i++) {
 144     Animation * tmp = _animations[i];
 145     _animations[i] = 0;
 146     delete tmp;
 147   }
 148
 149 }
 150
 151 void
 152 FG3DModel::init (const string &path)
 153 {
 154   SGPropertyNode props;
 155
 156                                 // Load the 3D aircraft object itself
 157   SGPath xmlpath = globals->get_fg_root();
 158   SGPath modelpath = path;
 159   xmlpath.append(modelpath.str());
 160
 161                                 // Check for an XML wrapper
 162   if (xmlpath.str().substr(xmlpath.str().size() - 4, 4) == ".xml") {
 163     readProperties(xmlpath.str(), &props);
 164     if (props.hasValue("/path")) {
 165       modelpath = modelpath.dir();
 166       modelpath.append(props.getStringValue("/path"));
 167     } else {
 168       throw sg_exception("No path for model");
 169     }
 170   }
 171
 172                                 // Assume that textures are in
 173                                 // the same location as the XML file.
 174   ssgTexturePath((char *)xmlpath.dir().c_str());
 175   _model = ssgLoad((char *)modelpath.c_str());
 176   if (_model == 0)
 177     throw sg_exception("Failed to load 3D model");
 178
 179                                 // Load animations
 180   vector<SGPropertyNode *> animation_nodes = props.getChildren("animation");
 181   for (unsigned int i = 0; i < animation_nodes.size(); i++) {
 182     vector<SGPropertyNode *> name_nodes =
 183       animation_nodes[i]->getChildren("object-name");
 184     if (name_nodes.size() < 1) {
 185       SG_LOG(SG_INPUT, SG_ALERT, "No object-name given for transformation");
 186     } else {
 187       for (unsigned int j = 0; j < name_nodes.size(); j++) {
 188         Animation * animation =
 189           make_animation(name_nodes[j]->getStringValue(), animation_nodes[i]);
 190         if (animation != 0)
 191           _animations.push_back(animation);
 192       }
 193     }
 194   }
 195
 196                                 // Set up the range selector node
 197   float ranges[2];
 198   ssgRangeSelector * lod = new ssgRangeSelector;
 199   lod->addKid(_model);
 200   ranges[0] = props.getFloatValue("range/min-m", 0);
 201   ranges[1] = props.getFloatValue("range/max-m", 5000);
 202   lod->setRanges(ranges, 2);
 203
 204
 205                                 // Set up the alignment node
 206   ssgTransform * align = new ssgTransform;
 207   align->addKid(lod);
 208   sgMat4 rot_matrix;
 209   sgMat4 off_matrix;
 210   sgMat4 res_matrix;
 211   float h_rot = props.getFloatValue("/offsets/heading-deg", 0.0);
 212   float p_rot = props.getFloatValue("/offsets/roll-deg", 0.0);
 213   float r_rot = props.getFloatValue("/offsets/pitch-deg", 0.0);
 214   float x_off = props.getFloatValue("/offsets/x-m", 0.0);
 215   float y_off = props.getFloatValue("/offsets/y-m", 0.0);
 216   float z_off = props.getFloatValue("/offsets/z-m", 0.0);
 217   sgMakeRotMat4(rot_matrix, h_rot, p_rot, r_rot);
 218   sgMakeTransMat4(off_matrix, x_off, y_off, z_off);
 219   sgMultMat4(res_matrix, off_matrix, rot_matrix);
 220   align->setTransform(res_matrix);
 221
 222                                 // Set up the position node
 223   _position->addKid(align);
 224
 225                                 // Set up the selector node
 226   _selector->addKid(_position);
 227   _selector->clrTraversalMaskBits(SSGTRAV_HOT);
 228
 229                                 // Set up a location class
 230   _location = (FGLocation *) new FGLocation;
 231
 232 }
 233
 234 void
 235 FG3DModel::update (int dt)
 236 {
 237   unsigned int i;
 238
 239   for (i = 0; i < _animations.size(); i++)
 240     _animations[i]->update(dt);
 241
 242   _location->setPosition( _lon_deg, _lat_deg, _elev_ft );
 243   _location->setOrientation( _roll_deg, _pitch_deg, _heading_deg );
 244
 245   sgMat4 POS;
 246   sgCopyMat4(POS, _location->getTransformMatrix());
 247
 248   sgVec3 trans;
 249   sgCopyVec3(trans, _location->get_view_pos());
 250
 251   for(i = 0; i < 4; i++) {
 252     float tmp = POS[i][3];
 253     for( int j=0; j<3; j++ ) {
 254       POS[i][j] += (tmp * trans[j]);
 255     }
 256   }
 257   _position->setTransform(POS);
 258 }
 259
 260 bool
 261 FG3DModel::getVisible () const
 262 {
 263   return _selector->getSelect();
 264 }
 265
 266 void
 267 FG3DModel::setVisible (bool visible)
 268 {
 269   _selector->select(visible);
 270 }
 271
 272 void
 273 FG3DModel::setLongitudeDeg (double lon_deg)
 274 {
 275   _lon_deg = lon_deg;
 276 }
 277
 278 void
 279 FG3DModel::setLatitudeDeg (double lat_deg)
 280 {
 281   _lat_deg = lat_deg;
 282 }
 283
 284 void
 285 FG3DModel::setElevationFt (double elev_ft)
 286 {
 287   _elev_ft = elev_ft;
 288 }
 289
 290 void
 291 FG3DModel::setPosition (double lon_deg, double lat_deg, double elev_ft)
 292 {
 293   _lon_deg = lon_deg;
 294   _lat_deg = lat_deg;
 295   _elev_ft = elev_ft;
 296 }
 297
 298 void
 299 FG3DModel::setRollDeg (double roll_deg)
 300 {
 301   _roll_deg = roll_deg;
 302 }
 303
 304 void
 305 FG3DModel::setPitchDeg (double pitch_deg)
 306 {
 307   _pitch_deg = pitch_deg;
 308 }
 309
 310 void
 311 FG3DModel::setHeadingDeg (double heading_deg)
 312 {
 313   _heading_deg = heading_deg;
 314 }
 315
 316 void
 317 FG3DModel::setOrientation (double roll_deg, double pitch_deg,
 318                            double heading_deg)
 319 {
 320   _roll_deg = roll_deg;
 321   _pitch_deg = pitch_deg;
 322   _heading_deg = heading_deg;
 323 }
 324
 325 FG3DModel::Animation *
 326 FG3DModel::make_animation (const char * object_name,
 327                                  SGPropertyNode * node)
 328 {
 329   Animation * animation = 0;
 330   const char * type = node->getStringValue("type");
 331   if (!strcmp("none", type)) {
 332     animation = new NullAnimation();
 333   } else if (!strcmp("range", type)) {
 334     animation = new RangeAnimation();
 335   } else if (!strcmp("select", type)) {
 336     animation = new SelectAnimation();
 337   } else if (!strcmp("spin", type)) {
 338     animation = new SpinAnimation();
 339   } else if (!strcmp("rotate", type)) {
 340     animation = new RotateAnimation();
 341   } else if (!strcmp("translate", type)) {
 342     animation = new TranslateAnimation();
 343   } else {
 344     animation = new NullAnimation();
 345     SG_LOG(SG_INPUT, SG_WARN, "Unknown animation type " << type);
 346   }
 347
 348   ssgEntity * object = find_named_node(_model, object_name);
 349   if (object == 0) {
 350     SG_LOG(SG_INPUT, SG_WARN, "Object " << object_name << " not found");
 351     delete animation;
 352     animation = 0;
 353   } else {
 354     animation->init(object, node);
 355   }
 356
 357   return animation;
 358 }
 359
 360
 361 \f
 362 ////////////////////////////////////////////////////////////////////////
 363 // Implementation of FG3DModel::Animation
 364 ////////////////////////////////////////////////////////////////////////
 365
 366 FG3DModel::Animation::Animation ()
 367 {
 368 }
 369
 370 FG3DModel::Animation::~Animation ()
 371 {
 372 }
 373
 374
 375 \f
 376 ////////////////////////////////////////////////////////////////////////
 377 // Implementation of FG3DModel::NullAnimation
 378 ////////////////////////////////////////////////////////////////////////
 379
 380 FG3DModel::NullAnimation::NullAnimation ()
 381   : _branch(new ssgBranch)
 382 {
 383 }
 384
 385 FG3DModel::NullAnimation::~NullAnimation ()
 386 {
 387   _branch = 0;
 388 }
 389
 390 void
 391 FG3DModel::NullAnimation::init (ssgEntity * object,
 392                                       SGPropertyNode * props)
 393 {
 394   splice_branch(_branch, object);
 395   _branch->setName(props->getStringValue("name", 0));
 396 }
 397
 398 void
 399 FG3DModel::NullAnimation::update (int dt)
 400 {
 401 }
 402
 403
 404 \f
 405 ////////////////////////////////////////////////////////////////////////
 406 // Implementation of FG3DModel::RangeAnimation
 407 ////////////////////////////////////////////////////////////////////////
 408
 409 FG3DModel::RangeAnimation::RangeAnimation ()
 410   : _branch(new ssgRangeSelector)
 411 {
 412 }
 413
 414 FG3DModel::RangeAnimation::~RangeAnimation ()
 415 {
 416   _branch = 0;
 417 }
 418
 419 void
 420 FG3DModel::RangeAnimation::init (ssgEntity * object,
 421                                       SGPropertyNode * props)
 422 {
 423   float ranges[2];
 424   splice_branch(_branch, object);
 425   _branch->setName(props->getStringValue("name", 0));
 426   ranges[0] = props->getFloatValue("min-m", 0);
 427   ranges[1] = props->getFloatValue("max-m", 5000);
 428   _branch->setRanges(ranges, 2);
 429 }
 430
 431 void
 432 FG3DModel::RangeAnimation::update (int dt)
 433 {
 434 }
 435
 436
 437 \f
 438 ////////////////////////////////////////////////////////////////////////
 439 // Implementation of FG3DModel::SelectAnimation
 440 ////////////////////////////////////////////////////////////////////////
 441
 442 FG3DModel::SelectAnimation::SelectAnimation ()
 443   : _condition(0),
 444     _selector(new ssgSelector)
 445 {
 446 }
 447
 448 FG3DModel::SelectAnimation::~SelectAnimation ()
 449 {
 450   delete _condition;
 451   _selector = 0;
 452 }
 453
 454 void
 455 FG3DModel::SelectAnimation::init (ssgEntity * object,
 456                                       SGPropertyNode * props)
 457 {
 458   splice_branch(_selector, object);
 459   _selector->setName(props->getStringValue("name", 0));
 460   SGPropertyNode * node = props->getChild("condition");
 461   if (node != 0) {
 462     _condition = fgReadCondition(node);
 463   }
 464 }
 465
 466 void
 467 FG3DModel::SelectAnimation::update (int dt)
 468 {
 469   if (_condition != 0 && _condition->test())
 470     _selector->select(0xffff);
 471   else
 472     _selector->select(0x0000);
 473 }
 474
 475
 476 \f
 477 ////////////////////////////////////////////////////////////////////////
 478 // Implementation of FG3DModel::SpinAnimation
 479 ////////////////////////////////////////////////////////////////////////
 480
 481 FG3DModel::SpinAnimation::SpinAnimation ()
 482   : _prop(0),
 483     _factor(0),
 484     _position_deg(0),
 485     _transform(new ssgTransform)
 486 {
 487 }
 488
 489 FG3DModel::SpinAnimation::~SpinAnimation ()
 490 {
 491   _transform = 0;
 492 }
 493
 494 void
 495 FG3DModel::SpinAnimation::init (ssgEntity * object,
 496                                       SGPropertyNode * props)
 497 {
 498                                 // Splice in the new transform node
 499   splice_branch(_transform, object);
 500   _transform->setName(props->getStringValue("name", 0));
 501   _prop = fgGetNode(props->getStringValue("property", "/null"), true);
 502   _factor = props->getDoubleValue("factor", 1.0);
 503   _position_deg = props->getDoubleValue("starting-position-deg", 0);
 504   _center[0] = props->getFloatValue("center/x-m", 0);
 505   _center[1] = props->getFloatValue("center/y-m", 0);
 506   _center[2] = props->getFloatValue("center/z-m", 0);
 507   _axis[0] = props->getFloatValue("axis/x", 0);
 508   _axis[1] = props->getFloatValue("axis/y", 0);
 509   _axis[2] = props->getFloatValue("axis/z", 0);
 510   sgNormalizeVec3(_axis);
 511 }
 512
 513 void
 514 FG3DModel::SpinAnimation::update (int dt)
 515 {
 516   float velocity_rpms = (_prop->getDoubleValue() * _factor / 60000.0);
 517   _position_deg += (dt * velocity_rpms * 360);
 518   while (_position_deg < 0)
 519     _position_deg += 360.0;
 520   while (_position_deg >= 360.0)
 521     _position_deg -= 360.0;
 522   set_rotation(_matrix, _position_deg, _center, _axis);
 523   _transform->setTransform(_matrix);
 524 }
 525
 526
 527 \f
 528 ////////////////////////////////////////////////////////////////////////
 529 // Implementation of FG3DModel::RotateAnimation
 530 ////////////////////////////////////////////////////////////////////////
 531
 532 FG3DModel::RotateAnimation::RotateAnimation ()
 533   : _prop(0),
 534     _offset_deg(0.0),
 535     _factor(1.0),
 536     _has_min(false),
 537     _min_deg(0.0),
 538     _has_max(false),
 539     _max_deg(1.0),
 540     _position_deg(0.0),
 541     _transform(new ssgTransform)
 542 {
 543 }
 544
 545 FG3DModel::RotateAnimation::~RotateAnimation ()
 546 {
 547   _transform = 0;
 548 }
 549
 550 void
 551 FG3DModel::RotateAnimation::init (ssgEntity * object,
 552                                         SGPropertyNode * props)
 553 {
 554                                 // Splice in the new transform node
 555   splice_branch(_transform, object);
 556   _transform->setName(props->getStringValue("name", 0));
 557   _prop = fgGetNode(props->getStringValue("property", "/null"), true);
 558   _offset_deg = props->getDoubleValue("offset-deg", 0.0);
 559   _factor = props->getDoubleValue("factor", 1.0);
 560   if (props->hasValue("min-deg")) {
 561     _has_min = true;
 562     _min_deg = props->getDoubleValue("min-deg");
 563   }
 564   if (props->hasValue("max-deg")) {
 565     _has_max = true;
 566     _max_deg = props->getDoubleValue("max-deg");
 567   }
 568   _position_deg = props->getDoubleValue("starting-position-deg", 0);
 569   _center[0] = props->getFloatValue("center/x-m", 0);
 570   _center[1] = props->getFloatValue("center/y-m", 0);
 571   _center[2] = props->getFloatValue("center/z-m", 0);
 572   _axis[0] = props->getFloatValue("axis/x", 0);
 573   _axis[1] = props->getFloatValue("axis/y", 0);
 574   _axis[2] = props->getFloatValue("axis/z", 0);
 575   sgNormalizeVec3(_axis);
 576 }
 577
 578 void
 579 FG3DModel::RotateAnimation::update (int dt)
 580 {
 581   _position_deg = ((_prop->getDoubleValue() + _offset_deg) * _factor);
 582   if (_has_min && _position_deg < _min_deg)
 583     _position_deg = _min_deg;
 584   if (_has_max && _position_deg > _max_deg)
 585     _position_deg = _max_deg;
 586   set_rotation(_matrix, _position_deg, _center, _axis);
 587   _transform->setTransform(_matrix);
 588 }
 589
 590
 591 \f
 592 ////////////////////////////////////////////////////////////////////////
 593 // Implementation of FG3DModel::TranslateAnimation
 594 ////////////////////////////////////////////////////////////////////////
 595
 596 FG3DModel::TranslateAnimation::TranslateAnimation ()
 597   : _prop(0),
 598     _offset_m(0.0),
 599     _factor(1.0),
 600     _has_min(false),
 601     _min_m(0.0),
 602     _has_max(false),
 603     _max_m(1.0),
 604     _position_m(0.0),
 605     _transform(new ssgTransform)
 606 {
 607 }
 608
 609 FG3DModel::TranslateAnimation::~TranslateAnimation ()
 610 {
 611   _transform = 0;
 612 }
 613
 614 void
 615 FG3DModel::TranslateAnimation::init (ssgEntity * object,
 616                                         SGPropertyNode * props)
 617 {
 618                                 // Splice in the new transform node
 619   splice_branch(_transform, object);
 620   _transform->setName(props->getStringValue("name", 0));
 621   _prop = fgGetNode(props->getStringValue("property", "/null"), true);
 622   _offset_m = props->getDoubleValue("offset-m", 0.0);
 623   _factor = props->getDoubleValue("factor", 1.0);
 624   if (props->hasValue("min-m")) {
 625     _has_min = true;
 626     _min_m = props->getDoubleValue("min-m");
 627   }
 628   if (props->hasValue("max-m")) {
 629     _has_max = true;
 630     _max_m = props->getDoubleValue("max-m");
 631   }
 632   _position_m = props->getDoubleValue("starting-position-m", 0);
 633   _axis[0] = props->getFloatValue("axis/x", 0);
 634   _axis[1] = props->getFloatValue("axis/y", 0);
 635   _axis[2] = props->getFloatValue("axis/z", 0);
 636   sgNormalizeVec3(_axis);
 637 }
 638
 639 void
 640 FG3DModel::TranslateAnimation::update (int dt)
 641 {
 642   _position_m = ((_prop->getDoubleValue() + _offset_m) * _factor);
 643   if (_has_min && _position_m < _min_m)
 644     _position_m = _min_m;
 645   if (_has_max && _position_m > _max_m)
 646     _position_m = _max_m;
 647   set_translation(_matrix, _position_m, _axis);
 648   _transform->setTransform(_matrix);
 649 }
 650
 651
 652 // end of model.cxx
 653
 654
 655
 656