--- /dev/null
+/**************************************************************************
+ * hud.c -- hud defines and prototypes
+ *
+ * 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$
+ * (Log is kept at end of this file)
+ **************************************************************************/
+
+
+#include <GL/glut.h>
+
+#include <stdlib.h>
+#include "hud.h"
+
+#include "../constants.h"
+
+#include "../Aircraft/aircraft.h"
+#include "../Scenery/mesh.h"
+#include "../Scenery/scenery.h"
+#include "../Math/mat3.h"
+#include "../Math/polar.h"
+#include "../Time/fg_timer.h"
+#include "../Math/fg_random.h"
+#include "../Weather/weather.h"
+
+// #define DEBUG
+
+#define drawOneLine(x1,y1,x2,y2) glBegin(GL_LINES); \
+ glVertex2f ((x1),(y1)); glVertex2f ((x2),(y2)); glEnd();
+
+/* textString - Bitmap font string */
+
+static void textString(int x, int y, char *msg, void *font)
+{
+ glRasterPos2f(x, y);
+ while (*msg) {
+ glutBitmapCharacter(font, *msg);
+ msg++;
+ }
+}
+
+/* strokeString - Stroke font string */
+
+static void strokeString(int x, int y, char *msg, void *font)
+{
+ glPushMatrix();
+ glTranslatef(x, y, 0);
+ glScalef(.04, .04, .04);
+ while (*msg) {
+ glutStrokeCharacter(font, *msg);
+ msg++;
+ }
+ glPopMatrix();
+}
+
+/*
+
+ Draws a measuring scale anywhere on the HUD
+
+
+ Needs: HUD_scale struct
+
+*/
+static void drawscale( int type, int sub_type, int min_value, int orientation, int scr_pos, \
+ int scr_min, int scr_max, double total_amount, int min_div, int max_div, \
+ double cur_value )
+{
+ double vmin, vmax;
+ int marker_x, marker_y;
+ int mid_scr;
+ // int scale_min, scale_max;
+ register i;
+ double factor;
+ char TextScale[80];
+ int condition;
+
+ vmin = cur_value-total_amount/2;
+ vmax = cur_value+total_amount/2;
+
+ mid_scr = scr_min+(scr_max-scr_min)/2;
+
+ if( type == VERTICAL ) // Vertical scale
+ {
+ if( orientation == LEFT )
+ marker_x = scr_pos-6;
+ else if( orientation == RIGHT )
+ marker_x = scr_pos;
+ drawOneLine( scr_pos, scr_min, scr_pos, scr_max );
+ if( orientation == LEFT )
+ {
+ drawOneLine( scr_pos-3, scr_min, scr_pos, scr_min );
+ drawOneLine( scr_pos-3, scr_max, scr_pos, scr_max );
+ drawOneLine( scr_pos, mid_scr, scr_pos+6, mid_scr );
+ } else if( orientation == RIGHT )
+ {
+ drawOneLine( scr_pos, scr_min, scr_pos+3, scr_min );
+ drawOneLine( scr_pos, scr_max, scr_pos+3, scr_max );
+ drawOneLine( scr_pos, mid_scr, scr_pos-6, mid_scr );
+ }
+
+ factor = (scr_max-scr_min)/total_amount;
+
+ for( i=vmin; i<=vmax; i+=1 )
+ {
+ if( sub_type == LIMIT )
+ condition = i>= min_value;
+ else if( sub_type == NOLIMIT )
+ condition = 1;
+
+ if( condition )
+ {
+ marker_y = scr_min+(i-vmin)*factor;
+ if( i%min_div==0 )
+ if( orientation == LEFT )
+ {
+ drawOneLine( marker_x+3, marker_y, marker_x+6, marker_y );
+ }
+ else if( orientation == RIGHT )
+ {
+ drawOneLine( marker_x, marker_y, marker_x+3, marker_y );
+ }
+ if( i%max_div==0 )
+ {
+ drawOneLine( marker_x, marker_y, marker_x+6, marker_y );
+ sprintf( TextScale, "%d", i );
+ if( orientation == LEFT )
+ {
+ textString( marker_x-8*strlen(TextScale)-2, marker_y-4, TextScale, GLUT_BITMAP_8_BY_13 );
+ }
+ else if( orientation == RIGHT )
+ {
+ textString( marker_x+10, marker_y-4, TextScale, GLUT_BITMAP_8_BY_13 );
+ }
+ }
+ }
+ }
+ }
+ if( type == HORIZONTAL ) // Horizontal scale
+ {
+ if( orientation == TOP )
+ marker_y = scr_pos;
+ else if( orientation == BOTTOM )
+ marker_y = scr_pos-6;
+ drawOneLine( scr_min, scr_pos, scr_max, scr_pos );
+ if( orientation == TOP )
+ {
+ drawOneLine( scr_min, scr_pos, scr_min, scr_pos-3 );
+ drawOneLine( scr_max, scr_pos, scr_max, scr_pos-3 );
+ drawOneLine( mid_scr, scr_pos, mid_scr, scr_pos-6 );
+ } else if( orientation == BOTTOM )
+ {
+ drawOneLine( scr_min, scr_pos, scr_min, scr_pos+3 );
+ drawOneLine( scr_max, scr_pos, scr_max, scr_pos+3 );
+ drawOneLine( mid_scr, scr_pos, mid_scr, scr_pos+6 );
+ }
+
+ factor = (scr_max-scr_min)/total_amount;
+
+ for( i=vmin; i<=vmax; i+=1 )
+ {
+ if( sub_type == LIMIT )
+ condition = i>= min_value;
+ else if( sub_type == NOLIMIT )
+ condition = 1;
+
+ if( condition )
+ {
+ marker_x = scr_min+(i-vmin)*factor;
+ if( i%min_div==0 )
+ if( orientation == TOP )
+ {
+ drawOneLine( marker_x, marker_y, marker_x, marker_y+3 );
+ }
+ else if( orientation == BOTTOM )
+ {
+ drawOneLine( marker_x, marker_y+3, marker_x, marker_y+6 );
+ }
+ if( i%max_div==0 )
+ {
+ sprintf( TextScale, "%d", i );
+ if( orientation == TOP )
+ {
+ drawOneLine( marker_x, marker_y, marker_x, marker_y+6 );
+ textString( marker_x-4*strlen(TextScale), marker_y+14, TextScale, GLUT_BITMAP_8_BY_13 );
+ }
+ else if( orientation == BOTTOM )
+ {
+ drawOneLine( marker_x, marker_y, marker_x, marker_y+6 );
+ textString( marker_x+10, marker_y-4, TextScale, GLUT_BITMAP_8_BY_13 );
+ }
+ }
+ }
+ }
+ }
+
+}
+
+/*
+
+ Draws a climb ladder in the center of the HUD
+
+
+ Needs: HUD_ladder struct
+
+*/
+static void drawladder( struct HUD_ladder ladder )
+{
+ double vmin, vmax;
+ double roll_value, pitch_value;
+ double cos_roll, sin_roll;
+ int marker_x, marker_y;
+ int mid_scr;
+ int scr_min, scr_max;
+ int x_ini, x_end;
+ int y_ini, y_end;
+ int new_x_ini, new_x_end;
+ int new_y_ini, new_y_end;
+ register i;
+ double factor;
+ char TextLadder[80];
+ int condition;
+
+ roll_value = (*ladder.load_roll)();
+ pitch_value = (*ladder.load_pitch)()*RAD_TO_DEG;
+
+ vmin = pitch_value-ladder.width_units/2;
+ vmax = pitch_value+ladder.width_units/2;
+
+ scr_min = ladder.y_pos-(ladder.scr_height/2);
+ scr_max = scr_min+ladder.scr_height;
+
+ mid_scr = scr_min+(scr_max-scr_min)/2;
+
+ marker_x = ladder.x_pos-ladder.scr_width/2;
+
+ factor = (scr_max-scr_min)/ladder.width_units;
+
+ for( i=vmin; i<=vmax; i+=1 )
+ {
+ condition = 1;
+ if( condition )
+ {
+ marker_y = scr_min+(i-vmin)*factor;
+ if( i%ladder.div_units==0 )
+ {
+ sprintf( TextLadder, "%d", i );
+ if( ladder.scr_hole == 0 )
+ {
+ if( i != 0 )
+ x_ini = ladder.x_pos-ladder.scr_width/2;
+ else
+ x_ini = ladder.x_pos-ladder.scr_width/2-10;
+ y_ini = marker_y;
+ x_end = ladder.x_pos+ladder.scr_width/2;
+ y_end = marker_y;
+ new_x_ini = ladder.x_pos+(x_ini-ladder.x_pos)*cos(roll_value)-\
+ (y_ini-ladder.y_pos)*sin(roll_value);
+ new_y_ini = ladder.y_pos+(x_ini-ladder.x_pos)*sin(roll_value)+\
+ (y_ini-ladder.y_pos)*cos(roll_value);
+ new_x_end = ladder.x_pos+(x_end-ladder.x_pos)*cos(roll_value)-\
+ (y_end-ladder.y_pos)*sin(roll_value);
+ new_y_end = ladder.y_pos+(x_end-ladder.x_pos)*sin(roll_value)+\
+ (y_end-ladder.y_pos)*cos(roll_value);
+
+ if( i >= 0 )
+ {
+ drawOneLine( new_x_ini, new_y_ini, new_x_end, new_y_end );
+ }
+ else
+ {
+ glEnable(GL_LINE_STIPPLE);
+ glLineStipple( 1, 0x00FF );
+ drawOneLine( new_x_ini, new_y_ini, new_x_end, new_y_end );
+ glDisable(GL_LINE_STIPPLE);
+ }
+ textString( new_x_ini-8*strlen(TextLadder)-8, new_y_ini-4, TextLadder, GLUT_BITMAP_8_BY_13 );
+ textString( new_x_end+10, new_y_end-4, TextLadder, GLUT_BITMAP_8_BY_13 );
+ }
+ else
+ {
+ if( i != 0 )
+ x_ini = ladder.x_pos-ladder.scr_width/2;
+ else
+ x_ini = ladder.x_pos-ladder.scr_width/2-10;
+ y_ini = marker_y;
+ x_end = ladder.x_pos-ladder.scr_width/2+ladder.scr_hole/2;
+ y_end = marker_y;
+ new_x_ini = ladder.x_pos+(x_ini-ladder.x_pos)*cos(roll_value)-\
+ (y_ini-ladder.y_pos)*sin(roll_value);
+ new_y_ini = ladder.y_pos+(x_ini-ladder.x_pos)*sin(roll_value)+\
+ (y_ini-ladder.y_pos)*cos(roll_value);
+ new_x_end = ladder.x_pos+(x_end-ladder.x_pos)*cos(roll_value)-\
+ (y_end-ladder.y_pos)*sin(roll_value);
+ new_y_end = ladder.y_pos+(x_end-ladder.x_pos)*sin(roll_value)+\
+ (y_end-ladder.y_pos)*cos(roll_value);
+
+ if( i >= 0 )
+ {
+ drawOneLine( new_x_ini, new_y_ini, new_x_end, new_y_end );
+ }
+ else
+ {
+ glEnable(GL_LINE_STIPPLE);
+ glLineStipple( 1, 0x00FF );
+ drawOneLine( new_x_ini, new_y_ini, new_x_end, new_y_end );
+ glDisable(GL_LINE_STIPPLE);
+ }
+ textString( new_x_ini-8*strlen(TextLadder)-8, new_y_ini-4, TextLadder, GLUT_BITMAP_8_BY_13 );
+
+ x_ini = ladder.x_pos+ladder.scr_width/2-ladder.scr_hole/2;
+ y_ini = marker_y;
+ if( i != 0 )
+ x_end = ladder.x_pos+ladder.scr_width/2;
+ else
+ x_end = ladder.x_pos+ladder.scr_width/2+10;
+ y_end = marker_y;
+ new_x_ini = ladder.x_pos+(x_ini-ladder.x_pos)*cos(roll_value)-\
+ (y_ini-ladder.y_pos)*sin(roll_value);
+ new_y_ini = ladder.y_pos+(x_ini-ladder.x_pos)*sin(roll_value)+\
+ (y_ini-ladder.y_pos)*cos(roll_value);
+ new_x_end = ladder.x_pos+(x_end-ladder.x_pos)*cos(roll_value)-\
+ (y_end-ladder.y_pos)*sin(roll_value);
+ new_y_end = ladder.y_pos+(x_end-ladder.x_pos)*sin(roll_value)+\
+ (y_end-ladder.y_pos)*cos(roll_value);
+
+ if( i >= 0 )
+ {
+ drawOneLine( new_x_ini, new_y_ini, new_x_end, new_y_end );
+ }
+ else
+ {
+ glEnable(GL_LINE_STIPPLE);
+ glLineStipple( 1, 0x00FF );
+ drawOneLine( new_x_ini, new_y_ini, new_x_end, new_y_end );
+ glDisable(GL_LINE_STIPPLE);
+ }
+ textString( new_x_end+10, new_y_end-4, TextLadder, GLUT_BITMAP_8_BY_13 );
+ }
+ }
+ /* if( i%max_div==0 )
+ {
+ drawOneLine( marker_x, marker_y, marker_x+6, marker_y );
+ sprintf( TextScale, "%d", i );
+ if( orientation == LEFT )
+ {
+ textString( marker_x-8*strlen(TextScale)-2, marker_y-4, TextScale, GLUT_BITMAP_8_BY_13 );
+ }
+ else if( orientation == RIGHT )
+ {
+ textString( marker_x+10, marker_y-4, TextScale, GLUT_BITMAP_8_BY_13 );
+ }
+ } */
+ }
+ }
+
+}
+
+/*
+
+ Draws an artificial horizon line in the center of the HUD
+ (with or without a center hole)
+
+ Needs: x_center, y_center, length, hole
+
+*/
+static void drawhorizon( struct HUD_horizon horizon )
+{
+ int x_inc1, y_inc1;
+ int x_inc2, y_inc2;
+ struct FLIGHT *f;
+ double sin_bank, cos_bank;
+ double bank_angle;
+
+ // f = ¤t_aircraft.flight;
+
+ bank_angle = (*horizon.load_value)();
+
+ // sin_bank = sin( 2*PI-FG_Phi );
+ // cos_bank = cos( 2*PI-FG_Phi );
+ sin_bank = sin(2*PI-bank_angle);
+ cos_bank = cos(2*PI-bank_angle);
+ x_inc1 = (int)(horizon.scr_width*cos_bank);
+ y_inc1 = (int)(horizon.scr_width*sin_bank);
+ x_inc2 = (int)(horizon.scr_hole*cos_bank);
+ y_inc2 = (int)(horizon.scr_hole*sin_bank);
+
+ if( horizon.scr_hole == 0 )
+ {
+ drawOneLine( horizon.x_pos-x_inc1, horizon.y_pos-y_inc1, \
+ horizon.x_pos+x_inc1, horizon.y_pos+y_inc1 );
+ }
+ else
+ {
+ drawOneLine( horizon.x_pos-x_inc1, horizon.y_pos-y_inc1, \
+ horizon.x_pos-x_inc2, horizon.y_pos-y_inc2 );
+ drawOneLine( horizon.x_pos+x_inc2, horizon.y_pos+y_inc2, \
+ horizon.x_pos+x_inc1, horizon.y_pos+y_inc1 );
+ }
+}
+
+/*
+
+ Draws a label anywhere in the HUD
+
+ Needs: HUD_label struct
+
+*/
+static void drawlabel( struct HUD_label label )
+{
+ char buffer[80];
+ char string[80];
+ int posincr;
+ int lenstr;
+
+ if( label.pre_str != NULL && label.post_str != NULL )
+ sprintf( buffer, "%s%s%s", label.pre_str, label.format, label.post_str );
+ else if( label.pre_str == NULL && label.post_str != NULL )
+ sprintf( buffer, "%s%s", label.format, label.post_str );
+ else if( label.pre_str != NULL && label.post_str == NULL )
+ sprintf( buffer, "%s%s", label.pre_str, label.format );
+
+ sprintf( string, buffer, (*label.load_value)() );
+
+#ifdef DEBUG
+ printf( buffer );
+ printf( "\n" );
+ printf( string );
+ printf( "\n" );
+#endif
+
+ lenstr = strlen( string );
+ if( label.justify == LEFT_JUST )
+ posincr = -lenstr*8;
+ else if( label.justify == CENTER_JUST )
+ posincr = -lenstr*4;
+ else if( label.justify == RIGHT_JUST )
+ posincr = 0;
+
+ if( label.size == SMALL )
+ textString( label.x_pos+posincr, label.y_pos, string, GLUT_BITMAP_8_BY_13);
+ else if( label.size == LARGE )
+ textString( label.x_pos+posincr, label.y_pos, string, GLUT_BITMAP_9_BY_15);
+
+}
+
+double get_speed()
+{
+ struct FLIGHT *f;
+
+ f = ¤t_aircraft.flight;
+ return( FG_V_true_kts );
+}
+
+double get_aoa()
+{
+ struct FLIGHT *f;
+
+ f = ¤t_aircraft.flight;
+ return( FG_Gamma_vert_rad*RAD_TO_DEG );
+}
+
+double get_roll()
+{
+ struct FLIGHT *f;
+
+ f = ¤t_aircraft.flight;
+ return( FG_Phi );
+}
+
+double get_pitch()
+{
+ struct FLIGHT *f;
+
+ f = ¤t_aircraft.flight;
+ return( FG_Theta );
+}
+
+double get_heading()
+{
+ struct FLIGHT *f;
+
+ f = ¤t_aircraft.flight;
+ return( FG_Gamma_horiz_rad*RAD_TO_DEG );
+}
+
+double get_altitude()
+{
+ struct FLIGHT *f;
+ double rough_elev;
+
+ f = ¤t_aircraft.flight;
+ rough_elev = mesh_altitude(FG_Longitude * RAD_TO_ARCSEC,
+ FG_Latitude * RAD_TO_ARCSEC);
+
+ return( FG_Altitude*FEET_TO_METER-rough_elev );
+}
+
+void add_instrument( Hptr hud, HIptr instrument )
+{
+ HIptr instruments;
+
+ instruments = hud->instruments;
+ // while( ++instruments
+}
+
+Hptr fgHUDInit( struct AIRCRAFT current_aircraft, int color )
+{
+ Hptr hud;
+
+ hud = (Hptr)calloc(sizeof(struct HUD),1);
+ if( hud == NULL )
+ return( NULL );
+
+ hud->code = 123;
+ hud->status = 0;
+
+ // For now let's just hardcode a hud here .
+ // In the future, hud information has to come from the same place
+ // aircraft information came
+
+ fgHUDAddHorizon( hud, 590, 50, 40, 20, get_roll );
+ fgHUDAddScale( hud, VERTICAL, 220, 100, 280, 5, 10, LEFT, LEFT, 0, 100, get_speed );
+ fgHUDAddScale( hud, VERTICAL, 440, 100, 280, 1, 5, RIGHT, RIGHT, -MAXINT, 25, get_aoa );
+ fgHUDAddScale( hud, HORIZONTAL, 280, 220, 440, 5, 10, TOP, TOP, 0, 50, get_heading );
+ fgHUDAddLabel( hud, 180, 85, SMALL, NOBLINK, RIGHT_JUST, NULL, " Kts", "%5.0f", get_speed );
+ fgHUDAddLabel( hud, 180, 73, SMALL, NOBLINK, RIGHT_JUST, NULL, " m", "%5.0f", get_altitude );
+ fgHUDAddLadder( hud, 330, 190, 90, 180, 70, 10, NONE, 45, get_roll, get_pitch );
+
+ return( hud );
+}
+
+
+Hptr fgHUDAddHorizon( Hptr hud, int x_pos, int y_pos, int length, \
+ int hole_len, double (*load_value)() )
+{
+ struct HUD_horizon *horizon;
+ struct HUD_instr *instrument;
+ HIptr tmp_first, tmp_next;
+
+ tmp_first = hud->instruments;
+ if( tmp_first != NULL )
+ tmp_next = tmp_first->next;
+ else
+ tmp_next = NULL;
+
+ instrument = (HIptr)calloc(sizeof(struct HUD_instr),1);
+ if( instrument == NULL )
+ return( NULL );
+
+ horizon = (struct HUD_horizon *)calloc(sizeof(struct HUD_horizon),1);
+ if( horizon == NULL )
+ return( NULL );
+
+ instrument->type = ARTIFICIAL_HORIZON;
+ instrument->instr = *horizon;
+ instrument->instr.horizon.x_pos = x_pos;
+ instrument->instr.horizon.y_pos = y_pos;
+ instrument->instr.horizon.scr_width = length;
+ instrument->instr.horizon.scr_hole = hole_len;
+ instrument->instr.horizon.load_value = load_value;
+ instrument->next = tmp_first;
+
+ hud->instruments = instrument;
+
+ return( hud );
+}
+
+Hptr fgHUDAddScale( Hptr hud, int type, int scr_pos, int scr_min, int scr_max, int div_min, int div_max, \
+ int orientation, int with_min, int min_value, int width_units, double (*load_value)() )
+{
+ struct HUD_scale *scale;
+ struct HUD_instr *instrument;
+ HIptr tmp_first, tmp_next;
+
+ tmp_first = hud->instruments;
+ if( tmp_first != NULL )
+ tmp_next = tmp_first->next;
+ else
+ tmp_next = NULL;
+
+ instrument = (HIptr)calloc(sizeof(struct HUD_instr),1);
+ if( instrument == NULL )
+ return( NULL );
+
+ scale = (struct HUD_scale *)calloc(sizeof(struct HUD_scale),1);
+ if( scale == NULL )
+ return( NULL );
+
+ instrument->type = SCALE;
+ instrument->instr = *scale;
+ instrument->instr.scale.type = type;
+ instrument->instr.scale.scr_pos = scr_pos;
+ instrument->instr.scale.scr_min = scr_min;
+ instrument->instr.scale.scr_max = scr_max;
+ instrument->instr.scale.div_min = div_min;
+ instrument->instr.scale.div_max = div_max;
+ instrument->instr.scale.orientation = orientation;
+ instrument->instr.scale.with_minimum = with_min;
+ instrument->instr.scale.minimum_value = min_value;
+ instrument->instr.scale.width_units = width_units;
+ instrument->instr.scale.load_value = load_value;
+ instrument->next = tmp_first;
+
+ hud->instruments = instrument;
+
+ return( hud );
+}
+
+Hptr fgHUDAddLabel( Hptr hud, int x_pos, int y_pos, int size, int blink, int justify, \
+ char *pre_str, char *post_str, char *format, double (*load_value)() )
+{
+ struct HUD_label *label;
+ struct HUD_instr *instrument;
+ HIptr tmp_first, tmp_next;
+
+ tmp_first = hud->instruments;
+ if( tmp_first != NULL )
+ tmp_next = tmp_first->next;
+ else
+ tmp_next = NULL;
+
+ instrument = (HIptr)calloc(sizeof(struct HUD_instr),1);
+ if( instrument == NULL )
+ return( NULL );
+
+ label = (struct HUD_label *)calloc(sizeof(struct HUD_label),1);
+ if( label == NULL )
+ return( NULL );
+
+ instrument->type = LABEL;
+ instrument->instr = *label;
+ instrument->instr.label.x_pos = x_pos;
+ instrument->instr.label.y_pos = y_pos;
+ instrument->instr.label.size = size;
+ instrument->instr.label.blink = blink;
+ instrument->instr.label.justify = justify;
+ instrument->instr.label.pre_str = pre_str;
+ instrument->instr.label.post_str = post_str;
+ instrument->instr.label.format = format;
+ instrument->instr.label.load_value = load_value;
+ instrument->next = tmp_first;
+
+ hud->instruments = instrument;
+
+ return( hud );
+}
+
+Hptr fgHUDAddLadder( Hptr hud, int x_pos, int y_pos, int scr_width, int scr_height, \
+ int hole_len, int div_units, int label_pos, int width_units, \
+ double (*load_roll)(), double (*load_pitch)() )
+{
+ struct HUD_ladder *ladder;
+ struct HUD_instr *instrument;
+ HIptr tmp_first, tmp_next;
+
+ tmp_first = hud->instruments;
+ if( tmp_first != NULL )
+ tmp_next = tmp_first->next;
+ else
+ tmp_next = NULL;
+
+ instrument = (HIptr)calloc(sizeof(struct HUD_instr),1);
+ if( instrument == NULL )
+ return( NULL );
+
+ ladder = (struct HUD_ladder *)calloc(sizeof(struct HUD_ladder),1);
+ if( ladder == NULL )
+ return( NULL );
+
+ instrument->type = LADDER;
+ instrument->instr = *ladder;
+ instrument->instr.ladder.type = 0; // Not used.
+ instrument->instr.ladder.x_pos = x_pos;
+ instrument->instr.ladder.y_pos = y_pos;
+ instrument->instr.ladder.scr_width = scr_width;
+ instrument->instr.ladder.scr_height = scr_height;
+ instrument->instr.ladder.scr_hole = hole_len;
+ instrument->instr.ladder.div_units = div_units;
+ instrument->instr.ladder.label_position = label_pos;
+ instrument->instr.ladder.width_units = width_units;
+ instrument->instr.ladder.load_roll = load_roll;
+ instrument->instr.ladder.load_pitch = load_pitch;
+ instrument->next = tmp_first;
+
+ hud->instruments = instrument;
+
+ return( hud );
+
+}
+
+/*
+Hptr fgHUDAddMovingHorizon( Hptr hud, int x_pos, int y_pos, int length, int hole_len, \
+ int color )
+{
+
+}
+
+Hptr fgHUDAddCircularLadder( Hptr hud, int scr_min, int scr_max, int div_min, int div_max, \
+ int max_value )
+{
+
+}
+
+Hptr fgHUDAddNumDisp( Hptr hud, int x_pos, int y_pos, int size, int color, int blink, \
+ char *pre_str, char *post_str )
+{
+
+}
+*/
+
+void fgUpdateHUD( Hptr hud )
+{
+ HIptr hud_instr;
+ union HUD_instr_data instr_data;
+
+ glMatrixMode(GL_PROJECTION);
+ glPushMatrix();
+
+ glLoadIdentity();
+ gluOrtho2D(0, 640, 0, 480);
+ glMatrixMode(GL_MODELVIEW);
+ glPushMatrix();
+ glLoadIdentity();
+
+ glColor3f(1.0, 1.0, 1.0);
+ glIndexi(7);
+
+ glDisable(GL_DEPTH_TEST);
+ glDisable(GL_LIGHTING);
+
+ glLineWidth(1);
+ glColor3f (0.1, 0.9, 0.1);
+
+#ifdef DEBUG
+ printf( "HUD Code %d Status %d\n", hud->code, hud->status );
+#endif
+ hud_instr = hud->instruments;
+ while( hud_instr != NULL )
+ {
+ instr_data = hud_instr->instr;
+#ifdef DEBUG
+ printf("Instr Type %d SubType %d Orient %d\n", hud_instr->type, hud_instr->sub_type, hud_instr->orientation );
+#endif
+ if( hud_instr->type == ARTIFICIAL_HORIZON )
+ {
+ drawhorizon( instr_data.horizon );
+ /* drawhorizon( instr_data.horizon.x_pos, instr_data.horizon.y_pos, \
+ instr_data.horizon.scr_width, instr_data.horizon.scr_hole ); */
+ }
+ else if( hud_instr->type == SCALE )
+ {
+ drawscale( instr_data.scale.type, instr_data.scale.with_minimum, \
+ instr_data.scale.minimum_value, instr_data.scale.orientation, \
+ instr_data.scale.scr_pos, instr_data.scale.scr_min, \
+ instr_data.scale.scr_max, instr_data.scale.width_units, \
+ instr_data.scale.div_min, instr_data.scale.div_max, \
+ (*instr_data.scale.load_value)() );
+ }
+ else if( hud_instr->type == LABEL )
+ {
+ drawlabel( instr_data.label );
+ /* drawlabel( instr_data.label.x_pos, instr_data.label.y_pos, instr_data.label.size, \
+ instr_data.label.blink, instr_data.label.pre_str, instr_data.label.post_str, \
+ instr_data.label.format, (*instr_data.label.load_value)() ); */
+ }
+ else if( hud_instr->type == LADDER )
+ {
+ drawladder( instr_data.ladder );
+ }
+ hud_instr = hud_instr->next;
+ }
+
+
+ glEnable(GL_DEPTH_TEST);
+ glEnable(GL_LIGHTING);
+ glMatrixMode(GL_PROJECTION);
+ glPopMatrix();
+ glMatrixMode(GL_MODELVIEW);
+ glPopMatrix();
+
+}
+
+
+/* $Log$
+/* Revision 1.1 1997/08/29 18:03:22 curt
+/* Initial revision.
+/*
+ */
--- /dev/null
+/**************************************************************************
+ * joystick.h -- joystick support
+ *
+ * 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$
+ * (Log is kept at end of this file)
+ **************************************************************************/
+
+
+#ifdef HAVE_JOYSTICK
+
+#include <linux/joystick.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <unistd.h>
+
+#endif
+
+static joy_x_min=0, joy_x_ctr=0, joy_x_max=0;
+static joy_y_min=0, joy_y_ctr=0, joy_y_max=0;
+static joy_x_dead_min=1000, joy_x_dead_max=-1000;
+static joy_y_dead_min=1000, joy_y_dead_max=-1000;
+
+
+static int joystick_fd;
+
+int fgJoystickInit( int joy_num )
+{
+#ifdef HAVE_JOYSTICK
+ int status;
+ char *fname;
+ struct JS_DATA_TYPE js;
+ int button;
+
+ /* argument should be 0 or 1 */
+ if( joy_num != 1 && joy_num != 0 ) {
+ perror( "js" );
+ return( 1 );
+ }
+
+ /* pick appropriate device file */
+ if (joy_num == 0)
+ fname = "/dev/js0";
+ if (joy_num == 1)
+ fname = "/dev/js1";
+
+ /* open device file */
+ joystick_fd = open(fname, O_RDONLY);
+ if (joystick_fd < 0) {
+ perror ("js");
+ return( 1 );
+ }
+
+ printf( "\nMove joystick around dead spot and press any joystick button.\n" );
+ status = read(joystick_fd, &js, JS_RETURN);
+ if (status != JS_RETURN) {
+ perror("js");
+ return( 1 );
+ }
+ button = js.buttons & 1 || js.buttons & 2;
+ while(button == 0 ) {
+ status = read(joystick_fd, &js, JS_RETURN);
+ if (status != JS_RETURN) {
+ perror("js");
+ return( 1 );
+ }
+ button = js.buttons & 1 || js.buttons & 2;
+ if( js.x > joy_x_dead_max )
+ joy_x_dead_max = js.x;
+ if( js.x < joy_x_dead_min )
+ joy_x_dead_min = js.x;
+ if( js.y > joy_y_dead_max )
+ joy_y_dead_max = js.y;
+ if( js.y < joy_y_dead_min )
+ joy_y_dead_min = js.y;
+
+ // printf( "Xmin %d Xmax %d Ymin %d Ymax %d", joy_x_dead_min, joy_x_dead_max, \
+ // joy_y_dead_min, joy_y_dead_max );
+ }
+ status = read(joystick_fd, &js, JS_RETURN);
+ if (status != JS_RETURN) {
+ perror("js");
+ return( 1 );
+ }
+
+ printf("\nJoystick calibration: X_dead_min = %d, X_dead_max = %d\n", joy_x_dead_min, joy_x_dead_max );
+ printf(" Y_dead_min = %d, Y_dead_max = %d\n", joy_y_dead_min, joy_y_dead_max );
+
+ sleep( 1 );
+
+ printf( "\nCenter joystick and press any joystick button.\n" );
+ status = read(joystick_fd, &js, JS_RETURN);
+ if (status != JS_RETURN) {
+ perror("js");
+ return( 1 );
+ }
+ button = js.buttons & 1 || js.buttons & 2;
+ while(button == 0 ) {
+ status = read(joystick_fd, &js, JS_RETURN);
+ if (status != JS_RETURN) {
+ perror("js");
+ return( 1 );
+ }
+ button = js.buttons & 1 || js.buttons & 2;
+ }
+ status = read(joystick_fd, &js, JS_RETURN);
+ if (status != JS_RETURN) {
+ perror("js");
+ return( 1 );
+ }
+ joy_x_ctr = js.x;
+ joy_y_ctr = js.y;
+
+ printf("Joystick calibration: X_ctr = %d, Y_ctr = %d\n", joy_x_ctr, joy_y_ctr );
+
+ sleep( 1 );
+
+ printf( "\nMove joystick to upper left and press any joystick button.\n" );
+ status = read(joystick_fd, &js, JS_RETURN);
+ if (status != JS_RETURN) {
+ perror("js");
+ return( 1 );
+ }
+ button = js.buttons & 1 || js.buttons & 2;
+ while(button == 0 ) {
+ status = read(joystick_fd, &js, JS_RETURN);
+ if (status != JS_RETURN) {
+ perror("js");
+ return( 1 );
+ }
+ button = js.buttons & 1 || js.buttons & 2;
+ }
+ status = read(joystick_fd, &js, JS_RETURN);
+ if (status != JS_RETURN) {
+ perror("js");
+ return( 1 );
+ }
+ joy_x_min = js.x;
+ joy_y_min = js.y;
+ printf("Joystick calibration: X_min = %d, Y_min = %d\n", joy_x_min, joy_y_min );
+
+ sleep( 1 );
+
+ printf( "\nMove joystick to lower right and press any joystick button.\n" );
+ status = read(joystick_fd, &js, JS_RETURN);
+ if (status != JS_RETURN) {
+ perror("js");
+ return( 1 );
+ }
+ button = js.buttons & 1 || js.buttons & 2;
+ while(button == 0 ) {
+ status = read(joystick_fd, &js, JS_RETURN);
+ if (status != JS_RETURN) {
+ perror("js");
+ return( 1 );
+ }
+ button = js.buttons & 1 || js.buttons & 2;
+ }
+ status = read(joystick_fd, &js, JS_RETURN);
+ if (status != JS_RETURN) {
+ perror("js");
+ return( 1 );
+ }
+ joy_x_max = js.x;
+ joy_y_max = js.y;
+
+ printf("Joystick calibration: X_max = %d, Y_max = %d\n", joy_x_max, joy_y_max );
+
+ // joy_x_ctr = (joy_x_max-joy_x_min)/2;
+ // joy_y_ctr = (joy_y_max-joy_y_min)/2;
+ // printf("Joystick calibration: X_ctr = %d, Y_ctr = %d\n", joy_x_ctr, joy_y_ctr );
+
+ return( joystick_fd );
+#endif
+}
+
+/* void fgJoystickCalibrate( int joy_fd )
+{
+
+} */
+
+int fgJoystickRead( double *joy_x, double *joy_y, int *joy_b1, int *joy_b2 )
+{
+#ifdef HAVE_JOYSTICK
+ struct JS_DATA_TYPE js;
+ int status;
+
+ status = read(joystick_fd, &js, JS_RETURN);
+ if (status != JS_RETURN) {
+ perror("js");
+ return( 1 );
+ }
+
+ /* printf("\n button 0: %s button 1: %s X position: %4d Y position: %4d\n",
+ (js.buttons & 1) ? "on " : "off",
+ (js.buttons & 2) ? "on " : "off",
+ js.x,
+ js.y ); */
+
+ if( js.x >= joy_x_dead_min && js.x <= joy_x_dead_max )
+ *joy_x = 0.5;
+ else
+ *joy_x = (double)js.x/(double)(joy_x_max-joy_x_min);
+ *joy_x = *joy_x*2-1;
+
+ if( js.y >= joy_y_dead_min && js.y <= joy_y_dead_max )
+ *joy_y = 0.5;
+ else
+ *joy_y = (double)js.y/(double)(joy_y_max-joy_y_min);
+ *joy_y = *joy_y*2-1;
+
+ *joy_b1 = js.buttons & 1;
+ *joy_b2 = js.buttons & 2;
+
+ return( 0 );
+#endif
+}
+
+
+/* $Log$
+/* Revision 1.1 1997/08/29 18:06:54 curt
+/* Initial revision.
+/*
+ */
projects / flightgear.git / commitdiff