fly/flightgear
1
0
Fork 0
Code Activity

Neetha Girish <neethagirish@usa.net>

Browse source 
====================================

Cockpit.cxx
-----------
Commented #ifdef FIGHTER_HUD.

Hud.cxx
-------
Included code to read the xml file and draw the corresponding instrument.

Hud.hxx, Hud_ladr.cxx, Hud_card.cxx and Hud_labl.cxx
---------------------------------------------------
Integrated code to draw any kind of hud.

Preference.xml
---------------
Included XML file path in the sim/hud property.

ReadMe.xmlhud
-------------
The Readme.xmlhud describes the reconfigurable HUD implemented thru XML
files.
This commit is contained in:
curt 2001-01-05 16:44:48 +00:00
parent 6f6f19cf24
commit af80c2080b
6 changed files with 1735 additions and 2554 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

16
src/Cockpit/cockpit.cxx
View file

@ -286,22 +286,28 @@ float get_view_direction( void )
}
// $$$ begin - added, VS Renganathan 13 Oct 2K
#ifdef FIGHTER_HUD
// #ifdef FIGHTER_HUD
float get_Vx ( void )
{
float Vxx = current_aircraft.fdm_state->get_V_north_rel_ground();
// CLO - 5 Jan 2000 - something needs to get addressed here
// float Vxx = current_aircraft.fdm_state->get_V_north_rel_ground();
float Vxx = 0;
return (Vxx);
}
float get_Vy ( void )
{
float Vyy = current_aircraft.fdm_state->get_V_east_rel_ground();
// CLO - 5 Jan 2000 - something needs to get addressed here
// float Vyy = current_aircraft.fdm_state->get_V_east_rel_ground();
float Vyy = 0;
return (Vyy);
}
float get_Vz ( void )
{
float Vzz = current_aircraft.fdm_state->get_V_down_rel_ground();
// CLO - 5 Jan 2000 - something needs to get addressed here
// float Vzz = current_aircraft.fdm_state->get_V_down_rel_ground();
float Vzz = 0;
return (Vzz);
}
@ -508,7 +514,7 @@ float get_aux18 (void)
FGADA *fdm = (FGADA *)current_aircraft.fdm_state;
return fdm->get_aux18();
}
#endif
// #endif
// $$$ end - added, VS Renganathan 13 Oct 2K

1662
src/Cockpit/hud.cxx
View file

File diff suppressed because it is too large Load diff

187
src/Cockpit/hud.hxx
View file

