src/Cockpit/hud.hxx

   1 // hud.hxx -- hud defines and prototypes (initial draft)
   2 //
   3 // Written by Michele America, started September 1997.
   4 //
   5 // Copyright (C) 1997  Michele F. America  - nomimarketing@mail.telepac.pt
   6 //
   7 // This program is free software; you can redistribute it and/or
   8 // modify it under the terms of the GNU General Public License as
   9 // published by the Free Software Foundation; either version 2 of the
  10 // License, or (at your option) any later version.
  11 //
  12 // This program is distributed in the hope that it will be useful, but
  13 // WITHOUT ANY WARRANTY; without even the implied warranty of
  14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15 // General Public License for more details.
  16 //
  17 // You should have received a copy of the GNU General Public License
  18 // along with this program; if not, write to the Free Software
  19 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  20 //
  21 // $Id$
  22
  23
  24 #ifndef _OLDHUD_HXX
  25 #define _OLDHUD_HXX
  26
  27 #ifndef __cplusplus
  28 # error This library requires C++
  29 #endif
  30
  31 #include <simgear/compiler.h>
  32
  33 #ifdef HAVE_CONFIG_H
  34 #  include <config.h>
  35 #endif
  36
  37 #ifdef HAVE_WINDOWS_H
  38 #  include <windows.h>
  39 #endif
  40
  41 #ifdef __CYGWIN__
  42 #include <ieeefp.h>
  43 #endif
  44
  45 #include <stdlib.h>
  46 #include <string.h>
  47
  48 #include <algorithm>    // for_each()
  49 #include <vector>       // STL vector
  50 #include <deque>        // STL double ended queue
  51 #include <fstream>
  52
  53 #include <osg/State>
  54
  55 #include <simgear/math/SGMath.hxx>
  56 #include <simgear/constants.h>
  57
  58 #include <Include/fg_typedefs.h>
  59 #include <Aircraft/aircraft.hxx>
  60 #include <Aircraft/controls.hxx>
  61 #include <FDM/flight.hxx>
  62 #include <GUI/gui.h>
  63 #include <Main/fg_props.hxx>
  64 #include <Main/globals.hxx>
  65 #include <Main/viewmgr.hxx>
  66 #include <Airports/runways.hxx>
  67
  68 #include <plib/sg.h>
  69
  70 SG_USING_STD(deque);
  71 SG_USING_STD(vector);
  72
  73 #define float_to_int(v) SGMiscf::roundToInt(v)
  74
  75 // some of Norman's crazy optimizations. :-)
  76
  77 #ifndef WIN32
  78 typedef struct {
  79     int x, y;
  80 } POINT;
  81
  82 typedef struct {
  83     int top, bottom, left, right;
  84 } RECT;
  85 #endif
  86
  87 // View mode definitions
  88
  89 enum VIEW_MODES{ HUD_VIEW, PANEL_VIEW, CHASE_VIEW, TOWER_VIEW };
  90
  91 // Label constants
  92 #define HUD_FONT_SMALL     1
  93 #define HUD_FONT_LARGE     2
  94
  95 enum fgLabelJust{ LEFT_JUST, CENTER_JUST, RIGHT_JUST } ;
  96
  97 #define HUDS_AUTOTICKS           0x0001
  98 #define HUDS_VERT                0x0002
  99 #define HUDS_HORZ                0x0000
 100 #define HUDS_TOP                 0x0004
 101 #define HUDS_BOTTOM              0x0008
 102 #define HUDS_LEFT     HUDS_TOP
 103 #define HUDS_RIGHT    HUDS_BOTTOM
 104 #define HUDS_BOTH     (HUDS_LEFT | HUDS_RIGHT)
 105 #define HUDS_NOTICKS             0x0010
 106 #define HUDS_ARITHTIC            0x0020
 107 #define HUDS_DECITICS            0x0040
 108 #define HUDS_NOTEXT              0x0080
 109
 110 // in cockpit.cxx
 111 extern float get_throttleval ( void );
 112 extern float get_aileronval  ( void );
 113 extern float get_elevatorval ( void );
 114 extern float get_elev_trimval( void );
 115 extern float get_rudderval   ( void );
 116 extern float get_speed       ( void );
 117 extern float get_aoa         ( void );
 118 extern float get_nlf         ( void );
 119 extern float get_roll        ( void );
 120 extern float get_pitch       ( void );
 121 extern float get_heading     ( void );
 122 extern float get_view_direction( void );
 123 extern float get_altitude    ( void );
 124 extern float get_agl         ( void );
 125 extern float get_sideslip    ( void );
 126 extern float get_frame_rate  ( void );
 127 extern float get_latitude    ( void );
 128 extern float get_lat_min     ( void );
 129 extern float get_longitude   ( void );
 130 extern float get_long_min    ( void );
 131 extern float get_fov         ( void );
 132 extern float get_vfc_ratio   ( void );
 133 extern float get_vfc_tris_drawn   ( void );
 134 extern float get_vfc_tris_culled   ( void );
 135 extern float get_climb_rate  ( void );
 136 extern float get_mach( void );
 137 extern char *coord_format_lat(float);
 138 extern char *coord_format_lon(float);
 139
 140 // $$$ begin - added, VS Renganathan, 13 Oct 2K
 141 extern float get_anzg (void);
 142 extern float get_Vx (void);
 143 extern float get_Vy (void);
 144 extern float get_Vz (void);
 145 extern float get_Ax (void);
 146 extern float get_Ay (void);
 147 extern float get_Az (void);
 148 extern int get_iaux1 (void);
 149 extern int get_iaux2 (void);
 150 extern int get_iaux3 (void);
 151 extern int get_iaux4 (void);
 152 extern int get_iaux5 (void);
 153 extern int get_iaux6 (void);
 154 extern int get_iaux7 (void);
 155 extern int get_iaux8 (void);
 156 extern int get_iaux9 (void);
 157 extern int get_iaux10 (void);
 158 extern int get_iaux11 (void);
 159 extern int get_iaux12 (void);
 160 extern float get_aux1(void);
 161 extern float get_aux2(void);
 162 extern float get_aux3(void);
 163 extern float get_aux4(void);
 164 extern float get_aux5 (void);
 165 extern float get_aux6 (void);
 166 extern float get_aux7 (void);
 167 extern float get_aux8(void);
 168 extern float get_aux9(void);
 169 extern float get_aux10(void);
 170 extern float get_aux11(void);
 171 extern float get_aux12(void);
 172 extern float get_aux13(void);
 173 extern float get_aux14(void);
 174 extern float get_aux15(void);
 175 extern float get_aux16(void);
 176 extern float get_aux17(void);
 177 extern float get_aux18(void);
 178 // $$$ end - added, VS Renganathan, 13 Oct 2K
 179
 180 extern char *get_formated_gmt_time( void );
 181
 182 enum  hudinstype{ HUDno_instr,
 183                   HUDscale,
 184                   HUDlabel,
 185                   HUDladder,
 186                   HUDcirc_ladder,
 187                   HUDhorizon,
 188                   HUDgauge,
 189                   HUDdual_inst,
 190                   HUDmoving_scale,
 191                   HUDtbi
 192 };
 193
 194 typedef struct gltagRGBTRIPLE { // rgbt
 195     GLfloat Blue;
 196     GLfloat Green;
 197     GLfloat Red;
 198 } glRGBTRIPLE;
 199
 200 class fgLineSeg2D {
 201 private:
 202     GLfloat x0, y0, x1, y1;
 203
 204 public:
 205     fgLineSeg2D( GLfloat a = 0, GLfloat b =0, GLfloat c = 0, GLfloat d =0 )
 206         : x0(a), y0(b),  x1(c), y1(d) {}
 207
 208     fgLineSeg2D( const fgLineSeg2D & image )
 209         : x0(image.x0), y0(image.y0), x1(image.x1), y1(image.y1) {}
 210
 211     fgLineSeg2D& operator= ( const fgLineSeg2D & image ) { // seems unused
 212         x0 = image.x0; y0 = image.y0; x1 = image.x1; y1 = image.y1; return *this;
 213     }
 214
 215     void draw() const
 216     {
 217         glVertex2f(x0, y0);
 218         glVertex2f(x1, y1);
 219     }
 220 };
 221
 222 class DrawLineSeg2D {
 223     public:
 224         void operator() (const fgLineSeg2D& elem) const {
 225             elem.draw();
 226         }
 227 };
 228
 229
 230 #define USE_HUD_TextList
 231 extern fntTexFont        *HUD_Font;
 232 extern float              HUD_TextSize;
 233 extern fntRenderer       *HUDtext;
 234 extern float HUD_matrix[16];
 235
 236 class fgText {
 237 private:
 238     float x, y;
 239     string msg;
 240         bool digit;
 241     // seems unused
 242
 243 public:
 244         fgText(float x, float y, const string& c, bool digits=false): x(x), y(y), msg( c), digit( digits) {};
 245
 246     fgText( const fgText & image )
 247                 : x(image.x), y(image.y), msg(image.msg), digit(image.digit) { }
 248
 249         fgText& operator = ( const fgText & image ) {
 250                 x = image.x; y = image.y; msg= image.msg; digit = image.digit;
 251                 return *this;
 252         }
 253
 254     static int getStringWidth ( const char *str )
 255     {
 256         if ( HUDtext && str ) {
 257             float r, l ;
 258             HUD_Font->getBBox ( str, HUD_TextSize, 0, &l, &r, NULL, NULL ) ;
 259             return float_to_int( r - l );
 260         }
 261         return 0 ;
 262     }
 263
 264     int StringWidth ()
 265     {
 266         if ( HUDtext && msg != "") {
 267             float r, l ;
 268             HUD_Font->getBBox ( msg.c_str(), HUD_TextSize, 0, &l, &r, NULL, NULL ) ;
 269             return float_to_int( r - l );
 270         }
 271         return 0 ;
 272     }
 273
 274     // this code is changed to display Numbers with big/small digits
 275     // according to MIL Standards for example Altitude above 10000 ft
 276     // is shown as 10ooo.
 277
 278     void Draw(fntRenderer *fnt) {
 279         if (digit) {
 280             int c=0,i=0;
 281
 282             int p=4;
 283
 284             if (msg[0]=='-') {
 285                 //if negative value then increase the c and p values
 286                 //for '-' sign.  c++;
 287                 p++;
 288             }
 289
 290                         for (string::size_type i = 0; i < msg.size(); i++) {
 291                 if ((msg[i]>='0') && (msg[i]<='9'))
 292                     c++;
 293             }
 294             float orig_size = fnt->getPointSize();
 295             if (c>p) {
 296                 fnt->setPointSize(HUD_TextSize * 0.8);
 297                 int p2=(c-3)*8;  //advance to the last 3 digits
 298
 299                 fnt->start2f(x+p2,y);
 300                 fnt->puts(msg.c_str() + c - 3); // display last 3 digits
 301
 302                 fnt->setPointSize(HUD_TextSize * 1.2);
 303
 304                 fnt->start2f(x,y);
 305                                 fnt->puts(msg.substr(0,c-3).c_str());
 306             } else {
 307                 fnt->setPointSize(HUD_TextSize * 1.2);
 308                 fnt->start2f( x, y );
 309                 fnt->puts(msg.c_str());
 310             }
 311             fnt->setPointSize(orig_size);
 312         } else {
 313             //if digits not true
 314             fnt->start2f( x, y );
 315             fnt->puts( msg.c_str()) ;
 316         }
 317     }
 318
 319     void Draw()
 320     {
 321                 guiFnt.drawString( msg.c_str(), float_to_int(x), float_to_int(y) );
 322     }
 323 };
 324
 325 class fgLineList {
 326     vector < fgLineSeg2D > List;
 327 public:
 328     fgLineList( void ) {}
 329     void add( const fgLineSeg2D& seg ) { List.push_back(seg); }
 330         void erase( void ) { List.clear();}
 331     void draw( void ) {
 332         glBegin(GL_LINES);
 333         for_each( List.begin(), List.end(), DrawLineSeg2D());
 334         glEnd();
 335     }
 336 };
 337
 338 class fgTextList {
 339     fntRenderer *Font;
 340     vector< fgText > List;
 341 public:
 342     fgTextList ( void ) { Font = 0; }
 343
 344     void setFont( fntRenderer *Renderer ) { Font = Renderer; }
 345     void add( const fgText& String ) { List.push_back(String); }
 346     void erase( void ) { List.clear(); }
 347     void draw( void );
 348 };
 349
 350
 351 inline void Text( fgTextList &List, float x, float y, char *s)
 352 {
 353     List.add( fgText( x, y, s) );
 354 }
 355
 356 inline void Text( fgTextList &List, const fgText &me)
 357 {
 358     List.add(me);
 359 }
 360
 361 inline void Line( fgLineList &List, float x1, float y1, float x2, float y2)
 362 {
 363     List.add(fgLineSeg2D(x1,y1,x2,y2));
 364 }
 365
 366
 367 // Declare our externals
 368 extern fgTextList         HUD_TextList;
 369 extern fgLineList         HUD_LineList;
 370 extern fgLineList         HUD_StippleLineList;
 371
 372
 373 class instr_item : public SGReferenced {  // An Abstract Base Class (ABC)
 374 private:
 375     static UINT        instances;     // More than 64K instruments? Nah!
 376     static int         brightness;
 377     static glRGBTRIPLE color;
 378
 379     UINT               handle;
 380     RECT               scrn_pos;      // Framing - affects scale dimensions
 381                                       // and orientation. Vert vs Horz, etc.
 382     FLTFNPTR           load_value_fn;
 383     float              disp_factor;   // Multiply by to get numbers shown on scale.
 384     UINT               opts;
 385     bool               is_enabled;
 386     bool               broken;
 387     UINT               scr_span;      // Working values for draw;
 388     POINT              mid_span;      //
 389     int                digits;
 390
 391 public:
 392     instr_item( int            x,
 393                 int            y,
 394                 UINT           height,
 395                 UINT           width,
 396                 FLTFNPTR       data_source,
 397                 float          data_scaling,
 398                 UINT           options,
 399                 bool           working = true,
 400                 int            digit = 0);
 401
 402     virtual ~instr_item ();
 403
 404     void    set_data_source ( FLTFNPTR fn ) { load_value_fn = fn; }
 405     int     get_brightness  ( void ) { return brightness;}
 406     RECT    get_location    ( void ) { return scrn_pos;  }
 407     bool    is_broken       ( void ) { return broken;    }
 408     bool    enabled         ( void ) { return is_enabled;}
 409     bool    data_available  ( void ) { return !!load_value_fn; }
 410     float   get_value       ( void ) { return load_value_fn(); }
 411     float   data_scaling    ( void ) { return disp_factor; }
 412     UINT    get_span        ( void ) { return scr_span;  }
 413     POINT   get_centroid    ( void ) { return mid_span;  }
 414     UINT    get_options     ( void ) { return opts;      }
 415     int     get_digits      ( void ) { return digits;         }
 416     inline int get_x() const { return scrn_pos.left; }
 417     inline int get_y() const { return scrn_pos.top; }
 418     inline int get_width() const { return scrn_pos.right; }
 419     inline int get_height() const { return scrn_pos.bottom; }
 420
 421     UINT    huds_vert     (UINT options) { return (options & HUDS_VERT); }
 422     UINT    huds_left     (UINT options) { return (options & HUDS_LEFT); }
 423     UINT    huds_right    (UINT options) { return (options & HUDS_RIGHT); }
 424     UINT    huds_both     (UINT options) {
 425         return ((options & HUDS_BOTH) == HUDS_BOTH);
 426     }
 427     UINT    huds_noticks  (UINT options) { return (options & HUDS_NOTICKS); }
 428     UINT    huds_notext   (UINT options) { return (options & HUDS_NOTEXT); }
 429     UINT    huds_top      (UINT options) { return (options & HUDS_TOP); }
 430     UINT    huds_bottom   (UINT options) { return (options & HUDS_BOTTOM); }
 431
 432     virtual void display_enable( bool working ) { is_enabled = working;}
 433
 434     virtual void break_display ( bool bad );
 435     virtual void SetBrightness( int illumination_level ); // fgHUDSetBright...
 436     void         SetPosition  ( int x, int y, UINT width, UINT height );
 437     UINT         get_Handle( void );
 438     virtual void draw( void ) = 0;   // Required method in derived classes
 439
 440     void drawOneLine( float x1, float y1, float x2, float y2)
 441     {
 442         HUD_LineList.add(fgLineSeg2D(x1,y1,x2,y2));
 443     }
 444     void drawOneStippleLine( float x1, float y1, float x2, float y2)
 445     {
 446         HUD_StippleLineList.add(fgLineSeg2D(x1,y1,x2,y2));
 447     }
 448     void TextString( char *msg, float x, float y, bool digit )
 449     {
 450         HUD_TextList.add(fgText(x, y, msg,digit));
 451     }
 452     int getStringWidth ( char *str )
 453     {
 454         if ( HUDtext && str ) {
 455             float r, l ;
 456             HUD_Font->getBBox ( str, HUD_TextSize, 0, &l, &r, NULL, NULL ) ;
 457             return float_to_int( r - l );
 458         }
 459         return 0 ;
 460     }
 461
 462
 463
 464 };
 465
 466 typedef instr_item *HIptr;
 467
 468 class HUDdraw {
 469     public:
 470         void operator() (HIptr elem) const {
 471             if ( elem->enabled())
 472                 elem->draw();
 473         }
 474 };
 475
 476
 477 extern int HUD_style;
 478
 479 // instr_item           This class has no other purpose than to maintain
 480 //                      a linked list of instrument and derived class
 481 // object pointers.
 482
 483
 484 class instr_label : public instr_item {
 485 private:
 486     const char  *pformat;
 487
 488     fgLabelJust justify;
 489     int         fontSize;
 490     int         blink;
 491     string      format_buffer;
 492     bool        lat;
 493     bool        lon;
 494     bool        lbox;
 495     SGPropertyNode_ptr lon_node;
 496     SGPropertyNode_ptr lat_node;
 497
 498 public:
 499     instr_label(const SGPropertyNode *);
 500     virtual void draw(void);
 501 };
 502
 503
 504 //
 505 // fgRunway_instr   This class is responsible for rendering the active runway
 506 //                  in the hud (if visible).
 507 class runway_instr : public instr_item {
 508 private:
 509         void boundPoint(const sgdVec3& v, sgdVec3& m);
 510         bool boundOutsidePoints(sgdVec3& v, sgdVec3& m);
 511         bool drawLine(const sgdVec3& a1, const sgdVec3& a2,
 512                 const sgdVec3& p1, const sgdVec3& p2);
 513         void drawArrow();
 514         bool get_active_runway(FGRunway& rwy);
 515         void get_rwy_points(sgdVec3 *points);
 516         void setLineWidth(void);
 517
 518         sgdVec3 points3d[6], points2d[6];
 519         double mm[16],pm[16], arrowScale, arrowRad, lnScale;
 520         double scaleDist, default_pitch, default_heading;
 521         GLint view[4];
 522         FGRunway runway;
 523         FGViewer* cockpit_view;
 524         unsigned short stippleOut, stippleCen;
 525         bool drawIA, drawIAAlways;
 526         RECT location;
 527         POINT center;
 528
 529 public:
 530     runway_instr(const SGPropertyNode *);
 531
 532     virtual void draw( void );
 533     void setArrowRotationRadius(double radius);
 534     // Scales the runway indication arrow
 535     void setArrowScale(double scale);
 536     // Draws arrow when runway is not visible in HUD if draw=true
 537     void setDrawArrow(bool draw);
 538     // Always draws arrow if draw=true;
 539     void setDrawArrowAlways(bool draw);
 540     // Sets the maximum line scale
 541     void setLineScale(double scale);
 542     // Sets the distance where to start scaling the lines
 543     void setScaleDist(double dist_nm);
 544     // Sets the stipple pattern of the outline of the runway
 545     void setStippleOutline(unsigned short stipple);
 546     // Sets the stipple patter of the center line of the runway
 547     void setStippleCenterline(unsigned short stipple);
 548 };
 549
 550
 551 //
 552 // instr_scale           This class is an abstract base class for both moving
 553 //                       scale and moving needle (fixed scale) indicators. It
 554 // does not draw itself, but is not instanciable.
 555 //
 556
 557 class instr_scale : public instr_item {
 558 private:
 559     float range_shown;   // Width Units.
 560     float Maximum_value; //                ceiling.
 561     float Minimum_value; // Representation floor.
 562     float scale_factor;  // factor => screen units/range values.
 563     UINT   Maj_div;       // major division marker units
 564     UINT   Min_div;       // minor division marker units
 565     UINT   Modulo;        // Roll over point
 566     int    signif_digits; // digits to show to the right.
 567
 568 public:
 569     instr_scale( int          x,
 570                  int          y,
 571                  UINT         width,
 572                  UINT         height,
 573                  FLTFNPTR     load_fn,
 574                  UINT         options,
 575                  float        show_range,
 576                  float        max_value,
 577                  float        min_value,
 578                  float        disp_scaling,
 579                  UINT         major_divs,
 580                  UINT         minor_divs,
 581                  UINT         rollover,
 582                  int          dp_showing,
 583                  bool         working = true);
 584
 585     virtual void draw    ( void ) {}; // No-op here. Defined in derived classes.
 586     UINT   div_min       ( void ) { return Min_div;}
 587     UINT   div_max       ( void ) { return Maj_div;}
 588     float  min_val       ( void ) { return Minimum_value;}
 589     float  max_val       ( void ) { return Maximum_value;}
 590     UINT   modulo        ( void ) { return Modulo; }
 591     float  factor        ( void ) { return scale_factor;}
 592     float  range_to_show ( void ) { return range_shown;}
 593 };
 594
 595 // hud_card                This class displays the indicated quantity on
 596 //                         a scale that moves past the pointer. It may be
 597 // horizontal or vertical, read above(left) or below(right) of the base
 598 // line.
 599
 600 class hud_card : public instr_scale {
 601 private:
 602     float  val_span;
 603     string type;
 604     float  half_width_units;
 605     bool   draw_tick_bottom;
 606     bool   draw_tick_top;
 607     bool   draw_tick_right;
 608     bool   draw_tick_left;
 609     bool   draw_cap_bottom;
 610     bool   draw_cap_top;
 611     bool   draw_cap_right;
 612     bool   draw_cap_left;
 613     float  marker_offset;
 614     bool   pointer;
 615     string pointer_type;
 616     string tick_type;
 617     string tick_length;
 618     float  radius;
 619     float  maxValue;
 620     float  minValue;
 621     int    divisions;
 622     int    zoom;
 623     UINT   Maj_div;
 624     UINT   Min_div;
 625
 626 public:
 627     hud_card(const SGPropertyNode *);
 628     //    virtual void display_enable( bool setting );                  // FIXME
 629     virtual void draw(void);
 630     void circles(float, float, float);
 631     void fixed(float, float, float, float, float, float);
 632     void zoomed_scale(int, int);
 633 };
 634
 635
 636 class gauge_instr : public instr_scale {
 637 public:
 638     gauge_instr(const SGPropertyNode *);
 639     virtual void draw( void );       // Required method in base class
 640 };
 641
 642
 643 //
 644 // dual_instr_item         This class was created to form the base class
 645 //                         for both panel and HUD Turn Bank Indicators.
 646
 647 class dual_instr_item : public instr_item {
 648 private:
 649     FLTFNPTR alt_data_source;
 650
 651 public:
 652     dual_instr_item ( int       x,
 653                       int       y,
 654                       UINT      width,
 655                       UINT      height,
 656                       FLTFNPTR  chn1_source,
 657                       FLTFNPTR  chn2_source,
 658                       bool      working,
 659                       UINT      options );
 660
 661     float current_ch1( void ) { return (float)alt_data_source(); }
 662     float current_ch2( void ) { return (float)get_value(); }
 663     virtual void draw( void ) {}
 664 };
 665
 666
 667 class fgTBI_instr : public dual_instr_item {
 668 private:
 669     UINT BankLimit;
 670     UINT SlewLimit;
 671     UINT scr_hole;
 672     bool tsi;
 673     float rad;
 674
 675 public:
 676     fgTBI_instr(const SGPropertyNode *);
 677
 678     UINT bank_limit(void) { return BankLimit; }
 679     UINT slew_limit(void) { return SlewLimit; }
 680
 681     virtual void draw(void);
 682 };
 683
 684
 685 class HudLadder : public dual_instr_item {
 686 private:
 687     UINT   width_units;
 688     int    div_units;
 689     UINT   minor_div;
 690     UINT   label_pos;
 691     UINT   scr_hole;
 692     float  vmax;
 693     float  vmin;
 694     float  factor;
 695     string hudladder_type;
 696     bool   frl;
 697     bool   target_spot;
 698     bool   velocity_vector;
 699     bool   drift_marker;
 700     bool   alpha_bracket;
 701     bool   energy_marker;
 702     bool   climb_dive_marker;
 703     bool   glide_slope_marker;
 704     float  glide_slope;
 705     bool   energy_worm;
 706     bool   waypoint_marker;
 707     int    zenith;
 708     int    nadir;
 709     int    hat;
 710
 711     // The Ladder has it's own temporary display lists
 712     fgTextList         TextList;
 713     fgLineList         LineList;
 714     fgLineList         StippleLineList;
 715
 716 public:
 717     HudLadder(const SGPropertyNode *);
 718
 719     virtual void draw(void);
 720     void drawZenith(float, float, float);
 721     void drawNadir(float, float, float);
 722
 723     void Text(float x, float y, char *s)
 724     {
 725         TextList.add(fgText(x, y, s));
 726     }
 727
 728     void Line(float x1, float y1, float x2, float y2)
 729     {
 730         LineList.add(fgLineSeg2D(x1, y1, x2, y2));
 731     }
 732
 733     void StippleLine(float x1, float y1, float x2, float y2)
 734     {
 735         StippleLineList.add(fgLineSeg2D(x1, y1, x2, y2));
 736     }
 737 };
 738
 739
 740 extern int  fgHUDInit( fgAIRCRAFT * /* current_aircraft */ );
 741 extern int  fgHUDInit2( fgAIRCRAFT * /* current_aircraft */ );
 742 extern void fgUpdateHUD( osg::State* );
 743 extern void fgUpdateHUD( osg::State*, GLfloat x_start, GLfloat y_start,
 744                          GLfloat x_end, GLfloat y_end );
 745
 746
 747
 748
 749 class HUD_Properties : public SGPropertyChangeListener {
 750 public:
 751     HUD_Properties();
 752     void valueChanged(SGPropertyNode *n);
 753     void setColor() const;
 754     bool isVisible() const { return _visible; }
 755     bool isAntialiased() const { return _antialiased; }
 756     bool isTransparent() const { return _transparent; }
 757     float alphaClamp() const { return _cl; }
 758
 759 private:
 760     float clamp(float f) { return f < 0.0f ? 0.0f : f > 1.0f ? 1.0f : f; }
 761     SGPropertyNode_ptr _current;
 762     SGPropertyNode_ptr _visibility;
 763     SGPropertyNode_ptr _antialiasing;
 764     SGPropertyNode_ptr _transparency;
 765     SGPropertyNode_ptr _red, _green, _blue, _alpha;
 766     SGPropertyNode_ptr _alpha_clamp;
 767     SGPropertyNode_ptr _brightness;
 768     bool _visible;
 769     bool _antialiased;
 770     bool _transparent;
 771     float _r, _g, _b, _a, _cl;
 772 };
 773
 774 #endif // _OLDHUD_H