fly/flightgear
1
0
Fork 0
Code Activity

HUD format changed contributed by Norman Vine.

Browse source
This commit is contained in:
curt 1999-05-12 02:04:38 +00:00
parent 41544fe6e5
commit a9b592c7e9
15 changed files with 2908 additions and 1744 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
Simulator/Cockpit/Makefile.am
View file

@ -5,6 +5,7 @@ libCockpit_a_SOURCES = \
hud.cxx hud.hxx \
hud_card.cxx hud_dnst.cxx hud_guag.cxx hud_inst.cxx \
hud_labl.cxx hud_ladr.cxx \
hud_lat.cxx hud_lon.cxx \
hud_scal.cxx hud_tbi.cxx \
panel.cxx panel.hxx

558
Simulator/Cockpit/cockpit.cxx
View file

@ -47,11 +47,10 @@
#include <Math/mat3.h>
#include <Math/polar3d.hxx>
#include <Scenery/scenery.hxx>
#include <Time/fg_time.hxx>
#include <Time/fg_timer.hxx>
#include <Time/fg_time.hxx>
#include "cockpit.hxx"
#include "panel.hxx"
// This is a structure that contains all data related to
@ -62,41 +61,68 @@ static pCockpit ac_cockpit;
// The following routines obtain information concerntin the aircraft's
// current state and return it to calling instrument display routines.
// They should eventually be member functions of the aircraft.
//
double get_latitude( void )
float get_latitude( void )
{
return (double)((int)(current_aircraft.fdm_state->get_Latitude()*RAD_TO_DEG));
// FGState *f;
double lat;
// current_aircraft.fdm_state
lat = current_aircraft.fdm_state->get_Latitude() * RAD_TO_DEG;
float flat = lat;
return(flat);
// if(fabs(lat)<1.0)
// {
// if(lat<0)
// return( -(double)((int)lat) );
// else
// return( (double)((int)lat) );
// }
// return( (double)((int)lat) );
}
double get_lat_min( void )
float get_lat_min( void )
{
// FGState *f;
double a, d;
// current_aircraft.fdm_state
a = current_aircraft.fdm_state->get_Latitude() * RAD_TO_DEG;
if (a < 0.0) {
a = -a;
}
d = (double) ( (int) a);
return( (a - d) * 60.0);
float lat_min = (a - d) * 60.0;
return(lat_min );
}
double get_longitude( void )
float get_longitude( void )
{
return( (double)((int) (current_aircraft.fdm_state->get_Longitude()
* RAD_TO_DEG)) );
double lon;
// FGState *f;
// current_aircraft.fdm_state
lon = current_aircraft.fdm_state->get_Longitude() * RAD_TO_DEG;
float flon = lon;
return(flon);
// if(fabs(lon)<1.0)
// {
// if(lon<0)
// return( -(double)((int)lon) );
// else
// return( (double)((int)lon) );
// }
// return( (double)((int)lon) );
}
double get_long_min( void )
{
double a, d;
a = current_aircraft.fdm_state->get_Longitude() * RAD_TO_DEG;
if (a < 0.0) {
a = -a;
}
d = (double) ( (int) a);
return( (a - d) * 60.0);
}
char*
get_formated_gmt_time( void )
@ -111,112 +137,442 @@ get_formated_gmt_time( void )
}
double get_throttleval( void )
float get_long_min( void )
{
return controls.get_throttle( 0 ); // Hack limiting to one engine
// FGState *f;
double a, d;
// current_aircraft.fdm_state
a = current_aircraft.fdm_state->get_Longitude() * RAD_TO_DEG;
if (a < 0.0) {
a = -a;
}
d = (double) ( (int) a);
float lon_min = (a - d) * 60.0;
return(lon_min);
}
double get_aileronval( void )
float get_throttleval( void )
{
return controls.get_aileron();
float throttle = controls.get_throttle( 0 );
return (throttle); // Hack limiting to one engine
}
double get_elevatorval( void )
float get_aileronval( void )
{
return controls.get_elevator();
float aileronval = controls.get_aileron();
return (aileronval);
}
double get_elev_trimval( void )
float get_elevatorval( void )
{
return controls.get_elevator_trim();
float elevator_val = (float)controls.get_elevator();
return elevator_val;
}
double get_rudderval( void )
float get_elev_trimval( void )
{
return controls.get_rudder();
float elevatorval = controls.get_elevator_trim();
return (elevatorval);
}
double get_speed( void )
float get_rudderval( void )
{
return( current_aircraft.fdm_state->get_V_equiv_kts() );
float rudderval = controls.get_rudder();
return (rudderval);
}
double get_aoa( void )
float get_speed( void )
{
return( current_aircraft.fdm_state->get_Alpha() * RAD_TO_DEG );
// Make an explicit function call.
float speed = current_aircraft.fdm_state->get_V_equiv_kts();
return( speed );
}
double get_roll( void )
float get_aoa( void )
{
return( current_aircraft.fdm_state->get_Phi() );
float aoa = current_aircraft.fdm_state->get_Alpha() * RAD_TO_DEG;
return( aoa );
}
double get_pitch( void )
float get_roll( void )
{
return( current_aircraft.fdm_state->get_Theta() );
float roll = current_aircraft.fdm_state->get_Phi();
return( roll );
}
double get_heading( void )
float get_pitch( void )
{
return( current_aircraft.fdm_state->get_Psi() * RAD_TO_DEG );
float pitch = current_aircraft.fdm_state->get_Theta();
return( pitch );
}
double get_altitude( void )
float get_heading( void )
{
float heading = (current_aircraft.fdm_state->get_Psi() * RAD_TO_DEG);
return( heading );
}
float get_altitude( void )
{
// FGState *f;
// double rough_elev;
// current_aircraft.fdm_state
// rough_elev = mesh_altitude(f->get_Longitude() * RAD_TO_ARCSEC,
// f->get_Latitude() * RAD_TO_ARCSEC);
float altitude;
if ( current_options.get_units() == fgOPTIONS::FG_UNITS_FEET ) {
return current_aircraft.fdm_state->get_Altitude();
altitude = current_aircraft.fdm_state->get_Altitude();
} else {
return current_aircraft.fdm_state->get_Altitude() * FEET_TO_METER;
altitude = (current_aircraft.fdm_state->get_Altitude() * FEET_TO_METER);
}
return altitude;
}
double get_agl( void )
float get_agl( void )
{
// FGState *f;
// f = current_aircraft.fdm_state;
float agl;
if ( current_options.get_units() == fgOPTIONS::FG_UNITS_FEET ) {
return current_aircraft.fdm_state->get_Altitude()
- scenery.cur_elev * METER_TO_FEET;
agl = (current_aircraft.fdm_state->get_Altitude()
- scenery.cur_elev * METER_TO_FEET);
} else {
return current_aircraft.fdm_state->get_Altitude() * FEET_TO_METER
- scenery.cur_elev;
agl = (current_aircraft.fdm_state->get_Altitude() * FEET_TO_METER
- scenery.cur_elev);
}
return agl;
}
double get_sideslip( void )
float get_sideslip( void )
{
return( current_aircraft.fdm_state->get_Beta() );
// FGState *f;
// f = current_aircraft.fdm_state;
float sideslip = current_aircraft.fdm_state->get_Beta();
return( sideslip );
}
double get_frame_rate( void )
float get_frame_rate( void )
{
return (double) general.get_frame_rate();
float frame_rate = general.get_frame_rate();
return (frame_rate);
}
double get_fov( void )
float get_fov( void )
{
return (current_options.get_fov());
float fov = current_options.get_fov();
return (fov);
}
double get_vfc_ratio( void )
float get_vfc_ratio( void )
{
return current_view.get_vfc_ratio();
float vfc = current_view.get_vfc_ratio();
return (vfc);
}
double get_vfc_tris_drawn ( void )
float get_vfc_tris_drawn ( void )
{
return current_view.get_tris_rendered();
float rendered = current_view.get_tris_rendered();
return (rendered);
}
double get_climb_rate( void )
float get_vfc_tris_culled ( void )
{
float culled = current_view.get_tris_culled();
return (culled);
}
float get_climb_rate( void )
{
// FGState *f;
// current_aircraft.fdm_state
float climb_rate;
if ( current_options.get_units() == fgOPTIONS::FG_UNITS_FEET ) {
return current_aircraft.fdm_state->get_Climb_Rate() * 60.0;
climb_rate = current_aircraft.fdm_state->get_Climb_Rate() * 60.0;
} else {
return current_aircraft.fdm_state->get_Climb_Rate()
* FEET_TO_METER * 60.0;
climb_rate = current_aircraft.fdm_state->get_Climb_Rate() * FEET_TO_METER * 60.0;
}
return (climb_rate);
}
float get_view_direction( void )
{
// FGState *f;
// FGView *pview;
double view;
// pview = &current_view;
// current_aircraft.fdm_state
view = FG_2PI - current_view.get_view_offset();
view = ( current_aircraft.fdm_state->get_Psi() + view) * RAD_TO_DEG;
if(view > 360.)
view -= 360.;
else if(view<0.)
view += 360.;
float fview = view;
return( fview );
}
#ifdef NOT_USED
/****************************************************************************/
/* Convert degrees to dd mm'ss.s" (DMS-Format) */
/****************************************************************************/
char *dmshh_format(double degrees)
{
static char buf[16];
int deg_part;
int min_part;
double sec_part;
if (degrees < 0)
degrees = -degrees;
deg_part = degrees;
min_part = 60.0 * (degrees - deg_part);
sec_part = 3600.0 * (degrees - deg_part - min_part / 60.0);
/* Round off hundredths */
if (sec_part + 0.005 >= 60.0)
sec_part -= 60.0, min_part += 1;
if (min_part >= 60)
min_part -= 60, deg_part += 1;
sprintf(buf,"%02d*%02d\'%05.2f\"",deg_part,min_part,sec_part);
return buf;
}
#endif // 0
/****************************************************************************/
/* Convert degrees to dd mm'ss.s'' (DMS-Format) */
/****************************************************************************/
static char *toDMS(float a)
{
int neg = 0;
float d, m, s;
static char dms[16];
if (a < 0.0f) {
a = -a;
neg = 1;
}
d = (float) ((int) a);
a = (a - d) * 60.0f;
m = (float) ((int) a);
s = (a - m) * 60.0f;
if (s > 59.5f) {
s = 0.0f;
m += 1.0f;
}
if (m > 59.5f) {
m = 0.0f;
d += 1.0f;
}
if (neg)
d = -d;
sprintf(dms, "%.0f*%02.0f'%04.1f\"", d, m, s);
return dms;
}
/****************************************************************************/
/* Convert degrees to dd mm.mmm' (DMM-Format) */
/****************************************************************************/
static char *toDM(float a)
{
int neg = 0;
float d, m;
static char dm[16];
if (a < 0.0f) {
a = -a;
neg = 1;
}
d = (float) ( (int) a);
m = (a - d) * 60.0f;
if (m > 59.5f) {
m = 0.0f;
d += 1.0f;
}
if (neg) d = -d;
sprintf(dm, "%.0f*%06.3f'", d, m);
return dm;
}
static char *(*fgLatLonFormat)(float);
char *coord_format_lat(float latitude)
{
static char buf[16];
sprintf(buf,"%s%c",
// dmshh_format(latitude),
// toDMS(latitude),
// toDM(latitude),
fgLatLonFormat(latitude),
latitude > 0 ? 'N' : 'S');
return buf;
}
char *coord_format_lon(float longitude)
{
static char buf[80];
sprintf(buf,"%s%c",
// dmshh_format(longitude),
// toDMS(longitude),
// toDM(longitude),
fgLatLonFormat(longitude),
longitude > 0 ? 'E' : 'W');
return buf;
}
void fgLatLonFormatToggle( puObject *)
{
static int toggle = 0;
if ( toggle )
fgLatLonFormat = toDM;
else
fgLatLonFormat = toDMS;
toggle = ~toggle;
}
#ifdef NOT_USED
char *coord_format_latlon(double latitude, double longitude)
{
static char buf[1024];
sprintf(buf,"%s%c %s%c",
dmshh_format(latitude),
latitude > 0 ? 'N' : 'S',
dmshh_format(longitude),
longitude > 0 ? 'E' : 'W');
return buf;
}
#endif
#ifdef FAST_TEXT_TEST
#undef FAST_TEXT_TEST
#endif
#ifdef FAST_TEXT_TEST
static unsigned int first=0, last=128;
unsigned int font_base;
#define FONT "-adobe-courier-medium-r-normal--24-240-75-75-m-150-iso8859-1"
HFONT hFont;
void Font_Setup(void)
{
#ifdef _WIN32
int count;
HDC hdc;
HGLRC hglrc;
hdc = wglGetCurrentDC();
hglrc = wglGetCurrentContext();
if (hdc == 0 || hglrc == 0) {
printf("Could not get context or DC\n");
exit(1);
}
if (!wglMakeCurrent(hdc, hglrc)) {
printf("Could not make context current\n");
exit(1);
}
#define FONTBASE 0x1000
/*
hFont = GetStockObject(SYSTEM_FONT);
hFont = CreateFont(h, w, esc, orient, weight,
ital, under, strike, set, out, clip, qual, pitch/fam, face);
*/
hFont = CreateFont(30, 0, 0, 0, FW_NORMAL,
FALSE, FALSE, FALSE, ANSI_CHARSET,
OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, DRAFT_QUALITY,
FIXED_PITCH | FF_MODERN, "Arial");
if (!hFont) {
MessageBox(WindowFromDC(hdc),
"Failed to find acceptable bitmap font.",
"OpenGL Application Error",
MB_ICONERROR | MB_OK);
exit(1);
}
(void) SelectObject(hdc, hFont);
wglUseFontBitmaps(hdc, 0, 255, FONTBASE);
glListBase(FONTBASE);
#if 0
SelectObject (hdc, GetStockObject (SYSTEM_FONT));
count=last-first+1;
font_base = glGenLists(count);
wglUseFontBitmaps (hdc, first, last, font_base);
if (font_base == 0) {
printf("Could not generate Text_Setup list\n");
exit(1);
}
#endif // 0
#else
Display *Dpy;
XFontStruct *fontInfo;
Font id;
Dpy = XOpenDisplay(NULL);
fontInfo = XLoadQueryFont(Dpy, FONT);
if (fontInfo == NULL)
{
printf("Failed to load font %s\n", FONT);
exit(1);
}
id = fontInfo->fid;
first = fontInfo->min_char_or_byte2;
last = fontInfo->max_char_or_byte2;
base = glGenLists((GLuint) last+1);
if (base == 0) {
printf ("out of display lists\n");
exit (1);
}
glXUseXFont(id, first, last-first+1, base+first);
#endif
}
static void
drawString(char *string, GLfloat x, GLfloat y, GLfloat color[4])
{
glColor4fv(color);
glRasterPos2f(x, y);
glCallLists(strlen(string), GL_BYTE, (GLbyte *) string);
}
#endif // #ifdef FAST_TEXT_TEST
bool fgCockpitInit( fgAIRCRAFT *cur_aircraft )
{
FG_LOG( FG_COCKPIT, FG_INFO, "Initializing cockpit subsystem" );
@ -233,6 +589,10 @@ bool fgCockpitInit( fgAIRCRAFT *cur_aircraft )
// HI_Head is now a null pointer so we can generate a new list from the
// current aircraft.
#ifdef FAST_TEXT_TEST
Font_Setup();
#endif // #ifdef FAST_TEXT_TEST
fgHUDInit( cur_aircraft );
ac_cockpit = new fg_Cockpit();
@ -240,6 +600,9 @@ bool fgCockpitInit( fgAIRCRAFT *cur_aircraft )
new FGPanel;
}
// Have to set the LatLon display type
fgLatLonFormat = toDM;
FG_LOG( FG_COCKPIT, FG_INFO,
" Code " << ac_cockpit->code() << " Status "
<< ac_cockpit->status() );
@ -249,6 +612,15 @@ bool fgCockpitInit( fgAIRCRAFT *cur_aircraft )
void fgCockpitUpdate( void ) {
#define DISPLAY_COUNTER
#ifdef DISPLAY_COUNTER
static float lightCheck[4] = { 0.7F, 0.7F, 0.7F, 1.0F };
char buf[64],*ptr;
// int fontSize;
int c;
#endif
FG_LOG( FG_COCKPIT, FG_DEBUG,
"Cockpit: code " << ac_cockpit->code() << " status "
<< ac_cockpit->status() );
@ -258,6 +630,64 @@ void fgCockpitUpdate( void ) {
// If these is anything to draw it will.
fgUpdateHUD();
}
#ifdef DISPLAY_COUNTER
else
{
float fps = get_frame_rate();
float tris = fps * get_vfc_tris_drawn();
float culled = fps * get_vfc_tris_culled();
int len = sprintf(buf," %4.1f %7.0f %7.0f",
fps, tris, culled);
// sprintf(buf,"Tris Per Sec: %7.0f", t);
// fontSize = (current_options.get_xsize() > 1000) ? LARGE : SMALL;
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
gluOrtho2D(0, 1024, 0, 768);
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
glDisable(GL_DEPTH_TEST);
glDisable(GL_LIGHTING);
// glColor3f (.90, 0.27, 0.67);
#ifdef FAST_TEXT_TEST
drawString(buf, 250.0F, 10.0F, lightCheck);
// glRasterPos2f( 220, 10);
// for (int i=0; i < len; i++) {
// glCallList(font_base+buf[i]);
// }
#else
glColor3f (.8, 0.8, 0.8);
glTranslatef( 400, 10, 0);
glScalef(.1, .1, 0.0);
ptr = buf;
while ( ( c = *ptr++) ){
glutStrokeCharacter( GLUT_STROKE_MONO_ROMAN, c);
}
#endif // #ifdef FAST_TEXT_TEST
// glutStrokeCharacter( GLUT_STROKE_MONO_ROMAN, ' ');
// glutStrokeCharacter( GLUT_STROKE_MONO_ROMAN, ' ');
// ptr = get_formated_gmt_time();
// while ( ( c = *ptr++) ){
// glutStrokeCharacter( GLUT_STROKE_MONO_ROMAN, c);
// }
glEnable(GL_DEPTH_TEST);
glEnable(GL_LIGHTING);
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glPopMatrix();
}
#endif // DISPLAY_COUNTER
if ( current_options.get_panel_status() &&
(fabs( current_view.get_view_offset() ) < 0.2) )
@ -268,5 +698,3 @@ void fgCockpitUpdate( void ) {
FGPanel::OurPanel->Update();
}
}

