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 _HUD_HXX
  25 #define _HUD_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 #include <stdlib.h>
  42 #include <string.h>
  43
  44 //#ifdef HAVE_VALUES_H
  45 //#  include <values.h>  // for MAXINT
  46 //#endif
  47
  48 #include <algorithm>    // for_each()
  49 #include <vector>       // STL vector
  50 #include <deque>        // STL double ended queue
  51 #include STL_FSTREAM
  52
  53 #include <simgear/constants.h>
  54
  55 #include <Include/fg_typedefs.h>
  56 #include <Aircraft/aircraft.hxx>
  57 #include <Aircraft/controls.hxx>
  58 #include <FDM/flight.hxx>
  59 #include <GUI/gui.h>
  60 #include <Main/globals.hxx>
  61 #include <Main/viewmgr.hxx>
  62 #include <Airports/runways.hxx>
  63
  64 #include "hud_opts.hxx"
  65 #include <plib/sg.h>
  66
  67 SG_USING_STD(deque);
  68 SG_USING_STD(vector);
  69 SG_USING_NAMESPACE(std);
  70
  71
  72 // some of Norman's crazy optimizations. :-)
  73
  74 #ifndef WIN32
  75 typedef struct {
  76     int x, y;
  77 } POINT;
  78
  79 typedef struct {
  80     int top, bottom, left, right;
  81 } RECT;
  82 #endif
  83
  84 // View mode definitions
  85
  86 enum VIEW_MODES{ HUD_VIEW, PANEL_VIEW, CHASE_VIEW, TOWER_VIEW };
  87
  88 // DAY, NIGHT and brightness levels need to be visible where dialogs and
  89 // controls can be used to set intensity and appropriate color. This will
  90 // be moved.
  91 // Hud general constants
  92 #define HUD_DAY                1
  93 #define HUD_NIGHT              2
  94 #define HUD_BRT_BLACK          3
  95 #define HUD_BRT_DARK           4
  96 #define HUD_BRT_MEDIUM         5
  97 #define HUD_BRT_LIGHT          6
  98
  99 // Label constants
 100 #define HUD_FONT_SMALL     1
 101 #define HUD_FONT_LARGE     2
 102
 103 enum fgLabelJust{ LEFT_JUST, CENTER_JUST, RIGHT_JUST } ;
 104
 105 #define HUDS_AUTOTICKS           0x0001
 106 #define HUDS_VERT                0x0002
 107 #define HUDS_HORZ                0x0000
 108 #define HUDS_TOP                 0x0004
 109 #define HUDS_BOTTOM              0x0008
 110 #define HUDS_LEFT     HUDS_TOP
 111 #define HUDS_RIGHT    HUDS_BOTTOM
 112 #define HUDS_BOTH     (HUDS_LEFT | HUDS_RIGHT)
 113 #define HUDS_NOTICKS             0x0010
 114 #define HUDS_ARITHTIC            0x0020
 115 #define HUDS_DECITICS            0x0040
 116 #define HUDS_NOTEXT              0x0080
 117
 118 // Ladder orientaion
 119 // #define HUD_VERTICAL        1
 120 // #define HUD_HORIZONTAL       2
 121 // #define HUD_FREEFLOAT        3
 122
 123 // Ladder orientation modes
 124 // #define HUD_LEFT         1
 125 // #define HUD_RIGHT            2
 126 // #define HUD_TOP              1
 127 // #define HUD_BOTTOM           2
 128 // #define HUD_V_LEFT           1
 129 // #define HUD_V_RIGHT          2
 130 // #define HUD_H_TOP            1
 131 // #define HUD_H_BOTTOM         2
 132
 133
 134 // Ladder sub-types
 135 // #define HUD_LIM              1
 136 // #define HUD_NOLIM            2
 137 // #define HUD_CIRC         3
 138
 139 // #define HUD_INSTR_LADDER 1
 140 // #define HUD_INSTR_CLADDER    2
 141 // #define HUD_INSTR_HORIZON    3
 142 // #define HUD_INSTR_LABEL      4
 143
 144 // in cockpit.cxx
 145 extern float get_throttleval ( void );
 146 extern float get_aileronval  ( void );
 147 extern float get_elevatorval ( void );
 148 extern float get_elev_trimval( void );
 149 extern float get_rudderval   ( void );
 150 extern float get_speed       ( void );
 151 extern float get_aoa         ( void );
 152 extern float get_nlf         ( void );
 153 extern float get_roll        ( void );
 154 extern float get_pitch       ( void );
 155 extern float get_heading     ( void );
 156 extern float get_view_direction( void );
 157 extern float get_altitude    ( void );
 158 extern float get_agl         ( void );
 159 extern float get_sideslip    ( void );
 160 extern float get_frame_rate  ( void );
 161 extern float get_latitude    ( void );
 162 extern float get_lat_min     ( void );
 163 extern float get_longitude   ( void );
 164 extern float get_long_min    ( void );
 165 extern float get_fov         ( void );
 166 extern float get_vfc_ratio   ( void );
 167 extern float get_vfc_tris_drawn   ( void );
 168 extern float get_vfc_tris_culled   ( void );
 169 extern float get_climb_rate  ( void );
 170 extern float get_mach( void );
 171 extern char *coord_format_lat(float);
 172 extern char *coord_format_lon(float);
 173 //extern char *coord_format_latlon(float latitude, float longitude);  // cockpit.cxx
 174
 175 // $$$ begin - added, VS Renganathan, 13 Oct 2K
 176 // #define FIGHTER_HUD
 177 extern float get_anzg (void);
 178 extern float get_Vx (void);
 179 extern float get_Vy (void);
 180 extern float get_Vz (void);
 181 extern float get_Ax (void);
 182 extern float get_Ay (void);
 183 extern float get_Az (void);
 184 extern int get_iaux1 (void);
 185 extern int get_iaux2 (void);
 186 extern int get_iaux3 (void);
 187 extern int get_iaux4 (void);
 188 extern int get_iaux5 (void);
 189 extern int get_iaux6 (void);
 190 extern int get_iaux7 (void);
 191 extern int get_iaux8 (void);
 192 extern int get_iaux9 (void);
 193 extern int get_iaux10 (void);
 194 extern int get_iaux11 (void);
 195 extern int get_iaux12 (void);
 196 extern float get_aux1(void);
 197 extern float get_aux2(void);
 198 extern float get_aux3(void);
 199 extern float get_aux4(void);
 200 extern float get_aux5 (void);
 201 extern float get_aux6 (void);
 202 extern float get_aux7 (void);
 203 extern float get_aux8(void);
 204 extern float get_aux9(void);
 205 extern float get_aux10(void);
 206 extern float get_aux11(void);
 207 extern float get_aux12(void);
 208 extern float get_aux13(void);
 209 extern float get_aux14(void);
 210 extern float get_aux15(void);
 211 extern float get_aux16(void);
 212 extern float get_aux17(void);
 213 extern float get_aux18(void);
 214 // $$$ end - added, VS Renganathan, 13 Oct 2K
 215
 216 extern char *get_formated_gmt_time( void );
 217 extern void fgHUDReshape(void);
 218
 219 enum  hudinstype{ HUDno_instr,
 220                   HUDscale,
 221                   HUDlabel,
 222                   HUDladder,
 223                   HUDcirc_ladder,
 224                   HUDhorizon,
 225                   HUDgauge,
 226                   HUDdual_inst,
 227                   HUDmoving_scale,
 228                   HUDtbi
 229 };
 230
 231 typedef struct gltagRGBTRIPLE { // rgbt
 232     GLfloat Blue;
 233     GLfloat Green;
 234     GLfloat Red;
 235 } glRGBTRIPLE;
 236
 237 class fgLineSeg2D {
 238 private:
 239     GLfloat x0, y0, x1, y1;
 240
 241 public:
 242     fgLineSeg2D( GLfloat a = 0, GLfloat b =0, GLfloat c = 0, GLfloat d =0 )
 243         : x0(a), y0(b),  x1(c), y1(d) {}
 244
 245     fgLineSeg2D( const fgLineSeg2D & image )
 246         : x0(image.x0), y0(image.y0), x1(image.x1), y1(image.y1) {}
 247
 248     fgLineSeg2D& operator= ( const fgLineSeg2D & image ) {
 249         x0 = image.x0; y0 = image.y0; x1 = image.x1; y1 = image.y1; return *this;
 250     }
 251
 252     ~fgLineSeg2D() {}
 253
 254     void draw() const
 255     {
 256         glVertex2f(x0, y0);
 257         glVertex2f(x1, y1);
 258     }
 259 };
 260
 261 class DrawLineSeg2D {
 262     public:
 263         void operator() (const fgLineSeg2D& elem) const {
 264             elem.draw();
 265         }
 266 };
 267
 268
 269 #define USE_HUD_TextList
 270 extern fntTexFont        *HUD_Font;
 271 extern float              HUD_TextSize;
 272 extern fntRenderer       *HUDtext;
 273 extern float HUD_matrix[16];
 274
 275 class fgText {
 276 private:
 277     float x, y;
 278     char msg[64];
 279 public:
 280     int digit; //suma
 281     fgText(float x = 0, float y = 0, char *c = NULL,int digits=0): x(x), y(y) //suma
 282     {
 283         strcpy(msg,c);
 284         digit=digits; //suma
 285     }
 286
 287     fgText( const fgText & image )
 288         : x(image.x), y(image.y),digit(image.digit) {strcpy(msg,image.msg);} //suma
 289
 290     fgText& operator = ( const fgText & image ) {
 291         strcpy(msg,image.msg); x = image.x; y = image.y;digit=image.digit; //suma
 292         return *this;
 293     }
 294
 295     ~fgText() {msg[0]='\0';}
 296
 297     int getStringWidth ( char *str )
 298     {
 299         if ( HUDtext && str ) {
 300             float r, l ;
 301             HUD_Font->getBBox ( str, HUD_TextSize, 0, &l, &r, NULL, NULL ) ;
 302             return FloatToInt( r - l );
 303         }
 304         return 0 ;
 305     }
 306
 307     int StringWidth (void )
 308     {
 309         if ( HUDtext && strlen( msg )) {
 310             float r, l ;
 311             HUD_Font->getBBox ( msg, HUD_TextSize, 0, &l, &r, NULL, NULL ) ;
 312             return FloatToInt( r - l );
 313         }
 314         return 0 ;
 315     }
 316
 317     // this code is changed to display Numbers with big/small digits
 318     // according to MIL Standards for example Altitude above 10000 ft
 319     // is shown as 10ooo.  begin suma
 320
 321     void Draw(fntRenderer *fnt,int digits) {
 322         if(digits==1) {
 323             int c=0,i=0;
 324             char *t=msg;
 325             int p=4;
 326
 327             if(t[0]=='-') {
 328                 //if negative value then increase the c and p values
 329                 //for '-' sign.  c++;
 330                 p++;
 331             }
 332             char *tmp=msg;
 333             while(tmp[i]!='\0') {
 334                 if((tmp[i]>='0') && (tmp[i]<='9'))
 335                     c++;
 336                 i++;
 337             }
 338             if(c>p) {
 339                 fnt->setPointSize(HUD_TextSize * 0.8);
 340                 int p1=c-3;
 341                 char *tmp1=msg+p1;
 342                 int p2=p1*8;
 343
 344                 fnt->start2f(x+p2,y);
 345                 fnt->puts(tmp1);
 346
 347                 fnt->setPointSize(HUD_TextSize * 1.2);
 348                 char tmp2[64];
 349                 strncpy(tmp2,msg,p1);
 350                 tmp2[p1]='\0';
 351
 352                 fnt->start2f(x,y);
 353                 fnt->puts(tmp2);
 354             } else {
 355                 fnt->setPointSize(HUD_TextSize * 1.2);
 356                 fnt->start2f( x, y );
 357                 fnt->puts(tmp);
 358             }
 359         } else {
 360             //if digits not equal to 1
 361             fnt->setPointSize(HUD_TextSize * 0.8);
 362             fnt->start2f( x, y );
 363             fnt->puts( msg ) ;
 364         }
 365     }
 366     //end suma
 367
 368     void Draw()
 369     {
 370         guiFnt.drawString( msg, FloatToInt(x), FloatToInt(y) );
 371     }
 372 };
 373
 374 class fgLineList {
 375     vector < fgLineSeg2D > List;
 376 public:
 377     fgLineList( void ) {}
 378     ~fgLineList( void ) {}
 379     void add( const fgLineSeg2D& seg ) { List.push_back(seg); }
 380     void erase( void ) { List.erase( List.begin(), List.end() ); }
 381     void draw( void ) {
 382         glBegin(GL_LINES);
 383         for_each( List.begin(), List.end(), DrawLineSeg2D());
 384         glEnd();
 385     }
 386 };
 387
 388 class fgTextList {
 389     fntRenderer *Font;
 390     vector< fgText > List;
 391 public:
 392     fgTextList ( void ) { Font = 0; }
 393     ~fgTextList( void ) {}
 394
 395     void setFont( fntRenderer *Renderer ) { Font = Renderer; }
 396     void add( const fgText& String ) { List.push_back(String); }
 397     void erase( void ) { List.erase( List.begin(), List.end() ); }
 398
 399     void draw( void ) {
 400         if( Font == 0 )
 401             return;
 402         vector < fgText > :: iterator curString = List.begin();
 403         vector < fgText > :: iterator lastString = List.end();
 404
 405         glPushAttrib( GL_COLOR_BUFFER_BIT );
 406         glEnable    ( GL_ALPHA_TEST   ) ;
 407         glEnable    ( GL_BLEND        ) ;
 408         glAlphaFunc ( GL_GREATER, 0.1 ) ;
 409         glBlendFunc ( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ) ;
 410
 411         Font->begin();
 412         for( ; curString != lastString; curString++ ) {
 413             curString->Draw(Font,curString->digit); //suma
 414         }
 415         Font->end();
 416
 417         glDisable ( GL_TEXTURE_2D ) ;
 418         glPopAttrib();
 419     }
 420 };
 421
 422
 423 inline void Text( fgTextList &List, float x, float y, char *s)
 424 {
 425     List.add( fgText( x, y, s) );
 426 }
 427
 428 inline void Text( fgTextList &List, const fgText &me)
 429 {
 430     List.add(me);
 431 }
 432
 433 inline void Line( fgLineList &List, float x1, float y1, float x2, float y2)
 434 {
 435     List.add(fgLineSeg2D(x1,y1,x2,y2));
 436 }
 437
 438
 439 // Declare our externals
 440 extern fgTextList         HUD_TextList;
 441 extern fgLineList         HUD_LineList;
 442 extern fgLineList         HUD_StippleLineList;
 443
 444
 445 class instr_item {  // An Abstract Base Class (ABC)
 446 private:
 447     static UINT        instances;     // More than 64K instruments? Nah!
 448     static int         brightness;
 449     static glRGBTRIPLE color;
 450
 451     UINT               handle;
 452     RECT               scrn_pos;      // Framing - affects scale dimensions
 453                                       // and orientation. Vert vs Horz, etc.
 454     FLTFNPTR           load_value_fn;
 455     float              disp_factor;   // Multiply by to get numbers shown on scale.
 456     UINT               opts;
 457     bool               is_enabled;
 458     bool               broken;
 459     UINT               scr_span;      // Working values for draw;
 460     POINT              mid_span;      //
 461     int                digits;        //suma
 462
 463 public:
 464     instr_item( int            x,
 465                 int            y,
 466                 UINT           height,
 467                 UINT           width,
 468                 FLTFNPTR       data_source,
 469                 float          data_scaling,
 470                 UINT           options,
 471                 bool           working  = true,
 472                 int            digit = 0); //suma
 473
 474     instr_item( const instr_item & image );
 475
 476     instr_item & operator = ( const instr_item & rhs );
 477     virtual ~instr_item ();
 478
 479     int     get_brightness  ( void ) { return brightness;}
 480     RECT    get_location    ( void ) { return scrn_pos;  }
 481     bool    is_broken       ( void ) { return broken;    }
 482     bool    enabled         ( void ) { return is_enabled;}
 483     bool    data_available  ( void ) { return !!load_value_fn; }
 484     float   get_value       ( void ) { return load_value_fn(); }
 485     float   data_scaling    ( void ) { return disp_factor; }
 486     UINT    get_span        ( void ) { return scr_span;  }
 487     POINT   get_centroid    ( void ) { return mid_span;  }
 488     UINT    get_options     ( void ) { return opts;      }
 489     int     get_digits      ( void ) { return digits;    } //suma
 490
 491     UINT    huds_vert     (UINT options) { return( options  & HUDS_VERT ); }
 492     UINT    huds_left     (UINT options) { return( options  & HUDS_LEFT ); }
 493     UINT    huds_right    (UINT options) { return( options  & HUDS_RIGHT ); }
 494     UINT    huds_both     (UINT options) {
 495         return( (options & HUDS_BOTH) == HUDS_BOTH );
 496     }
 497     UINT    huds_noticks  (UINT options) { return( options  & HUDS_NOTICKS ); }
 498     UINT    huds_notext   (UINT options) { return( options  & HUDS_NOTEXT ); }
 499     UINT    huds_top      (UINT options) { return( options  & HUDS_TOP ); }
 500     UINT    huds_bottom   (UINT options) { return( options  & HUDS_BOTTOM ); }
 501
 502     virtual void display_enable( bool working ) { is_enabled = !! working;}
 503
 504     virtual void update( void );
 505     virtual void break_display ( bool bad );
 506     virtual void SetBrightness( int illumination_level ); // fgHUDSetBright...
 507     void         SetPosition  ( int x, int y, UINT width, UINT height );
 508     UINT         get_Handle( void );
 509     virtual void draw( void ) = 0;   // Required method in derived classes
 510
 511     void drawOneLine( float x1, float y1, float x2, float y2)
 512     {
 513         HUD_LineList.add(fgLineSeg2D(x1,y1,x2,y2));
 514     }
 515     void drawOneStippleLine( float x1, float y1, float x2, float y2)
 516     {
 517         HUD_StippleLineList.add(fgLineSeg2D(x1,y1,x2,y2));
 518     }
 519     void TextString( char *msg, float x, float y,int digit ) //suma
 520     {
 521         HUD_TextList.add(fgText(x, y, msg,digit)); //suma
 522     }
 523     int getStringWidth ( char *str )
 524     {
 525         if ( HUDtext && str ) {
 526             float r, l ;
 527             HUD_Font->getBBox ( str, HUD_TextSize, 0, &l, &r, NULL, NULL ) ;
 528             return FloatToInt( r - l );
 529         }
 530         return 0 ;
 531     }
 532
 533     //code to draw ticks as small circles
 534     void drawOneCircle(float x1, float y1, float r)
 535     {
 536         glBegin(GL_LINE_LOOP);  // Use polygon to approximate a circle
 537         for(int count=0; count<25; count++) {
 538             float cosine = r * cos(count * 2 * SG_PI/10.0);
 539             float sine =   r * sin(count * 2 * SG_PI/10.0);
 540             glVertex2f(cosine+x1, sine+y1);
 541         }
 542         glEnd();
 543     }
 544
 545 };
 546
 547 typedef instr_item *HIptr;
 548
 549 class HUDdraw {
 550     public:
 551         void operator() (HIptr elem) const {
 552             if( elem->enabled())
 553                 elem->draw();
 554         }
 555 };
 556
 557 //typedef deque <  instr_item * > hud_deque_type;
 558 //typedef hud_deque_type::iterator hud_deque_iterator;
 559 //typedef hud_deque_type::const_iterator hud_deque_const_iterator;
 560
 561 extern deque< instr_item *> HUD_deque;
 562 extern int HUD_style;
 563 //extern hud_deque_type HUD_deque;
 564
 565 // instr_item           This class has no other purpose than to maintain
 566 //                      a linked list of instrument and derived class
 567 // object pointers.
 568
 569
 570 class instr_label : public instr_item {
 571 private:
 572     const char *pformat;
 573     const char *pre_str;
 574     const char *post_str;
 575     fgLabelJust justify;
 576     int         fontSize;
 577     int         blink;
 578     char format_buffer[80];
 579     bool                lat;
 580     bool                lon;
 581     bool                lbox;
 582
 583 public:
 584     instr_label( int          x,
 585                  int          y,
 586                  UINT         width,
 587                  UINT         height,
 588                  FLTFNPTR     data_source,
 589                  const char  *label_format,
 590                  const char  *pre_label_string,
 591                  const char  *post_label_string,
 592                  float        scale_data,
 593                  UINT         options,
 594                  fgLabelJust  justification,
 595                  int          font_size,
 596                  int          blinking,
 597                  bool             latitude,
 598                  bool             longitude,
 599                  bool             label_box,
 600                  bool         working,
 601                  int          digit ); //suma);
 602
 603     ~instr_label();
 604
 605     instr_label( const instr_label & image);
 606     instr_label & operator = (const instr_label & rhs );
 607     virtual void draw( void );       // Required method in base class
 608 };
 609
 610 typedef instr_label * pInstlabel;
 611
 612
 613 class lat_label : public instr_item {
 614 private:
 615     const char *pformat;
 616     const char *pre_str;
 617     const char *post_str;
 618     fgLabelJust justify;
 619     int         fontSize;
 620     int         blink;
 621     char format_buffer[80];
 622
 623 public:
 624     lat_label( int          x,
 625                int          y,
 626                UINT         width,
 627                UINT         height,
 628                FLTFNPTR     data_source,
 629                const char  *label_format,
 630                const char  *pre_label_string,
 631                const char  *post_label_string,
 632                float       scale_data,
 633                UINT         options,
 634                fgLabelJust  justification,
 635                int          font_size,
 636                int          blinking,
 637                bool         working,
 638                int          digits =0 );//suma
 639
 640     ~lat_label();
 641
 642     lat_label( const lat_label & image);
 643     lat_label & operator = (const lat_label & rhs );
 644     virtual void draw( void );       // Required method in base class
 645 };
 646
 647 typedef lat_label * pLatlabel;
 648
 649 class lon_label : public instr_item {
 650 private:
 651     const char *pformat;
 652     const char *pre_str;
 653     const char *post_str;
 654     fgLabelJust justify;
 655     int         fontSize;
 656     int         blink;
 657     char format_buffer[80];
 658
 659 public:
 660     lon_label( int          x,
 661                int          y,
 662                UINT         width,
 663                UINT         height,
 664                FLTFNPTR     data_source,
 665                const char  *label_format,
 666                const char  *pre_label_string,
 667                const char  *post_label_string,
 668                float       scale_data,
 669                UINT         options,
 670                fgLabelJust  justification,
 671                int          font_size,
 672                int          blinking,
 673                bool         working,
 674                int          digit=0); //suma
 675
 676
 677     ~lon_label();
 678
 679     lon_label( const lon_label & image);
 680     lon_label & operator = (const lon_label & rhs );
 681     virtual void draw( void );       // Required method in base class
 682 };
 683
 684 typedef lon_label * pLonlabel;
 685
 686 //
 687 // fgRunway_instr       This class is responsible for rendering the active runway
 688 //                      in the hud (if visible).
 689 class runway_instr : public instr_item
 690 {
 691 private:
 692         void boundPoint(const sgdVec3& v, sgdVec3& m);
 693         bool boundOutsidePoints(sgdVec3& v, sgdVec3& m);
 694         bool drawLine(const sgdVec3& a1, const sgdVec3& a2, const sgdVec3& p1, const sgdVec3& p2);
 695         void drawArrow();
 696         bool get_active_runway(FGRunway& rwy);
 697         void get_rwy_points(sgdVec3 *points);
 698         void setLineWidth(void);
 699
 700         sgdVec3 points3d[6],points2d[6];
 701         double mm[16],pm[16], arrowScale, arrowRad, lnScale, scaleDist, default_pitch, default_heading;
 702         GLint view[4];
 703         FGRunway runway;
 704         FGViewer* cockpit_view;
 705         unsigned short stippleOut,stippleCen;
 706         bool drawIA,drawIAAlways;
 707         RECT location;
 708         POINT center;
 709
 710 public:
 711     runway_instr( int    x,
 712                   int    y,
 713                                   int    width,
 714                                   int    height,
 715                   float  scale_data,
 716                   bool   working = true);
 717
 718     virtual void draw( void );       // Required method in base class
 719         void setArrowRotationRadius(double radius);
 720         void setArrowScale(double scale); // Scales the runway indication arrow
 721         void setDrawArrow(bool draw);    // Draws arrow when runway is not visible in HUD if draw=true
 722         void setDrawArrowAlways(bool draw); //Always draws arrow if draw=true;
 723         void setLineScale(double scale); //Sets the maximum line scale
 724         void setScaleDist(double dist_nm); //Sets the distance where to start scaling the lines
 725         void setStippleOutline(unsigned short stipple); //Sets the stipple pattern of the outline of the runway
 726         void setStippleCenterline(unsigned short stipple); //Sets the stipple patter of the center line of the runway
 727 };
 728
 729
 730 //
 731 // instr_scale           This class is an abstract base class for both moving
 732 //                       scale and moving needle (fixed scale) indicators. It
 733 // does not draw itself, but is not instanciable.
 734 //
 735
 736 class instr_scale : public instr_item {
 737 private:
 738     float range_shown;   // Width Units.
 739     float Maximum_value; //                ceiling.
 740     float Minimum_value; // Representation floor.
 741     float scale_factor;  // factor => screen units/range values.
 742     UINT   Maj_div;       // major division marker units
 743     UINT   Min_div;       // minor division marker units
 744     UINT   Modulo;        // Roll over point
 745     int    signif_digits; // digits to show to the right.
 746
 747 public:
 748     instr_scale( int          x,
 749                  int          y,
 750                  UINT         width,
 751                  UINT         height,
 752                  FLTFNPTR     load_fn,
 753                  UINT         options,
 754                  float       show_range,
 755                  float       max_value,
 756                  float       min_value,
 757                  float       disp_scaling,
 758                  UINT         major_divs,
 759                  UINT         minor_divs,
 760                  UINT         rollover,
 761                  int          dp_showing,
 762                  bool         working = true);
 763
 764     virtual ~instr_scale();
 765     instr_scale( const instr_scale & image);
 766     instr_scale & operator = (const instr_scale & rhs);
 767
 768     virtual void draw   ( void ) {}; // No-op here. Defined in derived classes.
 769     UINT   div_min      ( void ) { return Min_div;}
 770     UINT   div_max      ( void ) { return Maj_div;}
 771     float min_val      ( void ) { return Minimum_value;}
 772     float max_val      ( void ) { return Maximum_value;}
 773     UINT   modulo       ( void ) { return Modulo; }
 774     float factor       ( void ) { return scale_factor;}
 775     float range_to_show( void ) { return range_shown;}
 776 };
 777
 778 // hud_card_               This class displays the indicated quantity on
 779 //                         a scale that moves past the pointer. It may be
 780 // horizontal or vertical, read above(left) or below(right) of the base
 781 // line.
 782
 783 class hud_card : public instr_scale {
 784 private:
 785     float val_span;
 786     string type;
 787     float half_width_units;
 788     bool  draw_tick_bottom;
 789     bool  draw_tick_top;
 790     bool  draw_tick_right;
 791     bool  draw_tick_left;
 792     bool  draw_cap_bottom;
 793     bool  draw_cap_top;
 794     bool  draw_cap_right;
 795     bool  draw_cap_left;
 796     float marker_offset;
 797     bool  pointer;
 798     string  pointer_type;
 799     string  tick_type;
 800     string  tick_length;
 801     float   radius; //suma
 802     float   maxValue; //suma
 803     float   minValue; //suma
 804     int         divisions; //suma
 805     int     zoom; //suma
 806     UINT        Maj_div; //suma
 807     UINT        Min_div; //suma
 808
 809
 810 public:
 811     hud_card( int      x,
 812               int      y,
 813               UINT     width,
 814               UINT     height,
 815               FLTFNPTR load_fn,
 816               UINT     options,
 817               float    maxValue,
 818               float    minValue,
 819               float    disp_scaling,
 820               UINT     major_divs,
 821               UINT     minor_divs,
 822               UINT     modulator,
 823               int      dp_showing,
 824               float    value_span,
 825               string   type,
 826               bool     draw_tick_bottom,
 827               bool     draw_tick_top,
 828               bool     draw_tick_right,
 829               bool     draw_tick_left,
 830               bool     draw_cap_bottom,
 831               bool     draw_cap_top,
 832               bool     draw_cap_right,
 833               bool     draw_cap_left,
 834               float    marker_offset,
 835               bool     pointer,
 836               string   pointer_type,
 837               string  tick_type,
 838               string  tick_length,
 839               bool     working,
 840               float    radius, //suma
 841               int      divisions, //suma
 842               int       zoom //suma
 843             );
 844
 845
 846     ~hud_card();
 847     hud_card( const hud_card & image);
 848     hud_card & operator = (const hud_card & rhs );
 849     //    virtual void display_enable( bool setting );
 850     virtual void draw( void );       // Required method in base class
 851     void circles(float,float,float); // suma
 852     void fixed(float,float,float,float,float,float); //suma
 853     void zoomed_scale(int,int); //suma
 854 };
 855
 856 typedef hud_card * pCardScale;
 857
 858 class gauge_instr : public instr_scale {
 859 public:
 860     gauge_instr( int       x,
 861                  int       y,
 862                  UINT      width,
 863                  UINT      height,
 864                  FLTFNPTR  load_fn,
 865                  UINT      options,
 866                  float     disp_scaling,
 867                  float     maxValue,
 868                  float     minValue,
 869                  UINT      major_divs,
 870                  UINT      minor_divs,
 871                  int       dp_showing,
 872                  UINT      modulus,
 873                  bool      working);
 874
 875     ~gauge_instr();
 876     gauge_instr( const gauge_instr & image);
 877     gauge_instr & operator = (const gauge_instr & rhs );
 878     virtual void draw( void );       // Required method in base class
 879 };
 880
 881 typedef gauge_instr * pGaugeInst;
 882 //
 883 // dual_instr_item         This class was created to form the base class
 884 //                         for both panel and HUD Turn Bank Indicators.
 885
 886 class dual_instr_item : public instr_item {
 887 private:
 888     FLTFNPTR alt_data_source;
 889
 890 public:
 891     dual_instr_item ( int       x,
 892                       int       y,
 893                       UINT      width,
 894                       UINT      height,
 895                       FLTFNPTR  chn1_source,
 896                       FLTFNPTR  chn2_source,
 897                       bool      working,
 898                       UINT      options );
 899
 900     virtual ~dual_instr_item() {};
 901     dual_instr_item( const dual_instr_item & image);
 902     dual_instr_item & operator = (const dual_instr_item & rhs );
 903
 904     float current_ch1( void ) { return (float)alt_data_source();}
 905     float current_ch2( void ) { return (float)get_value();}
 906     virtual void draw ( void ) { }
 907 };
 908
 909 class fgTBI_instr : public dual_instr_item
 910 {
 911 private:
 912     UINT BankLimit;
 913     UINT SlewLimit;
 914     UINT scr_hole;
 915     bool tsi;  //suma
 916     float rad; //suma
 917
 918 public:
 919     fgTBI_instr( int       x,
 920                  int       y,
 921                  UINT      width,
 922                  UINT      height,
 923                  FLTFNPTR  chn1_source,
 924                  FLTFNPTR  chn2_source,
 925                  float    maxBankAngle,
 926                  float    maxSlipAngle,
 927                  UINT      gap_width,
 928                  bool      working,
 929                  bool      tsi, //suma
 930                  float     rad); //suma
 931
 932     fgTBI_instr( const fgTBI_instr & image);
 933     fgTBI_instr & operator = (const fgTBI_instr & rhs );
 934
 935     ~fgTBI_instr();
 936
 937     UINT bank_limit( void ) { return BankLimit;}
 938     UINT slew_limit( void ) { return SlewLimit;}
 939
 940     virtual void draw( void );       // Required method in base class
 941 };
 942
 943 typedef fgTBI_instr * pTBI;
 944
 945 class HudLadder : public dual_instr_item {
 946 private:
 947     UINT   width_units;
 948     int    div_units;
 949     UINT   minor_div;
 950     UINT   label_pos;
 951     UINT   scr_hole;
 952     float  vmax;
 953     float  vmin;
 954     float  factor;
 955     string hudladder_type;
 956     bool   frl;
 957     bool   target_spot;
 958     bool   velocity_vector;
 959     bool   drift_marker;
 960     bool   alpha_bracket;
 961     bool        energy_marker;
 962     bool        climb_dive_marker;
 963     bool        glide_slope_marker;
 964     float       glide_slope;
 965     bool        energy_worm;
 966     bool        waypoint_marker;
 967     int     zenith; //suma
 968     int     nadir; //suma
 969     int         hat; //suma
 970
 971
 972     // The Ladder has it's own temporary display lists
 973     fgTextList         TextList;
 974     fgLineList         LineList;
 975     fgLineList         StippleLineList;
 976
 977 public:
 978     HudLadder( const string&    name,
 979                int       x,
 980                int       y,
 981                UINT      width,
 982                UINT      height,
 983                float     factor,
 984                FLTFNPTR  ptch_source,
 985                FLTFNPTR  roll_source,
 986                float     span_units,
 987                float     division_units,
 988                float     minor_division,
 989                UINT      screen_hole,
 990                UINT      lbl_pos,
 991                bool      frl,
 992                bool      target_spot,
 993                bool     velocity_vector,
 994                bool     drift_marker,
 995                bool     alpha_bracket,
 996                bool      energy_marker,
 997                bool      climb_dive_marker,
 998                bool      glide_slope_marker,
 999                float     glide_slope,
1000                bool      energy_worm,
1001                bool      waypoint_marker,
1002                bool  working,
1003                int   zenith, //suma
1004                int   nadir, //suma
1005                int      hat
1006              ); //suma
1007
1008
1009     ~HudLadder();
1010
1011     HudLadder( const HudLadder & image );
1012     HudLadder & operator = ( const HudLadder & rhs );
1013     virtual void draw( void );
1014     void drawZenith(float,float,float); //suma
1015     void drawNadir(float, float, float); //suma
1016
1017     void Text( float x, float y, char *s)
1018     {
1019         TextList.add( fgText( x, y, s) );
1020     }
1021
1022     void Line( float x1, float y1, float x2, float y2)
1023     {
1024         LineList.add(fgLineSeg2D(x1,y1,x2,y2));
1025     }
1026
1027     void StippleLine( float x1, float y1, float x2, float y2)
1028     {
1029         StippleLineList.add(fgLineSeg2D(x1,y1,x2,y2));
1030     }
1031 };
1032
1033
1034 //using namespace std;
1035 //deque <instr_item>  * Hdeque_ptr;
1036
1037 extern void HUD_masterswitch( bool incr );
1038 extern void HUD_brightkey( bool incr_bright );
1039 extern int  fgHUDInit( fgAIRCRAFT * /* current_aircraft */ );
1040 extern int  fgHUDInit2( fgAIRCRAFT * /* current_aircraft */ );
1041 extern void fgUpdateHUD( void );
1042 extern void fgUpdateHUD( GLfloat x_start, GLfloat y_start,
1043                          GLfloat x_end, GLfloat y_end );
1044
1045 /*
1046 bool AddHUDInstrument( instr_item *pBlackBox );
1047 void DrawHUD ( void );
1048 bool DamageInstrument( INSTR_HANDLE unit );
1049 bool RepairInstrument( INSTR_HANDLE unit );
1050
1051
1052 void fgUpdateHUD ( Hptr hud );
1053 void fgUpdateHUD2( Hptr hud ); // Future use?
1054 void fgHUDSetTimeMode( Hptr hud, int time_of_day );
1055 */
1056
1057 #endif // _HUD_H