fly/flightgear
1
0
Fork 0
Code Activity
flightgear/src/Cockpit/hud_ladr.cxx

886 lines
24 KiB
C++
Raw Blame History

#include "hud.hxx"
#include "panel.hxx"
#define DO_PANEL_HACK
//====================== 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
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)
{
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_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;
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
//
void HudLadder :: draw( void )
{
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();
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);
// 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();
#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);
}
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();
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)/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)
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.
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)
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);
}
}
// 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);
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();
//*************************************************************
//*************************************************************
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);
}
View git blame Copy permalink