48
Simulator/Cockpit/cockpit.hxx
View file

@ -1,24 +1,26 @@
// cockpit.hxx -- cockpit defines and prototypes (initial draft)
//
// Written by Michele America, started September 1997.
//
// Copyright (C) 1997 Michele F. America - nomimarketing@mail.telepac.pt
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License as
// published by the Free Software Foundation; either version 2 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
//
// $Id$
/**************************************************************************
* cockpit.hxx -- cockpit defines and prototypes (initial draft)
*
* Written by Michele America, started September 1997.
*
* Copyright (C) 1997 Michele F. America - nomimarketing@mail.telepac.pt
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*
* $Id$
**************************************************************************/
#ifndef _COCKPIT_HXX
@ -53,6 +55,4 @@ bool fgCockpitInit( fgAIRCRAFT *cur_aircraft );
void fgCockpitUpdate( void );
#endif // _COCKPIT_HXX
#endif /* _COCKPIT_HXX */

692
Simulator/Cockpit/hud.cxx
View file

File diff suppressed because it is too large Load diff

409
Simulator/Cockpit/hud.hxx
View file

@ -44,8 +44,8 @@
# include <values.h> // for MAXINT
#endif
#include <deque> // STL double ended queue
#include <vector> // STL vector
#include <deque> // STL double ended queue
#include <fg_typedefs.h>
#include <fg_constants.h>
@ -53,6 +53,10 @@
#include <FDM/flight.hxx>
#include <Controls/controls.hxx>
//#include "glfont.h"
//extern GLFONT *myFont;
FG_USING_STD(deque);
FG_USING_STD(vector);
@ -151,28 +155,36 @@ enum fgLabelJust{ LEFT_JUST, CENTER_JUST, RIGHT_JUST } ;
// #define HUD_INSTR_HORIZON 3
// #define HUD_INSTR_LABEL 4
extern double get_throttleval ( void );
extern double get_aileronval ( void );
extern double get_elevatorval ( void );
extern double get_elev_trimval( void );
extern double get_rudderval ( void );
extern double get_speed ( void );
extern double get_aoa ( void );
extern double get_roll ( void );
extern double get_pitch ( void );
extern double get_heading ( void );
extern double get_altitude ( void );
extern double get_agl ( void );
extern double get_sideslip ( void );
extern double get_frame_rate ( void );
extern double get_latitude ( void );
extern double get_lat_min ( void );
extern double get_longitude ( void );
extern double get_long_min ( void );
extern double get_fov ( void );
extern double get_vfc_ratio ( void );
extern double get_vfc_tris_drawn ( void );
extern double get_climb_rate ( void );
// in cockpit.cxx
extern float get_throttleval ( void );
extern float get_aileronval ( void );
extern float get_elevatorval ( void );
extern float get_elev_trimval( void );
extern float get_rudderval ( void );
extern float get_speed ( void );
extern float get_aoa ( void );
extern float get_roll ( void );
extern float get_pitch ( void );
extern float get_heading ( void );
extern float get_view_direction( void );
extern float get_altitude ( void );
extern float get_agl ( void );
extern float get_sideslip ( void );
extern float get_frame_rate ( void );
extern float get_latitude ( void );
extern float get_lat_min ( void );
extern float get_longitude ( void );
extern float get_long_min ( void );
extern float get_fov ( void );
extern float get_vfc_ratio ( void );
extern float get_vfc_tris_drawn ( void );
extern float get_vfc_tris_culled ( void );
extern float get_climb_rate ( void );
extern char *coord_format_lat(float);
extern char *coord_format_lon(float);
//extern char *coord_format_latlon(float latitude, float longitude); // cockpit.cxx
extern char *get_formated_gmt_time( void );
enum hudinstype{ HUDno_instr,
HUDscale,
@ -191,6 +203,131 @@ typedef struct gltagRGBTRIPLE { // rgbt
GLfloat Green;
GLfloat Red;
} glRGBTRIPLE;
/*
struct fgVertex2D {
UINT x, y;
fgVertex2D( UINT a = 0, UINT b =0 )
: x(a), y(b) {}
fgVertex2D( const fgVertex2D & image )
: x(image.x), y(image.y) {}
fgVertex2D& operator= ( const fgVertex2D & image ) {
x = image.x; y = image.y; return *this;
}
~fgVertex2D() {}
};
*/
class fgLineSeg2D {
private:
GLfloat x0, y0, x1, y1; //UINT
public:
fgLineSeg2D( GLfloat a = 0, GLfloat b =0, GLfloat c = 0, GLfloat d =0 )
: x0(a), y0(b), x1(c), y1(d) {}
fgLineSeg2D( const fgLineSeg2D & image )
: x0(image.x0), y0(image.y0), x1(image.x1), y1(image.y1) {}
fgLineSeg2D& operator= ( const fgLineSeg2D & image ) {
x0 = image.x0; y0 = image.y0; x1 = image.x1; y1 = image.y1; return *this;
}
~fgLineSeg2D() {}
void draw()
{
glVertex2f(x0, y0);
glVertex2f(x1, y1);
}
};
#define USE_HUD_TextList
#ifdef USE_HUD_TextList
//#define FAST_TEXT_TEST
#ifdef FAST_TEXT_TEST
extern void Font_Setup(void);
extern unsigned int font_base;
#endif
class fgTextString {
private:
void *font;
char msg[80];
float x, y;
// static GLfloat mat[16];
public:
fgTextString( void *d = NULL, char *c = NULL, UINT x = 0, UINT y =0 )
: font(d), x(x), y(y) {strcpy(msg,c);}
fgTextString( const fgTextString & image )
: font(image.font), x(image.x), y(image.y) {strcpy(msg,image.msg);}
fgTextString& operator = ( const fgTextString & image ) {
font = image.font; strcpy(msg,image.msg); x = image.x; y = image.y;
return *this;
}
~fgTextString() {msg[0]='\0';}
// void set_mat(void) {
// glScalef(.075, .075, 0.0);
// glGetFloatv(GL_MODELVIEW_MATRIX, mat);
// }
void draw()
{
#ifdef FAST_TEXT_TEST
glRasterPos2f( x, y);
int len = (int) strlen(msg);
for (int i=0; i < len; i++) {
glCallList(font_base+msg[i]);
}
// glFontTextOut ( msg, x, y, 0.0f);
#else
#define USE_STROKED_CHAR
#ifdef USE_STROKED_CHAR
int c;
char *buf;
buf = msg;
if(*buf)
{
// glRasterPos2f( x, y);
glTranslatef( x, y, 0);
glScalef(.075, .075, 0.0);
while ((c=*buf++)) {
glutStrokeCharacter( GLUT_STROKE_MONO_ROMAN, c);
}
}
#else
char *c = msg;
if(*c)
{
glRasterPos2f(x, y);
while (*c) {
glutBitmapCharacter(font, *c);
c++;
}
}
#endif // #ifdef USE_STROKED_CHAR
#endif // FAST_TEXT_TEST
}
};
typedef vector< fgTextString > TYPE_HUD_TextList;
extern TYPE_HUD_TextList HUD_TextList;
#endif //#ifdef USE_HUD_TextList
typedef vector< fgLineSeg2D > TYPE_HUD_LineList;
extern TYPE_HUD_LineList HUD_LineList;
extern TYPE_HUD_LineList HUD_StippleLineList;
class instr_item { // An Abstract Base Class (ABC)
private:
@ -201,8 +338,8 @@ class instr_item { // An Abstract Base Class (ABC)
UINT handle;
RECT scrn_pos; // Framing - affects scale dimensions
// and orientation. Vert vs Horz, etc.
DBLFNPTR load_value_fn;
double disp_factor; // Multiply by to get numbers shown on scale.
FLTFNPTR load_value_fn;
float disp_factor; // Multiply by to get numbers shown on scale.
UINT opts;
bool is_enabled;
bool broken;
@ -214,8 +351,8 @@ class instr_item { // An Abstract Base Class (ABC)
int y,
UINT height,
UINT width,
DBLFNPTR data_source,
double data_scaling,
FLTFNPTR data_source,
float data_scaling,
UINT options,
bool working = true);
@ -229,14 +366,22 @@ class instr_item { // An Abstract Base Class (ABC)
bool is_broken ( void ) { return broken; }
bool enabled ( void ) { return is_enabled;}
bool data_available ( void ) { return !!load_value_fn; }
double get_value ( void ) { return load_value_fn(); }
double data_scaling ( void ) { return disp_factor; }
float get_value ( void ) { return load_value_fn(); }
float data_scaling ( void ) { return disp_factor; }
UINT get_span ( void ) { return scr_span; }
POINT get_centroid ( void ) { return mid_span; }
UINT get_options ( void ) { return opts; }
virtual void display_enable( bool working ) { is_enabled = !! working;}
UINT huds_vert (UINT options) { return( options & HUDS_VERT ); }
UINT huds_left (UINT options) { return( options & HUDS_LEFT ); }
UINT huds_right (UINT options) { return( options & HUDS_RIGHT ); }
UINT huds_both (UINT options) { return( (options & HUDS_BOTH) == HUDS_BOTH ); }
UINT huds_noticks (UINT options) { return( options & HUDS_NOTICKS ); }
UINT huds_notext (UINT options) { return( options & HUDS_NOTEXT ); }
UINT huds_top (UINT options) { return( options & HUDS_TOP ); }
UINT huds_bottom (UINT options) { return( options & HUDS_BOTTOM ); }
virtual void display_enable( bool working ) { is_enabled = !! working;}
virtual void update( void );
virtual void break_display ( bool bad );
@ -244,13 +389,41 @@ class instr_item { // An Abstract Base Class (ABC)
void SetPosition ( int x, int y, UINT width, UINT height );
UINT get_Handle( void );
virtual void draw( void ) = 0; // Required method in derived classes
void drawOneLine( UINT x1, UINT y1, UINT x2, UINT y2)
{
HUD_LineList.push_back(fgLineSeg2D(x1,y1,x2,y2));
// glBegin(GL_LINES);
// glVertex2i(x1, y1);
// glVertex2i(x2, y2);
// glEnd();
}
void drawOneStippleLine( UINT x1, UINT y1, UINT x2, UINT y2)
{
HUD_StippleLineList.push_back(fgLineSeg2D(x1,y1,x2,y2));
// glEnable(GL_LINE_STIPPLE);
// glLineStipple( 1, 0x00FF );
// glBegin(GL_LINES);
// glVertex2i(x1, y1);
// glVertex2i(x2, y2);
// glEnd();
// glDisable(GL_LINE_STIPPLE);
}
#ifdef USE_HUD_TextList
void TextString( void *font, char *msg, UINT x, UINT y )
{
HUD_TextList.push_back(fgTextString(font, msg, x, y));
}
#endif
};
typedef deque< instr_item * > HudContainerType;
typedef HudContainerType::iterator HudIterator;
typedef instr_item *HIptr;
extern HudContainerType HUD_deque;
//typedef deque < instr_item * > hud_deque_type;
//typedef hud_deque_type::iterator hud_deque_iterator;
//typedef hud_deque_type::const_iterator hud_deque_const_iterator;
extern deque< instr_item *> HUD_deque;
//extern hud_deque_type HUD_deque;
// instr_item This class has no other purpose than to maintain
// a linked list of instrument and derived class
@ -265,17 +438,18 @@ class instr_label : public instr_item {
fgLabelJust justify;
int fontSize;
int blink;
char format_buffer[80];
public:
instr_label( int x,
int y,
UINT width,
UINT height,
DBLFNPTR data_source,
FLTFNPTR data_source,
const char *label_format,
const char *pre_label_string = 0,
const char *post_label_string = 0,
double scale_data = 1.0,
float scale_data = 1.0,
UINT options = HUDS_TOP,
fgLabelJust justification = CENTER_JUST,
int font_size = SMALL,
@ -291,6 +465,77 @@ class instr_label : public instr_item {
typedef instr_label * pInstlabel;
class lat_label : public instr_item {
private:
const char *pformat;
const char *pre_str;
const char *post_str;
fgLabelJust justify;
int fontSize;
int blink;
char format_buffer[80];
public:
lat_label( int x,
int y,
UINT width,
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);
~lat_label();
lat_label( const lat_label & image);
lat_label & operator = (const lat_label & rhs );
virtual void draw( void ); // Required method in base class
};
typedef lat_label * pLatlabel;
class lon_label : public instr_item {
private:
const char *pformat;
const char *pre_str;
const char *post_str;
fgLabelJust justify;
int fontSize;
int blink;
char format_buffer[80];
public:
lon_label( int x,
int y,
UINT width,
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);
~lon_label();
lon_label( const lon_label & image);
lon_label & operator = (const lon_label & rhs );
virtual void draw( void ); // Required method in base class
};
typedef lon_label * pLonlabel;
//
// instr_scale This class is an abstract base class for both moving
// scale and moving needle (fixed scale) indicators. It
@ -299,10 +544,10 @@ typedef instr_label * pInstlabel;
class instr_scale : public instr_item {
private:
double range_shown; // Width Units.
double Maximum_value; // ceiling.
double Minimum_value; // Representation floor.
double scale_factor; // factor => screen units/range values.
float range_shown; // Width Units.
float Maximum_value; // ceiling.
float Minimum_value; // Representation floor.
float scale_factor; // factor => screen units/range values.
UINT Maj_div; // major division marker units
UINT Min_div; // minor division marker units
UINT Modulo; // Roll over point
@ -313,12 +558,12 @@ class instr_scale : public instr_item {
int y,
UINT width,
UINT height,
DBLFNPTR load_fn,
FLTFNPTR load_fn,
UINT options,
double show_range,
double max_value = 100.0,
double min_value = 0.0,
double disp_scaling = 1.0,
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,
@ -332,11 +577,11 @@ class instr_scale : public instr_item {
virtual void draw ( void ) {}; // No-op here. Defined in derived classes.
UINT div_min ( void ) { return Min_div;}
UINT div_max ( void ) { return Maj_div;}
double min_val ( void ) { return Minimum_value;}
double max_val ( void ) { return Maximum_value;}
float min_val ( void ) { return Minimum_value;}
float max_val ( void ) { return Maximum_value;}
UINT modulo ( void ) { return Modulo; }
double factor ( void ) { return scale_factor;}
double range_to_show( void ) { return range_shown;}
float factor ( void ) { return scale_factor;}
float range_to_show( void ) { return range_shown;}
};
// hud_card_ This class displays the indicated quantity on
@ -346,24 +591,24 @@ class instr_scale : public instr_item {
class hud_card : public instr_scale {
private:
double val_span;
double half_width_units;
float val_span;
float half_width_units;
public:
hud_card( int x,
int y,
UINT width,
UINT height,
DBLFNPTR load_fn,
FLTFNPTR load_fn,
UINT options,
double maxValue = 100.0,
double minValue = 0.0,
double disp_scaling = 1.0,
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,
double value_span = 100.0,
float value_span = 100.0,
bool working = true);
~hud_card();
@ -376,18 +621,16 @@ class hud_card : public instr_scale {
typedef hud_card * pCardScale;
class guage_instr : public instr_scale {
private:
public:
guage_instr( int x,
int y,
UINT width,
UINT height,
DBLFNPTR load_fn,
FLTFNPTR load_fn,
UINT options,
double disp_scaling = 1.0,
double maxValue = 100,
double minValue = 0,
float disp_scaling = 1.0,
float maxValue = 100,
float minValue = 0,
UINT major_divs = 50,
UINT minor_divs = 0,
int dp_showing = 2,
@ -407,15 +650,15 @@ typedef guage_instr * pGuageInst;
class dual_instr_item : public instr_item {
private:
DBLFNPTR alt_data_source;
FLTFNPTR alt_data_source;
public:
dual_instr_item ( int x,
int y,
UINT width,
UINT height,
DBLFNPTR chn1_source,
DBLFNPTR chn2_source,
FLTFNPTR chn1_source,
FLTFNPTR chn2_source,
bool working = true,
UINT options = HUDS_TOP);
@ -423,8 +666,8 @@ class dual_instr_item : public instr_item {
dual_instr_item( const dual_instr_item & image);
dual_instr_item & operator = (const dual_instr_item & rhs );
double current_ch1( void ) { return alt_data_source();}
double current_ch2( void ) { return get_value();}
float current_ch1( void ) { return (float)alt_data_source();}
float current_ch2( void ) { return (float)get_value();}
virtual void draw ( void ) { }
};
@ -439,11 +682,11 @@ class fgTBI_instr : public dual_instr_item {
int y,
UINT width,
UINT height,
DBLFNPTR chn1_source = get_roll,
DBLFNPTR chn2_source = get_sideslip,
double maxBankAngle = 45.0,
double maxSlipAngle = 5.0,
UINT gap_width = 5.0,
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);
fgTBI_instr( const fgTBI_instr & image);
@ -466,20 +709,20 @@ class HudLadder : public dual_instr_item {
UINT minor_div;
UINT label_pos;
UINT scr_hole;
double vmax;
double vmin;
double factor;
float vmax;
float vmin;
float factor;
public:
HudLadder( int x,
int y,
UINT width,
UINT height,
DBLFNPTR ptch_source = get_roll,
DBLFNPTR roll_source = get_pitch,
double span_units = 45.0,
double division_units = 10.0,
double minor_division = 0.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 );
@ -511,6 +754,11 @@ extern void strokeString( int x,
char *msg,
void *font = GLUT_STROKE_ROMAN,
float theta = 0);
//extern void strokeString(float xx,
// float yy,
// char *msg,
// void *font = GLUT_STROKE_ROMAN)
/*
bool AddHUDInstrument( instr_item *pBlackBox );
void DrawHUD ( void );
@ -524,4 +772,3 @@ void fgHUDSetTimeMode( Hptr hud, int time_of_day );
*/
#endif // _HUD_H

356
Simulator/Cockpit/hud_card.cxx
View file

@ -8,6 +8,7 @@
#include <stdlib.h>
#include <string.h>
#include <Aircraft/aircraft.hxx>
#include <GUI/gui.h>
#include <Include/fg_constants.h>
#include <Math/fg_random.h>
#include <Math/mat3.h>
@ -15,8 +16,12 @@
#include <Scenery/scenery.hxx>
#include <Time/fg_timer.hxx>
#include "hud.hxx"
#ifdef USE_HUD_TextList
#define textString( x , y, text, font ) TextString( font, text, x , y )
#endif
//========== Top of hud_card class member definitions =============
hud_card ::
@ -24,16 +29,16 @@ hud_card( int x,
int y,
UINT width,
UINT height,
DBLFNPTR data_source,
FLTFNPTR data_source,
UINT options,
double max_value,
double min_value,
double disp_scaling,
float max_value, // 360
float min_value, // 0
float disp_scaling,
UINT major_divs,
UINT minor_divs,
UINT modulus,
UINT modulus, // 360
int dp_showing,
double value_span,
float value_span,
bool working) :
instr_scale( x,y,width,height,
data_source, options,
@ -44,6 +49,14 @@ hud_card( int x,
val_span ( value_span)
{
half_width_units = range_to_show() / 2.0;
// UINT options = get_options();
// huds_both = (options & HUDS_BOTH) == HUDS_BOTH;
// huds_right = options & HUDS_RIGHT;
// huds_left = options & HUDS_LEFT;
// huds_vert = options & HUDS_VERT;
// huds_notext = options & HUDS_NOTEXT;
// huds_top = options & HUDS_TOP;
// huds_bottom = options & HUDS_BOTTOM;
}
hud_card ::
@ -55,6 +68,14 @@ hud_card( const hud_card & image):
val_span( image.val_span),
half_width_units (image.half_width_units)
{
// UINT options = get_options();
// huds_both = (options & HUDS_BOTH) == HUDS_BOTH;
// huds_right = options & HUDS_RIGHT;
// huds_left = options & HUDS_LEFT;
// huds_vert = options & HUDS_VERT;
// huds_notext = options & HUDS_NOTEXT;
// huds_top = options & HUDS_TOP;
// huds_bottom = options & HUDS_BOTTOM;
}
hud_card & hud_card ::
@ -71,73 +92,97 @@ operator = (const hud_card & rhs )
void hud_card ::
draw( void ) // (HUD_scale * pscale )
{
double vmin, vmax;
float vmin, vmax;
int marker_xs;
int marker_xe;
int marker_ys;
int marker_ye;
/* register */ int i;
int lenstr;
int height, width;
int i, last;
char TextScale[80];
bool condition;
int disp_val = 0;
POINT mid_scr = get_centroid();
double cur_value = get_value();
float cur_value = get_value();
RECT scrn_rect = get_location();
UINT options = get_options();
height = scrn_rect.top + scrn_rect.bottom;
width = scrn_rect.left + scrn_rect.right;
vmin = cur_value - half_width_units; // width units == needle travel
vmax = cur_value + half_width_units; // or picture unit span.
// Draw the basic markings for the scale...
if( options & HUDS_VERT ) { // Vertical scale
if( huds_vert(options) ) { // Vertical scale
drawOneLine( scrn_rect.left, // Bottom tick bar
scrn_rect.top,
scrn_rect.left + scrn_rect.right,
width,
scrn_rect.top);
drawOneLine( scrn_rect.left, // Top tick bar
scrn_rect.top + scrn_rect.bottom,
scrn_rect.left + scrn_rect.right,
scrn_rect.top + scrn_rect.bottom );
height,
width,
height );
marker_xs = scrn_rect.left;
marker_xe = scrn_rect.left + scrn_rect.right;
marker_xs = scrn_rect.left; // x start
marker_xe = width; // x extent
marker_ye = height;
// glBegin(GL_LINES);
// Bottom tick bar
// glVertex2f( marker_xs, scrn_rect.top);
// glVertex2f( marker_xe, scrn_rect.top);
// Top tick bar
// glVertex2f( marker_xs, marker_ye);
// glVertex2f( marker_xe, marker_ye );
// glEnd();
// We do not use else in the following so that combining the two
// options produces a "caged" display with double carrots. The
// same is done for horizontal card indicators.
if( options & HUDS_LEFT ) { // Calculate x marker offset
drawOneLine( scrn_rect.left + scrn_rect.right,
scrn_rect.top,
scrn_rect.left + scrn_rect.right,
scrn_rect.top + scrn_rect.bottom); // Cap right side
if( huds_left(options) ) { // Calculate x marker offset
drawOneLine( marker_xe, scrn_rect.top,
marker_xe, marker_ye); // Cap right side
marker_xs = marker_xe - scrn_rect.right / 3; // Adjust tick xs
// Indicator carrot
drawOneLine( marker_xs, mid_scr.y,
marker_xe, mid_scr.y + scrn_rect.right / 6);
drawOneLine( marker_xs, mid_scr.y,
marker_xe, mid_scr.y - scrn_rect.right / 6);
// drawOneLine( marker_xs, mid_scr.y,
// marker_xe, mid_scr.y + scrn_rect.right / 6);
// drawOneLine( marker_xs, mid_scr.y,
// marker_xe, mid_scr.y - scrn_rect.right / 6);
glBegin(GL_LINE_STRIP);
glVertex2f( marker_xe, mid_scr.y + scrn_rect.right / 6);
glVertex2f( marker_xs, mid_scr.y);
glVertex2f( marker_xe, mid_scr.y - scrn_rect.right / 6);
glEnd();
}
if( options & HUDS_RIGHT ) { // We'll default this for now.
drawOneLine( scrn_rect.left,
scrn_rect.top,
scrn_rect.left,
scrn_rect.top + scrn_rect.bottom); // Cap left side
if( huds_right(options) ) { // We'll default this for now.
drawOneLine( scrn_rect.left, scrn_rect.top,
scrn_rect.left, marker_ye ); // Cap left side
marker_xe = scrn_rect.left + scrn_rect.right / 3; // Adjust tick xe
// Indicator carrot
drawOneLine( scrn_rect.left, mid_scr.y + scrn_rect.right / 6,
marker_xe, mid_scr.y );
drawOneLine( scrn_rect.left, mid_scr.y - scrn_rect.right / 6,
marker_xe, mid_scr.y);
// drawOneLine( scrn_rect.left, mid_scr.y + scrn_rect.right / 6,
// marker_xe, mid_scr.y );
// drawOneLine( scrn_rect.left, mid_scr.y - scrn_rect.right / 6,
// marker_xe, mid_scr.y);
glBegin(GL_LINE_STRIP);
glVertex2f( scrn_rect.left, mid_scr.y + scrn_rect.right / 6);
glVertex2f( marker_xe, mid_scr.y );
glVertex2f( scrn_rect.left, mid_scr.y - scrn_rect.right / 6);
glEnd();
}
// At this point marker x_start and x_end values are transposed.
// To keep this from confusing things they are now interchanged.
if(( options & HUDS_BOTH) == HUDS_BOTH) {
if(huds_both(options)) {
marker_ye = marker_xs;
marker_xs = marker_xe;
marker_xe = marker_ye;
@ -146,7 +191,12 @@ draw( void ) // (HUD_scale * pscale )
// Work through from bottom to top of scale. Calculating where to put
// minor and major ticks.
for( i = (int)vmin; i <= (int)vmax; i++ ) {
// last = FloatToInt(vmax)+1;
// i = FloatToInt(vmin);
last = (int)vmax + 1;
i = (int)vmin;
for( ; i <last ; i++ )
{
condition = true;
if( !modulo()) {
if( i < min_val()) {
@ -156,28 +206,35 @@ draw( void ) // (HUD_scale * pscale )
if( condition ) { // Show a tick if necessary
// Calculate the location of this tick
marker_ys = scrn_rect.top + (int)((i - vmin) * factor() + .5);
marker_ys = scrn_rect.top + FloatToInt(((i - vmin) * factor()/*+.5f*/));
// marker_ys = scrn_rect.top + (int)((i - vmin) * factor() + .5);
// Block calculation artifact from drawing ticks below min coordinate.
// Calculation here accounts for text height.
if(( marker_ys < (scrn_rect.top + 4)) |
( marker_ys > (scrn_rect.top + scrn_rect.bottom - 4))) {
( marker_ys > (height - 4))) {
// Magic numbers!!!
continue;
}
if( div_min()) {
if( (i%div_min()) == 0) {
// if( (i%div_min()) == 0) {
if( !(i%(int)div_min())) {
if((( marker_ys - 5) > scrn_rect.top ) &&
(( marker_ys + 5) < (scrn_rect.top + scrn_rect.bottom))){
if( (options & HUDS_BOTH) == HUDS_BOTH ) {
(( marker_ys + 5) < (height))){
if( huds_both(options) ) {
drawOneLine( scrn_rect.left, marker_ys,
marker_xs, marker_ys );
drawOneLine( marker_xe, marker_ys,
scrn_rect.left + scrn_rect.right, marker_ys );
width, marker_ys );
// glBegin(GL_LINES);
// glVertex2f( scrn_rect.left, marker_ys );
// glVertex2f( marker_xs, marker_ys );
// glVertex2f( marker_xe, marker_ys);
// glVertex2f( scrn_rect.left + scrn_rect.right, marker_ys );
// glEnd();
}
else {
if( options & HUDS_LEFT ) {
if( huds_left(options) ) {
drawOneLine( marker_xs + 4, marker_ys,
marker_xe, marker_ys );
}
@ -190,42 +247,51 @@ draw( void ) // (HUD_scale * pscale )
}
}
if( div_max() ) {
if( !(i%(int)div_max())){
if( !(i%(int)div_max()) )
{
if(modulo()) {
if( disp_val < 0) {
while(disp_val < 0)
disp_val += modulo();
// } else {
// disp_val = i % (int)modulo();
}
else {
disp_val = i % modulo();
}
}
else {
disp_val = i % (int) modulo(); // ?????????
} else {
disp_val = i;
}
sprintf( TextScale, "%d", (int)(disp_val * data_scaling() +.5));
lenstr = sprintf( TextScale, "%d",
FloatToInt(disp_val * data_scaling()/*+.5*/));
// (int)(disp_val * data_scaling() +.5));
if(( (marker_ys - 8 ) > scrn_rect.top ) &&
( (marker_ys + 8) < (scrn_rect.top + scrn_rect.bottom))){
if( (options & HUDS_BOTH) == HUDS_BOTH) {
drawOneLine( scrn_rect.left, marker_ys,
marker_xs, marker_ys);
drawOneLine( marker_xs, marker_ys,
scrn_rect.left + scrn_rect.right,
marker_ys);
if( !(options & HUDS_NOTEXT)) {
( (marker_ys + 8) < (height))){
if( huds_both(options) ) {
// drawOneLine( scrn_rect.left, marker_ys,
// marker_xs, marker_ys);
// drawOneLine( marker_xs, marker_ys,
// scrn_rect.left + scrn_rect.right,
// marker_ys);
glBegin(GL_LINE_STRIP);
glVertex2f( scrn_rect.left, marker_ys );
glVertex2f( marker_xs, marker_ys);
glVertex2f( width, marker_ys);
glEnd();
if( !huds_notext(options)) {
textString ( marker_xs + 2, marker_ys,
TextScale, GLUT_BITMAP_8_BY_13 );
}
}
else {
drawOneLine( marker_xs, marker_ys, marker_xe, marker_ys );
if( !(options & HUDS_NOTEXT)) {
if( options & HUDS_LEFT ) {
textString( marker_xs - 8 * strlen(TextScale) - 2,
if( !huds_notext(options) ) {
if( huds_left(options) ) {
textString( marker_xs - 8 * lenstr - 2,
marker_ys - 4,
TextScale, GLUT_BITMAP_8_BY_13 );
}
else {
textString( marker_xe + 3 * strlen(TextScale),
textString( marker_xe + 3 * lenstr,
marker_ys - 4,
TextScale, GLUT_BITMAP_8_BY_13 );
}
@ -238,49 +304,72 @@ draw( void ) // (HUD_scale * pscale )
} // End for range of i from vmin to vmax
} // End if VERTICAL SCALE TYPE
else { // Horizontal scale by default
drawOneLine( scrn_rect.left, // left tick bar
scrn_rect.top,
scrn_rect.left,
scrn_rect.top + scrn_rect.bottom);
// left tick bar
drawOneLine( scrn_rect.left, scrn_rect.top,
scrn_rect.left, height);
drawOneLine( scrn_rect.left + scrn_rect.right, // right tick bar
scrn_rect.top,
scrn_rect.left + scrn_rect.right,
scrn_rect.top + scrn_rect.bottom );
// right tick bar
drawOneLine( width, scrn_rect.top,
width,
height );
marker_ys = scrn_rect.top; // Starting point for
marker_ye = scrn_rect.top + scrn_rect.bottom; // tick y location calcs
marker_ye = height; // tick y location calcs
marker_xe = width;
if( options & HUDS_TOP ) {
// glBegin(GL_LINES);
// left tick bar
// glVertex2f( scrn_rect.left, scrn_rect.top);
// glVertex2f( scrn_rect.left, marker_ye);
// right tick bar
// glVertex2f( marker_xe, scrn_rect.top);
// glVertex2f( marker_xe, marker_ye );
// glEnd();
if( huds_top(options) ) {
// Bottom box line
drawOneLine( scrn_rect.left,
scrn_rect.top,
scrn_rect.left + scrn_rect.right,
scrn_rect.top); // Bottom box line
width,
scrn_rect.top);
marker_ye = scrn_rect.top + scrn_rect.bottom / 2; // Tick point adjust
// Bottom arrow
drawOneLine( mid_scr.x, marker_ye,
mid_scr.x - scrn_rect.bottom / 4, scrn_rect.top);
drawOneLine( mid_scr.x, marker_ye,
mid_scr.x + scrn_rect.bottom / 4, scrn_rect.top);
}
if( options & HUDS_BOTTOM) {
drawOneLine( scrn_rect.left,
scrn_rect.top + scrn_rect.bottom,
scrn_rect.left + scrn_rect.right,
scrn_rect.top + scrn_rect.bottom); // Top box line
// Tick point adjust
marker_ys = scrn_rect.top +
scrn_rect.bottom - scrn_rect.bottom / 2;
marker_ye = scrn_rect.top + scrn_rect.bottom / 2;
// Bottom arrow
// drawOneLine( mid_scr.x, marker_ye,
// mid_scr.x - scrn_rect.bottom / 4, scrn_rect.top);
// drawOneLine( mid_scr.x, marker_ye,
// mid_scr.x + scrn_rect.bottom / 4, scrn_rect.top);
glBegin(GL_LINE_STRIP);
glVertex2f( mid_scr.x - scrn_rect.bottom / 4, scrn_rect.top);
glVertex2f( mid_scr.x, marker_ye);
glVertex2f( mid_scr.x + scrn_rect.bottom / 4, scrn_rect.top);
glEnd();
}
if( huds_bottom(options) ) {
// Top box line
drawOneLine( scrn_rect.left, height,
width, height);
// Tick point adjust
marker_ys = height - scrn_rect.bottom / 2;
// Top arrow
drawOneLine( mid_scr.x + scrn_rect.bottom / 4,
scrn_rect.top + scrn_rect.bottom,
mid_scr.x ,
marker_ys );
drawOneLine( mid_scr.x - scrn_rect.bottom / 4,
scrn_rect.top + scrn_rect.bottom,
mid_scr.x ,
marker_ys );
// drawOneLine( mid_scr.x + scrn_rect.bottom / 4,
// scrn_rect.top + scrn_rect.bottom,
// mid_scr.x, marker_ys );
// drawOneLine( mid_scr.x - scrn_rect.bottom / 4,
// scrn_rect.top + scrn_rect.bottom,
// mid_scr.x , marker_ys );
glBegin(GL_LINE_STRIP);
glVertex2f( mid_scr.x + scrn_rect.bottom / 4,
height);
glVertex2f( mid_scr.x , marker_ys );
glVertex2f( mid_scr.x - scrn_rect.bottom / 4,
height);
glEnd();
}
// if(( options & HUDS_BOTTOM) == HUDS_BOTTOM ) {
@ -290,7 +379,13 @@ draw( void ) // (HUD_scale * pscale )
// }
// printf("vmin = %d vmax = %d\n", (int)vmin, (int)vmax);
for( i = (int)vmin; i <= (int)vmax; i++ ) {
// last = FloatToInt(vmax)+1;
// i = FloatToInt(vmin);
last = (int)vmax + 1;
i = (int)vmin;
for(; i <last ; i++ ) {
// for( i = (int)vmin; i <= (int)vmax; i++ ) {
// printf("<*> i = %d\n", i);
condition = true;
if( !modulo()) {
@ -300,21 +395,29 @@ draw( void ) // (HUD_scale * pscale )
}
// printf("<**> i = %d\n", i);
if( condition ) {
marker_xs = scrn_rect.left + (int)((i - vmin) * factor() + .5);
// marker_xs = scrn_rect.left + (int)((i - vmin) * factor() + .5);
marker_xs = scrn_rect.left + FloatToInt(((i - vmin) * factor()/*+ .5f*/));
if( div_min()){
if( (i%(int)div_min()) == 0 ) {
// if( (i%(int)div_min()) == 0 ) {
if( !(i%(int)div_min() )) {
// draw in ticks only if they aren't too close to the edge.
if((( marker_xs - 5) > scrn_rect.left ) &&
(( marker_xs + 5 )< (scrn_rect.left + scrn_rect.right))){
if( (options & HUDS_BOTH) == HUDS_BOTH ) {
if( huds_both(options) ) {
drawOneLine( marker_xs, scrn_rect.top,
marker_xs, marker_ys - 4);
drawOneLine( marker_xs, marker_ye + 4,
marker_xs, scrn_rect.top + scrn_rect.bottom);
marker_xs, height);
// glBegin(GL_LINES);
// glVertex2f( marker_xs, scrn_rect.top);
// glVertex2f( marker_xs, marker_ys - 4);
// glVertex2f( marker_xs, marker_ye + 4);
// glVertex2f( marker_xs, scrn_rect.top + scrn_rect.bottom);
// glEnd();
}
else {
if( options & HUDS_TOP) {
if( huds_top(options)) {
drawOneLine( marker_xs, marker_ys,
marker_xs, marker_ye - 4);
}
@ -329,32 +432,37 @@ draw( void ) // (HUD_scale * pscale )
// printf("<***> i = %d\n", i);
if( div_max()) {
// printf("i = %d\n", i);
if( (i%(int)div_max())==0 ) {
// if( (i%(int)div_max())==0 ) {
if( !(i%(int)div_max()) ) {
if(modulo()) {
if( disp_val < 0) {
while(disp_val<0)
disp_val += modulo();
}
else {
disp_val = i % modulo();
}
}
else {
disp_val = i % (int) modulo(); // ?????????
} else {
disp_val = i;
}
// printf("disp_val = %d\n", disp_val);
// printf("%d\n", (int)(disp_val * (double)data_scaling() + 0.5));
sprintf( TextScale, "%d", (int)(disp_val * data_scaling() +.5));
lenstr = sprintf( TextScale, "%d",
// (int)(disp_val * data_scaling() +.5));
FloatToInt(disp_val * data_scaling()/*+.5*/));
// Draw major ticks and text only if far enough from the edge.
if(( (marker_xs - 10)> scrn_rect.left ) &&
( (marker_xs + 10) < (scrn_rect.left + scrn_rect.right))){
if( (options & HUDS_BOTH) == HUDS_BOTH) {
drawOneLine( marker_xs, scrn_rect.top,
marker_xs, marker_ys);
drawOneLine( marker_xs, marker_ye,
marker_xs, scrn_rect.top + scrn_rect.bottom);
if( !(options & HUDS_NOTEXT)) {
textString ( marker_xs - 4 * strlen(TextScale),
if( huds_both(options) ) {
// drawOneLine( marker_xs, scrn_rect.top,
// marker_xs, marker_ys);
// drawOneLine( marker_xs, marker_ye,
// marker_xs, scrn_rect.top + scrn_rect.bottom);
glBegin(GL_LINE_STRIP);
glVertex2f( marker_xs, scrn_rect.top);
glVertex2f( marker_xs, marker_ye);
glVertex2f( marker_xs, height);
glEnd();
if( !huds_notext(options) ) {
textString ( marker_xs - 4 * lenstr,
marker_ys + 4,
TextScale, GLUT_BITMAP_8_BY_13 );
}
@ -362,14 +470,14 @@ draw( void ) // (HUD_scale * pscale )
else {
drawOneLine( marker_xs, marker_ys,
marker_xs, marker_ye );
if( !(options & HUDS_NOTEXT)) {
if( options & HUDS_TOP ) {
textString ( marker_xs - 4 * strlen(TextScale),
scrn_rect.top + scrn_rect.bottom - 10,
if( !huds_notext(options)) {
if( huds_top(options) ) {
textString ( marker_xs - 4 * lenstr,
height - 10,
TextScale, GLUT_BITMAP_8_BY_13 );
}
else {
textString( marker_xs - 4 * strlen(TextScale),
textString( marker_xs - 4 * lenstr,
scrn_rect.top,
TextScale, GLUT_BITMAP_8_BY_13 );
}

4
Simulator/Cockpit/hud_dnst.cxx
View file

@ -25,8 +25,8 @@ dual_instr_item ::
int y,
UINT width,
UINT height,
DBLFNPTR chn1_source,
DBLFNPTR chn2_source,
FLTFNPTR chn1_source,
FLTFNPTR chn2_source,
bool working,
UINT options ):
instr_item( x, y, width, height,

241
Simulator/Cockpit/hud_guag.cxx
View file

@ -8,6 +8,7 @@
#include <stdlib.h>
#include <string.h>
#include <Aircraft/aircraft.hxx>
#include <GUI/gui.h>
#include <Include/fg_constants.h>
#include <Math/fg_random.h>
#include <Math/mat3.h>
@ -15,8 +16,12 @@
#include <Scenery/scenery.hxx>
#include <Time/fg_timer.hxx>
#include "hud.hxx"
#ifdef USE_HUD_TextList
#define textString( x , y, text, font ) TextString( font, text, x , y )
#endif
//============== Top of guage_instr class member definitions ==============
guage_instr ::
@ -24,11 +29,11 @@ guage_instr ::
int y,
UINT width,
UINT height,
DBLFNPTR load_fn,
FLTFNPTR load_fn,
UINT options,
double disp_scale,
double maxValue,
double minValue,
float disp_scale,
float maxValue,
float minValue,
UINT major_divs,
UINT minor_divs,
int dp_showing,
@ -43,6 +48,15 @@ guage_instr ::
modulus, dp_showing,
working)
{
// UINT options = get_options();
// huds_vert = options & HUDS_VERT;
// huds_left = options & HUDS_LEFT;
// huds_right = options & HUDS_RIGHT;
// huds_both = (options & HUDS_BOTH) == HUDS_BOTH;
// huds_noticks = options & HUDS_NOTICKS;
// huds_notext = options & HUDS_NOTEXT;
// huds_top = options & HUDS_TOP;
// huds_bottom = options & HUDS_BOTTOM;
}
guage_instr ::
@ -54,6 +68,15 @@ guage_instr ::
guage_instr( const guage_instr & image):
instr_scale( (instr_scale &) image)
{
// UINT options = get_options();
// huds_vert = options & HUDS_VERT;
// huds_left = options & HUDS_LEFT;
// huds_right = options & HUDS_RIGHT;
// huds_both = (options & HUDS_BOTH) == HUDS_BOTH;
// huds_noticks = options & HUDS_NOTICKS;
// huds_notext = options & HUDS_NOTEXT;
// huds_top = options & HUDS_TOP;
// huds_bottom = options & HUDS_BOTTOM;
}
guage_instr & guage_instr ::
@ -76,52 +99,60 @@ void guage_instr :: draw (void)
int marker_xs, marker_xe;
int marker_ys, marker_ye;
int text_x, text_y;
int width, height, bottom_4;
int lenstr;
int i;
char TextScale[80];
bool condition;
int disp_val;
double vmin = min_val();
double vmax = max_val();
int disp_val = 0;
float vmin = min_val();
float vmax = max_val();
POINT mid_scr = get_centroid();
double cur_value = get_value();
float cur_value = get_value();
RECT scrn_rect = get_location();
UINT options = get_options();
width = scrn_rect.left + scrn_rect.right;
height = scrn_rect.top + scrn_rect.bottom;
bottom_4 = scrn_rect.bottom / 4;
// Draw the basic markings for the scale...
if( options & HUDS_VERT ) { // Vertical scale
if( huds_vert(options) ) { // Vertical scale
drawOneLine( scrn_rect.left, // Bottom tick bar
scrn_rect.top,
scrn_rect.left + scrn_rect.right,
width,
scrn_rect.top);
drawOneLine( scrn_rect.left, // Top tick bar
scrn_rect.top + scrn_rect.bottom,
scrn_rect.left + scrn_rect.right,
scrn_rect.top + scrn_rect.bottom );
height,
width,
height );
marker_xs = scrn_rect.left;
marker_xe = scrn_rect.left + scrn_rect.right;
marker_xe = width;
if( options & HUDS_LEFT ) { // Read left, so line down right side
drawOneLine( scrn_rect.left + scrn_rect.right,
if( huds_left(options) ) { // Read left, so line down right side
drawOneLine( width,
scrn_rect.top,
scrn_rect.left + scrn_rect.right,
scrn_rect.top + scrn_rect.bottom);
width,
height);
marker_xs = marker_xe - scrn_rect.right / 3; // Adjust tick xs
}
if( options & HUDS_RIGHT ) { // Read right, so down left sides
if( huds_right(options) ) { // Read right, so down left sides
drawOneLine( scrn_rect.left,
scrn_rect.top,
scrn_rect.left,
scrn_rect.top + scrn_rect.bottom);
height);
marker_xe = scrn_rect.left + scrn_rect.right / 3; // Adjust tick xe
}
// At this point marker x_start and x_end values are transposed.
// To keep this from confusing things they are now interchanged.
if(( options & HUDS_BOTH) == HUDS_BOTH) {
if( huds_both(options) ) {
marker_ye = marker_xs;
marker_xs = marker_xe;
marker_xe = marker_ye;
@ -130,26 +161,29 @@ void guage_instr :: draw (void)
// Work through from bottom to top of scale. Calculating where to put
// minor and major ticks.
if( !(options & HUDS_NOTICKS )) { // If not no ticks...:)
if( !huds_noticks(options)) { // If not no ticks...:)
// Calculate x marker offsets
for( i = (int)vmin; i <= (int)vmax; i++ ) {
int last = (int)vmax + 1; //FloatToInt(vmax)+1;
i = (int)vmin; //FloatToInt(vmin);
for(; i <last ; i++ ) {
// for( i = (int)vmin; i <= (int)vmax; i++ ) {
// Calculate the location of this tick
marker_ys = scrn_rect.top + (int)((i - vmin) * factor() + .5);
marker_ys = scrn_rect.top + FloatToInt((i - vmin) * factor()/* +.5f*/);
// We compute marker_ys even though we don't know if we will use
// either major or minor divisions. Simpler.
if( div_min()) { // Minor tick marks
if( (i%div_min()) == 0) {
if((options & HUDS_LEFT) && (options && HUDS_RIGHT)) {
if( !(i%(int)div_min()) ) {
if( huds_left(options) && huds_right(options) ) {
drawOneLine( scrn_rect.left, marker_ys,
marker_xs - 3, marker_ys );
drawOneLine( marker_xe + 3, marker_ys,
scrn_rect.left + scrn_rect.right, marker_ys );
width, marker_ys );
}
else {
if( options & HUDS_LEFT) {
if( huds_left(options) ) {
drawOneLine( marker_xs + 3, marker_ys, marker_xe, marker_ys );
}
else {
@ -164,31 +198,31 @@ void guage_instr :: draw (void)
// statement.
if( div_max()) { // Major tick mark
if( (i%div_max()) == 0 ) {
if((options & HUDS_LEFT) && (options && HUDS_RIGHT)) {
if( !(i%(int)div_max()) ) {
if( huds_left(options) && huds_right(options) ) {
drawOneLine( scrn_rect.left, marker_ys,
marker_xs, marker_ys );
drawOneLine( marker_xe, marker_ys,
scrn_rect.left + scrn_rect.right, marker_ys );
width, marker_ys );
}
else {
drawOneLine( marker_xs, marker_ys, marker_xe, marker_ys );
}
if( !(options & HUDS_NOTEXT)) {
if( !huds_notext(options) ) {
disp_val = i;
sprintf( TextScale, "%d",disp_val * (int)(data_scaling() +.5));
lenstr = sprintf( TextScale, "%d",
FloatToInt(disp_val * data_scaling()/*+.5*/ ));
if((options & HUDS_LEFT) && (options && HUDS_RIGHT)) {
text_x = mid_scr.x - 2 - ((3 * strlen( TextScale ))>>1);
if( huds_left(options) && huds_right(options) ) {
text_x = mid_scr.x - 2 - ((3 * lenstr) >> 1);
}
else {
if( options & HUDS_LEFT ) {
text_x = marker_xs - 2 - 3 * strlen( TextScale);
if( huds_left(options) ) {
text_x = marker_xs - 2 - 3 * lenstr;
}
else {
text_x = marker_xe + 10 - strlen( TextScale );
text_x = marker_xe + 10 - lenstr;
}
}
// Now we know where to put the text.
@ -203,70 +237,71 @@ void guage_instr :: draw (void)
// have been drawn, text_x and text_y may be recycled. This is used
// with the marker start stops to produce a pointer for each side reading
text_y = scrn_rect.top + (int)((cur_value - vmin) * factor() + .5);
text_y = scrn_rect.top + FloatToInt((cur_value - vmin) * factor() /*+.5f*/);
// text_x = marker_xs - scrn_rect.left;
if( options & HUDS_RIGHT ) {
drawOneLine(scrn_rect.left, text_y + 5,
marker_xe, text_y);
drawOneLine(scrn_rect.left, text_y - 5,
marker_xe, text_y);
if( huds_right(options) ) {
glBegin(GL_LINE_STRIP);
glVertex2f( scrn_rect.left, text_y + 5);
glVertex2f( marker_xe, text_y);
glVertex2f( scrn_rect.left, text_y - 5);
glEnd();
}
if( options & HUDS_LEFT ) {
drawOneLine(scrn_rect.left + scrn_rect.right, text_y + 5,
marker_xs, text_y);
drawOneLine(scrn_rect.left + scrn_rect.right, text_y - 5,
marker_xs, text_y);
if( huds_left(options) ) {
glBegin(GL_LINE_STRIP);
glVertex2f( width, text_y + 5);
glVertex2f( marker_xs, text_y);
glVertex2f( width, text_y - 5);
glEnd();
}
} // End if VERTICAL SCALE TYPE
else { // Horizontal scale by default
drawOneLine( scrn_rect.left, // left tick bar
scrn_rect.top,
scrn_rect.left,
scrn_rect.top + scrn_rect.bottom);
height);
drawOneLine( scrn_rect.left + scrn_rect.right, // right tick bar
drawOneLine( width, // right tick bar
scrn_rect.top,
scrn_rect.left + scrn_rect.right,
scrn_rect.top + scrn_rect.bottom );
width,
height );
marker_ys = scrn_rect.top; // Starting point for
marker_ye = scrn_rect.top + scrn_rect.bottom; // tick y location calcs
marker_xs = scrn_rect.left + (int)((cur_value - vmin) * factor() + .5);
marker_ye = height; // tick y location calcs
marker_xs = scrn_rect.left + FloatToInt((cur_value - vmin) * factor() /*+ .5f*/);
if( options & HUDS_TOP ) {
if( huds_top(options) ) {
drawOneLine( scrn_rect.left,
scrn_rect.top,
scrn_rect.left + scrn_rect.right,
width,
scrn_rect.top); // Bottom box line
marker_ye = scrn_rect.top + scrn_rect.bottom / 2; // Tick point adjust
// Bottom arrow
drawOneLine( marker_xs, marker_ye,
marker_xs - scrn_rect.bottom / 4, scrn_rect.top);
drawOneLine( marker_xs, marker_ye,
marker_xs + scrn_rect.bottom / 4, scrn_rect.top);
glBegin(GL_LINE_STRIP);
glVertex2f( marker_xs - bottom_4, scrn_rect.top);
glVertex2f( marker_xs, marker_ye);
glVertex2f( marker_xs + bottom_4, scrn_rect.top);
glEnd();
}
if( options & HUDS_BOTTOM) {
drawOneLine( scrn_rect.left,
scrn_rect.top + scrn_rect.bottom,
scrn_rect.left + scrn_rect.right,
scrn_rect.top + scrn_rect.bottom); // Top box line
if( huds_bottom(options) ) {
// Top box line
drawOneLine( scrn_rect.left, height, width, height);
// Tick point adjust
marker_ys = scrn_rect.top +
scrn_rect.bottom - scrn_rect.bottom / 2;
marker_ys = height - scrn_rect.bottom / 2;
// Top arrow
drawOneLine( marker_xs + scrn_rect.bottom / 4,
scrn_rect.top + scrn_rect.bottom,
marker_xs,
marker_ys );
drawOneLine( marker_xs - scrn_rect.bottom / 4,
scrn_rect.top + scrn_rect.bottom,
marker_xs ,
marker_ys );
glBegin(GL_LINE_STRIP);
glVertex2f( marker_xs + bottom_4, height);
glVertex2f( marker_xs, marker_ys );
glVertex2f( marker_xs - bottom_4, height);
glEnd();
}
for( i = (int)vmin; i <= (int)vmax; i++ ) {
int last = (int)vmax + 1; //FloatToInt(vmax)+1;
i = (int)vmin; //FloatToInt(vmin);
for( ; i <last ; i++ ) {
condition = true;
if( !modulo()) {
if( i < min_val()) {
@ -274,21 +309,22 @@ void guage_instr :: draw (void)
}
}
if( condition ) {
marker_xs = scrn_rect.left + (int)((i - vmin) * factor() + .5);
marker_xs = scrn_rect.left + FloatToInt((i - vmin) * factor()/* +.5f*/);
// marker_xs = scrn_rect.left + (int)((i - vmin) * factor() + .5f);
if( div_min()){
if( (i%(int)div_min()) == 0 ) {
if( !(i%(int)div_min()) ) {
// draw in ticks only if they aren't too close to the edge.
if((( marker_xs + 5) > scrn_rect.left ) ||
(( marker_xs - 5 )< (scrn_rect.left + scrn_rect.right))){
(( marker_xs - 5 )< (width))){
if( (options & HUDS_BOTH) == HUDS_BOTH ) {
if( huds_both(options) ) {
drawOneLine( marker_xs, scrn_rect.top,
marker_xs, marker_ys - 4);
drawOneLine( marker_xs, marker_ye + 4,
marker_xs, scrn_rect.top + scrn_rect.bottom);
marker_xs, height);
}
else {
if( options & HUDS_TOP) {
if( huds_top(options) ) {
drawOneLine( marker_xs, marker_ys,
marker_xs, marker_ye - 4);
}
@ -301,46 +337,45 @@ void guage_instr :: draw (void)
}
}
if( div_max()) {
if( (i%(int)div_max())==0 ) {
if( !(i%(int)div_max()) ) {
if(modulo()) {
if( disp_val < 0) {
while( disp_val < 0 ) {
disp_val += modulo();
}
else {
disp_val = i % modulo();
}
}
else {
disp_val = i % (int)modulo();
} else {
disp_val = i;
}
sprintf( TextScale, "%d", (int)(disp_val * data_scaling() +.5));
lenstr = 4 * sprintf( TextScale, "%d",
FloatToInt(disp_val * data_scaling()/* +.5*/ ));
// Draw major ticks and text only if far enough from the edge.
if(( (marker_xs - 10)> scrn_rect.left ) &&
( (marker_xs + 10) < (scrn_rect.left + scrn_rect.right))){
if( (options & HUDS_BOTH) == HUDS_BOTH) {
( (marker_xs + 10) < width )){
if( huds_both(options) ) {
drawOneLine( marker_xs, scrn_rect.top,
marker_xs, marker_ys);
drawOneLine( marker_xs, marker_ye,
marker_xs, scrn_rect.top + scrn_rect.bottom);
marker_xs, height);
if( !(options & HUDS_NOTEXT)) {
textString ( marker_xs - 4 * strlen(TextScale),
marker_ys + 4,
if( !huds_notext(options) ) {
textString ( marker_xs - lenstr, marker_ys + 4,
TextScale, GLUT_BITMAP_8_BY_13 );
}
}
else {
drawOneLine( marker_xs, marker_ys,
marker_xs, marker_ye );
if( !(options & HUDS_NOTEXT)) {
if( options & HUDS_TOP ) {
textString ( marker_xs - 4 * strlen(TextScale),
scrn_rect.top + scrn_rect.bottom - 10,
if( !huds_notext(options) ) {
if( huds_top(options) ) {
textString ( marker_xs - lenstr,
height - 10,
TextScale, GLUT_BITMAP_8_BY_13 );
}
else {
textString( marker_xs - 4 * strlen(TextScale),
scrn_rect.top,
textString( marker_xs - lenstr, scrn_rect.top,
TextScale, GLUT_BITMAP_8_BY_13 );
}
}

4
Simulator/Cockpit/hud_inst.cxx
View file

@ -31,8 +31,8 @@ instr_item ::
int y,
UINT width,
UINT height,
DBLFNPTR data_source,
double data_scaling,
FLTFNPTR data_source,
float data_scaling,
UINT options,
bool working) :
handle ( ++instances ),

104
Simulator/Cockpit/hud_labl.cxx
View file

@ -8,6 +8,7 @@
#include <stdlib.h>
#include <string.h>
#include <Aircraft/aircraft.hxx>
#include <GUI/gui.h>
#include <Include/fg_constants.h>
#include <Math/fg_random.h>
#include <Math/mat3.h>
@ -15,20 +16,23 @@
#include <Scenery/scenery.hxx>
#include <Time/fg_timer.hxx>
#include "hud.hxx"
#ifdef USE_HUD_TextList
#define textString( x , y, text, font ) TextString( font, text, x , y )
#endif
//======================= Top of instr_label class =========================
instr_label ::
instr_label( int x,
int y,
UINT width,
UINT height,
DBLFNPTR data_source,
FLTFNPTR data_source,
const char *label_format,
const char *pre_label_string,
const char *post_label_string,
double scale_data,
float scale_data,
UINT options,
fgLabelJust justification,
int font_size,
@ -43,6 +47,20 @@ instr_label ::
fontSize ( font_size ),
blink ( blinking )
{
if( pre_str != NULL) {
if( post_str != NULL ) {
sprintf( format_buffer, "%s%s%s", pre_str, pformat, post_str );
}
else {
sprintf( format_buffer, "%s%s", pre_str, pformat );
}
}
else {
if( post_str != NULL ) {
sprintf( format_buffer, "%s%s", pformat, post_str );
}
} // else do nothing if both pre and post strings are nulls. Interesting.
}
// I put this in to make it easy to construct a class member using the current
@ -61,35 +79,6 @@ instr_label :: instr_label( const instr_label & image) :
post_str ( image.post_str ),
blink ( image.blink )
{
}
instr_label & instr_label ::operator = (const instr_label & rhs )
{
if( !(this == &rhs)) {
instr_item::operator = (rhs);
pformat = rhs.pformat;
fontSize = rhs.fontSize;
blink = rhs.blink;
justify = rhs.justify;
pre_str = rhs.pre_str;
post_str = rhs.post_str;
}
return *this;
}
//
// draw Draws a label anywhere in the HUD
//
//
void instr_label ::
draw( void ) // Required method in base class
{
char format_buffer[80];
char label_buffer[80];
int posincr;
int lenstr;
RECT scrn_rect = get_location();
if( pre_str != NULL) {
if( post_str != NULL ) {
sprintf( format_buffer, "%s%s%s", pre_str, pformat, post_str );
@ -104,11 +93,55 @@ draw( void ) // Required method in base class
}
} // else do nothing if both pre and post strings are nulls. Interesting.
}
instr_label & instr_label ::operator = (const instr_label & rhs )
{
if( !(this == &rhs)) {
instr_item::operator = (rhs);
pformat = rhs.pformat;
fontSize = rhs.fontSize;
blink = rhs.blink;
justify = rhs.justify;
pre_str = rhs.pre_str;
post_str = rhs.post_str;
strcpy(format_buffer,rhs.format_buffer);
}
return *this;
}
//
// draw Draws a label anywhere in the HUD
//
//
void instr_label ::
draw( void ) // Required method in base class
{
// char format_buffer[80];
char label_buffer[80];
int posincr;
int lenstr;
RECT scrn_rect = get_location();
// if( pre_str != NULL) {
// if( post_str != NULL ) {
// sprintf( format_buffer, "%s%s%s", pre_str, pformat, post_str );
// }
// else {
// sprintf( format_buffer, "%s%s", pre_str, pformat );
// }
// }
// else {
// if( post_str != NULL ) {
// sprintf( format_buffer, "%s%s", pformat, post_str );
// }
// } // else do nothing if both pre and post strings are nulls. Interesting.
if( data_available() ) {
sprintf( label_buffer, format_buffer, get_value() );
lenstr = sprintf( label_buffer, format_buffer, get_value() );
}
else {
sprintf( label_buffer, format_buffer );
lenstr = sprintf( label_buffer, format_buffer );
}
#ifdef DEBUGHUD
@ -117,7 +150,7 @@ draw( void ) // Required method in base class
fgPrintf( FG_COCKPIT, FG_DEBUG, label_buffer );
fgPrintf( FG_COCKPIT, FG_DEBUG, "\n" );
#endif
lenstr = strlen( label_buffer );
// lenstr = strlen( label_buffer );
posincr = 0; // default to RIGHT_JUST ... center located calc: -lenstr*8;
@ -129,7 +162,6 @@ draw( void ) // Required method in base class
posincr = - (lenstr << 8); // 0;
}
}
if( fontSize == SMALL ) {
textString( scrn_rect.left + posincr, scrn_rect.top,
label_buffer, GLUT_BITMAP_8_BY_13);

343
Simulator/Cockpit/hud_ladr.cxx
View file

@ -18,16 +18,15 @@
#include "hud.hxx"
//====================== Top of HudLadder Class =======================
HudLadder ::
HudLadder( int x,
HudLadder :: HudLadder( int x,
int y,
UINT width,
UINT height,
DBLFNPTR ptch_source,
DBLFNPTR roll_source,
double span_units,
double major_div,
double minor_div,
FLTFNPTR ptch_source,
FLTFNPTR roll_source,
float span_units,
float major_div,
float minor_div,
UINT screen_hole,
UINT lbl_pos,
bool working) :
@ -36,9 +35,9 @@ HudLadder ::
roll_source,
working,
HUDS_RIGHT),
width_units ( span_units ),
div_units ( major_div < 0? -major_div: major_div ),
minor_div ( minor_div ),
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 ),
@ -47,11 +46,10 @@ HudLadder ::
if( !width_units ) {
width_units = 45;
}
factor = (double)get_span() / (double) width_units;
factor = (float)get_span() / (float) width_units;
}
HudLadder ::
~HudLadder()
HudLadder :: ~HudLadder()
{
}
@ -67,8 +65,7 @@ HudLadder ::
factor ( image.factor )
{
}
HudLadder & HudLadder ::
operator = ( const HudLadder & rhs )
HudLadder & HudLadder :: operator = ( const HudLadder & rhs )
{
if( !(this == &rhs)) {
(dual_instr_item &)(*this) = (dual_instr_item &)rhs;
@ -87,213 +84,251 @@ HudLadder & HudLadder ::
// Draws a climb ladder in the center of the HUD
//
inline static void _strokeString(float xx, float yy, char *msg, void *font)
{
int c;
if(*msg)
{
glTranslatef( xx, yy, 0);
glScalef(.075, .075, 0.0);
while ((c=*msg++)) {
glutStrokeCharacter( font, c);
}
}
}
void HudLadder :: draw( void )
{
double roll_value;
double pitch_value;
int marker_y;
int x_ini;
int x_end;
int y_ini;
int y_end;
int new_x_ini;
int new_x_end;
int new_y_ini;
int new_y_end;
float roll_value;
float pitch_value;
float marker_y;
float x_ini;
float x_end;
float y_ini;
float y_end;
int i;
POINT centroid = get_centroid();
RECT box = get_location();
int scr_min = box.top;
int half_span = box.right >> 1;
char TextLadder[80];
int condition;
int label_length;
roll_value = current_ch2();
GLfloat sinRoll = sin( roll_value );
GLfloat cosRoll = cos( roll_value );
float hole = (float)((scr_hole)/2);
GLfloat mat[16];
pitch_value = current_ch1() * RAD_TO_DEG;
vmin = pitch_value - (double)width_units/2.0;
vmax = pitch_value + (double)width_units/2.0;
vmin = pitch_value - (float)width_units/2.0;
vmax = pitch_value + (float)width_units/2.0;
// Box the target.
drawOneLine( centroid.x - 5, centroid.y, centroid.x, centroid.y + 5);
drawOneLine( centroid.x, centroid.y + 5, centroid.x + 5, centroid.y);
drawOneLine( centroid.x + 5, centroid.y, centroid.x, centroid.y - 5);
drawOneLine( centroid.x, centroid.y - 5, centroid.x - 5, centroid.y);
for( i=(int)vmin; i<=(int)vmax; i++ ) { // Through integer pitch values...
condition = 1;
if( condition ) {
marker_y = centroid.y + (int)(((double)(i - pitch_value) * factor) + .5);
// We will do everything with glLoadMatrix :-)
// to avoid multiple pushing and popping matrix stack
glPushMatrix();
// glTranslatef( centroid.x, centroid.y, 0);
// glRotatef(roll_value * RAD_TO_DEG, 0.0, 0.0, 1.0);
// glGetFloatv(GL_MODELVIEW_MATRIX, mat);
// this is the same as above
float sinx = sin(roll_value);
float cosx = cos(roll_value);
mat[0] = cosx;
mat[1] = sinx;
mat[2] = mat[3] = 0.0;
mat[4] = -sinx;
mat[5] = cosx;
mat[6] = mat[7] = mat[8] = mat[9];
mat[10] = 1.0;
mat[11] = 0.0;
mat[12] = centroid.x;
mat[13] = centroid.y;
mat[14] = 0;
mat[15] = 1.0;
glLoadMatrixf( mat );
// Draw the target spot.
#define CENTER_DIAMOND_SIZE 5.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();
#if 0
glBegin(GL_LINES);
glVertex2f( -CENTER_DIAMOND_SIZE, 0);
glVertex2f( -(CENTER_DIAMOND_SIZE*2), 0);
glVertex2f(0, CENTER_DIAMOND_SIZE);
glVertex2f(0, (CENTER_DIAMOND_SIZE*2));
glVertex2f( CENTER_DIAMOND_SIZE, 0);
glVertex2f( (CENTER_DIAMOND_SIZE*2), 0);
glVertex2f(0, -CENTER_DIAMOND_SIZE);
glVertex2f(0, -(CENTER_DIAMOND_SIZE*2));
glEnd();
#endif // 0
#undef CENTER_DIAMOND_SIZE
int last =FloatToInt(vmax)+1;
i = FloatToInt(vmin);
if( div_units ) {
if( !scr_hole ) {
for( ; i <last ; i++ ) {
marker_y = /*(int)*/(((float)(i - pitch_value) * factor) + .5);
if( !(i % div_units )) { // At integral multiple of div
sprintf( TextLadder, "%d", i );
label_length = strlen( TextLadder );
if( scr_hole == 0 ) {
label_length = sprintf( TextLadder, "%d", i );
if( i ) {
x_ini = centroid.x - half_span;
}
else { // Make zero point wider on left
x_ini = centroid.x - half_span - 10;
x_ini = -half_span;
} else { // Make zero point wider on left
x_ini = -half_span - 10;
}
x_end = half_span;
y_ini = marker_y;
x_end = centroid.x + half_span;
y_end = marker_y;
new_x_ini = centroid.x + (int)(
(x_ini - centroid.x) * cosRoll -
(y_ini - centroid.y) * sinRoll);
new_y_ini = centroid.y + (int)( \
(x_ini - centroid.x) * sinRoll + \
(y_ini - centroid.y) * cosRoll);
new_x_end = centroid.x + (int)( \
(x_end - centroid.x) * cosRoll - \
(y_end - centroid.y) * sinRoll);
new_y_end = centroid.y + (int)( \
(x_end - centroid.x) * sinRoll + \
(y_end - centroid.y) * cosRoll);
// printf("(%.1f %.1f) (%.1f %.1f)\n",x_ini,y_ini,x_end,y_end);
if( i >= 0 ) { // Above zero draw solid lines
drawOneLine( new_x_ini, new_y_ini, new_x_end, new_y_end );
}
else { // Below zero draw dashed lines.
glBegin(GL_LINES);
glVertex2f( x_ini, y_ini);
glVertex2f( x_end, y_end );
glEnd();
} else { // Below zero draw dashed lines.
glEnable(GL_LINE_STIPPLE);
glLineStipple( 1, 0x00FF );
drawOneLine( new_x_ini, new_y_ini, new_x_end, new_y_end );
glBegin(GL_LINES);
glVertex2f( x_ini, y_ini);
glVertex2f( x_end, y_end );
glEnd();
glDisable(GL_LINE_STIPPLE);
}
// Calculate the position of the left text and write it.
new_x_ini = centroid.x + (int)(
(x_ini - 8 * label_length- 4 - centroid.x) * cosRoll -
(y_ini - 4 ) * sinRoll);
new_y_ini = centroid.y + (int)(
(x_ini - 8 * label_length- 4 - centroid.x) * sinRoll +
(y_ini - 4 - centroid.y) * cosRoll);
strokeString( new_x_ini , new_y_ini ,
TextLadder, GLUT_STROKE_ROMAN,
roll_value );
// Calculate the position of the left text and write it.
x_ini -= ( 8*label_length - 4);
y_ini -= 4;
_strokeString(x_ini, y_ini,
TextLadder, GLUT_STROKE_ROMAN );
glLoadMatrixf( mat );
// Calculate the position of the right text and write it.
new_x_end = centroid.x + (int)( \
(x_end + 24 - 8 * label_length - centroid.x) * cosRoll - \
(y_end - 4 - centroid.y) * sinRoll);
new_y_end = centroid.y + (int)( \
(x_end + 24 - 8 * label_length - centroid.x) * sinRoll + \
(y_end - 4 - centroid.y) * cosRoll);
strokeString( new_x_end, new_y_end,
TextLadder, GLUT_STROKE_ROMAN,
roll_value );
x_end -= (24 - 8 * label_length);
y_end -= 4;
_strokeString(x_end, y_end,
TextLadder, GLUT_STROKE_ROMAN );
glLoadMatrixf( mat );
}
else { // Draw ladder with space in the middle of the lines
}
}
else // if(scr_hole )
{ // Draw ladder with space in the middle of the lines
last =FloatToInt(vmax)+1;
i = FloatToInt(vmin);
for( ; i <last ; i++ ) {
marker_y = /*(int)*/(((float)(i - pitch_value) * factor) + .5);
if( !(i % div_units )) { // At integral multiple of div
label_length = sprintf( TextLadder, "%d", i );
// Start by calculating the points and drawing the
// left side lines.
if( i != 0 ) {
x_ini = centroid.x - half_span;
}
else {
x_ini = centroid.x - half_span - 10;
x_ini = -half_span;
} else {
x_ini = -half_span - 10;
}
x_end = -half_span + hole;
y_ini = marker_y;
x_end = centroid.x - half_span + scr_hole/2;
y_end = marker_y;
new_x_end = centroid.x+ (int)( \
(x_end - centroid.x) * cosRoll -\
(y_end - centroid.y) * sinRoll);
new_y_end = centroid.y+ (int)( \
(x_end - centroid.x) * sinRoll +\
(y_end - centroid.y) * cosRoll);
new_x_ini = centroid.x + (int)( \
(x_ini - centroid.x) * cosRoll -\
(y_ini - centroid.y) * sinRoll);
new_y_ini = centroid.y + (int)( \
(x_ini - centroid.x) * sinRoll +\
(y_ini - centroid.y) * cosRoll);
// printf("half_span(%d) scr_hole(%d)\n", half_span, scr_hole);
// printf("x_end(%f) %f\n",x_end,(float)(-half_span + scr_hole/2));
// printf("L: (%.1f %.1f) (%.1f %.1f)\n",x_ini,y_ini,x_end,y_end);
if( i >= 0 )
{
drawOneLine( new_x_ini, new_y_ini, new_x_end, new_y_end );
}
else {
if( i >= 0 ) { // Above zero draw solid lines
glBegin(GL_LINES);
glVertex2f( x_ini, y_ini);
glVertex2f( x_end, y_end );
glEnd();
} else { // Below zero draw dashed lines.
glEnable(GL_LINE_STIPPLE);
glLineStipple( 1, 0x00FF );
drawOneLine( new_x_ini, new_y_ini, new_x_end, new_y_end );
glBegin(GL_LINES);
glVertex2f( x_ini, y_ini);
glVertex2f( x_end, y_end );
glEnd();
glDisable(GL_LINE_STIPPLE);
}
// Now calculate the location of the left side label using
// the previously calculated start of the left side line.
x_ini = x_ini - (label_length + 32 + centroid.x);
x_ini -= (label_length + 32);
if( i < 0) {
x_ini -= 8;
}
else {
} else {
if( i == 0 ) {
x_ini += 20;
x_ini += 15; //20;
}
}
y_ini = y_ini - ( 4 + centroid.y);
y_ini -= 4;
new_x_ini = centroid.x + (int)(x_ini * cosRoll - y_ini * sinRoll);
new_y_ini = centroid.y + (int)(x_ini * sinRoll + y_ini * cosRoll);
strokeString( new_x_ini , new_y_ini ,
TextLadder, GLUT_STROKE_MONO_ROMAN,
roll_value );
_strokeString(x_ini, y_ini,
TextLadder, GLUT_STROKE_MONO_ROMAN );
glLoadMatrixf( mat );
// Now calculate and draw the right side line location
x_ini = centroid.x + half_span - scr_hole/2;
x_ini = half_span - hole;
y_ini = marker_y;
if( i != 0 ) {
x_end = centroid.x + half_span;
}
else {
x_end = centroid.x + half_span + 10;
x_end = half_span;
} else {
x_end = half_span + 10;
}
y_end = marker_y;
new_x_ini = centroid.x + (int)( \
(x_ini-centroid.x)*cosRoll -\
(y_ini-centroid.y)*sinRoll);
new_y_ini = centroid.y + (int)( \
(x_ini-centroid.x)*sinRoll +\
(y_ini-centroid.y)*cosRoll);
new_x_end = centroid.x + (int)( \
(x_end-centroid.x)*cosRoll -\
(y_end-centroid.y)*sinRoll);
new_y_end = centroid.y + (int)( \
(x_end-centroid.x)*sinRoll +\
(y_end-centroid.y)*cosRoll);
// printf("R: (%.1f %.1f) (%.1f %.1f)\n",x_ini,y_ini,x_end,y_end);
if( i >= 0 )
{
drawOneLine( new_x_ini, new_y_ini, new_x_end, new_y_end );
}
else
{
if( i >= 0 ) { // Above zero draw solid lines
glBegin(GL_LINES);
glVertex2f( x_ini, y_ini);
glVertex2f( x_end, y_end );
glEnd();
} else { // Below zero draw dashed lines.
glEnable(GL_LINE_STIPPLE);
glLineStipple( 1, 0x00FF );
drawOneLine( new_x_ini, new_y_ini, new_x_end, new_y_end );
glBegin(GL_LINES);
glVertex2f( x_ini, y_ini);
glVertex2f( x_end, y_end );
glEnd();
glDisable(GL_LINE_STIPPLE);
}
// Calculate the location and draw the right side label
// using the end of the line as previously calculated.
x_end -= centroid.x + label_length - 24;
if( i < 0 ) {
x_end -= (label_length - 24);
if( i <= 0 ) {
x_end -= 8;
}
y_end = marker_y - ( 4 + centroid.y);
new_x_end = centroid.x + (int)( (GLfloat)x_end * cosRoll -
(GLfloat)y_end * sinRoll);
new_y_end = centroid.y + (int)( (GLfloat)x_end * sinRoll +
(GLfloat)y_end * cosRoll);
strokeString( new_x_end, new_y_end,
TextLadder, GLUT_STROKE_MONO_ROMAN,
roll_value );
}
} // else if( i==0)
// {
// x_end -=4;
// }
y_end = marker_y - 4;
_strokeString(x_end, y_end,
TextLadder, GLUT_STROKE_MONO_ROMAN );
glLoadMatrixf( mat );
}
}
}
}
glPopMatrix();
}

14
Simulator/Cockpit/hud_scal.cxx
View file

@ -34,12 +34,12 @@ instr_scale ( int x,
int y,
UINT width,
UINT height,
DBLFNPTR load_fn,
FLTFNPTR load_fn,
UINT options,
double show_range,
double maxValue,
double minValue,
double disp_scale,
float show_range,
float maxValue,
float minValue,
float disp_scale,
UINT major_divs,
UINT minor_divs,
UINT rollover,
@ -57,11 +57,11 @@ instr_scale ( int x,
{
int temp;
scale_factor = (double)get_span() / range_shown;
scale_factor = (float)get_span() / range_shown;
if( show_range < 0 ) {
range_shown = -range_shown;
}
temp = (Maximum_value - Minimum_value) / 100;
temp = FloatToInt(Maximum_value - Minimum_value) / 100;
if( range_shown < temp ) {
range_shown = temp;
}

149
Simulator/Cockpit/hud_tbi.cxx
View file

@ -24,10 +24,10 @@ fgTBI_instr( int x,
int y,
UINT width,
UINT height,
DBLFNPTR chn1_source,
DBLFNPTR chn2_source,
double maxBankAngle,
double maxSlipAngle,
FLTFNPTR chn1_source,
FLTFNPTR chn2_source,
float maxBankAngle,
float maxSlipAngle,
UINT gap_width,
bool working ) :
dual_instr_item( x, y, width, height,
@ -35,8 +35,8 @@ fgTBI_instr( int x,
chn2_source,
working,
HUDS_TOP),
BankLimit (maxBankAngle),
SlewLimit (maxSlipAngle),
BankLimit ((int)(maxBankAngle)),
SlewLimit ((int)(maxSlipAngle)),
scr_hole (gap_width )
{
}
@ -69,122 +69,75 @@ operator = (const fgTBI_instr & rhs )
void fgTBI_instr :: draw( void )
{
int x_inc1, y_inc1;
int x_inc2, y_inc2;
int x_t_inc1, y_t_inc1;
float bank_angle, sideslip_angle;
float ss_const; // sideslip angle pixels per rad
float cen_x, cen_y, bank, fspan, tee, hole;
int d_bottom_x, d_bottom_y;
int d_right_x, d_right_y;
int d_top_x, d_top_y;
int d_left_x, d_left_y;
int span = get_span();
float zero = 0.0;
int inc_b_x, inc_b_y;
int inc_r_x, inc_r_y;
int inc_t_x, inc_t_y;
int inc_l_x, inc_l_y;
RECT My_box = get_location();
POINT centroid = get_centroid();
int tee_height = My_box.bottom;
// struct fgFLIGHT *f = &current_aircraft.flight;
double sin_bank, cos_bank;
double bank_angle, sideslip_angle;
double ss_const; // sideslip angle pixels per rad
bank_angle = current_ch2(); // Roll limit +/- 30 degrees
if( bank_angle < -FG_PI_2/3 ) {
bank_angle = -FG_PI_2/3;
}
else
if( bank_angle > FG_PI_2/3 ) {
} else if( bank_angle > FG_PI_2/3 ) {
bank_angle = FG_PI_2/3;
}
sideslip_angle = current_ch1(); // Sideslip limit +/- 20 degrees
if( sideslip_angle < -FG_PI/9 ) {
sideslip_angle = -FG_PI/9;
}
else
if( sideslip_angle > FG_PI/9 ) {
} else if( sideslip_angle > FG_PI/9 ) {
sideslip_angle = FG_PI/9;
}
// sin_bank = sin( FG_2PI-FG_Phi );
// cos_bank = cos( FG_2PI-FG_Phi );
sin_bank = sin(FG_2PI-bank_angle);
cos_bank = cos(FG_2PI-bank_angle);
cen_x = centroid.x;
cen_y = centroid.y;
bank = bank_angle * RAD_TO_DEG;
tee = -tee_height;
fspan = span;
hole = scr_hole;
ss_const = 2 * sideslip_angle * fspan/(FG_2PI/9); // width represents 40 degrees
x_inc1 = (int)(get_span() * cos_bank);
y_inc1 = (int)(get_span() * sin_bank);
x_inc2 = (int)(scr_hole * cos_bank);
y_inc2 = (int)(scr_hole * sin_bank);
// printf("side_slip: %f fspan: %f\n", sideslip_angle, fspan);
// printf("ss_const: %f hole: %f\n", ss_const, hole);
x_t_inc1 = (int)(tee_height * sin_bank);
y_t_inc1 = (int)(tee_height * cos_bank);
glPushMatrix();
glTranslatef(cen_x, cen_y, zero);
glRotatef(-bank, zero, zero, 1.0);
d_bottom_x = 0;
d_bottom_y = (int)(-scr_hole);
d_right_x = (int)(scr_hole);
d_right_y = 0;
d_top_x = 0;
d_top_y = (int)(scr_hole);
d_left_x = (int)(-scr_hole);
d_left_y = 0;
glBegin(GL_LINES);
ss_const = (get_span()*2)/(FG_2PI/9); // width represents 40 degrees
d_bottom_x += (int)(sideslip_angle*ss_const);
d_right_x += (int)(sideslip_angle*ss_const);
d_left_x += (int)(sideslip_angle*ss_const);
d_top_x += (int)(sideslip_angle*ss_const);
inc_b_x = (int)(d_bottom_x*cos_bank-d_bottom_y*sin_bank);
inc_b_y = (int)(d_bottom_x*sin_bank+d_bottom_y*cos_bank);
inc_r_x = (int)(d_right_x*cos_bank-d_right_y*sin_bank);
inc_r_y = (int)(d_right_x*sin_bank+d_right_y*cos_bank);
inc_t_x = (int)(d_top_x*cos_bank-d_top_y*sin_bank);
inc_t_y = (int)(d_top_x*sin_bank+d_top_y*cos_bank);
inc_l_x = (int)(d_left_x*cos_bank-d_left_y*sin_bank);
inc_l_y = (int)(d_left_x*sin_bank+d_left_y*cos_bank);
if( scr_hole == 0 )
if( !scr_hole )
{
drawOneLine( centroid.x - x_inc1, centroid.y - y_inc1, \
centroid.x + x_inc1, centroid.y + y_inc1 );
glVertex2f( -fspan, zero );
glVertex2f( fspan, zero );
} else {
glVertex2f( -fspan, zero );
glVertex2f( -hole, zero );
glVertex2f( hole, zero );
glVertex2f( fspan, zero );
}
else
{
drawOneLine( centroid.x - x_inc1, centroid.y - y_inc1, \
centroid.x - x_inc2, centroid.y - y_inc2 );
drawOneLine( centroid.x + x_inc2, centroid.y + y_inc2, \
centroid.x + x_inc1, centroid.y + y_inc1 );
}
// draw teemarks
drawOneLine( centroid.x + x_inc2, \
centroid.y + y_inc2, \
centroid.x + x_inc2 + x_t_inc1, \
centroid.y + y_inc2 - y_t_inc1 );
drawOneLine( centroid.x - x_inc2, \
centroid.y - y_inc2, \
centroid.x - x_inc2 + x_t_inc1, \
centroid.y - y_inc2 - y_t_inc1 );
glVertex2f( hole, zero );
glVertex2f( hole, tee );
glVertex2f( -hole, zero );
glVertex2f( -hole, tee );
// draw sideslip diamond (it is not yet positioned correctly )
drawOneLine( centroid.x + inc_b_x, \
centroid.y + inc_b_y, \
centroid.x + inc_r_x, \
centroid.y + inc_r_y );
drawOneLine( centroid.x + inc_r_x, \
centroid.y + inc_r_y, \
centroid.x + inc_t_x, \
centroid.y + inc_t_y );
drawOneLine( centroid.x + inc_t_x, \
centroid.y + inc_t_y, \
centroid.x + inc_l_x, \
centroid.y + inc_l_y );
drawOneLine( centroid.x + inc_l_x, \
centroid.y + inc_l_y, \
centroid.x + inc_b_x, \
centroid.y + inc_b_y );
glEnd();
glBegin(GL_LINE_LOOP);
glVertex2f( ss_const, -hole);
glVertex2f( ss_const + hole, zero);
glVertex2f( ss_const, hole);
glVertex2f( ss_const - hole, zero);
glEnd();
glPopMatrix();
}

22
Simulator/Cockpit/panel.cxx
View file

@ -25,10 +25,6 @@
# include <config.h>
#endif
#ifdef FG_MATH_EXCEPTION_CLASH
# include <math.h>
#endif
#ifdef HAVE_WINDOWS_H
# include <windows.h>
#endif
@ -464,9 +460,7 @@ void FGHorizon::Render(void){
n = i % 180;
xglNormal3f(0.0, 0.0, 1.5);
xglTexCoord2f((56 / 256), (140 / 256));
xglVertex3f(((vertices[n1 % 180][0] + vertices[n2 % 180][0]) / 2),
((vertices[n1 % 180][1] + vertices[n2 % 180][1]) / 2),
0.0);
xglVertex3f(((vertices[n1 % 180][0] + vertices[n2 % 180][0]) / 2), ((vertices[n1 % 180][1] + vertices[n2 % 180][1]) / 2), 0.0);
xglTexCoord2f((57 / 256), (139 / 256));
xglNormal3f(normals[n][0], normals[n][1], normals[n][3]);
@ -496,9 +490,7 @@ void FGHorizon::Render(void){
n = i % 180;
xglNormal3f(0.0, 0.0, 1.5);
xglTexCoord2f((73 / 256), (237 / 256));
xglVertex3f(((vertices[n1 % 180][0] + vertices[n2 % 180][0]) / 2),
((vertices[n1 % 180][1] + vertices[n2 % 180][1]) / 2),
0.0);
xglVertex3f(((vertices[n1 % 180][0] + vertices[n2 % 180][0]) / 2), ((vertices[n1 % 180][1] + vertices[n2 % 180][1]) / 2), 0.0);
xglTexCoord2f((73 / 256), (236 / 256));
xglNormal3f(normals[n][0], normals[n][1], normals[n][2]);
@ -805,8 +797,7 @@ void FGTurnCoordinator::Init(void){
}
}
void DrawScale(float XPos, float YPos, float InnerRadius, float OuterRadius,
float alpha1, float alpha2, int steps, float LineWidth,
void DrawScale(float XPos, float YPos, float InnerRadius, float OuterRadius, float alpha1, float alpha2, int steps, float LineWidth,
float red, float green, float blue, bool filled){
int i;
float diff = (alpha2 - alpha1) / (float)(steps - 1);
@ -837,9 +828,11 @@ void DrawScale(float XPos, float YPos, float InnerRadius, float OuterRadius,
for(i=0;i < steps; i++){
xglVertex3f(sin(i * diff * DEG_TO_RAD) * OuterRadius,
cos(i * diff * DEG_TO_RAD) * OuterRadius, 0.0);
cos(i * diff * DEG_TO_RAD) * OuterRadius,
0.0);
xglVertex3f(sin(i * diff * DEG_TO_RAD) * InnerRadius,
cos(i * diff * DEG_TO_RAD) * InnerRadius, 0.0);
cos(i * diff * DEG_TO_RAD) * InnerRadius,
0.0);
}
xglEnd();
@ -1092,4 +1085,3 @@ void FGTexInstrument::Render(void){
xglDisable(GL_TEXTURE_2D);
}

3
Simulator/Cockpit/panel.hxx
View file

@ -249,6 +249,3 @@ void DrawBeechcraftLogo(float XPos, float YPos, float Width, float Height);
void PrintMatrix( void);
#endif // _PANEL_HXX