X-Git-Url: https://git.mxchange.org/?a=blobdiff_plain;f=src%2FCockpit%2Fhud_ladr.cxx;h=edc4043c2355142d12c2fdf593fb4f75b1b3f7fc;hb=c0b4531d04215f76f9cf65afbdaed6b7c0b32634;hp=e3143cee6fdd4fd814fc4f5b515adbb24653d664;hpb=cc26bb7fe73be1fa23b5e1c3b88f71e0d361a4c2;p=flightgear.git

diff --git a/src/Cockpit/hud_ladr.cxx b/src/Cockpit/hud_ladr.cxx
index e3143cee6..edc4043c2 100644
--- a/src/Cockpit/hud_ladr.cxx
+++ b/src/Cockpit/hud_ladr.cxx
@@ -1,90 +1,132 @@
-#ifdef HAVE_CONFIG_H
-#  include <config.h>
-#endif
 
-#ifdef HAVE_WINDOWS_H
-#  include <windows.h>
-#endif
+#include "hud.hxx"
+#include "panel.hxx"
 
-#include <stdlib.h>
-#include <string.h>
+#define DO_PANEL_HACK
 
-#include <simgear/constants.h>
-#include <simgear/math/fg_random.h>
-#include <simgear/math/polar3d.hxx>
+//====================== Top of HudLadder Class =======================
+HudLadder ::   HudLadder(  string name,
+			   int       x,
+			   int       y,
+			   UINT      width,
+			   UINT      height,
+			   float	 factr,
+			   FLTFNPTR  ptch_source,
+			   FLTFNPTR  roll_source,
+			   float     span_units,
+			   float     major_div,
+			   float     minor_div,
+			   UINT      screen_hole,
+			   UINT      lbl_pos,
+			   bool      frl_spot,
+			   bool		 target,
+			   bool		 vel_vec,
+			   bool		 drift,
+			   bool		 alpha,
+			   bool      energy,
+			   bool      climb,
+			   bool      glide,
+			   float     glide_slope_val,
+			   bool      worm_energy,
+			   bool      waypoint,
+			   bool      working,
+   			   int		 zenithsymbol, //suma
+			   int       nadirsymbol, //suma
+			   int		 hat_marker): //suma
 
-#include <Aircraft/aircraft.hxx>
-#include <Scenery/scenery.hxx>
-#include <Time/fg_timer.hxx>
-#include <GUI/gui.h>
+    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        ),
+    factor				( factr		  ),
+    hudladder_type		( name		  ),
+    frl					( frl_spot		),
+    target_spot			( target		),
+    velocity_vector		( vel_vec		),
+    drift_marker		( drift			),
+    alpha_bracket		( alpha			),
+    energy_marker		( energy		),
+    climb_dive_marker	( climb		),
+    glide_slope_marker	( glide			),
+    glide_slope			( glide_slope_val),
+    energy_worm			( worm_energy),
+    waypoint_marker		( waypoint)
 
-#include "hud.hxx"
 
-
-//====================== 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;
-   }
+{
+		
+    zenith= zenithsymbol; //suma
+	nadir=nadirsymbol; //suma
+	hat= hat_marker; //suma
+ 
+	if( !width_units ) 
+	{
+	   width_units = 45;
+    }
+}
    
 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( 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_type		( image.hudladder_type),
+    frl					( image.frl),
+    target_spot			( image.target_spot),
+    velocity_vector		( image.velocity_vector),
+    drift_marker		( image.drift_marker),
+    alpha_bracket		( image.alpha_bracket),
+    energy_marker		( image.energy_marker),
+    climb_dive_marker	( image.climb_dive_marker),
+    glide_slope_marker	( image.glide_slope_marker),
+    glide_slope			( image.glide_slope),
+    energy_worm			( image.energy_worm),
+    waypoint_marker		( image.waypoint_marker)
+{
+}
 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;
+{
+    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;
+	hudladder_type		= rhs.hudladder_type;
+	frl					= rhs.frl;
+	velocity_vector		= rhs.velocity_vector;
+	drift_marker		= rhs.drift_marker;
+	alpha_bracket		= rhs.alpha_bracket;
+	energy_marker		= rhs.energy_marker;
+	climb_dive_marker	= rhs.climb_dive_marker;
+	target_spot			= rhs.target_spot;
+	glide_slope_marker	= rhs.glide_slope_marker;
+	glide_slope			= rhs.glide_slope;
+	energy_worm			= rhs.energy_worm;
+	waypoint_marker		= rhs.waypoint_marker;
     }
+    return *this;
+}
                            
 //
 //  Draws a climb ladder in the center of the HUD
