1 // navigation display texture
3 // Written by James Turner, forked from wxradar code
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.
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.
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.
26 #include "NavDisplay.hxx"
29 #include <boost/foreach.hpp>
30 #include <boost/algorithm/string/case_conv.hpp>
34 #include <osg/Geometry>
35 #include <osg/Matrixf>
36 #include <osg/PrimitiveSet>
37 #include <osg/StateSet>
38 #include <osg/LineWidth>
39 #include <osg/Version>
41 #include <simgear/constants.h>
42 #include <simgear/misc/sg_path.hxx>
43 #include <simgear/scene/model/model.hxx>
44 #include <simgear/structure/exception.hxx>
45 #include <simgear/misc/sg_path.hxx>
46 #include <simgear/misc/strutils.hxx>
47 #include <simgear/math/sg_geodesy.hxx>
51 #include <iostream> // for cout, endl
53 using std::stringstream;
55 using std::setprecision;
64 #include <Main/fg_props.hxx>
65 #include <Main/globals.hxx>
67 #include <Navaids/routePath.hxx>
68 #include <Autopilot/route_mgr.hxx>
69 #include <Navaids/navrecord.hxx>
70 #include <Navaids/navlist.hxx>
71 #include <Navaids/fix.hxx>
72 #include <Airports/simple.hxx>
73 #include <Airports/runways.hxx>
74 #include "od_gauge.hxx"
76 static const char *DEFAULT_FONT = "typewriter.txf";
79 osg::Matrixf degRotation(float angle)
81 return osg::Matrixf::rotate(angle * SG_DEGREES_TO_RADIANS, 0.0f, 0.0f, -1.0f);
84 static osg::Vec4 readColor(SGPropertyNode* colorNode, const osg::Vec4& c)
87 result.r() = colorNode->getDoubleValue("red", c.r());
88 result.g() = colorNode->getDoubleValue("green", c.g());
89 result.b() = colorNode->getDoubleValue("blue", c.b());
90 result.a() = colorNode->getDoubleValue("alpha", c.a());
94 static osgText::Text::AlignmentType readAlignment(const std::string& t)
96 if (t == "left-top") {
97 return osgText::Text::LEFT_TOP;
98 } else if (t == "left-center") {
99 return osgText::Text::LEFT_CENTER;
100 } else if (t == "left-bottom") {
101 return osgText::Text::LEFT_BOTTOM;
102 } else if (t == "center-top") {
103 return osgText::Text::CENTER_TOP;
104 } else if (t == "center-center") {
105 return osgText::Text::CENTER_CENTER;
106 } else if (t == "center-bottom") {
107 return osgText::Text::CENTER_BOTTOM;
108 } else if (t == "right-top") {
109 return osgText::Text::RIGHT_TOP;
110 } else if (t == "right-center") {
111 return osgText::Text::RIGHT_CENTER;
112 } else if (t == "right-bottom") {
113 return osgText::Text::RIGHT_BOTTOM;
114 } else if (t == "left-baseline") {
115 return osgText::Text::LEFT_BASE_LINE;
116 } else if (t == "center-baseline") {
117 return osgText::Text::CENTER_BASE_LINE;
118 } else if (t == "right-baseline") {
119 return osgText::Text::RIGHT_BASE_LINE;
122 return osgText::Text::BASE_LINE;
125 static string formatPropertyValue(SGPropertyNode* nd, const string& format)
128 static char buf[512];
129 if (format.find('d') != string::npos) {
130 ::snprintf(buf, 512, format.c_str(), nd->getIntValue());
134 if (format.find('s') != string::npos) {
135 ::snprintf(buf, 512, format.c_str(), nd->getStringValue());
139 // assume it's a double/float
140 ::snprintf(buf, 512, format.c_str(), nd->getDoubleValue());
144 static osg::Vec2 mult(const osg::Vec2& v, const osg::Matrixf& m)
146 osg::Vec3 r = m.preMult(osg::Vec3(v.x(), v.y(), 0.0));
147 return osg::Vec2(r.x(), r.y());
150 class NavDisplay::CacheListener : public SGPropertyChangeListener
153 CacheListener(NavDisplay *nd) :
157 virtual void valueChanged (SGPropertyNode * prop)
159 _nd->invalidatePositionedCache();
165 class NavDisplay::ForceUpdateListener : public SGPropertyChangeListener
168 ForceUpdateListener(NavDisplay *nd) :
172 virtual void valueChanged (SGPropertyNode * prop)
180 ///////////////////////////////////////////////////////////////////
190 bool initFromNode(SGPropertyNode* node, NavDisplay* owner)
192 if (!node->getChild("type")) {
196 type = node->getStringValue("type");
197 boost::to_lower(type);
198 SGPropertyNode* enableNode = node->getChild("enable");
200 enable.reset(sgReadCondition(fgGetNode("/"), enableNode));
204 while (node->hasChild("state", n)) {
205 string m = node->getChild("state", n++)->getStringValue();
207 excluded_states.insert(m.substr(1));
209 required_states.insert(m);
211 } // of matches parsing
217 void setDefinition(SymbolDef* d)
222 SymbolDef* getDefinition() const
223 { return definition; }
225 bool matches(const string_set& states) const
227 BOOST_FOREACH(const string& s, required_states) {
228 if (states.count(s) == 0) {
233 BOOST_FOREACH(const string& s, excluded_states) {
234 if (states.count(s) != 0) {
242 // return if the enabled state changed (needs a cache update)
246 bool wasEnabled = enabled;
247 enabled = enable->test();
248 return (enabled != wasEnabled);
255 bool enabled; // cached enabled state
258 // record instances for limiting by count
261 SymbolDef* definition;
263 std::auto_ptr<SGCondition> enable;
264 string_set required_states;
265 string_set excluded_states;
271 SymbolDef() : limitCount(0) { }
273 bool initFromNode(SGPropertyNode* node, NavDisplay* owner)
275 if (node->getChild("type")) {
276 SymbolRule* builtinRule = new SymbolRule;
277 builtinRule->initFromNode(node, owner);
278 builtinRule->setDefinition(this);
279 owner->addRule(builtinRule);
282 if (node->hasChild("width")) {
283 float w = node->getFloatValue("width");
284 float h = node->getFloatValue("height", w);
290 xy0.x() = node->getFloatValue("x0", 0.0);
291 xy0.y() = node->getFloatValue("y0", 0.0);
292 xy1.x() = node->getFloatValue("x1", 5);
293 xy1.y() = node->getFloatValue("y1", 5);
296 double texSize = node->getFloatValue("texture-size", owner->textureSize());
298 uv0.x() = node->getFloatValue("u0", 0) / texSize;
299 uv0.y() = node->getFloatValue("v0", 0) / texSize;
300 uv1.x() = node->getFloatValue("u1", 1) / texSize;
301 uv1.y() = node->getFloatValue("v1", 1) / texSize;
303 color = readColor(node->getChild("color"), osg::Vec4(1, 1, 1, 1));
304 priority = node->getIntValue("priority", 0);
305 zOrder = node->getIntValue("zOrder", 0);
306 rotateToHeading = node->getBoolValue("rotate-to-heading", false);
307 roundPos = node->getBoolValue("round-position", true);
309 if (node->hasChild("text")) {
311 alignment = readAlignment(node->getStringValue("text-align"));
312 textTemplate = node->getStringValue("text");
313 textOffset.x() = node->getFloatValue("text-offset-x", 0);
314 textOffset.y() = node->getFloatValue("text-offset-y", 0);
315 textColor = readColor(node->getChild("text-color"), color);
317 SGPropertyNode* enableNode = node->getChild("text-enable");
319 textEnable.reset(sgReadCondition(fgGetNode("/"), enableNode));
323 drawLine = node->getBoolValue("draw-line", false);
324 lineColor = readColor(node->getChild("line-color"), color);
325 drawRouteLeg = node->getBoolValue("draw-leg", false);
327 stretchSymbol = node->getBoolValue("stretch-symbol", false);
329 stretchY2 = node->getFloatValue("y2");
330 stretchY3 = node->getFloatValue("y3");
331 stretchV2 = node->getFloatValue("v2") / texSize;
332 stretchV3 = node->getFloatValue("v3") / texSize;
335 SGPropertyNode* limitNode = node->getChild("limit");
337 limitCount = limitNode->getIntValue();
349 bool rotateToHeading;
350 bool roundPos; ///< should position be rounded to integer values
352 std::auto_ptr<SGCondition> textEnable;
353 bool textEnabled; ///< cache condition result
355 osg::Vec2 textOffset;
356 osgText::Text::AlignmentType alignment;
362 // symbol stretching creates three quads (instead of one) - a start,
363 // middle and end quad, positioned along the line of the symbol.
364 // X (and U) axis values determined by the values above, so we only need
365 // to define the Y (and V) values to build the other quads.
367 double stretchY2, stretchY3;
368 double stretchV2, stretchV3;
372 int limitCount, instanceCount;
378 SymbolInstance(const osg::Vec2& p, double h, SymbolDef* def, SGPropertyNode* vars) :
385 osg::Vec2 pos; // projected position
388 SymbolDef* definition;
389 SGPropertyNode_ptr props;
393 assert(definition->hasText);
398 size_t pos = definition->textTemplate.find('{', lastPos);
399 if (pos == string::npos) { // no more replacements
400 r.append(definition->textTemplate.substr(lastPos));
404 r.append(definition->textTemplate.substr(lastPos, pos - lastPos));
406 size_t endReplacement = definition->textTemplate.find('}', pos+1);
407 if (endReplacement <= pos) {
408 return "bad replacement";
411 string spec = definition->textTemplate.substr(pos + 1, endReplacement - (pos + 1));
412 // look for formatter in spec
413 size_t colonPos = spec.find(':');
414 if (colonPos == string::npos) {
415 // simple replacement
416 r.append(props->getStringValue(spec));
418 string format = spec.substr(colonPos + 1);
419 string prop = spec.substr(0, colonPos);
420 r.append(formatPropertyValue(props->getNode(prop), format));
423 lastPos = endReplacement + 1;
430 //////////////////////////////////////////////////////////////////
432 NavDisplay::NavDisplay(SGPropertyNode *node) :
433 _name(node->getStringValue("name", "nd")),
434 _num(node->getIntValue("number", 0)),
436 _updateInterval(node->getDoubleValue("update-interval-sec", 0.1)),
446 _Instrument = fgGetNode(string("/instrumentation/" + _name).c_str(), _num, true);
447 _font_node = _Instrument->getNode("font", true);
449 #define INITFONT(p, val, type) if (!_font_node->hasValue(p)) _font_node->set##type##Value(p, val)
450 INITFONT("name", DEFAULT_FONT, String);
451 INITFONT("size", 8, Float);
452 INITFONT("line-spacing", 0.25, Float);
453 INITFONT("color/red", 0, Float);
454 INITFONT("color/green", 0.8, Float);
455 INITFONT("color/blue", 0, Float);
456 INITFONT("color/alpha", 1, Float);
459 _textureSize = _Instrument->getNode("symbol-texture-size", true)->getIntValue();
460 SGPropertyNode* symbolsNode = node->getNode("symbols");
461 SGPropertyNode* symbol;
463 map<string, SymbolDef*> definitionDict;
464 for (int i = 0; (symbol = symbolsNode->getChild("symbol", i)) != NULL; ++i) {
465 SymbolDef* def = new SymbolDef;
466 if (!def->initFromNode(symbol, this)) {
471 const char* id = symbol->getStringValue("id");
472 if (id && strlen(id)) {
473 definitionDict[id] = def;
476 _definitions.push_back(def);
477 } // of symbol definition parsing
479 SGPropertyNode* rulesNode = node->getNode("rules");
481 SGPropertyNode* rule;
483 for (int i = 0; (rule = rulesNode->getChild("rule", i)) != NULL; ++i) {
484 SymbolRule* r = new SymbolRule;
485 if (!r->initFromNode(rule, this)) {
490 const char* id = symbol->getStringValue("symbol");
491 if (id && strlen(id) && (definitionDict.find(id) != definitionDict.end())) {
492 r->setDefinition(definitionDict[id]);
494 SG_LOG(SG_INSTR, SG_WARN, "symbol rule has missing/unknown definition id:" << id);
500 } // of symbol rule parsing
506 NavDisplay::~NavDisplay()
514 _cachedItemsValid = false;
515 _cacheListener.reset(new CacheListener(this));
516 _forceUpdateListener.reset(new ForceUpdateListener(this));
518 _serviceable_node = _Instrument->getNode("serviceable", true);
519 _rangeNode = _Instrument->getNode("range", true);
520 if (!_rangeNode->hasValue()) {
521 _rangeNode->setDoubleValue(40.0);
523 _rangeNode->addChangeListener(_cacheListener.get());
524 _rangeNode->addChangeListener(_forceUpdateListener.get());
526 _xCenterNode = _Instrument->getNode("x-center");
527 if (!_xCenterNode->hasValue()) {
528 _xCenterNode->setDoubleValue(0.5);
530 _xCenterNode->addChangeListener(_forceUpdateListener.get());
531 _yCenterNode = _Instrument->getNode("y-center");
532 if (!_yCenterNode->hasValue()) {
533 _yCenterNode->setDoubleValue(0.5);
535 _yCenterNode->addChangeListener(_forceUpdateListener.get());
537 // texture name to use in 2D and 3D instruments
538 _texture_path = _Instrument->getStringValue("radar-texture-path",
539 "Aircraft/Instruments/Textures/od_wxradar.rgb");
541 string path = _Instrument->getStringValue("symbol-texture-path",
542 "Aircraft/Instruments/Textures/nd-symbols.png");
543 SGPath tpath = globals->resolve_aircraft_path(path);
544 if (!tpath.exists()) {
545 SG_LOG(SG_INSTR, SG_WARN, "ND symbol texture not found:" << path);
548 // no mipmap or else alpha will mix with pixels on the border of shapes, ruining the effect
549 _symbolTexture = SGLoadTexture2D(tpath, NULL, false, false);
551 _odg = new FGODGauge;
552 _odg->setSize(_Instrument->getIntValue("texture-size", 512));
554 _route = static_cast<FGRouteMgr*>(globals->get_subsystem("route-manager"));
556 _navRadio1Node = fgGetNode("/instrumentation/nav[0]", true);
557 _navRadio2Node = fgGetNode("/instrumentation/nav[1]", true);
559 _excessDataNode = _Instrument->getChild("excess-data", 0, true);
560 _excessDataNode->setBoolValue(false);
561 _testModeNode = _Instrument->getChild("test-mode", 0, true);
562 _testModeNode->setBoolValue(false);
564 _viewHeadingNode = _Instrument->getChild("view-heading-deg", 0, true);
565 _userLatNode = _Instrument->getChild("user-latitude-deg", 0, true);
566 _userLonNode = _Instrument->getChild("user-longitude-deg", 0, true);
567 _userPositionEnable = _Instrument->getChild("user-position", 0, true);
569 _customSymbols = _Instrument->getChild("symbols", 0, true);
571 // OSG geometry setup
572 _radarGeode = new osg::Geode;
574 _geom = new osg::Geometry;
575 _geom->setUseDisplayList(false);
577 osg::StateSet *stateSet = _geom->getOrCreateStateSet();
578 stateSet->setTextureAttributeAndModes(0, _symbolTexture.get());
579 stateSet->setDataVariance(osg::Object::STATIC);
581 // Initially allocate space for 128 quads
582 _vertices = new osg::Vec2Array;
583 _vertices->setDataVariance(osg::Object::DYNAMIC);
584 _vertices->reserve(128 * 4);
585 _geom->setVertexArray(_vertices);
586 _texCoords = new osg::Vec2Array;
587 _texCoords->setDataVariance(osg::Object::DYNAMIC);
588 _texCoords->reserve(128 * 4);
589 _geom->setTexCoordArray(0, _texCoords);
591 _quadColors = new osg::Vec4Array;
592 _quadColors->setDataVariance(osg::Object::DYNAMIC);
593 _geom->setColorBinding(osg::Geometry::BIND_PER_VERTEX);
594 _geom->setColorArray(_quadColors);
596 _symbolPrimSet = new osg::DrawArrays(osg::PrimitiveSet::QUADS);
597 _symbolPrimSet->setDataVariance(osg::Object::DYNAMIC);
598 _geom->addPrimitiveSet(_symbolPrimSet);
600 _geom->setInitialBound(osg::BoundingBox(osg::Vec3f(-256.0f, -256.0f, 0.0f),
601 osg::Vec3f(256.0f, 256.0f, 0.0f)));
603 _radarGeode->addDrawable(_geom);
605 // Texture in the 2D panel system
606 FGTextureManager::addTexture(_texture_path.c_str(), _odg->getTexture());
608 _lineGeometry = new osg::Geometry;
609 _lineGeometry->setUseDisplayList(false);
610 stateSet = _lineGeometry->getOrCreateStateSet();
611 osg::LineWidth *lw = new osg::LineWidth();
613 stateSet->setAttribute(lw);
615 _lineVertices = new osg::Vec2Array;
616 _lineVertices->setDataVariance(osg::Object::DYNAMIC);
617 _lineVertices->reserve(128 * 4);
618 _lineGeometry->setVertexArray(_lineVertices);
621 _lineColors = new osg::Vec4Array;
622 _lineColors->setDataVariance(osg::Object::DYNAMIC);
623 _lineGeometry->setColorBinding(osg::Geometry::BIND_PER_VERTEX);
624 _lineGeometry->setColorArray(_lineColors);
626 _linePrimSet = new osg::DrawArrays(osg::PrimitiveSet::LINES);
627 _linePrimSet->setDataVariance(osg::Object::DYNAMIC);
628 _lineGeometry->addPrimitiveSet(_linePrimSet);
630 _lineGeometry->setInitialBound(osg::BoundingBox(osg::Vec3f(-256.0f, -256.0f, 0.0f),
631 osg::Vec3f(256.0f, 256.0f, 0.0f)));
633 _radarGeode->addDrawable(_lineGeometry);
635 _textGeode = new osg::Geode;
637 osg::Camera *camera = _odg->getCamera();
638 camera->addChild(_radarGeode.get());
639 camera->addChild(_textGeode.get());
640 osg::Texture2D* tex = _odg->getTexture();
641 camera->setProjectionMatrixAsOrtho2D(0, tex->getTextureWidth(),
642 0, tex->getTextureHeight());
648 NavDisplay::update (double delta_time_sec)
650 if (!fgGetBool("sim/sceneryloaded", false)) {
654 if (!_odg || !_serviceable_node->getBoolValue()) {
655 _Instrument->setStringValue("status", "");
660 _forceUpdate = false;
663 _time += delta_time_sec;
664 if (_time < _updateInterval){
667 _time -= _updateInterval;
670 _rangeNm = _rangeNode->getFloatValue();
671 if (_testModeNode->getBoolValue()) {
673 } else if (_Instrument->getBoolValue("aircraft-heading-up", true)) {
674 _view_heading = fgGetDouble("/orientation/heading-deg");
676 _view_heading = _Instrument->getFloatValue("heading-up-deg", 0.0);
678 _viewHeadingNode->setDoubleValue(_view_heading);
680 double xCenterFrac = _xCenterNode->getDoubleValue();
681 double yCenterFrac = _yCenterNode->getDoubleValue();
682 int pixelSize = _odg->size();
684 int rangePixels = _Instrument->getIntValue("range-pixels", -1);
685 if (rangePixels < 0) {
686 // hacky - assume (as is very common) that x-frac doesn't vary, and
687 // y-frac is used to position the center at either the top or bottom of
688 // the pixel area. Measure from the center to the furthest edge (top or bottom)
689 rangePixels = pixelSize * std::max(fabs(1.0 - yCenterFrac), fabs(yCenterFrac));
692 _scale = rangePixels / _rangeNm;
693 _Instrument->setDoubleValue("scale", _scale);
696 _centerTrans = osg::Matrixf::translate(xCenterFrac * pixelSize,
697 yCenterFrac * pixelSize, 0.0);
699 // scale from nm to display units, rotate so aircraft heading is up
700 // (as opposed to north), and compensate for centering
701 _projectMat = osg::Matrixf::scale(_scale, _scale, 1.0) *
702 degRotation(-_view_heading) * _centerTrans;
704 if (_userPositionEnable->getBoolValue()) {
705 _pos = SGGeod::fromDeg(_userLonNode->getDoubleValue(), _userLatNode->getDoubleValue());
707 _pos = globals->get_aircraft_position();
710 // invalidate the cache of positioned items, if we travelled more than 1nm
711 if (_cachedItemsValid) {
712 SGVec3d cartNow(SGVec3d::fromGeod(_pos));
713 double movedNm = dist(_cachedPos, cartNow) * SG_METER_TO_NM;
714 _cachedItemsValid = (movedNm < 1.0);
718 _lineVertices->clear();
719 _lineColors->clear();
720 _quadColors->clear();
722 _textGeode->removeDrawables(0, _textGeode->getNumDrawables());
724 BOOST_FOREACH(SymbolInstance* si, _symbols) {
729 BOOST_FOREACH(SymbolDef* d, _definitions) {
730 d->instanceCount = 0;
731 d->textEnabled = d->textEnable.get() ? d->textEnable->test() : true;
734 bool enableChanged = false;
735 BOOST_FOREACH(SymbolRule* r, _rules) {
736 enableChanged |= r->checkEnabled();
740 SG_LOG(SG_INSTR, SG_INFO, "NS rule enables changed, rebuilding cache");
741 _cachedItemsValid = false;
744 if (_testModeNode->getBoolValue()) {
750 processCustomSymbols();
752 limitDisplayedSymbols();
757 _symbolPrimSet->set(osg::PrimitiveSet::QUADS, 0, _vertices->size());
758 _symbolPrimSet->dirty();
759 _linePrimSet->set(osg::PrimitiveSet::LINES, 0, _lineVertices->size());
760 _linePrimSet->dirty();
765 NavDisplay::updateFont()
767 float red = _font_node->getFloatValue("color/red");
768 float green = _font_node->getFloatValue("color/green");
769 float blue = _font_node->getFloatValue("color/blue");
770 float alpha = _font_node->getFloatValue("color/alpha");
771 _font_color.set(red, green, blue, alpha);
773 _font_size = _font_node->getFloatValue("size");
774 _font_spacing = _font_size * _font_node->getFloatValue("line-spacing");
775 string path = _font_node->getStringValue("name", DEFAULT_FONT);
778 if (path[0] != '/') {
779 tpath = globals->get_fg_root();
780 tpath.append("Fonts");
786 osg::ref_ptr<osgDB::ReaderWriter::Options> fontOptions = new osgDB::ReaderWriter::Options("monochrome");
787 osg::ref_ptr<osgText::Font> font = osgText::readFontFile(tpath.c_str(), fontOptions.get());
791 _font->setMinFilterHint(osg::Texture::NEAREST);
792 _font->setMagFilterHint(osg::Texture::NEAREST);
793 _font->setGlyphImageMargin(0);
794 _font->setGlyphImageMarginRatio(0);
798 void NavDisplay::addSymbolToScene(SymbolInstance* sym)
800 SymbolDef* def = sym->definition;
804 verts[1] = osg::Vec2(def->xy1.x(), def->xy0.y());
806 verts[3] = osg::Vec2(def->xy0.x(), def->xy1.y());
808 if (def->rotateToHeading) {
809 osg::Matrixf m(degRotation(sym->headingDeg - _view_heading));
810 for (int i=0; i<4; ++i) {
811 verts[i] = mult(verts[i], m);
815 osg::Vec2 pos = sym->pos;
817 pos = osg::Vec2((int) pos.x(), (int) pos.y());
820 _texCoords->push_back(def->uv0);
821 _texCoords->push_back(osg::Vec2(def->uv1.x(), def->uv0.y()));
822 _texCoords->push_back(def->uv1);
823 _texCoords->push_back(osg::Vec2(def->uv0.x(), def->uv1.y()));
825 for (int i=0; i<4; ++i) {
826 _vertices->push_back(verts[i] + pos);
827 _quadColors->push_back(def->color);
830 if (def->stretchSymbol) {
831 osg::Vec2 stretchVerts[4];
832 stretchVerts[0] = osg::Vec2(def->xy0.x(), def->stretchY2);
833 stretchVerts[1] = osg::Vec2(def->xy1.x(), def->stretchY2);
834 stretchVerts[2] = osg::Vec2(def->xy1.x(), def->stretchY3);
835 stretchVerts[3] = osg::Vec2(def->xy0.x(), def->stretchY3);
837 osg::Matrixf m(degRotation(sym->headingDeg - _view_heading));
838 for (int i=0; i<4; ++i) {
839 stretchVerts[i] = mult(stretchVerts[i], m);
843 _vertices->push_back(verts[2] + pos);
844 _vertices->push_back(stretchVerts[1] + sym->endPos);
845 _vertices->push_back(stretchVerts[0] + sym->endPos);
846 _vertices->push_back(verts[3] + pos);
848 _texCoords->push_back(def->uv1);
849 _texCoords->push_back(osg::Vec2(def->uv1.x(), def->stretchV2));
850 _texCoords->push_back(osg::Vec2(def->uv0.x(), def->stretchV2));
851 _texCoords->push_back(osg::Vec2(def->uv0.x(), def->uv1.y()));
853 for (int i=0; i<4; ++i) {
854 _quadColors->push_back(def->color);
857 // quad three, for the end portion
858 for (int i=0; i<4; ++i) {
859 _vertices->push_back(stretchVerts[i] + sym->endPos);
860 _quadColors->push_back(def->color);
863 _texCoords->push_back(osg::Vec2(def->uv0.x(), def->stretchV2));
864 _texCoords->push_back(osg::Vec2(def->uv1.x(), def->stretchV2));
865 _texCoords->push_back(osg::Vec2(def->uv1.x(), def->stretchV3));
866 _texCoords->push_back(osg::Vec2(def->uv0.x(), def->stretchV3));
870 addLine(sym->pos, sym->endPos, def->lineColor);
873 if (!def->hasText || !def->textEnabled) {
877 osgText::Text* t = new osgText::Text;
878 t->setFont(_font.get());
879 t->setFontResolution(12, 12);
880 t->setCharacterSize(_font_size);
881 t->setLineSpacing(_font_spacing);
882 t->setColor(def->textColor);
883 t->setAlignment(def->alignment);
884 t->setText(sym->text());
887 osg::Vec2 textPos = def->textOffset + pos;
888 // ensure we use ints here, or text visual quality goes bad
889 t->setPosition(osg::Vec3((int)textPos.x(), (int)textPos.y(), 0));
890 _textGeode->addDrawable(t);
893 class OrderByPriority
896 bool operator()(SymbolInstance* a, SymbolInstance* b)
898 return a->definition->priority > b->definition->priority;
902 void NavDisplay::limitDisplayedSymbols()
904 // gloabl symbol limit
905 _maxSymbols= _Instrument->getIntValue("max-symbols", _maxSymbols);
906 if ((int) _symbols.size() <= _maxSymbols) {
907 _excessDataNode->setBoolValue(false);
911 std::sort(_symbols.begin(), _symbols.end(), OrderByPriority());
912 _symbols.resize(_maxSymbols);
913 _excessDataNode->setBoolValue(true);
919 bool operator()(SymbolInstance* a, SymbolInstance* b)
921 return a->definition->zOrder > b->definition->zOrder;
925 void NavDisplay::addSymbolsToScene()
927 std::sort(_symbols.begin(), _symbols.end(), OrderByZ());
928 BOOST_FOREACH(SymbolInstance* sym, _symbols) {
929 addSymbolToScene(sym);
933 void NavDisplay::addLine(osg::Vec2 a, osg::Vec2 b, const osg::Vec4& color)
935 _lineVertices->push_back(a);
936 _lineVertices->push_back(b);
937 _lineColors->push_back(color);
938 _lineColors->push_back(color);
941 osg::Vec2 NavDisplay::projectBearingRange(double bearingDeg, double rangeNm) const
943 osg::Vec3 p(0, rangeNm, 0.0);
944 p = degRotation(bearingDeg).preMult(p);
945 p = _projectMat.preMult(p);
946 return osg::Vec2(p.x(), p.y());
949 osg::Vec2 NavDisplay::projectGeod(const SGGeod& geod) const
951 double rangeM, bearing, az2;
952 SGGeodesy::inverse(_pos, geod, bearing, az2, rangeM);
953 return projectBearingRange(bearing, rangeM * SG_METER_TO_NM);
956 class Filter : public FGPositioned::Filter
959 Filter(NavDisplay* nd) : _owner(nd) { }
961 double minRunwayLengthFt;
963 virtual bool pass(FGPositioned* aPos) const
965 if (aPos->type() == FGPositioned::FIX) {
966 string ident(aPos->ident());
967 // ignore fixes which end in digits
968 if ((ident.size() > 4) && isdigit(ident[3]) && isdigit(ident[4])) {
973 if (aPos->type() == FGPositioned::AIRPORT) {
974 FGAirport* apt = (FGAirport*) aPos;
975 if (!apt->hasHardRunwayOfLengthFt(minRunwayLengthFt)) {
980 // check against current rule states
981 return _owner->isPositionedShown(aPos);
984 virtual FGPositioned::Type minType() const {
985 return FGPositioned::AIRPORT;
988 virtual FGPositioned::Type maxType() const {
989 return FGPositioned::OBSTACLE;
996 void NavDisplay::findItems()
998 if (!_cachedItemsValid) {
1000 filt.minRunwayLengthFt = fgGetDouble("/sim/navdb/min-runway-length-ft", 2000);
1001 bool wasTimeLimited;
1002 _itemsInRange = FGPositioned::findClosestNPartial(_pos, _maxSymbols, _rangeNm,
1003 &filt, wasTimeLimited);
1004 _cachedItemsValid = true;
1005 _cachedPos = SGVec3d::fromGeod(_pos);
1007 if (wasTimeLimited) {
1008 // re-query next frame, to load incrementally
1009 _cachedItemsValid = false;
1013 // sort by distance from pos, so symbol limits are accurate
1014 FGPositioned::sortByRange(_itemsInRange, _pos);
1016 BOOST_FOREACH(FGPositioned* pos, _itemsInRange) {
1017 foundPositionedItem(pos);
1021 void NavDisplay::processRoute()
1023 _routeSources.clear();
1024 flightgear::FlightPlan* fp = _route->flightPlan();
1026 int current = _route->currentIndex();
1028 for (int l=0; l<fp->numLegs(); ++l) {
1029 flightgear::FlightPlan::Leg* leg = fp->legAtIndex(l);
1030 flightgear::WayptRef wpt(leg->waypoint());
1031 _routeSources.insert(wpt->source());
1034 state.insert("on-active-route");
1037 state.insert("passed");
1041 state.insert("current-wp");
1045 state.insert("future");
1048 if (l == (current + 1)) {
1049 state.insert("next-wp");
1052 SymbolRuleVector rules;
1053 findRules("waypoint" , state, rules);
1054 if (rules.empty()) {
1055 return; // no rules matched, we can skip this item
1058 SGGeod g = path.positionForIndex(l);
1059 SGPropertyNode* vars = _route->wayptNodeAtIndex(l);
1061 continue; // shouldn't happen, but let's guard against it
1065 computeWayptPropsAndHeading(wpt, g, vars, heading);
1067 osg::Vec2 projected = projectGeod(g);
1068 BOOST_FOREACH(SymbolRule* r, rules) {
1069 addSymbolInstance(projected, heading, r->getDefinition(), vars);
1071 if (r->getDefinition()->drawRouteLeg) {
1072 SGGeodVec gv(path.pathForIndex(l));
1074 osg::Vec2 pr = projectGeod(gv[0]);
1075 for (unsigned int i=1; i<gv.size(); ++i) {
1076 osg::Vec2 p = projectGeod(gv[i]);
1077 addLine(pr, p, r->getDefinition()->lineColor);
1081 } // of leg drawing enabled
1082 } // of matching rules iteration
1083 } // of waypoints iteration
1086 void NavDisplay::computeWayptPropsAndHeading(flightgear::Waypt* wpt, const SGGeod& pos, SGPropertyNode* nd, double& heading)
1089 SGGeodesy::inverse(_pos, pos, heading, az2, rangeM);
1090 nd->setIntValue("radial", heading);
1091 nd->setDoubleValue("distance-nm", rangeM * SG_METER_TO_NM);
1093 heading = nd->getDoubleValue("leg-bearing-true-deg");
1096 void NavDisplay::processNavRadios()
1098 _nav1Station = processNavRadio(_navRadio1Node);
1099 _nav2Station = processNavRadio(_navRadio2Node);
1101 foundPositionedItem(_nav1Station);
1102 foundPositionedItem(_nav2Station);
1105 FGNavRecord* NavDisplay::processNavRadio(const SGPropertyNode_ptr& radio)
1107 double mhz = radio->getDoubleValue("frequencies/selected-mhz", 0.0);
1108 FGNavRecord* nav = FGNavList::findByFreq(mhz, _pos, FGNavList::navFilter());
1109 if (!nav || (nav->ident() != radio->getStringValue("nav-id"))) {
1110 // station was not found
1118 bool NavDisplay::anyRuleForType(const string& type) const
1120 BOOST_FOREACH(SymbolRule* r, _rules) {
1125 if (r->type == type) {
1133 void NavDisplay::findRules(const string& type, const string_set& states, SymbolRuleVector& rules)
1135 BOOST_FOREACH(SymbolRule* candidate, _rules) {
1136 if (!candidate->enabled || (candidate->type != type)) {
1140 if (candidate->matches(states)) {
1141 rules.push_back(candidate);
1146 bool NavDisplay::isPositionedShown(FGPositioned* pos)
1148 SymbolRuleVector rules;
1149 isPositionedShownInner(pos, rules);
1150 return !rules.empty();
1153 void NavDisplay::isPositionedShownInner(FGPositioned* pos, SymbolRuleVector& rules)
1155 string type = FGPositioned::nameForType(pos->type());
1156 boost::to_lower(type);
1157 if (!anyRuleForType(type)) {
1158 return; // not diplayed at all, we're done
1162 computePositionedState(pos, states);
1164 findRules(type, states, rules);
1167 void NavDisplay::foundPositionedItem(FGPositioned* pos)
1173 SymbolRuleVector rules;
1174 isPositionedShownInner(pos, rules);
1175 if (rules.empty()) {
1179 SGPropertyNode_ptr vars(new SGPropertyNode);
1181 computePositionedPropsAndHeading(pos, vars, heading);
1183 osg::Vec2 projected = projectGeod(pos->geod());
1184 if (pos->type() == FGPositioned::RUNWAY) {
1185 FGRunway* rwy = (FGRunway*) pos;
1186 projected = projectGeod(rwy->threshold());
1189 BOOST_FOREACH(SymbolRule* r, rules) {
1190 SymbolInstance* ins = addSymbolInstance(projected, heading, r->getDefinition(), vars);
1191 if ((ins)&&(pos->type() == FGPositioned::RUNWAY)) {
1192 FGRunway* rwy = (FGRunway*) pos;
1193 ins->endPos = projectGeod(rwy->end());
1198 void NavDisplay::computePositionedPropsAndHeading(FGPositioned* pos, SGPropertyNode* nd, double& heading)
1200 nd->setStringValue("id", pos->ident());
1201 nd->setStringValue("name", pos->name());
1202 nd->setDoubleValue("elevation-ft", pos->elevation());
1203 nd->setIntValue("heading-deg", 0);
1206 switch (pos->type()) {
1207 case FGPositioned::VOR:
1208 case FGPositioned::LOC:
1209 case FGPositioned::TACAN: {
1210 FGNavRecord* nav = static_cast<FGNavRecord*>(pos);
1211 nd->setDoubleValue("frequency-mhz", nav->get_freq());
1213 if (pos == _nav1Station) {
1214 heading = _navRadio1Node->getDoubleValue("radials/target-radial-deg");
1215 } else if (pos == _nav2Station) {
1216 heading = _navRadio2Node->getDoubleValue("radials/target-radial-deg");
1219 nd->setIntValue("heading-deg", heading);
1223 case FGPositioned::AIRPORT:
1224 case FGPositioned::SEAPORT:
1225 case FGPositioned::HELIPORT:
1229 case FGPositioned::RUNWAY: {
1230 FGRunway* rwy = static_cast<FGRunway*>(pos);
1231 heading = rwy->headingDeg();
1232 nd->setDoubleValue("heading-deg", heading);
1233 nd->setIntValue("length-ft", rwy->lengthFt());
1234 nd->setStringValue("airport", rwy->airport()->ident());
1243 void NavDisplay::computePositionedState(FGPositioned* pos, string_set& states)
1245 if (_routeSources.count(pos) != 0) {
1246 states.insert("on-active-route");
1249 flightgear::FlightPlan* fp = _route->flightPlan();
1250 switch (pos->type()) {
1251 case FGPositioned::VOR:
1252 case FGPositioned::LOC:
1253 if (pos == _nav1Station) {
1254 states.insert("tuned");
1255 states.insert("nav1");
1258 if (pos == _nav2Station) {
1259 states.insert("tuned");
1260 states.insert("nav2");
1264 case FGPositioned::AIRPORT:
1265 case FGPositioned::SEAPORT:
1266 case FGPositioned::HELIPORT:
1268 // once the FMS system has some way to tell us about them, of course
1270 if (pos == fp->departureAirport()) {
1271 states.insert("departure");
1274 if (pos == fp->destinationAirport()) {
1275 states.insert("destination");
1279 case FGPositioned::RUNWAY:
1280 if (pos == fp->departureRunway()) {
1281 states.insert("departure");
1284 if (pos == fp->destinationRunway()) {
1285 states.insert("destination");
1289 case FGPositioned::OBSTACLE:
1291 FGObstacle* obs = (FGObstacle*) pos;
1293 states.insert("lit");
1296 if (obj->getHeightAGLFt() >= 1000) {
1297 states.insert("greater-1000-ft");
1304 } // FGPositioned::Type switch
1307 static string mapAINodeToType(SGPropertyNode* model)
1309 // assume all multiplayer items are aircraft for the moment. Not ideal.
1310 if (!strcmp(model->getName(), "multiplayer")) {
1311 return "ai-aircraft";
1314 return string("ai-") + model->getName();
1317 void NavDisplay::processAI()
1319 SGPropertyNode *ai = fgGetNode("/ai/models", true);
1320 for (int i = ai->nChildren() - 1; i >= 0; i--) {
1321 SGPropertyNode *model = ai->getChild(i);
1322 if (!model->nChildren()) {
1326 // prefix types with 'ai-', to avoid any chance of namespace collisions
1327 // with fg-positioned.
1329 computeAIStates(model, ss);
1330 SymbolRuleVector rules;
1331 findRules(mapAINodeToType(model), ss, rules);
1332 if (rules.empty()) {
1333 return; // no rules matched, we can skip this item
1336 double heading = model->getDoubleValue("orientation/true-heading-deg");
1337 SGGeod aiModelPos = SGGeod::fromDegFt(model->getDoubleValue("position/longitude-deg"),
1338 model->getDoubleValue("position/latitude-deg"),
1339 model->getDoubleValue("position/altitude-ft"));
1340 // compute some additional props
1341 int fl = (aiModelPos.getElevationFt() / 1000);
1342 model->setIntValue("flight-level", fl * 10);
1344 osg::Vec2 projected = projectGeod(aiModelPos);
1345 BOOST_FOREACH(SymbolRule* r, rules) {
1346 addSymbolInstance(projected, heading, r->getDefinition(), (SGPropertyNode*) model);
1348 } // of ai models iteration
1351 void NavDisplay::computeAIStates(const SGPropertyNode* ai, string_set& states)
1353 int threatLevel = ai->getIntValue("tcas/threat-level",-1);
1354 if (threatLevel < 1)
1357 states.insert("tcas");
1359 std::ostringstream os;
1360 os << "tcas-threat-level-" << threatLevel;
1361 states.insert(os.str());
1363 double vspeed = ai->getDoubleValue("velocities/vertical-speed-fps");
1364 if (vspeed < -3.0) {
1365 states.insert("descending");
1366 } else if (vspeed > 3.0) {
1367 states.insert("climbing");
1371 SymbolInstance* NavDisplay::addSymbolInstance(const osg::Vec2& proj, double heading, SymbolDef* def, SGPropertyNode* vars)
1373 if (isProjectedClipped(proj)) {
1377 if ((def->limitCount > 0) && (def->instanceCount >= def->limitCount)) {
1381 ++def->instanceCount;
1382 SymbolInstance* sym = new SymbolInstance(proj, heading, def, vars);
1383 _symbols.push_back(sym);
1387 bool NavDisplay::isProjectedClipped(const osg::Vec2& projected) const
1389 double size = _odg->size();
1390 return (projected.x() < 0.0) ||
1391 (projected.y() < 0.0) ||
1392 (projected.x() >= size) ||
1393 (projected.y() >= size);
1396 void NavDisplay::addTestSymbol(const std::string& type, const std::string& states, const SGGeod& pos, double heading, SGPropertyNode* vars)
1398 string_set stateSet;
1399 BOOST_FOREACH(std::string s, simgear::strutils::split(states, ",")) {
1403 SymbolRuleVector rules;
1404 findRules(type, stateSet, rules);
1405 if (rules.empty()) {
1406 return; // no rules matched, we can skip this item
1409 osg::Vec2 projected = projectGeod(pos);
1410 BOOST_FOREACH(SymbolRule* r, rules) {
1411 addSymbolInstance(projected, heading, r->getDefinition(), vars);
1415 void NavDisplay::addTestSymbols()
1417 _pos = SGGeod::fromDeg(-122.3748889, 37.6189722); // KSFO
1421 SGGeodesy::direct(_pos, 45.0, 20.0 * SG_NM_TO_METER, a1, dummy);
1423 addTestSymbol("airport", "", a1, 0.0, NULL);
1425 SGGeodesy::direct(_pos, 95.0, 40.0 * SG_NM_TO_METER, a1, dummy);
1427 addTestSymbol("vor", "", a1, 0.0, NULL);
1429 SGGeodesy::direct(_pos, 120, 80.0 * SG_NM_TO_METER, a1, dummy);
1431 addTestSymbol("airport", "destination", a1, 0.0, NULL);
1433 SGGeodesy::direct(_pos, 80.0, 20.0 * SG_NM_TO_METER, a1, dummy);
1434 addTestSymbol("fix", "", a1, 0.0, NULL);
1437 SGGeodesy::direct(_pos, 140.0, 20.0 * SG_NM_TO_METER, a1, dummy);
1438 addTestSymbol("fix", "", a1, 0.0, NULL);
1440 SGGeodesy::direct(_pos, 110.0, 10.0 * SG_NM_TO_METER, a1, dummy);
1441 addTestSymbol("fix", "", a1, 0.0, NULL);
1443 SGGeodesy::direct(_pos, 110.0, 5.0 * SG_NM_TO_METER, a1, dummy);
1444 addTestSymbol("fix", "", a1, 0.0, NULL);
1447 void NavDisplay::addRule(SymbolRule* r)
1449 _rules.push_back(r);
1452 void NavDisplay::computeCustomSymbolStates(const SGPropertyNode* sym, string_set& states)
1454 BOOST_FOREACH(SGPropertyNode* st, sym->getChildren("state")) {
1455 states.insert(st->getStringValue());
1459 void NavDisplay::processCustomSymbols()
1461 for (int i = _customSymbols->nChildren() - 1; i >= 0; i--) {
1462 SGPropertyNode *symNode = _customSymbols->getChild(i);
1463 if (!symNode->nChildren()) {
1467 computeCustomSymbolStates(symNode, ss);
1468 SymbolRuleVector rules;
1469 findRules(symNode->getName(), ss, rules);
1470 if (rules.empty()) {
1471 return; // no rules matched, we can skip this item
1474 double heading = symNode->getDoubleValue("true-heading-deg", 0.0);
1475 SGGeod pos = SGGeod::fromDegFt(symNode->getDoubleValue("longitude-deg"),
1476 symNode->getDoubleValue("latitude-deg"),
1477 symNode->getDoubleValue("altitude-ft"));
1480 osg::Vec2 projected = projectGeod(pos);
1481 BOOST_FOREACH(SymbolRule* r, rules) {
1482 addSymbolInstance(projected, heading, r->getDefinition(), symNode);
1484 } // of custom symbols iteration