fly/flightgear
1
0
Fork 0
Code Activity
flightgear/src/Instrumentation/HUD/HUD.hxx
James Turner 7c79e16d8d Add hud-cycling back - issue #337
2011-12-11 14:12:17 +00:00

640 lines
17 KiB
C++
Raw Blame History

// HUD.hxx -- Head Up Display
//
// Written by Michele America, started September 1997.
//
// Copyright (C) 1997 Michele F. America [micheleamerica#geocities:com]
// Copyright (C) 2006 Melchior FRANZ [mfranz#aon:at]
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License as
// published by the Free Software Foundation; either version 2 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#ifndef _HUD_HXX
#define _HUD_HXX
#include <simgear/compiler.h>
#include <simgear/props/condition.hxx>
#ifdef HAVE_CONFIG_H
# include <config.h>
#endif
#include <vector>
#include <deque>
#include <fstream>
using std::deque;
using std::vector;
#include <osg/State>
#include <simgear/math/SGLimits.hxx>
#include <simgear/constants.h>
#include <simgear/structure/subsystem_mgr.hxx>
#include <Airports/runways.hxx> // FGRunway
#include <GUI/gui.h> // fntRenderer ? guiErrorMessage()
#include <GUI/new_gui.hxx> // FGFontCache, FGColor
#include <Main/fg_props.hxx>
class FGViewer;
class ClipBox {
public:
ClipBox(const SGPropertyNode *, float xoffset = 0, float yoffset = 0);
void set();
void unset();
private:
bool _active;
float _xoffs, _yoffs;
SGConstPropertyNode_ptr _top_node;
SGConstPropertyNode_ptr _bot_node;
SGConstPropertyNode_ptr _left_node;
SGConstPropertyNode_ptr _right_node;
GLdouble _top[4];
GLdouble _bot[4];
GLdouble _left[4];
GLdouble _right[4];
};
class LineSegment {
public:
LineSegment(GLfloat x0, GLfloat y0, GLfloat x1, GLfloat y1)
: _x0(x0), _y0(y0), _x1(x1), _y1(y1) {}
void draw() const {
glVertex2f(_x0, _y0);
glVertex2f(_x1, _y1);
}
private:
GLfloat _x0, _y0, _x1, _y1;
};
class LineList {
public:
void add(const LineSegment& seg) { _list.push_back(seg); }
void erase() { _list.erase(_list.begin(), _list.end()); }
inline unsigned int size() const { return _list.size(); }
void draw() {
glBegin(GL_LINES);
vector<LineSegment>::const_iterator it, end = _list.end();
for (it = _list.begin(); it != end; ++it)
it->draw();
glEnd();
}
private:
vector<LineSegment> _list;
};
class HUDText {
public:
HUDText(fntRenderer *f, float x, float y, const char *s, int align = 0, int digits = 0);
void draw();
private:
fntRenderer *_fnt;
float _x, _y;
int _digits;
static const int BUFSIZE = 64;
char _msg[BUFSIZE];
};
class TextList {
public:
TextList() { _font = 0; }
void setFont(fntRenderer *Renderer) { _font = Renderer; }
void add(float x, float y, const char *s, int align = 0, int digit = 0) {
_list.push_back(HUDText(_font, x, y, s, align, digit));
}
void erase() { _list.erase(_list.begin(), _list.end()); }
void align(const char *s, int align, float *x, float *y,
float *l, float *r, float *b, float *t) const;
void draw();
private:
fntRenderer *_font;
vector<HUDText> _list;
};
class HUD : public SGSubsystem, public SGPropertyChangeListener {
public:
HUD();
~HUD();
void init();
void update(double);
void reinit();
// called from Main/renderer.cxx to draw 2D and 3D HUD
void draw(osg::State&);
// listener callback to read various HUD related properties
void valueChanged(SGPropertyNode *);
// set current glColor
void setColor() const;
inline bool isVisible() const { return _visible; }
inline bool isAntialiased() const { return _antialiased; }
inline bool isTransparent() const { return _transparent; }
inline bool is3D() const { return _3Denabled; }
inline float alphaClamp() const { return _cl; }
inline double timer() const { return _timer; }
static void textAlign(fntRenderer *rend, const char *s, int align, float *x, float *y,
float *l, float *r, float *b, float *t);
enum Units { FEET, METER };
Units getUnits() const { return _units; }
enum {
HORIZONTAL = 0x0000, // keep that at zero?
VERTICAL = 0x0001,
TOP = 0x0002,
BOTTOM = 0x0004,
LEFT = 0x0008,
RIGHT = 0x0010,
NOTICKS = 0x0020,
NOTEXT = 0x0040,
BOTH = (LEFT|RIGHT),
// for alignment (with LEFT, RIGHT, TOP, BOTTOM)
HCENTER = 0x0080,
VCENTER = 0x0100,
CENTER = (HCENTER|VCENTER),
};
protected:
void common_draw();
int load(const char *, float x = 320.0f, float y = 240.0f,
int level = 0, const std::string& indent = "");
private:
void deinit();
void draw3D();
void draw2D(GLfloat, GLfloat, GLfloat, GLfloat);
void currentColorChanged();
class Input;
class Item;
class Label;
class Scale;
class Gauge;
class Tape;
class Dial;
class TurnBankIndicator;
class Ladder;
class Runway;
class AimingReticle;
deque<Item *> _items;
deque<Item *> _ladders;
SGPropertyNode_ptr _currentPath;
SGPropertyNode_ptr _currentColor;
SGPropertyNode_ptr _visibility;
SGPropertyNode_ptr _3DenabledN;
SGPropertyNode_ptr _antialiasing;
SGPropertyNode_ptr _transparency;
SGPropertyNode_ptr _red, _green, _blue, _alpha;
SGPropertyNode_ptr _alpha_clamp;
SGPropertyNode_ptr _brightness;
bool _visible;
bool _3Denabled;
bool _antialiased;
bool _transparent;
float _r, _g, _b, _a, _cl;
SGPropertyNode_ptr _scr_widthN, _scr_heightN;
int _scr_width, _scr_height;
SGPropertyNode_ptr _unitsN;
Units _units;
double _timer;
fntRenderer *_font_renderer;
FGFontCache *_font_cache;
fntTexFont *_font;
float _font_size;
int _style;
bool _listener_active;
ClipBox *_clip_box;
TextList _text_list;
LineList _line_list;
LineList _stipple_line_list;
};
class HUD::Input {
public:
Input(const SGPropertyNode *n, float factor = 1.0, float offset = 0.0,
float min = -SGLimitsf::max(), float max = SGLimitsf::max()) :
_valid(false),
_property(0),
_damped(SGLimitsf::max())
{
if (!n)
return;
_factor = n->getFloatValue("factor", factor);
_offset = n->getFloatValue("offset", offset);
_min = n->getFloatValue("min", min);
_max = n->getFloatValue("max", max);
_coeff = 1.0 - 1.0 / powf(10, fabs(n->getFloatValue("damp", 0.0)));
SGPropertyNode *p = ((SGPropertyNode *)n)->getNode("property", false);
if (p) {
const char *path = p->getStringValue();
if (path && path[0]) {
_property = fgGetNode(path, true);
_valid = true;
}
}
}
bool getBoolValue() const {
assert(_property);
return _property->getBoolValue();
}
const char *getStringValue() const {
assert(_property);
return _property->getStringValue();
}
float getFloatValue() {
assert(_property);
float f = _property->getFloatValue() * _factor + _offset;
if (_damped == SGLimitsf::max())
_damped = f;
if (_coeff > 0.0f)
f = _damped = f * (1.0f - _coeff) + _damped * _coeff;
return clamp(f);
}
inline float isValid() const { return _valid; }
inline float min() const { return _min; }
inline float max() const { return _max; }
inline float factor() const { return _factor; }
float clamp(float v) const { return v < _min ? _min : v > _max ? _max : v; }
void set_min(float m, bool force = true) {
if (force || _min == -SGLimitsf::max())
_min = m;
}
void set_max(float m, bool force = true) {
if (force || _max == SGLimitsf::max())
_max = m;
}
private:
bool _valid;
SGConstPropertyNode_ptr _property;
float _factor;
float _offset;
float _min;
float _max;
float _coeff;
float _damped;
};
class HUD::Item {
public:
Item(HUD *parent, const SGPropertyNode *, float x = 0.0f, float y = 0.0f);
virtual ~Item () {}
virtual void draw() = 0;
virtual bool isEnabled();
protected:
enum Format {
INVALID,
NONE,
INT,
LONG,
FLOAT,
DOUBLE,
STRING,
};
Format check_format(const char *) const;
inline float get_span() const { return _scr_span; }
inline int get_digits() const { return _digits; }
inline bool option_vert() const { return (_options & VERTICAL) == VERTICAL; }
inline bool option_left() const { return (_options & LEFT) == LEFT; }
inline bool option_right() const { return (_options & RIGHT) == RIGHT; }
inline bool option_both() const { return (_options & BOTH) == BOTH; }
inline bool option_noticks() const { return (_options & NOTICKS) == NOTICKS; }
inline bool option_notext() const { return (_options & NOTEXT) == NOTEXT; }
inline bool option_top() const { return (_options & TOP) == TOP; }
inline bool option_bottom() const { return (_options & BOTTOM) == BOTTOM; }
void draw_line(float x1, float y1, float x2, float y2);
void draw_stipple_line(float x1, float y1, float x2, float y2);
void draw_text(float x, float y, const char *msg, int align = 0, int digit = 0);
void draw_circle(float x1, float y1, float r) const;
void draw_arc(float x1, float y1, float t0, float t1, float r) const;
void draw_bullet(float, float, float);
HUD *_hud;
std::string _name;
int _options;
float _x, _y, _w, _h;
float _center_x, _center_y;
private:
SGSharedPtr<SGCondition> _condition;
float _disp_factor; // Multiply by to get numbers shown on scale.
float _scr_span; // Working values for draw;
int _digits;
};
class HUD::Label : public Item {
public:
Label(HUD *parent, const SGPropertyNode *, float x, float y);
virtual void draw();
private:
bool blink();
Input _input;
Format _mode;
std::string _format;
int _halign; // HUDText alignment
int _blink;
bool _box;
float _text_y;
float _pointer_width;
float _pointer_length;
SGSharedPtr<SGCondition> _blink_condition;
double _blink_interval;
double _blink_target; // time for next blink state change
bool _blink_state;
};
// abstract base class for both moving scale and moving needle (fixed scale)
// indicators.
//
class HUD::Scale : public Item {
public:
Scale(HUD *parent, const SGPropertyNode *, float x, float y);
virtual void draw ( void ) {} // No-op here. Defined in derived classes.
protected:
inline float factor() const { return _display_factor; }
inline float range_to_show() const { return _range_shown; }
Input _input;
float _major_divs; // major division marker units
float _minor_divs; // minor division marker units
unsigned int _modulo; // Roll over point
private:
float _range_shown; // Width Units.
float _display_factor; // factor => screen units/range values.
};
class HUD::Gauge : public Scale {
public:
Gauge(HUD *parent, const SGPropertyNode *, float x, float y);
virtual void draw();
};
// displays the indicated quantity on a scale that moves past the
// pointer. It may be horizontal or vertical.
//
class HUD::Tape : public Scale {
public:
Tape(HUD *parent, const SGPropertyNode *, float x, float y);
virtual void draw();
protected:
void draw_vertical(float);
void draw_horizontal(float);
void draw_fixed_pointer(float, float, float, float, float, float);
char *format_value(float);
private:
float _val_span;
float _half_width_units;
bool _draw_tick_bottom;
bool _draw_tick_top;
bool _draw_tick_right;
bool _draw_tick_left;
bool _draw_cap_bottom;
bool _draw_cap_top;
bool _draw_cap_right;
bool _draw_cap_left;
float _marker_offset;
float _label_offset;
float _label_gap;
bool _pointer;
Format _label_fmt;
std::string _format;
int _div_ratio; // _major_divs/_minor_divs
bool _odd_type; // whether to put numbers at 0/2/4 or 1/3/5
enum { BUFSIZE = 64 };
char _buf[BUFSIZE];
enum PointerType { FIXED, MOVING } _pointer_type;
enum TickType { LINE, CIRCLE } _tick_type;
enum TickLength { VARIABLE, CONSTANT } _tick_length;
};
class HUD::Dial : public Scale {
public:
Dial(HUD *parent, const SGPropertyNode *, float x, float y);
virtual void draw();
private:
float _radius;
int _divisions;
};
class HUD::TurnBankIndicator : public Item {
public:
TurnBankIndicator(HUD *parent, const SGPropertyNode *, float x, float y);
virtual void draw();
private:
void draw_scale();
void draw_tee();
void draw_line(float, float, float, float);
void draw_tick(float angle, float r1, float r2, int side);
Input _bank;
Input _sideslip;
float _gap_width;
bool _bank_scale;
};
class HUD::Ladder : public Item {
public:
Ladder(HUD *parent, const SGPropertyNode *, float x, float y);
~Ladder();
virtual void draw();
private:
void draw_zenith(float, float);
void draw_nadir(float, float);
void draw_text(float x, float y, const char *s, int align = 0) {
_locTextList.add(x, y, s, align, 0);
}
void draw_line(float x1, float y1, float x2, float y2, bool stipple = false) {
if (stipple)
_locStippleLineList.add(LineSegment(x1, y1, x2, y2));
else
_locLineList.add(LineSegment(x1, y1, x2, y2));
}
enum Type { PITCH, CLIMB_DIVE } _type;
Input _pitch;
Input _roll;
float _width_units;
int _div_units;
float _scr_hole;
float _zero_bar_overlength;
bool _dive_bar_angle;
float _tick_length;
float _vmax;
float _vmin;
float _compression;
bool _dynamic_origin;
bool _frl; // fuselage reference line
bool _target_spot;
bool _target_markers;
bool _velocity_vector;
bool _drift_marker;
bool _alpha_bracket;
bool _energy_marker;
bool _climb_dive_marker;
bool _glide_slope_marker;
float _glide_slope;
bool _energy_worm;
bool _waypoint_marker;
bool _zenith;
bool _nadir;
bool _hat;
ClipBox *_clip_box;
// The Ladder has its own temporary display lists
TextList _locTextList;
LineList _locLineList;
LineList _locStippleLineList;
};
// responsible for rendering the active runway in the hud (if visible).
//
class HUD::Runway : public Item {
public:
Runway(HUD *parent, const SGPropertyNode *, float x, float y);
virtual void draw();
private:
void boundPoint(const sgdVec3& v, sgdVec3& m);
bool boundOutsidePoints(sgdVec3& v, sgdVec3& m);
bool drawLine(const sgdVec3& a1, const sgdVec3& a2, const sgdVec3& p1, const sgdVec3& p2);
void drawArrow();
FGRunway* get_active_runway();
void get_rwy_points(sgdVec3 *points);
void setLineWidth();
SGPropertyNode_ptr _agl;
sgdVec3 _points3d[6], _points2d[6];
double _mm[16];
double _pm[16];
double _arrow_scale; // scales of runway indication arrow
double _arrow_radius;
double _line_scale; // maximum line scale
double _scale_dist; // distance where to start scaling the lines
double _default_pitch;
double _default_heading;
GLint _view[4];
FGRunway* _runway;
unsigned short _stipple_out; // stipple pattern of the outline of the runway
unsigned short _stipple_center; // stipple pattern of the center line of the runway
bool _draw_arrow; // draw arrow when runway is not visible in HUD
bool _draw_arrow_always; // always draws arrow
float _left, _right, _top, _bottom;
};
class HUD::AimingReticle : public Item {
public:
AimingReticle(HUD *parent, const SGPropertyNode *, float x, float y);
virtual void draw();
private:
SGSharedPtr<SGCondition> _active_condition; // stadiametric (true) or standby (false)
SGSharedPtr<SGCondition> _tachy_condition; // tachymetric (true) or standby (false)
SGSharedPtr<SGCondition> _align_condition; // tachymetric (true) or standby (false)
Input _diameter; // inner/outer radius relation
Input _pitch;
Input _yaw;
Input _speed;
Input _range;
Input _t0;
Input _t1;
Input _offset_x;
Input _offset_y;
float _bullet_size;
float _inner_radius;
float _compression;
float _limit_x;
float _limit_y;
};
#endif // _HUD_HXX
View git blame Copy permalink