X-Git-Url: https://git.mxchange.org/?a=blobdiff_plain;f=src%2FCockpit%2Fhud.hxx;h=bec30f5539a6c570ca185b1c4efc3906bc3e3eb1;hb=8e5f3ac8a333a971d7f8104a387426c3bc47a014;hp=50365f35aaff4f5c54ca1e10d05f7865f060c08f;hpb=029dda3297e3697438e1a58188527cbae90beebe;p=flightgear.git

diff --git a/src/Cockpit/hud.hxx b/src/Cockpit/hud.hxx
index 50365f35a..bec30f553 100644
--- a/src/Cockpit/hud.hxx
+++ b/src/Cockpit/hud.hxx
@@ -16,13 +16,13 @@
 //
 // 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., 675 Mass Ave, Cambridge, MA 02139, USA.
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 //
 // $Id$
 
 
-#ifndef _HUD_HXX
-#define _HUD_HXX
+#ifndef _OLDHUD_HXX
+#define _OLDHUD_HXX
 
 #ifndef __cplusplus
 # error This library requires C++
@@ -34,40 +34,39 @@
 #  include <config.h>
 #endif
 
-#ifdef HAVE_WINDOWS_H
-#  include <windows.h>
+#ifdef __CYGWIN__
+#include <ieeefp.h>
 #endif
 
 #include <stdlib.h>
 #include <string.h>
 
-//#ifdef HAVE_VALUES_H
-//#  include <values.h>  // for MAXINT
-//#endif
-
 #include <algorithm>    // for_each()
 #include <vector>       // STL vector
 #include <deque>        // STL double ended queue
-#include STL_FSTREAM
+#include <fstream>
+
+namespace osg {
+    class State;
+}
 
+#include <simgear/math/SGMath.hxx>
 #include <simgear/constants.h>
 
 #include <Include/fg_typedefs.h>
-#include <Aircraft/aircraft.hxx>
 #include <Aircraft/controls.hxx>
 #include <FDM/flight.hxx>
 #include <GUI/gui.h>
+#include <Main/fg_props.hxx>
 #include <Main/globals.hxx>
 #include <Main/viewmgr.hxx>
-#include <Airports/runways.hxx>
 
-#include "hud_opts.hxx"
-#include <plib/sg.h>
+class FGRunway;
 
-SG_USING_STD(deque);
-SG_USING_STD(vector);
-SG_USING_NAMESPACE(std);
+using std::deque;
+using std::vector;
 
+#define float_to_int(v) SGMiscf::roundToInt(v)
 
 // some of Norman's crazy optimizations. :-)
 
@@ -75,7 +74,7 @@ SG_USING_NAMESPACE(std);
 typedef struct {
     int x, y;
 } POINT;
- 
+
 typedef struct {
     int top, bottom, left, right;
 } RECT;
