#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/fg_random.h>
-#include <simgear/mat3.h>
-#include <simgear/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;
+}
-//====================== 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)
{
- float x_ini;
- float x_end;
- float y;
- POINT centroid = get_centroid();
- RECT box = get_location();
+ 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;
- 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;
+ } else { // hudladder_type == "Pitch Ladder"
+ pitch_ladder = true;
+ climb_dive_ladder = false;
+ clip_plane = false;
+ }
+ //**************************************************************
glPushMatrix();
- glTranslatef( centroid.x, centroid.y, 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.
+ if (target_spot) {
#define CENTER_DIAMOND_SIZE 6.0
- glBegin(GL_LINE_LOOP);
- glVertex2f( -CENTER_DIAMOND_SIZE, 0.0);
+ glBegin(GL_LINE_LOOP);
+ glVertex2f(-CENTER_DIAMOND_SIZE, 0.0);
glVertex2f(0.0, CENTER_DIAMOND_SIZE);
- glVertex2f( CENTER_DIAMOND_SIZE, 0.0);
+ glVertex2f(CENTER_DIAMOND_SIZE, 0.0);
glVertex2f(0.0, -CENTER_DIAMOND_SIZE);
- glEnd();
+ 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();
- if(minimal) {
- glPopMatrix();
- return;
+ // 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();
+ }
}
- 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 = 10.0f ;
-
- fntFont *font = HUDtext->getFont();
- float pointsize = HUDtext->getPointSize();
- float italic = HUDtext->getSlant();
-
- TextList.setFont( HUDtext );
+ //**********************************************************
+ // 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 = FloatToInt(vmax)+1;
- int i = FloatToInt(vmin);
-
- if( !scr_hole ) {
- 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;
+
+ 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;
-
+ 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 )
+ 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 );
+ 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);
- 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;
+
+ } 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 );
-
+ 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;
-
- if( i >= 0 ) {
+ x_end2 = half_span;
+
+ if (i >= 0) {
// Make zero point wider on left
- if( i == 0 )
+ if (i == 0) {
x_ini -= zero_offset;
- // Zero or above draw solid lines
+ 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);
- } else {
- // Below zero draw dashed lines.
+ 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 );
-
- // 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);
- }
-
- // Calculate the location and draw the right side label
- Text( x_end+text_offset, y-label_height, TextLadder );
+ 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
}
TextList.draw();
glLineWidth(0.2);
-
+
LineList.draw();
-
+
glEnable(GL_LINE_STIPPLE);
- glLineStipple( 1, 0x00FF );
- StippleLineList.draw( );
+ 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);
+}
+
+
projects / flightgear.git / blobdiff