@ -530,6 +530,8 @@ class instr_label : public instr_item {
int fontSize;
int blink;
char format_buffer[80];
bool lat;
bool lon;
public:
instr_label( int x,
@ -538,14 +540,16 @@ class instr_label : public instr_item {
UINT height,
FLTFNPTR data_source,
const char *label_format,
const char *pre_label_string = 0,
const char *post_label_string = 0,
float scale_data = 1.0,
UINT options = HUDS_TOP,
fgLabelJust justification = CENTER_JUST,
int font_size = SMALL,
int blinking = NOBLINK,
bool working = true);
const char *pre_label_string,
const char *post_label_string,
float scale_data,
UINT options,
fgLabelJust justification,
int font_size,
int blinking,
bool latitude,
bool longitude,
bool working);
~instr_label();
@ -574,14 +578,14 @@ class lat_label : public instr_item {
UINT height,
FLTFNPTR data_source,
const char *label_format,
const char *pre_label_string = 0,
const char *post_label_string = 0,
float scale_data = 1.0,
UINT options = HUDS_TOP,
fgLabelJust justification = CENTER_JUST,
int font_size = SMALL,
int blinking = NOBLINK,
bool working = true);
const char *pre_label_string,
const char *post_label_string,
float scale_data,
UINT options,
fgLabelJust justification,
int font_size,
int blinking,
bool working);
~lat_label();
@ -609,14 +613,14 @@ class lon_label : public instr_item {
UINT height,
FLTFNPTR data_source,
const char *label_format,
const char *pre_label_string = 0,
const char *post_label_string = 0,
float scale_data = 1.0,
UINT options = HUDS_TOP,
fgLabelJust justification = CENTER_JUST,
int font_size = SMALL,
int blinking = NOBLINK,
bool working = true);
const char *pre_label_string,
const char *post_label_string,
float scale_data,
UINT options,
fgLabelJust justification,
int font_size,
int blinking,
bool working);
~lon_label();
@ -652,13 +656,13 @@ class instr_scale : public instr_item {
FLTFNPTR load_fn,
UINT options,
float show_range,
float max_value = 100.0,
float min_value = 0.0,
float disp_scaling = 1.0,
UINT major_divs = 10,
UINT minor_divs = 5,
UINT rollover = 0,
int dp_showing = 2,
float max_value,
float min_value,
float disp_scaling,
UINT major_divs,
UINT minor_divs,
UINT rollover,
int dp_showing,
bool working = true);
virtual ~instr_scale();
@ -683,7 +687,20 @@ class instr_scale : public instr_item {
class hud_card : public instr_scale {
private:
float val_span;
string type;
float half_width_units;
bool draw_tick_bottom;
bool draw_tick_top;
bool draw_tick_right;
bool draw_tick_left;
bool draw_cap_bottom;
bool draw_cap_top;
bool draw_cap_right;
bool draw_cap_left;
float marker_offset;
bool pointer;
string pointer_type;
public:
hud_card( int x,
@ -692,15 +709,27 @@ class hud_card : public instr_scale {
UINT height,
FLTFNPTR load_fn,
UINT options,
float maxValue = 100.0,
float minValue = 0.0,
float disp_scaling = 1.0,
UINT major_divs = 10,
UINT minor_divs = 5,
UINT modulator = 100,
int dp_showing = 2,
float value_span = 100.0,
bool working = true);
float maxValue,
float minValue,
float disp_scaling,
UINT major_divs,
UINT minor_divs,
UINT modulator,
int dp_showing,
float value_span,
string type,
bool draw_tick_bottom,
bool draw_tick_top,
bool draw_tick_right,
bool draw_tick_left,
bool draw_cap_bottom,
bool draw_cap_top,
bool draw_cap_right,
bool draw_cap_left,
float marker_offset,
bool pointer,
string pointer_type,
bool working);
~hud_card();
hud_card( const hud_card & image);
@ -719,14 +748,14 @@ class guage_instr : public instr_scale {
UINT height,
FLTFNPTR load_fn,
UINT options,
float disp_scaling = 1.0,
float maxValue = 100,
float minValue = 0,
UINT major_divs = 50,
UINT minor_divs = 0,
int dp_showing = 2,
UINT modulus = 0,
bool working = true);
float disp_scaling,
float maxValue,
float minValue,
UINT major_divs,
UINT minor_divs,
int dp_showing,
UINT modulus,
bool working);
~guage_instr();
guage_instr( const guage_instr & image);
@ -750,8 +779,8 @@ class dual_instr_item : public instr_item {
UINT height,
FLTFNPTR chn1_source,
FLTFNPTR chn2_source,
bool working = true,
UINT options = HUDS_TOP);
bool working,
UINT options );
virtual ~dual_instr_item() {};
dual_instr_item( const dual_instr_item & image);
@ -773,12 +802,12 @@ class fgTBI_instr : public dual_instr_item {
int y,
UINT width,
UINT height,
FLTFNPTR chn1_source = get_roll,
FLTFNPTR chn2_source = get_sideslip,
float maxBankAngle = 45.0,
float maxSlipAngle = 5.0,
UINT gap_width = 5,
bool working = true);
FLTFNPTR chn1_source,
FLTFNPTR chn2_source,
float maxBankAngle,
float maxSlipAngle,
UINT gap_width,
bool working);
fgTBI_instr( const fgTBI_instr & image);
fgTBI_instr & operator = (const fgTBI_instr & rhs );
@ -800,29 +829,52 @@ class HudLadder : public dual_instr_item {
UINT minor_div;
UINT label_pos;
UINT scr_hole;
UINT minimal;
float vmax;
float vmin;
float factor;
string hudladder_type;
bool frl;
bool target_spot;
bool velocity_vector;
bool drift_marker;
bool alpha_bracket;
bool energy_marker;
bool climb_dive_marker;
bool glide_slope_marker;
float glide_slope;
bool energy_worm;
bool waypoint_marker;
fgTextList TextList;
fgLineList LineList;
fgLineList StippleLineList;
public:
HudLadder( int x,
HudLadder( string name,
int x,
int y,
UINT width,
UINT height,
UINT minimal = 0,
FLTFNPTR ptch_source = get_roll,
FLTFNPTR roll_source = get_pitch,
float span_units = 45.0,
float division_units = 10.0,
float minor_division = 0.0,
UINT screen_hole = 70,
UINT lbl_pos = 0,
bool working = true );
float factor,
FLTFNPTR ptch_source,
FLTFNPTR roll_source,
float span_units,
float division_units,
float minor_division,
UINT screen_hole,
UINT lbl_pos,
bool frl,
bool target_spot,
bool velocity_vector,
bool drift_marker,
bool alpha_bracket,
bool energy_marker,
bool climb_dive_marker,
bool glide_slope_marker,
float glide_slope,
bool energy_worm,
bool waypoint_marker,
bool working);
~HudLadder();
@ -867,6 +919,7 @@ extern void strokeString( int x,
char *msg,
void *font = GLUT_STROKE_ROMAN,
float theta = 0);
//extern void strokeString(float xx,
// float yy,
// char *msg,

791
src/Cockpit/hud_card.cxx
View file

File diff suppressed because it is too large Load diff

26
src/Cockpit/hud_labl.cxx
View file

@ -23,15 +23,20 @@ instr_label ::
fgLabelJust justification,
int font_size,
int blinking,
bool working ):
bool latitude,
bool longitude,
bool working):
instr_item( x, y, width, height,
data_source, scale_data,options, working ),
data_source,scale_data,options, working ),
pformat ( label_format ),
pre_str ( pre_label_string ),
post_str ( post_label_string ),
justify ( justification ),
fontSize ( font_size ),
blink ( blinking )
blink ( blinking ),
lat ( latitude ),
lon ( longitude )
{
if( pre_str != NULL) {
if( post_str != NULL ) {
@ -63,7 +68,10 @@ instr_label :: instr_label( const instr_label & image) :
pformat ( image.pformat ),
pre_str ( image.pre_str ),
post_str ( image.post_str ),
blink ( image.blink )
blink ( image.blink ),
lat ( image.lat ),
lon ( image.lon )
{
if( pre_str != NULL) {
if( post_str != NULL ) {
@ -91,6 +99,10 @@ instr_label & instr_label ::operator = (const instr_label & rhs )
justify = rhs.justify;
pre_str = rhs.pre_str;
post_str = rhs.post_str;
lat = rhs.lat;
lon = rhs.lon;
strcpy(format_buffer,rhs.format_buffer);
}
return *this;
@ -110,6 +122,12 @@ draw( void ) // Required method in base class
RECT scrn_rect = get_location();
if( data_available() ) {
if(lat)
sprintf( label_buffer, format_buffer, coord_format_lat(get_value()) );
else
if(lon)
sprintf( label_buffer, format_buffer, coord_format_lon(get_value()) );
else
sprintf( label_buffer, format_buffer, get_value() );
}
else {

633
src/Cockpit/hud_ladr.cxx
View file

@ -5,11 +5,12 @@
#define DO_PANEL_HACK
//====================== Top of HudLadder Class =======================
HudLadder :: HudLadder( int x,
HudLadder :: HudLadder( string name,
int x,
int y,
UINT width,
UINT height,
UINT mini,
float factr,
FLTFNPTR ptch_source,
FLTFNPTR roll_source,
float span_units,
@ -17,6 +18,17 @@ HudLadder :: HudLadder( int x,
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) :
dual_instr_item( x, y, width, height,
ptch_source,
@ -29,39 +41,58 @@ HudLadder :: HudLadder( int x,
label_pos ( lbl_pos ),
scr_hole ( screen_hole ),
vmax ( span_units/2 ),
vmin ( -vmax )
{
vmin ( -vmax ),
factor ( factr ),
hudladder_type ( name ),
frl ( frl_spot ),
velocity_vector ( vel_vec ),
drift_marker ( drift ),
alpha_bracket ( alpha ),
energy_marker ( energy ),
climb_dive_marker ( climb ),
target_spot ( target ),
glide_slope_marker ( glide ),
glide_slope ( glide_slope_val),
energy_worm ( worm_energy),
waypoint_marker ( waypoint)
{
if( !width_units ) {
width_units = 45;
}
// $$$ begin -added VS Renganthan 16 Oct 2k
#ifdef FIGHTER_HUD
factor = 480.0 / 33.75;
#else
// $$$ begin -added VS Renganthan 16 Oct 2k
factor = (float)get_span() / (float) width_units;
#endif
minimal = mini;
}
}
HudLadder :: ~HudLadder()
{
}
{
}
HudLadder ::
HudLadder( const HudLadder & image ) :
dual_instr_item( (dual_instr_item &) image),
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 )
{
}
factor ( image.factor ),
hudladder_type ( image.hudladder_type),
frl ( image.frl),
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),
target_spot ( image.target_spot),
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;
@ -71,25 +102,40 @@ HudLadder & HudLadder :: operator = ( const HudLadder & rhs )
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
//
// $$$ begin - added VS Renganathan, 13 Oct 2K
#ifdef FIGHTER_HUD
void HudLadder :: draw( void )
{
float x_ini;
float x_end;
float x_ini,x_ini2;
float x_end,x_end2;
float y;
int count;
float cosine, sine,xvvr,yvvr,Vxx,Vyy,Vzz,up_vel,ground_vel,actslope;
float Axx,Ayy,Azz,total_vel,pot_slope,t1,t2,psi,alpha,pla;
float vel_x,vel_y,drift;
char Textaux[8] ;
bool pitch_ladder;
bool climb_dive_ladder;
bool clip_plane;
GLdouble eqn_top[4] = {0.0,-1.0,0.0,0.0};
GLdouble eqn_left[4] = {-1.0,0.0,0.0,100.0};
@ -103,47 +149,37 @@ void HudLadder :: draw( void )
alpha = get_aoa();
pla = get_throttleval();
int lgear,wown,wowm,iclaw,ihook;
iclaw = get_iaux1();
int lgear,wown,wowm,ilcanclaw,ihook;
ilcanclaw = get_iaux1();
lgear = get_iaux2();
wown = get_iaux3();
wowm = get_iaux4();
ihook = get_iaux5();
float pitch_value = current_ch1() * RAD_TO_DEG;
vmin = pitch_value - (float)width_units;
vmax = pitch_value + (float)width_units; //$$$
if(hudladder_type=="Climb/Dive Ladder") {
pitch_ladder = false;
climb_dive_ladder = true;
clip_plane = true;
}
else
if(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);
//*********************************************************
//waypoint marker computation
float fromwp_lat,towp_lat,fromwp_lon,towp_lon,dist,delx,dely,hyp,theta,brg;
fromwp_lon = get_longitude()*DEG_TO_RAD;
fromwp_lat = get_latitude()*DEG_TO_RAD;
towp_lon = get_aux5()*DEG_TO_RAD;
towp_lat = get_aux6()*DEG_TO_RAD;
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*RAD_TO_DEG;
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 * RAD_TO_DEG; }
dist = dist*RAD_TO_DEG * 60.0*1852.0; //rad->deg->nm->m
//*********************************************************
// 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);
@ -156,8 +192,27 @@ void HudLadder :: draw( void )
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();
@ -187,24 +242,103 @@ void HudLadder :: draw( void )
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))*(640/45.0);
// printf("%f %f %f %f\n",vel_x,vel_y,drift,psi);
// 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();
}
// clip hud ladder
//****************************************************************
// 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 * M_PI/50.0);
sine = 6 * sin(count * 2 * M_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();
// alpha bracket - reqd only for landing (tied to hook)
// 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);
@ -219,11 +353,15 @@ void HudLadder :: draw( void )
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;
@ -232,6 +370,8 @@ void HudLadder :: draw( void )
t2 = asin((Vxx*Axx + Vyy*Ayy + Vzz*Azz)/(9.81*total_vel));
}
pot_slope = ((t2/3)*RAD_TO_DEG)*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);
@ -256,19 +396,30 @@ void HudLadder :: draw( void )
glVertex2f(vel_x+24, pot_slope+5);
glEnd();
}
// ramp reticle - for ski jump takeoff only
if (iclaw == 1) {
}
//**********************************************************
// 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*RAD_TO_DEG*4.0 - 134);
glVertex2f(+6, t2*RAD_TO_DEG*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);
@ -276,66 +427,41 @@ void HudLadder :: draw( void )
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();
// draw velocity vector
glBegin(GL_LINE_LOOP); // Use polygon to approximate a circle
for(count=0; count<50; count++) {
cosine = 6 * cos(count * 2 * M_PI/50.0);
sine = 6 * sin(count * 2 * M_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();
if (lgear == 1) {
// undercarriage status
glBegin(GL_LINE_STRIP);
glVertex2f(vel_x+8, vel_y);
glVertex2f(vel_x+8, vel_y-4);
glEnd();
glBegin(GL_LINE_STRIP);
glVertex2f(vel_x-8, vel_y);
glVertex2f(vel_x-8, vel_y-4);
glEnd();
glBegin(GL_LINE_STRIP);
glVertex2f(vel_x, vel_y-6);
glVertex2f(vel_x, vel_y-10);
glEnd();
}
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(climb_dive_ladder) {// CONFORMAL_HUD
vmin = pitch_value - (float)width_units;
vmax = pitch_value + (float)width_units;
// FRL marker not rotated - this line shifted below
glTranslatef( vel_x, vel_y, 0);
}
else
if (pitch_ladder) {//Default Hud
vmin = pitch_value - (float)width_units * 0.5f;
vmax = pitch_value + (float)width_units * 0.5f;
}
glRotatef(roll_value * RAD_TO_DEG, 0.0, 0.0, 1.0);
// FRL marker not rotated - this line shifted below
if( div_units ) {
@ -347,7 +473,13 @@ void HudLadder :: draw( void )
float bot ;
float top ;
float text_offset = 4.0f ;
float zero_offset = 50.0f ;
float zero_offset;
if(climb_dive_ladder)
zero_offset = 50.0f ;
else
if(pitch_ladder)
zero_offset = 10.0f ;
fntFont *font = HUDtext->getFont();
float pointsize = HUDtext->getPointSize();
@ -362,6 +494,7 @@ void HudLadder :: draw( void )
int i = FloatToInt(vmin);
if( !scr_hole ) {
x_end = half_span;
for( ; i<last ; i++ ) {
y = (((float)(i - pitch_value) * factor) + .5f);
@ -375,7 +508,6 @@ void HudLadder :: draw( void )
label_height = (top - bot)/2.0f;
x_ini = -half_span;
x_end = half_span;
if( i >= 0 ) {
// Make zero point wider on left
@ -397,9 +529,15 @@ 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);
x_end = -half_span + hole;
x_ini2= half_span - hole;
for( ; i<last ; i++ ) {
// y = (((float)(i - pitch_value) * factor) + .5);
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
@ -410,64 +548,57 @@ void HudLadder :: draw( void )
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 );
// 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;
x_end2= half_span;
if( i >= 0 ) {
// Make zero point wider on left
if( i == 0 ) {
x_ini -= zero_offset;
x_end2 +=zero_offset;
} else {
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);
}
}
Line(x_ini, y, x_end, y);
Line(x_ini2, y, x_end2, y);
} else {
// Below zero draw dashed lines.
if(climb_dive_ladder) {
Line(x_end, y+5.0, x_end, y);
Line(x_ini2, y+5.0, x_ini2, y);
}
StippleLine(x_ini, y, x_end, y);
StippleLine(x_ini2, y, x_end2, 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 );
// 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;
} else {
Line(x_ini, y-5.0, x_ini, y);
}
// Zero or above draw solid lines
Line(x_ini, y, x_end, y);
} else {
// Below zero draw dashed lines.
Line(x_ini, y+5.0, x_ini, y);
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 );
}
}
// draw appraoch glide slope marker - for landing only (tied to hook)
// OBJECT LADDER MARK
// TYPE LINE
// ATTRIB - ON CONDITION
// draw appraoch glide slope marker
if (glide_slope_marker) {
if (ihook) {
Line(-half_span+15, (-4-actslope)*factor, -half_span + hole, (-4-actslope)*factor);
Line(half_span-15, (-4-actslope)*factor, half_span - hole, (-4-actslope)*factor);
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);
@ -482,11 +613,41 @@ void HudLadder :: draw( void )
glDisable(GL_CLIP_PLANE0);
glDisable(GL_CLIP_PLANE1);
glDisable(GL_CLIP_PLANE2);
// glDisable(GL_SCISSOR_TEST);
// glDisable(GL_SCISSOR_TEST);
glPopMatrix();
//*************************************************************
// waypoint marker
if (fabs(brg-psi) > 10.0) {
//*************************************************************
//*************************************************************
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()*DEG_TO_RAD;
fromwp_lat = get_latitude()*DEG_TO_RAD;
towp_lon = get_aux5()*DEG_TO_RAD;
towp_lat = get_aux6()*DEG_TO_RAD;
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*RAD_TO_DEG;
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 * RAD_TO_DEG; }
dist = dist*RAD_TO_DEG * 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);
@ -501,9 +662,9 @@ if (fabs(brg-psi) > 10.0) {
glVertex2f(2.5,20.0);
glEnd();
glPopMatrix();
}
// waypoint marker on heading scale
if (fabs(brg-psi) < 12.0) {
}
// waypoint marker on heading scale
if (fabs(brg-psi) < 12.0) {
glBegin(GL_LINE_LOOP);
glVertex2f(((brg-psi)*60/25)+320,240.0);
glVertex2f(((brg-psi)*60/25)+326,240.0-4);
@ -513,171 +674,7 @@ if (fabs(brg-psi) < 12.0) {
glVertex2f(((brg-psi)*60/25)+317,240.0-4);
glVertex2f(((brg-psi)*60/25)+314,240.0-4);
glEnd();
}
//*************************************************************
}
#else
// $$$ end - added VS Renganathan, 13 Oct 2K
// draw DEFAULT_HUD
void HudLadder :: draw( void )
{
POINT centroid = get_centroid();
float roll_value = current_ch2();
glPushMatrix();
glTranslatef( centroid.x, centroid.y, 0);
// Alex's panel patch
// glScalef( globals->get_options()->get_fov()/55.0, 1.0, 1.0 );
glRotatef(roll_value * RAD_TO_DEG, 0.0, 0.0, 1.0);
// Draw the target spot.
#define CENTER_DIAMOND_SIZE 6.0f
glBegin(GL_LINE_LOOP);
glVertex2f( CENTER_DIAMOND_SIZE, 0.0);
glVertex2f( 0.0, CENTER_DIAMOND_SIZE);
glVertex2f( -CENTER_DIAMOND_SIZE, 0.0);
glVertex2f( 0.0, -CENTER_DIAMOND_SIZE);
glEnd();
if( minimal || ! div_units ) {
glPopMatrix();
return;
}
float x_ini;
float x_end;
float y;
float pitch_value = current_ch1() * RAD_TO_DEG;
vmin = pitch_value - (float)width_units * 0.5f;
vmax = pitch_value + (float)width_units * 0.5f;
RECT box = get_location();
float half_span = box.right * 0.5f ;
char TextLadder[8] ;
float label_length ;
float label_height ;
float left ;
float right ;
float bot ;
float top ;
float text_offset = 4.0f ;
float zero_offset = 10.0f ;
fntFont *font = HUDtext->getFont();
float pointsize = HUDtext->getPointSize();
float italic = HUDtext->getSlant();
TextList.setFont( HUDtext );
TextList.erase();
LineList.erase();
StippleLineList.erase();
int last = FloatToInt(vmax)+1;
int i = FloatToInt(vmin);
if( !scr_hole ) {
x_end = half_span;
for( ; i<last ; i++ ) {
y = (((float)(i - pitch_value) * factor) + .5f);
if( !(i % div_units )) { // At integral multiple of div
sprintf( TextLadder, "%d", i );
font->getBBox ( TextLadder, pointsize, italic,
&left, &right, &bot, &top ) ;
label_length = right - left;
label_length += text_offset;
label_height = (top - bot) * 0.5f;
x_ini = -half_span;
if( i >= 0 ) {
// Make zero point wider on left
if( i == 0 )
x_ini -= zero_offset;
// Zero or above draw solid lines
Line(x_ini, y, x_end, y);
} else {
// Below zero draw dashed lines.
StippleLine(x_ini, y, x_end, y);
}
// Calculate the position of the left text and write it.
Text( x_ini-label_length, y-label_height, TextLadder );
Text( x_end+text_offset, y-label_height, TextLadder );
}
}
} else { // scr_hole != 0
// Draw ladder with space in the middle of the lines
float x_ini2;
float x_end2;
float hole = (float)((scr_hole)*0.5f);
x_end = -half_span + hole;
x_ini2 = half_span - hole;
for( ; i<last ; i++ ) {
y = (((float)(i - pitch_value) * factor) + .5);
if( !(i % div_units )) { // At integral multiple of div
sprintf( TextLadder, "%d", i );
font->getBBox ( TextLadder, pointsize, italic,
&left, &right, &bot, &top ) ;
label_length = right - left;
label_length += text_offset;
label_height = (top - bot) * 0.5f;
// Start by calculating the points and drawing the
// left side lines.
x_ini = -half_span;
x_end2 = half_span;
if( i >= 0 ) {
// Make zero point wider on left
if( i == 0 ) {
x_ini -= zero_offset;
x_end2 += zero_offset;
}
// Zero or above draw solid lines
Line(x_ini, y, x_end, y);
Line(x_ini2, y, x_end2, y);
} else {
// Below zero draw dashed lines.
StippleLine(x_ini, y, x_end, y);
StippleLine(x_ini2, y, x_end2, y);
}
// Calculate the location of the left side label using
Text( x_ini-label_length, y-label_height, TextLadder );
// Calculate the location and draw the right side label
Text( x_end2+text_offset, y-label_height, TextLadder );
}
}
}
TextList.draw();
LineList.draw();
glEnable(GL_LINE_STIPPLE);
#ifdef DO_PANEL_HACK
glLineStipple( 1, fgPanelVisible() ? 0x0F0F : 0x00FF );
#else
glLineStipple( 1, 0x00FF );
#endif
StippleLineList.draw( );
glDisable(GL_LINE_STIPPLE);
// } // if(div_units)
glPopMatrix();
}
#endif // DEFAULT_HUD
//*************************************************************
}// if waypoint_marker
}//draw