src/Instrumentation/HUD/HUD.hxx

   1 // HUD.hxx -- Head Up Display
   2 //
   3 // Written by Michele America, started September 1997.
   4 //
   5 // Copyright (C) 1997  Michele F. America  [micheleamerica#geocities:com]
   6 // Copyright (C) 2006  Melchior FRANZ  [mfranz#aon:at]
   7 //
   8 // This program is free software; you can redistribute it and/or
   9 // modify it under the terms of the GNU General Public License as
  10 // published by the Free Software Foundation; either version 2 of the
  11 // License, or (at your option) any later version.
  12 //
  13 // This program is distributed in the hope that it will be useful, but
  14 // WITHOUT ANY WARRANTY; without even the implied warranty of
  15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16 // General Public License for more details.
  17 //
  18 // You should have received a copy of the GNU General Public License
  19 // along with this program; if not, write to the Free Software
  20 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  21
  22 #ifndef _HUD_HXX
  23 #define _HUD_HXX
  24
  25 #include <simgear/compiler.h>
  26
  27 #ifdef HAVE_CONFIG_H
  28 #  include <config.h>
  29 #endif
  30
  31 #include <vector>
  32 #include <deque>
  33 #include STL_FSTREAM
  34
  35 SG_USING_STD(deque);
  36 SG_USING_STD(vector);
  37 SG_USING_NAMESPACE(std);
  38
  39 #include <plib/sg.h>
  40
  41 #include <simgear/math/SGLimits.hxx>
  42 #include <simgear/constants.h>
  43 #include <simgear/structure/subsystem_mgr.hxx>
  44
  45 #include <Airports/runways.hxx>     // FGRunway
  46 #include <GUI/gui.h>                // fntRenderer ?   guiErrorMessage()
  47 #include <GUI/new_gui.hxx>          // FGFontCache, FGColor
  48 #include <Include/fg_typedefs.h>
  49 #include <Main/fg_props.hxx>
  50
  51
  52 class FGViewer;
  53 class SGCondition;
  54
  55
  56
  57 class LineSegment {
  58 public:
  59     LineSegment(GLfloat x0, GLfloat y0, GLfloat x1, GLfloat y1)
  60         : _x0(x0), _y0(y0), _x1(x1), _y1(y1) {}
  61
  62     void draw() const {
  63         glVertex2f(_x0, _y0);
  64         glVertex2f(_x1, _y1);
  65     }
  66
  67 private:
  68     GLfloat _x0, _y0, _x1, _y1;
  69 };
  70
  71
  72
  73 class LineList {
  74 public:
  75     void add(const LineSegment& seg) { _list.push_back(seg); }
  76     void erase() { _list.erase(_list.begin(), _list.end()); }
  77     inline unsigned int size() const { return _list.size(); }
  78     void draw() {
  79         glBegin(GL_LINES);
  80         vector<LineSegment>::const_iterator it, end = _list.end();
  81         for (it = _list.begin(); it != end; ++it)
  82             it->draw();
  83         glEnd();
  84     }
  85
  86 private:
  87     vector<LineSegment> _list;
  88 };
  89
  90
  91
  92 class HUDText {
  93 public:
  94     HUDText(float x, float y, char *s, int d = 0) : _x(x), _y(y), _digits(d) {
  95         strncpy(_msg, s, BUFSIZE);
  96     }
  97
  98     // this code is changed to display Numbers with big/small digits
  99     // according to MIL Standards for example Altitude above 10000 ft
 100     // is shown as 10ooo.
 101
 102     void draw(fntRenderer *fnt) {
 103         float orig_size = fnt->getPointSize();
 104         if (!_digits) { // show all digits in same size
 105             fnt->setPointSize(orig_size * 0.8);
 106             fnt->start2f(_x, _y);
 107             fnt->puts(_msg);
 108
 109             fnt->setPointSize(orig_size);
 110             return;
 111         }
 112
 113         int c = 0, i = 0;
 114         char *t = _msg;
 115         int p = 4;
 116
 117         if (t[0] == '-') {
 118             //if negative value then increase the c and p values
 119             //for '-' sign.
 120             c++; // was moved to the comment. Unintentionally?   TODO
 121             p++;
 122         }
 123         char *tmp = _msg;
 124         while (tmp[i] != '\0') {
 125             if ((tmp[i] >= '0') && (tmp[i] <= '9'))
 126                 c++;
 127             i++;
 128         }
 129         if (c > p) {
 130             fnt->setPointSize(orig_size * 0.8);
 131             int p1 = c - 3;
 132             char *tmp1 = _msg + p1;
 133             int p2 = p1 * 8;
 134
 135             fnt->start2f(_x + p2, _y);
 136             fnt->puts(tmp1);
 137
 138             fnt->setPointSize(orig_size * 1.2);
 139             char tmp2[BUFSIZE];
 140             strncpy(tmp2, _msg, p1);
 141             tmp2[p1] = '\0';
 142
 143             fnt->start2f(_x, _y);
 144             fnt->puts(tmp2);
 145         } else {
 146             fnt->setPointSize(orig_size * 1.2);
 147             fnt->start2f(_x, _y);
 148             fnt->puts(tmp);
 149         }
 150         fnt->setPointSize(orig_size);
 151     }
 152
 153 private:
 154     float _x, _y;
 155     int _digits;
 156     static const int BUFSIZE = 64;
 157     char _msg[BUFSIZE];
 158 };
 159
 160
 161
 162 class TextList {
 163 public:
 164     TextList() { _font = 0; }
 165
 166     void setFont(fntRenderer *Renderer) { _font = Renderer; }
 167     void add(const HUDText& String) { _list.push_back(String); }
 168     void erase() { _list.erase(_list.begin(), _list.end()); }
 169     void draw() {
 170         assert(_font);
 171
 172         // FIXME
 173         glPushAttrib(GL_COLOR_BUFFER_BIT);
 174         glEnable(GL_BLEND);
 175
 176         _font->begin();
 177         vector<HUDText>::iterator it, end = _list.end();
 178         for (it = _list.begin(); it != end; ++it)
 179             it->draw(_font);
 180         _font->end();
 181
 182         glDisable(GL_TEXTURE_2D);
 183         glPopAttrib();
 184     }
 185
 186 private:
 187     fntRenderer *_font;
 188     vector<HUDText> _list;
 189 };
 190
 191
 192
 193
 194
 195
 196 class HUD : public SGSubsystem, public SGPropertyChangeListener {
 197 public:
 198     HUD();
 199     ~HUD();
 200     void init();
 201     void update(double);
 202
 203     typedef struct {
 204         float x, y;
 205     } Point;
 206
 207     typedef struct {
 208         float top, bottom, left, right;
 209     } Rect;
 210
 211     // called from Main/renderer.cxx to draw 2D and 3D HUD
 212     void draw();
 213
 214     // listener callback to read various HUD related properties
 215     void valueChanged(SGPropertyNode *);
 216     // set current glColor
 217     void setColor() const;
 218     inline bool isVisible() const { return _visible; }
 219     inline bool isAntialiased() const { return _antialiased; }
 220     inline bool isTransparent() const { return _transparent; }
 221     inline bool is3D() const { return _3Denabled; }
 222     inline float alphaClamp() const { return _cl; }
 223     inline double timer() const { return _timer; }
 224
 225     enum Units { FEET, METER };
 226     Units getUnits() const { return _units; }
 227
 228     enum {
 229         AUTOTICKS = 0x0001,
 230         VERT      = 0x0002,
 231         HORZ      = 0x0000,
 232         TOP       = 0x0004,
 233         BOTTOM    = 0x0008,
 234         LEFT      = TOP,
 235         RIGHT     = BOTTOM,
 236         BOTH      = (LEFT|RIGHT),
 237         NOTICKS   = 0x0010,
 238         ARITHTIC  = 0x0020,
 239         DECITICS  = 0x0040,
 240         NOTEXT    = 0x0080,
 241     };
 242
 243     enum Adjust {
 244         LEFT_ALIGN,
 245         CENTER_ALIGN,
 246         RIGHT_ALIGN
 247     };
 248
 249 protected:
 250     void common_draw();
 251     int load(const char *, float x = 320.0f, float y = 240.0f,
 252             int level = 0, const string& indent = "");
 253
 254 private:
 255     void draw3D();
 256     void draw2D(GLfloat, GLfloat, GLfloat, GLfloat);
 257
 258     class Input;
 259     class Item;
 260     class Label;
 261     class Scale;
 262     class Gauge;
 263     class Tape;
 264     class Dial;
 265     class TurnBankIndicator;
 266     class Ladder;
 267     class Runway;
 268
 269     deque<Item *> _items;
 270
 271     SGPropertyNode_ptr _current;
 272     SGPropertyNode_ptr _visibility;
 273     SGPropertyNode_ptr _3DenabledN;
 274     SGPropertyNode_ptr _antialiasing;
 275     SGPropertyNode_ptr _transparency;
 276     SGPropertyNode_ptr _red, _green, _blue, _alpha;
 277     SGPropertyNode_ptr _alpha_clamp;
 278     SGPropertyNode_ptr _brightness;
 279     bool _visible;
 280     bool _3Denabled;
 281     bool _antialiased;
 282     bool _transparent;
 283     float _r, _g, _b, _a, _cl;
 284
 285     SGPropertyNode_ptr _scr_widthN, _scr_heightN;
 286     int _scr_width, _scr_height;
 287     SGPropertyNode_ptr _unitsN;
 288     Units _units;
 289     double _timer;
 290
 291     fntRenderer *_font_renderer;
 292     FGFontCache *_font_cache;
 293     fntTexFont *_font;
 294     float _font_size;
 295     int _style;
 296
 297     TextList _text_list;
 298     LineList _line_list;
 299     LineList _stipple_line_list;
 300 };
 301
 302
 303
 304 class HUD::Input {
 305 public:
 306     Input(const SGPropertyNode *n, float factor = 1.0, float offset = 0.0,
 307             float min = -SGLimitsf::max(), float max = SGLimitsf::max()) :
 308         _valid(false),
 309         _property(0),
 310         _damped(SGLimitsf::max())
 311     {
 312         if (!n)
 313             return;
 314         _factor = n->getFloatValue("factor", factor);
 315         _offset = n->getFloatValue("offset", offset);
 316         _min = n->getFloatValue("min", min);
 317         _max = n->getFloatValue("max", max);
 318         _coeff = n->getFloatValue("damp", 0.0);
 319         SGPropertyNode *p = ((SGPropertyNode *)n)->getNode("property", false);
 320         if (p) {
 321             const char *path = p->getStringValue();
 322             if (path && path[0]) {
 323                 _property = fgGetNode(path, true);
 324                 _valid = true;
 325             }
 326         }
 327     }
 328
 329     const char *getStringValue() const {
 330         assert(_property);
 331         return _property->getStringValue();
 332     }
 333
 334     float getFloatValue() {
 335         assert(_property);
 336         float f = _property->getFloatValue() * _factor + _offset;
 337         if (_damped == SGLimitsf::max())
 338             _damped = f;
 339         if (_coeff > 0.0f)
 340             f = _damped = f * (1.0f - _coeff) + _damped * _coeff;
 341         return f < _min ? _min : f > _max ? _max : f;
 342     }
 343
 344     inline float isValid() const { return _valid; }
 345     inline float min() const { return _min; }
 346     inline float max() const { return _max; }
 347     inline float factor() const { return _factor; }
 348
 349     void set_min(float m, bool force = true) {
 350         if (force || _min == -SGLimitsf::max())
 351             _min = m;
 352     }
 353     void set_max(float m, bool force = true) {
 354         if (force || _max == SGLimitsf::max())
 355             _max = m;
 356     }
 357
 358 private:
 359     bool _valid;
 360     SGConstPropertyNode_ptr _property;
 361     float _factor;
 362     float _offset;
 363     float _min;
 364     float _max;
 365     float _coeff;
 366     float _damped;
 367 };
 368
 369
 370
 371 class HUD::Item { // An Abstract Base Class (ABC)
 372 public:
 373     Item(HUD *parent, const SGPropertyNode *, float x = 0.0f, float y = 0.0f);
 374     virtual ~Item () {}
 375     virtual void draw() = 0;
 376     virtual bool isEnabled();
 377
 378 protected:
 379
 380     inline Rect  get_location()   const { return _scrn_pos; }
 381     inline float get_span()       const { return _scr_span; }
 382     inline Point get_centroid()   const { return _mid_span; }
 383     inline int   get_digits()     const { return _digits; }
 384
 385     inline float get_x()      const { return _scrn_pos.left; }
 386     inline float get_y()      const { return _scrn_pos.top; }
 387     inline float get_width()  const { return _scrn_pos.right; }
 388     inline float get_height() const { return _scrn_pos.bottom; }
 389
 390     inline bool option_vert()    const { return _options & VERT; }
 391     inline bool option_left()    const { return _options & LEFT; }
 392     inline bool option_right()   const { return _options & RIGHT; }
 393     inline bool option_both()    const { return (_options & BOTH) == BOTH; }
 394     inline bool option_noticks() const { return _options & NOTICKS; }
 395     inline bool option_notext()  const { return _options & NOTEXT; }
 396     inline bool option_top()     const { return _options & TOP; }
 397     inline bool option_bottom()  const { return _options & BOTTOM; }
 398
 399     void draw_line( float x1, float y1, float x2, float y2) {
 400         _hud->_line_list.add(LineSegment(x1, y1, x2, y2));
 401     }
 402
 403     void draw_stipple_line( float x1, float y1, float x2, float y2) {
 404         _hud->_stipple_line_list.add(LineSegment(x1, y1, x2, y2));
 405     }
 406
 407     void draw_text( float x, float y, char *msg, int digit) {
 408         _hud->_text_list.add(HUDText(x, y, msg, digit));
 409     }
 410
 411     float text_width(char *str) const {
 412         assert(_hud->_font_renderer);
 413         float r, l;
 414         _hud->_font->getBBox(str, _hud->_font_size, 0, &l, &r, 0, 0);
 415         return r - l;
 416     }
 417
 418     void draw_circle(float x1, float y1, float r) const {
 419         glBegin(GL_LINE_LOOP);
 420         for (int count = 0; count < 25; count++) {
 421             float cosine = r * cos(count * 2 * SG_PI / 10.0);
 422             float sine =   r * sin(count * 2 * SG_PI / 10.0);
 423             glVertex2f(cosine + x1, sine + y1);
 424         }
 425         glEnd();
 426     }
 427
 428     HUD         *_hud;
 429     string      _name;
 430     int         _options;
 431
 432 private:
 433     SGCondition *_condition;
 434     Rect        _scrn_pos;      // Framing - affects scale dimensions
 435                                 // and orientation. Vert vs Horz, etc.
 436     float       _disp_factor;   // Multiply by to get numbers shown on scale.
 437     float       _scr_span;      // Working values for draw;
 438     Point       _mid_span;
 439     int         _digits;
 440 };
 441
 442
 443
 444 class HUD::Label : public Item {
 445 public:
 446     Label(HUD *parent, const SGPropertyNode *, float x, float y);
 447     virtual void draw();
 448
 449 private:
 450     enum Format {
 451         INVALID,
 452         NONE,
 453         INT,
 454         LONG,
 455         FLOAT,
 456         DOUBLE,
 457         STRING,
 458     };
 459
 460     enum FontSize {
 461         FONT_SMALL,
 462         FONT_LARGE
 463     };
 464
 465     Format  check_format(const char *) const;
 466     bool    blink();
 467
 468     Input   _input;
 469     Format  _mode;
 470     string  _format;
 471     Adjust  _halign;
 472     int     _fontsize;
 473     int     _blink;
 474     bool    _box;
 475
 476     SGCondition *_blink_condition;
 477     double  _blink_interval;
 478     double  _blink_target;  // time for next blink state change
 479     bool    _blink_state;
 480 };
 481
 482
 483
 484 // abstract base class for both moving scale and moving needle (fixed scale)
 485 // indicators.
 486 //
 487 class HUD::Scale : public Item {
 488 public:
 489     Scale(HUD *parent, const SGPropertyNode *, float x, float y);
 490     virtual void draw    ( void ) {}  // No-op here. Defined in derived classes.
 491
 492 protected:
 493     inline unsigned int modulo() const { return _modulo; }
 494     inline float  factor() const { return scale_factor; }
 495     inline float  range_to_show() const { return _range_shown; }
 496
 497     Input _input;
 498     unsigned int _major_divs;  // major division marker units
 499     unsigned int _minor_divs;  // minor division marker units
 500
 501 private:
 502     float _range_shown;     // Width Units.
 503     float scale_factor;    // factor => screen units/range values.
 504     unsigned int _modulo;  // Roll over point
 505 };
 506
 507
 508 class HUD::Gauge : public Scale {
 509 public:
 510     Gauge(HUD *parent, const SGPropertyNode *, float x, float y);
 511     virtual void draw();
 512 };
 513
 514
 515
 516 // displays the indicated quantity on a scale that moves past the
 517 // pointer. It may be horizontal or vertical.
 518 //
 519 class HUD::Tape : public Scale {
 520 public:
 521     Tape(HUD *parent, const SGPropertyNode *, float x, float y);
 522     virtual void draw();
 523
 524 protected:
 525     void circle(float, float, float);
 526     void fixed(float, float, float, float, float, float);
 527     void zoomed_scale(int, int);
 528
 529 private:
 530     float  _val_span;
 531     float  _half_width_units;
 532     bool   _draw_tick_bottom;
 533     bool   _draw_tick_top;
 534     bool   _draw_tick_right;
 535     bool   _draw_tick_left;
 536     bool   _draw_cap_bottom;
 537     bool   _draw_cap_top;
 538     bool   _draw_cap_right;
 539     bool   _draw_cap_left;
 540     float  _marker_offset;
 541     bool   _pointer;
 542     int    _zoom;
 543     enum PointerType { FIXED, MOVING } _pointer_type;
 544     enum TickType { LINE, CIRCLE } _tick_type;
 545     enum TickLength { VARIABLE, CONSTANT } _tick_length;
 546 };
 547
 548
 549
 550 class HUD::Dial : public Scale {
 551 public:
 552     Dial(HUD *parent, const SGPropertyNode *, float x, float y);
 553     virtual void draw();
 554
 555 private:
 556     float  _radius;
 557     int    _divisions;
 558 };
 559
 560
 561
 562 class HUD::TurnBankIndicator : public Item {
 563 public:
 564     TurnBankIndicator(HUD *parent, const SGPropertyNode *, float x, float y);
 565     virtual void draw();
 566
 567 private:
 568     Input _bank;
 569     Input _sideslip;
 570
 571     float _gap_width;
 572     bool  _bank_scale;
 573     float _bank_scale_radius;
 574 };
 575
 576
 577
 578 class HUD::Ladder : public Item {
 579 public:
 580     Ladder(HUD *parent, const SGPropertyNode *, float x, float y);
 581     virtual void draw();
 582
 583 private:
 584     void draw_zenith(float, float, float);
 585     void draw_nadir(float, float, float);
 586
 587     void draw_text(float x, float y, char *s) {
 588         _locTextList.add(HUDText(x, y, s));
 589     }
 590
 591     void draw_line(float x1, float y1, float x2, float y2) {
 592         _locLineList.add(LineSegment(x1, y1, x2, y2));
 593     }
 594
 595     void draw_stipple_line(float x1, float y1, float x2, float y2) {
 596         _locStippleLineList.add(LineSegment(x1, y1, x2, y2));
 597     }
 598
 599     Input  _pitch;
 600     Input  _roll;
 601     enum Type { PITCH, CLIMB_DIVE } _type;
 602     unsigned int width_units;
 603     int    div_units;
 604     unsigned int minor_div;
 605     unsigned int label_pos;
 606     unsigned int _scr_hole;
 607     float  _vmax;
 608     float  _vmin;
 609     float  _compression;
 610     bool   _frl;
 611     bool   _target_spot;
 612     bool   _velocity_vector;
 613     bool   _drift_marker;
 614     bool   _alpha_bracket;
 615     bool   _energy_marker;
 616     bool   _climb_dive_marker;
 617     bool   _glide_slope_marker;
 618     float  _glide_slope;
 619     bool   _energy_worm;
 620     bool   _waypoint_marker;
 621     int    _zenith;
 622     int    _nadir;
 623     int    _hat;
 624
 625     // The Ladder has its own temporary display lists
 626     TextList _locTextList;
 627     LineList _locLineList;
 628     LineList _locStippleLineList;
 629 };
 630
 631
 632
 633 // responsible for rendering the active runway in the hud (if visible).
 634 //
 635 class HUD::Runway : public Item {
 636 public:
 637     Runway(HUD *parent, const SGPropertyNode *, float x, float y);
 638     virtual void draw();
 639
 640 private:
 641     void boundPoint(const sgdVec3& v, sgdVec3& m);
 642     bool boundOutsidePoints(sgdVec3& v, sgdVec3& m);
 643     bool drawLine(const sgdVec3& a1, const sgdVec3& a2,
 644             const sgdVec3& p1, const sgdVec3& p2);
 645     void drawArrow();
 646     bool get_active_runway(FGRunway& rwy);
 647     void get_rwy_points(sgdVec3 *points);
 648     void setLineWidth();
 649
 650     SGPropertyNode_ptr _agl;
 651     sgdVec3 _points3d[6], _points2d[6];
 652     double _mm[16];
 653     double _pm[16];
 654     double _arrow_scale;  // scales of runway indication arrow
 655     double _arrow_radius;
 656     double _line_scale;   // maximum line scale
 657     double _scale_dist;   // distance where to start scaling the lines
 658     double _default_pitch;
 659     double _default_heading;
 660     GLint  _view[4];
 661     FGRunway _runway;
 662     FGViewer* _cockpit_view;
 663     unsigned short _stipple_out;    // stipple pattern of the outline of the runway
 664     unsigned short _stipple_center; // stipple pattern of the center line of the runway
 665     bool   _draw_arrow;             // draw arrow when runway is not visible in HUD
 666     bool   _draw_arrow_always;      // always draws arrow
 667     Rect   _location;
 668     Point  _center;
 669 };
 670
 671
 672 #endif // _HUD_HXX