1 // HUD_ladder.cxx -- HUD Ladder Instrument
3 // Written by Michele America, started September 1997.
5 // Copyright (C) 1997 Michele F. America [micheleamerica#geocities:com]
6 // Copyright (C) 2006 Melchior FRANZ [mfranz#aon:at]
8 // This program is free software; you can redistribute it and/or
9 // modify it under the terms of the GNU General Public License as
10 // published by the Free Software Foundation; either version 2 of the
11 // License, or (at your option) any later version.
13 // This program is distributed in the hope that it will be useful, but
14 // WITHOUT ANY WARRANTY; without even the implied warranty of
15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 // General Public License for more details.
18 // You should have received a copy of the GNU General Public License
19 // along with this program; if not, write to the Free Software
20 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
26 #include <Main/viewer.hxx>
31 float get__heading() { return fgGetFloat("/orientation/heading-deg") * M_PI / 180.0; }
32 float get__throttleval() { return fgGetFloat("/controls/engines/engine/throttle"); }
33 float get__aoa() { return fgGetFloat("/sim/frame-rate"); } // FIXME
34 float get__Vx() { return fgGetFloat("/velocities/uBody-fps"); }
35 float get__Vy() { return fgGetFloat("/velocities/vBody-fps"); }
36 float get__Vz() { return fgGetFloat("/velocities/wBody-fps"); }
37 float get__Ax() { return fgGetFloat("/acclerations/pilot/x-accel-fps_sec"); }
38 float get__Ay() { return fgGetFloat("/acclerations/pilot/y-accel-fps_sec"); }
39 float get__Az() { return fgGetFloat("/acclerations/pilot/z-accel-fps_sec"); }
43 HUD::Ladder::Ladder(HUD *hud, const SGPropertyNode *n, float x, float y) :
45 _pitch(n->getNode("pitch-input", false)),
46 _roll(n->getNode("roll-input", false)),
47 _width_units(int(n->getFloatValue("display-span"))),
48 _div_units(int(fabs(n->getFloatValue("divisions")))),
49 _scr_hole(n->getIntValue("screen-hole")),
50 _compression(n->getFloatValue("compression-factor")),
51 _frl(n->getBoolValue("enable-fuselage-ref-line", false)),
52 _target_spot(n->getBoolValue("enable-target-spot", false)),
53 _velocity_vector(n->getBoolValue("enable-velocity-vector", false)),
54 _drift_marker(n->getBoolValue("enable-drift-marker", false)),
55 _alpha_bracket(n->getBoolValue("enable-alpha-bracket", false)),
56 _energy_marker(n->getBoolValue("enable-energy-marker", false)),
57 _climb_dive_marker(n->getBoolValue("enable-climb-dive-marker", false)),
58 _glide_slope_marker(n->getBoolValue("enable-glide-slope-marker",false)),
59 _glide_slope(n->getFloatValue("glide-slope", -4.0)),
60 _energy_worm(n->getBoolValue("enable-energy-marker", false)),
61 _waypoint_marker(n->getBoolValue("enable-waypoint-marker", false)),
62 _zenith(n->getBoolValue("enable-zenith")),
63 _nadir(n->getBoolValue("enable-nadir")),
64 _hat(n->getBoolValue("enable-hat"))
66 const char *t = n->getStringValue("type");
67 _type = strcmp(t, "climb-dive") ? PITCH : CLIMB_DIVE;
72 _vmax = _width_units / 2;
77 void HUD::Ladder::draw(void)
79 if (!_pitch.isValid() || !_roll.isValid())
82 float roll_value = _roll.getFloatValue() * SGD_DEGREES_TO_RADIANS;
83 float pitch_value = _pitch.getFloatValue();
86 bool climb_dive_ladder;
89 if (_type == CLIMB_DIVE) {
91 climb_dive_ladder = true;
94 } else { // _type == PITCH
96 climb_dive_ladder = false;
100 //**************************************************************
102 glTranslatef(_center_x, _center_y, 0);
104 // OBJECT STATIC RETICLE
105 // TYPE FRL (FUSELAGE REFERENCE LINE)
107 // Draw the FRL spot and line
109 #define FRL_DIAMOND_SIZE 2.0
110 glBegin(GL_LINE_LOOP);
111 glVertex2f(-FRL_DIAMOND_SIZE, 0.0);
112 glVertex2f(0.0, FRL_DIAMOND_SIZE);
113 glVertex2f(FRL_DIAMOND_SIZE, 0.0);
114 glVertex2f(0.0, -FRL_DIAMOND_SIZE);
117 glBegin(GL_LINE_STRIP);
118 glVertex2f(0, FRL_DIAMOND_SIZE);
121 #undef FRL_DIAMOND_SIZE
123 // TYPE WATERLINE_MARK (W shaped _ _ )
126 //****************************************************************
128 // Draw the target spot.
130 #define CENTER_DIAMOND_SIZE 6.0
131 glBegin(GL_LINE_LOOP);
132 glVertex2f(-CENTER_DIAMOND_SIZE, 0.0);
133 glVertex2f(0.0, CENTER_DIAMOND_SIZE);
134 glVertex2f(CENTER_DIAMOND_SIZE, 0.0);
135 glVertex2f(0.0, -CENTER_DIAMOND_SIZE);
137 #undef CENTER_DIAMOND_SIZE
140 //****************************************************************
141 //velocity vector reticle - computations
142 float xvvr, yvvr, Vxx = 0.0, Vyy = 0.0, Vzz = 0.0;
143 float Axx = 0.0, Ayy = 0.0, Azz = 0.0, total_vel = 0.0, pot_slope, t1;
144 float up_vel, ground_vel, actslope = 0.0, psi = 0.0;
145 float vel_x = 0.0, vel_y = 0.0, drift;
147 if (_velocity_vector) {
154 psi = get__heading();
159 total_vel = sqrt(Vxx * Vxx + Vyy * Vyy + Vzz * Vzz);
160 ground_vel = sqrt(Vxx * Vxx + Vyy * Vyy);
163 if (ground_vel < 2.0) {
164 if (fabs(up_vel) < 2.0)
167 actslope = (up_vel / fabs(up_vel)) * 90.0;
170 actslope = atan(up_vel / ground_vel) * SGD_RADIANS_TO_DEGREES;
173 xvvr = (((atan2(Vyy, Vxx) * SGD_RADIANS_TO_DEGREES) - psi)
174 * (_compression / globals->get_current_view()->get_aspect_ratio()));
175 drift = ((atan2(Vyy, Vxx) * SGD_RADIANS_TO_DEGREES) - psi);
176 yvvr = ((actslope - pitch_value) * _compression);
177 vel_y = ((actslope - pitch_value) * cos(roll_value) + drift * sin(roll_value)) * _compression;
178 vel_x = (-(actslope - pitch_value) * sin(roll_value) + drift * cos(roll_value))
179 * (_compression / globals->get_current_view()->get_aspect_ratio());
180 // printf("%f %f %f %f\n",vel_x, vel_y, drift, psi);
182 //****************************************************************
183 // OBJECT MOVING RETICLE
184 // TYPE - DRIFT MARKER
188 glBegin(GL_LINE_STRIP);
189 glVertex2f((xvvr * 25 / 120) - 6, -4);
190 glVertex2f(xvvr * 25 / 120, 8);
191 glVertex2f((xvvr * 25 / 120) + 6, -4);
195 //****************************************************************
196 // Clipping coordinates for ladder to be input from xml file
199 GLdouble eqn_top[4] = {0.0, -1.0, 0.0, 0.0};
200 GLdouble eqn_left[4] = {-1.0, 0.0, 0.0, 100.0};
201 GLdouble eqn_right[4] = {1.0, 0.0, 0.0, 100.0};
203 glClipPlane(GL_CLIP_PLANE0, eqn_top);
204 glEnable(GL_CLIP_PLANE0);
205 glClipPlane(GL_CLIP_PLANE1, eqn_left);
206 glEnable(GL_CLIP_PLANE1);
207 glClipPlane(GL_CLIP_PLANE2, eqn_right);
208 glEnable(GL_CLIP_PLANE2);
209 // glScissor(-100,-240, 200, 240);
210 // glEnable(GL_SCISSOR_TEST);
213 //****************************************************************
214 // OBJECT MOVING RETICLE
215 // TYPE VELOCITY VECTOR
218 draw_circle(vel_x, vel_y, 6);
220 //velocity vector reticle orientation lines
221 glBegin(GL_LINE_STRIP);
222 glVertex2f(vel_x - 12, vel_y);
223 glVertex2f(vel_x - 6, vel_y);
225 glBegin(GL_LINE_STRIP);
226 glVertex2f(vel_x + 12, vel_y);
227 glVertex2f(vel_x + 6, vel_y);
229 glBegin(GL_LINE_STRIP);
230 glVertex2f(vel_x, vel_y + 12);
231 glVertex2f(vel_x, vel_y + 6);
235 int lgear = get__iaux3();
236 int ihook = get__iaux6();
238 // OBJECT MOVING RETICLE
240 // ATTRIB - ON CONDITION
242 // undercarriage status
243 glBegin(GL_LINE_STRIP);
244 glVertex2f(vel_x + 8, vel_y);
245 glVertex2f(vel_x + 8, vel_y - 4);
248 // OBJECT MOVING RETICLE
250 // ATTRIB - ON CONDITION
251 glBegin(GL_LINE_STRIP);
252 glVertex2f(vel_x - 8, vel_y);
253 glVertex2f(vel_x - 8, vel_y - 4);
256 // OBJECT MOVING RETICLE
258 // ATTRIB - ON CONDITION
259 glBegin(GL_LINE_STRIP);
260 glVertex2f(vel_x, vel_y - 6);
261 glVertex2f(vel_x, vel_y - 10);
265 // OBJECT MOVING RETICLE
267 // ATTRIB - ON CONDITION
269 // arrestor hook status
270 glBegin(GL_LINE_STRIP);
271 glVertex2f(vel_x - 4, vel_y - 8);
272 glVertex2f(vel_x, vel_y - 10);
273 glVertex2f(vel_x + 4, vel_y - 8);
277 } // if _velocity_vector
280 //***************************************************************
281 // OBJECT MOVING RETICLE
282 // TYPE - SQUARE_BRACKET
283 // ATTRIB - ON CONDITION
286 float alpha = get__aoa();
288 if (_alpha_bracket && ihook == 1) {
289 glBegin(GL_LINE_STRIP);
290 glVertex2f(vel_x - 20, vel_y - (16 - alpha) * _compression);
291 glVertex2f(vel_x - 17, vel_y - (16 - alpha) * _compression);
292 glVertex2f(vel_x - 17, vel_y - (14 - alpha) * _compression);
293 glVertex2f(vel_x - 20, vel_y - (14 - alpha) * _compression);
296 glBegin(GL_LINE_STRIP);
297 glVertex2f(vel_x + 20, vel_y - (16 - alpha) * _compression);
298 glVertex2f(vel_x + 17, vel_y - (16 - alpha) * _compression);
299 glVertex2f(vel_x + 17, vel_y - (14 - alpha) * _compression);
300 glVertex2f(vel_x + 20, vel_y - (14 - alpha) * _compression);
304 //printf("xvr=%f, yvr=%f, Vx=%f, Vy=%f, Vz=%f\n",xvvr, yvvr, Vx, Vy, Vz);
305 //printf("Ax=%f, Ay=%f, Az=%f\n",Ax, Ay, Az);
307 //****************************************************************
308 // OBJECT MOVING RETICLE
309 // TYPE ENERGY_MARKERS
311 //energy markers - compute potential slope
312 float pla = get__throttleval();
315 if (_energy_marker) {
316 if (total_vel < 5.0) {
320 t1 = up_vel / total_vel;
321 t2 = asin((Vxx * Axx + Vyy * Ayy + Vzz * Azz) / (9.81 * total_vel));
323 pot_slope = ((t2 / 3) * SGD_RADIANS_TO_DEGREES) * _compression + vel_y;
324 // if (pot_slope < (vel_y - 45)) pot_slope = vel_y - 45;
325 // if (pot_slope > (vel_y + 45)) pot_slope = vel_y + 45;
328 glBegin(GL_LINE_STRIP);
329 glVertex2f(vel_x - 20, pot_slope - 5);
330 glVertex2f(vel_x - 15, pot_slope);
331 glVertex2f(vel_x - 20, pot_slope + 5);
334 glBegin(GL_LINE_STRIP);
335 glVertex2f(vel_x + 20, pot_slope - 5);
336 glVertex2f(vel_x + 15, pot_slope);
337 glVertex2f(vel_x + 20, pot_slope + 5);
340 if (pla > (105.0 / 131.0)) {
341 glBegin(GL_LINE_STRIP);
342 glVertex2f(vel_x - 24, pot_slope - 5);
343 glVertex2f(vel_x - 19, pot_slope);
344 glVertex2f(vel_x - 24, pot_slope + 5);
347 glBegin(GL_LINE_STRIP);
348 glVertex2f(vel_x + 24, pot_slope - 5);
349 glVertex2f(vel_x + 19, pot_slope);
350 glVertex2f(vel_x + 24, pot_slope + 5);
355 //**********************************************************
357 // OBJECT STATIC RETICLE
359 // ATTRIB - ON CONDITION
361 int ilcanclaw = get__iaux2();
363 if (_energy_worm && ilcanclaw == 1) {
364 glBegin(GL_LINE_STRIP);
365 glVertex2f(-15, -134);
366 glVertex2f(15, -134);
369 // OBJECT MOVING RETICLE
371 // ATTRIB - ON CONDITION
372 glBegin(GL_LINE_STRIP);
373 glVertex2f(-6, -134);
374 glVertex2f(-6, t2 * SGD_RADIANS_TO_DEGREES * 4.0 - 134);
375 glVertex2f(+6, t2 * SGD_RADIANS_TO_DEGREES * 4.0 - 134);
379 // OBJECT MOVING RETICLE
381 // ATTRIB - ON CONDITION
382 glBegin(GL_LINE_LOOP);
383 glVertex2f(-6, actslope * 4.0 - 134);
384 glVertex2f(0, actslope * 4.0 -134 + 3);
385 glVertex2f(6, actslope * 4.0 - 134);
386 glVertex2f(0, actslope * 4.0 -134 -3);
391 //*************************************************************
392 // OBJECT MOVING RETICLE
395 // Draw the locked velocity vector.
396 if (_climb_dive_marker) {
397 glBegin(GL_LINE_LOOP);
398 glVertex2f(-3.0, 0.0 + vel_y);
399 glVertex2f(0.0, 6.0 + vel_y);
400 glVertex2f(3.0, 0.0 + vel_y);
401 glVertex2f(0.0, -6.0 + vel_y);
405 //****************************************************************
407 if (climb_dive_ladder) { // CONFORMAL_HUD
408 _vmin = pitch_value - _width_units;
409 _vmax = pitch_value + _width_units;
410 glTranslatef(vel_x, vel_y, 0);
412 } else { // pitch_ladder - Default Hud
413 _vmin = pitch_value - _width_units * 0.5f;
414 _vmax = pitch_value + _width_units * 0.5f;
417 glRotatef(roll_value * SGD_RADIANS_TO_DEGREES, 0.0, 0.0, 1.0);
418 // FRL marker not rotated - this line shifted below
419 float half_span = _w / 2.0;
425 const int BUFSIZE = 8;
433 float text_offset = 4.0f;
434 float zero_offset = 0.0;
436 if (climb_dive_ladder)
437 zero_offset = 50.0f; // horizon line is wider by this much (hard coded ??)
441 fntFont *font = _hud->_font_renderer->getFont(); // FIXME
442 float pointsize = _hud->_font_renderer->getPointSize();
443 float italic = _hud->_font_renderer->getSlant();
445 _locTextList.setFont(_hud->_font_renderer);
446 _locTextList.erase();
447 _locLineList.erase();
448 _locStippleLineList.erase();
450 int last = int(_vmax) + 1;
456 for (; i < last; i++) {
457 y = (i - pitch_value) * _compression + .5f;
459 if (!(i % _div_units)) { // At integral multiple of div
460 snprintf(buf, BUFSIZE, "%d", i);
461 font->getBBox(buf, pointsize, italic, &left, &right, &bot, &top);
462 label_length = right + left;
463 label_height = (top + bot) / 2.0f;
468 // Make zero point wider on left
470 x_ini -= zero_offset;
472 // Zero or above draw solid lines
473 draw_line(x_ini, y, x_end, y);
475 if (i == 90 && _zenith)
476 draw_zenith(x_ini, x_end, y);
478 // Below zero draw dashed lines.
479 draw_stipple_line(x_ini, y, x_end, y);
481 if (i == -90 && _nadir)
482 draw_nadir(x_ini, x_end, y);
485 // Calculate the position of the left text and write it.
486 draw_text(x_ini - text_offset - label_length + 2.5/*hack*/, y - label_height, buf);
487 draw_text(x_end + text_offset, y - label_height, buf);
491 } else { // if (_scr_hole)
492 // Draw ladder with space in the middle of the lines
493 float hole = _scr_hole / 2.0f;
495 x_end = -half_span + hole;
496 x_ini2 = half_span - hole;
498 for (; i < last; i++) {
500 y = float(i - pitch_value) * _compression + .5;
501 else // _type == CLIMB_DIVE
502 y = float(i - actslope) * _compression + .5;
504 if (!(i % _div_units)) { // At integral multiple of div
505 snprintf(buf, BUFSIZE, "%d", i);
506 font->getBBox(buf, pointsize, italic, &left, &right, &bot, &top);
507 label_length = right + left;
508 label_height = (top + bot) / 2.0f;
509 //printf("%s -- l %f r %f b %f t %f\n", buf, left, right, bot, top);
511 // Start by calculating the points and drawing the
517 // Make zero point wider on left
519 x_ini -= zero_offset;
520 x_end2 += zero_offset;
522 //draw climb bar vertical lines
523 if (climb_dive_ladder) {
524 // Zero or above draw solid lines
525 draw_line(x_end, y - 5.0, x_end, y);
526 draw_line(x_ini2, y - 5.0, x_ini2, y);
528 // draw pitch / climb bar
529 draw_line(x_ini, y, x_end, y);
530 draw_line(x_ini2, y, x_end2, y);
532 if (i == 90 && _zenith)
533 draw_zenith(x_ini2, x_end, y);
536 // draw dive bar vertical lines
537 if (climb_dive_ladder) {
538 draw_line(x_end, y + 5.0, x_end, y);
539 draw_line(x_ini2, y + 5.0, x_ini2, y);
542 // draw pitch / dive bars
543 draw_stipple_line(x_ini, y, x_end, y);
544 draw_stipple_line(x_ini2, y, x_end2, y);
546 if (i == -90 && _nadir)
547 draw_nadir(x_ini2, x_end, y);
550 // Now calculate the location of the left side label using
551 draw_text(x_ini - text_offset - label_length + 2.5/*hack*/, y - label_height, buf);
552 draw_text(x_end2 + text_offset, y - label_height, buf);
556 // OBJECT LADDER MARK
558 // ATTRIB - ON CONDITION
559 // draw appraoch glide slope marker
561 if (_glide_slope_marker && ihook) {
562 draw_line(-half_span + 15, (_glide_slope - actslope) * _compression,
563 -half_span + hole, (_glide_slope - actslope) * _compression);
564 draw_line(half_span - 15, (_glide_slope - actslope) * _compression,
565 half_span - hole, (_glide_slope - actslope) * _compression);
575 glEnable(GL_LINE_STIPPLE);
576 glLineStipple(1, 0x00FF);
577 _locStippleLineList.draw();
578 glDisable(GL_LINE_STIPPLE);
580 glDisable(GL_CLIP_PLANE0);
581 glDisable(GL_CLIP_PLANE1);
582 glDisable(GL_CLIP_PLANE2);
583 // glDisable(GL_SCISSOR_TEST);
585 //*************************************************************
587 //*************************************************************
589 if (_waypoint_marker) {
590 //waypoint marker computation
591 float fromwp_lat, towp_lat, fromwp_lon, towp_lon, dist, delx, dely, hyp, theta, brg;
593 fromwp_lon = get__longitude() * SGD_DEGREES_TO_RADIANS;
594 fromwp_lat = get__latitude() * SGD_DEGREES_TO_RADIANS;
595 towp_lon = get__aux2() * SGD_DEGREES_TO_RADIANS;
596 towp_lat = get__aux1() * SGD_DEGREES_TO_RADIANS;
598 dist = acos(sin(fromwp_lat) * sin(towp_lat) + cos(fromwp_lat)
599 * cos(towp_lat) * cos(fabs(fromwp_lon - towp_lon)));
600 delx= towp_lat - fromwp_lat;
601 dely = towp_lon - fromwp_lon;
602 hyp = sqrt(pow(delx, 2) + pow(dely, 2));
605 theta = asin(dely / hyp);
609 brg = theta * SGD_RADIANS_TO_DEGREES;
615 // {Brg = asin(cos(towp_lat)*sin(fabs(fromwp_lon-towp_lon))/ sin(dist));
616 // Brg = Brg * SGD_RADIANS_TO_DEGREES; }
618 dist *= SGD_RADIANS_TO_DEGREES * 60.0 * 1852.0; //rad->deg->nm->m
619 // end waypoint marker computation
621 //*********************************************************
622 // OBJECT MOVING RETICLE
625 if (fabs(brg - psi) > 10.0) {
627 glTranslatef(_center_x, _center_y, 0);
628 glTranslatef(vel_x, vel_y, 0);
629 glRotatef(brg - psi, 0.0, 0.0, -1.0);
630 glBegin(GL_LINE_LOOP);
631 glVertex2f(-2.5, 20.0);
632 glVertex2f(-2.5, 30.0);
633 glVertex2f(-5.0, 30.0);
634 glVertex2f(0.0, 35.0);
635 glVertex2f(5.0, 30.0);
636 glVertex2f(2.5, 30.0);
637 glVertex2f(2.5, 20.0);
642 // waypoint marker on heading scale
643 if (fabs(brg - psi) < 12.0) {
645 glBegin(GL_LINE_LOOP);
646 glVertex2f(((brg - psi) * 60 / 25) + 320, 240.0);
647 glVertex2f(((brg - psi) * 60 / 25) + 326, 240.0 - 4);
648 glVertex2f(((brg - psi) * 60 / 25) + 323, 240.0 - 4);
649 glVertex2f(((brg - psi) * 60 / 25) + 323, 240.0 - 8);
650 glVertex2f(((brg - psi) * 60 / 25) + 317, 240.0 - 8);
651 glVertex2f(((brg - psi) * 60 / 25) + 317, 240.0 - 4);
652 glVertex2f(((brg - psi) * 60 / 25) + 314, 240.0 - 4);
655 } else { // if (_hat)
656 float x = (brg - psi) * 60 / 25 + 320, y = 240.0, r = 5.0;
659 glEnable(GL_POINT_SMOOTH);
662 for (int count = 0; count <= 200; count++) {
663 float temp = count * SG_PI * 3 / (200.0 * 2.0);
664 float temp1 = temp - (45.0 * SGD_DEGREES_TO_RADIANS);
665 x1 = x + r * cos(temp1);
666 y1 = y + r * sin(temp1);
671 glDisable(GL_POINT_SMOOTH);
675 } // if _waypoint_marker
680 /******************************************************************/
681 // draws the zenith symbol for highest possible climb angle (i.e. 90 degree climb angle)
683 void HUD::Ladder::draw_zenith(float xfirst, float xlast, float yvalue)
685 float xcentre = (xfirst + xlast) / 2.0;
686 float ycentre = yvalue;
688 draw_line(xcentre - 9.0, ycentre, xcentre - 3.0, ycentre + 1.3);
689 draw_line(xcentre - 9.0, ycentre, xcentre - 3.0, ycentre - 1.3);
691 draw_line(xcentre + 9.0, ycentre, xcentre + 3.0, ycentre + 1.3);
692 draw_line(xcentre + 9.0, ycentre, xcentre + 3.0, ycentre - 1.3);
694 draw_line(xcentre, ycentre + 9.0, xcentre - 1.3, ycentre + 3.0);
695 draw_line(xcentre, ycentre + 9.0, xcentre + 1.3, ycentre + 3.0);
697 draw_line(xcentre - 3.9, ycentre + 3.9, xcentre - 3.0, ycentre + 1.3);
698 draw_line(xcentre - 3.9, ycentre + 3.9, xcentre - 1.3, ycentre + 3.0);
700 draw_line(xcentre + 3.9, ycentre + 3.9, xcentre + 1.3, ycentre+3.0);
701 draw_line(xcentre + 3.9, ycentre + 3.9, xcentre + 3.0, ycentre+1.3);
703 draw_line(xcentre - 3.9, ycentre - 3.9, xcentre - 3.0, ycentre-1.3);
704 draw_line(xcentre - 3.9, ycentre - 3.9, xcentre - 1.3, ycentre-2.6);
706 draw_line(xcentre + 3.9, ycentre - 3.9, xcentre + 3.0, ycentre-1.3);
707 draw_line(xcentre + 3.9, ycentre - 3.9, xcentre + 1.3, ycentre-2.6);
709 draw_line(xcentre - 1.3, ycentre - 2.6, xcentre, ycentre - 27.0);
710 draw_line(xcentre + 1.3, ycentre - 2.6, xcentre, ycentre - 27.0);
714 // draws the nadir symbol (lowest possible dive angle i.e. 90 degree dive angle))
716 void HUD::Ladder::draw_nadir(float xfirst, float xlast, float yvalue)
718 float xcentre = (xfirst + xlast) / 2.0;
719 float ycentre = yvalue;
722 draw_circle(xcentre, ycentre, R);
723 draw_line(xcentre, ycentre + R, xcentre, ycentre + 22.5); // line above the circle
724 draw_line(xcentre - R, ycentre, xcentre + R, ycentre); // line at middle of circle
726 float theta = asin(2.5 / R);
727 float theta1 = asin(5.0 / R);
728 float x1, y1, x2, y2;
730 x1 = xcentre + R * cos(theta);
732 x2 = xcentre + R * cos((180.0 * SGD_DEGREES_TO_RADIANS) - theta);
734 draw_line(x1, y1, x2, y2);
736 x1 = xcentre + R * cos(theta1);
738 x2 = xcentre + R * cos((180.0 * SGD_DEGREES_TO_RADIANS) - theta1);
740 draw_line(x1, y1, x2, y2);
742 x1 = xcentre + R * cos((180.0 * SGD_DEGREES_TO_RADIANS) + theta);
744 x2 = xcentre + R * cos((360.0 * SGD_DEGREES_TO_RADIANS) - theta);
746 draw_line(x1, y1, x2, y2);
748 x1 = xcentre + R * cos((180.0 * SGD_DEGREES_TO_RADIANS) + theta1);
750 x2 = xcentre + R * cos((360.0 * SGD_DEGREES_TO_RADIANS) - theta1);
752 draw_line(x1, y1, x2, y2);