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