src/Cockpit/panel.cxx

   1 //  panel.cxx - default, 2D single-engine prop instrument panel
   2 //
   3 //  Written by David Megginson, started January 2000.
   4 //
   5 //  This program is free software; you can redistribute it and/or
   6 //  modify it under the terms of the GNU General Public License as
   7 //  published by the Free Software Foundation; either version 2 of the
   8 //  License, or (at your option) any later version.
   9 //
  10 //  This program is distributed in the hope that it will be useful, but
  11 //  WITHOUT ANY WARRANTY; without even the implied warranty of
  12 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13 //  General Public License for more details.
  14 //
  15 //  You should have received a copy of the GNU General Public License
  16 //  along with this program; if not, write to the Free Software
  17 //  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18 //
  19 //  $Id$
  20
  21 #ifdef HAVE_CONFIG_H
  22 #  include <config.h>
  23 #endif
  24
  25 #ifdef HAVE_WINDOWS_H
  26 #  include <windows.h>
  27 #endif
  28
  29 #include <string.h>
  30
  31 #include <plib/ssg.h>
  32 #include <plib/fnt.h>
  33 #include <GL/glut.h>
  34
  35 #include <simgear/debug/logstream.hxx>
  36 #include <simgear/misc/fgpath.hxx>
  37 #include <Main/options.hxx>
  38 #include <Main/bfi.hxx>
  39 #include <Objects/texload.h>
  40 #include <Autopilot/autopilot.hxx>
  41 #include <Time/fg_time.hxx>
  42
  43 #include "cockpit.hxx"
  44 #include "panel.hxx"
  45 #include "hud.hxx"
  46 #include "steam.hxx"
  47
  48 extern fgAPDataPtr APDataGlobal;
  49
  50 #define SIX_X 200
  51 #define SIX_Y 345
  52 #define SIX_W 128
  53 #define SIX_SPACING (SIX_W + 5)
  54 #define SMALL_W 112
  55
  56
  57 \f
  58 ////////////////////////////////////////////////////////////////////////
  59 // Static functions for obtaining settings.
  60 //
  61 // These should be replaced with functions from a global facade,
  62 // or BFI (Big Friendly Interface).
  63 ////////////////////////////////////////////////////////////////////////
  64
  65 static char * panelGetTime (char * buf)
  66 {
  67   struct tm * t = FGTime::cur_time_params->getGmt();
  68   sprintf(buf, " %.2d:%.2d:%.2d",
  69           t->tm_hour, t->tm_min, t->tm_sec);
  70   return buf;
  71 }
  72
  73
  74 \f
  75 ////////////////////////////////////////////////////////////////////////
  76 // Static factory functions to create textured gauges.
  77 //
  78 // These will be replaced first with a giant table, and then with
  79 // configuration files read from an external source, but for now
  80 // they're hard-coded.
  81 ////////////////////////////////////////////////////////////////////////
  82
  83 static ssgTexture *
  84 createTexture (const char * relativePath)
  85 {
  86   return FGPanel::OurPanel->createTexture(relativePath);
  87 }
  88
  89
  90 /**
  91  * Construct an airspeed indicator for a single-engine prop.
  92  */
  93 static FGPanelInstrument *
  94 createAirspeedIndicator (int x, int y)
  95 {
  96   FGLayeredInstrument * inst = new FGLayeredInstrument(x, y, SIX_W, SIX_W);
  97
  98                                 // Layer 0: gauge background.
  99   inst->addLayer(0, createTexture("Textures/Panel/airspeed.rgb"));
 100
 101                                 // Layer 1: needle.
 102                                 // Rotates with airspeed.
 103   inst->addLayer(1, createTexture("Textures/Panel/long-needle.rgb"));
 104   inst->addTransformation(1, FGInstrumentLayer::ROTATION,
 105                           FGSteam::get_ASI_kias,
 106                           30.0, 220.0, 36.0 / 20.0, -54.0);
 107   return inst;
 108 }
 109
 110
 111 /**
 112  * Construct an artificial horizon.
 113  */
 114 static FGPanelInstrument *
 115 createHorizon (int x, int y)
 116 {
 117   FGLayeredInstrument * inst = new FGLayeredInstrument(x, y, SIX_W, SIX_W);
 118
 119                                 // Layer 0: coloured background
 120                                 // moves with roll only
 121   inst->addLayer(0, createTexture("Textures/Panel/horizon-bg.rgb"));
 122   inst->addTransformation(0, FGInstrumentLayer::ROTATION,
 123                           FGBFI::getRoll,
 124                           -360.0, 360.0, -1.0, 0.0);
 125
 126                                 // Layer 1: floating horizon
 127                                 // moves with roll and pitch
 128   inst->addLayer(1, createTexture("Textures/Panel/horizon-float.rgb"));
 129   inst->addTransformation(1, FGInstrumentLayer::ROTATION,
 130                           FGBFI::getRoll,
 131                           -360.0, 360.0, -1.0, 0.0);
 132   inst->addTransformation(1, FGInstrumentLayer::YSHIFT,
 133                           FGBFI::getPitch,
 134                           -20.0, 20.0, -(1.5 / 160.0) * SIX_W, 0.0);
 135
 136                                 // Layer 2: rim
 137                                 // moves with roll only
 138   inst->addLayer(2, createTexture("Textures/Panel/horizon-rim.rgb"));
 139   inst->addTransformation(2, FGInstrumentLayer::ROTATION,
 140                           FGBFI::getRoll,
 141                           -360.0, 360.0, -1.0, 0.0);
 142
 143                                 // Layer 3: glass front of gauge
 144                                 // fixed, with markings
 145   inst->addLayer(3, createTexture("Textures/Panel/horizon-fg.rgb"));
 146
 147   return inst;
 148 }
 149
 150
 151 /**
 152  * Construct an altimeter.
 153  */
 154 static FGPanelInstrument *
 155 createAltimeter (int x, int y)
 156 {
 157   FGLayeredInstrument * inst = new FGLayeredInstrument(x, y, SIX_W, SIX_W);
 158
 159                                 // Layer 0: gauge background
 160   inst->addLayer(0, createTexture("Textures/Panel/altimeter.rgb"));
 161
 162                                 // Layer 1: hundreds needle (long)
 163                                 // moves with altitude
 164   inst->addLayer(1, createTexture("Textures/Panel/long-needle.rgb"));
 165   inst->addTransformation(1, FGInstrumentLayer::ROTATION,
 166                           FGSteam::get_ALT_ft,
 167                           0.0, 100000.0, 360.0 / 1000.0, 0.0);
 168
 169                                 // Layer 2: thousands needle (short)
 170                                 // moves with altitude
 171   inst->addLayer(2, createTexture("Textures/Panel/short-needle.rgb"));
 172   inst->addTransformation(2, FGInstrumentLayer::ROTATION,
 173                           FGSteam::get_ALT_ft,
 174                           0.0, 100000.0, 360.0 / 10000.0, 0.0);
 175
 176                                 // Layer 3: ten thousands bug (outside)
 177                                 // moves with altitude
 178   inst->addLayer(3, createTexture("Textures/Panel/bug.rgb"));
 179   inst->addTransformation(3, FGInstrumentLayer::ROTATION,
 180                           FGSteam::get_ALT_ft,
 181                           0.0, 100000.0, 360.0 / 100000.0, 0.0);
 182
 183   return inst;
 184 }
 185
 186
 187 /**
 188  * Construct a turn coordinator.
 189  */
 190 static FGPanelInstrument *
 191 createTurnCoordinator (int x, int y)
 192 {
 193   FGLayeredInstrument * inst = new FGLayeredInstrument(x, y, SIX_W, SIX_W);
 194
 195                                 // Layer 0: background
 196   inst->addLayer(0, createTexture("Textures/Panel/turn-bg.rgb"));
 197
 198                                 // Layer 1: little plane
 199                                 // moves with roll
 200   inst->addLayer(1, createTexture("Textures/Panel/turn.rgb"));
 201   inst->addTransformation(1, FGInstrumentLayer::ROTATION,
 202                           FGSteam::get_TC_radps,
 203                           -30.0, 30.0, 1.0, 0.0);
 204
 205                                 // Layer 2: little ball
 206                                 // moves with slip/skid
 207   inst->addLayer(2, createTexture("Textures/Panel/ball.rgb"));
 208   inst->addTransformation(2, FGInstrumentLayer::ROTATION,
 209                           FGSteam::get_TC_radps,
 210                           -0.1, 0.1, 450.0, 0.0);
 211
 212   return inst;
 213 }
 214
 215
 216 /**
 217  * Construct a gyro compass.
 218  */
 219 static FGPanelInstrument *
 220 createGyroCompass (int x, int y)
 221 {
 222   FGLayeredInstrument * inst = new FGLayeredInstrument(x, y, SIX_W, SIX_W);
 223
 224                                 // Layer 0: compass background
 225                                 // rotates with heading
 226   inst->addLayer(0, createTexture("Textures/Panel/gyro-bg.rgb"));
 227   inst->addTransformation(0, FGInstrumentLayer::ROTATION,
 228                           FGSteam::get_DG_deg,
 229                           -360.0, 360.0, -1.0, 0.0);
 230
 231                                 // Layer 1: heading bug
 232                                 // rotates with heading and AP heading
 233   inst->addLayer(1, createTexture("Textures/Panel/bug.rgb"));
 234   inst->addTransformation(1, FGInstrumentLayer::ROTATION,
 235                           FGSteam::get_DG_deg,
 236                           -360.0, 360.0, -1.0, 0.0);
 237   inst->addTransformation(1, FGInstrumentLayer::ROTATION,
 238                           FGBFI::getAPHeading,
 239                           -360.0, 360.0, 1.0, 0.0);
 240
 241                                 // Layer 2: fixed center
 242   inst->addLayer(2, createTexture("Textures/Panel/gyro-fg.rgb"));
 243
 244   return inst;
 245 }
 246
 247
 248 /**
 249  * Construct a vertical velocity indicator.
 250  */
 251 static FGPanelInstrument *
 252 createVerticalVelocity (int x, int y)
 253 {
 254   FGLayeredInstrument * inst = new FGLayeredInstrument(x, y, SIX_W, SIX_W);
 255
 256                                 // Layer 0: gauge background
 257   inst->addLayer(0, createTexture("Textures/Panel/vertical.rgb"));
 258
 259                                 // Layer 1: needle
 260                                 // moves with vertical velocity
 261   inst->addLayer(1, createTexture("Textures/Panel/long-needle.rgb"));
 262   inst->addTransformation(1, FGInstrumentLayer::ROTATION,
 263                           FGSteam::get_VSI_fps,
 264                           -2000.0, 2000.0, 42.0/500.0, 270.0);
 265
 266   return inst;
 267 }
 268
 269
 270 /**
 271  * Construct an RPM gauge.
 272  */
 273 static FGPanelInstrument *
 274 createRPMGauge (int x, int y)
 275 {
 276   FGLayeredInstrument * inst = new FGLayeredInstrument(x, y, SMALL_W, SMALL_W);
 277
 278                                 // Layer 0: gauge background
 279   inst->addLayer(0, createTexture("Textures/Panel/rpm.rgb"));
 280
 281                                 // Layer 1: long needle
 282                                 // FIXME: moves with throttle (for now)
 283   inst->addLayer(1, createTexture("Textures/Panel/long-needle.rgb"));
 284   inst->addTransformation(1, FGInstrumentLayer::ROTATION,
 285                           FGBFI::getThrottle,
 286                           0.0, 100.0, 300.0, -150.0);
 287
 288   return inst;
 289 }
 290
 291
 292 /**
 293  * Construct a flap position indicator.
 294  */
 295 static FGPanelInstrument *
 296 createFlapIndicator (int x, int y)
 297 {
 298   FGLayeredInstrument * inst = new FGLayeredInstrument(x, y, SMALL_W, SMALL_W);
 299
 300                                 // Layer 0: gauge background
 301   inst->addLayer(0, createTexture("Textures/Panel/flaps.rgb"));
 302
 303                                 // Layer 1: long needle
 304                                 // shifted over, rotates with flap position
 305   inst->addLayer(1, createTexture("Textures/Panel/long-needle.rgb"));
 306   inst->addTransformation(1, FGInstrumentLayer::XSHIFT,
 307                           -(SMALL_W / 4) + (SMALL_W / 16));
 308   inst->addTransformation(1, FGInstrumentLayer::ROTATION,
 309                           FGBFI::getFlaps,
 310                           0.0, 1.0, 120.0, 30.0);
 311
 312   return inst;
 313 }
 314
 315 static FGPanelInstrument *
 316 createChronometer (int x, int y)
 317 {
 318   FGLayeredInstrument * inst = new FGLayeredInstrument(x, y, SMALL_W, SMALL_W);
 319
 320                                 // Layer 0: gauge background
 321   inst->addLayer(0, createTexture("Textures/Panel/clock.rgb"));
 322
 323                                 // Layer 1: text
 324                                 // displays current GMT
 325   FGCharInstrumentLayer * text =
 326     new FGCharInstrumentLayer(panelGetTime,
 327                               SMALL_W, SMALL_W, 1);
 328   text->setPointSize(14);
 329   text->setColor(0.2, 0.2, 0.2);
 330   inst->addLayer(text);
 331   inst->addTransformation(1, FGInstrumentLayer::XSHIFT, SMALL_W * -0.38);
 332   inst->addTransformation(1, FGInstrumentLayer::YSHIFT, SMALL_W * -0.06);
 333
 334   return inst;
 335 }
 336
 337
 338 /**
 339  * Construct control-position indicators.
 340  */
 341 static FGPanelInstrument *
 342 createControls (int x, int y)
 343 {
 344   FGLayeredInstrument * inst = new FGLayeredInstrument(x, y, SMALL_W, SMALL_W);
 345
 346                                 // Layer 0: gauge background
 347   inst->addLayer(0, createTexture("Textures/Panel/controls.rgb"));
 348
 349                                 // Layer 1: bug
 350                                 // moves left-right with aileron
 351   inst->addLayer(1, createTexture("Textures/Panel/bug.rgb"));
 352   inst->addTransformation(1, FGInstrumentLayer::XSHIFT, FGBFI::getAileron,
 353                           -1.0, 1.0, SMALL_W * .75 / 2.0, 0.0);
 354
 355                                 // Layer 2: bug
 356                                 // moves left-right with rudder
 357   inst->addLayer(2, createTexture("Textures/Panel/bug.rgb"));
 358   inst->addTransformation(2, FGInstrumentLayer::ROTATION, 180.0);
 359   inst->addTransformation(2, FGInstrumentLayer::XSHIFT, FGBFI::getRudder,
 360                           -1.0, 1.0, -SMALL_W * .75 / 2.0, 0.0);
 361
 362                                 // Layer 3: bug
 363                                 // moves up-down with elevator trim
 364   inst->addLayer(3, createTexture("Textures/Panel/bug.rgb"));
 365   inst->addTransformation(3, FGInstrumentLayer::ROTATION, 270.0);
 366   inst->addTransformation(3, FGInstrumentLayer::YSHIFT,
 367                           -SMALL_W * (3.0 / 8.0));
 368   inst->addTransformation(3, FGInstrumentLayer::XSHIFT, FGBFI::getElevatorTrim,
 369                           -1.0, 1.0, SMALL_W * .75 / 2.0, 0.0);
 370
 371                                 // Layer 4: bug
 372                                 // moves up-down with elevator
 373   inst->addLayer(4, createTexture("Textures/Panel/bug.rgb"));
 374   inst->addTransformation(4, FGInstrumentLayer::ROTATION, 90.0);
 375   inst->addTransformation(4, FGInstrumentLayer::YSHIFT,
 376                           -SMALL_W * (3.0 / 8.0));
 377   inst->addTransformation(4, FGInstrumentLayer::XSHIFT, FGBFI::getElevator,
 378                           -1.0, 1.0, -SMALL_W * .75 / 2.0, 0.0);
 379
 380   return inst;
 381 }
 382
 383
 384 /**
 385  * Construct a NAV1 gauge (dummy for now).
 386  */
 387 static FGPanelInstrument *
 388 createNAV1 (int x, int y)
 389 {
 390   FGLayeredInstrument * inst = new FGLayeredInstrument(x, y, SIX_W, SIX_W);
 391
 392                                 // Layer 0: background
 393   inst->addLayer(0, createTexture("Textures/Panel/gyro-bg.rgb"));
 394
 395   return inst;
 396 }
 397
 398
 399 /**
 400  * Construct a NAV2 gauge (dummy for now).
 401  */
 402 static FGPanelInstrument *
 403 createNAV2 (int x, int y)
 404 {
 405   FGLayeredInstrument * inst = new FGLayeredInstrument(x, y, SIX_W, SIX_W);
 406
 407                                 // Layer 0: background
 408   inst->addLayer(0, createTexture("Textures/Panel/gyro-bg.rgb"));
 409
 410   return inst;
 411 }
 412
 413
 414 /**
 415  * Construct an ADF gauge (dummy for now).
 416  */
 417 static FGPanelInstrument *
 418 createADF (int x, int y)
 419 {
 420   FGLayeredInstrument * inst = new FGLayeredInstrument(x, y, SIX_W, SIX_W);
 421
 422                                 // Layer 0: background
 423   inst->addLayer(0, createTexture("Textures/Panel/gyro-bg.rgb"));
 424
 425   return inst;
 426 }
 427
 428
 429 \f
 430 ////////////////////////////////////////////////////////////////////////
 431 // Implementation of FGPanel.
 432 ////////////////////////////////////////////////////////////////////////
 433
 434 FGPanel * FGPanel::OurPanel = 0;
 435
 436 FGPanel::FGPanel ()
 437 {
 438   if (OurPanel == 0) {
 439     OurPanel = this;
 440   } else {
 441     FG_LOG(FG_GENERAL, FG_ALERT, "Multiple panels");
 442     exit(-1);
 443   }
 444
 445   int x = SIX_X;
 446   int y = SIX_Y;
 447
 448   _bg = createTexture("Textures/Panel/panel-bg.rgb");
 449
 450                                 // Chronometer alone at side
 451   x = SIX_X - SIX_SPACING - 8;
 452   _instruments.push_back(createChronometer(x, y));
 453
 454                                 // Top row
 455   x = SIX_X;
 456   _instruments.push_back(createAirspeedIndicator(x, y));
 457   x += SIX_SPACING;
 458   _instruments.push_back(createHorizon(x, y));
 459   x += SIX_SPACING;
 460   _instruments.push_back(createAltimeter(x, y));
 461   x += SIX_SPACING + 20;
 462   _instruments.push_back(createNAV1(x, y));
 463
 464                                 // Middle row
 465   x = SIX_X;
 466   y -= SIX_SPACING;
 467   _instruments.push_back(createTurnCoordinator(x, y));
 468   x += SIX_SPACING;
 469   _instruments.push_back(createGyroCompass(x, y));
 470   x += SIX_SPACING;
 471   _instruments.push_back(createVerticalVelocity(x, y));
 472   x += SIX_SPACING + 20;
 473   _instruments.push_back(createNAV2(x, y));
 474
 475                                 // Bottom row
 476   x = SIX_X;
 477   y -= SIX_SPACING + 10;
 478   _instruments.push_back(createControls(x, y));
 479   x += SIX_SPACING;
 480   _instruments.push_back(createFlapIndicator(x, y));
 481   x += SIX_SPACING;
 482   _instruments.push_back(createRPMGauge(x, y));
 483   x += SIX_SPACING + 20;
 484   y += 10;
 485   _instruments.push_back(createADF(x, y));
 486 }
 487
 488 FGPanel::~FGPanel ()
 489 {
 490   OurPanel = 0;
 491
 492   instrument_list_type::iterator current = _instruments.begin();
 493   instrument_list_type::iterator last = _instruments.end();
 494
 495   for ( ; current != last; ++current) {
 496     delete *current;
 497     *current = 0;
 498   }
 499 }
 500
 501 float
 502 FGPanel::get_height () const
 503 {
 504   return _panel_h;
 505 }
 506
 507 void
 508 FGPanel::ReInit (int x, int y, int finx, int finy)
 509 {
 510   _x = x;
 511   _y = y;
 512   _w = finx - x;
 513   _h = finy - y;
 514   _panel_h = (int)((finy - y) * 0.5768 + 1);
 515 }
 516
 517 void
 518 FGPanel::Update () const
 519 {
 520   glMatrixMode(GL_PROJECTION);
 521   glPushMatrix();
 522   glLoadIdentity();
 523   gluOrtho2D(_x, _x + _w, _y, _y + _h);
 524
 525   glMatrixMode(GL_MODELVIEW);
 526   glPushMatrix();
 527   glLoadIdentity();
 528
 529                                 // Draw the background
 530   glEnable(GL_TEXTURE_2D);
 531   glDisable(GL_LIGHTING);
 532   glEnable(GL_BLEND);
 533   glEnable(GL_ALPHA_TEST);
 534   glEnable(GL_COLOR_MATERIAL);
 535   glColor4f(1.0, 1.0, 1.0, 1.0);
 536   glBindTexture(GL_TEXTURE_2D, _bg->getHandle());
 537   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
 538   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
 539   glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
 540   glBegin(GL_POLYGON);
 541   glTexCoord2f(0.0, 0.0); glVertex3f(_x, _y, 0);
 542   glTexCoord2f(10.0, 0.0); glVertex3f(_x + _w, _y, 0);
 543   glTexCoord2f(10.0, 5.0); glVertex3f(_x + _w, _y + _panel_h, 0);
 544   glTexCoord2f(0.0, 5.0); glVertex3f(_x, _y + _panel_h, 0);
 545   glEnd();
 546
 547                                 // Draw the instruments.
 548   instrument_list_type::const_iterator current = _instruments.begin();
 549   instrument_list_type::const_iterator end = _instruments.end();
 550
 551   for ( ; current != end; current++) {
 552     FGPanelInstrument * instr = *current;
 553     glLoadIdentity();
 554     glTranslated(instr->getXPos(), instr->getYPos(), 0);
 555     instr->draw();
 556   }
 557
 558   glMatrixMode(GL_PROJECTION);
 559   glPopMatrix();
 560   glMatrixMode(GL_MODELVIEW);
 561   glPopMatrix();
 562   ssgForceBasicState();
 563   glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
 564 }
 565
 566 ssgTexture *
 567 FGPanel::createTexture (const char * relativePath)
 568 {
 569   ssgTexture *texture;
 570
 571   texture = _textureMap[relativePath];
 572   if (texture == 0) {
 573     FGPath tpath(current_options.get_fg_root());
 574     tpath.append(relativePath);
 575     texture = new ssgTexture((char *)tpath.c_str(), false, false);
 576     _textureMap[relativePath] = texture;
 577     cerr << "Created texture " << relativePath
 578          << " handle=" << texture->getHandle() << endl;
 579   }
 580
 581   return texture;
 582 }
 583
 584
 585 \f
 586 ////////////////////////////////////////////////////////////////////////
 587 // Implementation of FGPanelInstrument.
 588 ////////////////////////////////////////////////////////////////////////
 589
 590
 591 FGPanelInstrument::FGPanelInstrument ()
 592 {
 593   setPosition(0, 0);
 594   setSize(0, 0);
 595 }
 596
 597 FGPanelInstrument::FGPanelInstrument (int x, int y, int w, int h)
 598 {
 599   setPosition(x, y);
 600   setSize(w, h);
 601 }
 602
 603 FGPanelInstrument::~FGPanelInstrument ()
 604 {
 605 }
 606
 607 void
 608 FGPanelInstrument::setPosition (int x, int y)
 609 {
 610   _x = x;
 611   _y = y;
 612 }
 613
 614 void
 615 FGPanelInstrument::setSize (int w, int h)
 616 {
 617   _w = w;
 618   _h = h;
 619 }
 620
 621 int
 622 FGPanelInstrument::getXPos () const
 623 {
 624   return _x;
 625 }
 626
 627 int
 628 FGPanelInstrument::getYPos () const
 629 {
 630   return _y;
 631 }
 632
 633
 634 \f
 635 ////////////////////////////////////////////////////////////////////////
 636 // Implementation of FGLayeredInstrument.
 637 ////////////////////////////////////////////////////////////////////////
 638
 639 FGLayeredInstrument::FGLayeredInstrument (int x, int y, int w, int h)
 640   : FGPanelInstrument(x, y, w, h)
 641 {
 642 }
 643
 644 FGLayeredInstrument::~FGLayeredInstrument ()
 645 {
 646   // FIXME: free layers
 647 }
 648
 649 void
 650 FGLayeredInstrument::draw () const
 651 {
 652   layer_list::const_iterator it = _layers.begin();
 653   layer_list::const_iterator last = _layers.end();
 654   while (it != last) {
 655     (*it)->draw();
 656     it++;
 657   }
 658 }
 659
 660 void
 661 FGLayeredInstrument::addLayer (FGInstrumentLayer *layer)
 662 {
 663   _layers.push_back(layer);
 664 }
 665
 666 void
 667 FGLayeredInstrument::addLayer (int layer, ssgTexture * texture)
 668 {
 669   addLayer(new FGTexturedInstrumentLayer(texture, _w, _h, layer));
 670 }
 671
 672 void
 673 FGLayeredInstrument::addTransformation (int layer,
 674                                         FGInstrumentLayer::transform_type type,
 675                                         FGInstrumentLayer::transform_func func,
 676                                         double min, double max,
 677                                         double factor, double offset)
 678 {
 679   _layers[layer]->addTransformation(type, func, min, max, factor, offset);
 680 }
 681
 682
 683 \f
 684 ////////////////////////////////////////////////////////////////////////
 685 // Implementation of FGInstrumentLayer.
 686 ////////////////////////////////////////////////////////////////////////
 687
 688 FGInstrumentLayer::FGInstrumentLayer (int w, int h, int z)
 689   : _w(w),
 690     _h(h),
 691     _z(z)
 692 {
 693 }
 694
 695 FGInstrumentLayer::~FGInstrumentLayer ()
 696 {
 697   transformation_list::iterator it = _transformations.begin();
 698   transformation_list::iterator end = _transformations.end();
 699   while (it != end) {
 700     delete *it;
 701     it++;
 702   }
 703 }
 704
 705 void
 706 FGInstrumentLayer::transform () const
 707 {
 708   glTranslatef(0.0, 0.0, (_z / 100.0) + 0.1);
 709
 710   transformation_list::const_iterator it = _transformations.begin();
 711   transformation_list::const_iterator last = _transformations.end();
 712   while (it != last) {
 713     transformation *t = *it;
 714     double value = (t->func == 0 ? 0.0 : (*(t->func))());
 715     if (value < t->min) {
 716       value = t->min;
 717     } else if (value > t->max) {
 718       value = t->max;
 719     }
 720     value = value * t->factor + t->offset;
 721
 722     switch (t->type) {
 723     case XSHIFT:
 724       glTranslatef(value, 0.0, 0.0);
 725       break;
 726     case YSHIFT:
 727       glTranslatef(0.0, value, 0.0);
 728       break;
 729     case ROTATION:
 730       glRotatef(-value, 0.0, 0.0, 1.0);
 731       break;
 732     }
 733     it++;
 734   }
 735 }
 736
 737 void
 738 FGInstrumentLayer::addTransformation (transform_type type,
 739                                       transform_func func,
 740                                       double min, double max,
 741                                       double factor, double offset)
 742 {
 743   transformation *t = new transformation;
 744   t->type = type;
 745   t->func = func;
 746   t->min = min;
 747   t->max = max;
 748   t->factor = factor;
 749   t->offset = offset;
 750   _transformations.push_back(t);
 751 }
 752
 753
 754 \f
 755 ////////////////////////////////////////////////////////////////////////
 756 // Implementation of FGTexturedInstrumentLayer.
 757 ////////////////////////////////////////////////////////////////////////
 758
 759 // FGTexturedInstrumentLayer::FGTexturedInstrumentLayer (const char *tname,
 760 //                                                    int w, int h, int z)
 761 //   : FGInstrumentLayer(w, h, z)
 762 // {
 763 //   setTexture(tname);
 764 // }
 765
 766 FGTexturedInstrumentLayer::FGTexturedInstrumentLayer (ssgTexture * texture,
 767                                                       int w, int h, int z)
 768   : FGInstrumentLayer(w, h, z)
 769 {
 770   setTexture(texture);
 771 }
 772
 773 FGTexturedInstrumentLayer::~FGTexturedInstrumentLayer ()
 774 {
 775 }
 776
 777 void
 778 FGTexturedInstrumentLayer::draw () const
 779 {
 780   int w2 = _w / 2;
 781   int h2 = _h / 2;
 782
 783   glPushMatrix();
 784   transform();
 785   glBindTexture(GL_TEXTURE_2D, _texture->getHandle());
 786   glBegin(GL_POLYGON);
 787                                 // FIXME: is this really correct
 788                                 // for layering?
 789   glTexCoord2f(0.0, 0.0); glVertex2f(-w2, -h2);
 790   glTexCoord2f(1.0, 0.0); glVertex2f(w2, -h2);
 791   glTexCoord2f(1.0, 1.0); glVertex2f(w2, h2);
 792   glTexCoord2f(0.0, 1.0); glVertex2f(-w2, h2);
 793   glEnd();
 794   glPopMatrix();
 795 }
 796
 797 // void
 798 // FGTexturedInstrumentLayer::setTexture (const char *textureName)
 799 // {
 800 //   FGPath tpath(current_options.get_fg_root());
 801 //   tpath.append(textureName);
 802 //   ssgTexture * texture = new ssgTexture((char *)tpath.c_str(), false, false);
 803 //   setTexture(texture);
 804 // }
 805
 806
 807 \f
 808 ////////////////////////////////////////////////////////////////////////
 809 // Implementation of FGCharInstrumentLayer.
 810 ////////////////////////////////////////////////////////////////////////
 811
 812 FGCharInstrumentLayer::FGCharInstrumentLayer (text_func func,
 813                                               int w, int h, int z)
 814   : FGInstrumentLayer(w, h, z),
 815     _func(func)
 816 {
 817   _renderer.setFont(guiFntHandle);
 818   _renderer.setPointSize(14);
 819   _color[0] = _color[1] = _color[2] = 0.0;
 820   _color[3] = 1.0;
 821 }
 822
 823 FGCharInstrumentLayer::~FGCharInstrumentLayer ()
 824 {
 825 }
 826
 827 void
 828 FGCharInstrumentLayer::draw () const
 829 {
 830   glPushMatrix();
 831   glColor4fv(_color);
 832   transform();
 833   _renderer.begin();
 834   _renderer.start3f(0, 0, 0);
 835   _renderer.puts((*_func)(_buf));
 836   _renderer.end();
 837   glColor4f(1.0, 1.0, 1.0, 1.0);        // FIXME
 838   glPopMatrix();
 839 }
 840
 841 void
 842 FGCharInstrumentLayer::setColor (float r, float g, float b)
 843 {
 844   _color[0] = r;
 845   _color[1] = g;
 846   _color[2] = b;
 847   _color[3] = 1.0;
 848 }
 849
 850 void
 851 FGCharInstrumentLayer::setPointSize (const float size)
 852 {
 853   _renderer.setPointSize(size);
 854 }
 855
 856 void
 857 FGCharInstrumentLayer::setFont(fntFont * font)
 858 {
 859   _renderer.setFont(font);
 860 }
 861
 862
 863 \f
 864 // end of panel.cxx