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_rad,
 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 (hardwired).
 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   inst->addTransformation(0, FGInstrumentLayer::ROTATION,
 395                           FGSteam::get_HackOBS1_deg,
 396                           -360.0, 360.0, -1.0, 0.0);
 397                                 // Layer 1: long needle
 398   inst->addLayer(1, createTexture("Textures/Panel/nav-needle.rgb"));
 399   inst->addTransformation(1, FGInstrumentLayer::XSHIFT,
 400                           FGSteam::get_HackVOR1_deg,
 401                           -10.0, 10.0, SIX_W / 40.0, 0.0);
 402   inst->addLayer(2, createTexture("Textures/Panel/nav-needle.rgb"));
 403   inst->addTransformation(2, FGInstrumentLayer::YSHIFT,
 404                           FGSteam::get_HackGS_deg,
 405                           -1.0, 1.0, SIX_W / 5.0, 0.0);
 406   inst->addTransformation(2, FGInstrumentLayer::ROTATION,
 407                           90 );
 408   inst->addLayer(3, createTexture("Textures/Panel/nav-face.rgb"));
 409
 410   return inst;
 411 }
 412
 413
 414 /**
 415  * Construct a NAV2 gauge (hardwired).
 416  */
 417 static FGPanelInstrument *
 418 createNAV2 (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   inst->addTransformation(0, FGInstrumentLayer::ROTATION,
 425                           FGSteam::get_HackOBS2_deg,
 426                           -360.0, 360.0, -1.0, 0.0);
 427   inst->addLayer(1, createTexture("Textures/Panel/nav-needle.rgb"));
 428   inst->addTransformation(1, FGInstrumentLayer::XSHIFT,
 429                           FGSteam::get_HackVOR2_deg,
 430                           -10.0, 10.0, SIX_W / 40.0, 0.0);
 431 //   inst->addTransformation(1, FGInstrumentLayer::YSHIFT,
 432 //                        -SIX_W / 4.4 );
 433   inst->addLayer(2, createTexture("Textures/Panel/nav-face.rgb"));
 434
 435   return inst;
 436 }
 437
 438
 439 /**
 440  * Construct an ADF gauge (hardwired).
 441  */
 442 static FGPanelInstrument *
 443 createADF (int x, int y)
 444 {
 445   FGLayeredInstrument * inst = new FGLayeredInstrument(x, y, SIX_W, SIX_W);
 446
 447                                 // Layer 0: background
 448   inst->addLayer(0, createTexture("Textures/Panel/gyro-bg.rgb"));
 449   inst->addLayer(1, createTexture("Textures/Panel/long-needle.rgb"));
 450   inst->addTransformation(1, FGInstrumentLayer::ROTATION,
 451                           FGSteam::get_HackADF_deg,
 452                           -720.0, 720.0, 1.0, 0.0);
 453
 454   return inst;
 455 }
 456
 457
 458 \f
 459 ////////////////////////////////////////////////////////////////////////
 460 // Implementation of FGPanel.
 461 ////////////////////////////////////////////////////////////////////////
 462
 463 FGPanel * FGPanel::OurPanel = 0;
 464
 465 FGPanel::FGPanel ()
 466 {
 467   if (OurPanel == 0) {
 468     OurPanel = this;
 469   } else {
 470     FG_LOG(FG_GENERAL, FG_ALERT, "Multiple panels");
 471     exit(-1);
 472   }
 473
 474   int x = SIX_X;
 475   int y = SIX_Y;
 476
 477   _bg = createTexture("Textures/Panel/panel-bg.rgb");
 478
 479                                 // Chronometer alone at side
 480   x = SIX_X - SIX_SPACING - 8;
 481   _instruments.push_back(createChronometer(x, y));
 482
 483                                 // Top row
 484   x = SIX_X;
 485   _instruments.push_back(createAirspeedIndicator(x, y));
 486   x += SIX_SPACING;
 487   _instruments.push_back(createHorizon(x, y));
 488   x += SIX_SPACING;
 489   _instruments.push_back(createAltimeter(x, y));
 490   x += SIX_SPACING + 20;
 491   _instruments.push_back(createNAV1(x, y));
 492
 493                                 // Middle row
 494   x = SIX_X;
 495   y -= SIX_SPACING;
 496   _instruments.push_back(createTurnCoordinator(x, y));
 497   x += SIX_SPACING;
 498   _instruments.push_back(createGyroCompass(x, y));
 499   x += SIX_SPACING;
 500   _instruments.push_back(createVerticalVelocity(x, y));
 501   x += SIX_SPACING + 20;
 502   _instruments.push_back(createNAV2(x, y));
 503
 504                                 // Bottom row
 505   x = SIX_X;
 506   y -= SIX_SPACING + 10;
 507   _instruments.push_back(createControls(x, y));
 508   x += SIX_SPACING;
 509   _instruments.push_back(createFlapIndicator(x, y));
 510   x += SIX_SPACING;
 511   _instruments.push_back(createRPMGauge(x, y));
 512   x += SIX_SPACING + 20;
 513   y += 10;
 514   _instruments.push_back(createADF(x, y));
 515 }
 516
 517 FGPanel::~FGPanel ()
 518 {
 519   OurPanel = 0;
 520
 521   instrument_list_type::iterator current = _instruments.begin();
 522   instrument_list_type::iterator last = _instruments.end();
 523
 524   for ( ; current != last; ++current) {
 525     delete *current;
 526     *current = 0;
 527   }
 528 }
 529
 530 float
 531 FGPanel::get_height () const
 532 {
 533   return _panel_h;
 534 }
 535
 536 void
 537 FGPanel::ReInit (int x, int y, int finx, int finy)
 538 {
 539   _x = x;
 540   _y = y;
 541   _w = finx - x;
 542   _h = finy - y;
 543   _panel_h = (int)((finy - y) * 0.5768 + 1);
 544 }
 545
 546 void
 547 FGPanel::Update () const
 548 {
 549   glMatrixMode(GL_PROJECTION);
 550   glPushMatrix();
 551   glLoadIdentity();
 552   gluOrtho2D(_x, _x + _w, _y, _y + _h);
 553
 554   glMatrixMode(GL_MODELVIEW);
 555   glPushMatrix();
 556   glLoadIdentity();
 557
 558                                 // Draw the background
 559   glEnable(GL_TEXTURE_2D);
 560   glDisable(GL_LIGHTING);
 561   glEnable(GL_BLEND);
 562   glEnable(GL_ALPHA_TEST);
 563   glEnable(GL_COLOR_MATERIAL);
 564   glColor4f(1.0, 1.0, 1.0, 1.0);
 565   glBindTexture(GL_TEXTURE_2D, _bg->getHandle());
 566   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
 567   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
 568   glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
 569   glBegin(GL_POLYGON);
 570   glTexCoord2f(0.0, 0.0); glVertex3f(_x, _y, 0);
 571   glTexCoord2f(10.0, 0.0); glVertex3f(_x + _w, _y, 0);
 572   glTexCoord2f(10.0, 5.0); glVertex3f(_x + _w, _y + _panel_h, 0);
 573   glTexCoord2f(0.0, 5.0); glVertex3f(_x, _y + _panel_h, 0);
 574   glEnd();
 575
 576                                 // Draw the instruments.
 577   instrument_list_type::const_iterator current = _instruments.begin();
 578   instrument_list_type::const_iterator end = _instruments.end();
 579
 580   for ( ; current != end; current++) {
 581     FGPanelInstrument * instr = *current;
 582     glLoadIdentity();
 583     glTranslated(instr->getXPos(), instr->getYPos(), 0);
 584     instr->draw();
 585   }
 586
 587   glMatrixMode(GL_PROJECTION);
 588   glPopMatrix();
 589   glMatrixMode(GL_MODELVIEW);
 590   glPopMatrix();
 591   ssgForceBasicState();
 592   glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
 593 }
 594
 595 ssgTexture *
 596 FGPanel::createTexture (const char * relativePath)
 597 {
 598   ssgTexture *texture;
 599
 600   texture = _textureMap[relativePath];
 601   if (texture == 0) {
 602     FGPath tpath(current_options.get_fg_root());
 603     tpath.append(relativePath);
 604     texture = new ssgTexture((char *)tpath.c_str(), false, false);
 605     _textureMap[relativePath] = texture;
 606     cerr << "Created texture " << relativePath
 607          << " handle=" << texture->getHandle() << endl;
 608   }
 609
 610   return texture;
 611 }
 612
 613
 614 \f
 615 ////////////////////////////////////////////////////////////////////////
 616 // Implementation of FGPanelInstrument.
 617 ////////////////////////////////////////////////////////////////////////
 618
 619
 620 FGPanelInstrument::FGPanelInstrument ()
 621 {
 622   setPosition(0, 0);
 623   setSize(0, 0);
 624 }
 625
 626 FGPanelInstrument::FGPanelInstrument (int x, int y, int w, int h)
 627 {
 628   setPosition(x, y);
 629   setSize(w, h);
 630 }
 631
 632 FGPanelInstrument::~FGPanelInstrument ()
 633 {
 634 }
 635
 636 void
 637 FGPanelInstrument::setPosition (int x, int y)
 638 {
 639   _x = x;
 640   _y = y;
 641 }
 642
 643 void
 644 FGPanelInstrument::setSize (int w, int h)
 645 {
 646   _w = w;
 647   _h = h;
 648 }
 649
 650 int
 651 FGPanelInstrument::getXPos () const
 652 {
 653   return _x;
 654 }
 655
 656 int
 657 FGPanelInstrument::getYPos () const
 658 {
 659   return _y;
 660 }
 661
 662
 663 \f
 664 ////////////////////////////////////////////////////////////////////////
 665 // Implementation of FGLayeredInstrument.
 666 ////////////////////////////////////////////////////////////////////////
 667
 668 FGLayeredInstrument::FGLayeredInstrument (int x, int y, int w, int h)
 669   : FGPanelInstrument(x, y, w, h)
 670 {
 671 }
 672
 673 FGLayeredInstrument::~FGLayeredInstrument ()
 674 {
 675   // FIXME: free layers
 676 }
 677
 678 void
 679 FGLayeredInstrument::draw () const
 680 {
 681   layer_list::const_iterator it = _layers.begin();
 682   layer_list::const_iterator last = _layers.end();
 683   while (it != last) {
 684     (*it)->draw();
 685     it++;
 686   }
 687 }
 688
 689 void
 690 FGLayeredInstrument::addLayer (FGInstrumentLayer *layer)
 691 {
 692   _layers.push_back(layer);
 693 }
 694
 695 void
 696 FGLayeredInstrument::addLayer (int layer, ssgTexture * texture)
 697 {
 698   addLayer(new FGTexturedInstrumentLayer(texture, _w, _h, layer));
 699 }
 700
 701 void
 702 FGLayeredInstrument::addTransformation (int layer,
 703                                         FGInstrumentLayer::transform_type type,
 704                                         FGInstrumentLayer::transform_func func,
 705                                         double min, double max,
 706                                         double factor, double offset)
 707 {
 708   _layers[layer]->addTransformation(type, func, min, max, factor, offset);
 709 }
 710
 711
 712 \f
 713 ////////////////////////////////////////////////////////////////////////
 714 // Implementation of FGInstrumentLayer.
 715 ////////////////////////////////////////////////////////////////////////
 716
 717 FGInstrumentLayer::FGInstrumentLayer (int w, int h, int z)
 718   : _w(w),
 719     _h(h),
 720     _z(z)
 721 {
 722 }
 723
 724 FGInstrumentLayer::~FGInstrumentLayer ()
 725 {
 726   transformation_list::iterator it = _transformations.begin();
 727   transformation_list::iterator end = _transformations.end();
 728   while (it != end) {
 729     delete *it;
 730     it++;
 731   }
 732 }
 733
 734 void
 735 FGInstrumentLayer::transform () const
 736 {
 737   glTranslatef(0.0, 0.0, (_z / 100.0) + 0.1);
 738
 739   transformation_list::const_iterator it = _transformations.begin();
 740   transformation_list::const_iterator last = _transformations.end();
 741   while (it != last) {
 742     transformation *t = *it;
 743     double value = (t->func == 0 ? 0.0 : (*(t->func))());
 744     if (value < t->min) {
 745       value = t->min;
 746     } else if (value > t->max) {
 747       value = t->max;
 748     }
 749     value = value * t->factor + t->offset;
 750
 751     switch (t->type) {
 752     case XSHIFT:
 753       glTranslatef(value, 0.0, 0.0);
 754       break;
 755     case YSHIFT:
 756       glTranslatef(0.0, value, 0.0);
 757       break;
 758     case ROTATION:
 759       glRotatef(-value, 0.0, 0.0, 1.0);
 760       break;
 761     }
 762     it++;
 763   }
 764 }
 765
 766 void
 767 FGInstrumentLayer::addTransformation (transform_type type,
 768                                       transform_func func,
 769                                       double min, double max,
 770                                       double factor, double offset)
 771 {
 772   transformation *t = new transformation;
 773   t->type = type;
 774   t->func = func;
 775   t->min = min;
 776   t->max = max;
 777   t->factor = factor;
 778   t->offset = offset;
 779   _transformations.push_back(t);
 780 }
 781
 782
 783 \f
 784 ////////////////////////////////////////////////////////////////////////
 785 // Implementation of FGTexturedInstrumentLayer.
 786 ////////////////////////////////////////////////////////////////////////
 787
 788 // FGTexturedInstrumentLayer::FGTexturedInstrumentLayer (const char *tname,
 789 //                                                    int w, int h, int z)
 790 //   : FGInstrumentLayer(w, h, z)
 791 // {
 792 //   setTexture(tname);
 793 // }
 794
 795 FGTexturedInstrumentLayer::FGTexturedInstrumentLayer (ssgTexture * texture,
 796                                                       int w, int h, int z)
 797   : FGInstrumentLayer(w, h, z)
 798 {
 799   setTexture(texture);
 800 }
 801
 802 FGTexturedInstrumentLayer::~FGTexturedInstrumentLayer ()
 803 {
 804 }
 805
 806 void
 807 FGTexturedInstrumentLayer::draw () const
 808 {
 809   int w2 = _w / 2;
 810   int h2 = _h / 2;
 811
 812   glPushMatrix();
 813   transform();
 814   glBindTexture(GL_TEXTURE_2D, _texture->getHandle());
 815   glBegin(GL_POLYGON);
 816                                 // FIXME: is this really correct
 817                                 // for layering?
 818   glTexCoord2f(0.0, 0.0); glVertex2f(-w2, -h2);
 819   glTexCoord2f(1.0, 0.0); glVertex2f(w2, -h2);
 820   glTexCoord2f(1.0, 1.0); glVertex2f(w2, h2);
 821   glTexCoord2f(0.0, 1.0); glVertex2f(-w2, h2);
 822   glEnd();
 823   glPopMatrix();
 824 }
 825
 826 // void
 827 // FGTexturedInstrumentLayer::setTexture (const char *textureName)
 828 // {
 829 //   FGPath tpath(current_options.get_fg_root());
 830 //   tpath.append(textureName);
 831 //   ssgTexture * texture = new ssgTexture((char *)tpath.c_str(), false, false);
 832 //   setTexture(texture);
 833 // }
 834
 835
 836 \f
 837 ////////////////////////////////////////////////////////////////////////
 838 // Implementation of FGCharInstrumentLayer.
 839 ////////////////////////////////////////////////////////////////////////
 840
 841 FGCharInstrumentLayer::FGCharInstrumentLayer (text_func func,
 842                                               int w, int h, int z)
 843   : FGInstrumentLayer(w, h, z),
 844     _func(func)
 845 {
 846   _renderer.setFont(guiFntHandle);
 847   _renderer.setPointSize(14);
 848   _color[0] = _color[1] = _color[2] = 0.0;
 849   _color[3] = 1.0;
 850 }
 851
 852 FGCharInstrumentLayer::~FGCharInstrumentLayer ()
 853 {
 854 }
 855
 856 void
 857 FGCharInstrumentLayer::draw () const
 858 {
 859   glPushMatrix();
 860   glColor4fv(_color);
 861   transform();
 862   _renderer.begin();
 863   _renderer.start3f(0, 0, 0);
 864   _renderer.puts((*_func)(_buf));
 865   _renderer.end();
 866   glColor4f(1.0, 1.0, 1.0, 1.0);        // FIXME
 867   glPopMatrix();
 868 }
 869
 870 void
 871 FGCharInstrumentLayer::setColor (float r, float g, float b)
 872 {
 873   _color[0] = r;
 874   _color[1] = g;
 875   _color[2] = b;
 876   _color[3] = 1.0;
 877 }
 878
 879 void
 880 FGCharInstrumentLayer::setPointSize (const float size)
 881 {
 882   _renderer.setPointSize(size);
 883 }
 884
 885 void
 886 FGCharInstrumentLayer::setFont(fntFont * font)
 887 {
 888   _renderer.setFont(font);
 889 }
 890
 891
 892 \f
 893 // end of panel.cxx