X-Git-Url: https://git.mxchange.org/?a=blobdiff_plain;f=src%2FCockpit%2Fhud_ladr.cxx;h=38def8d9d7c85b4c13b1d2d7bc59c0232f46a1e4;hb=13ec36af4218402eda39c680e8da6ca2c198733c;hp=e4ae0c115d46da9bc74e0866223c63410facfd36;hpb=a74e2059300a053e0667a4039412923fb1e70a54;p=flightgear.git

diff --git a/src/Cockpit/hud_ladr.cxx b/src/Cockpit/hud_ladr.cxx
index e4ae0c115..38def8d9d 100644
--- a/src/Cockpit/hud_ladr.cxx
+++ b/src/Cockpit/hud_ladr.cxx
@@ -1,252 +1,785 @@
 #ifdef HAVE_CONFIG_H
-#  include <config.h>
+#  include "config.h"
 #endif
 
-#ifdef HAVE_WINDOWS_H
-#  include <windows.h>
-#endif
+#include <simgear/constants.h>
 
-#include <stdlib.h>
-#include <string.h>
+#include "hud.hxx"
+#include "panel.hxx"
+#include <Main/viewer.hxx>
 
-#include <simgear/constants.h>
-#include <simgear/math/fg_random.h>
-#include <simgear/math/polar3d.hxx>
+// FIXME
+extern float get_roll(void);
+extern float get_pitch(void);
 
-#include <Aircraft/aircraft.hxx>
-#include <Scenery/scenery.hxx>
-#include <Time/fg_timer.hxx>
-#include <GUI/gui.h>
 
-#include "hud.hxx"
+HudLadder::HudLadder(const SGPropertyNode *node) :
+    dual_instr_item(
+            node->getIntValue("x"),
+            node->getIntValue("y"),
+            node->getIntValue("width"),
+            node->getIntValue("height"),
+            get_roll,
+            get_pitch,				// FIXME getter functions from cockpit.cxx
+            node->getBoolValue("working", true),
+            HUDS_RIGHT),
+    width_units(int(node->getFloatValue("span_units"))),
+    div_units(int(fabs(node->getFloatValue("division_units")))),
+    minor_div(0 /* hud.cxx: static float minor_division = 0 */),
+    label_pos(node->getIntValue("lbl_pos")),
+    scr_hole(node->getIntValue("screen_hole")),
+    factor(node->getFloatValue("compression_factor")),
+    hudladder_type(node->getStringValue("name")),
+    frl(node->getBoolValue("enable_frl", false)),
+    target_spot(node->getBoolValue("enable_target_spot", false)),
+    velocity_vector(node->getBoolValue("enable_velocity_vector", false)),
+    drift_marker(node->getBoolValue("enable_drift_marker", false)),
+    alpha_bracket(node->getBoolValue("enable_alpha_bracket", false)),
+    energy_marker(node->getBoolValue("enable_energy_marker", false)),
+    climb_dive_marker(node->getBoolValue("enable_climb_dive_marker", false)),
+    glide_slope_marker(node->getBoolValue("enable_glide_slope_marker",false)),
+    glide_slope(node->getFloatValue("glide_slope", -4.0)),
+    energy_worm(node->getBoolValue("enable_energy_marker", false)),
+    waypoint_marker(node->getBoolValue("enable_waypoint_marker", false)),
+    zenith(node->getIntValue("zenith")),
+    nadir(node->getIntValue("nadir")),
+    hat(node->getIntValue("hat"))
+{
+    // The factor assumes a base of 55 degrees per 640 pixels.
+    // Invert to convert the "compression" factor to a
+    // pixels-per-degree number.
+    if (fgGetBool("/sim/hud/enable3d", true) && HUD_style == 1)
+        factor = 640.0 / 55.0;
+
+    SG_LOG(SG_INPUT, SG_INFO, "Done reading HudLadder instrument"
+            << node->getStringValue("name", "[unnamed]"));
+
+    if (!width_units)
+        width_units = 45;
+
+    vmax = width_units / 2;
+    vmin = -vmax;
+}
+
 
-#define DO_PANEL_HACK
-
-//====================== Top of HudLadder Class =======================
-HudLadder ::   HudLadder(  int       x,
-               int       y,
-               UINT      width,
-               UINT      height,
-               UINT      mini,
-               FLTFNPTR  ptch_source,
-               FLTFNPTR  roll_source,
-               float    span_units,
-               float    major_div,
-               float    minor_div,
-               UINT      screen_hole,
-               UINT      lbl_pos,
-               bool      working) :
-   dual_instr_item( x, y, width, height,
-                    ptch_source,
-                    roll_source,
-                    working,
-                    HUDS_RIGHT),
-                    width_units    ( (int)(span_units)   ),
-                    div_units      ( (int)(major_div < 0? -major_div: major_div) ),
-                    minor_div      ( (int)(minor_div)    ),
-                    label_pos      ( lbl_pos      ),
-                    scr_hole       ( screen_hole  ),
-                    vmax           ( span_units/2 ),
-                    vmin           ( -vmax        )
-   {
-       if( !width_units ) {
-           width_units = 45;
-       }
-       factor = (float)get_span() / (float) width_units;
-       minimal = mini;
-   }
-   
-HudLadder ::  ~HudLadder()
-    {
-    }
-           
-    HudLadder ::
-            HudLadder( const HudLadder & image ) :
-            dual_instr_item( (dual_instr_item &) image),
-            width_units    ( image.width_units   ),
-            div_units      ( image.div_units     ),
-            label_pos      ( image.label_pos     ),
-            scr_hole       ( image.scr_hole      ),
-            vmax           ( image.vmax ),
-            vmin           ( image.vmin ),
-            factor         ( image.factor        )
-    {
-    }
-HudLadder & HudLadder ::  operator = ( const HudLadder & rhs )
-    {
-        if( !(this == &rhs)) {
-            (dual_instr_item &)(*this) = (dual_instr_item &)rhs;
-            width_units  = rhs.width_units;
-            div_units    = rhs.div_units;
-            label_pos    = rhs.label_pos;
-            scr_hole     = rhs.scr_hole;
-            vmax         = rhs.vmax;
-            vmin         = rhs.vmin;
-            factor       = rhs.factor;
-        }
-        return *this;
-    }
-                           
 //
 //  Draws a climb ladder in the center of the HUD
 //
 
