fly/flightgear
1
0
Fork 0
Code Activity

Restructured view calculation code. Added stars.

Browse source
This commit is contained in:
curt 1997-08-27 21:32:23 +00:00
parent 27adc6d5d0
commit 7c5f7fdc85
8 changed files with 137 additions and 148 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

49
Main/GLUTkey.c
View file

@ -24,31 +24,33 @@
**************************************************************************/
#include <stdio.h>
#ifdef WIN32
# include <windows.h>
#endif
#include <GL/glut.h>
#include <stdio.h>
#include "GLUTkey.h"
#include "views.h"
#include "../constants.h"
#include "../Aircraft/aircraft.h"
#include "../Weather/weather.h"
extern double goal_view_offset;
extern int show_hud; /* HUD state */
/* Handle keyboard events */
void GLUTkey(unsigned char k, int x, int y) {
struct CONTROLS *c;
struct VIEW *v;
struct WEATHER *w;
c = &current_aircraft.controls;
v = &current_view;
w = &current_weather;
printf("Key hit = %d", k);
@ -57,28 +59,28 @@ void GLUTkey(unsigned char k, int x, int y) {
printf(" SHIFTED\n");
switch (k) {
case 49: /* numeric keypad 1 */
goal_view_offset = FG_PI * 0.75;
v->goal_view_offset = FG_PI * 0.75;
return;
case 50: /* numeric keypad 2 */
goal_view_offset = FG_PI;
v->goal_view_offset = FG_PI;
return;
case 51: /* numeric keypad 3 */
goal_view_offset = FG_PI * 1.25;
v->goal_view_offset = FG_PI * 1.25;
return;
case 52: /* numeric keypad 4 */
goal_view_offset = FG_PI * 0.50;
v->goal_view_offset = FG_PI * 0.50;
return;
case 54: /* numeric keypad 6 */
goal_view_offset = FG_PI * 1.50;
v->goal_view_offset = FG_PI * 1.50;
return;
case 55: /* numeric keypad 7 */
goal_view_offset = FG_PI * 0.25;
v->goal_view_offset = FG_PI * 0.25;
return;
case 56: /* numeric keypad 8 */
goal_view_offset = 0.00;
v->goal_view_offset = 0.00;
return;
case 57: /* numeric keypad 9 */
goal_view_offset = FG_PI * 1.75;
v->goal_view_offset = FG_PI * 1.75;
return;
case 72: /* H key */
show_hud = !show_hud;
@ -143,8 +145,10 @@ void GLUTkey(unsigned char k, int x, int y) {
/* Handle "special" keyboard events */
void GLUTspecialkey(int k, int x, int y) {
struct CONTROLS *c;
struct VIEW *v;
c = &current_aircraft.controls;
v = &current_view;
printf("Special key hit = %d", k);
@ -152,28 +156,28 @@ void GLUTspecialkey(int k, int x, int y) {
printf(" SHIFTED\n");
switch (k) {
case GLUT_KEY_END: /* numeric keypad 1 */
goal_view_offset = FG_PI * 0.75;
v->goal_view_offset = FG_PI * 0.75;
return;
case GLUT_KEY_DOWN: /* numeric keypad 2 */
goal_view_offset = FG_PI;
v->goal_view_offset = FG_PI;
return;
case GLUT_KEY_PAGE_DOWN: /* numeric keypad 3 */
goal_view_offset = FG_PI * 1.25;
v->goal_view_offset = FG_PI * 1.25;
return;
case GLUT_KEY_LEFT: /* numeric keypad 4 */
goal_view_offset = FG_PI * 0.50;
v->goal_view_offset = FG_PI * 0.50;
return;
case GLUT_KEY_RIGHT: /* numeric keypad 6 */
goal_view_offset = FG_PI * 1.50;
v->goal_view_offset = FG_PI * 1.50;
return;
case GLUT_KEY_HOME: /* numeric keypad 7 */
goal_view_offset = FG_PI * 0.25;
v->goal_view_offset = FG_PI * 0.25;
return;
case GLUT_KEY_UP: /* numeric keypad 8 */
goal_view_offset = 0.00;
v->goal_view_offset = 0.00;
return;
case GLUT_KEY_PAGE_UP: /* numeric keypad 9 */
goal_view_offset = FG_PI * 1.75;
v->goal_view_offset = FG_PI * 1.75;
return;
}
} else {
@ -220,9 +224,12 @@ void GLUTspecialkey(int k, int x, int y) {
/* $Log$
/* Revision 1.20 1997/08/27 03:30:13 curt
/* Changed naming scheme of basic shared structures.
/* Revision 1.21 1997/08/27 21:32:23 curt
/* Restructured view calculation code. Added stars.
/*
* Revision 1.20 1997/08/27 03:30:13 curt
* Changed naming scheme of basic shared structures.
*
* Revision 1.19 1997/08/25 20:27:21 curt
* Merged in initial HUD and Joystick code.
*

151
Main/GLUTmain.c
View file

@ -24,18 +24,16 @@
**************************************************************************/
#include <stdio.h>
#ifdef WIN32
# include <windows.h>
#endif
#ifdef GLUT
#include <GL/glut.h>
#include "GLUTkey.h"
#endif
#include <GL/glut.h>
#include <stdio.h>
#include "GLUTkey.h"
#include "fg_init.h"
#include "views.h"
#include "../constants.h"
#include "../general.h"
@ -64,6 +62,9 @@ struct GENERAL general;
/* This is a record containing current weather info */
struct WEATHER current_weather;
/* This is a record containing current view parameters */
struct VIEW current_view;
/* view parameters */
static GLfloat win_ratio = 1.0;
@ -86,8 +87,8 @@ static GLfloat fgFogColor[4] = {0.65, 0.65, 0.85, 1.0};
/* static GLint scenery, runway; */
/* Another hack */
double view_offset = 0.0;
double goal_view_offset = 0.0;
/* double view_offset = 0.0;
double goal_view_offset = 0.0; */
double Simtime;
@ -139,17 +140,19 @@ static void fgInitVisuals() {
**************************************************************************/
static void fgUpdateViewParams() {
struct fgCartesianPoint view_pos /*, alt_up */;
struct FLIGHT *f;
struct fgTIME *t;
MAT3mat R, TMP, UP, LOCAL, VIEW;
MAT3vec vec, view_up, forward, view_forward, local_up, nup, nsun;
struct VIEW *v;
MAT3vec nup, nsun;
double sun_angle, temp, ambient, diffuse, sky;
GLfloat color[4] = { 1.0, 1.0, 0.50, 1.0 };
GLfloat amb[3], diff[3], fog[4], clear[4];
f = &current_aircraft.flight;
t = &cur_time_params;
v = &current_view;
fgViewUpdate(f, v);
/* Tell GL we are about to modify the projection parameters */
glMatrixMode(GL_PROJECTION);
@ -159,96 +162,19 @@ static void fgUpdateViewParams() {
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
/* calculate view position in current FG view coordinate system */
view_pos = fgPolarToCart(FG_Longitude, FG_Lat_geocentric,
FG_Radius_to_vehicle * FEET_TO_METER + 1.0);
view_pos.x -= scenery.center.x;
view_pos.y -= scenery.center.y;
view_pos.z -= scenery.center.z;
printf("View pos = %.4f, %.4f, %.4f\n", view_pos.x, view_pos.y, view_pos.z);
/* Derive the LOCAL aircraft rotation matrix (roll, pitch, yaw) */
MAT3_SET_VEC(vec, 0.0, 0.0, 1.0);
MAT3rotate(R, vec, FG_Phi);
/* printf("Roll matrix\n"); */
/* MAT3print(R, stdout); */
MAT3_SET_VEC(vec, 0.0, 1.0, 0.0);
/* MAT3mult_vec(vec, vec, R); */
MAT3rotate(TMP, vec, FG_Theta);
/* printf("Pitch matrix\n"); */
/* MAT3print(TMP, stdout); */
MAT3mult(R, R, TMP);
MAT3_SET_VEC(vec, 1.0, 0.0, 0.0);
/* MAT3mult_vec(vec, vec, R); */
/* MAT3rotate(TMP, vec, FG_Psi - FG_PI_2); */
MAT3rotate(TMP, vec, -FG_Psi);
/* printf("Yaw matrix\n");
MAT3print(TMP, stdout); */
MAT3mult(LOCAL, R, TMP);
/* printf("LOCAL matrix\n"); */
/* MAT3print(LOCAL, stdout); */
/* Derive the local UP transformation matrix based on *geodetic*
* coordinates */
MAT3_SET_VEC(vec, 0.0, 0.0, 1.0);
MAT3rotate(R, vec, FG_Longitude); /* R = rotate about Z axis */
/* printf("Longitude matrix\n"); */
/* MAT3print(R, stdout); */
MAT3_SET_VEC(vec, 0.0, 1.0, 0.0);
MAT3mult_vec(vec, vec, R);
MAT3rotate(TMP, vec, -FG_Latitude); /* TMP = rotate about X axis */
/* printf("Latitude matrix\n"); */
/* MAT3print(TMP, stdout); */
MAT3mult(UP, R, TMP);
/* printf("Local up matrix\n"); */
/* MAT3print(UP, stdout); */
MAT3_SET_VEC(local_up, 1.0, 0.0, 0.0);
MAT3mult_vec(local_up, local_up, UP);
printf(" Local Up = (%.4f, %.4f, %.4f)\n", local_up[0], local_up[1],
local_up[2]);
/* Alternative method to Derive local up vector based on
* *geodetic* coordinates */
/* alt_up = fgPolarToCart(FG_Longitude, FG_Latitude, 1.0); */
/* printf(" Alt Up = (%.4f, %.4f, %.4f)\n",
alt_up.x, alt_up.y, alt_up.z); */
/* Derive the VIEW matrix */
MAT3mult(VIEW, LOCAL, UP);
/* printf("VIEW matrix\n"); */
/* MAT3print(VIEW, stdout); */
/* generate the current up, forward, and fwrd-view vectors */
MAT3_SET_VEC(vec, 1.0, 0.0, 0.0);
MAT3mult_vec(view_up, vec, VIEW);
MAT3_SET_VEC(vec, 0.0, 0.0, 1.0);
MAT3mult_vec(forward, vec, VIEW);
printf("Forward vector is (%.2f,%.2f,%.2f)\n", forward[0], forward[1],
forward[2]);
MAT3rotate(TMP, view_up, view_offset);
MAT3mult_vec(view_forward, forward, TMP);
/* set up our view volume */
gluLookAt(view_pos.x, view_pos.y, view_pos.z,
view_pos.x + view_forward[0], view_pos.y + view_forward[1],
view_pos.z + view_forward[2],
view_up[0], view_up[1], view_up[2]);
gluLookAt(v->view_pos.x, v->view_pos.y, v->view_pos.z,
v->view_pos.x + v->view_forward[0],
v->view_pos.y + v->view_forward[1],
v->view_pos.z + v->view_forward[2],
v->view_up[0], v->view_up[1], v->view_up[2]);
/* set the sun position */
glLightfv( GL_LIGHT0, GL_POSITION, sun_vec );
/* calculate lighting parameters based on sun's relative angle to
* local up */
MAT3_COPY_VEC(nup, local_up);
MAT3_COPY_VEC(nup, v->local_up);
nsun[0] = t->fg_sunpos.x;
nsun[1] = t->fg_sunpos.y;
nsun[2] = t->fg_sunpos.z;
@ -332,10 +258,12 @@ static void fgUpdateVisuals( void ) {
void fgUpdateTimeDepCalcs(int multi_loop) {
struct FLIGHT *f;
struct fgTIME *t;
struct VIEW *v;
int i;
f = &current_aircraft.flight;
t = &cur_time_params;
v = &current_view;
/* update the flight model */
if ( multi_loop < 0 ) {
@ -357,28 +285,28 @@ void fgUpdateTimeDepCalcs(int multi_loop) {
/* update the view angle */
for ( i = 0; i < multi_loop; i++ ) {
if ( fabs(goal_view_offset - view_offset) < 0.05 ) {
view_offset = goal_view_offset;
if ( fabs(v->goal_view_offset - v->view_offset) < 0.05 ) {
v->view_offset = v->goal_view_offset;
break;
} else {
/* move view_offset towards goal_view_offset */
if ( goal_view_offset > view_offset ) {
if ( goal_view_offset - view_offset < FG_PI ) {
view_offset += 0.01;
/* move v->view_offset towards v->goal_view_offset */
if ( v->goal_view_offset > v->view_offset ) {
if ( v->goal_view_offset - v->view_offset < FG_PI ) {
v->view_offset += 0.01;
} else {
view_offset -= 0.01;
v->view_offset -= 0.01;
}
} else {
if ( view_offset - goal_view_offset < FG_PI ) {
view_offset -= 0.01;
if ( v->view_offset - v->goal_view_offset < FG_PI ) {
v->view_offset -= 0.01;
} else {
view_offset += 0.01;
v->view_offset += 0.01;
}
}
if ( view_offset > FG_2PI ) {
view_offset -= FG_2PI;
} else if ( view_offset < 0 ) {
view_offset += FG_2PI;
if ( v->view_offset > FG_2PI ) {
v->view_offset -= FG_2PI;
} else if ( v->view_offset < 0 ) {
v->view_offset += FG_2PI;
}
}
}
@ -646,9 +574,12 @@ int main( int argc, char *argv[] ) {
/* $Log$
/* Revision 1.11 1997/08/27 03:30:16 curt
/* Changed naming scheme of basic shared structures.
/* Revision 1.12 1997/08/27 21:32:24 curt
/* Restructured view calculation code. Added stars.
/*
* Revision 1.11 1997/08/27 03:30:16 curt
* Changed naming scheme of basic shared structures.
*
* Revision 1.10 1997/08/25 20:27:22 curt
* Merged in initial HUD and Joystick code.
*

5
Main/depend
View file

@ -28,5 +28,6 @@ fg_init.o: fg_init.c fg_init.h ../constants.h ../general.h \
../Cockpit/hud.h ../Cockpit/../Aircraft/aircraft.h \
../Cockpit/../Flight/flight.h ../Cockpit/../Controls/controls.h \
../Joystick/joystick.h ../Math/fg_random.h ../Scenery/mesh.h \
../Scenery/scenery.h ../Scenery/../types.h ../Time/sunpos.h \
../Weather/weather.h
../Scenery/scenery.h ../Scenery/../types.h ../Scenery/stars.h \
../Time/sunpos.h ../Weather/weather.h
views.o: views.c views.h ../types.h

14
Main/fg_init.c
View file

@ -28,6 +28,7 @@
#include <stdlib.h>
#include "fg_init.h"
#include "views.h"
#include "../constants.h"
#include "../general.h"
@ -74,8 +75,11 @@ void fgInitSubsystems( void ) {
double cur_elev;
struct FLIGHT *f;
struct VIEW *v;
f = &current_aircraft.flight;
v = &current_view;
/****************************************************************
* The following section sets up the flight model EOM parameters and
@ -140,6 +144,9 @@ void fgInitSubsystems( void ) {
/* Initialize shared sun position and sun_vec */
fgUpdateSunPos();
/* Initialize view parameters */
fgViewInit(v);
/* Initialize the weather modeling subsystem */
fgWeatherInit();
@ -188,9 +195,12 @@ void fgInitSubsystems( void ) {
/* $Log$
/* Revision 1.3 1997/08/27 03:30:19 curt
/* Changed naming scheme of basic shared structures.
/* Revision 1.4 1997/08/27 21:32:26 curt
/* Restructured view calculation code. Added stars.
/*
* Revision 1.3 1997/08/27 03:30:19 curt
* Changed naming scheme of basic shared structures.
*
* Revision 1.2 1997/08/25 20:27:23 curt
* Merged in initial HUD and Joystick code.
*

1
Scenery/depend
View file

@ -8,3 +8,4 @@ parser.o: parser.c parsevrml.h geometry.h common.h mesh.h scenery.h \
../types.h
scanner.o: scanner.c parser.h
scenery.o: scenery.c ../general.h scenery.h ../types.h parsevrml.h
stars.o: stars.c stars.h ../general.h

12
Scenery/scenery.c
View file

@ -36,6 +36,7 @@
#include "scenery.h"
#include "parsevrml.h"
#include "stars.h"
/* Temporary hack until we get the scenery management system running */
@ -49,7 +50,7 @@ struct SCENERY scenery;
/* Initialize the Scenery Management system */
void fgSceneryInit() {
/* set the default terrain detail level */
scenery.terrain_skip = 4;
scenery.terrain_skip = 2;
}
@ -81,13 +82,18 @@ void fgSceneryRender() {
glPushMatrix();
glCallList(mesh_hack);
glPopMatrix();
fgStarsRender();
}
/* $Log$
/* Revision 1.15 1997/08/27 03:30:32 curt
/* Changed naming scheme of basic shared structures.
/* Revision 1.16 1997/08/27 21:32:29 curt
/* Restructured view calculation code. Added stars.
/*
* Revision 1.15 1997/08/27 03:30:32 curt
* Changed naming scheme of basic shared structures.
*
* Revision 1.14 1997/08/25 20:27:24 curt
* Merged in initial HUD and Joystick code.
*

44
Scenery/stars.c
View file

@ -38,19 +38,21 @@
#include "../general.h"
#include "../GLUT/views.h"
/* static struct STAR stars[FG_MAX_STARS]; */
static GLint stars;
/* Initialize the Star Management Subsystem */
void fgStarsInit() {
FILE *fd;
struct general_params *g;
struct GENERAL *g;
char path[1024];
char line[256], name[256];
char *tmp_ptr;
double right_ascension, declination, magnitude;
GLfloat mag[4] = {0.0, 0.0, 0.0, 1.0};
int count;
g = &general;
@ -93,10 +95,12 @@ void fgStarsInit() {
/* printf("Found star: %d %s, %.3f %.3f %.3f\n", count,
name, right_ascension, declination, magnitude); */
count++;
magnitude = magnitude * 0.8 + 0.2;
mag[0] = mag[1] = mag[2] = magnitude;
glColor3f( magnitude, magnitude, magnitude );
glVertex3f( 100.0 * sin(right_ascension) * cos(declination),
100.0 * cos(right_ascension) * cos(declination),
100.0 * sin(declination) );
glVertex3f( 190000.0 * sin(right_ascension) * cos(declination),
190000.0 * cos(right_ascension) * cos(declination),
190000.0 * sin(declination) );
} /* if valid line */
@ -109,12 +113,38 @@ void fgStarsInit() {
/* Draw the Stars */
void fgStarsRender() {
struct VIEW *v;
GLfloat amb[3], diff[3];
v = &current_view;
printf("RENDERING STARS\n");
glDisable( GL_FOG );
glDisable( GL_LIGHTING );
glPushMatrix();
/* set lighting parameters for stars */
/* amb[0] = amb[1] = amb[2] = 1.0;
diff[0] = diff[1] = diff[2] = 1.0;
glLightfv(GL_LIGHT0, GL_AMBIENT, amb );
glLightfv(GL_LIGHT0, GL_DIFFUSE, diff ); */
glTranslatef(v->view_pos.x, v->view_pos.y, v->view_pos.z);
glCallList(stars);
glPopMatrix();
glEnable( GL_LIGHTING );
glEnable( GL_FOG );
}
/* $Log$
/* Revision 1.1 1997/08/27 03:34:48 curt
/* Initial revisio.
/* Revision 1.2 1997/08/27 21:32:30 curt
/* Restructured view calculation code. Added stars.
/*
* Revision 1.1 1997/08/27 03:34:48 curt
* Initial revisio.
*
*/

9
Scenery/stars.h
View file

@ -28,7 +28,7 @@
#define STARS_H
#define FG_MAX_STARS 100
#define FG_MAX_STARS 1000
/* Define a structure containing star information */
@ -50,7 +50,10 @@ void fgStarsRender();
/* $Log$
/* Revision 1.1 1997/08/27 03:34:50 curt
/* Initial revisio.
/* Revision 1.2 1997/08/27 21:32:30 curt
/* Restructured view calculation code. Added stars.
/*
* Revision 1.1 1997/08/27 03:34:50 curt
* Initial revisio.
*
*/