members private and make required accessor functions.
void fgSkyRender( void ) {
FGState *f;
fgLIGHT *l;
- fgVIEW *v;
float inner_color[4];
float middle_color[4];
float outer_color[4];
f = current_aircraft.fdm_state;
l = &cur_light_params;
- v = ¤t_view;
// printf("Rendering the sky.\n");
xglPushMatrix();
// Translate to view position
- xglTranslatef( v->cur_zero_elev.x(),
- v->cur_zero_elev.y(),
- v->cur_zero_elev.z() );
+ Point3D zero_elev = current_view.get_cur_zero_elev();
+ xglTranslatef( zero_elev.x(), zero_elev.y(), zero_elev.z() );
// printf(" Translated to %.2f %.2f %.2f\n",
- // v->cur_zero_elev.x, v->cur_zero_elev.y, v->cur_zero_elev.z );
+ // zero_elev.x, zero_elev.y, zero_elev.z );
// Rotate to proper orientation
// printf(" lon = %.2f lat = %.2f\n", FG_Longitude * RAD_TO_DEG,
// $Log$
+// Revision 1.17 1998/12/09 18:50:12 curt
+// Converted "class fgVIEW" to "class FGView" and updated to make data
+// members private and make required accessor functions.
+//
// Revision 1.16 1998/12/05 15:54:03 curt
// Renamed class fgFLIGHT to class FGState as per request by JSB.
//
#include "pluto.hxx"
-extern fgLIGHT cur_light_params;
-extern fgTIME cur_time_params;
-extern fgVIEW current_view;
-
-
-
class SolarSystem
{
private:
// Draw the Stars
void fgStarsRender( void ) {
FGState *f;
- fgVIEW *v;
fgLIGHT *l;
fgTIME *t;
int i;
f = current_aircraft.fdm_state;
l = &cur_light_params;
t = &cur_time_params;
- v = ¤t_view;
// FG_PI_2 + 0.1 is about 6 degrees after sundown and before sunrise
// $Log$
+// Revision 1.25 1998/12/09 18:50:15 curt
+// Converted "class fgVIEW" to "class FGView" and updated to make data
+// members private and make required accessor functions.
+//
// Revision 1.24 1998/12/05 15:54:04 curt
// Renamed class fgFLIGHT to class FGState as per request by JSB.
//
double get_frame_rate( void )
{
- fgGENERAL *pgeneral;
-
- pgeneral = &general;
-
- return pgeneral->frame_rate;
+ return general.frame_rate;
}
double get_fov( void )
double get_vfc_ratio( void )
{
- fgVIEW *pview;
-
- pview = ¤t_view;
-
- return pview->vfc_ratio;
+ return current_view.get_vfc_ratio();
}
double get_vfc_tris_drawn ( void )
{
- return current_view.tris_rendered;
+ return current_view.get_tris_rendered();
}
double get_climb_rate( void )
void fgCockpitUpdate( void ) {
- fgVIEW *pview;
-
- pview = ¤t_view;
-
FG_LOG( FG_COCKPIT, FG_DEBUG,
"Cockpit: code " << ac_cockpit->code() << " status "
<< ac_cockpit->status() );
}
if ( current_options.get_panel_status() &&
- (fabs(pview->view_offset) < 0.2) ) {
- xglViewport(0, 0, pview->winWidth, pview->winHeight);
+ (fabs( current_view.get_view_offset() ) < 0.2) )
+ {
+ xglViewport( 0, 0,
+ current_view.get_winWidth(),
+ current_view.get_winHeight() );
fgPanelUpdate();
}
}
// $Log$
+// Revision 1.26 1998/12/09 18:50:19 curt
+// Converted "class fgVIEW" to "class FGView" and updated to make data
+// members private and make required accessor functions.
+//
// Revision 1.25 1998/12/05 15:54:07 curt
// Renamed class fgFLIGHT to class FGState as per request by JSB.
//
// Beginning of the "panel-code"
void fgPanelInit ( void ) {
- fgVIEW *v;
string tpath;
int x, y;
- v = ¤t_view;
-
- Xzoom = (float)((float)(current_view.winWidth)/1024);
- Yzoom = (float)((float)(current_view.winHeight)/768);
+ Xzoom = (float)((float)(current_view.get_winWidth())/1024.0);
+ Yzoom = (float)((float)(current_view.get_winHeight())/768.0);
pointer[1].XPos = 357;
pointer[1].YPos = 167;
}
void fgPanelReInit( int x, int y, int finx, int finy){
- fgVIEW *v;
fgOPTIONS *o;
int i;
o = ¤t_options;
- v = ¤t_view;
- Xzoom = (float)((float)(current_view.winWidth)/1024);
- Yzoom = (float)((float)(current_view.winHeight)/768);
+ Xzoom = (float)((float)(current_view.get_winWidth())/1024);
+ Yzoom = (float)((float)(current_view.get_winHeight())/768);
xglMatrixMode(GL_PROJECTION);
xglPushMatrix();
}
void fgPanelUpdate ( void ) {
- fgVIEW *v;
float alpha;
double pitch;
double roll;
var[1] = get_altitude();
var[2] = get_aoa(); // A placeholder. It should be the vertical speed once.
var[3] = get_throttleval();
- v = ¤t_view;
xglMatrixMode(GL_PROJECTION);
xglPushMatrix();
xglLoadIdentity();
}
// $Log$
+// Revision 1.12 1998/12/09 18:50:20 curt
+// Converted "class fgVIEW" to "class FGView" and updated to make data
+// members private and make required accessor functions.
+//
// Revision 1.11 1998/11/11 00:19:27 curt
// Updated comment delimeter to C++ style.
//
void GLUTkey(unsigned char k, int x, int y) {
FGState *f;
fgTIME *t;
- fgVIEW *v;
+ FGView *v;
FGWeather *w;
float fov, tmp;
static bool winding_ccw = true;
fgAPToggleTerrainFollow();
return;
case 49: // numeric keypad 1
- v->goal_view_offset = FG_PI * 0.75;
+ v->set_goal_view_offset( FG_PI * 0.75 );
return;
case 50: // numeric keypad 2
- v->goal_view_offset = FG_PI;
+ v->set_goal_view_offset( FG_PI );
return;
case 51: // numeric keypad 3
- v->goal_view_offset = FG_PI * 1.25;
+ v->set_goal_view_offset( FG_PI * 1.25 );
return;
case 52: // numeric keypad 4
- v->goal_view_offset = FG_PI * 0.50;
+ v->set_goal_view_offset( FG_PI * 0.50 );
return;
case 54: // numeric keypad 6
- v->goal_view_offset = FG_PI * 1.50;
+ v->set_goal_view_offset( FG_PI * 1.50 );
return;
case 55: // numeric keypad 7
- v->goal_view_offset = FG_PI * 0.25;
+ v->set_goal_view_offset( FG_PI * 0.25 );
return;
case 56: // numeric keypad 8
- v->goal_view_offset = 0.00;
+ v->set_goal_view_offset( 0.00 );
return;
case 57: // numeric keypad 9
- v->goal_view_offset = FG_PI * 1.75;
+ v->set_goal_view_offset( FG_PI * 1.75 );
return;
case 72: // H key
// status = current_options.get_hud_status();
fov = FG_FOV_MAX;
}
current_options.set_fov(fov);
- v->update_fov = TRUE;
+ v->set_update_fov( true );
return;
case 90: // Z key
tmp = w->get_visibility(); // in meters
fov = FG_FOV_MIN;
}
current_options.set_fov(fov);
- v->update_fov = TRUE;
+ v->set_update_fov( true );
return;
case 122: // z key
tmp = w->get_visibility(); // in meters
// Handle "special" keyboard events
void GLUTspecialkey(int k, int x, int y) {
- fgVIEW *v;
+ FGView *v;
v = ¤t_view;
FG_LOG( FG_INPUT, FG_DEBUG, " SHIFTED" );
switch (k) {
case GLUT_KEY_END: // numeric keypad 1
- v->goal_view_offset = FG_PI * 0.75;
+ v->set_goal_view_offset( FG_PI * 0.75 );
return;
case GLUT_KEY_DOWN: // numeric keypad 2
- v->goal_view_offset = FG_PI;
+ v->set_goal_view_offset( FG_PI );
return;
case GLUT_KEY_PAGE_DOWN: // numeric keypad 3
- v->goal_view_offset = FG_PI * 1.25;
+ v->set_goal_view_offset( FG_PI * 1.25 );
return;
case GLUT_KEY_LEFT: // numeric keypad 4
- v->goal_view_offset = FG_PI * 0.50;
+ v->set_goal_view_offset( FG_PI * 0.50 );
return;
case GLUT_KEY_RIGHT: // numeric keypad 6
- v->goal_view_offset = FG_PI * 1.50;
+ v->set_goal_view_offset( FG_PI * 1.50 );
return;
case GLUT_KEY_HOME: // numeric keypad 7
- v->goal_view_offset = FG_PI * 0.25;
+ v->set_goal_view_offset( FG_PI * 0.25 );
return;
case GLUT_KEY_UP: // numeric keypad 8
- v->goal_view_offset = 0.00;
+ v->set_goal_view_offset( 0.00 );
return;
case GLUT_KEY_PAGE_UP: // numeric keypad 9
- v->goal_view_offset = FG_PI * 1.75;
+ v->set_goal_view_offset( FG_PI * 1.75 );
return;
}
} else {
// $Log$
+// Revision 1.37 1998/12/09 18:50:22 curt
+// Converted "class fgVIEW" to "class FGView" and updated to make data
+// members private and make required accessor functions.
+//
// Revision 1.36 1998/12/06 13:51:20 curt
// Turned "struct fgWEATHER" into "class FGWeather".
//
exit(0);
- fgVIEW *v;
-
- v = ¤t_view;
+ fgVIEW *v = ¤t_view;
xglViewport(0, 0 , (GLint)(v->winWidth), (GLint)(v->winHeight) / 2);
// Update all Visuals (redraws anything graphics related)
static void fgRenderFrame( void ) {
- FGState *f;
- fgLIGHT *l;
- fgTIME *t;
- fgVIEW *v;
+ FGState *f = current_aircraft.fdm_state;
+ fgLIGHT *l = &cur_light_params;
+ fgTIME *t = &cur_time_params;
+ FGView *v = ¤t_view;
+
double angle;
static int iteration = 0;
// GLfloat black[4] = { 0.0, 0.0, 0.0, 1.0 };
GLfloat terrain_color[4] = { 0.54, 0.44, 0.29, 1.0 };
GLbitfield clear_mask;
- f = current_aircraft.fdm_state;
- l = &cur_light_params;
- t = &cur_time_params;
- v = ¤t_view;
-
if ( idle_state != 1000 ) {
// still initializing, draw the splash screen
if ( current_options.get_splash_screen() == 1 ) {
// setup transformation for drawing astronomical objects
xglPushMatrix();
// Translate to view position
- xglTranslatef( v->view_pos.x(), v->view_pos.y(), v->view_pos.z() );
+ Point3D view_pos = v->get_view_pos();
+ xglTranslatef( view_pos.x(), view_pos.y(), view_pos.z() );
// Rotate based on gst (sidereal time)
// note: constant should be 15.041085, Curt thought it was 15
angle = t->gst * 15.041085;
fgTileMgrRender();
xglDisable( GL_TEXTURE_2D );
+ xglDisable( GL_FOG );
if ( (iteration == 0) && (current_options.get_panel_status()) ) {
// Did we run this loop before ?? ...and do we need the panel ??
xglBlendFunc ( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ) ;
puDisplay();
xglDisable ( GL_BLEND ) ;
+ xglEnable( GL_FOG );
}
xglutSwapBuffers();
// Update internal time dependent calculations (i.e. flight model)
void fgUpdateTimeDepCalcs(int multi_loop) {
- FGState *f;
- fgLIGHT *l;
- fgTIME *t;
- fgVIEW *v;
+ FGState *f = current_aircraft.fdm_state;
+ fgLIGHT *l = &cur_light_params;
+ fgTIME *t = &cur_time_params;
+ FGView *v = ¤t_view;
int i;
- f = current_aircraft.fdm_state;
- l = &cur_light_params;
- t = &cur_time_params;
- v = ¤t_view;
-
// update the flight model
if ( multi_loop < 0 ) {
multi_loop = DEFAULT_MULTILOOP;
// update the view angle
for ( i = 0; i < multi_loop; i++ ) {
- if ( fabs(v->goal_view_offset - v->view_offset) < 0.05 ) {
- v->view_offset = v->goal_view_offset;
+ if ( fabs(v->get_goal_view_offset() - v->get_view_offset()) < 0.05 ) {
+ v->set_view_offset( v->get_goal_view_offset() );
break;
} else {
// 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;
+ if ( v->get_goal_view_offset() > v->get_view_offset() ) {
+ if ( v->get_goal_view_offset() - v->get_view_offset() < FG_PI ){
+ v->inc_view_offset( 0.01 );
} else {
- v->view_offset -= 0.01;
+ v->inc_view_offset( -0.01 );
}
} else {
- if ( v->view_offset - v->goal_view_offset < FG_PI ) {
- v->view_offset -= 0.01;
+ if ( v->get_view_offset() - v->get_goal_view_offset() < FG_PI ){
+ v->inc_view_offset( -0.01 );
} else {
- v->view_offset += 0.01;
+ v->inc_view_offset( 0.01 );
}
}
- if ( v->view_offset > FG_2PI ) {
- v->view_offset -= FG_2PI;
- } else if ( v->view_offset < 0 ) {
- v->view_offset += FG_2PI;
+ if ( v->get_view_offset() > FG_2PI ) {
+ v->inc_view_offset( -FG_2PI );
+ } else if ( v->get_view_offset() < 0 ) {
+ v->inc_view_offset( FG_2PI );
}
}
}
- double tmp = -(l->sun_rotation + FG_PI) - (f->get_Psi() - v->view_offset);
+ double tmp = -(l->sun_rotation + FG_PI)
+ - (f->get_Psi() - v->get_view_offset() );
while ( tmp < 0.0 ) {
tmp += FG_2PI;
}
// Handle new window size or exposure
static void fgReshape( int width, int height ) {
- fgVIEW *v;
-
- v = ¤t_view;
+ FGView *v = ¤t_view;
// Do this so we can call fgReshape(0,0) ourselves without having
// to know what the values of width & height are.
if ( (height > 0) && (width > 0) ) {
if ( ! current_options.get_panel_status() ) {
- v->win_ratio = (GLfloat) width / (GLfloat) height;
+ v->set_win_ratio( (GLfloat) width / (GLfloat) height );
} else {
- v->win_ratio = (GLfloat) width / ((GLfloat) (height)*0.4232);
+ v->set_win_ratio( (GLfloat) width / ((GLfloat) (height)*0.4232) );
}
}
- v->winWidth = width;
- v->winHeight = height;
- v->update_fov = true;
+ v->set_winWidth( width );
+ v->set_winHeight( height );
+ v->set_update_fov( true );
// Inform gl of our view window size (now handled elsewhere)
// xglViewport(0, 0, (GLint)width, (GLint)height);
// $Log$
+// Revision 1.75 1998/12/09 18:50:23 curt
+// Converted "class fgVIEW" to "class FGView" and updated to make data
+// members private and make required accessor functions.
+//
// Revision 1.74 1998/12/06 14:52:54 curt
// Fixed a problem with the initial starting altitude. "v->abs_view_pos" wasn't
// being calculated correctly at the beginning causing the first terrain
// Returns non-zero if a problem encountered.
int fgInitSubsystems( void )
{
- FGState *f;
- fgLIGHT *l;
- fgTIME *t;
- fgVIEW *v;
+ FGState *f; // assigned later
+ fgLIGHT *l = &cur_light_params;
+ fgTIME *t = &cur_time_params;
+ FGView *v = ¤t_view;
Point3D geod_pos, tmp_abs_view_pos;
- l = &cur_light_params;
- t = &cur_time_params;
- v = ¤t_view;
-
FG_LOG( FG_GENERAL, FG_INFO, "Initialize Subsystems");
FG_LOG( FG_GENERAL, FG_INFO, "========== ==========");
v->Init();
FG_LOG( FG_GENERAL, FG_DEBUG, "After v->init()");
v->UpdateViewMath(f);
- FG_LOG( FG_GENERAL, FG_DEBUG, " abs_view_pos = " << v->abs_view_pos );
+ FG_LOG( FG_GENERAL, FG_DEBUG, " abs_view_pos = " << v->get_abs_view_pos());
v->UpdateWorldToEye(f);
// Build the solar system
// $Log$
+// Revision 1.58 1998/12/09 18:50:25 curt
+// Converted "class fgVIEW" to "class FGView" and updated to make data
+// members private and make required accessor functions.
+//
// Revision 1.57 1998/12/06 14:52:56 curt
// Fixed a problem with the initial starting altitude. "v->abs_view_pos" wasn't
// being calculated correctly at the beginning causing the first terrain
int xsize = 480;
int ysize = 380;
- xmin = (current_view.winWidth - xsize) / 2;
+ xmin = (current_view.get_winWidth() - xsize) / 2;
xmax = xmin + xsize;
- ymin = (current_view.winHeight - ysize) / 2;
+ ymin = (current_view.get_winHeight() - ysize) / 2;
ymax = ymin + ysize;
// first clear the screen;
xglMatrixMode(GL_PROJECTION);
xglPushMatrix();
xglLoadIdentity();
- gluOrtho2D(0, current_view.winWidth, 0, current_view.winHeight);
+ gluOrtho2D(0, current_view.get_winWidth(), 0, current_view.get_winHeight());
xglMatrixMode(GL_MODELVIEW);
xglPushMatrix();
xglLoadIdentity();
// $Log$
+// Revision 1.9 1998/12/09 18:50:26 curt
+// Converted "class fgVIEW" to "class FGView" and updated to make data
+// members private and make required accessor functions.
+//
// Revision 1.8 1998/11/16 14:00:05 curt
// Added pow() macro bug work around.
// Added support for starting FGFS at various resolutions.
// This is a record containing current view parameters
-fgVIEW current_view;
+FGView current_view;
// Constructor
-fgVIEW::fgVIEW( void ) {
+FGView::FGView( void ) {
}
// Initialize a view structure
-void fgVIEW::Init( void ) {
+void FGView::Init( void ) {
FG_LOG( FG_VIEW, FG_INFO, "Initializing View parameters" );
view_offset = 0.0;
// Update the field of view parameters
-void fgVIEW::UpdateFOV( fgOPTIONS *o ) {
+void FGView::UpdateFOV( fgOPTIONS *o ) {
double fov, theta_x, theta_y;
fov = o->get_fov();
// Basically, this is a modified version of the Mesa gluLookAt()
// function that's been modified slightly so we can capture the
// result before sending it off to OpenGL land.
-void fgVIEW::LookAt( GLdouble eyex, GLdouble eyey, GLdouble eyez,
+void FGView::LookAt( GLdouble eyex, GLdouble eyey, GLdouble eyez,
GLdouble centerx, GLdouble centery, GLdouble centerz,
GLdouble upx, GLdouble upy, GLdouble upz ) {
GLdouble *m;
// Update the view volume, position, and orientation
-void fgVIEW::UpdateViewParams( void ) {
+void FGView::UpdateViewParams( void ) {
FGState *f;
fgLIGHT *l;
// Update the view parameters
-void fgVIEW::UpdateViewMath( FGState *f ) {
+void FGView::UpdateViewMath( FGState *f ) {
Point3D p;
MAT3vec vec, forward, v0, minus_z;
MAT3mat R, TMP, UP, LOCAL, VIEW;
// Update the "World to Eye" transformation matrix
// This is most useful for view frustum culling
-void fgVIEW::UpdateWorldToEye( FGState *f ) {
+void FGView::UpdateWorldToEye( FGState *f ) {
MAT3mat R_Phi, R_Theta, R_Psi, R_Lat, R_Lon, T_view;
MAT3mat TMP;
MAT3hvec vec;
// Olson curt@me.umn.edu and Norman Vine nhv@yahoo.com with 'gentle
// guidance' from Steve Baker sbaker@link.com
int
-fgVIEW::SphereClip( const Point3D& cp, const double radius )
+FGView::SphereClip( const Point3D& cp, const double radius )
{
double x1, y1;
// Destructor
-fgVIEW::~fgVIEW( void ) {
+FGView::~FGView( void ) {
}
// $Log$
+// Revision 1.30 1998/12/09 18:50:28 curt
+// Converted "class fgVIEW" to "class FGView" and updated to make data
+// members private and make required accessor functions.
+//
// Revision 1.29 1998/12/05 15:54:24 curt
// Renamed class fgFLIGHT to class FGState as per request by JSB.
//
// Define a structure containing view information
-class fgVIEW {
-
-public:
+class FGView {
// the current offset from forward for viewing
double view_offset;
// Current model view matrix;
GLdouble MODEL_VIEW[16];
+public:
+
// Constructor
- fgVIEW( void );
+ FGView( void );
+
+ // Destructor
+ ~FGView( void );
// Initialize a view class
void Init( void );
- void update_globals( FGState *f );
+ void UpdateGlobals( FGState *f );
// Basically, this is a modified version of the Mesa gluLookAt()
// function that's been modified slightly so we can capture the
// Update the field of view parameters
void UpdateFOV( fgOPTIONS *o );
-
- // Destructor
- ~fgVIEW( void );
+
+ // accessor functions
+ inline double get_view_offset() const { return view_offset; }
+ inline void set_view_offset( double a ) { view_offset = a; }
+ inline void inc_view_offset( double amt ) { view_offset += amt; }
+ inline double get_goal_view_offset() const { return goal_view_offset; }
+ inline void set_goal_view_offset( double a) { goal_view_offset = a; }
+ inline bool get_update_fov() const { return update_fov; }
+ inline void set_update_fov(bool value) { update_fov = value; }
+ inline double get_win_ratio() const { return win_ratio; }
+ inline void set_win_ratio( double r ) { win_ratio = r; }
+ inline int get_winWidth() const { return winWidth; }
+ inline void set_winWidth( int w ) { winWidth = w; }
+ inline int get_winHeight() const { return winHeight; }
+ inline void set_winHeight( int h ) { winHeight = h; }
+ inline double get_slope_y() const { return slope_y; }
+ inline double get_slope_x() const { return slope_x; }
+#if defined( USE_FAST_FOV_CLIP )
+ inline double get_fov_x_clip() const { return fov_x_clip; }
+ inline double get_fov_y_clip() const { return fov_y_clip; }
+#endif // USE_FAST_FOV_CLIP
+ inline double get_vfc_ratio() const { return vfc_ratio; }
+ inline void set_vfc_ratio(double r) { vfc_ratio = r; }
+ inline int get_tris_rendered() const { return tris_rendered; }
+ inline void set_tris_rendered( int tris) { tris_rendered = tris; }
+ inline Point3D get_abs_view_pos() const { return abs_view_pos; }
+ inline Point3D get_view_pos() const { return view_pos; }
+ inline Point3D get_cur_zero_elev() const { return cur_zero_elev; }
+ inline double *get_to_sun() { return to_sun; }
+ inline void set_to_sun( double x, double y, double z) {
+ to_sun[0] = x;
+ to_sun[1] = y;
+ to_sun[2] = z;
+ }
+ inline double *get_surface_to_sun() { return surface_to_sun; }
+ inline void set_surface_to_sun( double x, double y, double z) {
+ surface_to_sun[0] = x;
+ surface_to_sun[1] = y;
+ surface_to_sun[2] = z;
+ }
+ inline double *get_surface_south() { return surface_south; }
+ inline double *get_surface_east() { return surface_east; }
+ inline double *get_local_up() { return local_up; }
+ inline MAT3mat *get_WORLD_TO_EYE() const { return &WORLD_TO_EYE; }
+ inline GLdouble *get_MODEL_VIEW() { return MODEL_VIEW; }
};
-extern fgVIEW current_view;
+extern FGView current_view;
#endif // _VIEWS_HXX
// $Log$
+// Revision 1.17 1998/12/09 18:50:29 curt
+// Converted "class fgVIEW" to "class FGView" and updated to make data
+// members private and make required accessor functions.
+//
// Revision 1.16 1998/12/05 15:54:25 curt
// Renamed class fgFLIGHT to class FGState as per request by JSB.
//
void
fgMATERIAL::render_fragments()
{
+ int tris_rendered = current_view.get_tris_rendered();
+
// cout << "rendering " + texture_name + " = " << list_size << "\n";
if ( empty() )
for ( ; current != last; ++current ) {
fgFRAGMENT* frag_ptr = *current;
- current_view.tris_rendered += frag_ptr->num_faces();
+ tris_rendered += frag_ptr->num_faces();
if ( frag_ptr->tile_ptr != last_tile_ptr )
{
// new tile, new translate
// printf(" display_list = %d\n", frag_ptr->display_list);
xglCallList( frag_ptr->display_list );
}
+
+ current_view.set_tris_rendered( tris_rendered );
}
void
fgMATERIAL_MGR::render_fragments()
{
- current_view.tris_rendered = 0;
+ current_view.set_tris_rendered( 0 );
+
iterator last = end();
for ( iterator current = begin(); current != last; ++current )
(*current).second.render_fragments();
// $Log$
+// Revision 1.12 1998/12/09 18:50:30 curt
+// Converted "class fgVIEW" to "class FGView" and updated to make data
+// members private and make required accessor functions.
+//
// Revision 1.11 1998/11/07 19:07:12 curt
// Enable release builds using the --without-logging option to the configure
// script. Also a couple log message cleanups, plus some C to C++ comment
int
fgTILECACHE::next_avail( void )
{
- fgVIEW *v;
- Point3D delta;
+ Point3D delta, abs_view_pos;
int i;
float max, med, min, tmp;
float dist, max_dist;
int max_index;
- v = ¤t_view;
-
max_dist = 0.0;
max_index = 0;
return(i);
} else {
// calculate approximate distance from view point
+ abs_view_pos = current_view.get_abs_view_pos();
+
FG_LOG( FG_TERRAIN, FG_DEBUG,
- "DIST Abs view pos = " << v->abs_view_pos );
+ "DIST Abs view pos = " << abs_view_pos );
FG_LOG( FG_TERRAIN, FG_DEBUG,
" ref point = " << tile_cache[i].center );
- delta.setx( fabs(tile_cache[i].center.x() - v->abs_view_pos.x() ) );
- delta.sety( fabs(tile_cache[i].center.y() - v->abs_view_pos.y() ) );
- delta.setz( fabs(tile_cache[i].center.z() - v->abs_view_pos.z() ) );
+ delta.setx( fabs(tile_cache[i].center.x() - abs_view_pos.x() ) );
+ delta.sety( fabs(tile_cache[i].center.y() - abs_view_pos.y() ) );
+ delta.setz( fabs(tile_cache[i].center.z() - abs_view_pos.z() ) );
max = delta.x(); med = delta.y(); min = delta.z();
if ( max < med ) {
// $Log$
+// Revision 1.21 1998/12/09 18:50:32 curt
+// Converted "class fgVIEW" to "class FGView" and updated to make data
+// members private and make required accessor functions.
+//
// Revision 1.20 1998/11/09 23:40:49 curt
// Bernie Bright <bbright@c031.aone.net.au> writes:
// I've made some changes to the Scenery handling. Basically just tidy ups.
fgTileMgrCurElev( const fgBUCKET& p ) {
fgTILE *t;
fgFRAGMENT *frag_ptr;
- Point3D abs_view_pos = current_view.abs_view_pos;
+ Point3D abs_view_pos = current_view.get_abs_view_pos();
Point3D earth_center(0.0);
Point3D result;
MAT3vec local_up;
y = cp.y();
z = cp.z();
- mat = (double *)(current_view.WORLD_TO_EYE);
+ mat = (double *)(current_view.get_WORLD_TO_EYE());
eye[2] = x*mat[2] + y*mat[6] + z*mat[10] + mat[14];
return(0);
}
- eye[0] = (x*mat[0] + y*mat[4] + z*mat[8] + mat[12]) * current_view.slope_x;
+ eye[0] = (x*mat[0] + y*mat[4] + z*mat[8] + mat[12])
+ * current_view.get_slope_x();
// check right and left clip plane (from eye perspective)
- x1 = radius * current_view.fov_x_clip;
+ x1 = radius * current_view.get_fov_x_clip();
if( (eye[2] > -(eye[0]+x1)) || (eye[2] > (eye[0]-x1)) )
{
return(0);
}
- eye[1] = (x*mat[1] + y*mat[5] + z*mat[9] + mat[13]) * current_view.slope_y;
+ eye[1] = (x*mat[1] + y*mat[5] + z*mat[9] + mat[13])
+ * current_view.get_slope_y();
// check bottom and top clip plane (from eye perspective)
- y1 = radius * current_view.fov_y_clip;
+ y1 = radius * current_view.get_fov_y_clip();
if( (eye[2] > -(eye[1]+y1)) || (eye[2] > (eye[1]-y1)) )
{
return(0);
FGState *f;
fgTILECACHE *c;
fgTILE *t;
- fgVIEW *v;
+ FGView *v;
Point3D frag_offset;
fgFRAGMENT *frag_ptr;
fgMATERIAL *mtl_ptr;
// Calculate the model_view transformation matrix for this tile
// This is equivalent to doing a glTranslatef(x, y, z);
- t->UpdateViewMatrix( v->MODEL_VIEW );
+ t->UpdateViewMatrix( v->get_MODEL_VIEW() );
// xglPushMatrix();
// xglTranslatef(t->offset.x, t->offset.y, t->offset.z);
}
if ( (drawn + culled) > 0 ) {
- v->vfc_ratio = (double)culled / (double)(drawn + culled);
+ v->set_vfc_ratio( (double)culled / (double)(drawn + culled) );
} else {
- v->vfc_ratio = 0.0;
+ v->set_vfc_ratio( 0.0 );
}
// printf("drawn = %d culled = %d saved = %.2f\n", drawn, culled,
// v->vfc_ratio);
// $Log$
+// Revision 1.51 1998/12/09 18:50:33 curt
+// Converted "class fgVIEW" to "class FGView" and updated to make data
+// members private and make required accessor functions.
+//
// Revision 1.50 1998/12/06 13:51:25 curt
// Turned "struct fgWEATHER" into "class FGWeather".
//
void fgLIGHT::Update( void ) {
FGState *f;
fgTIME *t;
- fgVIEW *v;
// if the 4th field is 0.0, this specifies a direction ...
GLfloat white[4] = { 1.0, 1.0, 1.0, 1.0 };
// base sky color
f = current_aircraft.fdm_state;
t = &cur_time_params;
- v = ¤t_view;
FG_LOG( FG_EVENT, FG_INFO, "Updating light parameters." );
// calculate fog color adjusted for sunrise/sunset effects
void fgLIGHT::UpdateAdjFog( void ) {
FGState *f;
- fgVIEW *v;
double sun_angle_deg, rotation, param1[3], param2[3];
f = current_aircraft.fdm_state;
- v = ¤t_view;
FG_LOG( FG_EVENT, FG_DEBUG, "Updating adjusted fog parameters." );
// first determine the difference between our view angle and local
// direction to the sun
- rotation = -(sun_rotation + FG_PI) - (f->get_Psi() - v->view_offset) ;
+ rotation = -(sun_rotation + FG_PI)
+ - (f->get_Psi() - current_view.get_view_offset());
while ( rotation < 0 ) {
rotation += FG_2PI;
}
// $Log$
+// Revision 1.24 1998/12/09 18:50:35 curt
+// Converted "class fgVIEW" to "class FGView" and updated to make data
+// members private and make required accessor functions.
+//
// Revision 1.23 1998/12/05 15:54:30 curt
// Renamed class fgFLIGHT to class FGState as per request by JSB.
//
void fgUpdateSunPos( void ) {
fgLIGHT *l;
fgTIME *t;
- fgVIEW *v;
- MAT3vec nup, nsun, v0;
+ FGView *v;
+ MAT3vec nup, nsun, v0, surface_to_sun;
Point3D p, rel_sunpos;
double dot, east_dot;
double sun_gd_lat, sl_radius;
// l->sun_vec[2]);
// calculate the sun's relative angle to local up
- MAT3_COPY_VEC(nup, v->local_up);
+ MAT3_COPY_VEC(nup, v->get_local_up());
nsun[0] = l->fg_sunpos.x();
nsun[1] = l->fg_sunpos.y();
nsun[2] = l->fg_sunpos.z();
// l->sun_angle);
// calculate vector to sun's position on the earth's surface
- rel_sunpos = l->fg_sunpos - (v->view_pos + scenery.center);
- v->to_sun[0] = rel_sunpos.x();
- v->to_sun[1] = rel_sunpos.y();
- v->to_sun[2] = rel_sunpos.z();
+ rel_sunpos = l->fg_sunpos - (v->get_view_pos() + scenery.center);
+ v->set_to_sun( rel_sunpos.x(), rel_sunpos.y(), rel_sunpos.z() );
// printf( "Vector to sun = %.2f %.2f %.2f\n",
// v->to_sun[0], v->to_sun[1], v->to_sun[2]);
// make a vector to the current view position
- MAT3_SET_VEC(v0, v->view_pos.x(), v->view_pos.y(), v->view_pos.z());
+ Point3D view_pos = v->get_view_pos();
+ MAT3_SET_VEC(v0, view_pos.x(), view_pos.y(), view_pos.z());
// Given a vector from the view position to the point on the
// earth's surface the sun is directly over, map into onto the
// local plane representing "horizontal".
- map_vec_onto_cur_surface_plane(v->local_up, v0, v->to_sun,
- v->surface_to_sun);
- MAT3_NORMALIZE_VEC(v->surface_to_sun, ntmp);
+ map_vec_onto_cur_surface_plane( v->get_local_up(), v0, v->get_to_sun(),
+ surface_to_sun );
+ MAT3_NORMALIZE_VEC(surface_to_sun, ntmp);
+ v->set_surface_to_sun( surface_to_sun[0], surface_to_sun[1],
+ surface_to_sun[2] );
// printf("Surface direction to sun is %.2f %.2f %.2f\n",
// v->surface_to_sun[0], v->surface_to_sun[1], v->surface_to_sun[2]);
// printf("Should be close to zero = %.2f\n",
// calculate the angle between v->surface_to_sun and
// v->surface_east. We do this so we can sort out the acos()
// ambiguity. I wish I could think of a more efficient way ... :-(
- east_dot = MAT3_DOT_PRODUCT(v->surface_to_sun, v->surface_east);
+ east_dot = MAT3_DOT_PRODUCT( surface_to_sun, v->get_surface_east() );
// printf(" East dot product = %.2f\n", east_dot);
// calculate the angle between v->surface_to_sun and
// v->surface_south. this is how much we have to rotate the sky
// for it to align with the sun
- dot = MAT3_DOT_PRODUCT(v->surface_to_sun, v->surface_south);
+ dot = MAT3_DOT_PRODUCT( surface_to_sun, v->get_surface_south() );
// printf(" Dot product = %.2f\n", dot);
if ( east_dot >= 0 ) {
l->sun_rotation = acos(dot);
// $Log$
+// Revision 1.18 1998/12/09 18:50:36 curt
+// Converted "class fgVIEW" to "class FGView" and updated to make data
+// members private and make required accessor functions.
+//
// Revision 1.17 1998/11/09 23:41:53 curt
// Log message clean ups.
//
projects / flightgear.git / commitdiff