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