@@ -92,40 +134,354 @@ HudLadder & HudLadder ::  operator = ( const HudLadder & rhs )
 
 void HudLadder :: draw( void )
 {
-    float  x_ini;
-    float  x_end;
-    float  y;
+
+    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,
+        up_vel, ground_vel, actslope = 0.0;
+    float Axx = 0.0, Ayy = 0.0, Azz = 0.0, total_vel = 0.0, pot_slope, t1,
+        t2 = 0.0, psi = 0.0, alpha,pla;
+    float vel_x = 0.0, vel_y = 0.0, drift;
+    // char     Textaux[8] ;
+    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();
-    
-    float pitch_value = current_ch1() * RAD_TO_DEG;
-    vmin              = pitch_value - (float)width_units/2.0;
-    vmax              = pitch_value + (float)width_units/2.0;
+    alpha = get_aoa();
+    pla = get_throttleval();
 
+    int lgear,wown,wowm,ilcanclaw,ihook;
+    ilcanclaw = get_iaux2();
+    lgear = get_iaux3();
+    wown = get_iaux4();
+    wowm = get_iaux5();
+    ihook = get_iaux6();
+    
+    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();
+    // define (0,0) as center of screen
     glTranslatef( centroid.x, centroid.y, 0);
-    glRotatef(roll_value * RAD_TO_DEG, 0.0, 0.0, 1.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.
+    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();
+	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 * 2 * SGD_PI/50.0); 
+            sine =   6 * sin(count * 2 * SGD_PI/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();
+
+	// 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();
+	}
+    }//if velocity_vector
+
+    //***************************************************************
+    // OBJECT MOVING RETICLE
+    // TYPE - SQUARE_BRACKET
+    // ATTRIB - ON CONDITION
+    // alpha bracket
+    if (alpha_bracket)	{
+	if (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();
+	}
+    }
+    //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();
+	}
+    }
+    //********************************************************** 
+    // ramp reticle
+    // OBJECT STATIC RETICLE
+    // TYPE LINE
+    // ATTRIB - ON CONDITION
+    if (energy_worm)	{
+	if (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();
+	}
+    }
+    //*************************************************************
+    // 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);
 
-    if(minimal) {
-        glPopMatrix();      
-        return;
     }
+    else 
+	// pitch_ladder - Default Hud
+	{
+
+	    vmin              = pitch_value - (float)width_units * 0.5f;
+	    vmax              = pitch_value + (float)width_units * 0.5f;
+
+	}
 
-    if( div_units ) {
+    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 ;
@@ -134,25 +490,34 @@ void HudLadder :: draw( void )
         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);
-        
+    	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();
+	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 ) {
-            for( ; i<last ; i++ ) {
+	    x_end =  half_span;
+            for( ; i<last ; i++ ) 
+			{
                 
                 y =  (((float)(i - pitch_value) * factor) + .5f);
-                if( !(i % div_units ))    {        //  At integral multiple of div
+                if( !(i % div_units ))            //  At integral multiple of div
+				{
                 
                     sprintf( TextLadder, "%d", i );
                     font->getBBox ( TextLadder, pointsize, italic,
@@ -162,17 +527,31 @@ void HudLadder :: draw( void )
                     label_height  = (top - bot)/2.0f;
                 
                     x_ini = -half_span;
-                    x_end =  half_span;
                     
-                    if( i >= 0 ) {
+                    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);
+                            
+						// Zero or above draw solid lines
+						Line(x_ini, y, x_end, y);
+						
+						if(i == 90)
+						if(zenith == 1)
+						{
+						  drawZenith(x_ini, x_end,y);
+						}
                     } else {
                         // Below zero draw dashed lines.
                         StippleLine(x_ini, y, x_end, y);
+
+						
+						if(i == -90)
+						if(nadir ==1)
+						{ 
+							drawNadir(x_ini, x_end,y);
+						}
                     }
                     
                     // Calculate the position of the left text and write it.
@@ -182,59 +561,97 @@ void HudLadder :: draw( void )
             }
         }
         else // if(scr_hole )
-        {    // Draw ladder with space in the middle of the lines
-            float hole = (float)((scr_hole)/2.0f);
-            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)/2.0f;
-//                  printf("l %f r %f b %f t %f\n",left, right, bot, top );
+	    {    // 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_end = -half_span + hole;
+			// 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;
-                        // 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);
-                    }
-                    
-                    // Now calculate the location of the left side label using
-                    Text( x_ini-label_length, y-label_height, TextLadder );
-                    
-                    // Now calculate and draw the right side line location
-                    x_ini = half_span - hole;
-                    x_end = half_span;
-                    
-                    if( i >= 0 ) {
-                        if( i == 0 ) 
-                            x_end += 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);
-                    }
+			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)
+				if(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)
+			    if(nadir == 1)
+				{
+				    drawNadir(x_ini2, x_end,y);
+				}
+			}
                     
-                    // Calculate the location and draw the right side label
-                    Text( x_end+text_offset,  y-label_height, TextLadder );
-                }
-            }
-        }
+			// 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
+		if (glide_slope_marker)	{
+		    if (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);
+		    }
+		}// if glide_slope_marker
+	    }
         TextList.draw();
 
         glLineWidth(0.2);
@@ -246,6 +663,224 @@ void HudLadder :: draw( void )
         StippleLineList.draw( );
         glDisable(GL_LINE_STIPPLE);
     }
+    glDisable(GL_CLIP_PLANE0);
+    glDisable(GL_CLIP_PLANE1);
+    glDisable(GL_CLIP_PLANE2);
+    //      glDisable(GL_SCISSOR_TEST);
     glPopMatrix();
-}
+    //*************************************************************
+    //*************************************************************
+    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 = 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
+}//draw
+
+/******************************************************************/
+
+//begin suma
+	//  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);
+
+  
+} 
+	//end suma
+
+//begin suma
+	//  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 * cos(0.0);
+		ycent1 = ycentre + r * sin(0.0);
+    	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 * cos(0.0);
+		ycent2 = ycentre + r * sin(0.0);
+
+        drawOneLine(xcent1, ycent1, xcent2, ycent2); //to connect last point to first point
+		//end circle
+
+
+		Line(xcentre, ycentre+7.5, xcentre, ycentre+22.5); //to draw a line above the circle
+
+		Line(xcentre-7.5, ycentre, xcentre+7.5,ycentre); //line in the middle of circle
+
+		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);
+
+
+}