1 // HUD.hxx -- Head Up Display
3 // Written by Michele America, started September 1997.
5 // Copyright (C) 1997 Michele F. America [micheleamerica#geocities:com]
6 // Copyright (C) 2006 Melchior FRANZ [mfranz#aon:at]
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.
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.
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.
25 #include <simgear/compiler.h>
26 #include <simgear/props/condition.hxx>
41 #include <simgear/math/SGLimits.hxx>
42 #include <simgear/constants.h>
43 #include <simgear/structure/subsystem_mgr.hxx>
45 #include <Airports/runways.hxx> // FGRunway
46 #include <GUI/gui.h> // fntRenderer ? guiErrorMessage()
47 #include <GUI/new_gui.hxx> // FGFontCache, FGColor
48 #include <Include/fg_typedefs.h>
49 #include <Main/fg_props.hxx>
57 ClipBox(const SGPropertyNode *, float xoffset = 0, float yoffset = 0);
64 SGConstPropertyNode_ptr _top_node;
65 SGConstPropertyNode_ptr _bot_node;
66 SGConstPropertyNode_ptr _left_node;
67 SGConstPropertyNode_ptr _right_node;
78 LineSegment(GLfloat x0, GLfloat y0, GLfloat x1, GLfloat y1)
79 : _x0(x0), _y0(y0), _x1(x1), _y1(y1) {}
87 GLfloat _x0, _y0, _x1, _y1;
94 void add(const LineSegment& seg) { _list.push_back(seg); }
95 void erase() { _list.erase(_list.begin(), _list.end()); }
96 inline unsigned int size() const { return _list.size(); }
99 vector<LineSegment>::const_iterator it, end = _list.end();
100 for (it = _list.begin(); it != end; ++it)
106 vector<LineSegment> _list;
113 HUDText(fntRenderer *f, float x, float y, const char *s, int align = 0, int digits = 0);
120 static const int BUFSIZE = 64;
128 TextList() { _font = 0; }
130 void setFont(fntRenderer *Renderer) { _font = Renderer; }
131 void add(float x, float y, const char *s, int align = 0, int digit = 0) {
132 _list.push_back(HUDText(_font, x, y, s, align, digit));
134 void erase() { _list.erase(_list.begin(), _list.end()); }
135 void align(const char *s, int align, float *x, float *y,
136 float *l, float *r, float *b, float *t) const;
141 vector<HUDText> _list;
149 class HUD : public SGSubsystem, public SGPropertyChangeListener {
156 // called from Main/renderer.cxx to draw 2D and 3D HUD
157 void draw(osg::State&);
159 // listener callback to read various HUD related properties
160 void valueChanged(SGPropertyNode *);
161 // set current glColor
162 void setColor() const;
163 inline bool isVisible() const { return _visible; }
164 inline bool isAntialiased() const { return _antialiased; }
165 inline bool isTransparent() const { return _transparent; }
166 inline bool is3D() const { return _3Denabled; }
167 inline float alphaClamp() const { return _cl; }
168 inline double timer() const { return _timer; }
169 static void textAlign(fntRenderer *rend, const char *s, int align, float *x, float *y,
170 float *l, float *r, float *b, float *t);
172 enum Units { FEET, METER };
173 Units getUnits() const { return _units; }
176 HORIZONTAL = 0x0000, // keep that at zero?
186 // for alignment (with LEFT, RIGHT, TOP, BOTTOM)
189 CENTER = (HCENTER|VCENTER),
194 int load(const char *, float x = 320.0f, float y = 240.0f,
195 int level = 0, const std::string& indent = "");
199 void draw2D(GLfloat, GLfloat, GLfloat, GLfloat);
208 class TurnBankIndicator;
213 deque<Item *> _items;
214 deque<Item *> _ladders;
216 SGPropertyNode_ptr _path;
217 SGPropertyNode_ptr _current;
218 SGPropertyNode_ptr _visibility;
219 SGPropertyNode_ptr _3DenabledN;
220 SGPropertyNode_ptr _antialiasing;
221 SGPropertyNode_ptr _transparency;
222 SGPropertyNode_ptr _red, _green, _blue, _alpha;
223 SGPropertyNode_ptr _alpha_clamp;
224 SGPropertyNode_ptr _brightness;
229 float _r, _g, _b, _a, _cl;
231 SGPropertyNode_ptr _scr_widthN, _scr_heightN;
232 int _scr_width, _scr_height;
233 SGPropertyNode_ptr _unitsN;
237 fntRenderer *_font_renderer;
238 FGFontCache *_font_cache;
242 bool _listener_active;
247 LineList _stipple_line_list;
254 Input(const SGPropertyNode *n, float factor = 1.0, float offset = 0.0,
255 float min = -SGLimitsf::max(), float max = SGLimitsf::max()) :
258 _damped(SGLimitsf::max())
262 _factor = n->getFloatValue("factor", factor);
263 _offset = n->getFloatValue("offset", offset);
264 _min = n->getFloatValue("min", min);
265 _max = n->getFloatValue("max", max);
266 _coeff = 1.0 - 1.0 / powf(10, fabsf(n->getFloatValue("damp", 0.0)));
267 SGPropertyNode *p = ((SGPropertyNode *)n)->getNode("property", false);
269 const char *path = p->getStringValue();
270 if (path && path[0]) {
271 _property = fgGetNode(path, true);
277 bool getBoolValue() const {
279 return _property->getBoolValue();
282 const char *getStringValue() const {
284 return _property->getStringValue();
287 float getFloatValue() {
289 float f = _property->getFloatValue() * _factor + _offset;
290 if (_damped == SGLimitsf::max())
293 f = _damped = f * (1.0f - _coeff) + _damped * _coeff;
297 inline float isValid() const { return _valid; }
298 inline float min() const { return _min; }
299 inline float max() const { return _max; }
300 inline float factor() const { return _factor; }
301 float clamp(float v) const { return v < _min ? _min : v > _max ? _max : v; }
303 void set_min(float m, bool force = true) {
304 if (force || _min == -SGLimitsf::max())
307 void set_max(float m, bool force = true) {
308 if (force || _max == SGLimitsf::max())
314 SGConstPropertyNode_ptr _property;
327 Item(HUD *parent, const SGPropertyNode *, float x = 0.0f, float y = 0.0f);
329 virtual void draw() = 0;
330 virtual bool isEnabled();
343 Format check_format(const char *) const;
344 inline float get_span() const { return _scr_span; }
345 inline int get_digits() const { return _digits; }
347 inline bool option_vert() const { return (_options & VERTICAL) == VERTICAL; }
348 inline bool option_left() const { return (_options & LEFT) == LEFT; }
349 inline bool option_right() const { return (_options & RIGHT) == RIGHT; }
350 inline bool option_both() const { return (_options & BOTH) == BOTH; }
351 inline bool option_noticks() const { return (_options & NOTICKS) == NOTICKS; }
352 inline bool option_notext() const { return (_options & NOTEXT) == NOTEXT; }
353 inline bool option_top() const { return (_options & TOP) == TOP; }
354 inline bool option_bottom() const { return (_options & BOTTOM) == BOTTOM; }
356 void draw_line(float x1, float y1, float x2, float y2);
357 void draw_stipple_line(float x1, float y1, float x2, float y2);
358 void draw_text(float x, float y, const char *msg, int align = 0, int digit = 0);
359 void draw_circle(float x1, float y1, float r) const;
360 void draw_arc(float x1, float y1, float t0, float t1, float r) const;
361 void draw_bullet(float, float, float);
366 float _x, _y, _w, _h;
367 float _center_x, _center_y;
370 SGSharedPtr<SGCondition> _condition;
371 float _disp_factor; // Multiply by to get numbers shown on scale.
372 float _scr_span; // Working values for draw;
378 class HUD::Label : public Item {
380 Label(HUD *parent, const SGPropertyNode *, float x, float y);
389 int _halign; // HUDText alignment
393 float _pointer_width;
394 float _pointer_length;
396 SGSharedPtr<SGCondition> _blink_condition;
397 double _blink_interval;
398 double _blink_target; // time for next blink state change
404 // abstract base class for both moving scale and moving needle (fixed scale)
407 class HUD::Scale : public Item {
409 Scale(HUD *parent, const SGPropertyNode *, float x, float y);
410 virtual void draw ( void ) {} // No-op here. Defined in derived classes.
413 inline float factor() const { return _display_factor; }
414 inline float range_to_show() const { return _range_shown; }
417 float _major_divs; // major division marker units
418 float _minor_divs; // minor division marker units
419 unsigned int _modulo; // Roll over point
422 float _range_shown; // Width Units.
423 float _display_factor; // factor => screen units/range values.
427 class HUD::Gauge : public Scale {
429 Gauge(HUD *parent, const SGPropertyNode *, float x, float y);
435 // displays the indicated quantity on a scale that moves past the
436 // pointer. It may be horizontal or vertical.
438 class HUD::Tape : public Scale {
440 Tape(HUD *parent, const SGPropertyNode *, float x, float y);
444 void draw_vertical(float);
445 void draw_horizontal(float);
446 void draw_fixed_pointer(float, float, float, float, float, float);
447 char *format_value(float);
451 float _half_width_units;
452 bool _draw_tick_bottom;
454 bool _draw_tick_right;
455 bool _draw_tick_left;
456 bool _draw_cap_bottom;
458 bool _draw_cap_right;
460 float _marker_offset;
466 int _div_ratio; // _major_divs/_minor_divs
467 bool _odd_type; // whether to put numbers at 0/2/4 or 1/3/5
469 enum { BUFSIZE = 64 };
472 enum PointerType { FIXED, MOVING } _pointer_type;
473 enum TickType { LINE, CIRCLE } _tick_type;
474 enum TickLength { VARIABLE, CONSTANT } _tick_length;
479 class HUD::Dial : public Scale {
481 Dial(HUD *parent, const SGPropertyNode *, float x, float y);
491 class HUD::TurnBankIndicator : public Item {
493 TurnBankIndicator(HUD *parent, const SGPropertyNode *, float x, float y);
499 void draw_line(float, float, float, float);
500 void draw_tick(float angle, float r1, float r2, int side);
511 class HUD::Ladder : public Item {
513 Ladder(HUD *parent, const SGPropertyNode *, float x, float y);
518 void draw_zenith(float, float);
519 void draw_nadir(float, float);
521 void draw_text(float x, float y, const char *s, int align = 0) {
522 _locTextList.add(x, y, s, align, 0);
525 void draw_line(float x1, float y1, float x2, float y2, bool stipple = false) {
527 _locStippleLineList.add(LineSegment(x1, y1, x2, y2));
529 _locLineList.add(LineSegment(x1, y1, x2, y2));
532 enum Type { PITCH, CLIMB_DIVE } _type;
538 float _zero_bar_overlength;
539 bool _dive_bar_angle;
544 bool _dynamic_origin;
545 bool _frl; // fuselage reference line
547 bool _target_markers;
548 bool _velocity_vector;
552 bool _climb_dive_marker;
553 bool _glide_slope_marker;
556 bool _waypoint_marker;
562 // The Ladder has its own temporary display lists
563 TextList _locTextList;
564 LineList _locLineList;
565 LineList _locStippleLineList;
570 // responsible for rendering the active runway in the hud (if visible).
572 class HUD::Runway : public Item {
574 Runway(HUD *parent, const SGPropertyNode *, float x, float y);
578 void boundPoint(const sgdVec3& v, sgdVec3& m);
579 bool boundOutsidePoints(sgdVec3& v, sgdVec3& m);
580 bool drawLine(const sgdVec3& a1, const sgdVec3& a2, const sgdVec3& p1, const sgdVec3& p2);
582 FGRunway* get_active_runway();
583 void get_rwy_points(sgdVec3 *points);
586 SGPropertyNode_ptr _agl;
587 sgdVec3 _points3d[6], _points2d[6];
590 double _arrow_scale; // scales of runway indication arrow
591 double _arrow_radius;
592 double _line_scale; // maximum line scale
593 double _scale_dist; // distance where to start scaling the lines
594 double _default_pitch;
595 double _default_heading;
598 FGViewer* _cockpit_view;
599 unsigned short _stipple_out; // stipple pattern of the outline of the runway
600 unsigned short _stipple_center; // stipple pattern of the center line of the runway
601 bool _draw_arrow; // draw arrow when runway is not visible in HUD
602 bool _draw_arrow_always; // always draws arrow
603 float _left, _right, _top, _bottom;
607 class HUD::AimingReticle : public Item {
609 AimingReticle(HUD *parent, const SGPropertyNode *, float x, float y);
613 SGSharedPtr<SGCondition> _active_condition; // stadiametric (true) or standby (false)
614 SGSharedPtr<SGCondition> _tachy_condition; // tachymetric (true) or standby (false)
615 SGSharedPtr<SGCondition> _align_condition; // tachymetric (true) or standby (false)
617 Input _diameter; // inner/outer radius relation