-void HudLadder :: draw( void )
+void HudLadder::draw(void)
 {
-    POINT  centroid    = get_centroid();
-	
-    float   roll_value = current_ch2();
-    
+
+    float x_ini, x_ini2;
+    float x_end, x_end2;
+    float y = 0;
+    int count;
+    float cosine, sine, xvvr, yvvr, Vxx = 0.0, Vyy = 0.0, Vzz = 0.0;
+    float up_vel, ground_vel, actslope = 0.0;
+    float Axx = 0.0, Ayy = 0.0, Azz = 0.0, total_vel = 0.0, pot_slope, t1;
+    float t2 = 0.0, psi = 0.0, alpha, pla;
+    float vel_x = 0.0, vel_y = 0.0, drift;
+    bool pitch_ladder = false;
+    bool climb_dive_ladder = false;
+    bool clip_plane = false;
+
+    GLdouble eqn_top[4] = {0.0, -1.0, 0.0, 0.0};
+    GLdouble eqn_left[4] = {-1.0, 0.0, 0.0, 100.0};
+    GLdouble eqn_right[4] = {1.0, 0.0, 0.0, 100.0};
+
+    POINT centroid = get_centroid();
+    RECT box = get_location();
+
+    float half_span  = box.right / 2.0;
+    float roll_value = current_ch2();
+    alpha = get_aoa();
+    pla = get_throttleval();
+
+#ifdef ENABLE_SP_FDM
+    int lgear, wown, wowm, ilcanclaw, ihook;
+    ilcanclaw = get_iaux2();
+    lgear = get_iaux3();
+    wown = get_iaux4();
+    wowm = get_iaux5();
+    ihook = get_iaux6();
+#endif
+    float pitch_value = current_ch1() * SGD_RADIANS_TO_DEGREES;
+
+    if (hudladder_type == "Climb/Dive Ladder") {
+        pitch_ladder = false;
+        climb_dive_ladder = true;
+        clip_plane = true;
+
+    } else { // hudladder_type == "Pitch Ladder"
+        pitch_ladder = true;
+        climb_dive_ladder = false;
+        clip_plane = false;
+    }
+
+    //**************************************************************
     glPushMatrix();
-    glTranslatef( centroid.x, centroid.y, 0);
-	// Alex's panel patch
-//	glScalef( current_options.get_fov()/55.0, 1.0, 1.0 );
-    glRotatef(roll_value * RAD_TO_DEG, 0.0, 0.0, 1.0);
+    // define (0, 0) as center of screen
+    glTranslatef(centroid.x, centroid.y, 0);
+
+    // OBJECT STATIC RETICLE
+    // TYPE FRL
+    // ATTRIB - ALWAYS
+    // Draw the FRL spot and line
+    if (frl) {
+#define FRL_DIAMOND_SIZE 2.0
+        glBegin(GL_LINE_LOOP);
+        glVertex2f(-FRL_DIAMOND_SIZE, 0.0);
+        glVertex2f(0.0, FRL_DIAMOND_SIZE);
+        glVertex2f(FRL_DIAMOND_SIZE, 0.0);
+        glVertex2f(0.0, -FRL_DIAMOND_SIZE);
+        glEnd();
 
+        glBegin(GL_LINE_STRIP);
+        glVertex2f(0, FRL_DIAMOND_SIZE);
+        glVertex2f(0, 8.0);
+        glEnd();
+#undef FRL_DIAMOND_SIZE
+    }
+    // TYPE WATERLINE_MARK (W shaped _    _ )
+    //                                    \/\/
+
+    //****************************************************************
+    // TYPE TARGET_SPOT
     // Draw the target spot.
-#define CENTER_DIAMOND_SIZE 6.0f
-	
-    glBegin(GL_LINE_LOOP);
-        glVertex2f( CENTER_DIAMOND_SIZE, 0.0);
-        glVertex2f( 0.0, CENTER_DIAMOND_SIZE);
-        glVertex2f( -CENTER_DIAMOND_SIZE, 0.0);
-        glVertex2f( 0.0, -CENTER_DIAMOND_SIZE);
-    glEnd();
-
-    if( minimal || ! div_units ) {
-        glPopMatrix();      
-        return;
+    if (target_spot) {
+#define CENTER_DIAMOND_SIZE 6.0
+        glBegin(GL_LINE_LOOP);
+        glVertex2f(-CENTER_DIAMOND_SIZE, 0.0);
+        glVertex2f(0.0, CENTER_DIAMOND_SIZE);
+        glVertex2f(CENTER_DIAMOND_SIZE, 0.0);
+        glVertex2f(0.0, -CENTER_DIAMOND_SIZE);
+        glEnd();
+#undef CENTER_DIAMOND_SIZE
+    }
+
+    //****************************************************************
+    //velocity vector reticle - computations
+    if (velocity_vector) {
+        Vxx = get_Vx();
+        Vyy = get_Vy();
+        Vzz = get_Vz();
+        Axx = get_Ax();
+        Ayy = get_Ay();
+        Azz = get_Az();
+        psi = get_heading();
+
+        if (psi > 180.0)
+            psi = psi - 360;
+
+        total_vel = sqrt(Vxx * Vxx + Vyy * Vyy + Vzz * Vzz);
+        ground_vel = sqrt(Vxx * Vxx + Vyy * Vyy);
+        up_vel = Vzz;
+
+        if (ground_vel < 2.0) {
+            if (fabs(up_vel) < 2.0)
+                actslope = 0.0;
+            else
+                actslope = (up_vel / fabs(up_vel)) * 90.0;
+
+        } else {
+            actslope = atan(up_vel / ground_vel) * SGD_RADIANS_TO_DEGREES;
+        }
+
+        xvvr = (((atan2(Vyy, Vxx) * SGD_RADIANS_TO_DEGREES) - psi)
+                * (factor / globals->get_current_view()->get_aspect_ratio()));
+        drift = ((atan2(Vyy, Vxx) * SGD_RADIANS_TO_DEGREES) - psi);
+        yvvr = ((actslope - pitch_value) * factor);
+        vel_y = ((actslope - pitch_value) * cos(roll_value) + drift * sin(roll_value)) * factor;
+        vel_x = (-(actslope - pitch_value) * sin(roll_value) + drift * cos(roll_value))
+                * (factor/globals->get_current_view()->get_aspect_ratio());
+        //  printf("%f %f %f %f\n",vel_x, vel_y, drift, psi);
+
+        //****************************************************************
+        // OBJECT MOVING RETICLE
+        // TYPE - DRIFT MARKER
+        // ATTRIB - ALWAYS
+        // drift marker
+        if (drift_marker) {
+            glBegin(GL_LINE_STRIP);
+            glVertex2f((xvvr * 25 / 120) - 6, -4);
+            glVertex2f(xvvr * 25 / 120, 8);
+            glVertex2f((xvvr * 25 / 120) + 6, -4);
+            glEnd();
+        }
+
+        //****************************************************************
+        // Clipping coordinates for ladder to be input from xml file
+        // Clip hud ladder
+        if (clip_plane) {
+            glClipPlane(GL_CLIP_PLANE0, eqn_top);
+            glEnable(GL_CLIP_PLANE0);
+            glClipPlane(GL_CLIP_PLANE1, eqn_left);
+            glEnable(GL_CLIP_PLANE1);
+            glClipPlane(GL_CLIP_PLANE2, eqn_right);
+            glEnable(GL_CLIP_PLANE2);
+            // glScissor(-100,-240, 200, 240);
+            // glEnable(GL_SCISSOR_TEST);
+        }
+
+        //****************************************************************
+        // OBJECT MOVING RETICLE
+        // TYPE VELOCITY VECTOR
+        // ATTRIB - ALWAYS
+        // velocity vector
+        glBegin(GL_LINE_LOOP);  // Use polygon to approximate a circle
+        for (count = 0; count < 50; count++) {
+            cosine = 6 * cos(count * SGD_2PI / 50.0);
+            sine =   6 * sin(count * SGD_2PI / 50.0);
+            glVertex2f(cosine + vel_x, sine + vel_y);
+        }
+        glEnd();
+
+        //velocity vector reticle orientation lines
+        glBegin(GL_LINE_STRIP);
+        glVertex2f(vel_x - 12, vel_y);
+        glVertex2f(vel_x - 6, vel_y);
+        glEnd();
+        glBegin(GL_LINE_STRIP);
+        glVertex2f(vel_x + 12, vel_y);
+        glVertex2f(vel_x + 6, vel_y);
+        glEnd();
+        glBegin(GL_LINE_STRIP);
+        glVertex2f(vel_x, vel_y + 12);
+        glVertex2f(vel_x, vel_y + 6);
+        glEnd();
+
+#ifdef ENABLE_SP_FDM
+        // OBJECT MOVING RETICLE
+        // TYPE LINE
+        // ATTRIB - ON CONDITION
+        if (lgear == 1) {
+            // undercarriage status
+            glBegin(GL_LINE_STRIP);
+            glVertex2f(vel_x + 8, vel_y);
+            glVertex2f(vel_x + 8, vel_y - 4);
+            glEnd();
+
+            // OBJECT MOVING RETICLE
+            // TYPE LINE
+            // ATTRIB - ON CONDITION
+            glBegin(GL_LINE_STRIP);
+            glVertex2f(vel_x - 8, vel_y);
+            glVertex2f(vel_x - 8, vel_y - 4);
+            glEnd();
+
+            // OBJECT MOVING RETICLE
+            // TYPE LINE
+            // ATTRIB - ON CONDITION
+            glBegin(GL_LINE_STRIP);
+            glVertex2f(vel_x, vel_y - 6);
+            glVertex2f(vel_x, vel_y - 10);
+            glEnd();
+        }
+
+        // OBJECT MOVING RETICLE
+        // TYPE V
+        // ATTRIB - ON CONDITION
+        if (ihook == 1) {
+            // arrestor hook status
+            glBegin(GL_LINE_STRIP);
+            glVertex2f(vel_x - 4, vel_y - 8);
+            glVertex2f(vel_x, vel_y - 10);
+            glVertex2f(vel_x + 4, vel_y - 8);
+            glEnd();
+        }
+#endif
+    } // if velocity_vector
+
+
+    //***************************************************************
+    // OBJECT MOVING RETICLE
+    // TYPE - SQUARE_BRACKET
+    // ATTRIB - ON CONDITION
+    // alpha bracket
+#ifdef ENABLE_SP_FDM
+    if (alpha_bracket && ihook == 1) {
+        glBegin(GL_LINE_STRIP);
+        glVertex2f(vel_x - 20 , vel_y - (16 - alpha) * factor);
+        glVertex2f(vel_x - 17, vel_y - (16 - alpha) * factor);
+        glVertex2f(vel_x - 17, vel_y - (14 - alpha) * factor);
+        glVertex2f(vel_x - 20, vel_y - (14 - alpha) * factor);
+        glEnd();
+
+        glBegin(GL_LINE_STRIP);
+        glVertex2f(vel_x + 20 , vel_y - (16 - alpha) * factor);
+        glVertex2f(vel_x + 17, vel_y - (16 - alpha) * factor);
+        glVertex2f(vel_x + 17, vel_y - (14 - alpha) * factor);
+        glVertex2f(vel_x + 20, vel_y - (14 - alpha) * factor);
+        glEnd();
+    }
+#endif
+    //printf("xvr=%f, yvr=%f, Vx=%f, Vy=%f, Vz=%f\n",xvvr, yvvr, Vx, Vy, Vz);
+    //printf("Ax=%f, Ay=%f, Az=%f\n",Ax, Ay, Az);
+
+    //****************************************************************
+    // OBJECT MOVING RETICLE
+    // TYPE ENERGY_MARKERS
+    // ATTRIB - ALWAYS
+    //energy markers - compute potential slope
+    if (energy_marker) {
+        if (total_vel < 5.0) {
+            t1 = 0;
+            t2 = 0;
+        } else {
+            t1 = up_vel / total_vel;
+            t2 = asin((Vxx * Axx + Vyy * Ayy + Vzz * Azz) / (9.81 * total_vel));
+        }
+        pot_slope = ((t2 / 3) * SGD_RADIANS_TO_DEGREES) * factor + vel_y;
+        // if (pot_slope < (vel_y - 45)) pot_slope = vel_y - 45;
+        // if (pot_slope > (vel_y + 45)) pot_slope = vel_y + 45;
+
+        //energy markers
+        glBegin(GL_LINE_STRIP);
+        glVertex2f(vel_x - 20, pot_slope - 5);
+        glVertex2f(vel_x - 15, pot_slope);
+        glVertex2f(vel_x - 20, pot_slope + 5);
+        glEnd();
+
+        glBegin(GL_LINE_STRIP);
+        glVertex2f(vel_x + 20, pot_slope - 5);
+        glVertex2f(vel_x + 15, pot_slope);
+        glVertex2f(vel_x + 20, pot_slope + 5);
+        glEnd();
+
+        if (pla > (105.0 / 131.0)) {
+            glBegin(GL_LINE_STRIP);
+            glVertex2f(vel_x - 24, pot_slope - 5);
+            glVertex2f(vel_x - 19, pot_slope);
+            glVertex2f(vel_x - 24, pot_slope + 5);
+            glEnd();
+
+            glBegin(GL_LINE_STRIP);
+            glVertex2f(vel_x + 24, pot_slope - 5);
+            glVertex2f(vel_x + 19, pot_slope);
+            glVertex2f(vel_x + 24, pot_slope + 5);
+            glEnd();
+        }
     }
 
-	float  x_ini;
-	float  x_end;
-	float  y;
-
-	float pitch_value = current_ch1() * RAD_TO_DEG;
-	vmin              = pitch_value - (float)width_units * 0.5f;
-	vmax              = pitch_value + (float)width_units * 0.5f;
-
-	RECT   box         = get_location();
-
-	float   half_span  = box.right * 0.5f ;
-
-	char     TextLadder[8] ;
-	float    label_length ;
-	float    label_height ;
-	float    left ;
-	float    right ;
-	float    bot ;
-	float    top ;
-	float    text_offset = 4.0f ;
-	float    zero_offset = 10.0f ;
-	
-	fntFont *font      = HUDtext->getFont();
-	float    pointsize = HUDtext->getPointSize();
-	float    italic    = HUDtext->getSlant();
-	
-	TextList.setFont( HUDtext );
-	TextList.erase();
-	LineList.erase();
-	StippleLineList.erase();
-	
-	int last = FloatToInt(vmax)+1;
-	int i    = FloatToInt(vmin);
-	
-	if( !scr_hole ) {
-		x_end =  half_span;
-		for( ; i<last ; i++ ) {
-                
-			y =  (((float)(i - pitch_value) * factor) + .5f);
-			if( !(i % div_units ))    {        //  At integral multiple of div
-                
-				sprintf( TextLadder, "%d", i );
-				font->getBBox ( TextLadder, pointsize, italic,
-								&left, &right, &bot, &top ) ;
-				
-				label_length  = right - left;
-				label_length += text_offset;
-				label_height  = (top - bot) * 0.5f;
-                
-				x_ini = -half_span;
-
-				if( i >= 0 ) {
-					// Make zero point wider on left
-					if( i == 0 )
-						x_ini -= zero_offset;
-					// Zero or above draw solid lines
-					Line(x_ini, y, x_end, y);
-				} else {
-					// Below zero draw dashed lines.
-					StippleLine(x_ini, y, x_end, y);
-				}
-                    
-				// Calculate the position of the left text and write it.
-				Text( x_ini-label_length, y-label_height, TextLadder );
-				Text( x_end+text_offset,  y-label_height, TextLadder );
-			}
-		}
-	} else	{ // scr_hole != 0
-		// Draw ladder with space in the middle of the lines
-		float  x_ini2;
-		float  x_end2;
-		float hole = (float)((scr_hole)*0.5f);
-		
-		x_end  = -half_span + hole;
-		x_ini2 =  half_span - hole;
-		
-		for( ; i<last ; i++ )      {
-                
-			y = (((float)(i - pitch_value) * factor) + .5);
-			if( !(i % div_units ))    {        //  At integral multiple of div
-                
-				sprintf( TextLadder, "%d", i );
-				font->getBBox ( TextLadder, pointsize, italic,
-								&left, &right, &bot, &top ) ;
-				label_length  = right - left;
-				label_length += text_offset;
-				label_height  = (top - bot) * 0.5f;
-                
-				// Start by calculating the points and drawing the
-				// left side lines.
-				x_ini  = -half_span;
-				x_end2 =  half_span;
-                    
-				if( i >= 0 ) { 
-					// Make zero point wider on left
-					if( i == 0 ) {
-						x_ini -= zero_offset;
-						x_end2 += zero_offset;
-					}
-					// Zero or above draw solid lines
-					Line(x_ini, y, x_end, y);
-					Line(x_ini2, y, x_end2, y);
-				} else {
-					// Below zero draw dashed lines.
-					StippleLine(x_ini,  y, x_end,  y);
-					StippleLine(x_ini2, y, x_end2, y);
-				}
-				// Calculate the location of the left side label using
-				Text( x_ini-label_length, y-label_height, TextLadder );
-				// Calculate the location and draw the right side label
-				Text( x_end2+text_offset, y-label_height, TextLadder );
-			}
-		}
-	}
-	TextList.draw();
-	
-	LineList.draw();
-
-	glEnable(GL_LINE_STIPPLE);
-#ifdef DO_PANEL_HACK
-	glLineStipple( 1, current_options.get_panel_status() ? 0x0F0F : 0x00FF );
-#else
-	glLineStipple( 1, 0x00FF );
+    //**********************************************************
+    // ramp reticle
+    // OBJECT STATIC RETICLE
+    // TYPE LINE
+    // ATTRIB - ON CONDITION
+#ifdef ENABLE_SP_FDM
+    if (energy_worm && ilcanclaw == 1) {
+        glBegin(GL_LINE_STRIP);
+        glVertex2f(-15, -134);
+        glVertex2f(15, -134);
+        glEnd();
+
+        // OBJECT MOVING RETICLE
+        // TYPE BOX
+        // ATTRIB - ON CONDITION
+        glBegin(GL_LINE_STRIP);
+        glVertex2f(-6, -134);
+        glVertex2f(-6, t2 * SGD_RADIANS_TO_DEGREES * 4.0 - 134);
+        glVertex2f(+6, t2 * SGD_RADIANS_TO_DEGREES * 4.0 - 134);
+        glVertex2f(6, -134);
+        glEnd();
+
+        // OBJECT MOVING RETICLE
+        // TYPE DIAMOND
+        // ATTRIB - ON CONDITION
+        glBegin(GL_LINE_LOOP);
+        glVertex2f(-6, actslope * 4.0 - 134);
+        glVertex2f(0, actslope * 4.0 -134 + 3);
+        glVertex2f(6, actslope * 4.0 - 134);
+        glVertex2f(0, actslope * 4.0 -134 -3);
+        glEnd();
+    }
+#endif
+
+    //*************************************************************
+    // OBJECT MOVING RETICLE
+    // TYPE DIAMOND
+    // ATTRIB - ALWAYS
+    // Draw the locked velocity vector.
+    if (climb_dive_marker) {
+        glBegin(GL_LINE_LOOP);
+        glVertex2f(-3.0, 0.0 + vel_y);
+        glVertex2f(0.0, 6.0 + vel_y);
+        glVertex2f(3.0, 0.0 + vel_y);
+        glVertex2f(0.0, -6.0 + vel_y);
+        glEnd();
+    }
+
+    //****************************************************************
+
+    if (climb_dive_ladder) { // CONFORMAL_HUD
+        vmin = pitch_value - (float)width_units;
+        vmax = pitch_value + (float)width_units;
+        glTranslatef(vel_x, vel_y, 0);
+
+    } else { // pitch_ladder - Default Hud
+        vmin = pitch_value - (float)width_units * 0.5f;
+        vmax = pitch_value + (float)width_units * 0.5f;
+    }
+
+    glRotatef(roll_value * SGD_RADIANS_TO_DEGREES, 0.0, 0.0, 1.0);
+    // FRL marker not rotated - this line shifted below
+
+    if (div_units) {
+        char  TextLadder[8];
+        float label_length;
+        float label_height;
+        float left;
+        float right;
+        float bot;
+        float top;
+        float text_offset = 4.0f;
+        float zero_offset = 0.0;
+
+        if (climb_dive_ladder)
+            zero_offset = 50.0f; // horizon line is wider by this much (hard coded ??)
+        else
+            zero_offset = 10.0f;
+
+        fntFont *font = HUDtext->getFont();			// FIXME
+        float pointsize = HUDtext->getPointSize();
+        float italic = HUDtext->getSlant();
+
+        TextList.setFont(HUDtext);
+        TextList.erase();
+        LineList.erase();
+        StippleLineList.erase();
+
+        int last = float_to_int(vmax) + 1;
+        int i = float_to_int(vmin);
+
+        if (!scr_hole) {
+            x_end = half_span;
+
+            for (; i<last; i++) {
+                y = (((float)(i - pitch_value) * factor) + .5f);
+
+                if (!(i % div_units)) {           //  At integral multiple of div
+                    sprintf(TextLadder, "%d", i);
+                    font->getBBox(TextLadder, pointsize, italic,
+                            &left, &right, &bot, &top);
+                    label_length = right - left;
+                    label_length += text_offset;
+                    label_height = (top - bot) / 2.0f;
+
+                    x_ini = -half_span;
+
+                    if (i >= 0) {
+                        // Make zero point wider on left
+                        if (i == 0)
+                            x_ini -= zero_offset;
+
+                        // Zero or above draw solid lines
+                        Line(x_ini, y, x_end, y);
+
+                        if (i == 90 && zenith == 1)
+                            drawZenith(x_ini, x_end, y);
+                    } else {
+                        // Below zero draw dashed lines.
+                        StippleLine(x_ini, y, x_end, y);
+
+                        if (i == -90 && nadir ==1)
+                            drawNadir(x_ini, x_end, y);
+                    }
+
+                    // Calculate the position of the left text and write it.
+                    Text(x_ini-label_length, y-label_height, TextLadder);
+                    Text(x_end+text_offset, y-label_height, TextLadder);
+                }
+            }
+
+        } else { // if (scr_hole)
+            // Draw ladder with space in the middle of the lines
+            float hole = (float)((scr_hole) / 2.0f);
+
+            x_end = -half_span + hole;
+            x_ini2 = half_span - hole;
+
+            for (; i < last; i++) {
+                if (hudladder_type == "Pitch Ladder")
+                    y = (((float)(i - pitch_value) * factor) + .5);
+                else if (hudladder_type == "Climb/Dive Ladder")
+                    y = (((float)(i - actslope) * factor) + .5);
+
+                if (!(i % div_units)) {  //  At integral multiple of div
+                    sprintf(TextLadder, "%d", i);
+                    font->getBBox(TextLadder, pointsize, italic,
+                            &left, &right, &bot, &top);
+                    label_length = right - left;
+                    label_length += text_offset;
+                    label_height = (top - bot) / 2.0f;
+                    // printf("l %f r %f b %f t %f\n",left, right, bot, top);
+
+                    // Start by calculating the points and drawing the
+                    // left side lines.
+                    x_ini = -half_span;
+                    x_end2 = half_span;
+
+                    if (i >= 0) {
+                        // Make zero point wider on left
+                        if (i == 0) {
+                            x_ini -= zero_offset;
+                            x_end2 += zero_offset;
+                        }
+                        //draw climb bar vertical lines
+                        if (climb_dive_ladder) {
+                            // Zero or above draw solid lines
+                            Line(x_end, y - 5.0, x_end, y);
+                            Line(x_ini2, y - 5.0, x_ini2, y);
+                        }
+                        // draw pitch / climb bar
+                        Line(x_ini, y, x_end, y);
+                        Line(x_ini2, y, x_end2, y);
+
+                        if (i == 90 && zenith == 1)
+                            drawZenith(x_ini2, x_end, y);
+
+                    } else { // i < 0
+                        // draw dive bar vertical lines
+                        if (climb_dive_ladder) {
+                            Line(x_end, y + 5.0, x_end, y);
+                            Line(x_ini2, y + 5.0, x_ini2, y);
+                        }
+
+                        // draw pitch / dive bars
+                        StippleLine(x_ini, y, x_end, y);
+                        StippleLine(x_ini2, y, x_end2, y);
+
+                        if (i == -90 && nadir == 1)
+                            drawNadir(x_ini2, x_end, y);
+                    }
+
+                    // Now calculate the location of the left side label using
+                    Text(x_ini-label_length, y - label_height, TextLadder);
+                    Text(x_end2+text_offset, y - label_height, TextLadder);
+                }
+            }
+
+            // OBJECT LADDER MARK
+            // TYPE LINE
+            // ATTRIB - ON CONDITION
+            // draw appraoch glide slope marker
+#ifdef ENABLE_SP_FDM
+            if (glide_slope_marker && ihook) {
+                Line(-half_span + 15, (glide_slope-actslope) * factor,
+                        -half_span + hole, (glide_slope - actslope) * factor);
+                Line(half_span - 15, (glide_slope-actslope) * factor,
+                        half_span - hole, (glide_slope - actslope) * factor);
+            }
 #endif
-	
-	StippleLineList.draw( );
-	glDisable(GL_LINE_STIPPLE);
+        }
+        TextList.draw();
 
-//   } // if(div_units)
+        glLineWidth(0.2);
+
+        LineList.draw();
+
+        glEnable(GL_LINE_STIPPLE);
+        glLineStipple(1, 0x00FF);
+        StippleLineList.draw();
+        glDisable(GL_LINE_STIPPLE);
+    }
+    glDisable(GL_CLIP_PLANE0);
+    glDisable(GL_CLIP_PLANE1);
+    glDisable(GL_CLIP_PLANE2);
+    //  glDisable(GL_SCISSOR_TEST);
     glPopMatrix();
+    //*************************************************************
+
+    //*************************************************************
+#ifdef ENABLE_SP_FDM
+    if (waypoint_marker) {
+        //waypoint marker computation
+        float fromwp_lat, towp_lat, fromwp_lon, towp_lon, dist, delx, dely, hyp, theta, brg;
+
+        fromwp_lon = get_longitude() * SGD_DEGREES_TO_RADIANS;
+        fromwp_lat = get_latitude() * SGD_DEGREES_TO_RADIANS;
+        towp_lon = get_aux2() * SGD_DEGREES_TO_RADIANS;
+        towp_lat = get_aux1() * SGD_DEGREES_TO_RADIANS;
+
+        dist = acos(sin(fromwp_lat) * sin(towp_lat) + cos(fromwp_lat)
+                * cos(towp_lat) * cos(fabs(fromwp_lon - towp_lon)));
+        delx= towp_lat - fromwp_lat;
+        dely = towp_lon - fromwp_lon;
+        hyp = sqrt(pow(delx, 2) + pow(dely, 2));
+
+        if (hyp != 0)
+            theta = asin(dely / hyp);
+        else
+            theta = 0.0;
+
+        brg = theta * SGD_RADIANS_TO_DEGREES;
+        if (brg > 360.0)
+            brg = 0.0;
+        if (delx < 0)
+            brg = 180 - brg;
+
+        // {Brg  = asin(cos(towp_lat)*sin(fabs(fromwp_lon-towp_lon))/ sin(dist));
+        // Brg = Brg * SGD_RADIANS_TO_DEGREES; }
+
+        dist *= SGD_RADIANS_TO_DEGREES * 60.0 * 1852.0; //rad->deg->nm->m
+        // end waypoint marker computation
+
+        //*********************************************************
+        // OBJECT MOVING RETICLE
+        // TYPE ARROW
+        // waypoint marker
+        if (fabs(brg-psi) > 10.0) {
+            glPushMatrix();
+            glTranslatef(centroid.x, centroid.y, 0);
+            glTranslatef(vel_x, vel_y, 0);
+            glRotatef(brg - psi, 0.0, 0.0, -1.0);
+            glBegin(GL_LINE_LOOP);
+            glVertex2f(-2.5, 20.0);
+            glVertex2f(-2.5, 30.0);
+            glVertex2f(-5.0, 30.0);
+            glVertex2f(0.0, 35.0);
+            glVertex2f(5.0, 30.0);
+            glVertex2f(2.5, 30.0);
+            glVertex2f(2.5, 20.0);
+            glEnd();
+            glPopMatrix();
+        }
+
+        // waypoint marker on heading scale
+        if (fabs(brg-psi) < 12.0) {
+            if (hat == 0) {
+                glBegin(GL_LINE_LOOP);
+                glVertex2f(((brg - psi) * 60 / 25) + 320, 240.0);
+                glVertex2f(((brg - psi) * 60 / 25) + 326, 240.0 - 4);
+                glVertex2f(((brg - psi) * 60 / 25) + 323, 240.0 - 4);
+                glVertex2f(((brg - psi) * 60 / 25) + 323, 240.0 - 8);
+                glVertex2f(((brg - psi) * 60 / 25) + 317, 240.0 - 8);
+                glVertex2f(((brg - psi) * 60 / 25) + 317, 240.0 - 4);
+                glVertex2f(((brg - psi) * 60 / 25) + 314, 240.0 - 4);
+                glEnd();
+
+            } else { //if hat=0
+                float x = (brg - psi) * 60 / 25 + 320, y = 240.0, r = 5.0;
+                float x1, y1;
+
+                glEnable(GL_POINT_SMOOTH);
+                glBegin(GL_POINTS);
+
+                for (int count = 0; count <= 200; count++) {
+                    float temp = count * 3.142 * 3 / (200.0 * 2.0);
+                    float temp1 = temp - (45.0 * SGD_DEGREES_TO_RADIANS);
+                    x1 = x + r * cos(temp1);
+                    y1 = y + r * sin(temp1);
+                    glVertex2f(x1, y1);
+                }
+
+                glEnd();
+                glDisable(GL_POINT_SMOOTH);
+            } //hat=0
+
+         } //brg<12
+     } // if waypoint_marker
+#endif
+}//draw
+
+
+/******************************************************************/
+//  draws the zenith symbol  for highest possible climb angle (i.e. 90 degree climb angle)
+//
+void HudLadder::drawZenith(float xfirst, float xlast, float yvalue)
+{
+    float xcentre = (xfirst + xlast) / 2.0;
+    float ycentre = yvalue;
+
+    Line(xcentre - 9.0, ycentre, xcentre - 3.0, ycentre + 1.3);
+    Line(xcentre - 9.0, ycentre, xcentre - 3.0, ycentre - 1.3);
+
+    Line(xcentre + 9.0, ycentre, xcentre + 3.0, ycentre + 1.3);
+    Line(xcentre + 9.0, ycentre, xcentre + 3.0, ycentre - 1.3);
+
+    Line(xcentre, ycentre + 9.0, xcentre - 1.3, ycentre + 3.0);
+    Line(xcentre, ycentre + 9.0, xcentre + 1.3, ycentre + 3.0);
+
+    Line(xcentre - 3.9, ycentre + 3.9, xcentre - 3.0, ycentre + 1.3);
+    Line(xcentre - 3.9, ycentre + 3.9, xcentre - 1.3, ycentre + 3.0);
+
+    Line(xcentre + 3.9, ycentre + 3.9, xcentre + 1.3, ycentre+3.0);
+    Line(xcentre + 3.9, ycentre + 3.9, xcentre + 3.0, ycentre+1.3);
+
+    Line(xcentre - 3.9, ycentre - 3.9, xcentre - 3.0, ycentre-1.3);
+    Line(xcentre - 3.9, ycentre - 3.9, xcentre - 1.3, ycentre-2.6);
+
+    Line(xcentre + 3.9, ycentre - 3.9, xcentre + 3.0, ycentre-1.3);
+    Line(xcentre + 3.9, ycentre - 3.9, xcentre + 1.3, ycentre-2.6);
+
+    Line(xcentre - 1.3, ycentre - 2.6, xcentre, ycentre - 27.0);
+    Line(xcentre + 1.3, ycentre - 2.6, xcentre, ycentre - 27.0);
+}
+
+
+//  draws the nadir symbol  for lowest possible dive angle (i.e. 90 degree dive angle)
+//
+void HudLadder::drawNadir(float xfirst, float xlast, float yvalue)
+{
+    float xcentre = (xfirst + xlast) / 2.0;
+    float ycentre = yvalue;
+
+    float r = 7.5;
+    float x1, y1, x2, y2;
+
+    // to draw a circle
+    float xcent1, xcent2, ycent1, ycent2;
+    xcent1 = xcentre + r;
+    ycent1 = ycentre;
+
+    for (int count = 1; count <= 400; count++) {
+        float temp = count * 2 * 3.142 / 400.0;
+        xcent2 = xcentre + r * cos(temp);
+        ycent2 = ycentre + r * sin(temp);
+
+        Line(xcent1, ycent1, xcent2, ycent2);
+
+        xcent1 = xcent2;
+        ycent1 = ycent2;
+    }
+
+    xcent2 = xcentre + r;
+    ycent2 = ycentre;
+
+    drawOneLine(xcent1, ycent1, xcent2, ycent2); //to connect last point to first point
+    //end circle
+
+    //to draw a line above the circle
+    Line(xcentre, ycentre + 7.5, xcentre, ycentre + 22.5);
+
+    //line in the middle of circle
+    Line(xcentre - 7.5, ycentre, xcentre + 7.5, ycentre);
+
+    float theta = asin (2.5 / 7.5);
+    float theta1 = asin(5.0 / 7.5);
+
+    x1 = xcentre + r * cos(theta);
+    y1 = ycentre + 2.5;
+    x2 = xcentre + r * cos((180.0 * SGD_DEGREES_TO_RADIANS) - theta);
+    y2 = ycentre + 2.5;
+    Line(x1, y1, x2, y2);
+
+    x1 = xcentre + r * cos(theta1);
+    y1 = ycentre + 5.0;
+    x2 = xcentre + r * cos((180.0 * SGD_DEGREES_TO_RADIANS) - theta1);
+    y2 = ycentre + 5.0;
+    Line(x1, y1, x2, y2);
+
+    x1 = xcentre + r * cos((180.0 * SGD_DEGREES_TO_RADIANS) + theta);
+    y1 = ycentre - 2.5;
+    x2 = xcentre + r * cos((360.0 * SGD_DEGREES_TO_RADIANS) - theta);
+    y2 = ycentre - 2.5;
+    Line(x1, y1, x2, y2);
+
+    x1 = xcentre + r * cos((180.0 * SGD_DEGREES_TO_RADIANS) + theta1);
+    y1 = ycentre - 5.0;
+    x2 = xcentre + r * cos((360.0 * SGD_DEGREES_TO_RADIANS) - theta1);
+    y2 = ycentre - 5.0;
+    Line(x1, y1, x2, y2);
 }
 
+