src/Cockpit/cockpit.cxx

   1 // cockpit.cxx -- routines to draw a cockpit (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 #ifdef HAVE_CONFIG_H
  25 #  include <config.h>
  26 #endif
  27
  28 #ifdef HAVE_WINDOWS_H
  29 #  include <windows.h>
  30 #endif
  31
  32 #include <GL/glut.h>
  33 #include <XGL/xgl.h>
  34
  35 #include <stdlib.h>
  36 #include <stdio.h>
  37 #include <string.h>
  38
  39 #include <Aircraft/aircraft.hxx>
  40 #include <Debug/logstream.hxx>
  41 #include <Include/fg_constants.h>
  42 #include <Include/general.hxx>
  43 #include <Main/options.hxx>
  44 #include <Main/views.hxx>
  45 #include <Math/fg_random.h>
  46 #include <Math/mat3.h>
  47 #include <Math/polar3d.hxx>
  48 #include <Scenery/scenery.hxx>
  49 #include <Time/fg_timer.hxx>
  50 #include <Time/fg_time.hxx>
  51 #include <GUI/gui.h>
  52
  53 #include "cockpit.hxx"
  54
  55
  56 // This is a structure that contains all data related to
  57 // cockpit/panel/hud system
  58
  59 static pCockpit ac_cockpit;
  60 fntRenderer *HUDtext = 0;
  61 float  HUD_TextSize = 0;
  62 int HUD_style = 0;
  63
  64 float HUD_matrix[16];
  65 // The following routines obtain information concerntin the aircraft's
  66 // current state and return it to calling instrument display routines.
  67 // They should eventually be member functions of the aircraft.
  68 //
  69
  70 float get_latitude( void )
  71 {
  72     double lat;
  73
  74     lat = current_aircraft.fdm_state->get_Latitude() * RAD_TO_DEG;
  75
  76     float flat = lat;
  77     return(flat);
  78
  79 }
  80
  81 float get_lat_min( void )
  82 {
  83     double      a, d;
  84
  85     a = current_aircraft.fdm_state->get_Latitude() * RAD_TO_DEG;
  86     if (a < 0.0) {
  87         a = -a;
  88     }
  89     d = (double) ( (int) a);
  90     float lat_min = (a - d) * 60.0;
  91     return(lat_min );
  92 }
  93
  94
  95 float get_longitude( void )
  96 {
  97     double lon;
  98
  99     lon = current_aircraft.fdm_state->get_Longitude() * RAD_TO_DEG;
 100
 101     float flon = lon;
 102     return(flon);
 103 }
 104
 105
 106 char*
 107 get_formated_gmt_time( void )
 108 {
 109     static char buf[32];
 110     FGTime *t = FGTime::cur_time_params;
 111     const struct tm *p = t->getGmt();
 112     sprintf( buf, "%d/%d/%2d %d:%02d:%02d",
 113          p->tm_mon+1, p->tm_mday, p->tm_year,
 114          p->tm_hour, p->tm_min, p->tm_sec);
 115     return buf;
 116 }
 117
 118
 119 float get_long_min( void )
 120 {
 121     double  a, d;
 122     a = current_aircraft.fdm_state->get_Longitude() * RAD_TO_DEG;
 123     if (a < 0.0) {
 124         a = -a;
 125     }
 126     d = (double) ( (int) a);
 127     float lon_min = (a - d) * 60.0;
 128     return(lon_min);
 129 }
 130
 131 float get_throttleval( void )
 132 {
 133     float throttle = controls.get_throttle( 0 );
 134     return (throttle);     // Hack limiting to one engine
 135 }
 136
 137 float get_aileronval( void )
 138 {
 139     float aileronval = controls.get_aileron();
 140     return (aileronval);
 141 }
 142
 143 float get_elevatorval( void )
 144 {
 145     float elevator_val = (float)controls.get_elevator();
 146     return elevator_val;
 147 }
 148
 149 float get_elev_trimval( void )
 150 {
 151     float elevatorval = controls.get_elevator_trim();
 152     return (elevatorval);
 153 }
 154
 155 float get_rudderval( void )
 156 {
 157     float rudderval = controls.get_rudder();
 158     return (rudderval);
 159 }
 160
 161 float get_speed( void )
 162 {
 163     // Make an explicit function call.
 164     float speed = current_aircraft.fdm_state->get_V_equiv_kts();
 165     return( speed );
 166 }
 167
 168 float get_aoa( void )
 169 {
 170     float aoa = current_aircraft.fdm_state->get_Alpha() * RAD_TO_DEG;
 171     return( aoa );
 172 }
 173
 174 float get_roll( void )
 175 {
 176     float roll = current_aircraft.fdm_state->get_Phi();
 177     return( roll );
 178 }
 179
 180 float get_pitch( void )
 181 {
 182     float pitch = current_aircraft.fdm_state->get_Theta();
 183     return( pitch );
 184 }
 185
 186 float get_heading( void )
 187 {
 188     float heading = (current_aircraft.fdm_state->get_Psi() * RAD_TO_DEG);
 189     return( heading );
 190 }
 191
 192 float get_altitude( void )
 193 {
 194 //  FGState *f;
 195     // double rough_elev;
 196
 197 //  current_aircraft.fdm_state
 198     // rough_elev = mesh_altitude(f->get_Longitude() * RAD_TO_ARCSEC,
 199     //                         f->get_Latitude()  * RAD_TO_ARCSEC);
 200     float altitude;
 201
 202     if ( current_options.get_units() == fgOPTIONS::FG_UNITS_FEET ) {
 203         altitude = current_aircraft.fdm_state->get_Altitude();
 204     } else {
 205         altitude = (current_aircraft.fdm_state->get_Altitude() * FEET_TO_METER);
 206     }
 207     return altitude;
 208 }
 209
 210 float get_agl( void )
 211 {
 212     float agl;
 213
 214     if ( current_options.get_units() == fgOPTIONS::FG_UNITS_FEET ) {
 215         agl = (current_aircraft.fdm_state->get_Altitude()
 216                - scenery.cur_elev * METER_TO_FEET);
 217     } else {
 218         agl = (current_aircraft.fdm_state->get_Altitude() * FEET_TO_METER
 219                - scenery.cur_elev);
 220     }
 221     return agl;
 222 }
 223
 224 float get_sideslip( void )
 225 {
 226     float sideslip = current_aircraft.fdm_state->get_Beta();
 227     return( sideslip );
 228 }
 229
 230 float get_frame_rate( void )
 231 {
 232     float frame_rate = general.get_frame_rate();
 233     return (frame_rate);
 234 }
 235
 236 float get_fov( void )
 237 {
 238     float fov = current_options.get_fov();
 239     return (fov);
 240 }
 241
 242 float get_vfc_ratio( void )
 243 {
 244     float vfc = current_view.get_vfc_ratio();
 245     return (vfc);
 246 }
 247
 248 float get_vfc_tris_drawn   ( void )
 249 {
 250     float rendered = current_view.get_tris_rendered();
 251     return (rendered);
 252 }
 253
 254 float get_vfc_tris_culled   ( void )
 255 {
 256     float culled = current_view.get_tris_culled();
 257     return (culled);
 258 }
 259
 260 float get_climb_rate( void )
 261 {
 262     float climb_rate;
 263     if ( current_options.get_units() == fgOPTIONS::FG_UNITS_FEET ) {
 264         climb_rate = current_aircraft.fdm_state->get_Climb_Rate() * 60.0;
 265     } else {
 266         climb_rate = current_aircraft.fdm_state->get_Climb_Rate() * FEET_TO_METER * 60.0;
 267     }
 268     return (climb_rate);
 269 }
 270
 271
 272 float get_view_direction( void )
 273 {
 274     double view;
 275
 276     view = FG_2PI - current_view.get_view_offset();
 277     view = ( current_aircraft.fdm_state->get_Psi() + view) * RAD_TO_DEG;
 278
 279     if(view > 360.)
 280         view -= 360.;
 281     else if(view<0.)
 282         view += 360.;
 283
 284     float fview = view;
 285     return( fview );
 286 }
 287
 288 #ifdef NOT_USED
 289 /****************************************************************************/
 290 /* Convert degrees to dd mm'ss.s" (DMS-Format)                              */
 291 /****************************************************************************/
 292 char *dmshh_format(double degrees)
 293 {
 294     static char buf[16];
 295     int deg_part;
 296     int min_part;
 297     double sec_part;
 298
 299     if (degrees < 0)
 300       degrees = -degrees;
 301
 302     deg_part = degrees;
 303     min_part = 60.0 * (degrees - deg_part);
 304     sec_part = 3600.0 * (degrees - deg_part - min_part / 60.0);
 305
 306     /* Round off hundredths */
 307     if (sec_part + 0.005 >= 60.0)
 308       sec_part -= 60.0, min_part += 1;
 309     if (min_part >= 60)
 310       min_part -= 60, deg_part += 1;
 311
 312     sprintf(buf,"%02d*%02d %05.2f",deg_part,min_part,sec_part);
 313
 314     return buf;
 315 }
 316 #endif // 0
 317
 318 /****************************************************************************/
 319 /* Convert degrees to dd mm'ss.s'' (DMS-Format)                              */
 320 /****************************************************************************/
 321 static char *toDMS(float a)
 322 {
 323   int        neg = 0;
 324   float       d, m, s;
 325   static char  dms[16];
 326
 327   if (a < 0.0f) {
 328     a   = -a;
 329     neg = 1;
 330   }
 331   d = (float) ((int) a);
 332   a = (a - d) * 60.0f;
 333   m = (float) ((int) a);
 334   s = (a - m) * 60.0f;
 335
 336   if (s > 59.5f) {
 337     s  = 0.0f;
 338     m += 1.0f;
 339   }
 340   if (m > 59.5f) {
 341     m  = 0.0f;
 342     d += 1.0f;
 343   }
 344   if (neg)
 345     d = -d;
 346
 347   sprintf(dms, "%.0f*%02.0f %04.1f", d, m, s);
 348   return dms;
 349 }
 350
 351
 352 /****************************************************************************/
 353 /* Convert degrees to dd mm.mmm' (DMM-Format)                               */
 354 /****************************************************************************/
 355 static char *toDM(float a)
 356 {
 357   int        neg = 0;
 358   float       d, m;
 359   static char  dm[16];
 360
 361   if (a < 0.0f) {
 362     a = -a;
 363     neg = 1;
 364   }
 365
 366   d = (float) ( (int) a);
 367   m = (a - d) * 60.0f;
 368
 369   if (m > 59.5f) {
 370     m  = 0.0f;
 371     d += 1.0f;
 372   }
 373   if (neg) d = -d;
 374
 375   sprintf(dm, "%.0f*%06.3f", d, m);
 376   return dm;
 377 }
 378
 379 // Have to set the LatLon display type
 380 //static char *(*fgLatLonFormat)(float) = toDM;
 381 static char *(*fgLatLonFormat)(float);
 382
 383 char *coord_format_lat(float latitude)
 384 {
 385     static char buf[16];
 386
 387     sprintf(buf,"%s%c",
 388 //      dmshh_format(latitude),
 389 //      toDMS(latitude),
 390 //      toDM(latitude),
 391         fgLatLonFormat(latitude),
 392         latitude > 0 ? 'N' : 'S');
 393     return buf;
 394 }
 395
 396 char *coord_format_lon(float longitude)
 397 {
 398     static char buf[80];
 399
 400     sprintf(buf,"%s%c",
 401 //      dmshh_format(longitude),
 402 //      toDMS(longitude),
 403 //      toDM(longitude),
 404         fgLatLonFormat(longitude),
 405         longitude > 0 ? 'E' : 'W');
 406     return buf;
 407 }
 408
 409 void fgLatLonFormatToggle( puObject *)
 410 {
 411     static int toggle = 0;
 412
 413     if ( toggle )
 414         fgLatLonFormat = toDM;
 415     else
 416         fgLatLonFormat = toDMS;
 417
 418     toggle = ~toggle;
 419 }
 420
 421 #ifdef NOT_USED
 422 char *coord_format_latlon(double latitude, double longitude)
 423 {
 424     static char buf[1024];
 425
 426     sprintf(buf,"%s%c %s%c",
 427         dmshh_format(latitude),
 428         latitude > 0 ? 'N' : 'S',
 429         dmshh_format(longitude),
 430         longitude > 0 ? 'E' : 'W');
 431     return buf;
 432 }
 433 #endif
 434
 435
 436 bool fgCockpitInit( fgAIRCRAFT *cur_aircraft )
 437 {
 438     FG_LOG( FG_COCKPIT, FG_INFO, "Initializing cockpit subsystem" );
 439
 440     //  cockpit->code = 1;  /* It will be aircraft dependent */
 441     //  cockpit->status = 0;
 442
 443     // If aircraft has HUD specified we will get the specs from its def
 444     // file. For now we will depend upon hard coding in hud?
 445
 446     // We must insure that the existing instrument link is purged.
 447     // This is done by deleting the links in the list.
 448
 449     // HI_Head is now a null pointer so we can generate a new list from the
 450     // current aircraft.
 451
 452     fgHUDInit( cur_aircraft );
 453     ac_cockpit = new fg_Cockpit();
 454
 455     if ( current_options.get_panel_status() ) {
 456         new FGPanel;
 457     }
 458
 459     // Have to set the LatLon display type
 460     fgLatLonFormat = toDM;
 461
 462     FG_LOG( FG_COCKPIT, FG_INFO,
 463         "  Code " << ac_cockpit->code() << " Status "
 464         << ac_cockpit->status() );
 465
 466 //  HUD_TextSize = (current_options.get_xsize() > 1000) ? 10 : 8;
 467     HUD_TextSize = 10;
 468     HUDtext = new fntRenderer();
 469     HUDtext -> setFont      ( guiFntHandle ) ;
 470     HUDtext -> setPointSize ( HUD_TextSize ) ;
 471     HUD_TextList.setFont( HUDtext );
 472
 473     return true;
 474 }
 475
 476
 477 void fgCockpitUpdate( void ) {
 478
 479     int iwidth   = current_view.get_winWidth();
 480     int iheight  = current_view.get_winHeight();
 481     float width  = iwidth;
 482     float height = iheight;
 483
 484     FG_LOG( FG_COCKPIT, FG_DEBUG,
 485         "Cockpit: code " << ac_cockpit->code() << " status "
 486         << ac_cockpit->status() );
 487
 488     if ( current_options.get_hud_status() ) {
 489         // This will check the global hud linked list pointer.
 490         // If these is anything to draw it will.
 491         fgUpdateHUD();
 492     }
 493 #define DISPLAY_COUNTER
 494 #ifdef DISPLAY_COUNTER
 495     else
 496     {
 497         char buf[64];
 498         float fps    =       get_frame_rate();
 499 //      float tris   = fps * get_vfc_tris_drawn();
 500 //      float culled = fps * get_vfc_tris_culled();
 501 //      sprintf(buf,"%-4.1f  %7.0f  %7.0f", fps, tris, culled);
 502         sprintf(buf,"%-5.1f", fps);
 503
 504         glMatrixMode(GL_PROJECTION);
 505         glPushMatrix();
 506         glLoadIdentity();
 507         gluOrtho2D(0, width, 0, height);
 508         glMatrixMode(GL_MODELVIEW);
 509         glPushMatrix();
 510         glLoadIdentity();
 511
 512         glDisable(GL_DEPTH_TEST);
 513         glDisable(GL_LIGHTING);
 514
 515         glColor3f (0.9, 0.4, 0.2);
 516
 517         guiFnt.drawString( buf,
 518                            width/2 - guiFnt.getStringWidth(buf)/2,
 519                            10 );
 520         glEnable(GL_DEPTH_TEST);
 521         glEnable(GL_LIGHTING);
 522         glMatrixMode(GL_PROJECTION);
 523         glPopMatrix();
 524         glMatrixMode(GL_MODELVIEW);
 525         glPopMatrix();
 526     }
 527 #endif // #ifdef DISPLAY_COUNTER
 528
 529     if( current_options.get_panel_status() &&
 530          (fabs( current_view.get_view_offset() ) < 0.2) )
 531     {
 532         xglViewport( 0, 0, iwidth, iheight );
 533
 534         FGPanel::OurPanel->Update();
 535     }
 536 }