src/Cockpit/hud_tbi.cxx

   1
   2 #include "hud.hxx"
   3 #include<math.h>
   4
   5
   6 //============ Top of fgTBI_instr class member definitions ==============
   7
   8 fgTBI_instr ::
   9 fgTBI_instr( int              x,
  10              int              y,
  11              UINT             width,
  12              UINT             height,
  13              FLTFNPTR  chn1_source,
  14              FLTFNPTR  chn2_source,
  15              float    maxBankAngle,
  16              float    maxSlipAngle,
  17              UINT      gap_width,
  18              bool      working,
  19                          bool      tsivalue, //suma
  20                          float     radius) : //suma
  21                dual_instr_item( x, y, width, height,
  22                                 chn1_source,
  23                                 chn2_source,
  24                                 working,
  25                                 HUDS_TOP),
  26                BankLimit      ((int)(maxBankAngle)),
  27                SlewLimit      ((int)(maxSlipAngle)),
  28                scr_hole       (gap_width   )
  29 {
  30         tsi=tsivalue; //suma
  31         rad=radius; //suma
  32 }
  33
  34 fgTBI_instr :: ~fgTBI_instr() {}
  35
  36 fgTBI_instr :: fgTBI_instr( const fgTBI_instr & image):
  37                  dual_instr_item( (const dual_instr_item &) image),
  38                  BankLimit( image.BankLimit),
  39                  SlewLimit( image.SlewLimit),
  40                  scr_hole ( image.scr_hole )
  41 {
  42 }
  43
  44 fgTBI_instr & fgTBI_instr ::
  45 operator = (const fgTBI_instr & rhs )
  46 {
  47   if( !(this == &rhs)) {
  48     dual_instr_item::operator = (rhs);
  49     BankLimit = rhs.BankLimit;
  50     SlewLimit = rhs.SlewLimit;
  51     scr_hole  = rhs.scr_hole;
  52     }
  53    return *this;
  54 }
  55
  56 //
  57 //  Draws a Turn Bank Indicator on the screen
  58 //
  59
  60  void fgTBI_instr :: draw( void )
  61 {
  62      float bank_angle, sideslip_angle;
  63      float ss_const; // sideslip angle pixels per rad
  64      float cen_x, cen_y, bank, fspan, tee, hole;
  65
  66      int span = get_span();
  67
  68      float zero = 0.0;
  69
  70      RECT My_box = get_location();
  71      POINT centroid = get_centroid();
  72      int tee_height = My_box.bottom;
  73
  74      bank_angle     = current_ch2();  // Roll limit +/- 30 degrees
  75
  76      if( bank_angle < -SGD_PI_2/3 )
  77          {
  78          bank_angle = -SGD_PI_2/3;
  79      }
  80          else if( bank_angle > SGD_PI_2/3 )
  81          {
  82              bank_angle = SGD_PI_2/3;
  83      }
  84
  85
  86          sideslip_angle = current_ch1(); // Sideslip limit +/- 20 degrees
  87
  88      if( sideslip_angle < -SGD_PI/9 )
  89          {
  90          sideslip_angle = -SGD_PI/9;
  91      }
  92          else if( sideslip_angle > SGD_PI/9 )
  93          {
  94              sideslip_angle = SGD_PI/9;
  95      }
  96
  97      cen_x = centroid.x;
  98      cen_y = centroid.y;
  99
 100      bank  = bank_angle * SGD_RADIANS_TO_DEGREES;
 101          tee   = -tee_height;
 102      fspan = span;
 103      hole  = scr_hole;
 104      ss_const = 2 * sideslip_angle * fspan/(SGD_2PI/9);  // width represents 40 degrees
 105
 106 //   printf("side_slip: %f   fspan: %f\n", sideslip_angle, fspan);
 107 //   printf("ss_const: %f   hole: %f\n", ss_const, hole);
 108
 109
 110      glPushMatrix();
 111      glTranslatef(cen_x, cen_y, zero);
 112      glRotatef(-bank, zero, zero, 1.0);
 113
 114          if(!tsi)
 115          {
 116
 117                 glBegin(GL_LINES);
 118
 119                 if( !scr_hole )
 120                 {
 121                         glVertex2f( -fspan, zero );
 122                         glVertex2f(  fspan, zero );
 123                 }
 124                 else
 125                 {
 126                         glVertex2f( -fspan, zero );
 127                         glVertex2f( -hole,  zero );
 128                         glVertex2f(  hole,  zero );
 129                         glVertex2f(  fspan, zero );
 130                 }
 131                 // draw teemarks
 132                 glVertex2f(  hole, zero );
 133                 glVertex2f(  hole, tee );
 134                 glVertex2f( -hole, zero );
 135                 glVertex2f( -hole, tee );
 136
 137                 glEnd();
 138
 139                 glBegin(GL_LINE_LOOP);
 140                         glVertex2f( ss_const,        -hole);
 141                         glVertex2f( ss_const + hole,  zero);
 142                         glVertex2f( ss_const,         hole);
 143                         glVertex2f( ss_const - hole,  zero);
 144                 glEnd();
 145
 146
 147          }
 148
 149
 150          else //if tsi enabled
 151          {
 152                  // float factor = My_box.right / 6.0;
 153
 154                  drawOneLine(cen_x-1.0, My_box.top,      cen_x+1.0, My_box.top);
 155                  drawOneLine(cen_x-1.0, My_box.top,      cen_x-1.0, My_box.top+10.0);
 156                  drawOneLine(cen_x+1.0, My_box.top,      cen_x+1.0, My_box.top+10.0);
 157                  drawOneLine(cen_x-1.0, My_box.top+10.0, cen_x+1.0, My_box.top+10.0);
 158
 159          float x1, y1, x2, y2, x3, y3, x4,y4, x5, y5;
 160                  float xc, yc, r=rad, r1= rad-10.0, r2=rad-5.0;
 161
 162                  xc = My_box.left + My_box.right/ 2.0 ;
 163                  yc = My_box.top + r;
 164
 165 //first n last lines
 166                   x1= xc + r * cos (255.0 * SGD_DEGREES_TO_RADIANS);
 167                   y1= yc + r * sin (255.0 * SGD_DEGREES_TO_RADIANS);
 168
 169                   x2= xc + r1 * cos (255.0 * SGD_DEGREES_TO_RADIANS);
 170                   y2= yc + r1 * sin (255.0 * SGD_DEGREES_TO_RADIANS);
 171
 172                   drawOneLine(x1,y1,x2,y2);
 173
 174                   x1= xc + r * cos (285.0 * SGD_DEGREES_TO_RADIANS);
 175                   y1= yc + r * sin (285.0 * SGD_DEGREES_TO_RADIANS);
 176
 177                   x2= xc + r1 * cos (285.0 * SGD_DEGREES_TO_RADIANS);
 178                   y2= yc + r1 * sin (285.0 * SGD_DEGREES_TO_RADIANS);
 179
 180           drawOneLine(x1,y1,x2,y2);
 181
 182 //second n fifth  lines
 183
 184                   x1= xc + r * cos (260.0 * SGD_DEGREES_TO_RADIANS);
 185                   y1= yc + r * sin (260.0 * SGD_DEGREES_TO_RADIANS);
 186
 187                   x2= xc + r2 * cos (260.0 * SGD_DEGREES_TO_RADIANS);
 188                   y2= yc + r2 * sin (260.0 * SGD_DEGREES_TO_RADIANS);
 189
 190                   drawOneLine(x1,y1,x2,y2);
 191
 192                   x1= xc + r * cos (280.0 * SGD_DEGREES_TO_RADIANS);
 193                   y1= yc + r * sin (280.0 * SGD_DEGREES_TO_RADIANS);
 194
 195
 196                   x2= xc + r2 * cos (280.0 * SGD_DEGREES_TO_RADIANS);
 197                   y2= yc + r2 * sin (280.0 * SGD_DEGREES_TO_RADIANS);
 198
 199           drawOneLine(x1,y1,x2,y2);
 200
 201 //third n fourth lines
 202
 203
 204                   x1= xc + r * cos (265.0 * SGD_DEGREES_TO_RADIANS);
 205                   y1= yc + r * sin (265.0 * SGD_DEGREES_TO_RADIANS);
 206
 207
 208                   x2= xc + r2 * cos (265.0 * SGD_DEGREES_TO_RADIANS);
 209                   y2= yc + r2 * sin (265.0 * SGD_DEGREES_TO_RADIANS);
 210
 211                   drawOneLine(x1,y1,x2,y2);
 212
 213                   x1= xc + r * cos (275.0 * SGD_DEGREES_TO_RADIANS);
 214                   y1= yc + r * sin (275.0 * SGD_DEGREES_TO_RADIANS);
 215
 216                   x2= xc + r2 * cos (275.0 * SGD_DEGREES_TO_RADIANS);
 217                   y2= yc + r2 * sin (275.0 * SGD_DEGREES_TO_RADIANS);
 218
 219           drawOneLine(x1,y1,x2,y2);
 220
 221                   //to draw marker
 222
 223
 224
 225                           float  valbank, valsideslip, sideslip;
 226
 227                           r = rad + 5.0;  //5 is added to get a gap
 228                          // upper polygon
 229               bank_angle     = current_ch2();
 230
 231                           bank= bank_angle * SGD_RADIANS_TO_DEGREES;  // Roll limit +/- 30 degrees
 232                           if(bank > BankLimit)
 233                                         bank = BankLimit;
 234                           if(bank < -1.0*BankLimit)
 235                                         bank = -1.0*BankLimit;
 236
 237                           valbank = bank * 15.0 / BankLimit; // total span of TSI is 30 degrees
 238
 239                           sideslip_angle = current_ch1(); // Sideslip limit +/- 20 degrees
 240                           sideslip= sideslip_angle * SGD_RADIANS_TO_DEGREES;
 241                           if(sideslip > SlewLimit)
 242                                   sideslip = SlewLimit;
 243                           if(sideslip < -1.0*SlewLimit)
 244                                   sideslip = -1.0*SlewLimit;
 245               valsideslip = sideslip * 15.0 / SlewLimit;
 246
 247                           //values 270, 225 and 315 are angles in degrees...
 248
 249                           x1= xc + r * cos ((valbank+270.0) * SGD_DEGREES_TO_RADIANS);
 250                           y1= yc + r * sin ((valbank+270.0) * SGD_DEGREES_TO_RADIANS);
 251
 252                           x2= x1 + 6.0 * cos (225 * SGD_DEGREES_TO_RADIANS);
 253                           y2= y1 + 6.0 * sin (225 * SGD_DEGREES_TO_RADIANS);
 254
 255                           x3= x1 + 6.0 * cos (315 * SGD_DEGREES_TO_RADIANS);
 256                           y3= y1 + 6.0 * sin (315 * SGD_DEGREES_TO_RADIANS);
 257
 258                       drawOneLine(x1, y1, x2, y2);
 259                           drawOneLine(x2, y2, x3, y3);
 260                           drawOneLine(x3, y3, x1, y1);
 261
 262                           //lower polygon...
 263
 264
 265
 266                           x1= xc + r * cos ((valbank+270.0) * SGD_DEGREES_TO_RADIANS);
 267                           y1= yc + r * sin ((valbank+270.0) * SGD_DEGREES_TO_RADIANS);
 268
 269                           x2= x1 + 6.0 * cos (225 * SGD_DEGREES_TO_RADIANS);
 270                           y2= y1 + 6.0 * sin (225 * SGD_DEGREES_TO_RADIANS);
 271
 272                           x3= x1 + 6.0 * cos (315 * SGD_DEGREES_TO_RADIANS);
 273                           y3= y1 + 6.0 * sin (315 * SGD_DEGREES_TO_RADIANS);
 274
 275                           x4= x1 + 10.0 * cos (225 * SGD_DEGREES_TO_RADIANS);
 276                           y4= y1 + 10.0 * sin (225 * SGD_DEGREES_TO_RADIANS);
 277
 278                           x5= x1 + 10.0 * cos (315 * SGD_DEGREES_TO_RADIANS);
 279                           y5= y1 + 10.0 * sin (315 * SGD_DEGREES_TO_RADIANS);
 280
 281                           x2 = x2 + cos (valsideslip * SGD_DEGREES_TO_RADIANS);
 282                       y2 = y2 + sin (valsideslip * SGD_DEGREES_TO_RADIANS);
 283                           x3 = x3 + cos (valsideslip * SGD_DEGREES_TO_RADIANS);
 284                           y3 = y3 + sin (valsideslip * SGD_DEGREES_TO_RADIANS);
 285                           x4 = x4 + cos (valsideslip * SGD_DEGREES_TO_RADIANS);
 286                           y4 = y4 + sin (valsideslip * SGD_DEGREES_TO_RADIANS);
 287                           x5 = x5 + cos (valsideslip * SGD_DEGREES_TO_RADIANS);
 288                           y5 = y5 + sin (valsideslip * SGD_DEGREES_TO_RADIANS);
 289
 290                           drawOneLine(x2, y2, x3, y3);
 291                           drawOneLine(x3, y3, x5, y5);
 292                           drawOneLine(x5, y5, x4, y4);
 293                           drawOneLine(x4, y4, x2, y2);
 294
 295
 296          }
 297
 298                 glPopMatrix();
 299 }