@@ -85,17 +84,6 @@ typedef struct {
 
 enum VIEW_MODES{ HUD_VIEW, PANEL_VIEW, CHASE_VIEW, TOWER_VIEW };
 
-// DAY, NIGHT and brightness levels need to be visible where dialogs and
-// controls can be used to set intensity and appropriate color. This will
-// be moved.
-// Hud general constants
-#define HUD_DAY                1
-#define HUD_NIGHT              2
-#define HUD_BRT_BLACK          3
-#define HUD_BRT_DARK           4
-#define HUD_BRT_MEDIUM         5
-#define HUD_BRT_LIGHT          6
-
 // Label constants
 #define HUD_FONT_SMALL     1
 #define HUD_FONT_LARGE     2
@@ -115,32 +103,6 @@ enum fgLabelJust{ LEFT_JUST, CENTER_JUST, RIGHT_JUST } ;
 #define HUDS_DECITICS            0x0040
 #define HUDS_NOTEXT              0x0080
 
-// Ladder orientaion
-// #define HUD_VERTICAL        1
-// #define HUD_HORIZONTAL       2
-// #define HUD_FREEFLOAT        3
-
-// Ladder orientation modes
-// #define HUD_LEFT         1
-// #define HUD_RIGHT            2
-// #define HUD_TOP              1
-// #define HUD_BOTTOM           2
-// #define HUD_V_LEFT           1
-// #define HUD_V_RIGHT          2
-// #define HUD_H_TOP            1
-// #define HUD_H_BOTTOM         2
-
-
-// Ladder sub-types
-// #define HUD_LIM              1
-// #define HUD_NOLIM            2
-// #define HUD_CIRC         3
-
-// #define HUD_INSTR_LADDER 1
-// #define HUD_INSTR_CLADDER    2
-// #define HUD_INSTR_HORIZON    3
-// #define HUD_INSTR_LABEL      4
-
 // in cockpit.cxx
 extern float get_throttleval ( void );
 extern float get_aileronval  ( void );
@@ -170,51 +132,8 @@ extern float get_climb_rate  ( void );
 extern float get_mach( void );
 extern char *coord_format_lat(float);
 extern char *coord_format_lon(float);
-//extern char *coord_format_latlon(float latitude, float longitude);  // cockpit.cxx
-
-// $$$ begin - added, VS Renganathan, 13 Oct 2K
-// #define FIGHTER_HUD
-extern float get_anzg (void);
-extern float get_Vx (void);
-extern float get_Vy (void);
-extern float get_Vz (void);
-extern float get_Ax (void);
-extern float get_Ay (void);
-extern float get_Az (void);
-extern int get_iaux1 (void);
-extern int get_iaux2 (void);
-extern int get_iaux3 (void);
-extern int get_iaux4 (void);
-extern int get_iaux5 (void);
-extern int get_iaux6 (void);
-extern int get_iaux7 (void);
-extern int get_iaux8 (void);
-extern int get_iaux9 (void);
-extern int get_iaux10 (void);
-extern int get_iaux11 (void);
-extern int get_iaux12 (void);
-extern float get_aux1(void);
-extern float get_aux2(void);
-extern float get_aux3(void);
-extern float get_aux4(void);
-extern float get_aux5 (void);
-extern float get_aux6 (void);
-extern float get_aux7 (void);
-extern float get_aux8(void);
-extern float get_aux9(void);
-extern float get_aux10(void);
-extern float get_aux11(void);
-extern float get_aux12(void);
-extern float get_aux13(void);
-extern float get_aux14(void);
-extern float get_aux15(void);
-extern float get_aux16(void);
-extern float get_aux17(void);
-extern float get_aux18(void);
-// $$$ end - added, VS Renganathan, 13 Oct 2K
 
 extern char *get_formated_gmt_time( void );
-extern void fgHUDReshape(void);
 
 enum  hudinstype{ HUDno_instr,
                   HUDscale,
@@ -245,12 +164,10 @@ public:
     fgLineSeg2D( const fgLineSeg2D & image )
         : x0(image.x0), y0(image.y0), x1(image.x1), y1(image.y1) {}
 
-    fgLineSeg2D& operator= ( const fgLineSeg2D & image ) {
+    fgLineSeg2D& operator= ( const fgLineSeg2D & image ) { // seems unused
         x0 = image.x0; y0 = image.y0; x1 = image.x1; y1 = image.y1; return *this;
     }
 
-    ~fgLineSeg2D() {}
-    
     void draw() const
     {
         glVertex2f(x0, y0);
@@ -267,6 +184,7 @@ class DrawLineSeg2D {
 
 
 #define USE_HUD_TextList
+extern fntTexFont        *HUD_Font;
 extern float              HUD_TextSize;
 extern fntRenderer       *HUDtext;
 extern float HUD_matrix[16];
@@ -274,99 +192,89 @@ extern float HUD_matrix[16];
 class fgText {
 private:
     float x, y;
-    char msg[64];
+    string msg;
+	bool digit;
+    // seems unused   
+	
 public:
-    int digit; //suma
-    fgText(float x = 0, float y = 0, char *c = NULL,int digits=0): x(x), y(y) //suma
-    { 
-        strcpy(msg,c);
-        digit=digits; //suma
-    }
-		   
-    fgText( const fgText & image )
-        : x(image.x), y(image.y),digit(image.digit) {strcpy(msg,image.msg);} //suma
-
-    fgText& operator = ( const fgText & image ) {
-        strcpy(msg,image.msg); x = image.x; y = image.y;digit=image.digit; //suma
-        return *this;   
-    }
+	fgText(float x, float y, const string& c, bool digits=false): x(x), y(y), msg( c), digit( digits) {};	
 
-    ~fgText() {msg[0]='\0';}
+    fgText( const fgText & image )
+		: x(image.x), y(image.y), msg(image.msg), digit(image.digit) { }
 
-    int getStringWidth ( char *str )
+	fgText& operator = ( const fgText & image ) {
+		x = image.x; y = image.y; msg= image.msg; digit = image.digit;
+		return *this;
+	}
+	
+    static int getStringWidth ( const char *str )
     {
         if ( HUDtext && str ) {
             float r, l ;
-            guiFntHandle->getBBox ( str, HUD_TextSize, 0, &l, &r, NULL, NULL ) ;
-            return FloatToInt( r - l );
+            HUD_Font->getBBox ( str, HUD_TextSize, 0, &l, &r, NULL, NULL ) ;
+            return float_to_int( r - l );
         }
         return 0 ;
     }
-    
-    int StringWidth (void )
+
+    int StringWidth ()
     {
-        if ( HUDtext && strlen( msg )) {
+        if ( HUDtext && msg != "") {
             float r, l ;
-            guiFntHandle->getBBox ( msg, HUD_TextSize, 0, &l, &r, NULL, NULL ) ;
-            return FloatToInt( r - l );
+            HUD_Font->getBBox ( msg.c_str(), HUD_TextSize, 0, &l, &r, NULL, NULL ) ;
+            return float_to_int( r - l );
         }
         return 0 ;
     }
-   
+
     // this code is changed to display Numbers with big/small digits
     // according to MIL Standards for example Altitude above 10000 ft
-    // is shown as 10ooo.  begin suma
+    // is shown as 10ooo.
 
-    void Draw(fntRenderer *fnt,int digits) {
-        if(digits==1) {
-            int c=0,i=0;
-            char *t=msg;
+    void Draw(fntRenderer *fnt) {
+        if (digit) {
+            int c=0;
+            
             int p=4;
 
-            if(t[0]=='-') {
+            if (msg[0]=='-') {
                 //if negative value then increase the c and p values
                 //for '-' sign.  c++;
                 p++;
             }
-            char *tmp=msg;
-            while(tmp[i]!='\0') {
-                if((tmp[i]>='0') && (tmp[i]<='9'))  
+			
+			for (string::size_type i = 0; i < msg.size(); i++) {
+                if ((msg[i]>='0') && (msg[i]<='9'))
                     c++;
-                i++;
             }
-            if(c>p) {
-                fnt->setPointSize(8);
-                int p1=c-3;
-                char *tmp1=msg+p1;
-                int p2=p1*8;
- 			  
+            float orig_size = fnt->getPointSize();
+            if (c>p) {
+                fnt->setPointSize(HUD_TextSize * 0.8);
+                int p2=(c-3)*8;  //advance to the last 3 digits
+
                 fnt->start2f(x+p2,y);
-                fnt->puts(tmp1);
+                fnt->puts(msg.c_str() + c - 3); // display last 3 digits
 
-                fnt->setPointSize(12);
-                char tmp2[64];
-                strncpy(tmp2,msg,p1);
-                tmp2[p1]='\0';
-			 
+                fnt->setPointSize(HUD_TextSize * 1.2);
+              
                 fnt->start2f(x,y);
-                fnt->puts(tmp2);
+				fnt->puts(msg.substr(0,c-3).c_str());
             } else {
-                fnt->setPointSize(12);					
+                fnt->setPointSize(HUD_TextSize * 1.2);
                 fnt->start2f( x, y );
-                fnt->puts(tmp);
+                fnt->puts(msg.c_str());
             }
+            fnt->setPointSize(orig_size);
         } else {
-            //if digits not equal to 1
-            fnt->setPointSize(8);         
+            //if digits not true
             fnt->start2f( x, y );
-            fnt->puts( msg ) ;
+            fnt->puts( msg.c_str()) ;
         }
     }
-    //end suma
 
     void Draw()
     {
-        guiFnt.drawString( msg, FloatToInt(x), FloatToInt(y) );
+		guiFnt.drawString( msg.c_str(), float_to_int(x), float_to_int(y) );
     }
 };
 
@@ -374,9 +282,8 @@ class fgLineList {
     vector < fgLineSeg2D > List;
 public:
     fgLineList( void ) {}
-    ~fgLineList( void ) {}
     void add( const fgLineSeg2D& seg ) { List.push_back(seg); }
-    void erase( void ) { List.erase( List.begin(), List.end() ); }
+	void erase( void ) { List.clear();}
     void draw( void ) {
         glBegin(GL_LINES);
         for_each( List.begin(), List.end(), DrawLineSeg2D());
@@ -389,33 +296,11 @@ class fgTextList {
     vector< fgText > List;
 public:
     fgTextList ( void ) { Font = 0; }
-    ~fgTextList( void ) {}
-    
+
     void setFont( fntRenderer *Renderer ) { Font = Renderer; }
     void add( const fgText& String ) { List.push_back(String); }
-    void erase( void ) { List.erase( List.begin(), List.end() ); }
-    
-    void draw( void ) {
-        if( Font == 0 )
-            return;
-        vector < fgText > :: iterator curString = List.begin();
-        vector < fgText > :: iterator lastString = List.end();
-
-        glPushAttrib( GL_COLOR_BUFFER_BIT );
-        glEnable    ( GL_ALPHA_TEST   ) ;
-        glEnable    ( GL_BLEND        ) ;
-        glAlphaFunc ( GL_GREATER, 0.1 ) ;
-        glBlendFunc ( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ) ;
-
-        Font->begin();
-        for( ; curString != lastString; curString++ ) {
-            curString->Draw(Font,curString->digit); //suma
-        }
-        Font->end();
-
-        glDisable ( GL_TEXTURE_2D ) ;
-        glPopAttrib();
-    }
+    void erase( void ) { List.clear(); }
+    void draw( void );
 };
 
 
@@ -441,7 +326,7 @@ extern fgLineList         HUD_LineList;
 extern fgLineList         HUD_StippleLineList;
 
 
-class instr_item {  // An Abstract Base Class (ABC)
+class instr_item : public SGReferenced {  // An Abstract Base Class (ABC)
 private:
     static UINT        instances;     // More than 64K instruments? Nah!
     static int         brightness;
@@ -457,8 +342,8 @@ private:
     bool               broken;
     UINT               scr_span;      // Working values for draw;
     POINT              mid_span;      //
-    int		       digits;        //suma
-  
+    int                digits;
+
 public:
     instr_item( int            x,
                 int            y,
@@ -467,14 +352,12 @@ public:
                 FLTFNPTR       data_source,
                 float          data_scaling,
                 UINT           options,
-                bool           working  = true,
-                int	       digit = 0); //suma
-
-    instr_item( const instr_item & image );
+                bool           working = true,
+                int            digit = 0);
 
-    instr_item & operator = ( const instr_item & rhs );
     virtual ~instr_item ();
 
+    void    set_data_source ( FLTFNPTR fn ) { load_value_fn = fn; }
     int     get_brightness  ( void ) { return brightness;}
     RECT    get_location    ( void ) { return scrn_pos;  }
     bool    is_broken       ( void ) { return broken;    }
@@ -485,28 +368,31 @@ public:
     UINT    get_span        ( void ) { return scr_span;  }
     POINT   get_centroid    ( void ) { return mid_span;  }
     UINT    get_options     ( void ) { return opts;      }
-    int     get_digits	    ( void ) { return digits;	 } //suma
-
-    UINT    huds_vert     (UINT options) { return( options  & HUDS_VERT ); }
-    UINT    huds_left     (UINT options) { return( options  & HUDS_LEFT ); }
-    UINT    huds_right    (UINT options) { return( options  & HUDS_RIGHT ); }
+    int     get_digits      ( void ) { return digits;         }
+    inline int get_x() const { return scrn_pos.left; }
+    inline int get_y() const { return scrn_pos.top; }
+    inline int get_width() const { return scrn_pos.right; }
+    inline int get_height() const { return scrn_pos.bottom; }
+
+    UINT    huds_vert     (UINT options) { return (options & HUDS_VERT); }
+    UINT    huds_left     (UINT options) { return (options & HUDS_LEFT); }
+    UINT    huds_right    (UINT options) { return (options & HUDS_RIGHT); }
     UINT    huds_both     (UINT options) {
-        return( (options & HUDS_BOTH) == HUDS_BOTH );
+        return ((options & HUDS_BOTH) == HUDS_BOTH);
     }
-    UINT    huds_noticks  (UINT options) { return( options  & HUDS_NOTICKS ); }
-    UINT    huds_notext   (UINT options) { return( options  & HUDS_NOTEXT ); }
-    UINT    huds_top      (UINT options) { return( options  & HUDS_TOP ); }
-    UINT    huds_bottom   (UINT options) { return( options  & HUDS_BOTTOM ); }
-  
-    virtual void display_enable( bool working ) { is_enabled = !! working;}
-
-    virtual void update( void );
+    UINT    huds_noticks  (UINT options) { return (options & HUDS_NOTICKS); }
+    UINT    huds_notext   (UINT options) { return (options & HUDS_NOTEXT); }
+    UINT    huds_top      (UINT options) { return (options & HUDS_TOP); }
+    UINT    huds_bottom   (UINT options) { return (options & HUDS_BOTTOM); }
+
+    virtual void display_enable( bool working ) { is_enabled = working;}
+
     virtual void break_display ( bool bad );
     virtual void SetBrightness( int illumination_level ); // fgHUDSetBright...
     void         SetPosition  ( int x, int y, UINT width, UINT height );
     UINT         get_Handle( void );
     virtual void draw( void ) = 0;   // Required method in derived classes
-    
+
     void drawOneLine( float x1, float y1, float x2, float y2)
     {
         HUD_LineList.add(fgLineSeg2D(x1,y1,x2,y2));
@@ -515,32 +401,22 @@ public:
     {
         HUD_StippleLineList.add(fgLineSeg2D(x1,y1,x2,y2));
     }
-    void TextString( char *msg, float x, float y,int digit ) //suma
+    void TextString( char *msg, float x, float y, bool digit )
     {
-        HUD_TextList.add(fgText(x, y, msg,digit)); //suma  
+        HUD_TextList.add(fgText(x, y, msg,digit));
     }
     int getStringWidth ( char *str )
     {
         if ( HUDtext && str ) {
             float r, l ;
-            guiFntHandle->getBBox ( str, HUD_TextSize, 0, &l, &r, NULL, NULL ) ;
-            return FloatToInt( r - l );
+            HUD_Font->getBBox ( str, HUD_TextSize, 0, &l, &r, NULL, NULL ) ;
+            return float_to_int( r - l );
         }
         return 0 ;
     }
 
-    //code to draw ticks as small circles
-    void drawOneCircle(float x1, float y1, float r)
-    {
-        glBegin(GL_LINE_LOOP);  // Use polygon to approximate a circle 
-        for(int count=0; count<25; count++) {             
-            float cosine = r * cos(count * 2 * SG_PI/10.0); 
-            float sine =   r * sin(count * 2 * SG_PI/10.0); 
-            glVertex2f(cosine+x1, sine+y1);
-        }     
-        glEnd(); 
-    }
-    
+
+
 };
 
 typedef instr_item *HIptr;
@@ -548,18 +424,13 @@ typedef instr_item *HIptr;
 class HUDdraw {
     public:
         void operator() (HIptr elem) const {
-            if( elem->enabled())
+            if ( elem->enabled())
                 elem->draw();
         }
 };
 
-//typedef deque <  instr_item * > hud_deque_type;
-//typedef hud_deque_type::iterator hud_deque_iterator;
-//typedef hud_deque_type::const_iterator hud_deque_const_iterator;
 
-extern deque< instr_item *> HUD_deque;
 extern int HUD_style;
-//extern hud_deque_type HUD_deque;
 
 // instr_item           This class has no other purpose than to maintain
 //                      a linked list of instrument and derived class
@@ -568,161 +439,68 @@ extern int HUD_style;
 
 class instr_label : public instr_item {
 private:
-    const char *pformat;
-    const char *pre_str;
-    const char *post_str;
-    fgLabelJust justify;
-    int         fontSize;
-    int         blink;
-    char format_buffer[80];
-    bool		lat;
-    bool		lon;
-    bool		lbox;
-
-public:
-    instr_label( int          x,
-                 int          y,
-                 UINT         width,
-                 UINT         height,
-                 FLTFNPTR     data_source,
-                 const char  *label_format,
-                 const char  *pre_label_string,
-                 const char  *post_label_string,
-                 float        scale_data,
-                 UINT         options,
-                 fgLabelJust  justification,
-                 int          font_size,
-                 int          blinking,
-                 bool		  latitude,
-                 bool		  longitude,
-                 bool		  label_box,
-                 bool         working,
-                 int          digit ); //suma);
-
-    ~instr_label();
-
-    instr_label( const instr_label & image);
-    instr_label & operator = (const instr_label & rhs );
-    virtual void draw( void );       // Required method in base class
-};
-
-typedef instr_label * pInstlabel;
-
-
-class lat_label : public instr_item {
-private:
-    const char *pformat;
-    const char *pre_str;
-    const char *post_str;
+    const char  *pformat;
+    
     fgLabelJust justify;
     int         fontSize;
     int         blink;
-    char format_buffer[80];
+    string      format_buffer;
+    bool        lat;
+    bool        lon;
+    bool        lbox;
+    SGPropertyNode_ptr lon_node;
+    SGPropertyNode_ptr lat_node;
 
 public:
-    lat_label( int          x,
-               int          y,
-               UINT         width,
-               UINT         height,
-               FLTFNPTR     data_source,
-               const char  *label_format,
-               const char  *pre_label_string,
-               const char  *post_label_string,
-               float       scale_data,
-               UINT         options,
-               fgLabelJust  justification,
-               int          font_size,
-               int          blinking,
-               bool         working,
-               int	    digits =0 );//suma
-
-    ~lat_label();
-
-    lat_label( const lat_label & image);
-    lat_label & operator = (const lat_label & rhs );
-    virtual void draw( void );       // Required method in base class
+    instr_label(const SGPropertyNode *);
+    virtual void draw(void);
 };
 
-typedef lat_label * pLatlabel;
 
-class lon_label : public instr_item {
+//
+// fgRunway_instr   This class is responsible for rendering the active runway
+//                  in the hud (if visible).
+class runway_instr : public instr_item {
 private:
-    const char *pformat;
-    const char *pre_str;
-    const char *post_str;
-    fgLabelJust justify;
-    int         fontSize;
-    int         blink;
-    char format_buffer[80];
+        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(void);
+
+        sgdVec3 points3d[6], points2d[6];
+        double mm[16],pm[16], arrowScale, arrowRad, lnScale;
+        double scaleDist, default_pitch, default_heading;
+        GLint view[4];
+        FGRunway* runway;
+        FGViewer* cockpit_view;
+        unsigned short stippleOut, stippleCen;
+        bool drawIA, drawIAAlways;
+        RECT location;
+        POINT center;
 
 public:
-    lon_label( int          x,
-               int          y,
-               UINT         width,
-               UINT         height,
-               FLTFNPTR     data_source,
-               const char  *label_format,
-               const char  *pre_label_string,
-               const char  *post_label_string,
-               float       scale_data,
-               UINT         options,
-               fgLabelJust  justification,
-               int          font_size,
-               int          blinking,
-               bool         working,
-               int	    digit=0); //suma
-
-
-    ~lon_label();
-
-    lon_label( const lon_label & image);
-    lon_label & operator = (const lon_label & rhs );
-    virtual void draw( void );       // Required method in base class
-};
-
-typedef lon_label * pLonlabel;
-
-//
-// fgRunway_instr	This class is responsible for rendering the active runway
-//			in the hud (if visible).
-class runway_instr : public instr_item 
-{
-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();
-	bool get_active_runway(FGRunway& rwy);
-	void get_rwy_points(sgdVec3 *points);
-	void setLineWidth(void);
-
-	sgdVec3 points3d[6],points2d[6];
-	double mm[16],pm[16], arrowScale, arrowRad, lnScale, scaleDist, default_pitch, default_heading;
-	GLint view[4];
-	FGRunway runway;
-	FGViewer* cockpit_view;	
-	unsigned short stippleOut,stippleCen;
-	bool drawIA,drawIAAlways;
-	RECT location;
-	POINT center; 
-	
-public:
-    runway_instr( int    x,
-                  int    y,			
-				  int	 width,
-				  int    height,
-               	  float  scale_data,
-               	  bool   working = true);
+    runway_instr(const SGPropertyNode *);
 
-    virtual void draw( void );       // Required method in base class
-	void setArrowRotationRadius(double radius);
-	void setArrowScale(double scale); // Scales the runway indication arrow
-	void setDrawArrow(bool draw);	 // Draws arrow when runway is not visible in HUD if draw=true
-	void setDrawArrowAlways(bool draw); //Always draws arrow if draw=true;
-	void setLineScale(double scale); //Sets the maximum line scale
-	void setScaleDist(double dist_nm); //Sets the distance where to start scaling the lines
-	void setStippleOutline(unsigned short stipple); //Sets the stipple pattern of the outline of the runway
-	void setStippleCenterline(unsigned short stipple); //Sets the stipple patter of the center line of the runway
+    virtual void draw( void );
+    void setArrowRotationRadius(double radius);
+    // Scales the runway indication arrow
+    void setArrowScale(double scale);
+    // Draws arrow when runway is not visible in HUD if draw=true
+    void setDrawArrow(bool draw);
+    // Always draws arrow if draw=true;
+    void setDrawArrowAlways(bool draw);
+    // Sets the maximum line scale
+    void setLineScale(double scale);
+    // Sets the distance where to start scaling the lines
+    void setScaleDist(double dist_nm);
+    // Sets the stipple pattern of the outline of the runway
+    void setStippleOutline(unsigned short stipple);
+    // Sets the stipple patter of the center line of the runway
+    void setStippleCenterline(unsigned short stipple);
 };
 
 
@@ -750,134 +528,74 @@ public:
                  UINT         height,
                  FLTFNPTR     load_fn,
                  UINT         options,
-                 float       show_range,
-                 float       max_value,
-                 float       min_value,
-                 float       disp_scaling,
+                 float        show_range,
+                 float        max_value,
+                 float        min_value,
+                 float        disp_scaling,
                  UINT         major_divs,
                  UINT         minor_divs,
                  UINT         rollover,
                  int          dp_showing,
                  bool         working = true);
 
-    virtual ~instr_scale();
-    instr_scale( const instr_scale & image);
-    instr_scale & operator = (const instr_scale & rhs);
-
-    virtual void draw   ( void ) {}; // No-op here. Defined in derived classes.
-    UINT   div_min      ( void ) { return Min_div;}
-    UINT   div_max      ( void ) { return Maj_div;}
-    float min_val      ( void ) { return Minimum_value;}
-    float max_val      ( void ) { return Maximum_value;}
-    UINT   modulo       ( void ) { return Modulo; }
-    float factor       ( void ) { return scale_factor;}
-    float range_to_show( void ) { return range_shown;}
+    virtual void draw    ( void ) {}; // No-op here. Defined in derived classes.
+    UINT   div_min       ( void ) { return Min_div;}
+    UINT   div_max       ( void ) { return Maj_div;}
+    float  min_val       ( void ) { return Minimum_value;}
+    float  max_val       ( void ) { return Maximum_value;}
+    UINT   modulo        ( void ) { return Modulo; }
+    float  factor        ( void ) { return scale_factor;}
+    float  range_to_show ( void ) { return range_shown;}
 };
 
-// hud_card_               This class displays the indicated quantity on
+// hud_card                This class displays the indicated quantity on
 //                         a scale that moves past the pointer. It may be
 // horizontal or vertical, read above(left) or below(right) of the base
 // line.
 
 class hud_card : public instr_scale {
 private:
-    float val_span;
+    float  val_span;
     string type;
-    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;
-    bool  pointer;
-    string  pointer_type;
-    string  tick_type;
-    string  tick_length;
-    float   radius; //suma
-    float   maxValue; //suma
-    float   minValue; //suma
-    int		divisions; //suma
-    int     zoom; //suma
-    UINT	Maj_div; //suma
-    UINT	Min_div; //suma
-	
-    
+    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;
+    bool   pointer;
+    string pointer_type;
+    string tick_type;
+    string tick_length;
+    float  radius;
+    float  maxValue;
+    float  minValue;
+    int    divisions;
+    int    zoom;
+    UINT   Maj_div;
+    UINT   Min_div;
+
 public:
-    hud_card( int      x,
-              int      y,
-              UINT     width,
-              UINT     height,
-              FLTFNPTR load_fn,
-              UINT     options,
-              float    maxValue,
-              float    minValue,
-              float    disp_scaling,
-              UINT     major_divs,
-              UINT     minor_divs,
-              UINT     modulator,
-              int      dp_showing,
-              float    value_span,
-	      string   type,
-	      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,
-	      bool     pointer,
-	      string   pointer_type,
-              string  tick_type,
-              string  tick_length,
-              bool     working,
-              float    radius, //suma
-              int      divisions, //suma
-              int       zoom //suma
-            );
-
-
-    ~hud_card();
-    hud_card( const hud_card & image);
-    hud_card & operator = (const hud_card & rhs );
-    //    virtual void display_enable( bool setting );
-    virtual void draw( void );       // Required method in base class
-    void circles(float,float,float); // suma
-    void fixed(float,float,float,float,float,float); //suma
-    void zoomed_scale(int,int); //suma
+    hud_card(const SGPropertyNode *);
+    //    virtual void display_enable( bool setting );			// FIXME
+    virtual void draw(void);
+    void circles(float, float, float);
+    void fixed(float, float, float, float, float, float);
+    void zoomed_scale(int, int);
 };
 
-typedef hud_card * pCardScale;
 
 class gauge_instr : public instr_scale {
 public:
-    gauge_instr( int       x,
-                 int       y,
-                 UINT      width,
-                 UINT      height,
-                 FLTFNPTR  load_fn,
-                 UINT      options,
-                 float     disp_scaling,
-                 float     maxValue,
-                 float     minValue,
-                 UINT      major_divs,
-                 UINT      minor_divs,
-                 int       dp_showing,
-                 UINT      modulus,
-                 bool      working);
-
-    ~gauge_instr();
-    gauge_instr( const gauge_instr & image);
-    gauge_instr & operator = (const gauge_instr & rhs );
+    gauge_instr(const SGPropertyNode *);
     virtual void draw( void );       // Required method in base class
 };
 
-typedef gauge_instr * pGaugeInst;
+
 //
 // dual_instr_item         This class was created to form the base class
 //                         for both panel and HUD Turn Bank Indicators.
@@ -896,50 +614,29 @@ public:
                       bool      working,
                       UINT      options );
 
-    virtual ~dual_instr_item() {};
-    dual_instr_item( const dual_instr_item & image);
-    dual_instr_item & operator = (const dual_instr_item & rhs );
-
-    float current_ch1( void ) { return (float)alt_data_source();}
-    float current_ch2( void ) { return (float)get_value();}
-    virtual void draw ( void ) { }
+    float current_ch1( void ) { return (float)alt_data_source(); }
+    float current_ch2( void ) { return (float)get_value(); }
+    virtual void draw( void ) {}
 };
 
-class fgTBI_instr : public dual_instr_item 
-{
+
+class fgTBI_instr : public dual_instr_item {
 private:
     UINT BankLimit;
     UINT SlewLimit;
     UINT scr_hole;
-    bool tsi;  //suma
-    float rad; //suma
+    bool tsi;
+    float rad;
 
 public:
-    fgTBI_instr( int       x,
-                 int       y,
-                 UINT      width,
-                 UINT      height,
-                 FLTFNPTR  chn1_source,
-                 FLTFNPTR  chn2_source,
-                 float    maxBankAngle,
-                 float    maxSlipAngle,
-                 UINT      gap_width,
-                 bool      working,
-                 bool	   tsi, //suma
-                 float     rad); //suma
-
-    fgTBI_instr( const fgTBI_instr & image);
-    fgTBI_instr & operator = (const fgTBI_instr & rhs );
-
-    ~fgTBI_instr();
-
-    UINT bank_limit( void ) { return BankLimit;}
-    UINT slew_limit( void ) { return SlewLimit;}
+    fgTBI_instr(const SGPropertyNode *);
 
-    virtual void draw( void );       // Required method in base class
+    UINT bank_limit(void) { return BankLimit; }
+    UINT slew_limit(void) { return SlewLimit; }
+
+    virtual void draw(void);
 };
 
-typedef fgTBI_instr * pTBI;
 
 class HudLadder : public dual_instr_item {
 private:
@@ -957,16 +654,15 @@ private:
     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;
-    int     zenith; //suma
-    int     nadir; //suma
-    int		hat; //suma
-    
+    bool   energy_marker;
+    bool   climb_dive_marker;
+    bool   glide_slope_marker;
+    float  glide_slope;
+    bool   energy_worm;
+    bool   waypoint_marker;
+    int    zenith;
+    int    nadir;
+    int    hat;
 
     // The Ladder has it's own temporary display lists
     fgTextList         TextList;
@@ -974,83 +670,61 @@ private:
     fgLineList         StippleLineList;
 
 public:
-    HudLadder( const string&    name,
-	       int       x,
-               int       y,
-               UINT      width,
-               UINT      height,
-	       float	 factor,
-               FLTFNPTR  ptch_source,
-               FLTFNPTR  roll_source,
-               float     span_units,
-               float     division_units,
-               float     minor_division,
-               UINT      screen_hole,
-               UINT      lbl_pos,
-	       bool	 frl,
-	       bool	 target_spot,
-	       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  working,
-               int   zenith, //suma
-               int   nadir, //suma
-               int      hat
-             ); //suma
-
-
-    ~HudLadder();
-
-    HudLadder( const HudLadder & image );
-    HudLadder & operator = ( const HudLadder & rhs );
-    virtual void draw( void );
-    void drawZenith(float,float,float); //suma
-    void drawNadir(float, float, float); //suma
+    HudLadder(const SGPropertyNode *);
+
+    virtual void draw(void);
+    void drawZenith(float, float, float);
+    void drawNadir(float, float, float);
 
-    void Text( float x, float y, char *s)
+    void Text(float x, float y, char *s)
     {
-        TextList.add( fgText( x, y, s) );
+        TextList.add(fgText(x, y, s));
     }
 
-    void Line( float x1, float y1, float x2, float y2)
+    void Line(float x1, float y1, float x2, float y2)
     {
-        LineList.add(fgLineSeg2D(x1,y1,x2,y2));
+        LineList.add(fgLineSeg2D(x1, y1, x2, y2));
     }
 
-    void StippleLine( float x1, float y1, float x2, float y2)
+    void StippleLine(float x1, float y1, float x2, float y2)
     {
-        StippleLineList.add(fgLineSeg2D(x1,y1,x2,y2));
+        StippleLineList.add(fgLineSeg2D(x1, y1, x2, y2));
     }
 };
 
 
-//using namespace std;
-//deque <instr_item>  * Hdeque_ptr;
-
-extern void HUD_masterswitch( bool incr );
-extern void HUD_brightkey( bool incr_bright );
-extern int  fgHUDInit( fgAIRCRAFT * /* current_aircraft */ );
-extern int  fgHUDInit2( fgAIRCRAFT * /* current_aircraft */ );
-extern void fgUpdateHUD( void );
-extern void fgUpdateHUD( GLfloat x_start, GLfloat y_start,
+extern int  fgHUDInit();
+extern int  fgHUDInit2();
+extern void fgUpdateHUD( osg::State* );
+extern void fgUpdateHUD( osg::State*, GLfloat x_start, GLfloat y_start,
                          GLfloat x_end, GLfloat y_end );
 
-/*
-bool AddHUDInstrument( instr_item *pBlackBox );
-void DrawHUD ( void );
-bool DamageInstrument( INSTR_HANDLE unit );
-bool RepairInstrument( INSTR_HANDLE unit );
 
 
-void fgUpdateHUD ( Hptr hud );
-void fgUpdateHUD2( Hptr hud ); // Future use?
-void fgHUDSetTimeMode( Hptr hud, int time_of_day );
-*/
 
-#endif // _HUD_H
+class HUD_Properties : public SGPropertyChangeListener {
+public:
+    HUD_Properties();
+    void valueChanged(SGPropertyNode *n);
+    void setColor() const;
+    bool isVisible() const { return _visible; }
+    bool isAntialiased() const { return _antialiased; }
+    bool isTransparent() const { return _transparent; }
+    float alphaClamp() const { return _cl; }
+
+private:
+    float clamp(float f) { return f < 0.0f ? 0.0f : f > 1.0f ? 1.0f : f; }
+    SGPropertyNode_ptr _current;
+    SGPropertyNode_ptr _visibility;
+    SGPropertyNode_ptr _antialiasing;
+    SGPropertyNode_ptr _transparency;
+    SGPropertyNode_ptr _red, _green, _blue, _alpha;
+    SGPropertyNode_ptr _alpha_clamp;
+    SGPropertyNode_ptr _brightness;
+    bool _visible;
+    bool _antialiased;
+    bool _transparent;
+    float _r, _g, _b, _a, _cl;
+};
+
+#endif // _OLDHUD_H