src/Instrumentation/NavDisplay.cxx

   1 // navigation display texture
   2 //
   3 // Written by James Turner, forked from wxradar code
   4 //
   5 //
   6 // This program is free software; you can redistribute it and/or
   7 // modify it under the terms of the GNU General Public License as
   8 // published by the Free Software Foundation; either version 2 of the
   9 // License, or (at your option) any later version.
  10 //
  11 // This program is distributed in the hope that it will be useful, but
  12 // WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 // General Public License for more details.
  15 //
  16 // You should have received a copy of the GNU General Public License
  17 // along with this program; if not, write to the Free Software
  18 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  19 //
  20 //
  21
  22 #ifdef HAVE_CONFIG_H
  23 #  include "config.h"
  24 #endif
  25
  26 #include "NavDisplay.hxx"
  27
  28 #include <cassert>
  29 #include <boost/foreach.hpp>
  30 #include <algorithm>
  31
  32 #include <osg/Array>
  33 #include <osg/Geometry>
  34 #include <osg/Matrixf>
  35 #include <osg/PrimitiveSet>
  36 #include <osg/StateSet>
  37 #include <osg/LineWidth>
  38 #include <osg/Version>
  39
  40 #include <simgear/constants.h>
  41 #include <simgear/misc/sg_path.hxx>
  42 #include <simgear/scene/model/model.hxx>
  43 #include <simgear/structure/exception.hxx>
  44 #include <simgear/misc/sg_path.hxx>
  45 #include <simgear/misc/strutils.hxx>
  46 #include <simgear/math/sg_geodesy.hxx>
  47
  48 #include <sstream>
  49 #include <iomanip>
  50 #include <iostream>             // for cout, endl
  51
  52 using std::stringstream;
  53 using std::endl;
  54 using std::setprecision;
  55 using std::fixed;
  56 using std::setw;
  57 using std::setfill;
  58 using std::cout;
  59 using std::endl;
  60 using std::map;
  61 using std::string;
  62
  63 #include <Main/fg_props.hxx>
  64 #include <Main/globals.hxx>
  65 #include <Cockpit/panel.hxx>
  66 #include <Navaids/routePath.hxx>
  67 #include <Autopilot/route_mgr.hxx>
  68 #include <Navaids/navrecord.hxx>
  69 #include <Navaids/navlist.hxx>
  70 #include <Navaids/fix.hxx>
  71 #include <Airports/simple.hxx>
  72 #include <Airports/runways.hxx>
  73
  74 #include "instrument_mgr.hxx"
  75 #include "od_gauge.hxx"
  76
  77 static const char *DEFAULT_FONT = "typewriter.txf";
  78
  79 static
  80 osg::Matrixf degRotation(float angle)
  81 {
  82     return osg::Matrixf::rotate(angle * SG_DEGREES_TO_RADIANS, 0.0f, 0.0f, -1.0f);
  83 }
  84
  85 static osg::Vec4 readColor(SGPropertyNode* colorNode, const osg::Vec4& c)
  86 {
  87     osg::Vec4 result;
  88     result.r() = colorNode->getDoubleValue("red",   c.r());
  89     result.g() = colorNode->getDoubleValue("green", c.g());
  90     result.b() = colorNode->getDoubleValue("blue",  c.b());
  91     result.a() = colorNode->getDoubleValue("alpha", c.a());
  92     return result;
  93 }
  94
  95 static osgText::Text::AlignmentType readAlignment(const std::string& t)
  96 {
  97     if (t == "left-top") {
  98         return osgText::Text::LEFT_TOP;
  99     } else if (t == "left-center") {
 100         return osgText::Text::LEFT_CENTER;
 101     } else if (t == "left-bottom") {
 102         return osgText::Text::LEFT_BOTTOM;
 103     } else if (t == "center-top") {
 104         return osgText::Text::CENTER_TOP;
 105     } else if (t == "center-center") {
 106         return osgText::Text::CENTER_CENTER;
 107     } else if (t == "center-bottom") {
 108         return osgText::Text::CENTER_BOTTOM;
 109     } else if (t == "right-top") {
 110         return osgText::Text::RIGHT_TOP;
 111     } else if (t == "right-center") {
 112         return osgText::Text::RIGHT_CENTER;
 113     } else if (t == "right-bottom") {
 114         return osgText::Text::RIGHT_BOTTOM;
 115     } else if (t == "left-baseline") {
 116         return osgText::Text::LEFT_BASE_LINE;
 117     } else if (t == "center-baseline") {
 118         return osgText::Text::CENTER_BASE_LINE;
 119     } else if (t == "right-baseline") {
 120         return osgText::Text::RIGHT_BASE_LINE;
 121     }
 122
 123     return osgText::Text::BASE_LINE;
 124 }
 125
 126 static string formatPropertyValue(SGPropertyNode* nd, const string& format)
 127 {
 128     assert(nd);
 129     static char buf[512];
 130     if (format.find('d') != string::npos) {
 131         ::snprintf(buf, 512, format.c_str(), nd->getIntValue());
 132         return buf;
 133     }
 134
 135     if (format.find('s') != string::npos) {
 136         ::snprintf(buf, 512, format.c_str(), nd->getStringValue());
 137         return buf;
 138     }
 139
 140 // assume it's a double/float
 141     ::snprintf(buf, 512, format.c_str(), nd->getDoubleValue());
 142     return buf;
 143 }
 144
 145 static osg::Vec2 mult(const osg::Vec2& v, const osg::Matrixf& m)
 146 {
 147     osg::Vec3 r = m.preMult(osg::Vec3(v.x(), v.y(), 0.0));
 148     return osg::Vec2(r.x(), r.y());
 149 }
 150
 151 class NavDisplay::CacheListener : public SGPropertyChangeListener
 152 {
 153 public:
 154     CacheListener(NavDisplay *nd) :
 155         _nd(nd)
 156     {}
 157
 158     virtual void valueChanged (SGPropertyNode * prop)
 159     {
 160         _nd->invalidatePositionedCache();
 161         SG_LOG(SG_INSTR, SG_INFO, "invalidating NavDisplay cache");
 162     }
 163 private:
 164     NavDisplay* _nd;
 165 };
 166
 167 class NavDisplay::ForceUpdateListener : public SGPropertyChangeListener
 168 {
 169 public:
 170   ForceUpdateListener(NavDisplay *nd) :
 171     _nd(nd)
 172   {}
 173
 174   virtual void valueChanged (SGPropertyNode * prop)
 175   {
 176     SG_LOG(SG_INSTR, SG_INFO, "forcing NavDisplay update");
 177     _nd->forceUpdate();
 178   }
 179 private:
 180   NavDisplay* _nd;
 181 };
 182
 183 ///////////////////////////////////////////////////////////////////
 184
 185 class SymbolRule
 186 {
 187 public:
 188     SymbolRule()
 189     {
 190
 191     }
 192
 193     bool initFromNode(SGPropertyNode* node, NavDisplay* owner)
 194     {
 195         if (!node->getChild("type")) {
 196             return false;
 197         }
 198
 199         type = node->getStringValue("type");
 200         SGPropertyNode* enableNode = node->getChild("enable");
 201         if (enableNode) {
 202             enable.reset(sgReadCondition(fgGetNode("/"), enableNode));
 203         }
 204
 205         int n=0;
 206         while (node->hasChild("state", n)) {
 207             string m = node->getChild("state", n++)->getStringValue();
 208             if (m[0] == '!') {
 209                 excluded_states.insert(m.substr(1));
 210             } else {
 211                 required_states.insert(m);
 212             }
 213         } // of matches parsing
 214
 215         return true;
 216     }
 217
 218     void setDefinition(SymbolDef* d)
 219     {
 220         definition = d;
 221     }
 222
 223     SymbolDef* getDefinition() const
 224     { return definition; }
 225
 226     bool matches(const string_set& states) const
 227     {
 228         BOOST_FOREACH(const string& s, required_states) {
 229             if (states.count(s) == 0) {
 230                 return false;
 231             }
 232         }
 233
 234         BOOST_FOREACH(const string& s, excluded_states) {
 235             if (states.count(s) != 0) {
 236                 return false;
 237             }
 238         }
 239
 240         return true;
 241     }
 242
 243     void checkEnabled()
 244     {
 245         if (enable.get()) {
 246             enabled = enable->test();
 247         } else {
 248             enabled = true;
 249         }
 250     }
 251
 252     bool enabled; // cached enabled state
 253     std::string type;
 254 private:
 255     SymbolDef* definition;
 256
 257     std::auto_ptr<SGCondition> enable;
 258     string_set required_states;
 259     string_set excluded_states;
 260
 261 };
 262
 263 class SymbolDef
 264 {
 265 public:
 266     bool initFromNode(SGPropertyNode* node, NavDisplay* owner)
 267     {
 268         if (node->getChild("type")) {
 269             SymbolRule* builtinRule = new SymbolRule;
 270             builtinRule->initFromNode(node, owner);
 271             builtinRule->setDefinition(this);
 272             owner->addRule(builtinRule);
 273         }
 274
 275         if (node->hasChild("width")) {
 276             float w = node->getFloatValue("width");
 277             float h = node->getFloatValue("height", w);
 278             xy0.x() = -w * 0.5;
 279             xy0.y() = -h * 0.5;
 280             xy1.x() = w * 0.5;
 281             xy1.y() = h * 0.5;
 282         } else {
 283             xy0.x()  = node->getFloatValue("x0", 0.0);
 284             xy0.y()  = node->getFloatValue("y0", 0.0);
 285             xy1.x()  = node->getFloatValue("x1", 5);
 286             xy1.y()  = node->getFloatValue("y1", 5);
 287         }
 288
 289         double texSize = node->getFloatValue("texture-size", owner->textureSize());
 290
 291         uv0.x()  = node->getFloatValue("u0", 0) / texSize;
 292         uv0.y()  = node->getFloatValue("v0", 0) / texSize;
 293         uv1.x()  = node->getFloatValue("u1", 1) / texSize;
 294         uv1.y()  = node->getFloatValue("v1", 1) / texSize;
 295
 296         color = readColor(node->getChild("color"), osg::Vec4(1, 1, 1, 1));
 297         priority = node->getIntValue("priority", 0);
 298         zOrder = node->getIntValue("zOrder", 0);
 299         rotateToHeading = node->getBoolValue("rotate-to-heading", false);
 300         roundPos = node->getBoolValue("round-position", true);
 301         hasText = false;
 302         if (node->hasChild("text")) {
 303             hasText = true;
 304             alignment = readAlignment(node->getStringValue("text-align"));
 305             textTemplate = node->getStringValue("text");
 306             textOffset.x() = node->getFloatValue("text-offset-x", 0);
 307             textOffset.y() = node->getFloatValue("text-offset-y", 0);
 308             textColor = readColor(node->getChild("text-color"), color);
 309         }
 310
 311         drawLine = node->getBoolValue("draw-line", false);
 312         lineColor = readColor(node->getChild("line-color"), color);
 313         drawRouteLeg = node->getBoolValue("draw-leg", false);
 314
 315         stretchSymbol = node->getBoolValue("stretch-symbol", false);
 316         if (stretchSymbol) {
 317             stretchY2 = node->getFloatValue("y2");
 318             stretchY3 = node->getFloatValue("y3");
 319             stretchV2 = node->getFloatValue("v2") / texSize;
 320             stretchV3 = node->getFloatValue("v3") / texSize;
 321         }
 322
 323         return true;
 324     }
 325
 326     osg::Vec2 xy0, xy1;
 327     osg::Vec2 uv0, uv1;
 328     osg::Vec4 color;
 329
 330     int priority;
 331     int zOrder;
 332     bool rotateToHeading;
 333     bool roundPos; ///< should position be rounded to integer values
 334     bool hasText;
 335     osg::Vec4 textColor;
 336     osg::Vec2 textOffset;
 337     osgText::Text::AlignmentType alignment;
 338     string textTemplate;
 339
 340     bool drawLine;
 341     osg::Vec4 lineColor;
 342
 343 // symbol stretching creates three quads (instead of one) - a start,
 344 // middle and end quad, positioned along the line of the symbol.
 345 // X (and U) axis values determined by the values above, so we only need
 346 // to define the Y (and V) values to build the other quads.
 347     bool stretchSymbol;
 348     double stretchY2, stretchY3;
 349     double stretchV2, stretchV3;
 350
 351     bool drawRouteLeg;
 352
 353 };
 354
 355 class SymbolInstance
 356 {
 357 public:
 358     SymbolInstance(const osg::Vec2& p, double h, SymbolDef* def, SGPropertyNode* vars) :
 359         pos(p),
 360         headingDeg(h),
 361         definition(def),
 362         props(vars)
 363     { }
 364
 365     osg::Vec2 pos; // projected position
 366     osg::Vec2 endPos;
 367     double headingDeg;
 368     SymbolDef* definition;
 369     SGPropertyNode_ptr props;
 370
 371     string text() const
 372     {
 373         assert(definition->hasText);
 374         string r;
 375         size_t lastPos = 0;
 376
 377         while (true) {
 378             size_t pos = definition->textTemplate.find('{', lastPos);
 379             if (pos == string::npos) { // no more replacements
 380                 r.append(definition->textTemplate.substr(lastPos));
 381                 break;
 382             }
 383
 384             r.append(definition->textTemplate.substr(lastPos, pos - lastPos));
 385
 386             size_t endReplacement = definition->textTemplate.find('}', pos+1);
 387             if (endReplacement <= pos) {
 388                 return "bad replacement";
 389             }
 390
 391             string spec = definition->textTemplate.substr(pos + 1, endReplacement - (pos + 1));
 392         // look for formatter in spec
 393             size_t colonPos = spec.find(':');
 394             if (colonPos == string::npos) {
 395             // simple replacement
 396                 r.append(props->getStringValue(spec));
 397             } else {
 398                 string format = spec.substr(colonPos + 1);
 399                 string prop = spec.substr(0, colonPos);
 400                 r.append(formatPropertyValue(props->getNode(prop), format));
 401             }
 402
 403             lastPos = endReplacement + 1;
 404         }
 405
 406         return r;
 407     }
 408 };
 409
 410 //////////////////////////////////////////////////////////////////
 411
 412 NavDisplay::NavDisplay(SGPropertyNode *node) :
 413     _name(node->getStringValue("name", "nd")),
 414     _num(node->getIntValue("number", 0)),
 415     _time(0.0),
 416     _updateInterval(node->getDoubleValue("update-interval-sec", 0.1)),
 417     _forceUpdate(true),
 418     _odg(0),
 419     _scale(0),
 420     _view_heading(0),
 421     _font_size(0),
 422     _font_spacing(0),
 423     _rangeNm(0)
 424 {
 425     _Instrument = fgGetNode(string("/instrumentation/" + _name).c_str(), _num, true);
 426     _font_node = _Instrument->getNode("font", true);
 427
 428 #define INITFONT(p, val, type) if (!_font_node->hasValue(p)) _font_node->set##type##Value(p, val)
 429     INITFONT("name", DEFAULT_FONT, String);
 430     INITFONT("size", 8, Float);
 431     INITFONT("line-spacing", 0.25, Float);
 432     INITFONT("color/red", 0, Float);
 433     INITFONT("color/green", 0.8, Float);
 434     INITFONT("color/blue", 0, Float);
 435     INITFONT("color/alpha", 1, Float);
 436 #undef INITFONT
 437
 438     _textureSize = _Instrument->getNode("symbol-texture-size", true)->getIntValue();
 439     SGPropertyNode* symbolsNode = node->getNode("symbols");
 440     SGPropertyNode* symbol;
 441
 442     map<string, SymbolDef*> definitionDict;
 443     for (int i = 0; (symbol = symbolsNode->getChild("symbol", i)) != NULL; ++i) {
 444         SymbolDef* def = new SymbolDef;
 445         if (!def->initFromNode(symbol, this)) {
 446           delete def;
 447           continue;
 448         }
 449
 450         const char* id = symbol->getStringValue("id");
 451         if (id && strlen(id)) {
 452             definitionDict[id] = def;
 453         }
 454
 455         _definitions.push_back(def);
 456     } // of symbol definition parsing
 457
 458     SGPropertyNode* rulesNode = node->getNode("rules");
 459     if (rulesNode) {
 460         SGPropertyNode* rule;
 461
 462         for (int i = 0; (rule = rulesNode->getChild("rule", i)) != NULL; ++i) {
 463             SymbolRule* r = new SymbolRule;
 464             if (!r->initFromNode(rule, this)) {
 465                 delete r;
 466                 continue;
 467             }
 468
 469             const char* id = symbol->getStringValue("symbol");
 470             if (id && strlen(id) && (definitionDict.find(id) != definitionDict.end())) {
 471                 r->setDefinition(definitionDict[id]);
 472             } else {
 473                 SG_LOG(SG_INSTR, SG_WARN, "symbol rule has missing/unknown definition id:" << id);
 474                 delete r;
 475                 continue;
 476             }
 477
 478             addRule(r);
 479         } // of symbol rule parsing
 480     }
 481
 482 }
 483
 484
 485 NavDisplay::~NavDisplay()
 486 {
 487   delete _odg;
 488 }
 489
 490 void
 491 NavDisplay::init ()
 492 {
 493     _cachedItemsValid = false;
 494     _cacheListener.reset(new CacheListener(this));
 495     _forceUpdateListener.reset(new ForceUpdateListener(this));
 496
 497     _serviceable_node = _Instrument->getNode("serviceable", true);
 498     _rangeNode = _Instrument->getNode("range", true);
 499     if (!_rangeNode->hasValue()) {
 500       _rangeNode->setDoubleValue(40.0);
 501     }
 502     _rangeNode->addChangeListener(_cacheListener.get());
 503     _rangeNode->addChangeListener(_forceUpdateListener.get());
 504
 505     _xCenterNode = _Instrument->getNode("x-center");
 506     if (!_xCenterNode->hasValue()) {
 507       _xCenterNode->setDoubleValue(0.5);
 508     }
 509     _xCenterNode->addChangeListener(_forceUpdateListener.get());
 510     _yCenterNode = _Instrument->getNode("y-center");
 511     if (!_yCenterNode->hasValue()) {
 512       _yCenterNode->setDoubleValue(0.5);
 513     }
 514     _yCenterNode->addChangeListener(_forceUpdateListener.get());
 515
 516     // texture name to use in 2D and 3D instruments
 517     _texture_path = _Instrument->getStringValue("radar-texture-path",
 518         "Aircraft/Instruments/Textures/od_wxradar.rgb");
 519
 520     string path = _Instrument->getStringValue("symbol-texture-path",
 521         "Aircraft/Instruments/Textures/nd-symbols.png");
 522     SGPath tpath = globals->resolve_aircraft_path(path);
 523     if (!tpath.exists()) {
 524       SG_LOG(SG_INSTR, SG_WARN, "ND symbol texture not found:" << path);
 525     }
 526
 527     // no mipmap or else alpha will mix with pixels on the border of shapes, ruining the effect
 528     _symbolTexture = SGLoadTexture2D(tpath, NULL, false, false);
 529
 530     _odg = new FGODGauge;
 531     _odg->setSize(_Instrument->getIntValue("texture-size", 512));
 532
 533     _route = static_cast<FGRouteMgr*>(globals->get_subsystem("route-manager"));
 534
 535     _navRadio1Node = fgGetNode("/instrumentation/nav[0]", true);
 536     _navRadio2Node = fgGetNode("/instrumentation/nav[1]", true);
 537
 538     _excessDataNode = _Instrument->getChild("excess-data", 0, true);
 539     _excessDataNode->setBoolValue(false);
 540     _testModeNode = _Instrument->getChild("test-mode", 0, true);
 541     _testModeNode->setBoolValue(false);
 542
 543     _viewHeadingNode = _Instrument->getChild("view-heading-deg", 0, true);
 544 // OSG geometry setup
 545     _radarGeode = new osg::Geode;
 546
 547     _geom = new osg::Geometry;
 548     _geom->setUseDisplayList(false);
 549
 550     osg::StateSet *stateSet = _geom->getOrCreateStateSet();
 551     stateSet->setTextureAttributeAndModes(0, _symbolTexture.get());
 552     stateSet->setDataVariance(osg::Object::STATIC);
 553
 554     // Initially allocate space for 128 quads
 555     _vertices = new osg::Vec2Array;
 556     _vertices->setDataVariance(osg::Object::DYNAMIC);
 557     _vertices->reserve(128 * 4);
 558     _geom->setVertexArray(_vertices);
 559     _texCoords = new osg::Vec2Array;
 560     _texCoords->setDataVariance(osg::Object::DYNAMIC);
 561     _texCoords->reserve(128 * 4);
 562     _geom->setTexCoordArray(0, _texCoords);
 563
 564     _quadColors = new osg::Vec4Array;
 565     _quadColors->setDataVariance(osg::Object::DYNAMIC);
 566     _geom->setColorBinding(osg::Geometry::BIND_PER_VERTEX);
 567     _geom->setColorArray(_quadColors);
 568
 569     _symbolPrimSet = new osg::DrawArrays(osg::PrimitiveSet::QUADS);
 570     _symbolPrimSet->setDataVariance(osg::Object::DYNAMIC);
 571     _geom->addPrimitiveSet(_symbolPrimSet);
 572
 573     _geom->setInitialBound(osg::BoundingBox(osg::Vec3f(-256.0f, -256.0f, 0.0f),
 574         osg::Vec3f(256.0f, 256.0f, 0.0f)));
 575
 576     _radarGeode->addDrawable(_geom);
 577     _odg->allocRT();
 578     // Texture in the 2D panel system
 579     FGTextureManager::addTexture(_texture_path.c_str(), _odg->getTexture());
 580
 581     _lineGeometry = new osg::Geometry;
 582     _lineGeometry->setUseDisplayList(false);
 583     stateSet = _lineGeometry->getOrCreateStateSet();
 584     osg::LineWidth *lw = new osg::LineWidth();
 585     lw->setWidth(2.0);
 586     stateSet->setAttribute(lw);
 587
 588     _lineVertices = new osg::Vec2Array;
 589     _lineVertices->setDataVariance(osg::Object::DYNAMIC);
 590     _lineVertices->reserve(128 * 4);
 591     _lineGeometry->setVertexArray(_lineVertices);
 592
 593
 594     _lineColors = new osg::Vec4Array;
 595     _lineColors->setDataVariance(osg::Object::DYNAMIC);
 596     _lineGeometry->setColorBinding(osg::Geometry::BIND_PER_VERTEX);
 597     _lineGeometry->setColorArray(_lineColors);
 598
 599     _linePrimSet = new osg::DrawArrays(osg::PrimitiveSet::LINES);
 600     _linePrimSet->setDataVariance(osg::Object::DYNAMIC);
 601     _lineGeometry->addPrimitiveSet(_linePrimSet);
 602
 603     _lineGeometry->setInitialBound(osg::BoundingBox(osg::Vec3f(-256.0f, -256.0f, 0.0f),
 604                                             osg::Vec3f(256.0f, 256.0f, 0.0f)));
 605
 606     _radarGeode->addDrawable(_lineGeometry);
 607
 608     _textGeode = new osg::Geode;
 609
 610     osg::Camera *camera = _odg->getCamera();
 611     camera->addChild(_radarGeode.get());
 612     camera->addChild(_textGeode.get());
 613     osg::Texture2D* tex = _odg->getTexture();
 614     camera->setProjectionMatrixAsOrtho2D(0, tex->getTextureWidth(),
 615         0, tex->getTextureHeight());
 616
 617     updateFont();
 618 }
 619
 620 void
 621 NavDisplay::update (double delta_time_sec)
 622 {
 623   if (!fgGetBool("sim/sceneryloaded", false)) {
 624     return;
 625   }
 626
 627   if (!_odg || !_serviceable_node->getBoolValue()) {
 628     _Instrument->setStringValue("status", "");
 629     return;
 630   }
 631
 632   if (_forceUpdate) {
 633     _forceUpdate = false;
 634     _time = 0.0;
 635   } else {
 636     _time += delta_time_sec;
 637     if (_time < _updateInterval){
 638       return;
 639     }
 640     _time -= _updateInterval;
 641   }
 642
 643   _rangeNm = _rangeNode->getFloatValue();
 644   if (_testModeNode->getBoolValue()) {
 645     _view_heading = 90;
 646   } else if (_Instrument->getBoolValue("aircraft-heading-up", true)) {
 647     _view_heading = fgGetDouble("/orientation/heading-deg");
 648   } else {
 649     _view_heading = _Instrument->getFloatValue("heading-up-deg", 0.0);
 650   }
 651   _viewHeadingNode->setDoubleValue(_view_heading);
 652
 653   double xCenterFrac = _xCenterNode->getDoubleValue();
 654   double yCenterFrac = _yCenterNode->getDoubleValue();
 655   int pixelSize = _odg->size();
 656
 657   int rangePixels = _Instrument->getIntValue("range-pixels", -1);
 658   if (rangePixels < 0) {
 659     // hacky - assume (as is very common) that x-frac doesn't vary, and
 660     // y-frac is used to position the center at either the top or bottom of
 661     // the pixel area. Measure from the center to the furthest edge (top or bottom)
 662     rangePixels = pixelSize * std::max(fabs(1.0 - yCenterFrac), fabs(yCenterFrac));
 663   }
 664
 665   _scale = rangePixels / _rangeNm;
 666   _Instrument->setDoubleValue("scale", _scale);
 667
 668
 669   _centerTrans = osg::Matrixf::translate(xCenterFrac * pixelSize,
 670       yCenterFrac * pixelSize, 0.0);
 671
 672 // scale from nm to display units, rotate so aircraft heading is up
 673 // (as opposed to north), and compensate for centering
 674   _projectMat = osg::Matrixf::scale(_scale, _scale, 1.0) *
 675       degRotation(-_view_heading) * _centerTrans;
 676
 677   _pos = globals->get_aircraft_position();
 678
 679     // invalidate the cache of positioned items, if we travelled more than 1nm
 680     if (_cachedItemsValid) {
 681         SGVec3d cartNow(SGVec3d::fromGeod(_pos));
 682         double movedNm = dist(_cachedPos, cartNow) * SG_METER_TO_NM;
 683         _cachedItemsValid = (movedNm < 1.0);
 684         if (!_cachedItemsValid) {
 685             SG_LOG(SG_INSTR, SG_INFO, "invalidating NavDisplay cache due to moving: " << movedNm);
 686         }
 687     }
 688
 689   _vertices->clear();
 690   _lineVertices->clear();
 691   _lineColors->clear();
 692   _quadColors->clear();
 693   _texCoords->clear();
 694   _textGeode->removeDrawables(0, _textGeode->getNumDrawables());
 695
 696   BOOST_FOREACH(SymbolInstance* si, _symbols) {
 697       delete si;
 698   }
 699   _symbols.clear();
 700
 701   BOOST_FOREACH(SymbolRule* r, _rules) {
 702       r->checkEnabled();
 703   }
 704
 705   if (_testModeNode->getBoolValue()) {
 706     addTestSymbols();
 707   } else {
 708     processRoute();
 709     processNavRadios();
 710     processAI();
 711     findItems();
 712     limitDisplayedSymbols();
 713   }
 714
 715   addSymbolsToScene();
 716
 717   _symbolPrimSet->set(osg::PrimitiveSet::QUADS, 0, _vertices->size());
 718   _symbolPrimSet->dirty();
 719   _linePrimSet->set(osg::PrimitiveSet::LINES, 0, _lineVertices->size());
 720   _linePrimSet->dirty();
 721 }
 722
 723
 724 void
 725 NavDisplay::updateFont()
 726 {
 727     float red = _font_node->getFloatValue("color/red");
 728     float green = _font_node->getFloatValue("color/green");
 729     float blue = _font_node->getFloatValue("color/blue");
 730     float alpha = _font_node->getFloatValue("color/alpha");
 731     _font_color.set(red, green, blue, alpha);
 732
 733     _font_size = _font_node->getFloatValue("size");
 734     _font_spacing = _font_size * _font_node->getFloatValue("line-spacing");
 735     string path = _font_node->getStringValue("name", DEFAULT_FONT);
 736
 737     SGPath tpath;
 738     if (path[0] != '/') {
 739         tpath = globals->get_fg_root();
 740         tpath.append("Fonts");
 741         tpath.append(path);
 742     } else {
 743         tpath = path;
 744     }
 745
 746     osg::ref_ptr<osgDB::ReaderWriter::Options> fontOptions = new osgDB::ReaderWriter::Options("monochrome");
 747     osg::ref_ptr<osgText::Font> font = osgText::readFontFile(tpath.c_str(), fontOptions.get());
 748
 749     if (font != 0) {
 750         _font = font;
 751         _font->setMinFilterHint(osg::Texture::NEAREST);
 752         _font->setMagFilterHint(osg::Texture::NEAREST);
 753         _font->setGlyphImageMargin(0);
 754         _font->setGlyphImageMarginRatio(0);
 755     }
 756 }
 757
 758 void NavDisplay::addSymbolToScene(SymbolInstance* sym)
 759 {
 760     SymbolDef* def = sym->definition;
 761
 762     osg::Vec2 verts[4];
 763     verts[0] = def->xy0;
 764     verts[1] = osg::Vec2(def->xy1.x(), def->xy0.y());
 765     verts[2] = def->xy1;
 766     verts[3] = osg::Vec2(def->xy0.x(), def->xy1.y());
 767
 768     if (def->rotateToHeading) {
 769         osg::Matrixf m(degRotation(sym->headingDeg - _view_heading));
 770         for (int i=0; i<4; ++i) {
 771             verts[i] = mult(verts[i], m);
 772         }
 773     }
 774
 775     osg::Vec2 pos = sym->pos;
 776     if (def->roundPos) {
 777         pos = osg::Vec2((int) pos.x(), (int) pos.y());
 778     }
 779
 780     _texCoords->push_back(def->uv0);
 781     _texCoords->push_back(osg::Vec2(def->uv1.x(), def->uv0.y()));
 782     _texCoords->push_back(def->uv1);
 783     _texCoords->push_back(osg::Vec2(def->uv0.x(), def->uv1.y()));
 784
 785     for (int i=0; i<4; ++i) {
 786         _vertices->push_back(verts[i] + pos);
 787         _quadColors->push_back(def->color);
 788     }
 789
 790     if (def->stretchSymbol) {
 791         osg::Vec2 stretchVerts[4];
 792         stretchVerts[0] = osg::Vec2(def->xy0.x(), def->stretchY2);
 793         stretchVerts[1] = osg::Vec2(def->xy1.x(), def->stretchY2);
 794         stretchVerts[2] = osg::Vec2(def->xy1.x(), def->stretchY3);
 795         stretchVerts[3] = osg::Vec2(def->xy0.x(), def->stretchY3);
 796
 797         osg::Matrixf m(degRotation(sym->headingDeg - _view_heading));
 798         for (int i=0; i<4; ++i) {
 799             stretchVerts[i] = mult(stretchVerts[i], m);
 800         }
 801
 802     // stretched quad
 803         _vertices->push_back(verts[2] + pos);
 804         _vertices->push_back(stretchVerts[1] + sym->endPos);
 805         _vertices->push_back(stretchVerts[0] + sym->endPos);
 806         _vertices->push_back(verts[3] + pos);
 807
 808         _texCoords->push_back(def->uv1);
 809         _texCoords->push_back(osg::Vec2(def->uv1.x(), def->stretchV2));
 810         _texCoords->push_back(osg::Vec2(def->uv0.x(), def->stretchV2));
 811         _texCoords->push_back(osg::Vec2(def->uv0.x(), def->uv1.y()));
 812
 813         for (int i=0; i<4; ++i) {
 814             _quadColors->push_back(def->color);
 815         }
 816
 817     // quad three, for the end portion
 818         for (int i=0; i<4; ++i) {
 819             _vertices->push_back(stretchVerts[i] + sym->endPos);
 820             _quadColors->push_back(def->color);
 821         }
 822
 823         _texCoords->push_back(osg::Vec2(def->uv0.x(), def->stretchV2));
 824         _texCoords->push_back(osg::Vec2(def->uv1.x(), def->stretchV2));
 825         _texCoords->push_back(osg::Vec2(def->uv1.x(), def->stretchV3));
 826         _texCoords->push_back(osg::Vec2(def->uv0.x(), def->stretchV3));
 827     }
 828
 829     if (def->drawLine) {
 830         addLine(sym->pos, sym->endPos, def->lineColor);
 831     }
 832
 833     if (!def->hasText) {
 834         return;
 835     }
 836
 837     osgText::Text* t = new osgText::Text;
 838     t->setFont(_font.get());
 839     t->setFontResolution(12, 12);
 840     t->setCharacterSize(_font_size);
 841     t->setLineSpacing(_font_spacing);
 842     t->setColor(def->textColor);
 843     t->setAlignment(def->alignment);
 844     t->setText(sym->text());
 845
 846
 847     osg::Vec2 textPos = def->textOffset + pos;
 848 // ensure we use ints here, or text visual quality goes bad
 849     t->setPosition(osg::Vec3((int)textPos.x(), (int)textPos.y(), 0));
 850     _textGeode->addDrawable(t);
 851 }
 852
 853 class OrderByPriority
 854 {
 855 public:
 856     bool operator()(SymbolInstance* a, SymbolInstance* b)
 857     {
 858         return a->definition->priority > b->definition->priority;
 859     }
 860 };
 861
 862 void NavDisplay::limitDisplayedSymbols()
 863 {
 864     unsigned int maxSymbols = _Instrument->getIntValue("max-symbols", 100);
 865     if (_symbols.size() <= maxSymbols) {
 866         _excessDataNode->setBoolValue(false);
 867         return;
 868     }
 869
 870     std::sort(_symbols.begin(), _symbols.end(), OrderByPriority());
 871     _symbols.resize(maxSymbols);
 872     _excessDataNode->setBoolValue(true);
 873 }
 874
 875 class OrderByZ
 876 {
 877 public:
 878     bool operator()(SymbolInstance* a, SymbolInstance* b)
 879     {
 880         return a->definition->zOrder > b->definition->zOrder;
 881     }
 882 };
 883
 884 void NavDisplay::addSymbolsToScene()
 885 {
 886     std::sort(_symbols.begin(), _symbols.end(), OrderByZ());
 887     BOOST_FOREACH(SymbolInstance* sym, _symbols) {
 888         addSymbolToScene(sym);
 889     }
 890 }
 891
 892 void NavDisplay::addLine(osg::Vec2 a, osg::Vec2 b, const osg::Vec4& color)
 893 {
 894     _lineVertices->push_back(a);
 895     _lineVertices->push_back(b);
 896     _lineColors->push_back(color);
 897     _lineColors->push_back(color);
 898 }
 899
 900 osg::Vec2 NavDisplay::projectBearingRange(double bearingDeg, double rangeNm) const
 901 {
 902     osg::Vec3 p(0, rangeNm, 0.0);
 903     p = degRotation(bearingDeg).preMult(p);
 904     p = _projectMat.preMult(p);
 905     return osg::Vec2(p.x(), p.y());
 906 }
 907
 908 osg::Vec2 NavDisplay::projectGeod(const SGGeod& geod) const
 909 {
 910     double rangeM, bearing, az2;
 911     SGGeodesy::inverse(_pos, geod, bearing, az2, rangeM);
 912     return projectBearingRange(bearing, rangeM * SG_METER_TO_NM);
 913 }
 914
 915 class Filter : public FGPositioned::Filter
 916 {
 917 public:
 918     double minRunwayLengthFt;
 919
 920     virtual bool pass(FGPositioned* aPos) const
 921     {
 922         if (aPos->type() == FGPositioned::FIX) {
 923             string ident(aPos->ident());
 924             // ignore fixes which end in digits
 925             if ((ident.size() > 4) && isdigit(ident[3]) && isdigit(ident[4])) {
 926                 return false;
 927             }
 928         }
 929
 930         if (aPos->type() == FGPositioned::AIRPORT) {
 931           FGAirport* apt = (FGAirport*) aPos;
 932           if (!apt->hasHardRunwayOfLengthFt(minRunwayLengthFt)) {
 933             return false;
 934           }
 935         }
 936
 937         return true;
 938     }
 939
 940     virtual FGPositioned::Type minType() const {
 941         return FGPositioned::AIRPORT;
 942     }
 943
 944     virtual FGPositioned::Type maxType() const {
 945         return FGPositioned::OBSTACLE;
 946     }
 947 };
 948
 949 void NavDisplay::findItems()
 950 {
 951     if (!_cachedItemsValid) {
 952         SG_LOG(SG_INSTR, SG_INFO, "re-validating NavDisplay cache");
 953         Filter filt;
 954         filt.minRunwayLengthFt = 2000;
 955         _itemsInRange = FGPositioned::findWithinRange(_pos, _rangeNm, &filt);
 956         _cachedItemsValid = true;
 957         _cachedPos = SGVec3d::fromGeod(_pos);
 958     }
 959
 960     BOOST_FOREACH(FGPositioned* pos, _itemsInRange) {
 961         foundPositionedItem(pos);
 962     }
 963 }
 964
 965 void NavDisplay::processRoute()
 966 {
 967     _routeSources.clear();
 968     RoutePath path(_route->waypts());
 969     int current = _route->currentIndex();
 970
 971     for (int w=0; w<_route->numWaypts(); ++w) {
 972         flightgear::WayptRef wpt(_route->wayptAtIndex(w));
 973         _routeSources.insert(wpt->source());
 974
 975         string_set state;
 976         state.insert("on-active-route");
 977
 978         if (w < current) {
 979             state.insert("passed");
 980         }
 981
 982         if (w == current) {
 983             state.insert("current-wp");
 984         }
 985
 986         if (w > current) {
 987             state.insert("future");
 988         }
 989
 990         if (w == (current + 1)) {
 991             state.insert("next-wp");
 992         }
 993
 994         SymbolRuleVector rules;
 995         findRules("waypoint" , state, rules);
 996         if (rules.empty()) {
 997             return; // no rules matched, we can skip this item
 998         }
 999
1000         SGGeod g = path.positionForIndex(w);
1001         SGPropertyNode* vars = _route->wayptNodeAtIndex(w);
1002         double heading;
1003         computeWayptPropsAndHeading(wpt, g, vars, heading);
1004
1005         osg::Vec2 projected = projectGeod(g);
1006         BOOST_FOREACH(SymbolRule* r, rules) {
1007             addSymbolInstance(projected, heading, r->getDefinition(), vars);
1008
1009             if (r->getDefinition()->drawRouteLeg) {
1010                 SGGeodVec gv(path.pathForIndex(w));
1011                 if (!gv.empty()) {
1012                     osg::Vec2 pr = projectGeod(gv[0]);
1013                     for (unsigned int i=1; i<gv.size(); ++i) {
1014                         osg::Vec2 p = projectGeod(gv[i]);
1015                         addLine(pr, p, r->getDefinition()->lineColor);
1016                         pr = p;
1017                     }
1018                 }
1019             } // of leg drawing enabled
1020         } // of matching rules iteration
1021     } // of waypoints iteration
1022 }
1023
1024 void NavDisplay::computeWayptPropsAndHeading(flightgear::Waypt* wpt, const SGGeod& pos, SGPropertyNode* nd, double& heading)
1025 {
1026     double rangeM, az2;
1027     SGGeodesy::inverse(_pos, pos, heading, az2, rangeM);
1028     nd->setIntValue("radial", heading);
1029     nd->setDoubleValue("distance-nm", rangeM * SG_METER_TO_NM);
1030
1031     heading = nd->getDoubleValue("leg-bearing-true-deg");
1032 }
1033
1034 void NavDisplay::processNavRadios()
1035 {
1036     _nav1Station = processNavRadio(_navRadio1Node);
1037     _nav2Station = processNavRadio(_navRadio2Node);
1038
1039     foundPositionedItem(_nav1Station);
1040     foundPositionedItem(_nav2Station);
1041 }
1042
1043 FGNavRecord* NavDisplay::processNavRadio(const SGPropertyNode_ptr& radio)
1044 {
1045     double mhz = radio->getDoubleValue("frequencies/selected-mhz", 0.0);
1046     FGNavRecord* nav = globals->get_navlist()->findByFreq(mhz, _pos);
1047     if (!nav || (nav->ident() != radio->getStringValue("nav-id"))) {
1048         // station was not found
1049         return NULL;
1050     }
1051
1052
1053     return nav;
1054 }
1055
1056 bool NavDisplay::anyRuleForType(const string& type) const
1057 {
1058     BOOST_FOREACH(SymbolRule* r, _rules) {
1059         if (!r->enabled) {
1060             continue;
1061         }
1062
1063         if (r->type == type) {
1064             return true;
1065         }
1066     }
1067
1068     return false;
1069 }
1070
1071 bool NavDisplay::anyRuleMatches(const string& type, const string_set& states) const
1072 {
1073     BOOST_FOREACH(SymbolRule* r, _rules) {
1074         if (!r->enabled || (r->type != type)) {
1075             continue;
1076         }
1077
1078         if (r->matches(states)) {
1079             return true;
1080         }
1081     } // of rules iteration
1082
1083     return false;
1084 }
1085
1086 void NavDisplay::findRules(const string& type, const string_set& states, SymbolRuleVector& rules)
1087 {
1088     BOOST_FOREACH(SymbolRule* candidate, _rules) {
1089         if (!candidate->enabled || (candidate->type != type)) {
1090             continue;
1091         }
1092
1093         if (candidate->matches(states)) {
1094             rules.push_back(candidate);
1095         }
1096     }
1097 }
1098
1099 void NavDisplay::foundPositionedItem(FGPositioned* pos)
1100 {
1101     if (!pos) {
1102         return;
1103     }
1104
1105     string type = FGPositioned::nameForType(pos->type());
1106     if (!anyRuleForType(type)) {
1107         return; // not diplayed at all, we're done
1108     }
1109
1110     string_set states;
1111     computePositionedState(pos, states);
1112
1113     SymbolRuleVector rules;
1114     findRules(type, states, rules);
1115     if (rules.empty()) {
1116         return; // no rules matched, we can skip this item
1117     }
1118
1119     SGPropertyNode_ptr vars(new SGPropertyNode);
1120     double heading;
1121     computePositionedPropsAndHeading(pos, vars, heading);
1122
1123     osg::Vec2 projected = projectGeod(pos->geod());
1124     if (pos->type() == FGPositioned::RUNWAY) {
1125         FGRunway* rwy = (FGRunway*) pos;
1126         projected = projectGeod(rwy->threshold());
1127     }
1128
1129     BOOST_FOREACH(SymbolRule* r, rules) {
1130         SymbolInstance* ins = addSymbolInstance(projected, heading, r->getDefinition(), vars);
1131         if (pos->type() == FGPositioned::RUNWAY) {
1132             FGRunway* rwy = (FGRunway*) pos;
1133             ins->endPos = projectGeod(rwy->end());
1134         }
1135     }
1136 }
1137
1138 void NavDisplay::computePositionedPropsAndHeading(FGPositioned* pos, SGPropertyNode* nd, double& heading)
1139 {
1140     nd->setStringValue("id", pos->ident());
1141     nd->setStringValue("name", pos->name());
1142     nd->setDoubleValue("elevation-ft", pos->elevation());
1143     nd->setIntValue("heading-deg", 0);
1144     heading = 0.0;
1145
1146     switch (pos->type()) {
1147     case FGPositioned::VOR:
1148     case FGPositioned::LOC:
1149     case FGPositioned::TACAN: {
1150         FGNavRecord* nav = static_cast<FGNavRecord*>(pos);
1151         nd->setDoubleValue("frequency-mhz", nav->get_freq());
1152
1153         if (pos == _nav1Station) {
1154             heading = _navRadio1Node->getDoubleValue("radials/target-radial-deg");
1155         } else if (pos == _nav2Station) {
1156             heading = _navRadio2Node->getDoubleValue("radials/target-radial-deg");
1157         }
1158
1159         nd->setIntValue("heading-deg", heading);
1160         break;
1161     }
1162
1163     case FGPositioned::AIRPORT:
1164     case FGPositioned::SEAPORT:
1165     case FGPositioned::HELIPORT:
1166
1167         break;
1168
1169     case FGPositioned::RUNWAY: {
1170         FGRunway* rwy = static_cast<FGRunway*>(pos);
1171         heading = rwy->headingDeg();
1172         nd->setDoubleValue("heading-deg", heading);
1173         nd->setIntValue("length-ft", rwy->lengthFt());
1174         nd->setStringValue("airport", rwy->airport()->ident());
1175         break;
1176     }
1177
1178     default:
1179         break;
1180     }
1181 }
1182
1183 void NavDisplay::computePositionedState(FGPositioned* pos, string_set& states)
1184 {
1185     if (_routeSources.count(pos) != 0) {
1186         states.insert("on-active-route");
1187     }
1188
1189     switch (pos->type()) {
1190     case FGPositioned::VOR:
1191     case FGPositioned::LOC:
1192         if (pos == _nav1Station) {
1193             states.insert("tuned");
1194             states.insert("nav1");
1195         }
1196
1197         if (pos == _nav2Station) {
1198             states.insert("tuned");
1199             states.insert("nav2");
1200         }
1201         break;
1202
1203     case FGPositioned::AIRPORT:
1204     case FGPositioned::SEAPORT:
1205     case FGPositioned::HELIPORT:
1206         // mark alternates!
1207         // once the FMS system has some way to tell us about them, of course
1208
1209         if (pos == _route->departureAirport()) {
1210             states.insert("departure");
1211         }
1212
1213         if (pos == _route->destinationAirport()) {
1214             states.insert("destination");
1215         }
1216         break;
1217
1218     case FGPositioned::RUNWAY:
1219         if (pos == _route->departureRunway()) {
1220             states.insert("departure");
1221         }
1222
1223         if (pos == _route->destinationRunway()) {
1224             states.insert("destination");
1225         }
1226         break;
1227
1228     case FGPositioned::OBSTACLE:
1229     #if 0
1230         FGObstacle* obs = (FGObstacle*) pos;
1231         if (obj->isLit()) {
1232             states.insert("lit");
1233         }
1234
1235         if (obj->getHeightAGLFt() >= 1000) {
1236             states.insert("greater-1000-ft");
1237         }
1238     #endif
1239         break;
1240
1241     default:
1242         break;
1243     } // FGPositioned::Type switch
1244 }
1245
1246 static string mapAINodeToType(SGPropertyNode* model)
1247 {
1248   // assume all multiplayer items are aircraft for the moment. Not ideal.
1249   if (!strcmp(model->getName(), "multiplayer")) {
1250     return "ai-aircraft";
1251   }
1252
1253   return string("ai-") + model->getName();
1254 }
1255
1256 void NavDisplay::processAI()
1257 {
1258     SGPropertyNode *ai = fgGetNode("/ai/models", true);
1259     for (int i = ai->nChildren() - 1; i >= 0; i--) {
1260         SGPropertyNode *model = ai->getChild(i);
1261         if (!model->nChildren()) {
1262             continue;
1263         }
1264
1265     // prefix types with 'ai-', to avoid any chance of namespace collisions
1266     // with fg-positioned.
1267         string_set ss;
1268         computeAIStates(model, ss);
1269         SymbolRuleVector rules;
1270         findRules(mapAINodeToType(model), ss, rules);
1271         if (rules.empty()) {
1272             return; // no rules matched, we can skip this item
1273         }
1274
1275         double heading = model->getDoubleValue("orientation/true-heading-deg");
1276         SGGeod aiModelPos = SGGeod::fromDegFt(model->getDoubleValue("position/longitude-deg"),
1277                                             model->getDoubleValue("position/latitude-deg"),
1278                                             model->getDoubleValue("position/altitude-ft"));
1279     // compute some additional props
1280         int fl = (aiModelPos.getElevationFt() / 1000);
1281         model->setIntValue("flight-level", fl * 10);
1282
1283         osg::Vec2 projected = projectGeod(aiModelPos);
1284         BOOST_FOREACH(SymbolRule* r, rules) {
1285             addSymbolInstance(projected, heading, r->getDefinition(), (SGPropertyNode*) model);
1286         }
1287     } // of ai models iteration
1288 }
1289
1290 void NavDisplay::computeAIStates(const SGPropertyNode* ai, string_set& states)
1291 {
1292     int threatLevel = ai->getIntValue("tcas/threat-level",-1);
1293     if (threatLevel < 1)
1294       threatLevel = 0;
1295
1296     states.insert("tcas");
1297
1298     std::ostringstream os;
1299     os << "tcas-threat-level-" << threatLevel;
1300     states.insert(os.str());
1301
1302     double vspeed = ai->getDoubleValue("velocities/vertical-speed-fps");
1303     if (vspeed < -3.0) {
1304         states.insert("descending");
1305     } else if (vspeed > 3.0) {
1306         states.insert("climbing");
1307     }
1308 }
1309
1310 SymbolInstance* NavDisplay::addSymbolInstance(const osg::Vec2& proj, double heading, SymbolDef* def, SGPropertyNode* vars)
1311 {
1312     if (isProjectedClipped(proj)) {
1313         return NULL;
1314     }
1315
1316     SymbolInstance* sym = new SymbolInstance(proj, heading, def, vars);
1317     _symbols.push_back(sym);
1318     return sym;
1319 }
1320
1321 bool NavDisplay::isProjectedClipped(const osg::Vec2& projected) const
1322 {
1323     double size = _odg->size();
1324     return (projected.x() < 0.0) ||
1325         (projected.y() < 0.0) ||
1326         (projected.x() >= size) ||
1327             (projected.y() >= size);
1328 }
1329
1330 void NavDisplay::addTestSymbol(const std::string& type, const std::string& states, const SGGeod& pos, double heading, SGPropertyNode* vars)
1331 {
1332   string_set stateSet;
1333   BOOST_FOREACH(std::string s, simgear::strutils::split(states, ",")) {
1334     stateSet.insert(s);
1335   }
1336
1337   SymbolRuleVector rules;
1338   findRules(type, stateSet, rules);
1339   if (rules.empty()) {
1340     return; // no rules matched, we can skip this item
1341   }
1342
1343   osg::Vec2 projected = projectGeod(pos);
1344   BOOST_FOREACH(SymbolRule* r, rules) {
1345     addSymbolInstance(projected, heading, r->getDefinition(), vars);
1346   }
1347 }
1348
1349 void NavDisplay::addTestSymbols()
1350 {
1351   _pos = SGGeod::fromDeg(-122.3748889, 37.6189722); // KSFO
1352
1353   SGGeod a1;
1354   double dummy;
1355   SGGeodesy::direct(_pos, 45.0, 20.0 * SG_NM_TO_METER, a1, dummy);
1356
1357   addTestSymbol("airport", "", a1, 0.0, NULL);
1358
1359   SGGeodesy::direct(_pos, 95.0, 40.0 * SG_NM_TO_METER, a1, dummy);
1360
1361   addTestSymbol("vor", "", a1, 0.0, NULL);
1362
1363   SGGeodesy::direct(_pos, 120, 80.0 * SG_NM_TO_METER, a1, dummy);
1364
1365   addTestSymbol("airport", "destination", a1, 0.0, NULL);
1366
1367   SGGeodesy::direct(_pos, 80.0, 20.0 * SG_NM_TO_METER, a1, dummy);
1368   addTestSymbol("fix", "", a1, 0.0, NULL);
1369
1370
1371   SGGeodesy::direct(_pos, 140.0, 20.0 * SG_NM_TO_METER, a1, dummy);
1372   addTestSymbol("fix", "", a1, 0.0, NULL);
1373
1374   SGGeodesy::direct(_pos, 110.0, 10.0 * SG_NM_TO_METER, a1, dummy);
1375   addTestSymbol("fix", "", a1, 0.0, NULL);
1376
1377   SGGeodesy::direct(_pos, 110.0, 5.0 * SG_NM_TO_METER, a1, dummy);
1378   addTestSymbol("fix", "", a1, 0.0, NULL);
1379 }
1380
1381 void NavDisplay::addRule(SymbolRule* r)
1382 {
1383     _rules.push_back(r);
1384 }
1385