src/Instrumentation/HUD/HUD.cxx

   1 // HUD.cxx -- Head Up Display
   2 //
   3 // Written by Michele America, started September 1997.
   4 //
   5 // Copyright (C) 1997  Michele F. America  [micheleamerica#geocities:com]
   6 // Copyright (C) 2006  Melchior FRANZ  [mfranz#aon:at]
   7 //
   8 // This program is free software; you can redistribute it and/or
   9 // modify it under the terms of the GNU General Public License as
  10 // published by the Free Software Foundation; either version 2 of the
  11 // License, or (at your option) any later version.
  12 //
  13 // This program is distributed in the hope that it will be useful, but
  14 // WITHOUT ANY WARRANTY; without even the implied warranty of
  15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16 // General Public License for more details.
  17 //
  18 // You should have received a copy of the GNU General Public License
  19 // along with this program; if not, write to the Free Software
  20 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  21
  22 #include <simgear/compiler.h>
  23 #include <simgear/structure/exception.hxx>
  24
  25 #include STL_STRING
  26 #include STL_FSTREAM
  27
  28 #ifdef HAVE_CONFIG_H
  29 #  include <config.h>
  30 #endif
  31
  32 #ifdef HAVE_WINDOWS_H
  33 #   include <windows.h>
  34 #endif
  35
  36 #include SG_GLU_H
  37
  38 #include <simgear/constants.h>
  39 #include <simgear/misc/sg_path.hxx>
  40
  41 #include <Main/globals.hxx>
  42 #include <Main/viewmgr.hxx>
  43
  44 #include "HUD.hxx"
  45
  46
  47 static float clamp(float f)
  48 {
  49     return f < 0.0f ? 0.0f : f > 1.0f ? 1.0f : f;
  50 }
  51
  52
  53 HUD::HUD() :
  54     _current(fgGetNode("/sim/hud/current-color", true)),
  55     _visibility(fgGetNode("/sim/hud/visibility[1]", true)),
  56     _3DenabledN(fgGetNode("/sim/hud/enable3d", true)),
  57     _antialiasing(fgGetNode("/sim/hud/color/antialiased", true)),
  58     _transparency(fgGetNode("/sim/hud/color/transparent", true)),
  59     _red(fgGetNode("/sim/hud/color/red", true)),
  60     _green(fgGetNode("/sim/hud/color/green", true)),
  61     _blue(fgGetNode("/sim/hud/color/blue", true)),
  62     _alpha(fgGetNode("/sim/hud/color/alpha", true)),
  63     _alpha_clamp(fgGetNode("/sim/hud/color/alpha-clamp", true)),
  64     _brightness(fgGetNode("/sim/hud/color/brightness", true)),
  65     _visible(false),
  66     _antialiased(false),
  67     _transparent(false),
  68     _a(0.67),                                                                   // FIXME better names
  69     _cl(0.01),
  70     //
  71     _scr_widthN(fgGetNode("/sim/startup/xsize", true)),
  72     _scr_heightN(fgGetNode("/sim/startup/ysize", true)),
  73     _unitsN(fgGetNode("/sim/startup/units", true)),
  74     _timer(0.0),
  75     //
  76     _font_renderer(new fntRenderer()),
  77     _font(0),
  78     _font_size(0.0),
  79     _style(0)
  80 {
  81     SG_LOG(SG_COCKPIT, SG_INFO, "Initializing HUD Instrument");
  82
  83     _visibility->addChangeListener(this);
  84     _3DenabledN->addChangeListener(this);
  85     _antialiasing->addChangeListener(this);
  86     _transparency->addChangeListener(this);
  87     _red->addChangeListener(this);
  88     _green->addChangeListener(this);
  89     _blue->addChangeListener(this);
  90     _alpha->addChangeListener(this);
  91     _alpha_clamp->addChangeListener(this);
  92     _brightness->addChangeListener(this);
  93     _current->addChangeListener(this);
  94     _scr_widthN->addChangeListener(this);
  95     _scr_heightN->addChangeListener(this);
  96     _unitsN->addChangeListener(this, true);
  97 }
  98
  99
 100 HUD::~HUD()
 101 {
 102     _visibility->removeChangeListener(this);
 103     _3DenabledN->removeChangeListener(this);
 104     _antialiasing->removeChangeListener(this);
 105     _transparency->removeChangeListener(this);
 106     _red->removeChangeListener(this);
 107     _green->removeChangeListener(this);
 108     _blue->removeChangeListener(this);
 109     _alpha->removeChangeListener(this);
 110     _alpha_clamp->removeChangeListener(this);
 111     _brightness->removeChangeListener(this);
 112     _current->removeChangeListener(this);
 113     _scr_widthN->removeChangeListener(this);
 114     _scr_heightN->removeChangeListener(this);
 115     _unitsN->removeChangeListener(this);
 116     delete _font_renderer;
 117
 118     deque<Item *>::const_iterator it, end = _items.end();
 119     for (it = _items.begin(); it != end; ++it)
 120         delete *it;
 121 }
 122
 123
 124 void HUD::init()
 125 {
 126     _font_cache = globals->get_fontcache();
 127     if (!_font)
 128         _font = _font_cache->getTexFont(fgGetString("/sim/hud/font/name", "Helvetica.txf"));
 129     if (!_font)
 130         throw sg_throwable(string("/sim/hud/font/name is not a texture font"));
 131
 132     _font_size = fgGetFloat("/sim/hud/font/size", 10);
 133     _font_renderer->setFont(_font);
 134     _font_renderer->setPointSize(_font_size);
 135     _text_list.setFont(_font_renderer);
 136
 137     load(fgGetString("/hud", "Huds/default.xml"));
 138 }
 139
 140
 141 void HUD::update(double dt)
 142 {
 143     _timer += dt;
 144 }
 145
 146
 147 void HUD::draw()
 148 {
 149     if (!isVisible())
 150         return;
 151
 152     if (!_items.size())
 153         return;
 154
 155     if (is3D()) {
 156         draw3D();
 157         return;
 158     }
 159
 160     const float normal_aspect = 640.0f / 480.0f;
 161     // note: aspect_ratio is Y/X
 162     float current_aspect = 1.0f / globals->get_current_view()->get_aspect_ratio();
 163     if (current_aspect > normal_aspect) {
 164         float aspect_adjust = current_aspect / normal_aspect;
 165         float adjust = 320.0f * aspect_adjust - 320.0f;
 166         draw2D(-adjust, 0.0f, 640.0f + adjust, 480.0f);
 167
 168     } else {
 169         float aspect_adjust = normal_aspect / current_aspect;
 170         float adjust = 240.0f * aspect_adjust - 240.0f;
 171         draw2D(0.0f, -adjust, 640.0f, 480.0f + adjust);
 172     }
 173
 174     glViewport(0, 0, _scr_width, _scr_height);
 175 }
 176
 177
 178 void HUD::draw3D()
 179 {
 180     FGViewer* view = globals->get_current_view();
 181
 182     // Standard fgfs projection, with essentially meaningless clip
 183     // planes (we'll map the whole HUD plane to z=-1)
 184     glMatrixMode(GL_PROJECTION);
 185     glPushMatrix();
 186     glLoadIdentity();
 187     gluPerspective(view->get_v_fov(), 1.0 / view->get_aspect_ratio(), 0.1, 10);
 188
 189     glMatrixMode(GL_MODELVIEW);
 190     glPushMatrix();
 191     glLoadIdentity();
 192
 193     // Standard fgfs view direction computation
 194     float lookat[3];
 195     lookat[0] = -sin(SG_DEGREES_TO_RADIANS * view->getHeadingOffset_deg());
 196     lookat[1] = tan(SG_DEGREES_TO_RADIANS * view->getPitchOffset_deg());
 197     lookat[2] = -cos(SG_DEGREES_TO_RADIANS * view->getHeadingOffset_deg());
 198     if (fabs(lookat[1]) > 9999)
 199         lookat[1] = 9999; // FPU sanity
 200     gluLookAt(0, 0, 0, lookat[0], lookat[1], lookat[2], 0, 1, 0);
 201
 202     // Map the -1:1 square to a 55.0x41.25 degree wide patch at z=1.
 203     // This is the default fgfs field of view, which the HUD files are
 204     // written to assume.
 205     float dx = 0.52056705; // tan(55/2)
 206     float dy = dx * 0.75;  // assumes 4:3 aspect ratio
 207     float m[16];
 208     m[0] = dx; m[4] =  0; m[ 8] = 0; m[12] = 0;
 209     m[1] =  0; m[5] = dy; m[ 9] = 0; m[13] = 0;
 210     m[2] =  0; m[6] =  0; m[10] = 1; m[14] = 0;
 211     m[3] =  0; m[7] =  0; m[11] = 0; m[15] = 1;
 212     glMultMatrixf(m);
 213
 214     // Convert the 640x480 "HUD standard" coordinate space to a square
 215     // about the origin in the range [-1:1] at depth of -1
 216     glScalef(1.0 / 320, 1.0 / 240, 1);
 217     glTranslatef(-320, -240, -1);
 218
 219     common_draw();
 220
 221     glMatrixMode(GL_PROJECTION);
 222     glPopMatrix();
 223     glMatrixMode(GL_MODELVIEW);
 224     glPopMatrix();
 225 }
 226
 227
 228 void HUD::draw2D( GLfloat x_start, GLfloat y_start,
 229                   GLfloat x_end, GLfloat y_end )
 230 {
 231     glMatrixMode(GL_PROJECTION);
 232     glPushMatrix();
 233     glLoadIdentity();
 234     gluOrtho2D(x_start, x_end, y_start, y_end);
 235
 236     glMatrixMode(GL_MODELVIEW);
 237     glPushMatrix();
 238     glLoadIdentity();
 239
 240     common_draw();
 241
 242     glMatrixMode(GL_PROJECTION);
 243     glPopMatrix();
 244     glMatrixMode(GL_MODELVIEW);
 245     glPopMatrix();
 246 }
 247
 248
 249 void HUD::common_draw()
 250 {
 251     _text_list.erase();
 252     _line_list.erase();
 253     _stipple_line_list.erase();
 254
 255     glDisable(GL_DEPTH_TEST);
 256     glDisable(GL_LIGHTING);
 257
 258     glEnable(GL_BLEND);
 259     if (isTransparent())
 260         glBlendFunc(GL_SRC_ALPHA, GL_ONE);
 261     else
 262         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 263
 264     if (isAntialiased()) {
 265         glEnable(GL_LINE_SMOOTH);
 266         glAlphaFunc(GL_GREATER, alphaClamp());
 267         glHint(GL_LINE_SMOOTH_HINT, GL_DONT_CARE);
 268         //glLineWidth(1.5);
 269     } else {
 270         //glLineWidth(1.0);
 271     }
 272
 273     setColor();
 274     deque<Item *>::const_iterator it, end = _items.end();
 275     for (it = _items.begin(); it != end; ++it)
 276         if ((*it)->isEnabled())
 277             (*it)->draw();
 278
 279     _text_list.draw();
 280     _line_list.draw();
 281
 282     if (_stipple_line_list.size()) {
 283         glEnable(GL_LINE_STIPPLE);
 284         glLineStipple(1, 0x00FF);
 285         _stipple_line_list.draw();
 286         glDisable(GL_LINE_STIPPLE);
 287     }
 288
 289     if (isAntialiased()) {
 290         glDisable(GL_ALPHA_TEST);
 291         glDisable(GL_LINE_SMOOTH);
 292         //glLineWidth(1.0);
 293     }
 294
 295     if (isTransparent())
 296         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 297
 298     glEnable(GL_DEPTH_TEST);
 299     glEnable(GL_LIGHTING);
 300 }
 301
 302
 303 int HUD::load(const char *file, float x, float y, int level, const string& indent)
 304 {
 305     const sgDebugPriority TREE = SG_INFO;
 306     const int MAXNEST = 10;
 307
 308     SGPath path(globals->get_fg_root());
 309     path.append(file);
 310
 311     if (!level) {
 312         SG_LOG(SG_INPUT, TREE, endl << "load " << file);
 313         _items.erase(_items.begin(), _items.end());
 314     } else if (level > MAXNEST) {
 315         SG_LOG(SG_INPUT, SG_ALERT, "HUD: files nested more than " << MAXNEST << " levels");
 316         return 0x1;
 317     } else if (!file || !file[0]) {
 318         SG_LOG(SG_INPUT, SG_ALERT, "HUD: invalid filename ");
 319         return 0x2;
 320     }
 321
 322     int ret = 0;
 323     ifstream input(path.c_str());
 324     if (!input.good()) {
 325         SG_LOG(SG_INPUT, SG_ALERT, "HUD: Cannot read configuration from " << path.str());
 326         return 0x4;
 327     }
 328
 329     SGPropertyNode root;
 330     try {
 331         readProperties(input, &root);
 332     } catch (const sg_exception &e) {
 333         input.close();
 334         guiErrorMessage("HUD: Error ", e);
 335         return 0x8;
 336     }
 337
 338     for (int i = 0; i < root.nChildren(); i++) {
 339         SGPropertyNode *n = root.getChild(i);
 340         const char *d = n->getStringValue("name", 0);
 341         string desc;
 342         if (d)
 343             desc = string(": \"") + d + '"';
 344
 345         const char *name = n->getName();
 346         if (!strcmp(name, "name")) {
 347             continue;
 348
 349         } else if (!strcmp(name, "enable3d")) {
 350             // set in the tree so that valueChanged() picks it up
 351             fgSetBool("/sim/hud/enable3d", n->getBoolValue());
 352             continue;
 353
 354         } else if (!strcmp(name, "import")) {
 355             const char *fn = n->getStringValue("path", "");
 356             float xoffs = n->getFloatValue("x-offset", 0.0f);
 357             float yoffs = n->getFloatValue("y-offset", 0.0f);
 358
 359             SG_LOG(SG_INPUT, TREE, indent << "|__import " << fn << desc);
 360
 361             string ind = indent + string(i + 1 < root.nChildren() ? "|    " : "     ");
 362             ret |= load(fn, x + xoffs, y + yoffs, level + 1, ind);
 363             continue;
 364         }
 365
 366         SG_LOG(SG_INPUT, TREE, indent << "|__" << name << desc);
 367
 368         Item *item;
 369         if (!strcmp(name, "label")) {
 370             item = static_cast<Item *>(new Label(this, n, x, y));
 371         } else if (!strcmp(name, "gauge")) {
 372             item = static_cast<Item *>(new Gauge(this, n, x, y));
 373         } else if (!strcmp(name, "tape")) {
 374             item = static_cast<Item *>(new Tape(this, n, x, y));
 375         } else if (!strcmp(name, "dial")) {
 376             item = static_cast<Item *>(new Dial(this, n, x, y));
 377         } else if (!strcmp(name, "turn-bank-indicator")) {
 378             item = static_cast<Item *>(new TurnBankIndicator(this, n, x, y));
 379         } else if (!strcmp(name, "ladder")) {
 380             item = static_cast<Item *>(new Ladder(this, n, x, y));
 381         } else if (!strcmp(name, "runway")) {
 382             item = static_cast<Item *>(new Runway(this, n, x, y));
 383         } else {
 384             SG_LOG(SG_INPUT, TREE, indent << "      \\...unsupported!");
 385             continue;
 386         }
 387         _items.insert(_items.begin(), item);
 388     }
 389     input.close();
 390     SG_LOG(SG_INPUT, TREE, indent);
 391     return ret;
 392 }
 393
 394
 395 void HUD::valueChanged(SGPropertyNode *node)
 396 {
 397     if (!strcmp(node->getName(), "current-color")) {
 398         int i = node->getIntValue();
 399         if (i < 0)
 400             i = 0;
 401         SGPropertyNode *n = fgGetNode("/sim/hud/palette", true);
 402         if ((n = n->getChild("color", i, false))) {
 403             if (n->hasValue("red"))
 404                 _red->setFloatValue(n->getFloatValue("red", 1.0));
 405             if (n->hasValue("green"))
 406                 _green->setFloatValue(n->getFloatValue("green", 1.0));
 407             if (n->hasValue("blue"))
 408                 _blue->setFloatValue(n->getFloatValue("blue", 1.0));
 409             if (n->hasValue("alpha"))
 410                 _alpha->setFloatValue(n->getFloatValue("alpha", 0.67));
 411             if (n->hasValue("alpha-clamp"))
 412                 _alpha_clamp->setFloatValue(n->getFloatValue("alpha-clamp", 0.01));
 413             if (n->hasValue("brightness"))
 414                 _brightness->setFloatValue(n->getFloatValue("brightness", 0.75));
 415             if (n->hasValue("antialiased"))
 416                 _antialiasing->setBoolValue(n->getBoolValue("antialiased", false));
 417             if (n->hasValue("transparent"))
 418                 _transparency->setBoolValue(n->getBoolValue("transparent", false));
 419         }
 420     }
 421     _scr_width = _scr_widthN->getIntValue();
 422     _scr_height = _scr_heightN->getIntValue();
 423
 424     _visible = _visibility->getBoolValue();
 425     _3Denabled = _3DenabledN->getBoolValue();
 426     _transparent = _transparency->getBoolValue();
 427     _antialiased = _antialiasing->getBoolValue();
 428     float brt = _brightness->getFloatValue();
 429     _r = clamp(brt * _red->getFloatValue());
 430     _g = clamp(brt * _green->getFloatValue());
 431     _b = clamp(brt * _blue->getFloatValue());
 432     _a = clamp(_alpha->getFloatValue());
 433     _cl = clamp(_alpha_clamp->getFloatValue());
 434
 435     _units = strcmp(_unitsN->getStringValue(), "feet") ? METER : FEET;
 436 }
 437
 438
 439 void HUD::setColor() const
 440 {
 441     if (_antialiased)
 442         glColor4f(_r, _g, _b, _a);
 443     else
 444         glColor3f(_r, _g, _b);
 445 }
 446
 447