1999-06-18 03:42:54 +00:00
|
|
|
// main.cxx -- top level sim routines
|
1998-04-21 17:02:27 +00:00
|
|
|
//
|
2002-04-05 00:38:55 +00:00
|
|
|
// Written by Curtis Olson, started May 1997.
|
1998-04-21 17:02:27 +00:00
|
|
|
//
|
2002-04-05 00:38:55 +00:00
|
|
|
// Copyright (C) 1997 - 2002 Curtis L. Olson - curt@flightgear.org
|
1998-04-21 17:02:27 +00:00
|
|
|
//
|
|
|
|
// 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$
|
|
|
|
|
1999-06-18 03:42:54 +00:00
|
|
|
|
1998-04-24 00:49:17 +00:00
|
|
|
#ifdef HAVE_CONFIG_H
|
|
|
|
# include <config.h>
|
|
|
|
#endif
|
1998-04-21 17:02:27 +00:00
|
|
|
|
2003-08-17 09:54:41 +00:00
|
|
|
#include <simgear/compiler.h>
|
|
|
|
|
2001-12-22 23:16:43 +00:00
|
|
|
#if defined(__linux__) && defined(__i386__)
|
2001-12-22 19:10:37 +00:00
|
|
|
# include <fpu_control.h>
|
2002-01-04 20:56:28 +00:00
|
|
|
# include <signal.h>
|
2001-12-22 19:10:37 +00:00
|
|
|
#endif
|
|
|
|
|
2001-03-23 22:42:49 +00:00
|
|
|
#ifdef SG_MATH_EXCEPTION_CLASH
|
1999-05-08 02:33:13 +00:00
|
|
|
# include <math.h>
|
|
|
|
#endif
|
|
|
|
|
1998-04-21 17:02:27 +00:00
|
|
|
#ifdef HAVE_WINDOWS_H
|
2001-03-19 13:56:19 +00:00
|
|
|
# include <windows.h>
|
|
|
|
# include <float.h>
|
1998-04-21 17:02:27 +00:00
|
|
|
#endif
|
|
|
|
|
2000-11-01 02:30:10 +00:00
|
|
|
#include <plib/ssg.h>
|
2003-08-17 09:54:41 +00:00
|
|
|
#include <plib/pu.h>
|
2003-08-25 12:41:40 +00:00
|
|
|
#include <plib/netSocket.h>
|
1999-06-18 03:42:54 +00:00
|
|
|
|
2003-08-17 09:54:41 +00:00
|
|
|
#include <simgear/screen/extensions.hxx>
|
2003-05-12 21:34:29 +00:00
|
|
|
#include <simgear/scene/material/matlib.hxx>
|
2003-08-17 09:54:41 +00:00
|
|
|
#include <simgear/props/props.hxx>
|
|
|
|
#include <simgear/scene/sky/sky.hxx>
|
|
|
|
#include <simgear/timing/sg_time.hxx>
|
2003-05-08 16:33:48 +00:00
|
|
|
#include <simgear/scene/model/animation.hxx>
|
2003-08-17 09:54:41 +00:00
|
|
|
#include <simgear/ephemeris/ephemeris.hxx>
|
|
|
|
#include <simgear/scene/model/placement.hxx>
|
|
|
|
#include <simgear/math/sg_random.h>
|
2003-05-15 21:35:51 +00:00
|
|
|
#include <simgear/scene/model/modellib.hxx>
|
2003-08-17 09:54:41 +00:00
|
|
|
|
2002-12-10 19:25:12 +00:00
|
|
|
#ifdef FG_USE_CLOUDS_3D
|
2003-05-30 15:16:57 +00:00
|
|
|
# include <simgear/scene/sky/clouds3d/SkySceneLoader.hpp>
|
|
|
|
# include <simgear/scene/sky/clouds3d/SkyUtil.hpp>
|
2002-12-10 19:25:12 +00:00
|
|
|
#endif
|
2000-02-15 03:30:01 +00:00
|
|
|
|
1999-01-07 20:24:43 +00:00
|
|
|
#include <Include/general.hxx>
|
2003-08-17 09:54:41 +00:00
|
|
|
#include <Scenery/tileentry.hxx>
|
|
|
|
#include <Time/light.hxx>
|
|
|
|
#include <Time/light.hxx>
|
1998-10-17 01:33:52 +00:00
|
|
|
#include <Aircraft/aircraft.hxx>
|
2003-08-17 09:54:41 +00:00
|
|
|
#include <Cockpit/panel.hxx>
|
|
|
|
#include <Cockpit/cockpit.hxx>
|
|
|
|
#include <Cockpit/radiostack.hxx>
|
|
|
|
#include <Cockpit/hud.hxx>
|
|
|
|
#include <Model/panelnode.hxx>
|
|
|
|
#include <Model/modelmgr.hxx>
|
|
|
|
#include <Model/acmodel.hxx>
|
|
|
|
#include <Scenery/scenery.hxx>
|
|
|
|
#include <Scenery/tilemgr.hxx>
|
|
|
|
#include <FDM/flight.hxx>
|
|
|
|
#include <FDM/UIUCModel/uiuc_aircraftdir.h>
|
|
|
|
#include <FDM/ADA.hxx>
|
2001-11-07 17:55:28 +00:00
|
|
|
#include <ATC/ATCdisplay.hxx>
|
2003-08-17 09:54:41 +00:00
|
|
|
#include <ATC/ATCmgr.hxx>
|
2002-10-02 15:25:58 +00:00
|
|
|
#include <ATC/AIMgr.hxx>
|
2003-08-17 09:54:41 +00:00
|
|
|
#include <Replay/replay.hxx>
|
|
|
|
#include <Time/tmp.hxx>
|
|
|
|
#include <Time/fg_timer.hxx>
|
|
|
|
#include <Environment/environment_mgr.hxx>
|
2001-11-07 17:55:28 +00:00
|
|
|
|
2003-03-19 20:45:09 +00:00
|
|
|
#ifdef FG_MPLAYER_AS
|
|
|
|
#include <MultiPlayer/multiplaytxmgr.hxx>
|
|
|
|
#include <MultiPlayer/multiplayrxmgr.hxx>
|
|
|
|
#endif
|
|
|
|
|
2003-08-17 09:54:41 +00:00
|
|
|
#include "splash.hxx"
|
Andy Ross:
The biggest and coolest patch adds mouse sensitivity to the 3D
cockpits, so we can finally work the radios. This ended up requiring
significant modifications outside of the 3D cockpit code. Stuff folks
will want to look at:
+ The list of all "3D" cockpits is stored statically in the
panelnode.cxx file. This is clumsy, and won't migrate well to a
multiple-aircraft feature. Really, there should be a per-model list
of 3D panels, but I couldn't find a clean place to put this. The
only handle you get back after parsing a model is a generic ssg
node, to which I obviously can't add panel-specific methods.
+ The aircraft model is parsed *very* early in the initialization
order. Earlier, in fact, than the static list of allowable command
bindings is built in fgInitCommands(). This is bad, as it means
that mouse bindings on the instruments can't work yet. I moved the
call to fgInitCommands, but someone should look carefully to see
that I picked the right place. There's a lot of initialization
code, and I got a little lost in there... :)
+ I added yet another "update" hook to the fgRenderFrame routine to
hook the updates for the 3D panels. This is only required for
"mouse press delay", and it's a fairly clumsy mechanism based on
frame rate instead of real time. There appears to be delay handling
already in place in the Input stuff, and there's a discussion going
on about different mouse behavior right now. Maybe this is a good
time to unify these two (now three) approaches?
2002-10-29 19:44:03 +00:00
|
|
|
#include "fg_commands.hxx"
|
2003-08-17 09:54:41 +00:00
|
|
|
#include "fg_io.hxx"
|
2003-08-29 16:46:21 +00:00
|
|
|
#include "main.hxx"
|
2002-10-16 03:44:44 +00:00
|
|
|
|
2001-09-19 22:58:29 +00:00
|
|
|
float default_attenuation[3] = {1.0, 0.0, 0.0};
|
2000-12-08 20:05:43 +00:00
|
|
|
ssgSelector *ship_sel=NULL;
|
|
|
|
// upto 32 instances of a same object can be loaded.
|
|
|
|
ssgTransform *ship_pos[32];
|
2001-09-19 22:58:29 +00:00
|
|
|
double obj_lat[32],obj_lon[32],obj_alt[32],obj_pitch[32],obj_roll[32];
|
2000-12-08 20:05:43 +00:00
|
|
|
int objc=0;
|
2001-09-19 22:58:29 +00:00
|
|
|
ssgSelector *lightpoints_brightness = new ssgSelector;
|
|
|
|
ssgTransform *lightpoints_transform = new ssgTransform;
|
|
|
|
FGTileEntry *dummy_tile;
|
|
|
|
sgVec3 rway_ols;
|
|
|
|
// ADA
|
2002-03-28 16:14:04 +00:00
|
|
|
// Clip plane settings...
|
|
|
|
float scene_nearplane = 0.5f;
|
|
|
|
float scene_farplane = 120000.0f;
|
|
|
|
|
2003-11-21 23:35:25 +00:00
|
|
|
static double real_delta_time_sec = 0.0;
|
2003-07-17 18:24:17 +00:00
|
|
|
static double delta_time_sec = 0.0;
|
2002-05-11 16:28:50 +00:00
|
|
|
|
2003-08-29 16:46:21 +00:00
|
|
|
glPointParameterfProc glPointParameterfPtr = 0;
|
|
|
|
glPointParameterfvProc glPointParameterfvPtr = 0;
|
|
|
|
bool glPointParameterIsSupported = false;
|
|
|
|
|
The following changes were made to flightgear-0.7.5 code to implement the follow
ing features:
a) ADA Flight model - ADA.cxx, ADA.hxx, flight.hxx
b) Fighter a/c HUD - flight.hxx, hud.hxx, hud.cxx, cockpit.cxx, hud_ladr.c
xx, hud_card.cxx
c) 3-window display - options.hxx, options.cxx, viewer.cxx
d) Moving objects (ship) - main.cxx
e) Patches - main.cxx
ADA.cxx, ADA.hxx
--------------------------
Interface to the external ADA flight dynamics package.
flight.hxx
----------
Included prototypes for accepting additional data fron the External flight
model for fighter aircraft HUD
Hud.hxx
-------
Included prototypes for accepting additional data for fighter HUD from Exernal F
light model.
Defined FIGHTER_HUD pre-processor directive to enable compilation of fighter hud
code.
hud.cxx, cockpit.cxx, hud_ladr.cxx, hud_card.cxx
---------------------------------------
Included code to initialise additional reticles/text for fighter HUD which is co
nditionally
compiled if FIGHTER_HUD is defined.
options.hxx
-----------
Added window_offset, and function to retrieve its value for 3 windows
options.cxx
-----------
Changed few options to suit ADA/CEF projection system/screens and checks for win
dow offset.
views.cxx
---------
Added code to retrieve view offset for window.
Main.cxx
--------
Added code to load and move an aircraft carrier.
Patch to enable clouds from command line until Curtis fixes it. By default cloud
s are disabled.
2000-10-19 19:46:13 +00:00
|
|
|
|
2002-05-12 00:12:19 +00:00
|
|
|
#ifdef FG_WEATHERCM
|
1999-10-22 00:27:49 +00:00
|
|
|
# include <WeatherCM/FGLocalWeatherDatabase.h>
|
1999-08-12 17:13:44 +00:00
|
|
|
#endif
|
1998-04-21 17:02:27 +00:00
|
|
|
|
2000-09-10 00:04:50 +00:00
|
|
|
#ifdef macintosh
|
2000-12-13 23:02:02 +00:00
|
|
|
# include <console.h> // -dw- for command line dialog
|
1999-04-27 19:27:45 +00:00
|
|
|
#endif
|
|
|
|
|
1999-01-07 20:24:43 +00:00
|
|
|
// This is a record containing a bit of global housekeeping information
|
|
|
|
FGGeneral general;
|
1998-04-21 17:02:27 +00:00
|
|
|
|
1998-07-06 02:42:02 +00:00
|
|
|
// Specify our current idle function state. This is used to run all
|
|
|
|
// our initializations out of the glutIdleLoop() so that we can get a
|
|
|
|
// splash screen up and running right away.
|
1998-09-15 02:09:24 +00:00
|
|
|
static int idle_state = 0;
|
2001-01-17 23:30:35 +00:00
|
|
|
static long global_multi_loop;
|
1998-07-06 02:42:02 +00:00
|
|
|
|
2002-03-13 17:06:41 +00:00
|
|
|
// fog constants. I'm a little nervous about putting actual code out
|
|
|
|
// here but it seems to work (?)
|
|
|
|
static const double m_log01 = -log( 0.01 );
|
|
|
|
static const double sqrt_m_log01 = sqrt( m_log01 );
|
|
|
|
static GLfloat fog_exp_density;
|
|
|
|
static GLfloat fog_exp2_density;
|
2002-11-01 21:56:48 +00:00
|
|
|
static GLfloat rwy_exp2_punch_through;
|
|
|
|
static GLfloat taxi_exp2_punch_through;
|
2002-11-26 16:01:39 +00:00
|
|
|
static GLfloat ground_exp2_punch_through;
|
2002-03-13 17:06:41 +00:00
|
|
|
|
2000-03-02 13:51:31 +00:00
|
|
|
// Sky structures
|
2000-03-16 04:15:22 +00:00
|
|
|
SGSky *thesky;
|
2002-12-10 19:25:12 +00:00
|
|
|
|
|
|
|
#ifdef FG_USE_CLOUDS_3D
|
|
|
|
SkySceneLoader *sgClouds3d;
|
|
|
|
bool _bcloud_orig = true;
|
|
|
|
#endif
|
2000-03-02 13:51:31 +00:00
|
|
|
|
1999-08-08 01:31:30 +00:00
|
|
|
// hack
|
|
|
|
sgMat4 copy_of_ssgOpenGLAxisSwapMatrix =
|
|
|
|
{
|
|
|
|
{ 1.0f, 0.0f, 0.0f, 0.0f },
|
|
|
|
{ 0.0f, 0.0f, -1.0f, 0.0f },
|
|
|
|
{ 0.0f, 1.0f, 0.0f, 0.0f },
|
|
|
|
{ 0.0f, 0.0f, 0.0f, 1.0f }
|
2002-02-05 20:54:08 +00:00
|
|
|
};
|
1999-06-18 03:42:54 +00:00
|
|
|
|
2000-10-10 20:31:20 +00:00
|
|
|
// The following defines flightgear options. Because glutlib will also
|
1998-04-21 17:02:27 +00:00
|
|
|
// want to parse its own options, those options must not be included here
|
|
|
|
// or they will get parsed by the main program option parser. Hence case
|
|
|
|
// is significant for any option added that might be in conflict with
|
|
|
|
// glutlib's parser.
|
|
|
|
//
|
|
|
|
// glutlib parses for:
|
|
|
|
// -display
|
|
|
|
// -direct (invalid in Win32)
|
|
|
|
// -geometry
|
|
|
|
// -gldebug
|
|
|
|
// -iconized
|
|
|
|
// -indirect (invalid in Win32)
|
|
|
|
// -synce
|
|
|
|
//
|
|
|
|
// Note that glutlib depends upon strings while this program's
|
|
|
|
// option parser wants only initial characters followed by numbers
|
|
|
|
// or pathnames.
|
|
|
|
//
|
|
|
|
|
|
|
|
|
2002-09-19 01:27:49 +00:00
|
|
|
ssgSimpleState *cloud3d_imposter_state;
|
2000-03-02 03:03:16 +00:00
|
|
|
ssgSimpleState *default_state;
|
|
|
|
ssgSimpleState *hud_and_panel;
|
|
|
|
ssgSimpleState *menus;
|
|
|
|
|
2002-04-20 14:52:43 +00:00
|
|
|
SGTimeStamp last_time_stamp;
|
2002-03-12 16:30:27 +00:00
|
|
|
SGTimeStamp current_time_stamp;
|
|
|
|
|
2003-03-22 10:38:15 +00:00
|
|
|
|
2000-03-02 03:03:16 +00:00
|
|
|
void fgBuildRenderStates( void ) {
|
|
|
|
default_state = new ssgSimpleState;
|
2000-10-18 00:48:12 +00:00
|
|
|
default_state->ref();
|
2000-03-02 03:03:16 +00:00
|
|
|
default_state->disable( GL_TEXTURE_2D );
|
|
|
|
default_state->enable( GL_CULL_FACE );
|
2000-06-01 21:14:06 +00:00
|
|
|
default_state->enable( GL_COLOR_MATERIAL );
|
|
|
|
default_state->setColourMaterial( GL_AMBIENT_AND_DIFFUSE );
|
|
|
|
default_state->setMaterial( GL_EMISSION, 0, 0, 0, 1 );
|
|
|
|
default_state->setMaterial( GL_SPECULAR, 0, 0, 0, 1 );
|
2000-03-02 03:03:16 +00:00
|
|
|
default_state->disable( GL_BLEND );
|
|
|
|
default_state->disable( GL_ALPHA_TEST );
|
|
|
|
default_state->disable( GL_LIGHTING );
|
|
|
|
|
2002-09-19 01:27:49 +00:00
|
|
|
cloud3d_imposter_state = new ssgSimpleState;
|
|
|
|
cloud3d_imposter_state->ref();
|
|
|
|
cloud3d_imposter_state->enable( GL_TEXTURE_2D );
|
|
|
|
cloud3d_imposter_state->enable( GL_CULL_FACE );
|
|
|
|
cloud3d_imposter_state->enable( GL_COLOR_MATERIAL );
|
|
|
|
cloud3d_imposter_state->setColourMaterial( GL_AMBIENT_AND_DIFFUSE );
|
|
|
|
cloud3d_imposter_state->setMaterial( GL_DIFFUSE, 1, 1, 1, 1 );
|
|
|
|
cloud3d_imposter_state->setMaterial( GL_AMBIENT, 1, 1, 1, 1 );
|
|
|
|
cloud3d_imposter_state->setMaterial( GL_EMISSION, 0, 0, 0, 1 );
|
|
|
|
cloud3d_imposter_state->setMaterial( GL_SPECULAR, 0, 0, 0, 1 );
|
|
|
|
cloud3d_imposter_state->enable( GL_BLEND );
|
|
|
|
cloud3d_imposter_state->enable( GL_ALPHA_TEST );
|
2002-09-19 02:21:23 +00:00
|
|
|
cloud3d_imposter_state->disable( GL_LIGHTING );
|
2002-09-19 01:27:49 +00:00
|
|
|
|
2000-03-02 03:03:16 +00:00
|
|
|
hud_and_panel = new ssgSimpleState;
|
2000-10-18 00:48:12 +00:00
|
|
|
hud_and_panel->ref();
|
2000-03-02 03:03:16 +00:00
|
|
|
hud_and_panel->disable( GL_CULL_FACE );
|
|
|
|
hud_and_panel->disable( GL_TEXTURE_2D );
|
|
|
|
hud_and_panel->disable( GL_LIGHTING );
|
2000-05-30 20:51:47 +00:00
|
|
|
hud_and_panel->enable( GL_BLEND );
|
2000-03-02 03:03:16 +00:00
|
|
|
|
|
|
|
menus = new ssgSimpleState;
|
2000-10-18 00:48:12 +00:00
|
|
|
menus->ref();
|
2000-03-02 03:03:16 +00:00
|
|
|
menus->disable( GL_CULL_FACE );
|
|
|
|
menus->disable( GL_TEXTURE_2D );
|
|
|
|
menus->enable( GL_BLEND );
|
|
|
|
}
|
|
|
|
|
2002-04-05 00:38:55 +00:00
|
|
|
|
1998-04-21 17:02:27 +00:00
|
|
|
// fgInitVisuals() -- Initialize various GL/view parameters
|
1999-10-14 23:46:28 +00:00
|
|
|
void fgInitVisuals( void ) {
|
1998-04-21 17:02:27 +00:00
|
|
|
|
2003-09-20 09:38:32 +00:00
|
|
|
FGLight *l = (FGLight *)(globals->get_subsystem("lighting"));
|
1998-04-21 17:02:27 +00:00
|
|
|
|
1999-04-27 19:27:45 +00:00
|
|
|
#ifndef GLUT_WRONG_VERSION
|
1998-05-03 00:47:31 +00:00
|
|
|
// Go full screen if requested ...
|
2001-01-13 22:06:39 +00:00
|
|
|
if ( fgGetBool("/sim/startup/fullscreen") ) {
|
2003-04-15 14:10:47 +00:00
|
|
|
glutFullScreen();
|
1998-05-03 00:47:31 +00:00
|
|
|
}
|
1999-04-27 19:27:45 +00:00
|
|
|
#endif
|
1998-04-21 17:02:27 +00:00
|
|
|
|
|
|
|
// If enabled, normal vectors specified with glNormal are scaled
|
2002-04-05 00:38:55 +00:00
|
|
|
// to unit length after transformation. Enabling this has
|
|
|
|
// performance implications. See the docs for glNormal.
|
2000-03-17 06:16:15 +00:00
|
|
|
// glEnable( GL_NORMALIZE );
|
1998-04-21 17:02:27 +00:00
|
|
|
|
2000-03-17 06:16:15 +00:00
|
|
|
glEnable( GL_LIGHTING );
|
|
|
|
glEnable( GL_LIGHT0 );
|
2002-07-21 17:03:29 +00:00
|
|
|
// glLightfv( GL_LIGHT0, GL_POSITION, l->sun_vec ); // done later with ssg
|
1998-04-21 17:02:27 +00:00
|
|
|
|
1999-06-18 03:42:54 +00:00
|
|
|
sgVec3 sunpos;
|
2003-09-20 09:38:32 +00:00
|
|
|
sgSetVec3( sunpos, l->sun_vec()[0], l->sun_vec()[1], l->sun_vec()[2] );
|
1999-06-18 03:42:54 +00:00
|
|
|
ssgGetLight( 0 ) -> setPosition( sunpos );
|
|
|
|
|
2000-03-17 06:16:15 +00:00
|
|
|
glFogi (GL_FOG_MODE, GL_EXP2);
|
2002-03-26 02:38:11 +00:00
|
|
|
if ( (!strcmp(fgGetString("/sim/rendering/fog"), "disabled")) ||
|
2003-04-15 14:10:47 +00:00
|
|
|
(!fgGetBool("/sim/rendering/shading"))) {
|
|
|
|
// if fastest fog requested, or if flat shading force fastest
|
|
|
|
glHint ( GL_FOG_HINT, GL_FASTEST );
|
2002-03-26 02:38:11 +00:00
|
|
|
} else if ( !strcmp(fgGetString("/sim/rendering/fog"), "nicest") ) {
|
2003-04-15 14:10:47 +00:00
|
|
|
glHint ( GL_FOG_HINT, GL_NICEST );
|
1998-05-11 18:18:15 +00:00
|
|
|
}
|
2001-01-13 22:06:39 +00:00
|
|
|
if ( fgGetBool("/sim/rendering/wireframe") ) {
|
2003-04-15 14:10:47 +00:00
|
|
|
// draw wire frame
|
|
|
|
glPolygonMode( GL_FRONT_AND_BACK, GL_LINE );
|
1998-04-30 12:34:17 +00:00
|
|
|
}
|
1998-05-20 20:51:33 +00:00
|
|
|
|
|
|
|
// This is the default anyways, but it can't hurt
|
2000-03-17 06:16:15 +00:00
|
|
|
glFrontFace ( GL_CCW );
|
1998-07-20 12:49:44 +00:00
|
|
|
|
|
|
|
// Just testing ...
|
2000-03-17 06:16:15 +00:00
|
|
|
// glEnable(GL_POINT_SMOOTH);
|
|
|
|
// glEnable(GL_LINE_SMOOTH);
|
|
|
|
// glEnable(GL_POLYGON_SMOOTH);
|
1998-04-21 17:02:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2001-06-26 18:23:07 +00:00
|
|
|
// For HiRes screen Dumps using Brian Pauls TR Library
|
|
|
|
void trRenderFrame( void ) {
|
|
|
|
|
|
|
|
if ( fgPanelVisible() ) {
|
|
|
|
GLfloat height = fgGetInt("/sim/startup/ysize");
|
|
|
|
GLfloat view_h =
|
2003-03-30 12:46:08 +00:00
|
|
|
(globals->get_current_panel()->getViewHeight() - globals->get_current_panel()->getYOffset())
|
2001-06-26 18:23:07 +00:00
|
|
|
* (height / 768.0) + 1;
|
|
|
|
glTranslatef( 0.0, view_h, 0.0 );
|
|
|
|
}
|
|
|
|
|
|
|
|
static GLfloat black[4] = { 0.0, 0.0, 0.0, 1.0 };
|
|
|
|
static GLfloat white[4] = { 1.0, 1.0, 1.0, 1.0 };
|
|
|
|
|
2003-09-20 09:38:32 +00:00
|
|
|
FGLight *l = (FGLight *)(globals->get_subsystem("lighting"));
|
2001-06-26 18:23:07 +00:00
|
|
|
|
2003-09-20 09:38:32 +00:00
|
|
|
glClearColor(l->adj_fog_color()[0], l->adj_fog_color()[1],
|
|
|
|
l->adj_fog_color()[2], l->adj_fog_color()[3]);
|
2001-06-26 18:23:07 +00:00
|
|
|
|
|
|
|
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
|
|
|
|
|
|
|
|
// set the opengl state to known default values
|
|
|
|
default_state->force();
|
|
|
|
|
|
|
|
glEnable( GL_FOG );
|
|
|
|
glFogf ( GL_FOG_DENSITY, fog_exp2_density);
|
|
|
|
glFogi ( GL_FOG_MODE, GL_EXP2 );
|
2003-09-20 09:38:32 +00:00
|
|
|
glFogfv ( GL_FOG_COLOR, l->adj_fog_color() );
|
2001-06-26 18:23:07 +00:00
|
|
|
|
|
|
|
// GL_LIGHT_MODEL_AMBIENT has a default non-zero value so if
|
|
|
|
// we only update GL_AMBIENT for our lights we will never get
|
|
|
|
// a completely dark scene. So, we set GL_LIGHT_MODEL_AMBIENT
|
|
|
|
// explicitely to black.
|
|
|
|
glLightModelfv( GL_LIGHT_MODEL_AMBIENT, black );
|
2002-09-13 20:38:15 +00:00
|
|
|
glLightModeli( GL_LIGHT_MODEL_LOCAL_VIEWER, GL_FALSE );
|
2003-09-12 21:43:01 +00:00
|
|
|
|
2003-09-20 09:38:32 +00:00
|
|
|
ssgGetLight( 0 ) -> setColour( GL_AMBIENT, l->scene_ambient() );
|
2001-06-26 18:23:07 +00:00
|
|
|
|
|
|
|
// texture parameters
|
|
|
|
glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE ) ;
|
|
|
|
glHint( GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST ) ;
|
|
|
|
|
|
|
|
// we need a white diffuse light for the phase of the moon
|
|
|
|
ssgGetLight( 0 ) -> setColour( GL_DIFFUSE, white );
|
2003-09-23 08:43:19 +00:00
|
|
|
thesky->preDraw( cur_fdm_state->get_Altitude() * SG_FEET_TO_METER, fog_exp2_density );
|
2001-06-26 18:23:07 +00:00
|
|
|
|
|
|
|
// draw the ssg scene
|
|
|
|
// return to the desired diffuse color
|
2003-09-20 09:38:32 +00:00
|
|
|
ssgGetLight( 0 ) -> setColour( GL_DIFFUSE, l->scene_diffuse() );
|
2001-06-26 18:23:07 +00:00
|
|
|
glEnable( GL_DEPTH_TEST );
|
2002-03-28 16:14:04 +00:00
|
|
|
ssgSetNearFar( scene_nearplane, scene_farplane );
|
2002-05-14 05:49:47 +00:00
|
|
|
ssgCullAndDraw( globals->get_scenery()->get_scene_graph() );
|
2001-06-26 18:23:07 +00:00
|
|
|
|
|
|
|
// draw the lights
|
2002-11-01 21:56:48 +00:00
|
|
|
glFogf (GL_FOG_DENSITY, rwy_exp2_punch_through);
|
2002-03-28 16:14:04 +00:00
|
|
|
ssgSetNearFar( scene_nearplane, scene_farplane );
|
2004-01-11 19:45:29 +00:00
|
|
|
ssgCullAndDraw( globals->get_scenery()->get_vasi_lights_root() );
|
2002-10-06 03:53:19 +00:00
|
|
|
ssgCullAndDraw( globals->get_scenery()->get_rwy_lights_root() );
|
2001-06-26 18:23:07 +00:00
|
|
|
|
2002-11-01 21:56:48 +00:00
|
|
|
ssgCullAndDraw( globals->get_scenery()->get_gnd_lights_root() );
|
|
|
|
|
2002-05-17 19:04:20 +00:00
|
|
|
if (fgGetBool("/environment/clouds/status"))
|
2002-12-21 05:01:51 +00:00
|
|
|
thesky->postDraw( cur_fdm_state->get_Altitude() * SG_FEET_TO_METER );
|
2001-06-26 18:23:07 +00:00
|
|
|
|
2002-04-12 12:45:49 +00:00
|
|
|
globals->get_model_mgr()->draw();
|
2002-04-11 04:26:07 +00:00
|
|
|
globals->get_aircraft_model()->draw();
|
2001-06-26 18:23:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
1998-04-21 17:02:27 +00:00
|
|
|
// Update all Visuals (redraws anything graphics related)
|
2002-05-11 16:28:50 +00:00
|
|
|
void fgRenderFrame() {
|
2003-07-05 09:59:03 +00:00
|
|
|
bool draw_otw = fgGetBool("/sim/rendering/draw-otw");
|
|
|
|
bool skyblend = fgGetBool("/sim/rendering/skyblend");
|
|
|
|
bool enhanced_lighting = fgGetBool("/sim/rendering/enhanced-lighting");
|
|
|
|
bool distance_attenuation = fgGetBool("/sim/rendering/distance-attenuation");
|
2003-03-19 20:45:09 +00:00
|
|
|
|
2002-09-19 01:27:49 +00:00
|
|
|
GLfloat black[4] = { 0.0, 0.0, 0.0, 1.0 };
|
|
|
|
GLfloat white[4] = { 1.0, 1.0, 1.0, 1.0 };
|
|
|
|
|
2003-05-06 23:46:24 +00:00
|
|
|
// static const SGPropertyNode *longitude
|
|
|
|
// = fgGetNode("/position/longitude-deg");
|
|
|
|
// static const SGPropertyNode *latitude
|
|
|
|
// = fgGetNode("/position/latitude-deg");
|
|
|
|
// static const SGPropertyNode *altitude
|
|
|
|
// = fgGetNode("/position/altitude-ft");
|
2002-04-18 16:51:47 +00:00
|
|
|
static const SGPropertyNode *groundlevel_nearplane
|
2003-04-15 14:10:47 +00:00
|
|
|
= fgGetNode("/sim/current-view/ground-level-nearplane-m");
|
2001-10-28 16:16:30 +00:00
|
|
|
|
2002-04-07 15:24:32 +00:00
|
|
|
FGViewer *current__view = globals->get_current_view();
|
|
|
|
|
2003-09-20 09:38:32 +00:00
|
|
|
FGLight *l = (FGLight *)(globals->get_subsystem("lighting"));
|
1999-10-22 00:27:49 +00:00
|
|
|
static double last_visibility = -9999;
|
2000-06-20 22:31:47 +00:00
|
|
|
|
2002-03-13 17:06:41 +00:00
|
|
|
// update fog params
|
2002-10-13 10:46:37 +00:00
|
|
|
double actual_visibility;
|
|
|
|
if (fgGetBool("/environment/clouds/status"))
|
|
|
|
actual_visibility = thesky->get_visibility();
|
|
|
|
else
|
|
|
|
actual_visibility = fgGetDouble("/environment/visibility-m");
|
2002-03-13 17:06:41 +00:00
|
|
|
if ( actual_visibility != last_visibility ) {
|
|
|
|
last_visibility = actual_visibility;
|
|
|
|
|
|
|
|
fog_exp_density = m_log01 / actual_visibility;
|
|
|
|
fog_exp2_density = sqrt_m_log01 / actual_visibility;
|
2002-11-26 16:01:39 +00:00
|
|
|
ground_exp2_punch_through = sqrt_m_log01 / (actual_visibility * 1.5);
|
2002-11-26 02:29:03 +00:00
|
|
|
if ( actual_visibility < 8000 ) {
|
|
|
|
rwy_exp2_punch_through = sqrt_m_log01 / (actual_visibility * 2.5);
|
|
|
|
taxi_exp2_punch_through = sqrt_m_log01 / (actual_visibility * 1.5);
|
|
|
|
} else {
|
|
|
|
rwy_exp2_punch_through = sqrt_m_log01 / ( 8000 * 2.5 );
|
|
|
|
taxi_exp2_punch_through = sqrt_m_log01 / ( 8000 * 1.5 );
|
|
|
|
}
|
2002-03-13 17:06:41 +00:00
|
|
|
}
|
|
|
|
|
2000-10-25 15:27:55 +00:00
|
|
|
// double angle;
|
1998-07-22 21:40:43 +00:00
|
|
|
// GLfloat black[4] = { 0.0, 0.0, 0.0, 1.0 };
|
1999-10-22 00:27:49 +00:00
|
|
|
// GLfloat white[4] = { 1.0, 1.0, 1.0, 1.0 };
|
|
|
|
// GLfloat terrain_color[4] = { 0.54, 0.44, 0.29, 1.0 };
|
1999-05-13 02:10:52 +00:00
|
|
|
// GLfloat mat_shininess[] = { 10.0 };
|
1998-07-13 15:32:37 +00:00
|
|
|
GLbitfield clear_mask;
|
2003-03-19 20:45:09 +00:00
|
|
|
|
1998-07-06 02:42:02 +00:00
|
|
|
if ( idle_state != 1000 ) {
|
2003-04-15 14:10:47 +00:00
|
|
|
// still initializing, draw the splash screen
|
|
|
|
if ( fgGetBool("/sim/startup/splash-screen") ) {
|
|
|
|
fgSplashUpdate(0.0, 1.0);
|
|
|
|
}
|
2002-04-20 14:52:43 +00:00
|
|
|
// Keep resetting sim time while the sim is initializing
|
2003-04-15 14:10:47 +00:00
|
|
|
globals->set_sim_time_sec( 0.0 );
|
2003-05-13 03:18:42 +00:00
|
|
|
SGAnimation::set_sim_time_sec( 0.0 );
|
1998-04-30 12:34:17 +00:00
|
|
|
} else {
|
2003-04-15 14:10:47 +00:00
|
|
|
// idle_state is now 1000 meaning we've finished all our
|
|
|
|
// initializations and are running the main loop, so this will
|
|
|
|
// now work without seg faulting the system.
|
1998-04-21 17:02:27 +00:00
|
|
|
|
2003-04-15 14:10:47 +00:00
|
|
|
// calculate our current position in cartesian space
|
|
|
|
globals->get_scenery()->set_center( globals->get_scenery()->get_next_center() );
|
2000-10-25 15:27:55 +00:00
|
|
|
|
2003-04-15 14:10:47 +00:00
|
|
|
// update view port
|
|
|
|
fgReshape( fgGetInt("/sim/startup/xsize"),
|
2003-04-17 15:42:18 +00:00
|
|
|
fgGetInt("/sim/startup/ysize") );
|
2000-11-01 23:27:32 +00:00
|
|
|
|
2002-09-23 22:05:36 +00:00
|
|
|
if ( fgGetBool("/sim/rendering/clouds3d") ) {
|
|
|
|
glClear( GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT );
|
|
|
|
cloud3d_imposter_state->force();
|
|
|
|
glDisable( GL_FOG );
|
|
|
|
glColor4f( 1.0, 1.0, 1.0, 1.0 );
|
|
|
|
glEnable(GL_DEPTH_TEST);
|
|
|
|
glEnable(GL_BLEND);
|
|
|
|
glBlendFunc( GL_ONE, GL_ONE_MINUS_SRC_ALPHA ) ;
|
2002-10-04 15:19:07 +00:00
|
|
|
|
2002-12-10 19:25:12 +00:00
|
|
|
#ifdef FG_USE_CLOUDS_3D
|
2002-09-23 22:05:36 +00:00
|
|
|
if ( _bcloud_orig ) {
|
|
|
|
Point3D c = globals->get_scenery()->get_center();
|
|
|
|
sgClouds3d->Set_Cloud_Orig( &c );
|
|
|
|
_bcloud_orig = false;
|
|
|
|
}
|
|
|
|
sgClouds3d->Update( current__view->get_absolute_view_pos() );
|
2002-12-10 19:25:12 +00:00
|
|
|
#endif
|
2002-09-23 22:05:36 +00:00
|
|
|
glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ) ;
|
|
|
|
glDisable(GL_DEPTH_TEST);
|
|
|
|
}
|
1998-12-11 20:26:25 +00:00
|
|
|
|
2003-04-15 14:10:47 +00:00
|
|
|
clear_mask = GL_DEPTH_BUFFER_BIT;
|
|
|
|
if ( fgGetBool("/sim/rendering/wireframe") ) {
|
|
|
|
clear_mask |= GL_COLOR_BUFFER_BIT;
|
|
|
|
}
|
|
|
|
|
2003-07-05 09:59:03 +00:00
|
|
|
if ( skyblend ) {
|
2003-04-15 14:10:47 +00:00
|
|
|
if ( fgGetBool("/sim/rendering/textures") ) {
|
|
|
|
// glClearColor(black[0], black[1], black[2], black[3]);
|
2003-09-20 09:38:32 +00:00
|
|
|
glClearColor(l->adj_fog_color()[0], l->adj_fog_color()[1],
|
|
|
|
l->adj_fog_color()[2], l->adj_fog_color()[3]);
|
2003-04-15 14:10:47 +00:00
|
|
|
clear_mask |= GL_COLOR_BUFFER_BIT;
|
|
|
|
}
|
|
|
|
} else {
|
2003-09-20 09:38:32 +00:00
|
|
|
glClearColor(l->sky_color()[0], l->sky_color()[1],
|
|
|
|
l->sky_color()[2], l->sky_color()[3]);
|
2003-04-15 14:10:47 +00:00
|
|
|
clear_mask |= GL_COLOR_BUFFER_BIT;
|
|
|
|
}
|
|
|
|
glClear( clear_mask );
|
|
|
|
|
|
|
|
// Tell GL we are switching to model view parameters
|
|
|
|
|
|
|
|
// I really should create a derived ssg node or use a call
|
|
|
|
// back or something so that I can draw the sky within the
|
|
|
|
// ssgCullAndDraw() function, but for now I just mimic what
|
|
|
|
// ssg does to set up the model view matrix
|
|
|
|
glMatrixMode(GL_MODELVIEW);
|
|
|
|
glLoadIdentity();
|
|
|
|
ssgSetCamera( (sgVec4 *)current__view->get_VIEW() );
|
|
|
|
|
|
|
|
// set the opengl state to known default values
|
|
|
|
default_state->force();
|
|
|
|
|
|
|
|
// update fog params if visibility has changed
|
|
|
|
double visibility_meters = fgGetDouble("/environment/visibility-m");
|
|
|
|
thesky->set_visibility(visibility_meters);
|
|
|
|
|
|
|
|
thesky->modify_vis( cur_fdm_state->get_Altitude() * SG_FEET_TO_METER,
|
2003-07-25 20:09:30 +00:00
|
|
|
( global_multi_loop * fgGetInt("/sim/speed-up") )
|
2002-02-06 23:31:33 +00:00
|
|
|
/ (double)fgGetInt("/sim/model-hz") );
|
2000-06-20 22:31:47 +00:00
|
|
|
|
2003-04-15 14:10:47 +00:00
|
|
|
// Set correct opengl fog density
|
|
|
|
glFogf (GL_FOG_DENSITY, fog_exp2_density);
|
2000-12-04 05:26:40 +00:00
|
|
|
|
2003-04-15 14:10:47 +00:00
|
|
|
// update the sky dome
|
2003-07-05 09:59:03 +00:00
|
|
|
if ( skyblend ) {
|
2003-04-15 14:10:47 +00:00
|
|
|
/*
|
2003-03-20 10:43:02 +00:00
|
|
|
SG_LOG( SG_GENERAL, SG_BULK, "thesky->repaint() sky_color = "
|
2003-09-24 17:20:55 +00:00
|
|
|
<< l->sky_color()[0] << " "
|
|
|
|
<< l->sky_color()[1] << " "
|
|
|
|
<< l->sky_color()[2] << " "
|
|
|
|
<< l->sky_color()[3] );
|
2003-04-15 14:10:47 +00:00
|
|
|
SG_LOG( SG_GENERAL, SG_BULK, " fog = "
|
2003-09-24 17:20:55 +00:00
|
|
|
<< l->fog_color()[0] << " "
|
|
|
|
<< l->fog_color()[1] << " "
|
|
|
|
<< l->fog_color()[2] << " "
|
|
|
|
<< l->fog_color()[3] );
|
2003-04-15 14:10:47 +00:00
|
|
|
SG_LOG( SG_GENERAL, SG_BULK,
|
2003-09-24 17:20:55 +00:00
|
|
|
" sun_angle = " << l->sun_angle
|
|
|
|
<< " moon_angle = " << l->moon_angle );
|
2003-03-20 10:43:02 +00:00
|
|
|
*/
|
2003-07-31 09:06:15 +00:00
|
|
|
|
|
|
|
static SGSkyColor scolor;
|
2003-09-20 09:38:32 +00:00
|
|
|
FGLight *l = (FGLight *)(globals->get_subsystem("lighting"));
|
2003-07-31 09:06:15 +00:00
|
|
|
|
2003-09-20 09:38:32 +00:00
|
|
|
scolor.sky_color = l->sky_color();
|
|
|
|
scolor.fog_color = l->adj_fog_color();
|
|
|
|
scolor.cloud_color = l->cloud_color();
|
|
|
|
scolor.sun_angle = l->get_sun_angle();
|
|
|
|
scolor.moon_angle = l->get_moon_angle();
|
2003-07-31 09:06:15 +00:00
|
|
|
scolor.nplanets = globals->get_ephem()->getNumPlanets();
|
|
|
|
scolor.nstars = globals->get_ephem()->getNumStars();
|
|
|
|
scolor.planet_data = globals->get_ephem()->getPlanets();
|
|
|
|
scolor.star_data = globals->get_ephem()->getStars();
|
|
|
|
|
|
|
|
thesky->repaint( scolor );
|
2003-04-15 14:10:47 +00:00
|
|
|
|
|
|
|
/*
|
2003-03-20 10:43:02 +00:00
|
|
|
SG_LOG( SG_GENERAL, SG_BULK,
|
|
|
|
"thesky->reposition( view_pos = " << view_pos[0] << " "
|
2003-04-15 14:10:47 +00:00
|
|
|
<< view_pos[1] << " " << view_pos[2] );
|
|
|
|
SG_LOG( SG_GENERAL, SG_BULK,
|
2003-03-20 10:43:02 +00:00
|
|
|
" zero_elev = " << zero_elev[0] << " "
|
2003-04-15 14:10:47 +00:00
|
|
|
<< zero_elev[1] << " " << zero_elev[2]
|
|
|
|
<< " lon = " << cur_fdm_state->get_Longitude()
|
|
|
|
<< " lat = " << cur_fdm_state->get_Latitude() );
|
|
|
|
SG_LOG( SG_GENERAL, SG_BULK,
|
2003-09-24 17:20:55 +00:00
|
|
|
" sun_rot = " << l->get_sun_rotation
|
2003-04-15 14:10:47 +00:00
|
|
|
<< " gst = " << SGTime::cur_time_params->getGst() );
|
|
|
|
SG_LOG( SG_GENERAL, SG_BULK,
|
2003-03-20 10:43:02 +00:00
|
|
|
" sun ra = " << globals->get_ephem()->getSunRightAscension()
|
|
|
|
<< " sun dec = " << globals->get_ephem()->getSunDeclination()
|
|
|
|
<< " moon ra = " << globals->get_ephem()->getMoonRightAscension()
|
|
|
|
<< " moon dec = " << globals->get_ephem()->getMoonDeclination() );
|
|
|
|
*/
|
2003-05-06 14:00:18 +00:00
|
|
|
|
2003-06-14 09:32:06 +00:00
|
|
|
// The sun and moon distances are scaled down versions
|
|
|
|
// of the actual distance to get both the moon and the sun
|
|
|
|
// within the range of the far clip plane.
|
|
|
|
// Moon distance: 384,467 kilometers
|
|
|
|
// Sun distance: 150,000,000 kilometers
|
2003-06-17 16:59:26 +00:00
|
|
|
double sun_horiz_eff, moon_horiz_eff;
|
|
|
|
if (fgGetBool("/sim/rendering/horizon-effect")) {
|
2003-09-20 09:38:32 +00:00
|
|
|
sun_horiz_eff = 0.67+pow(0.5+cos(l->get_sun_angle())*2/2, 0.33)/3;
|
|
|
|
moon_horiz_eff = 0.67+pow(0.5+cos(l->get_moon_angle())*2/2, 0.33)/3;
|
2003-06-17 16:59:26 +00:00
|
|
|
} else {
|
|
|
|
sun_horiz_eff = moon_horiz_eff = 1.0;
|
|
|
|
}
|
2003-07-31 09:06:15 +00:00
|
|
|
|
|
|
|
static SGSkyState sstate;
|
|
|
|
|
|
|
|
sstate.view_pos = current__view->get_view_pos();
|
|
|
|
sstate.zero_elev = current__view->get_zero_elev();
|
|
|
|
sstate.view_up = current__view->get_world_up();
|
|
|
|
sstate.lon = current__view->getLongitude_deg()
|
|
|
|
* SGD_DEGREES_TO_RADIANS;
|
|
|
|
sstate.lat = current__view->getLatitude_deg()
|
|
|
|
* SGD_DEGREES_TO_RADIANS;
|
|
|
|
sstate.alt = current__view->getAltitudeASL_ft()
|
|
|
|
* SG_FEET_TO_METER;
|
2003-09-20 09:38:32 +00:00
|
|
|
sstate.spin = l->get_sun_rotation();
|
2003-07-31 09:06:15 +00:00
|
|
|
sstate.gst = globals->get_time_params()->getGst();
|
|
|
|
sstate.sun_ra = globals->get_ephem()->getSunRightAscension();
|
|
|
|
sstate.sun_dec = globals->get_ephem()->getSunDeclination();
|
|
|
|
sstate.sun_dist = 50000.0 * sun_horiz_eff;
|
|
|
|
sstate.moon_ra = globals->get_ephem()->getMoonRightAscension();
|
|
|
|
sstate.moon_dec = globals->get_ephem()->getMoonDeclination();
|
|
|
|
sstate.moon_dist = 40000.0 * moon_horiz_eff;
|
|
|
|
|
2003-07-31 14:47:56 +00:00
|
|
|
thesky->reposition( sstate, delta_time_sec );
|
2003-04-15 14:10:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
glEnable( GL_DEPTH_TEST );
|
|
|
|
if ( strcmp(fgGetString("/sim/rendering/fog"), "disabled") ) {
|
|
|
|
glEnable( GL_FOG );
|
|
|
|
glFogi( GL_FOG_MODE, GL_EXP2 );
|
2003-09-20 09:38:32 +00:00
|
|
|
glFogfv( GL_FOG_COLOR, l->adj_fog_color() );
|
2003-04-15 14:10:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// set sun/lighting parameters
|
2003-09-20 09:38:32 +00:00
|
|
|
ssgGetLight( 0 ) -> setPosition( l->sun_vec() );
|
2001-03-28 00:39:29 +00:00
|
|
|
|
|
|
|
// GL_LIGHT_MODEL_AMBIENT has a default non-zero value so if
|
2001-03-29 01:42:31 +00:00
|
|
|
// we only update GL_AMBIENT for our lights we will never get
|
|
|
|
// a completely dark scene. So, we set GL_LIGHT_MODEL_AMBIENT
|
|
|
|
// explicitely to black.
|
2003-04-15 14:10:47 +00:00
|
|
|
glLightModelfv( GL_LIGHT_MODEL_AMBIENT, black );
|
2001-03-28 00:39:29 +00:00
|
|
|
|
2003-09-20 09:38:32 +00:00
|
|
|
ssgGetLight( 0 ) -> setColour( GL_AMBIENT, l->scene_ambient() );
|
|
|
|
ssgGetLight( 0 ) -> setColour( GL_DIFFUSE, l->scene_diffuse() );
|
|
|
|
ssgGetLight( 0 ) -> setColour( GL_SPECULAR, l->scene_specular() );
|
1999-10-20 22:18:54 +00:00
|
|
|
|
2003-04-15 14:10:47 +00:00
|
|
|
// texture parameters
|
|
|
|
// glEnable( GL_TEXTURE_2D );
|
|
|
|
glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE ) ;
|
|
|
|
glHint( GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST ) ;
|
1999-06-18 03:42:54 +00:00
|
|
|
|
2003-04-15 14:10:47 +00:00
|
|
|
// glMatrixMode( GL_PROJECTION );
|
|
|
|
// glLoadIdentity();
|
|
|
|
ssgSetFOV( current__view->get_h_fov(),
|
2003-04-17 15:42:18 +00:00
|
|
|
current__view->get_v_fov() );
|
1999-06-29 14:57:00 +00:00
|
|
|
|
2003-04-15 14:10:47 +00:00
|
|
|
double agl =
|
2002-05-14 05:22:52 +00:00
|
|
|
current_aircraft.fdm_state->get_Altitude() * SG_FEET_TO_METER
|
2003-04-15 14:10:47 +00:00
|
|
|
- globals->get_scenery()->get_cur_elev();
|
2002-03-05 22:25:11 +00:00
|
|
|
|
2002-03-28 16:14:04 +00:00
|
|
|
if ( agl > 10.0 ) {
|
|
|
|
scene_nearplane = 10.0f;
|
|
|
|
scene_farplane = 120000.0f;
|
2003-04-15 14:10:47 +00:00
|
|
|
} else {
|
2002-04-18 16:51:47 +00:00
|
|
|
scene_nearplane = groundlevel_nearplane->getDoubleValue();
|
2002-03-28 16:14:04 +00:00
|
|
|
scene_farplane = 120000.0f;
|
|
|
|
}
|
|
|
|
|
|
|
|
ssgSetNearFar( scene_nearplane, scene_farplane );
|
1999-06-19 04:48:07 +00:00
|
|
|
|
2003-03-19 20:45:09 +00:00
|
|
|
#ifdef FG_MPLAYER_AS
|
|
|
|
// Update any multiplayer models
|
|
|
|
globals->get_multiplayer_rx_mgr()->Update();
|
|
|
|
#endif
|
|
|
|
|
2003-07-05 09:59:03 +00:00
|
|
|
if ( draw_otw && skyblend )
|
2003-03-29 03:21:48 +00:00
|
|
|
{
|
2003-04-15 14:10:47 +00:00
|
|
|
// draw the sky backdrop
|
2001-03-28 17:52:40 +00:00
|
|
|
|
|
|
|
// we need a white diffuse light for the phase of the moon
|
|
|
|
ssgGetLight( 0 ) -> setColour( GL_DIFFUSE, white );
|
|
|
|
|
2003-09-23 08:43:19 +00:00
|
|
|
thesky->preDraw( cur_fdm_state->get_Altitude() * SG_FEET_TO_METER, fog_exp2_density );
|
2001-03-28 17:52:40 +00:00
|
|
|
|
|
|
|
// return to the desired diffuse color
|
2003-09-20 09:38:32 +00:00
|
|
|
ssgGetLight( 0 ) -> setColour( GL_DIFFUSE, l->scene_diffuse() );
|
2003-04-15 14:10:47 +00:00
|
|
|
}
|
2000-06-20 02:29:31 +00:00
|
|
|
|
2003-04-15 14:10:47 +00:00
|
|
|
// draw the ssg scene
|
|
|
|
glEnable( GL_DEPTH_TEST );
|
2002-03-30 12:52:24 +00:00
|
|
|
|
2002-03-28 16:14:04 +00:00
|
|
|
ssgSetNearFar( scene_nearplane, scene_farplane );
|
2003-03-14 02:07:45 +00:00
|
|
|
|
|
|
|
if ( fgGetBool("/sim/rendering/wireframe") ) {
|
|
|
|
// draw wire frame
|
|
|
|
glPolygonMode( GL_FRONT_AND_BACK, GL_LINE );
|
|
|
|
}
|
2003-07-05 09:59:03 +00:00
|
|
|
if ( draw_otw ) {
|
2003-03-29 03:21:48 +00:00
|
|
|
ssgCullAndDraw( globals->get_scenery()->get_scene_graph() );
|
|
|
|
}
|
1999-06-18 03:42:54 +00:00
|
|
|
|
2003-04-15 14:10:47 +00:00
|
|
|
// This is a bit kludgy. Every 200 frames, do an extra
|
|
|
|
// traversal of the scene graph without drawing anything, but
|
|
|
|
// with the field-of-view set to 360x360 degrees. This
|
|
|
|
// ensures that out-of-range random objects that are not in
|
|
|
|
// the current view frustum will still be freed properly.
|
|
|
|
static int counter = 0;
|
|
|
|
counter++;
|
|
|
|
if (counter == 200) {
|
|
|
|
sgFrustum f;
|
|
|
|
f.setFOV(360, 360);
|
|
|
|
// No need to put the near plane too close;
|
|
|
|
// this way, at least the aircraft can be
|
|
|
|
// culled.
|
|
|
|
f.setNearFar(1000, 1000000);
|
|
|
|
sgMat4 m;
|
|
|
|
ssgGetModelviewMatrix(m);
|
|
|
|
globals->get_scenery()->get_scene_graph()->cull(&f, m, true);
|
|
|
|
counter = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
// change state for lighting here
|
|
|
|
|
|
|
|
// draw runway lighting
|
|
|
|
glFogf (GL_FOG_DENSITY, rwy_exp2_punch_through);
|
2002-10-17 04:34:32 +00:00
|
|
|
ssgSetNearFar( scene_nearplane, scene_farplane );
|
|
|
|
|
2003-07-05 09:59:03 +00:00
|
|
|
if ( enhanced_lighting ) {
|
2003-01-06 02:50:29 +00:00
|
|
|
|
2003-06-17 16:59:26 +00:00
|
|
|
// Enable states for drawing points with GL_extension
|
|
|
|
glEnable(GL_POINT_SMOOTH);
|
2003-01-06 02:50:29 +00:00
|
|
|
|
2003-07-05 09:59:03 +00:00
|
|
|
if ( distance_attenuation && glPointParameterIsSupported )
|
2003-06-17 16:59:26 +00:00
|
|
|
{
|
|
|
|
// Enable states for drawing points with GL_extension
|
|
|
|
glEnable(GL_POINT_SMOOTH);
|
|
|
|
|
|
|
|
float quadratic[3] = {1.0, 0.001, 0.0000001};
|
|
|
|
// makes the points fade as they move away
|
2003-06-18 09:19:41 +00:00
|
|
|
glPointParameterfvPtr(GL_DISTANCE_ATTENUATION_EXT, quadratic);
|
|
|
|
glPointParameterfPtr(GL_POINT_SIZE_MIN_EXT, 1.0);
|
2003-06-17 16:59:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
glPointSize(4.0);
|
|
|
|
|
|
|
|
// blending function for runway lights
|
|
|
|
glBlendFunc ( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA) ;
|
|
|
|
}
|
2001-09-19 22:58:29 +00:00
|
|
|
|
2002-10-06 03:53:19 +00:00
|
|
|
glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
|
|
|
|
glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
|
|
|
|
glEnable(GL_TEXTURE_GEN_S);
|
|
|
|
glEnable(GL_TEXTURE_GEN_T);
|
|
|
|
glPolygonMode(GL_FRONT, GL_POINT);
|
2002-11-01 21:56:48 +00:00
|
|
|
|
|
|
|
// draw runway lighting
|
2003-07-05 09:59:03 +00:00
|
|
|
if ( draw_otw ) {
|
2004-01-11 19:45:29 +00:00
|
|
|
ssgCullAndDraw( globals->get_scenery()->get_vasi_lights_root() );
|
2003-03-29 03:21:48 +00:00
|
|
|
ssgCullAndDraw( globals->get_scenery()->get_rwy_lights_root() );
|
|
|
|
}
|
2002-11-01 21:56:48 +00:00
|
|
|
|
|
|
|
// change punch through and then draw taxi lighting
|
2003-04-15 14:10:47 +00:00
|
|
|
glFogf ( GL_FOG_DENSITY, fog_exp2_density );
|
2002-12-12 01:24:48 +00:00
|
|
|
// sgVec3 taxi_fog;
|
|
|
|
// sgSetVec3( taxi_fog, 0.0, 0.0, 0.0 );
|
|
|
|
// glFogfv ( GL_FOG_COLOR, taxi_fog );
|
2003-07-05 09:59:03 +00:00
|
|
|
if ( draw_otw ) {
|
2003-03-29 03:21:48 +00:00
|
|
|
ssgCullAndDraw( globals->get_scenery()->get_taxi_lights_root() );
|
|
|
|
}
|
2002-11-01 21:56:48 +00:00
|
|
|
|
|
|
|
// clean up lighting
|
2002-10-06 03:53:19 +00:00
|
|
|
glPolygonMode(GL_FRONT, GL_FILL);
|
|
|
|
glDisable(GL_TEXTURE_GEN_S);
|
|
|
|
glDisable(GL_TEXTURE_GEN_T);
|
2000-12-04 05:26:40 +00:00
|
|
|
|
2003-04-15 14:10:47 +00:00
|
|
|
//static int _frame_count = 0;
|
|
|
|
//if (_frame_count % 30 == 0) {
|
|
|
|
// printf("SSG: %s\n", ssgShowStats());
|
|
|
|
//}
|
|
|
|
//else {
|
|
|
|
// ssgShowStats();
|
|
|
|
//}
|
|
|
|
//_frame_count++;
|
2002-09-10 19:43:33 +00:00
|
|
|
|
2002-03-30 12:52:24 +00:00
|
|
|
|
2003-07-05 09:59:03 +00:00
|
|
|
if ( enhanced_lighting ) {
|
|
|
|
if ( distance_attenuation && glPointParameterIsSupported )
|
2003-06-17 16:59:26 +00:00
|
|
|
{
|
2003-06-18 09:19:41 +00:00
|
|
|
glPointParameterfvPtr(GL_DISTANCE_ATTENUATION_EXT,
|
2003-06-17 16:59:26 +00:00
|
|
|
default_attenuation);
|
|
|
|
}
|
2001-09-19 22:58:29 +00:00
|
|
|
|
2003-06-17 16:59:26 +00:00
|
|
|
glPointSize(1.0);
|
|
|
|
glDisable(GL_POINT_SMOOTH);
|
|
|
|
}
|
2003-01-06 02:50:29 +00:00
|
|
|
|
2002-11-01 21:56:48 +00:00
|
|
|
// draw ground lighting
|
2003-04-15 14:10:47 +00:00
|
|
|
glFogf (GL_FOG_DENSITY, ground_exp2_punch_through);
|
2003-07-05 09:59:03 +00:00
|
|
|
if ( draw_otw ) {
|
2003-03-29 03:21:48 +00:00
|
|
|
ssgCullAndDraw( globals->get_scenery()->get_gnd_lights_root() );
|
|
|
|
}
|
2002-11-01 21:56:48 +00:00
|
|
|
|
2003-07-05 09:59:03 +00:00
|
|
|
if ( skyblend ) {
|
2003-04-15 14:10:47 +00:00
|
|
|
// draw the sky cloud layers
|
2003-07-05 09:59:03 +00:00
|
|
|
if ( draw_otw && fgGetBool("/environment/clouds/status") )
|
2003-03-29 03:21:48 +00:00
|
|
|
{
|
2002-09-13 20:38:15 +00:00
|
|
|
thesky->postDraw( cur_fdm_state->get_Altitude()
|
|
|
|
* SG_FEET_TO_METER );
|
|
|
|
}
|
2003-04-15 14:10:47 +00:00
|
|
|
}
|
1999-06-28 05:47:02 +00:00
|
|
|
|
2003-07-05 09:59:03 +00:00
|
|
|
if ( draw_otw && fgGetBool("/sim/rendering/clouds3d") )
|
2003-03-29 03:21:48 +00:00
|
|
|
{
|
2002-09-20 14:01:06 +00:00
|
|
|
glDisable( GL_FOG );
|
|
|
|
glDisable( GL_LIGHTING );
|
2002-09-19 01:27:49 +00:00
|
|
|
// cout << "drawing new clouds" << endl;
|
2002-10-04 15:19:07 +00:00
|
|
|
|
|
|
|
glEnable(GL_DEPTH_TEST);
|
|
|
|
glEnable(GL_BLEND);
|
|
|
|
glBlendFunc( GL_ONE, GL_ONE_MINUS_SRC_ALPHA ) ;
|
|
|
|
|
|
|
|
/*
|
|
|
|
glEnable( GL_TEXTURE_2D );
|
|
|
|
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
|
|
|
|
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
|
|
|
|
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
|
|
|
|
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
|
|
|
|
*/
|
|
|
|
|
2002-12-10 19:25:12 +00:00
|
|
|
#ifdef FG_USE_CLOUDS_3D
|
2002-09-19 01:27:49 +00:00
|
|
|
sgClouds3d->Draw((sgVec4 *)current__view->get_VIEW());
|
2002-12-10 19:25:12 +00:00
|
|
|
#endif
|
2002-09-23 22:05:36 +00:00
|
|
|
glEnable( GL_FOG );
|
|
|
|
glEnable( GL_LIGHTING );
|
|
|
|
glEnable( GL_DEPTH_TEST );
|
|
|
|
glBlendFunc ( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ) ;
|
2002-09-19 01:27:49 +00:00
|
|
|
}
|
|
|
|
|
2003-07-05 09:59:03 +00:00
|
|
|
if ( draw_otw ) {
|
2003-03-29 03:21:48 +00:00
|
|
|
globals->get_model_mgr()->draw();
|
|
|
|
globals->get_aircraft_model()->draw();
|
|
|
|
}
|
2002-09-20 15:30:54 +00:00
|
|
|
|
2003-04-15 14:10:47 +00:00
|
|
|
// display HUD && Panel
|
|
|
|
glDisable( GL_FOG );
|
|
|
|
glDisable( GL_DEPTH_TEST );
|
|
|
|
// glDisable( GL_CULL_FACE );
|
|
|
|
// glDisable( GL_TEXTURE_2D );
|
2001-01-11 22:44:18 +00:00
|
|
|
|
2003-04-15 14:10:47 +00:00
|
|
|
// update the controls subsystem
|
|
|
|
globals->get_controls()->update(delta_time_sec);
|
2001-01-11 22:44:18 +00:00
|
|
|
|
2003-04-15 14:10:47 +00:00
|
|
|
hud_and_panel->apply();
|
|
|
|
fgCockpitUpdate();
|
1999-06-28 05:47:02 +00:00
|
|
|
|
2003-04-15 14:10:47 +00:00
|
|
|
// Use the hud_and_panel ssgSimpleState for rendering the ATC output
|
|
|
|
// This only works properly if called before the panel call
|
|
|
|
if((fgGetBool("/sim/ATC/enabled")) || (fgGetBool("/sim/ai-traffic/enabled")))
|
|
|
|
globals->get_ATC_display()->update(delta_time_sec);
|
2001-11-07 17:55:28 +00:00
|
|
|
|
2003-04-15 14:10:47 +00:00
|
|
|
// update the panel subsystem
|
|
|
|
if ( globals->get_current_panel() != NULL ) {
|
|
|
|
globals->get_current_panel()->update(delta_time_sec);
|
|
|
|
}
|
Andy Ross:
The biggest and coolest patch adds mouse sensitivity to the 3D
cockpits, so we can finally work the radios. This ended up requiring
significant modifications outside of the 3D cockpit code. Stuff folks
will want to look at:
+ The list of all "3D" cockpits is stored statically in the
panelnode.cxx file. This is clumsy, and won't migrate well to a
multiple-aircraft feature. Really, there should be a per-model list
of 3D panels, but I couldn't find a clean place to put this. The
only handle you get back after parsing a model is a generic ssg
node, to which I obviously can't add panel-specific methods.
+ The aircraft model is parsed *very* early in the initialization
order. Earlier, in fact, than the static list of allowable command
bindings is built in fgInitCommands(). This is bad, as it means
that mouse bindings on the instruments can't work yet. I moved the
call to fgInitCommands, but someone should look carefully to see
that I picked the right place. There's a lot of initialization
code, and I got a little lost in there... :)
+ I added yet another "update" hook to the fgRenderFrame routine to
hook the updates for the 3D panels. This is only required for
"mouse press delay", and it's a fairly clumsy mechanism based on
frame rate instead of real time. There appears to be delay handling
already in place in the Input stuff, and there's a discussion going
on about different mouse behavior right now. Maybe this is a good
time to unify these two (now three) approaches?
2002-10-29 19:44:03 +00:00
|
|
|
fgUpdate3DPanels();
|
2001-01-11 22:44:18 +00:00
|
|
|
|
2003-04-15 14:10:47 +00:00
|
|
|
// We can do translucent menus, so why not. :-)
|
|
|
|
menus->apply();
|
|
|
|
glBlendFunc ( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ) ;
|
|
|
|
puDisplay();
|
|
|
|
// glDisable ( GL_BLEND ) ;
|
1999-06-28 05:47:02 +00:00
|
|
|
|
2002-09-18 14:57:20 +00:00
|
|
|
glEnable( GL_DEPTH_TEST );
|
|
|
|
glEnable( GL_FOG );
|
2002-03-12 16:30:27 +00:00
|
|
|
|
2002-11-17 01:21:13 +00:00
|
|
|
// Fade out the splash screen over the first three seconds.
|
|
|
|
double t = globals->get_sim_time_sec();
|
|
|
|
if ( t <= 1.0 ) {
|
|
|
|
fgSplashUpdate(0.0, 1.0);
|
|
|
|
} else if ( t <= 3.0) {
|
|
|
|
fgSplashUpdate(0.0, (3.0 - t) / 2.0);
|
|
|
|
}
|
1998-07-06 02:42:02 +00:00
|
|
|
}
|
1998-04-21 17:02:27 +00:00
|
|
|
|
2000-03-17 06:16:15 +00:00
|
|
|
glutSwapBuffers();
|
1998-04-21 17:02:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// Update internal time dependent calculations (i.e. flight model)
|
2002-05-11 21:10:11 +00:00
|
|
|
// FIXME: this distinction is obsolete; all subsystems now get delta
|
|
|
|
// time on update.
|
2001-01-17 02:37:12 +00:00
|
|
|
void fgUpdateTimeDepCalcs() {
|
2001-01-17 23:30:35 +00:00
|
|
|
static bool inited = false;
|
|
|
|
|
2003-07-18 14:14:24 +00:00
|
|
|
static const SGPropertyNode *replay_master
|
|
|
|
= fgGetNode( "/sim/freeze/replay", true );
|
2003-07-17 18:24:17 +00:00
|
|
|
static SGPropertyNode *replay_time
|
|
|
|
= fgGetNode( "/sim/replay/time", true );
|
|
|
|
static const SGPropertyNode *replay_end_time
|
|
|
|
= fgGetNode( "/sim/replay/end-time", true );
|
|
|
|
|
2002-02-17 21:05:27 +00:00
|
|
|
//SG_LOG(SG_FLIGHT,SG_INFO, "Updating time dep calcs()");
|
2001-10-28 16:16:30 +00:00
|
|
|
|
|
|
|
// Initialize the FDM here if it hasn't been and if we have a
|
|
|
|
// scenery elevation hit.
|
|
|
|
|
|
|
|
// cout << "cur_fdm_state->get_inited() = " << cur_fdm_state->get_inited()
|
|
|
|
// << " cur_elev = " << scenery.get_cur_elev() << endl;
|
|
|
|
|
2002-05-14 05:22:52 +00:00
|
|
|
if ( !cur_fdm_state->get_inited() &&
|
|
|
|
globals->get_scenery()->get_cur_elev() > -9990 )
|
|
|
|
{
|
2003-04-15 14:10:47 +00:00
|
|
|
SG_LOG(SG_FLIGHT,SG_INFO, "Finally initializing fdm");
|
|
|
|
cur_fdm_state->init();
|
|
|
|
if ( cur_fdm_state->get_bound() ) {
|
|
|
|
cur_fdm_state->unbind();
|
|
|
|
}
|
|
|
|
cur_fdm_state->bind();
|
2001-10-28 16:16:30 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// conceptually, the following block could be done for each fdm
|
|
|
|
// instance ...
|
2003-07-18 01:51:45 +00:00
|
|
|
if ( cur_fdm_state->get_inited() ) {
|
2003-04-15 14:10:47 +00:00
|
|
|
// we have been inited, and we are good to go ...
|
2001-01-17 23:30:35 +00:00
|
|
|
|
2003-04-15 14:10:47 +00:00
|
|
|
if ( !inited ) {
|
|
|
|
inited = true;
|
|
|
|
}
|
2001-01-17 23:30:35 +00:00
|
|
|
|
2003-07-18 14:14:24 +00:00
|
|
|
if ( ! replay_master->getBoolValue() ) {
|
2003-07-25 20:09:30 +00:00
|
|
|
cur_fdm_state->update( delta_time_sec );
|
2003-07-17 18:24:17 +00:00
|
|
|
} else {
|
|
|
|
FGReplay *r = (FGReplay *)(globals->get_subsystem( "replay" ));
|
|
|
|
r->replay( replay_time->getDoubleValue() );
|
|
|
|
replay_time->setDoubleValue( replay_time->getDoubleValue()
|
2003-07-25 20:09:30 +00:00
|
|
|
+ ( delta_time_sec
|
|
|
|
* fgGetInt("/sim/speed-up") ) );
|
2003-07-17 18:24:17 +00:00
|
|
|
}
|
2003-07-18 01:51:45 +00:00
|
|
|
} else {
|
|
|
|
// do nothing, fdm isn't inited yet
|
1999-09-09 00:16:28 +00:00
|
|
|
}
|
|
|
|
|
2004-02-27 16:48:27 +00:00
|
|
|
globals->get_model_mgr()->update(delta_time_sec);
|
|
|
|
globals->get_aircraft_model()->update(delta_time_sec);
|
|
|
|
|
|
|
|
// update the view angle
|
|
|
|
globals->get_viewmgr()->update(delta_time_sec);
|
|
|
|
|
2000-03-02 13:51:31 +00:00
|
|
|
// Update solar system
|
2000-07-08 05:09:24 +00:00
|
|
|
globals->get_ephem()->update( globals->get_time_params()->getMjd(),
|
2003-09-15 22:55:39 +00:00
|
|
|
globals->get_time_params()->getLst(),
|
|
|
|
cur_fdm_state->get_Latitude() );
|
2000-04-25 03:09:26 +00:00
|
|
|
|
|
|
|
// Update radio stack model
|
2002-05-11 16:28:50 +00:00
|
|
|
current_radiostack->update(delta_time_sec);
|
1998-04-21 17:02:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void fgInitTimeDepCalcs( void ) {
|
2002-04-05 00:38:55 +00:00
|
|
|
// noop for now
|
1998-04-21 17:02:27 +00:00
|
|
|
}
|
|
|
|
|
1999-09-01 20:24:54 +00:00
|
|
|
|
1998-08-27 17:01:55 +00:00
|
|
|
static const double alt_adjust_ft = 3.758099;
|
2001-03-24 04:56:46 +00:00
|
|
|
static const double alt_adjust_m = alt_adjust_ft * SG_FEET_TO_METER;
|
1998-04-21 17:02:27 +00:00
|
|
|
|
1999-09-01 20:24:54 +00:00
|
|
|
|
1998-04-24 00:49:17 +00:00
|
|
|
// What should we do when we have nothing else to do? Let's get ready
|
|
|
|
// for the next move and update the display?
|
1998-04-21 17:02:27 +00:00
|
|
|
static void fgMainLoop( void ) {
|
2003-07-05 09:59:03 +00:00
|
|
|
int model_hz = fgGetInt("/sim/model-hz");
|
2002-05-11 16:28:50 +00:00
|
|
|
|
2001-10-28 16:16:30 +00:00
|
|
|
static const SGPropertyNode *longitude
|
2003-04-15 14:10:47 +00:00
|
|
|
= fgGetNode("/position/longitude-deg");
|
2001-10-28 16:16:30 +00:00
|
|
|
static const SGPropertyNode *latitude
|
2003-04-15 14:10:47 +00:00
|
|
|
= fgGetNode("/position/latitude-deg");
|
2001-10-28 16:16:30 +00:00
|
|
|
static const SGPropertyNode *altitude
|
2003-04-15 14:10:47 +00:00
|
|
|
= fgGetNode("/position/altitude-ft");
|
2002-02-13 02:37:44 +00:00
|
|
|
static const SGPropertyNode *clock_freeze
|
2003-04-15 14:10:47 +00:00
|
|
|
= fgGetNode("/sim/freeze/clock", true);
|
2002-02-10 04:18:10 +00:00
|
|
|
static const SGPropertyNode *cur_time_override
|
2003-04-15 14:10:47 +00:00
|
|
|
= fgGetNode("/sim/time/cur-time-override", true);
|
2003-07-18 14:14:24 +00:00
|
|
|
static const SGPropertyNode *replay_master
|
|
|
|
= fgGetNode("/sim/freeze/replay", true);
|
2001-10-28 16:16:30 +00:00
|
|
|
|
2002-09-27 22:02:48 +00:00
|
|
|
// Update the elapsed time.
|
|
|
|
static bool first_time = true;
|
|
|
|
if ( first_time ) {
|
|
|
|
last_time_stamp.stamp();
|
|
|
|
first_time = false;
|
|
|
|
}
|
2003-06-02 16:35:36 +00:00
|
|
|
|
|
|
|
double throttle_hz = fgGetDouble("/sim/frame-rate-throttle-hz", 0.0);
|
|
|
|
if ( throttle_hz > 0.0 ) {
|
|
|
|
// simple frame rate throttle
|
|
|
|
double dt = 1000000.0 / throttle_hz;
|
|
|
|
current_time_stamp.stamp();
|
|
|
|
while ( current_time_stamp - last_time_stamp < dt ) {
|
|
|
|
current_time_stamp.stamp();
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
// run as fast as the app will go
|
|
|
|
current_time_stamp.stamp();
|
|
|
|
}
|
|
|
|
|
2003-11-21 23:35:25 +00:00
|
|
|
real_delta_time_sec
|
|
|
|
= double(current_time_stamp - last_time_stamp) / 1000000.0;
|
2003-06-02 16:35:36 +00:00
|
|
|
if ( clock_freeze->getBoolValue() ) {
|
2002-09-27 22:02:48 +00:00
|
|
|
delta_time_sec = 0;
|
2003-11-21 23:35:25 +00:00
|
|
|
} else {
|
|
|
|
delta_time_sec = real_delta_time_sec;
|
|
|
|
}
|
2002-09-27 22:02:48 +00:00
|
|
|
last_time_stamp = current_time_stamp;
|
|
|
|
globals->inc_sim_time_sec( delta_time_sec );
|
2003-05-13 03:18:42 +00:00
|
|
|
SGAnimation::set_sim_time_sec( globals->get_sim_time_sec() );
|
2002-09-27 22:02:48 +00:00
|
|
|
|
2003-12-19 02:42:32 +00:00
|
|
|
// These are useful, especially for Nasal scripts.
|
|
|
|
fgSetDouble("/sim/time/delta-realtime-sec", real_delta_time_sec);
|
|
|
|
fgSetDouble("/sim/time/delta-sec", delta_time_sec);
|
|
|
|
|
1999-01-09 13:37:32 +00:00
|
|
|
static long remainder = 0;
|
1999-10-23 00:09:26 +00:00
|
|
|
long elapsed;
|
1999-05-06 21:14:06 +00:00
|
|
|
#ifdef FANCY_FRAME_COUNTER
|
|
|
|
int i;
|
|
|
|
double accum;
|
|
|
|
#else
|
1998-12-18 23:40:55 +00:00
|
|
|
static time_t last_time = 0;
|
|
|
|
static int frames = 0;
|
1999-05-06 21:14:06 +00:00
|
|
|
#endif // FANCY_FRAME_COUNTER
|
1998-04-21 17:02:27 +00:00
|
|
|
|
2000-07-07 20:28:51 +00:00
|
|
|
SGTime *t = globals->get_time_params();
|
1998-04-21 17:02:27 +00:00
|
|
|
|
2003-09-24 17:20:55 +00:00
|
|
|
globals->get_event_mgr()->update(delta_time_sec);
|
|
|
|
|
2003-05-13 03:18:42 +00:00
|
|
|
SGLocation * acmodel_location = 0;
|
From: "Jim Wilson" <jimw@kelcomaine.com>
This is a new improved patch for the previous tile manager fixes.
Rather than building dependencies between FGlocation or the viewer or fdm with
tilemgr what I ended up doing was linking the pieces together in the Mainloop
in main.cxx. You'll see what I mean...it's been commented fairly well. More
than likely we should move that chunk somewhere...just not sure where yet.
The changes seem clean now. As I get more ideas there could be some further
improvement in organizing the update in tilemgr. You'll note that I left an
override in there for the tilemgr::update() function to preserve earlier
functionality if someone needs it (e.g. usage independent of an fdm or
viewer), not to mention there are a few places in flightgear that call it
directly that have not been changed to the new interface (and may not need to be).
The code has been optimized to avoid duplicate traversals and seems to run
generally quite well. Note that there can be a short delay reloading tiles
that have been dropped from static views. We could call the tile scheduler on
a view switch, but it's not a big deal and at the moment I'd like to get this
in so people can try it and comment on it as it is.
Everything has been resycned with CVS tonight and I've included the
description submitted earlier (below).
Best,
Jim
Changes synced with CVS approx 20:30EDT 2002-05-09 (after this evenings updates).
Files:
http://www.spiderbark.com/fgfs/viewer-update-20020516.tar.gz
or
http://www.spiderbark.com/fgfs/viewer-update-20020516.diffs.gz
Description:
In a nutshell, these patches begin to take what was one value for ground
elevation and calculate ground elevation values seperately for the FDM and the
viewer (eye position). Several outstanding view related bugs have been fixed.
With the introduction of the new viewer code a lot of that Flight Gear code
broke related to use of a global variable called "scenery.cur_elev".
Therefore the ground_elevation and other associated items (like the current
tile bucket) is maintained per FDM instance and per View. Each of these has a
"point" or location that can be identified. See changes to FGLocation class
and main.cxx.
Most of the problems related to the new viewer in terms of sky, ground and
runway lights, and tower views are fixed.
There are four minor problems remaining. 1) The sun/moon spins when you pan
the "lookat" tower view only (view #3). 2) Under stress (esp. magic carpet
full speed with max visibility), there is a memory leak in the tile caching
that was not introduced with these changes. 3) I have not tested these
changes or made corrections to the ADA or External FDM interfaces. 4) The
change view function doesn't call the time/light update (not a problem unless
a tower is very far away).
Details:
FDM/flight.cxx, flight.hxx - FGInterface ties to FGAircraftModel so that it's
location data can be accessed for runway (ground elevation under aircraft)
elevation.
FDM/larsim.cxx, larcsim.hxx - gets runway elevation from FGInterface now.
Commented out function that is causing a namespace conflict, hasn't been
called with recent code anyway.
FDM/JSBSim/JSBSim.cxx, YASim/YASim.cxx - gets runway elevation from
FGInterface now.
Scenery/newcache.cxx, newcache.hxx - changed caching scheme to time based
(oldest tiles discard).
Scenery/tileentry.cxx, tileentry.hxx - added place to record time, changed
rendering to reference viewer altitude in order to fix a problem with ground
and runway lights.
Scenery/tilemgr.cxx, tilemgr.hxx - Modified update() to accept values for
multiple locations. Refresh function added in order to periodically make
the tiles current for a non-moving view (like a tower).
Main/fg_init.cxx - register event for making tiles current in a non-moving
view (like a tower).
Main/location.hxx - added support for current ground elevation data.
Main/main.cxx - added second tilemgr call for fdm, fixed places where viewer
position data was required for correct sky rendering.
Main/options.cxx - fixed segfault reported by Curtis when using --view-offset
command line parameter.
Main/viewer.cxx, viewer.hxx - removed fudging of view position. Fixed numerous
bugs that were causing eye and target values to get mixed up.
2002-05-17 17:25:28 +00:00
|
|
|
if(cur_fdm_state->getACModel() != 0) {
|
2003-05-13 03:18:42 +00:00
|
|
|
acmodel_location = (SGLocation *) cur_fdm_state->getACModel()->get3DModel()->getSGLocation();
|
From: "Jim Wilson" <jimw@kelcomaine.com>
This is a new improved patch for the previous tile manager fixes.
Rather than building dependencies between FGlocation or the viewer or fdm with
tilemgr what I ended up doing was linking the pieces together in the Mainloop
in main.cxx. You'll see what I mean...it's been commented fairly well. More
than likely we should move that chunk somewhere...just not sure where yet.
The changes seem clean now. As I get more ideas there could be some further
improvement in organizing the update in tilemgr. You'll note that I left an
override in there for the tilemgr::update() function to preserve earlier
functionality if someone needs it (e.g. usage independent of an fdm or
viewer), not to mention there are a few places in flightgear that call it
directly that have not been changed to the new interface (and may not need to be).
The code has been optimized to avoid duplicate traversals and seems to run
generally quite well. Note that there can be a short delay reloading tiles
that have been dropped from static views. We could call the tile scheduler on
a view switch, but it's not a big deal and at the moment I'd like to get this
in so people can try it and comment on it as it is.
Everything has been resycned with CVS tonight and I've included the
description submitted earlier (below).
Best,
Jim
Changes synced with CVS approx 20:30EDT 2002-05-09 (after this evenings updates).
Files:
http://www.spiderbark.com/fgfs/viewer-update-20020516.tar.gz
or
http://www.spiderbark.com/fgfs/viewer-update-20020516.diffs.gz
Description:
In a nutshell, these patches begin to take what was one value for ground
elevation and calculate ground elevation values seperately for the FDM and the
viewer (eye position). Several outstanding view related bugs have been fixed.
With the introduction of the new viewer code a lot of that Flight Gear code
broke related to use of a global variable called "scenery.cur_elev".
Therefore the ground_elevation and other associated items (like the current
tile bucket) is maintained per FDM instance and per View. Each of these has a
"point" or location that can be identified. See changes to FGLocation class
and main.cxx.
Most of the problems related to the new viewer in terms of sky, ground and
runway lights, and tower views are fixed.
There are four minor problems remaining. 1) The sun/moon spins when you pan
the "lookat" tower view only (view #3). 2) Under stress (esp. magic carpet
full speed with max visibility), there is a memory leak in the tile caching
that was not introduced with these changes. 3) I have not tested these
changes or made corrections to the ADA or External FDM interfaces. 4) The
change view function doesn't call the time/light update (not a problem unless
a tower is very far away).
Details:
FDM/flight.cxx, flight.hxx - FGInterface ties to FGAircraftModel so that it's
location data can be accessed for runway (ground elevation under aircraft)
elevation.
FDM/larsim.cxx, larcsim.hxx - gets runway elevation from FGInterface now.
Commented out function that is causing a namespace conflict, hasn't been
called with recent code anyway.
FDM/JSBSim/JSBSim.cxx, YASim/YASim.cxx - gets runway elevation from
FGInterface now.
Scenery/newcache.cxx, newcache.hxx - changed caching scheme to time based
(oldest tiles discard).
Scenery/tileentry.cxx, tileentry.hxx - added place to record time, changed
rendering to reference viewer altitude in order to fix a problem with ground
and runway lights.
Scenery/tilemgr.cxx, tilemgr.hxx - Modified update() to accept values for
multiple locations. Refresh function added in order to periodically make
the tiles current for a non-moving view (like a tower).
Main/fg_init.cxx - register event for making tiles current in a non-moving
view (like a tower).
Main/location.hxx - added support for current ground elevation data.
Main/main.cxx - added second tilemgr call for fdm, fixed places where viewer
position data was required for correct sky rendering.
Main/options.cxx - fixed segfault reported by Curtis when using --view-offset
command line parameter.
Main/viewer.cxx, viewer.hxx - removed fudging of view position. Fixed numerous
bugs that were causing eye and target values to get mixed up.
2002-05-17 17:25:28 +00:00
|
|
|
}
|
|
|
|
|
2001-03-24 06:03:11 +00:00
|
|
|
SG_LOG( SG_ALL, SG_DEBUG, "Running Main Loop");
|
|
|
|
SG_LOG( SG_ALL, SG_DEBUG, "======= ==== ====");
|
1998-05-06 03:16:23 +00:00
|
|
|
|
1999-05-27 00:21:54 +00:00
|
|
|
#if defined( ENABLE_PLIB_JOYSTICK )
|
1998-12-18 23:40:55 +00:00
|
|
|
// Read joystick and update control settings
|
2001-06-04 21:08:06 +00:00
|
|
|
// if ( fgGetString("/sim/control-mode") == "joystick" )
|
|
|
|
// {
|
|
|
|
// fgJoystickRead();
|
|
|
|
// }
|
1998-12-18 23:40:55 +00:00
|
|
|
#elif defined( ENABLE_GLUT_JOYSTICK )
|
|
|
|
// Glut joystick support works by feeding a joystick handler
|
|
|
|
// function to glut. This is taken care of once in the joystick
|
|
|
|
// init routine and we don't have to worry about it again.
|
|
|
|
#endif
|
|
|
|
|
1998-07-12 03:14:42 +00:00
|
|
|
// Fix elevation. I'm just sticking this here for now, it should
|
|
|
|
// probably move eventually
|
|
|
|
|
1998-12-06 14:52:54 +00:00
|
|
|
/* printf("Before - ground = %.2f runway = %.2f alt = %.2f\n",
|
2003-04-15 14:10:47 +00:00
|
|
|
scenery.get_cur_elev(),
|
|
|
|
cur_fdm_state->get_Runway_altitude() * SG_FEET_TO_METER,
|
|
|
|
cur_fdm_state->get_Altitude() * SG_FEET_TO_METER); */
|
1998-07-12 03:14:42 +00:00
|
|
|
|
1998-12-06 14:52:54 +00:00
|
|
|
/* printf("Adjustment - ground = %.2f runway = %.2f alt = %.2f\n",
|
2003-04-15 14:10:47 +00:00
|
|
|
scenery.get_cur_elev(),
|
|
|
|
cur_fdm_state->get_Runway_altitude() * SG_FEET_TO_METER,
|
|
|
|
cur_fdm_state->get_Altitude() * SG_FEET_TO_METER); */
|
1998-07-12 03:14:42 +00:00
|
|
|
|
2001-07-02 16:44:02 +00:00
|
|
|
// cout << "Warp = " << globals->get_warp() << endl;
|
|
|
|
|
1998-04-21 17:02:27 +00:00
|
|
|
// update "time"
|
2002-02-13 02:37:44 +00:00
|
|
|
static bool last_clock_freeze = false;
|
|
|
|
|
|
|
|
if ( clock_freeze->getBoolValue() ) {
|
2003-04-15 14:10:47 +00:00
|
|
|
// clock freeze requested
|
|
|
|
if ( cur_time_override->getLongValue() == 0 ) {
|
|
|
|
fgSetLong( "/sim/time/cur-time-override", t->get_cur_time() );
|
|
|
|
globals->set_warp( 0 );
|
|
|
|
}
|
2002-02-13 02:37:44 +00:00
|
|
|
} else {
|
2003-04-15 14:10:47 +00:00
|
|
|
// no clock freeze requested
|
|
|
|
if ( last_clock_freeze == true ) {
|
|
|
|
// clock just unfroze, let's set warp as the difference
|
|
|
|
// between frozen time and current time so we don't get a
|
|
|
|
// time jump (and corresponding sky object and lighting
|
|
|
|
// jump.)
|
|
|
|
globals->set_warp( cur_time_override->getLongValue() - time(NULL) );
|
|
|
|
fgSetLong( "/sim/time/cur-time-override", 0 );
|
|
|
|
}
|
|
|
|
if ( globals->get_warp_delta() != 0 ) {
|
|
|
|
globals->inc_warp( globals->get_warp_delta() );
|
|
|
|
}
|
2000-07-07 17:27:37 +00:00
|
|
|
}
|
|
|
|
|
2002-02-13 02:37:44 +00:00
|
|
|
last_clock_freeze = clock_freeze->getBoolValue();
|
|
|
|
|
2001-10-28 16:16:30 +00:00
|
|
|
t->update( longitude->getDoubleValue() * SGD_DEGREES_TO_RADIANS,
|
2003-04-15 14:10:47 +00:00
|
|
|
latitude->getDoubleValue() * SGD_DEGREES_TO_RADIANS,
|
|
|
|
cur_time_override->getLongValue(),
|
|
|
|
globals->get_warp() );
|
1998-04-21 17:02:27 +00:00
|
|
|
|
2003-09-20 11:05:12 +00:00
|
|
|
if (globals->get_warp_delta() != 0) {
|
|
|
|
FGLight *l = (FGLight *)(globals->get_subsystem("lighting"));
|
|
|
|
l->update( 0.5 );
|
|
|
|
}
|
|
|
|
|
2000-07-05 02:39:30 +00:00
|
|
|
// update magvar model
|
2001-10-28 16:16:30 +00:00
|
|
|
globals->get_mag()->update( longitude->getDoubleValue()
|
2003-04-15 14:10:47 +00:00
|
|
|
* SGD_DEGREES_TO_RADIANS,
|
|
|
|
latitude->getDoubleValue()
|
|
|
|
* SGD_DEGREES_TO_RADIANS,
|
|
|
|
altitude->getDoubleValue() * SG_FEET_TO_METER,
|
|
|
|
globals->get_time_params()->getJD() );
|
2000-07-05 02:39:30 +00:00
|
|
|
|
1999-01-09 13:37:32 +00:00
|
|
|
// Get elapsed time (in usec) for this past frame
|
1998-04-21 17:02:27 +00:00
|
|
|
elapsed = fgGetTimeInterval();
|
2001-03-24 06:03:11 +00:00
|
|
|
SG_LOG( SG_ALL, SG_DEBUG,
|
2003-04-15 14:10:47 +00:00
|
|
|
"Elapsed time interval is = " << elapsed
|
|
|
|
<< ", previous remainder is = " << remainder );
|
1998-05-06 03:16:23 +00:00
|
|
|
|
|
|
|
// Calculate frame rate average
|
1999-05-06 21:14:06 +00:00
|
|
|
#ifdef FANCY_FRAME_COUNTER
|
|
|
|
/* old fps calculation */
|
|
|
|
if ( elapsed > 0 ) {
|
|
|
|
double tmp;
|
|
|
|
accum = 0.0;
|
|
|
|
for ( i = FG_FRAME_RATE_HISTORY - 2; i >= 0; i-- ) {
|
|
|
|
tmp = general.get_frame(i);
|
|
|
|
accum += tmp;
|
|
|
|
// printf("frame[%d] = %.2f\n", i, g->frames[i]);
|
|
|
|
general.set_frame(i+1,tmp);
|
|
|
|
}
|
|
|
|
tmp = 1000000.0 / (float)elapsed;
|
|
|
|
general.set_frame(0,tmp);
|
|
|
|
// printf("frame[0] = %.2f\n", general.frames[0]);
|
|
|
|
accum += tmp;
|
|
|
|
general.set_frame_rate(accum / (float)FG_FRAME_RATE_HISTORY);
|
|
|
|
// printf("ave = %.2f\n", general.frame_rate);
|
|
|
|
}
|
|
|
|
#else
|
1999-04-08 19:53:46 +00:00
|
|
|
if ( (t->get_cur_time() != last_time) && (last_time > 0) ) {
|
2003-04-15 14:10:47 +00:00
|
|
|
general.set_frame_rate( frames );
|
2003-03-29 03:21:48 +00:00
|
|
|
fgSetInt("/sim/frame-rate", frames);
|
2003-04-15 14:10:47 +00:00
|
|
|
SG_LOG( SG_ALL, SG_DEBUG,
|
|
|
|
"--> Frame rate is = " << general.get_frame_rate() );
|
|
|
|
frames = 0;
|
1998-12-18 23:40:55 +00:00
|
|
|
}
|
1999-04-08 19:53:46 +00:00
|
|
|
last_time = t->get_cur_time();
|
1998-12-18 23:40:55 +00:00
|
|
|
++frames;
|
1999-05-06 21:14:06 +00:00
|
|
|
#endif
|
1998-07-12 03:14:42 +00:00
|
|
|
|
2002-03-01 17:39:52 +00:00
|
|
|
// Run ATC subsystem
|
2003-04-01 13:42:10 +00:00
|
|
|
if (fgGetBool("/sim/ATC/enabled"))
|
|
|
|
globals->get_ATC_mgr()->update(delta_time_sec);
|
2002-04-03 23:54:44 +00:00
|
|
|
|
|
|
|
// Run the AI subsystem
|
2002-10-02 15:25:58 +00:00
|
|
|
if (fgGetBool("/sim/ai-traffic/enabled"))
|
|
|
|
globals->get_AI_mgr()->update(delta_time_sec);
|
2002-03-01 17:39:52 +00:00
|
|
|
|
1998-04-21 17:02:27 +00:00
|
|
|
// Run flight model
|
2001-01-16 21:41:28 +00:00
|
|
|
|
|
|
|
// Calculate model iterations needed for next frame
|
|
|
|
elapsed += remainder;
|
|
|
|
|
2003-07-05 09:59:03 +00:00
|
|
|
global_multi_loop = (long)(((double)elapsed * 0.000001) * model_hz );
|
|
|
|
remainder = elapsed - ( (global_multi_loop*1000000) / model_hz );
|
2001-03-24 06:03:11 +00:00
|
|
|
SG_LOG( SG_ALL, SG_DEBUG,
|
2003-04-15 14:10:47 +00:00
|
|
|
"Model iterations needed = " << global_multi_loop
|
|
|
|
<< ", new remainder = " << remainder );
|
|
|
|
|
2001-01-17 23:30:35 +00:00
|
|
|
// chop max interations to something reasonable if the sim was
|
|
|
|
// delayed for an excesive amount of time
|
2003-07-05 09:59:03 +00:00
|
|
|
if ( global_multi_loop > 2.0 * model_hz ) {
|
|
|
|
global_multi_loop = (int)(2.0 * model_hz );
|
2003-04-15 14:10:47 +00:00
|
|
|
remainder = 0;
|
2001-01-17 23:30:35 +00:00
|
|
|
}
|
|
|
|
|
2001-01-16 21:41:28 +00:00
|
|
|
// flight model
|
|
|
|
if ( global_multi_loop > 0 ) {
|
2003-04-15 14:10:47 +00:00
|
|
|
fgUpdateTimeDepCalcs();
|
2001-01-16 21:41:28 +00:00
|
|
|
} else {
|
2003-04-15 14:10:47 +00:00
|
|
|
SG_LOG( SG_ALL, SG_DEBUG,
|
|
|
|
"Elapsed time is zero ... we're zinging" );
|
1998-04-21 17:02:27 +00:00
|
|
|
}
|
|
|
|
|
1999-11-19 02:10:24 +00:00
|
|
|
// Do any I/O channel work that might need to be done
|
2003-11-21 23:35:25 +00:00
|
|
|
globals->get_io()->update( real_delta_time_sec );
|
1998-04-21 17:02:27 +00:00
|
|
|
|
2001-05-15 00:01:04 +00:00
|
|
|
// see if we need to load any deferred-load textures
|
2003-05-14 18:33:56 +00:00
|
|
|
globals->get_matlib()->load_next_deferred();
|
2001-05-15 00:01:04 +00:00
|
|
|
|
1998-06-01 17:54:40 +00:00
|
|
|
// Run audio scheduler
|
1998-07-16 17:33:34 +00:00
|
|
|
#ifdef ENABLE_AUDIO_SUPPORT
|
2002-02-27 15:13:58 +00:00
|
|
|
if ( fgGetBool("/sim/sound/audible")
|
|
|
|
&& globals->get_soundmgr()->is_working() ) {
|
2002-08-26 20:46:13 +00:00
|
|
|
globals->get_soundmgr()->update( delta_time_sec );
|
1998-07-27 18:41:23 +00:00
|
|
|
}
|
1998-06-03 00:47:11 +00:00
|
|
|
#endif
|
1998-06-01 17:54:40 +00:00
|
|
|
|
2002-10-03 21:20:56 +00:00
|
|
|
globals->get_subsystem_mgr()->update(delta_time_sec);
|
2002-09-23 19:55:10 +00:00
|
|
|
|
From: "Jim Wilson" <jimw@kelcomaine.com>
This is a new improved patch for the previous tile manager fixes.
Rather than building dependencies between FGlocation or the viewer or fdm with
tilemgr what I ended up doing was linking the pieces together in the Mainloop
in main.cxx. You'll see what I mean...it's been commented fairly well. More
than likely we should move that chunk somewhere...just not sure where yet.
The changes seem clean now. As I get more ideas there could be some further
improvement in organizing the update in tilemgr. You'll note that I left an
override in there for the tilemgr::update() function to preserve earlier
functionality if someone needs it (e.g. usage independent of an fdm or
viewer), not to mention there are a few places in flightgear that call it
directly that have not been changed to the new interface (and may not need to be).
The code has been optimized to avoid duplicate traversals and seems to run
generally quite well. Note that there can be a short delay reloading tiles
that have been dropped from static views. We could call the tile scheduler on
a view switch, but it's not a big deal and at the moment I'd like to get this
in so people can try it and comment on it as it is.
Everything has been resycned with CVS tonight and I've included the
description submitted earlier (below).
Best,
Jim
Changes synced with CVS approx 20:30EDT 2002-05-09 (after this evenings updates).
Files:
http://www.spiderbark.com/fgfs/viewer-update-20020516.tar.gz
or
http://www.spiderbark.com/fgfs/viewer-update-20020516.diffs.gz
Description:
In a nutshell, these patches begin to take what was one value for ground
elevation and calculate ground elevation values seperately for the FDM and the
viewer (eye position). Several outstanding view related bugs have been fixed.
With the introduction of the new viewer code a lot of that Flight Gear code
broke related to use of a global variable called "scenery.cur_elev".
Therefore the ground_elevation and other associated items (like the current
tile bucket) is maintained per FDM instance and per View. Each of these has a
"point" or location that can be identified. See changes to FGLocation class
and main.cxx.
Most of the problems related to the new viewer in terms of sky, ground and
runway lights, and tower views are fixed.
There are four minor problems remaining. 1) The sun/moon spins when you pan
the "lookat" tower view only (view #3). 2) Under stress (esp. magic carpet
full speed with max visibility), there is a memory leak in the tile caching
that was not introduced with these changes. 3) I have not tested these
changes or made corrections to the ADA or External FDM interfaces. 4) The
change view function doesn't call the time/light update (not a problem unless
a tower is very far away).
Details:
FDM/flight.cxx, flight.hxx - FGInterface ties to FGAircraftModel so that it's
location data can be accessed for runway (ground elevation under aircraft)
elevation.
FDM/larsim.cxx, larcsim.hxx - gets runway elevation from FGInterface now.
Commented out function that is causing a namespace conflict, hasn't been
called with recent code anyway.
FDM/JSBSim/JSBSim.cxx, YASim/YASim.cxx - gets runway elevation from
FGInterface now.
Scenery/newcache.cxx, newcache.hxx - changed caching scheme to time based
(oldest tiles discard).
Scenery/tileentry.cxx, tileentry.hxx - added place to record time, changed
rendering to reference viewer altitude in order to fix a problem with ground
and runway lights.
Scenery/tilemgr.cxx, tilemgr.hxx - Modified update() to accept values for
multiple locations. Refresh function added in order to periodically make
the tiles current for a non-moving view (like a tower).
Main/fg_init.cxx - register event for making tiles current in a non-moving
view (like a tower).
Main/location.hxx - added support for current ground elevation data.
Main/main.cxx - added second tilemgr call for fdm, fixed places where viewer
position data was required for correct sky rendering.
Main/options.cxx - fixed segfault reported by Curtis when using --view-offset
command line parameter.
Main/viewer.cxx, viewer.hxx - removed fudging of view position. Fixed numerous
bugs that were causing eye and target values to get mixed up.
2002-05-17 17:25:28 +00:00
|
|
|
//
|
|
|
|
// Tile Manager updates - see if we need to load any new scenery tiles.
|
|
|
|
// this code ties together the fdm, viewer and scenery classes...
|
|
|
|
// we may want to move this to it's own class at some point
|
|
|
|
//
|
2002-04-19 00:25:25 +00:00
|
|
|
double visibility_meters = fgGetDouble("/environment/visibility-m");
|
From: "Jim Wilson" <jimw@kelcomaine.com>
This is a new improved patch for the previous tile manager fixes.
Rather than building dependencies between FGlocation or the viewer or fdm with
tilemgr what I ended up doing was linking the pieces together in the Mainloop
in main.cxx. You'll see what I mean...it's been commented fairly well. More
than likely we should move that chunk somewhere...just not sure where yet.
The changes seem clean now. As I get more ideas there could be some further
improvement in organizing the update in tilemgr. You'll note that I left an
override in there for the tilemgr::update() function to preserve earlier
functionality if someone needs it (e.g. usage independent of an fdm or
viewer), not to mention there are a few places in flightgear that call it
directly that have not been changed to the new interface (and may not need to be).
The code has been optimized to avoid duplicate traversals and seems to run
generally quite well. Note that there can be a short delay reloading tiles
that have been dropped from static views. We could call the tile scheduler on
a view switch, but it's not a big deal and at the moment I'd like to get this
in so people can try it and comment on it as it is.
Everything has been resycned with CVS tonight and I've included the
description submitted earlier (below).
Best,
Jim
Changes synced with CVS approx 20:30EDT 2002-05-09 (after this evenings updates).
Files:
http://www.spiderbark.com/fgfs/viewer-update-20020516.tar.gz
or
http://www.spiderbark.com/fgfs/viewer-update-20020516.diffs.gz
Description:
In a nutshell, these patches begin to take what was one value for ground
elevation and calculate ground elevation values seperately for the FDM and the
viewer (eye position). Several outstanding view related bugs have been fixed.
With the introduction of the new viewer code a lot of that Flight Gear code
broke related to use of a global variable called "scenery.cur_elev".
Therefore the ground_elevation and other associated items (like the current
tile bucket) is maintained per FDM instance and per View. Each of these has a
"point" or location that can be identified. See changes to FGLocation class
and main.cxx.
Most of the problems related to the new viewer in terms of sky, ground and
runway lights, and tower views are fixed.
There are four minor problems remaining. 1) The sun/moon spins when you pan
the "lookat" tower view only (view #3). 2) Under stress (esp. magic carpet
full speed with max visibility), there is a memory leak in the tile caching
that was not introduced with these changes. 3) I have not tested these
changes or made corrections to the ADA or External FDM interfaces. 4) The
change view function doesn't call the time/light update (not a problem unless
a tower is very far away).
Details:
FDM/flight.cxx, flight.hxx - FGInterface ties to FGAircraftModel so that it's
location data can be accessed for runway (ground elevation under aircraft)
elevation.
FDM/larsim.cxx, larcsim.hxx - gets runway elevation from FGInterface now.
Commented out function that is causing a namespace conflict, hasn't been
called with recent code anyway.
FDM/JSBSim/JSBSim.cxx, YASim/YASim.cxx - gets runway elevation from
FGInterface now.
Scenery/newcache.cxx, newcache.hxx - changed caching scheme to time based
(oldest tiles discard).
Scenery/tileentry.cxx, tileentry.hxx - added place to record time, changed
rendering to reference viewer altitude in order to fix a problem with ground
and runway lights.
Scenery/tilemgr.cxx, tilemgr.hxx - Modified update() to accept values for
multiple locations. Refresh function added in order to periodically make
the tiles current for a non-moving view (like a tower).
Main/fg_init.cxx - register event for making tiles current in a non-moving
view (like a tower).
Main/location.hxx - added support for current ground elevation data.
Main/main.cxx - added second tilemgr call for fdm, fixed places where viewer
position data was required for correct sky rendering.
Main/options.cxx - fixed segfault reported by Curtis when using --view-offset
command line parameter.
Main/viewer.cxx, viewer.hxx - removed fudging of view position. Fixed numerous
bugs that were causing eye and target values to get mixed up.
2002-05-17 17:25:28 +00:00
|
|
|
FGViewer *current_view = globals->get_current_view();
|
|
|
|
|
|
|
|
// update tile manager for FDM...
|
|
|
|
// ...only if location is different than the viewer (to avoid duplicating effort)
|
2003-05-13 03:18:42 +00:00
|
|
|
if( acmodel_location != current_view->getSGLocation() ) {
|
From: "Jim Wilson" <jimw@kelcomaine.com>
This is a new improved patch for the previous tile manager fixes.
Rather than building dependencies between FGlocation or the viewer or fdm with
tilemgr what I ended up doing was linking the pieces together in the Mainloop
in main.cxx. You'll see what I mean...it's been commented fairly well. More
than likely we should move that chunk somewhere...just not sure where yet.
The changes seem clean now. As I get more ideas there could be some further
improvement in organizing the update in tilemgr. You'll note that I left an
override in there for the tilemgr::update() function to preserve earlier
functionality if someone needs it (e.g. usage independent of an fdm or
viewer), not to mention there are a few places in flightgear that call it
directly that have not been changed to the new interface (and may not need to be).
The code has been optimized to avoid duplicate traversals and seems to run
generally quite well. Note that there can be a short delay reloading tiles
that have been dropped from static views. We could call the tile scheduler on
a view switch, but it's not a big deal and at the moment I'd like to get this
in so people can try it and comment on it as it is.
Everything has been resycned with CVS tonight and I've included the
description submitted earlier (below).
Best,
Jim
Changes synced with CVS approx 20:30EDT 2002-05-09 (after this evenings updates).
Files:
http://www.spiderbark.com/fgfs/viewer-update-20020516.tar.gz
or
http://www.spiderbark.com/fgfs/viewer-update-20020516.diffs.gz
Description:
In a nutshell, these patches begin to take what was one value for ground
elevation and calculate ground elevation values seperately for the FDM and the
viewer (eye position). Several outstanding view related bugs have been fixed.
With the introduction of the new viewer code a lot of that Flight Gear code
broke related to use of a global variable called "scenery.cur_elev".
Therefore the ground_elevation and other associated items (like the current
tile bucket) is maintained per FDM instance and per View. Each of these has a
"point" or location that can be identified. See changes to FGLocation class
and main.cxx.
Most of the problems related to the new viewer in terms of sky, ground and
runway lights, and tower views are fixed.
There are four minor problems remaining. 1) The sun/moon spins when you pan
the "lookat" tower view only (view #3). 2) Under stress (esp. magic carpet
full speed with max visibility), there is a memory leak in the tile caching
that was not introduced with these changes. 3) I have not tested these
changes or made corrections to the ADA or External FDM interfaces. 4) The
change view function doesn't call the time/light update (not a problem unless
a tower is very far away).
Details:
FDM/flight.cxx, flight.hxx - FGInterface ties to FGAircraftModel so that it's
location data can be accessed for runway (ground elevation under aircraft)
elevation.
FDM/larsim.cxx, larcsim.hxx - gets runway elevation from FGInterface now.
Commented out function that is causing a namespace conflict, hasn't been
called with recent code anyway.
FDM/JSBSim/JSBSim.cxx, YASim/YASim.cxx - gets runway elevation from
FGInterface now.
Scenery/newcache.cxx, newcache.hxx - changed caching scheme to time based
(oldest tiles discard).
Scenery/tileentry.cxx, tileentry.hxx - added place to record time, changed
rendering to reference viewer altitude in order to fix a problem with ground
and runway lights.
Scenery/tilemgr.cxx, tilemgr.hxx - Modified update() to accept values for
multiple locations. Refresh function added in order to periodically make
the tiles current for a non-moving view (like a tower).
Main/fg_init.cxx - register event for making tiles current in a non-moving
view (like a tower).
Main/location.hxx - added support for current ground elevation data.
Main/main.cxx - added second tilemgr call for fdm, fixed places where viewer
position data was required for correct sky rendering.
Main/options.cxx - fixed segfault reported by Curtis when using --view-offset
command line parameter.
Main/viewer.cxx, viewer.hxx - removed fudging of view position. Fixed numerous
bugs that were causing eye and target values to get mixed up.
2002-05-17 17:25:28 +00:00
|
|
|
if( acmodel_location != 0 ) {
|
2002-12-06 22:29:46 +00:00
|
|
|
globals->get_tile_mgr()->prep_ssg_nodes( acmodel_location,
|
|
|
|
visibility_meters );
|
|
|
|
globals->get_tile_mgr()->
|
|
|
|
update( acmodel_location, visibility_meters,
|
2003-05-06 23:46:24 +00:00
|
|
|
acmodel_location->get_absolute_view_pos(globals->get_scenery()->get_center()) );
|
2003-05-13 03:18:42 +00:00
|
|
|
// save results of update in SGLocation for fdm...
|
From: "Jim Wilson" <jimw@kelcomaine.com>
This is a new improved patch for the previous tile manager fixes.
Rather than building dependencies between FGlocation or the viewer or fdm with
tilemgr what I ended up doing was linking the pieces together in the Mainloop
in main.cxx. You'll see what I mean...it's been commented fairly well. More
than likely we should move that chunk somewhere...just not sure where yet.
The changes seem clean now. As I get more ideas there could be some further
improvement in organizing the update in tilemgr. You'll note that I left an
override in there for the tilemgr::update() function to preserve earlier
functionality if someone needs it (e.g. usage independent of an fdm or
viewer), not to mention there are a few places in flightgear that call it
directly that have not been changed to the new interface (and may not need to be).
The code has been optimized to avoid duplicate traversals and seems to run
generally quite well. Note that there can be a short delay reloading tiles
that have been dropped from static views. We could call the tile scheduler on
a view switch, but it's not a big deal and at the moment I'd like to get this
in so people can try it and comment on it as it is.
Everything has been resycned with CVS tonight and I've included the
description submitted earlier (below).
Best,
Jim
Changes synced with CVS approx 20:30EDT 2002-05-09 (after this evenings updates).
Files:
http://www.spiderbark.com/fgfs/viewer-update-20020516.tar.gz
or
http://www.spiderbark.com/fgfs/viewer-update-20020516.diffs.gz
Description:
In a nutshell, these patches begin to take what was one value for ground
elevation and calculate ground elevation values seperately for the FDM and the
viewer (eye position). Several outstanding view related bugs have been fixed.
With the introduction of the new viewer code a lot of that Flight Gear code
broke related to use of a global variable called "scenery.cur_elev".
Therefore the ground_elevation and other associated items (like the current
tile bucket) is maintained per FDM instance and per View. Each of these has a
"point" or location that can be identified. See changes to FGLocation class
and main.cxx.
Most of the problems related to the new viewer in terms of sky, ground and
runway lights, and tower views are fixed.
There are four minor problems remaining. 1) The sun/moon spins when you pan
the "lookat" tower view only (view #3). 2) Under stress (esp. magic carpet
full speed with max visibility), there is a memory leak in the tile caching
that was not introduced with these changes. 3) I have not tested these
changes or made corrections to the ADA or External FDM interfaces. 4) The
change view function doesn't call the time/light update (not a problem unless
a tower is very far away).
Details:
FDM/flight.cxx, flight.hxx - FGInterface ties to FGAircraftModel so that it's
location data can be accessed for runway (ground elevation under aircraft)
elevation.
FDM/larsim.cxx, larcsim.hxx - gets runway elevation from FGInterface now.
Commented out function that is causing a namespace conflict, hasn't been
called with recent code anyway.
FDM/JSBSim/JSBSim.cxx, YASim/YASim.cxx - gets runway elevation from
FGInterface now.
Scenery/newcache.cxx, newcache.hxx - changed caching scheme to time based
(oldest tiles discard).
Scenery/tileentry.cxx, tileentry.hxx - added place to record time, changed
rendering to reference viewer altitude in order to fix a problem with ground
and runway lights.
Scenery/tilemgr.cxx, tilemgr.hxx - Modified update() to accept values for
multiple locations. Refresh function added in order to periodically make
the tiles current for a non-moving view (like a tower).
Main/fg_init.cxx - register event for making tiles current in a non-moving
view (like a tower).
Main/location.hxx - added support for current ground elevation data.
Main/main.cxx - added second tilemgr call for fdm, fixed places where viewer
position data was required for correct sky rendering.
Main/options.cxx - fixed segfault reported by Curtis when using --view-offset
command line parameter.
Main/viewer.cxx, viewer.hxx - removed fudging of view position. Fixed numerous
bugs that were causing eye and target values to get mixed up.
2002-05-17 17:25:28 +00:00
|
|
|
if ( globals->get_scenery()->get_cur_elev() > -9990 ) {
|
2002-12-06 22:29:46 +00:00
|
|
|
acmodel_location->
|
|
|
|
set_cur_elev_m( globals->get_scenery()->get_cur_elev() );
|
From: "Jim Wilson" <jimw@kelcomaine.com>
This is a new improved patch for the previous tile manager fixes.
Rather than building dependencies between FGlocation or the viewer or fdm with
tilemgr what I ended up doing was linking the pieces together in the Mainloop
in main.cxx. You'll see what I mean...it's been commented fairly well. More
than likely we should move that chunk somewhere...just not sure where yet.
The changes seem clean now. As I get more ideas there could be some further
improvement in organizing the update in tilemgr. You'll note that I left an
override in there for the tilemgr::update() function to preserve earlier
functionality if someone needs it (e.g. usage independent of an fdm or
viewer), not to mention there are a few places in flightgear that call it
directly that have not been changed to the new interface (and may not need to be).
The code has been optimized to avoid duplicate traversals and seems to run
generally quite well. Note that there can be a short delay reloading tiles
that have been dropped from static views. We could call the tile scheduler on
a view switch, but it's not a big deal and at the moment I'd like to get this
in so people can try it and comment on it as it is.
Everything has been resycned with CVS tonight and I've included the
description submitted earlier (below).
Best,
Jim
Changes synced with CVS approx 20:30EDT 2002-05-09 (after this evenings updates).
Files:
http://www.spiderbark.com/fgfs/viewer-update-20020516.tar.gz
or
http://www.spiderbark.com/fgfs/viewer-update-20020516.diffs.gz
Description:
In a nutshell, these patches begin to take what was one value for ground
elevation and calculate ground elevation values seperately for the FDM and the
viewer (eye position). Several outstanding view related bugs have been fixed.
With the introduction of the new viewer code a lot of that Flight Gear code
broke related to use of a global variable called "scenery.cur_elev".
Therefore the ground_elevation and other associated items (like the current
tile bucket) is maintained per FDM instance and per View. Each of these has a
"point" or location that can be identified. See changes to FGLocation class
and main.cxx.
Most of the problems related to the new viewer in terms of sky, ground and
runway lights, and tower views are fixed.
There are four minor problems remaining. 1) The sun/moon spins when you pan
the "lookat" tower view only (view #3). 2) Under stress (esp. magic carpet
full speed with max visibility), there is a memory leak in the tile caching
that was not introduced with these changes. 3) I have not tested these
changes or made corrections to the ADA or External FDM interfaces. 4) The
change view function doesn't call the time/light update (not a problem unless
a tower is very far away).
Details:
FDM/flight.cxx, flight.hxx - FGInterface ties to FGAircraftModel so that it's
location data can be accessed for runway (ground elevation under aircraft)
elevation.
FDM/larsim.cxx, larcsim.hxx - gets runway elevation from FGInterface now.
Commented out function that is causing a namespace conflict, hasn't been
called with recent code anyway.
FDM/JSBSim/JSBSim.cxx, YASim/YASim.cxx - gets runway elevation from
FGInterface now.
Scenery/newcache.cxx, newcache.hxx - changed caching scheme to time based
(oldest tiles discard).
Scenery/tileentry.cxx, tileentry.hxx - added place to record time, changed
rendering to reference viewer altitude in order to fix a problem with ground
and runway lights.
Scenery/tilemgr.cxx, tilemgr.hxx - Modified update() to accept values for
multiple locations. Refresh function added in order to periodically make
the tiles current for a non-moving view (like a tower).
Main/fg_init.cxx - register event for making tiles current in a non-moving
view (like a tower).
Main/location.hxx - added support for current ground elevation data.
Main/main.cxx - added second tilemgr call for fdm, fixed places where viewer
position data was required for correct sky rendering.
Main/options.cxx - fixed segfault reported by Curtis when using --view-offset
command line parameter.
Main/viewer.cxx, viewer.hxx - removed fudging of view position. Fixed numerous
bugs that were causing eye and target values to get mixed up.
2002-05-17 17:25:28 +00:00
|
|
|
}
|
2002-12-06 22:29:46 +00:00
|
|
|
acmodel_location->
|
|
|
|
set_tile_center( globals->get_scenery()->get_next_center() );
|
From: "Jim Wilson" <jimw@kelcomaine.com>
This is a new improved patch for the previous tile manager fixes.
Rather than building dependencies between FGlocation or the viewer or fdm with
tilemgr what I ended up doing was linking the pieces together in the Mainloop
in main.cxx. You'll see what I mean...it's been commented fairly well. More
than likely we should move that chunk somewhere...just not sure where yet.
The changes seem clean now. As I get more ideas there could be some further
improvement in organizing the update in tilemgr. You'll note that I left an
override in there for the tilemgr::update() function to preserve earlier
functionality if someone needs it (e.g. usage independent of an fdm or
viewer), not to mention there are a few places in flightgear that call it
directly that have not been changed to the new interface (and may not need to be).
The code has been optimized to avoid duplicate traversals and seems to run
generally quite well. Note that there can be a short delay reloading tiles
that have been dropped from static views. We could call the tile scheduler on
a view switch, but it's not a big deal and at the moment I'd like to get this
in so people can try it and comment on it as it is.
Everything has been resycned with CVS tonight and I've included the
description submitted earlier (below).
Best,
Jim
Changes synced with CVS approx 20:30EDT 2002-05-09 (after this evenings updates).
Files:
http://www.spiderbark.com/fgfs/viewer-update-20020516.tar.gz
or
http://www.spiderbark.com/fgfs/viewer-update-20020516.diffs.gz
Description:
In a nutshell, these patches begin to take what was one value for ground
elevation and calculate ground elevation values seperately for the FDM and the
viewer (eye position). Several outstanding view related bugs have been fixed.
With the introduction of the new viewer code a lot of that Flight Gear code
broke related to use of a global variable called "scenery.cur_elev".
Therefore the ground_elevation and other associated items (like the current
tile bucket) is maintained per FDM instance and per View. Each of these has a
"point" or location that can be identified. See changes to FGLocation class
and main.cxx.
Most of the problems related to the new viewer in terms of sky, ground and
runway lights, and tower views are fixed.
There are four minor problems remaining. 1) The sun/moon spins when you pan
the "lookat" tower view only (view #3). 2) Under stress (esp. magic carpet
full speed with max visibility), there is a memory leak in the tile caching
that was not introduced with these changes. 3) I have not tested these
changes or made corrections to the ADA or External FDM interfaces. 4) The
change view function doesn't call the time/light update (not a problem unless
a tower is very far away).
Details:
FDM/flight.cxx, flight.hxx - FGInterface ties to FGAircraftModel so that it's
location data can be accessed for runway (ground elevation under aircraft)
elevation.
FDM/larsim.cxx, larcsim.hxx - gets runway elevation from FGInterface now.
Commented out function that is causing a namespace conflict, hasn't been
called with recent code anyway.
FDM/JSBSim/JSBSim.cxx, YASim/YASim.cxx - gets runway elevation from
FGInterface now.
Scenery/newcache.cxx, newcache.hxx - changed caching scheme to time based
(oldest tiles discard).
Scenery/tileentry.cxx, tileentry.hxx - added place to record time, changed
rendering to reference viewer altitude in order to fix a problem with ground
and runway lights.
Scenery/tilemgr.cxx, tilemgr.hxx - Modified update() to accept values for
multiple locations. Refresh function added in order to periodically make
the tiles current for a non-moving view (like a tower).
Main/fg_init.cxx - register event for making tiles current in a non-moving
view (like a tower).
Main/location.hxx - added support for current ground elevation data.
Main/main.cxx - added second tilemgr call for fdm, fixed places where viewer
position data was required for correct sky rendering.
Main/options.cxx - fixed segfault reported by Curtis when using --view-offset
command line parameter.
Main/viewer.cxx, viewer.hxx - removed fudging of view position. Fixed numerous
bugs that were causing eye and target values to get mixed up.
2002-05-17 17:25:28 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2003-05-13 03:18:42 +00:00
|
|
|
globals->get_tile_mgr()->prep_ssg_nodes( current_view->getSGLocation(),
|
2002-12-06 22:29:46 +00:00
|
|
|
visibility_meters );
|
From: "Jim Wilson" <jimw@kelcomaine.com>
This is a new improved patch for the previous tile manager fixes.
Rather than building dependencies between FGlocation or the viewer or fdm with
tilemgr what I ended up doing was linking the pieces together in the Mainloop
in main.cxx. You'll see what I mean...it's been commented fairly well. More
than likely we should move that chunk somewhere...just not sure where yet.
The changes seem clean now. As I get more ideas there could be some further
improvement in organizing the update in tilemgr. You'll note that I left an
override in there for the tilemgr::update() function to preserve earlier
functionality if someone needs it (e.g. usage independent of an fdm or
viewer), not to mention there are a few places in flightgear that call it
directly that have not been changed to the new interface (and may not need to be).
The code has been optimized to avoid duplicate traversals and seems to run
generally quite well. Note that there can be a short delay reloading tiles
that have been dropped from static views. We could call the tile scheduler on
a view switch, but it's not a big deal and at the moment I'd like to get this
in so people can try it and comment on it as it is.
Everything has been resycned with CVS tonight and I've included the
description submitted earlier (below).
Best,
Jim
Changes synced with CVS approx 20:30EDT 2002-05-09 (after this evenings updates).
Files:
http://www.spiderbark.com/fgfs/viewer-update-20020516.tar.gz
or
http://www.spiderbark.com/fgfs/viewer-update-20020516.diffs.gz
Description:
In a nutshell, these patches begin to take what was one value for ground
elevation and calculate ground elevation values seperately for the FDM and the
viewer (eye position). Several outstanding view related bugs have been fixed.
With the introduction of the new viewer code a lot of that Flight Gear code
broke related to use of a global variable called "scenery.cur_elev".
Therefore the ground_elevation and other associated items (like the current
tile bucket) is maintained per FDM instance and per View. Each of these has a
"point" or location that can be identified. See changes to FGLocation class
and main.cxx.
Most of the problems related to the new viewer in terms of sky, ground and
runway lights, and tower views are fixed.
There are four minor problems remaining. 1) The sun/moon spins when you pan
the "lookat" tower view only (view #3). 2) Under stress (esp. magic carpet
full speed with max visibility), there is a memory leak in the tile caching
that was not introduced with these changes. 3) I have not tested these
changes or made corrections to the ADA or External FDM interfaces. 4) The
change view function doesn't call the time/light update (not a problem unless
a tower is very far away).
Details:
FDM/flight.cxx, flight.hxx - FGInterface ties to FGAircraftModel so that it's
location data can be accessed for runway (ground elevation under aircraft)
elevation.
FDM/larsim.cxx, larcsim.hxx - gets runway elevation from FGInterface now.
Commented out function that is causing a namespace conflict, hasn't been
called with recent code anyway.
FDM/JSBSim/JSBSim.cxx, YASim/YASim.cxx - gets runway elevation from
FGInterface now.
Scenery/newcache.cxx, newcache.hxx - changed caching scheme to time based
(oldest tiles discard).
Scenery/tileentry.cxx, tileentry.hxx - added place to record time, changed
rendering to reference viewer altitude in order to fix a problem with ground
and runway lights.
Scenery/tilemgr.cxx, tilemgr.hxx - Modified update() to accept values for
multiple locations. Refresh function added in order to periodically make
the tiles current for a non-moving view (like a tower).
Main/fg_init.cxx - register event for making tiles current in a non-moving
view (like a tower).
Main/location.hxx - added support for current ground elevation data.
Main/main.cxx - added second tilemgr call for fdm, fixed places where viewer
position data was required for correct sky rendering.
Main/options.cxx - fixed segfault reported by Curtis when using --view-offset
command line parameter.
Main/viewer.cxx, viewer.hxx - removed fudging of view position. Fixed numerous
bugs that were causing eye and target values to get mixed up.
2002-05-17 17:25:28 +00:00
|
|
|
// update tile manager for view...
|
|
|
|
// IMPORTANT!!! the tilemgr update for view location _must_ be done last
|
|
|
|
// after the FDM's until all of Flight Gear code references the viewer's location
|
|
|
|
// for elevation instead of the "scenery's" current elevation.
|
2003-05-13 03:18:42 +00:00
|
|
|
SGLocation *view_location = globals->get_current_view()->getSGLocation();
|
2002-12-06 22:29:46 +00:00
|
|
|
globals->get_tile_mgr()->update( view_location, visibility_meters,
|
|
|
|
current_view->get_absolute_view_pos() );
|
2003-05-13 03:18:42 +00:00
|
|
|
// save results of update in SGLocation for fdm...
|
From: "Jim Wilson" <jimw@kelcomaine.com>
This is a new improved patch for the previous tile manager fixes.
Rather than building dependencies between FGlocation or the viewer or fdm with
tilemgr what I ended up doing was linking the pieces together in the Mainloop
in main.cxx. You'll see what I mean...it's been commented fairly well. More
than likely we should move that chunk somewhere...just not sure where yet.
The changes seem clean now. As I get more ideas there could be some further
improvement in organizing the update in tilemgr. You'll note that I left an
override in there for the tilemgr::update() function to preserve earlier
functionality if someone needs it (e.g. usage independent of an fdm or
viewer), not to mention there are a few places in flightgear that call it
directly that have not been changed to the new interface (and may not need to be).
The code has been optimized to avoid duplicate traversals and seems to run
generally quite well. Note that there can be a short delay reloading tiles
that have been dropped from static views. We could call the tile scheduler on
a view switch, but it's not a big deal and at the moment I'd like to get this
in so people can try it and comment on it as it is.
Everything has been resycned with CVS tonight and I've included the
description submitted earlier (below).
Best,
Jim
Changes synced with CVS approx 20:30EDT 2002-05-09 (after this evenings updates).
Files:
http://www.spiderbark.com/fgfs/viewer-update-20020516.tar.gz
or
http://www.spiderbark.com/fgfs/viewer-update-20020516.diffs.gz
Description:
In a nutshell, these patches begin to take what was one value for ground
elevation and calculate ground elevation values seperately for the FDM and the
viewer (eye position). Several outstanding view related bugs have been fixed.
With the introduction of the new viewer code a lot of that Flight Gear code
broke related to use of a global variable called "scenery.cur_elev".
Therefore the ground_elevation and other associated items (like the current
tile bucket) is maintained per FDM instance and per View. Each of these has a
"point" or location that can be identified. See changes to FGLocation class
and main.cxx.
Most of the problems related to the new viewer in terms of sky, ground and
runway lights, and tower views are fixed.
There are four minor problems remaining. 1) The sun/moon spins when you pan
the "lookat" tower view only (view #3). 2) Under stress (esp. magic carpet
full speed with max visibility), there is a memory leak in the tile caching
that was not introduced with these changes. 3) I have not tested these
changes or made corrections to the ADA or External FDM interfaces. 4) The
change view function doesn't call the time/light update (not a problem unless
a tower is very far away).
Details:
FDM/flight.cxx, flight.hxx - FGInterface ties to FGAircraftModel so that it's
location data can be accessed for runway (ground elevation under aircraft)
elevation.
FDM/larsim.cxx, larcsim.hxx - gets runway elevation from FGInterface now.
Commented out function that is causing a namespace conflict, hasn't been
called with recent code anyway.
FDM/JSBSim/JSBSim.cxx, YASim/YASim.cxx - gets runway elevation from
FGInterface now.
Scenery/newcache.cxx, newcache.hxx - changed caching scheme to time based
(oldest tiles discard).
Scenery/tileentry.cxx, tileentry.hxx - added place to record time, changed
rendering to reference viewer altitude in order to fix a problem with ground
and runway lights.
Scenery/tilemgr.cxx, tilemgr.hxx - Modified update() to accept values for
multiple locations. Refresh function added in order to periodically make
the tiles current for a non-moving view (like a tower).
Main/fg_init.cxx - register event for making tiles current in a non-moving
view (like a tower).
Main/location.hxx - added support for current ground elevation data.
Main/main.cxx - added second tilemgr call for fdm, fixed places where viewer
position data was required for correct sky rendering.
Main/options.cxx - fixed segfault reported by Curtis when using --view-offset
command line parameter.
Main/viewer.cxx, viewer.hxx - removed fudging of view position. Fixed numerous
bugs that were causing eye and target values to get mixed up.
2002-05-17 17:25:28 +00:00
|
|
|
if ( globals->get_scenery()->get_cur_elev() > -9990 ) {
|
2003-05-13 03:18:42 +00:00
|
|
|
current_view->getSGLocation()->set_cur_elev_m( globals->get_scenery()->get_cur_elev() );
|
From: "Jim Wilson" <jimw@kelcomaine.com>
This is a new improved patch for the previous tile manager fixes.
Rather than building dependencies between FGlocation or the viewer or fdm with
tilemgr what I ended up doing was linking the pieces together in the Mainloop
in main.cxx. You'll see what I mean...it's been commented fairly well. More
than likely we should move that chunk somewhere...just not sure where yet.
The changes seem clean now. As I get more ideas there could be some further
improvement in organizing the update in tilemgr. You'll note that I left an
override in there for the tilemgr::update() function to preserve earlier
functionality if someone needs it (e.g. usage independent of an fdm or
viewer), not to mention there are a few places in flightgear that call it
directly that have not been changed to the new interface (and may not need to be).
The code has been optimized to avoid duplicate traversals and seems to run
generally quite well. Note that there can be a short delay reloading tiles
that have been dropped from static views. We could call the tile scheduler on
a view switch, but it's not a big deal and at the moment I'd like to get this
in so people can try it and comment on it as it is.
Everything has been resycned with CVS tonight and I've included the
description submitted earlier (below).
Best,
Jim
Changes synced with CVS approx 20:30EDT 2002-05-09 (after this evenings updates).
Files:
http://www.spiderbark.com/fgfs/viewer-update-20020516.tar.gz
or
http://www.spiderbark.com/fgfs/viewer-update-20020516.diffs.gz
Description:
In a nutshell, these patches begin to take what was one value for ground
elevation and calculate ground elevation values seperately for the FDM and the
viewer (eye position). Several outstanding view related bugs have been fixed.
With the introduction of the new viewer code a lot of that Flight Gear code
broke related to use of a global variable called "scenery.cur_elev".
Therefore the ground_elevation and other associated items (like the current
tile bucket) is maintained per FDM instance and per View. Each of these has a
"point" or location that can be identified. See changes to FGLocation class
and main.cxx.
Most of the problems related to the new viewer in terms of sky, ground and
runway lights, and tower views are fixed.
There are four minor problems remaining. 1) The sun/moon spins when you pan
the "lookat" tower view only (view #3). 2) Under stress (esp. magic carpet
full speed with max visibility), there is a memory leak in the tile caching
that was not introduced with these changes. 3) I have not tested these
changes or made corrections to the ADA or External FDM interfaces. 4) The
change view function doesn't call the time/light update (not a problem unless
a tower is very far away).
Details:
FDM/flight.cxx, flight.hxx - FGInterface ties to FGAircraftModel so that it's
location data can be accessed for runway (ground elevation under aircraft)
elevation.
FDM/larsim.cxx, larcsim.hxx - gets runway elevation from FGInterface now.
Commented out function that is causing a namespace conflict, hasn't been
called with recent code anyway.
FDM/JSBSim/JSBSim.cxx, YASim/YASim.cxx - gets runway elevation from
FGInterface now.
Scenery/newcache.cxx, newcache.hxx - changed caching scheme to time based
(oldest tiles discard).
Scenery/tileentry.cxx, tileentry.hxx - added place to record time, changed
rendering to reference viewer altitude in order to fix a problem with ground
and runway lights.
Scenery/tilemgr.cxx, tilemgr.hxx - Modified update() to accept values for
multiple locations. Refresh function added in order to periodically make
the tiles current for a non-moving view (like a tower).
Main/fg_init.cxx - register event for making tiles current in a non-moving
view (like a tower).
Main/location.hxx - added support for current ground elevation data.
Main/main.cxx - added second tilemgr call for fdm, fixed places where viewer
position data was required for correct sky rendering.
Main/options.cxx - fixed segfault reported by Curtis when using --view-offset
command line parameter.
Main/viewer.cxx, viewer.hxx - removed fudging of view position. Fixed numerous
bugs that were causing eye and target values to get mixed up.
2002-05-17 17:25:28 +00:00
|
|
|
}
|
2003-05-13 03:18:42 +00:00
|
|
|
current_view->getSGLocation()->set_tile_center( globals->get_scenery()->get_next_center() );
|
From: "Jim Wilson" <jimw@kelcomaine.com>
This is a new improved patch for the previous tile manager fixes.
Rather than building dependencies between FGlocation or the viewer or fdm with
tilemgr what I ended up doing was linking the pieces together in the Mainloop
in main.cxx. You'll see what I mean...it's been commented fairly well. More
than likely we should move that chunk somewhere...just not sure where yet.
The changes seem clean now. As I get more ideas there could be some further
improvement in organizing the update in tilemgr. You'll note that I left an
override in there for the tilemgr::update() function to preserve earlier
functionality if someone needs it (e.g. usage independent of an fdm or
viewer), not to mention there are a few places in flightgear that call it
directly that have not been changed to the new interface (and may not need to be).
The code has been optimized to avoid duplicate traversals and seems to run
generally quite well. Note that there can be a short delay reloading tiles
that have been dropped from static views. We could call the tile scheduler on
a view switch, but it's not a big deal and at the moment I'd like to get this
in so people can try it and comment on it as it is.
Everything has been resycned with CVS tonight and I've included the
description submitted earlier (below).
Best,
Jim
Changes synced with CVS approx 20:30EDT 2002-05-09 (after this evenings updates).
Files:
http://www.spiderbark.com/fgfs/viewer-update-20020516.tar.gz
or
http://www.spiderbark.com/fgfs/viewer-update-20020516.diffs.gz
Description:
In a nutshell, these patches begin to take what was one value for ground
elevation and calculate ground elevation values seperately for the FDM and the
viewer (eye position). Several outstanding view related bugs have been fixed.
With the introduction of the new viewer code a lot of that Flight Gear code
broke related to use of a global variable called "scenery.cur_elev".
Therefore the ground_elevation and other associated items (like the current
tile bucket) is maintained per FDM instance and per View. Each of these has a
"point" or location that can be identified. See changes to FGLocation class
and main.cxx.
Most of the problems related to the new viewer in terms of sky, ground and
runway lights, and tower views are fixed.
There are four minor problems remaining. 1) The sun/moon spins when you pan
the "lookat" tower view only (view #3). 2) Under stress (esp. magic carpet
full speed with max visibility), there is a memory leak in the tile caching
that was not introduced with these changes. 3) I have not tested these
changes or made corrections to the ADA or External FDM interfaces. 4) The
change view function doesn't call the time/light update (not a problem unless
a tower is very far away).
Details:
FDM/flight.cxx, flight.hxx - FGInterface ties to FGAircraftModel so that it's
location data can be accessed for runway (ground elevation under aircraft)
elevation.
FDM/larsim.cxx, larcsim.hxx - gets runway elevation from FGInterface now.
Commented out function that is causing a namespace conflict, hasn't been
called with recent code anyway.
FDM/JSBSim/JSBSim.cxx, YASim/YASim.cxx - gets runway elevation from
FGInterface now.
Scenery/newcache.cxx, newcache.hxx - changed caching scheme to time based
(oldest tiles discard).
Scenery/tileentry.cxx, tileentry.hxx - added place to record time, changed
rendering to reference viewer altitude in order to fix a problem with ground
and runway lights.
Scenery/tilemgr.cxx, tilemgr.hxx - Modified update() to accept values for
multiple locations. Refresh function added in order to periodically make
the tiles current for a non-moving view (like a tower).
Main/fg_init.cxx - register event for making tiles current in a non-moving
view (like a tower).
Main/location.hxx - added support for current ground elevation data.
Main/main.cxx - added second tilemgr call for fdm, fixed places where viewer
position data was required for correct sky rendering.
Main/options.cxx - fixed segfault reported by Curtis when using --view-offset
command line parameter.
Main/viewer.cxx, viewer.hxx - removed fudging of view position. Fixed numerous
bugs that were causing eye and target values to get mixed up.
2002-05-17 17:25:28 +00:00
|
|
|
|
|
|
|
// If fdm location is same as viewer's then we didn't do the update for fdm location
|
2003-05-13 03:18:42 +00:00
|
|
|
// above so we need to save the viewer results in the fdm SGLocation as well...
|
|
|
|
if( acmodel_location == current_view->getSGLocation() ) {
|
From: "Jim Wilson" <jimw@kelcomaine.com>
This is a new improved patch for the previous tile manager fixes.
Rather than building dependencies between FGlocation or the viewer or fdm with
tilemgr what I ended up doing was linking the pieces together in the Mainloop
in main.cxx. You'll see what I mean...it's been commented fairly well. More
than likely we should move that chunk somewhere...just not sure where yet.
The changes seem clean now. As I get more ideas there could be some further
improvement in organizing the update in tilemgr. You'll note that I left an
override in there for the tilemgr::update() function to preserve earlier
functionality if someone needs it (e.g. usage independent of an fdm or
viewer), not to mention there are a few places in flightgear that call it
directly that have not been changed to the new interface (and may not need to be).
The code has been optimized to avoid duplicate traversals and seems to run
generally quite well. Note that there can be a short delay reloading tiles
that have been dropped from static views. We could call the tile scheduler on
a view switch, but it's not a big deal and at the moment I'd like to get this
in so people can try it and comment on it as it is.
Everything has been resycned with CVS tonight and I've included the
description submitted earlier (below).
Best,
Jim
Changes synced with CVS approx 20:30EDT 2002-05-09 (after this evenings updates).
Files:
http://www.spiderbark.com/fgfs/viewer-update-20020516.tar.gz
or
http://www.spiderbark.com/fgfs/viewer-update-20020516.diffs.gz
Description:
In a nutshell, these patches begin to take what was one value for ground
elevation and calculate ground elevation values seperately for the FDM and the
viewer (eye position). Several outstanding view related bugs have been fixed.
With the introduction of the new viewer code a lot of that Flight Gear code
broke related to use of a global variable called "scenery.cur_elev".
Therefore the ground_elevation and other associated items (like the current
tile bucket) is maintained per FDM instance and per View. Each of these has a
"point" or location that can be identified. See changes to FGLocation class
and main.cxx.
Most of the problems related to the new viewer in terms of sky, ground and
runway lights, and tower views are fixed.
There are four minor problems remaining. 1) The sun/moon spins when you pan
the "lookat" tower view only (view #3). 2) Under stress (esp. magic carpet
full speed with max visibility), there is a memory leak in the tile caching
that was not introduced with these changes. 3) I have not tested these
changes or made corrections to the ADA or External FDM interfaces. 4) The
change view function doesn't call the time/light update (not a problem unless
a tower is very far away).
Details:
FDM/flight.cxx, flight.hxx - FGInterface ties to FGAircraftModel so that it's
location data can be accessed for runway (ground elevation under aircraft)
elevation.
FDM/larsim.cxx, larcsim.hxx - gets runway elevation from FGInterface now.
Commented out function that is causing a namespace conflict, hasn't been
called with recent code anyway.
FDM/JSBSim/JSBSim.cxx, YASim/YASim.cxx - gets runway elevation from
FGInterface now.
Scenery/newcache.cxx, newcache.hxx - changed caching scheme to time based
(oldest tiles discard).
Scenery/tileentry.cxx, tileentry.hxx - added place to record time, changed
rendering to reference viewer altitude in order to fix a problem with ground
and runway lights.
Scenery/tilemgr.cxx, tilemgr.hxx - Modified update() to accept values for
multiple locations. Refresh function added in order to periodically make
the tiles current for a non-moving view (like a tower).
Main/fg_init.cxx - register event for making tiles current in a non-moving
view (like a tower).
Main/location.hxx - added support for current ground elevation data.
Main/main.cxx - added second tilemgr call for fdm, fixed places where viewer
position data was required for correct sky rendering.
Main/options.cxx - fixed segfault reported by Curtis when using --view-offset
command line parameter.
Main/viewer.cxx, viewer.hxx - removed fudging of view position. Fixed numerous
bugs that were causing eye and target values to get mixed up.
2002-05-17 17:25:28 +00:00
|
|
|
if( acmodel_location != 0 ) {
|
|
|
|
if ( globals->get_scenery()->get_cur_elev() > -9990 ) {
|
|
|
|
acmodel_location->set_cur_elev_m( globals->get_scenery()->get_cur_elev() );
|
|
|
|
}
|
2002-05-20 16:13:37 +00:00
|
|
|
acmodel_location->set_tile_center( globals->get_scenery()->get_next_center() );
|
From: "Jim Wilson" <jimw@kelcomaine.com>
This is a new improved patch for the previous tile manager fixes.
Rather than building dependencies between FGlocation or the viewer or fdm with
tilemgr what I ended up doing was linking the pieces together in the Mainloop
in main.cxx. You'll see what I mean...it's been commented fairly well. More
than likely we should move that chunk somewhere...just not sure where yet.
The changes seem clean now. As I get more ideas there could be some further
improvement in organizing the update in tilemgr. You'll note that I left an
override in there for the tilemgr::update() function to preserve earlier
functionality if someone needs it (e.g. usage independent of an fdm or
viewer), not to mention there are a few places in flightgear that call it
directly that have not been changed to the new interface (and may not need to be).
The code has been optimized to avoid duplicate traversals and seems to run
generally quite well. Note that there can be a short delay reloading tiles
that have been dropped from static views. We could call the tile scheduler on
a view switch, but it's not a big deal and at the moment I'd like to get this
in so people can try it and comment on it as it is.
Everything has been resycned with CVS tonight and I've included the
description submitted earlier (below).
Best,
Jim
Changes synced with CVS approx 20:30EDT 2002-05-09 (after this evenings updates).
Files:
http://www.spiderbark.com/fgfs/viewer-update-20020516.tar.gz
or
http://www.spiderbark.com/fgfs/viewer-update-20020516.diffs.gz
Description:
In a nutshell, these patches begin to take what was one value for ground
elevation and calculate ground elevation values seperately for the FDM and the
viewer (eye position). Several outstanding view related bugs have been fixed.
With the introduction of the new viewer code a lot of that Flight Gear code
broke related to use of a global variable called "scenery.cur_elev".
Therefore the ground_elevation and other associated items (like the current
tile bucket) is maintained per FDM instance and per View. Each of these has a
"point" or location that can be identified. See changes to FGLocation class
and main.cxx.
Most of the problems related to the new viewer in terms of sky, ground and
runway lights, and tower views are fixed.
There are four minor problems remaining. 1) The sun/moon spins when you pan
the "lookat" tower view only (view #3). 2) Under stress (esp. magic carpet
full speed with max visibility), there is a memory leak in the tile caching
that was not introduced with these changes. 3) I have not tested these
changes or made corrections to the ADA or External FDM interfaces. 4) The
change view function doesn't call the time/light update (not a problem unless
a tower is very far away).
Details:
FDM/flight.cxx, flight.hxx - FGInterface ties to FGAircraftModel so that it's
location data can be accessed for runway (ground elevation under aircraft)
elevation.
FDM/larsim.cxx, larcsim.hxx - gets runway elevation from FGInterface now.
Commented out function that is causing a namespace conflict, hasn't been
called with recent code anyway.
FDM/JSBSim/JSBSim.cxx, YASim/YASim.cxx - gets runway elevation from
FGInterface now.
Scenery/newcache.cxx, newcache.hxx - changed caching scheme to time based
(oldest tiles discard).
Scenery/tileentry.cxx, tileentry.hxx - added place to record time, changed
rendering to reference viewer altitude in order to fix a problem with ground
and runway lights.
Scenery/tilemgr.cxx, tilemgr.hxx - Modified update() to accept values for
multiple locations. Refresh function added in order to periodically make
the tiles current for a non-moving view (like a tower).
Main/fg_init.cxx - register event for making tiles current in a non-moving
view (like a tower).
Main/location.hxx - added support for current ground elevation data.
Main/main.cxx - added second tilemgr call for fdm, fixed places where viewer
position data was required for correct sky rendering.
Main/options.cxx - fixed segfault reported by Curtis when using --view-offset
command line parameter.
Main/viewer.cxx, viewer.hxx - removed fudging of view position. Fixed numerous
bugs that were causing eye and target values to get mixed up.
2002-05-17 17:25:28 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// END Tile Manager udpates
|
|
|
|
|
2003-09-13 09:27:50 +00:00
|
|
|
if (fgGetBool("/sim/rendering/specular-highlight")) {
|
2003-11-09 15:07:23 +00:00
|
|
|
glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR);
|
|
|
|
// glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE);
|
2003-09-13 09:27:50 +00:00
|
|
|
} else {
|
|
|
|
glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SINGLE_COLOR);
|
2003-11-09 15:07:23 +00:00
|
|
|
// glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_FALSE);
|
2003-09-13 09:27:50 +00:00
|
|
|
}
|
|
|
|
|
2002-05-20 16:13:37 +00:00
|
|
|
// redraw display
|
|
|
|
fgRenderFrame();
|
2002-04-19 00:25:25 +00:00
|
|
|
|
2001-03-24 06:03:11 +00:00
|
|
|
SG_LOG( SG_ALL, SG_DEBUG, "" );
|
1998-04-21 17:02:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
1998-07-06 02:42:02 +00:00
|
|
|
// This is the top level master main function that is registered as
|
|
|
|
// our idle funciton
|
|
|
|
|
|
|
|
// The first few passes take care of initialization things (a couple
|
|
|
|
// per pass) and once everything has been initialized fgMainLoop from
|
|
|
|
// then on.
|
|
|
|
|
|
|
|
static void fgIdleFunction ( void ) {
|
|
|
|
// printf("idle state == %d\n", idle_state);
|
|
|
|
|
|
|
|
if ( idle_state == 0 ) {
|
2003-04-15 14:10:47 +00:00
|
|
|
// Initialize the splash screen right away
|
|
|
|
if ( fgGetBool("/sim/startup/splash-screen") ) {
|
2003-12-22 21:49:11 +00:00
|
|
|
fgSplashInit(fgGetString("/sim/startup/splash-texture"));
|
2003-04-15 14:10:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
idle_state++;
|
1998-07-06 02:42:02 +00:00
|
|
|
} else if ( idle_state == 1 ) {
|
2003-04-15 14:10:47 +00:00
|
|
|
// Initialize audio support
|
2001-07-11 06:01:55 +00:00
|
|
|
#ifdef ENABLE_AUDIO_SUPPORT
|
|
|
|
|
2003-04-15 14:10:47 +00:00
|
|
|
// Start the intro music
|
|
|
|
if ( fgGetBool("/sim/startup/intro-music") ) {
|
|
|
|
SGPath mp3file( globals->get_fg_root() );
|
|
|
|
mp3file.append( "Sounds/intro.mp3" );
|
1999-04-27 19:27:45 +00:00
|
|
|
|
2003-04-15 14:10:47 +00:00
|
|
|
SG_LOG( SG_GENERAL, SG_INFO,
|
|
|
|
"Starting intro music: " << mp3file.str() );
|
2001-07-11 06:01:55 +00:00
|
|
|
|
2002-02-05 05:04:02 +00:00
|
|
|
#if defined( __CYGWIN__ )
|
2003-04-15 14:10:47 +00:00
|
|
|
string command = "start /m `cygpath -w " + mp3file.str() + "`";
|
2002-02-05 05:04:02 +00:00
|
|
|
#elif defined( WIN32 )
|
2003-04-15 14:10:47 +00:00
|
|
|
string command = "start /m " + mp3file.str();
|
2002-02-05 05:04:02 +00:00
|
|
|
#else
|
2003-04-15 14:10:47 +00:00
|
|
|
string command = "mpg123 " + mp3file.str() + "> /dev/null 2>&1";
|
2002-02-05 05:04:02 +00:00
|
|
|
#endif
|
|
|
|
|
2003-04-15 14:10:47 +00:00
|
|
|
system ( command.c_str() );
|
|
|
|
}
|
1998-07-06 02:42:02 +00:00
|
|
|
#endif
|
|
|
|
|
2003-04-15 14:10:47 +00:00
|
|
|
idle_state++;
|
1998-07-06 02:42:02 +00:00
|
|
|
} else if ( idle_state == 2 ) {
|
2003-04-15 14:10:47 +00:00
|
|
|
// These are a few miscellaneous things that aren't really
|
|
|
|
// "subsystems" but still need to be initialized.
|
1998-07-27 18:41:23 +00:00
|
|
|
|
1998-07-06 02:42:02 +00:00
|
|
|
#ifdef USE_GLIDE
|
2003-04-15 14:10:47 +00:00
|
|
|
if ( strstr ( general.get_glRenderer(), "Glide" ) ) {
|
|
|
|
grTexLodBiasValue ( GR_TMU0, 1.0 ) ;
|
|
|
|
}
|
1998-07-06 02:42:02 +00:00
|
|
|
#endif
|
|
|
|
|
2003-04-15 14:10:47 +00:00
|
|
|
idle_state++;
|
1998-07-06 02:42:02 +00:00
|
|
|
} else if ( idle_state == 3 ) {
|
2003-04-15 14:10:47 +00:00
|
|
|
// This is the top level init routine which calls all the
|
|
|
|
// other subsystem initialization routines. If you are adding
|
|
|
|
// a subsystem to flightgear, its initialization call should
|
|
|
|
// located in this routine.
|
|
|
|
if( !fgInitSubsystems()) {
|
|
|
|
SG_LOG( SG_GENERAL, SG_ALERT,
|
|
|
|
"Subsystem initializations failed ..." );
|
|
|
|
exit(-1);
|
|
|
|
}
|
|
|
|
|
|
|
|
idle_state++;
|
1998-07-06 02:42:02 +00:00
|
|
|
} else if ( idle_state == 4 ) {
|
2003-09-15 22:55:39 +00:00
|
|
|
// Initialize the time offset (warp) after fgInitSubsystem
|
|
|
|
// (which initializes the lighting interpolation tables.)
|
|
|
|
fgInitTimeOffset();
|
|
|
|
|
2003-04-15 14:10:47 +00:00
|
|
|
// setup OpenGL view parameters
|
|
|
|
fgInitVisuals();
|
1998-07-06 02:42:02 +00:00
|
|
|
|
2003-03-29 15:04:52 +00:00
|
|
|
// Read the list of available aircrafts
|
|
|
|
fgReadAircraft();
|
|
|
|
|
2003-04-15 14:10:47 +00:00
|
|
|
idle_state++;
|
1998-07-06 02:42:02 +00:00
|
|
|
} else if ( idle_state == 5 ) {
|
|
|
|
|
2003-04-15 14:10:47 +00:00
|
|
|
idle_state++;
|
1998-07-06 02:42:02 +00:00
|
|
|
} else if ( idle_state == 6 ) {
|
2003-04-15 14:10:47 +00:00
|
|
|
// sleep(1);
|
2003-09-15 22:55:39 +00:00
|
|
|
|
2003-04-15 14:10:47 +00:00
|
|
|
idle_state = 1000;
|
2000-10-19 23:09:33 +00:00
|
|
|
|
2003-04-15 14:10:47 +00:00
|
|
|
SG_LOG( SG_GENERAL, SG_INFO, "Panel visible = " << fgPanelVisible() );
|
|
|
|
fgReshape( fgGetInt("/sim/startup/xsize"),
|
|
|
|
fgGetInt("/sim/startup/ysize") );
|
2003-09-17 10:02:36 +00:00
|
|
|
|
1998-07-06 02:42:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if ( idle_state == 1000 ) {
|
2003-04-15 14:10:47 +00:00
|
|
|
// We've finished all our initialization steps, from now on we
|
|
|
|
// run the main loop.
|
1998-07-06 02:42:02 +00:00
|
|
|
|
2003-04-15 14:10:47 +00:00
|
|
|
glutIdleFunc(fgMainLoop);
|
1998-07-06 02:42:02 +00:00
|
|
|
} else {
|
2003-04-15 14:10:47 +00:00
|
|
|
if ( fgGetBool("/sim/startup/splash-screen") ) {
|
|
|
|
fgSplashUpdate(0.0, 1.0);
|
|
|
|
}
|
1998-07-06 02:42:02 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1999-05-06 22:16:12 +00:00
|
|
|
// options.cxx needs to see this for toggle_panel()
|
1998-04-21 17:02:27 +00:00
|
|
|
// Handle new window size or exposure
|
1999-05-06 22:16:12 +00:00
|
|
|
void fgReshape( int width, int height ) {
|
2001-10-24 20:28:28 +00:00
|
|
|
int view_h;
|
|
|
|
|
Virtual cockpit patches from Andy Ross:
What the attached patch does is map your panel definition onto a (non
z-buffered) quad in front of your face. You can twist the view around
and see it move in the appropriate ways.
Apply the patch (let me know if folks need help with that step), and
then set the /sim/virtual-cockpit property to true. You can do this
on the command line with --prop:/sim/virtual-cockpit=1, or via the
property picker. Bind it to a key for fast toggling if you like.
The default bindings don't allow for "panning" the view, so you'll
have to modify yours. These are the mappings to my joystick's hat
switch, for those who need hints:
<axis n="6">
<desc>View Direction</desc>
<low>
<repeatable>true</repeatable>
<binding>
<command>property-adjust</command>
<property>/sim/view/goal-offset-deg</property>
<step type="double">1.0</step>
</binding>
</low>
<high>
<repeatable>true</repeatable>
<binding>
<command>property-adjust</command>
<property>/sim/view/goal-offset-deg</property>
<step type="double">-1.0</step>
</binding>
</high>
</axis>
<axis n="7">
<desc>View Elevation</desc>
<low>
<repeatable>true</repeatable>
<binding>
<command>property-adjust</command>
<property>/sim/view/goal-tilt-deg</property>
<step type="double">1.0</step>
</binding>
</low>
<high>
<repeatable>true</repeatable>
<binding>
<command>property-adjust</command>
<property>/sim/view/goal-tilt-deg</property>
<step type="double">-1.0</step>
</binding>
</high>
</axis>
While the current implementation is happy with just plastering the
panel's notion of "screen" into the 3D world, this is actually more
general. Each panel can, in principle, have it's own coordinate
system, and you could build a cockpit out of a bunch of them. The
mapping is specified by providing a 3D coordinate for three corners of
the quad the panel should be mapped to; this should be pretty simple
to work with.
All that's needed for a perfectly general solution is a convention on
where to store the information (a cockpit xml file, or put it in the
aircraft -set file, or...), and some work on the panel's coordinate
system conventions (some of which don't coexist very nicely with a
generalized 3D environment). Combine that with a plib model for the
non-panel interior of the cockpit, and we're golden.
I'm actually really pleased with this. It worked better and more
quickly than I could have imagined, and impact on the surrounding code
is quite light -- a few property tests only. But some stuff is still
missing:
+ No equivalent work was done to the HUD, so it still displays
incorrect headings when the view changes. The use of pixel
coordinates deep in the HUD code is going to give me fits doing the
port, I sure. It's not nearly so well put together as the panel
(where I just changed the setup code -- none of the rendering code
changed at all).
+ I forgot that the panel was clickable. :) Input events still have
the screen coordinates, which essentially kills the interactivity
when in virtual cockpit mode. This won't be hard to fix; it's only
broken because I forgot the feature existed.
And one note about the implementation choice: to get away from the
inevitable near clip plane issue, the virtual cockpit renderer simply
disables the z buffer. This means that cockpits built using these
panels need to be z-sorted, which isn't too hard since they are static
geometry. It also means that no two "virtual panels" can ever be
allowed to interpenetrate. No biggie.
2002-03-03 00:06:24 +00:00
|
|
|
if ( (!fgGetBool("/sim/virtual-cockpit"))
|
2003-04-15 14:10:47 +00:00
|
|
|
&& fgPanelVisible() && idle_state == 1000 ) {
|
|
|
|
view_h = (int)(height * (globals->get_current_panel()->getViewHeight() -
|
|
|
|
globals->get_current_panel()->getYOffset()) / 768.0);
|
2001-10-24 20:28:28 +00:00
|
|
|
} else {
|
2003-04-15 14:10:47 +00:00
|
|
|
view_h = height;
|
2001-10-24 20:28:28 +00:00
|
|
|
}
|
|
|
|
|
2000-11-01 23:27:32 +00:00
|
|
|
// for all views
|
2002-04-07 15:24:32 +00:00
|
|
|
FGViewMgr *viewmgr = globals->get_viewmgr();
|
|
|
|
for ( int i = 0; i < viewmgr->size(); ++i ) {
|
|
|
|
viewmgr->get_view(i)->
|
2003-04-15 14:10:47 +00:00
|
|
|
set_aspect_ratio((float)view_h / (float)width);
|
2000-11-01 23:27:32 +00:00
|
|
|
}
|
|
|
|
|
2001-10-24 20:28:28 +00:00
|
|
|
glViewport( 0, (GLint)(height - view_h), (GLint)(width), (GLint)(view_h) );
|
1998-04-21 17:02:27 +00:00
|
|
|
|
2001-01-13 22:06:39 +00:00
|
|
|
fgSetInt("/sim/startup/xsize", width);
|
|
|
|
fgSetInt("/sim/startup/ysize", height);
|
2002-02-05 20:54:08 +00:00
|
|
|
guiInitMouse(width, height);
|
1999-09-28 22:43:52 +00:00
|
|
|
|
2002-04-07 15:24:32 +00:00
|
|
|
ssgSetFOV( viewmgr->get_current_view()->get_h_fov(),
|
2003-04-15 14:10:47 +00:00
|
|
|
viewmgr->get_current_view()->get_v_fov() );
|
1999-08-31 23:22:05 +00:00
|
|
|
|
2000-05-13 00:02:43 +00:00
|
|
|
fgHUDReshape();
|
2002-12-10 19:25:12 +00:00
|
|
|
|
|
|
|
#ifdef FG_USE_CLOUDS_3D
|
2002-09-13 20:38:15 +00:00
|
|
|
sgClouds3d->Resize( viewmgr->get_current_view()->get_h_fov(),
|
|
|
|
viewmgr->get_current_view()->get_v_fov() );
|
2002-12-10 19:25:12 +00:00
|
|
|
#endif
|
|
|
|
|
1998-04-21 17:02:27 +00:00
|
|
|
}
|
|
|
|
|
1998-04-24 00:49:17 +00:00
|
|
|
// Initialize GLUT and define a main window
|
2002-11-16 20:17:11 +00:00
|
|
|
static bool fgGlutInit( int *argc, char **argv ) {
|
1999-06-02 22:22:47 +00:00
|
|
|
|
2000-09-10 00:04:50 +00:00
|
|
|
#if !defined( macintosh )
|
1998-04-24 00:49:17 +00:00
|
|
|
// GLUT will extract all glut specific options so later on we only
|
|
|
|
// need wory about our own.
|
2000-03-17 06:16:15 +00:00
|
|
|
glutInit(argc, argv);
|
1999-06-02 22:22:47 +00:00
|
|
|
#endif
|
1998-04-21 17:02:27 +00:00
|
|
|
|
2002-09-16 14:56:16 +00:00
|
|
|
// Define Display Parameters. Clouds3d works best with --bpp32 option
|
|
|
|
if ( fgGetBool("/sim/rendering/clouds3d") ) {
|
|
|
|
glutInitDisplayMode( GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE | GLUT_ALPHA );
|
|
|
|
} else {
|
|
|
|
glutInitDisplayMode( GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE );
|
|
|
|
}
|
1998-04-21 17:02:27 +00:00
|
|
|
|
2001-03-24 06:03:11 +00:00
|
|
|
SG_LOG( SG_GENERAL, SG_INFO, "Opening a window: " <<
|
2003-04-15 14:10:47 +00:00
|
|
|
fgGetInt("/sim/startup/xsize") << "x"
|
|
|
|
<< fgGetInt("/sim/startup/ysize") );
|
1998-11-16 13:59:58 +00:00
|
|
|
|
1998-04-21 17:02:27 +00:00
|
|
|
// Define initial window size
|
2001-01-13 22:06:39 +00:00
|
|
|
glutInitWindowSize( fgGetInt("/sim/startup/xsize"),
|
2003-04-15 14:10:47 +00:00
|
|
|
fgGetInt("/sim/startup/ysize") );
|
1998-04-21 17:02:27 +00:00
|
|
|
|
|
|
|
// Initialize windows
|
2001-01-13 22:06:39 +00:00
|
|
|
if ( !fgGetBool("/sim/startup/game-mode")) {
|
2003-04-15 14:10:47 +00:00
|
|
|
// Open the regular window
|
|
|
|
glutCreateWindow("FlightGear");
|
1999-04-27 19:27:45 +00:00
|
|
|
#ifndef GLUT_WRONG_VERSION
|
1998-08-20 15:10:33 +00:00
|
|
|
} else {
|
2003-04-15 14:10:47 +00:00
|
|
|
// Open the cool new 'game mode' window
|
|
|
|
char game_mode_str[256];
|
2002-04-07 15:24:32 +00:00
|
|
|
//#define SYNC_OPENGL_WITH_DESKTOP_SETTINGS
|
|
|
|
#if defined(WIN32) && defined(SYNC_OPENGL_WITH_DESKTOP_SETTINGS)
|
|
|
|
#ifndef ENUM_CURRENT_SETTINGS
|
|
|
|
#define ENUM_CURRENT_SETTINGS ((DWORD)-1)
|
|
|
|
#define ENUM_REGISTRY_SETTINGS ((DWORD)-2)
|
|
|
|
#endif
|
|
|
|
|
2003-04-15 14:10:47 +00:00
|
|
|
DEVMODE dm;
|
|
|
|
dm.dmSize = sizeof(DEVMODE);
|
|
|
|
EnumDisplaySettings(NULL, ENUM_CURRENT_SETTINGS, &dm);
|
|
|
|
fgSetInt("/sim/startup/xsize", dm.dmPelsWidth);
|
|
|
|
fgSetInt("/sim/startup/ysize", dm.dmPelsHeight);
|
|
|
|
glutInitWindowSize( fgGetInt("/sim/startup/xsize"),
|
|
|
|
fgGetInt("/sim/startup/ysize") );
|
|
|
|
sprintf( game_mode_str, "%dx%d:%d@%d",
|
|
|
|
dm.dmPelsWidth,
|
|
|
|
dm.dmPelsHeight,
|
|
|
|
dm.dmBitsPerPel,
|
|
|
|
dm.dmDisplayFrequency );
|
2002-04-07 15:24:32 +00:00
|
|
|
#else
|
2003-04-15 14:10:47 +00:00
|
|
|
// Open the cool new 'game mode' window
|
|
|
|
sprintf( game_mode_str, "width=%d height=%d bpp=%d",
|
|
|
|
fgGetInt("/sim/startup/xsize"),
|
|
|
|
fgGetInt("/sim/startup/ysize"),
|
|
|
|
fgGetInt("/sim/rendering/bits-per-pixel"));
|
1999-01-27 04:49:17 +00:00
|
|
|
|
2002-04-07 15:24:32 +00:00
|
|
|
#endif // HAVE_WINDOWS_H
|
2003-04-15 14:10:47 +00:00
|
|
|
SG_LOG( SG_GENERAL, SG_INFO,
|
|
|
|
"game mode params = " << game_mode_str );
|
|
|
|
glutGameModeString( game_mode_str );
|
|
|
|
glutEnterGameMode();
|
2002-04-07 15:24:32 +00:00
|
|
|
#endif // GLUT_WRONG_VERSION
|
1998-08-20 15:10:33 +00:00
|
|
|
}
|
1998-04-21 17:02:27 +00:00
|
|
|
|
1998-11-23 20:51:26 +00:00
|
|
|
// This seems to be the absolute earliest in the init sequence
|
|
|
|
// that these calls will return valid info. Too bad it's after
|
|
|
|
// we've already created and sized out window. :-(
|
1999-01-07 20:24:43 +00:00
|
|
|
general.set_glVendor( (char *)glGetString ( GL_VENDOR ) );
|
|
|
|
general.set_glRenderer( (char *)glGetString ( GL_RENDERER ) );
|
|
|
|
general.set_glVersion( (char *)glGetString ( GL_VERSION ) );
|
2001-03-24 06:03:11 +00:00
|
|
|
SG_LOG( SG_GENERAL, SG_INFO, general.get_glRenderer() );
|
2000-12-05 14:27:27 +00:00
|
|
|
|
2000-12-13 23:02:02 +00:00
|
|
|
GLint tmp;
|
2000-09-18 21:02:59 +00:00
|
|
|
glGetIntegerv( GL_MAX_TEXTURE_SIZE, &tmp );
|
|
|
|
general.set_glMaxTexSize( tmp );
|
2001-03-24 06:03:11 +00:00
|
|
|
SG_LOG ( SG_GENERAL, SG_INFO, "Max texture size = " << tmp );
|
1998-11-23 20:51:26 +00:00
|
|
|
|
2000-12-05 14:27:27 +00:00
|
|
|
glGetIntegerv( GL_DEPTH_BITS, &tmp );
|
|
|
|
general.set_glDepthBits( tmp );
|
2001-03-24 06:03:11 +00:00
|
|
|
SG_LOG ( SG_GENERAL, SG_INFO, "Depth buffer bits = " << tmp );
|
2000-12-05 14:27:27 +00:00
|
|
|
|
2002-11-16 20:17:11 +00:00
|
|
|
return true;
|
1998-04-24 00:49:17 +00:00
|
|
|
}
|
1998-04-21 17:02:27 +00:00
|
|
|
|
|
|
|
|
1998-04-24 00:49:17 +00:00
|
|
|
// Initialize GLUT event handlers
|
2002-11-16 20:17:11 +00:00
|
|
|
static bool fgGlutInitEvents( void ) {
|
1998-04-24 00:49:17 +00:00
|
|
|
// call fgReshape() on window resizes
|
2000-03-17 06:16:15 +00:00
|
|
|
glutReshapeFunc( fgReshape );
|
1998-04-21 17:02:27 +00:00
|
|
|
|
2002-03-26 13:45:44 +00:00
|
|
|
// keyboard and mouse callbacks are set in FGInput::init
|
|
|
|
|
1998-04-24 00:49:17 +00:00
|
|
|
// call fgMainLoop() whenever there is
|
|
|
|
// nothing else to do
|
2000-03-17 06:16:15 +00:00
|
|
|
glutIdleFunc( fgIdleFunction );
|
1998-04-21 17:02:27 +00:00
|
|
|
|
1998-04-24 00:49:17 +00:00
|
|
|
// draw the scene
|
2000-03-17 06:16:15 +00:00
|
|
|
glutDisplayFunc( fgRenderFrame );
|
1998-04-21 17:02:27 +00:00
|
|
|
|
2002-11-16 20:17:11 +00:00
|
|
|
return true;
|
1998-04-24 00:49:17 +00:00
|
|
|
}
|
1998-04-21 17:02:27 +00:00
|
|
|
|
2002-11-16 20:17:11 +00:00
|
|
|
// Main top level initialization
|
2003-08-17 09:54:41 +00:00
|
|
|
bool fgMainInit( int argc, char **argv ) {
|
2001-10-29 04:39:54 +00:00
|
|
|
|
2000-09-10 00:04:50 +00:00
|
|
|
#if defined( macintosh )
|
2000-04-27 21:57:08 +00:00
|
|
|
freopen ("stdout.txt", "w", stdout );
|
|
|
|
freopen ("stderr.txt", "w", stderr );
|
1999-06-02 22:22:47 +00:00
|
|
|
argc = ccommand( &argv );
|
1999-04-27 19:27:45 +00:00
|
|
|
#endif
|
|
|
|
|
1998-11-16 13:59:58 +00:00
|
|
|
// set default log levels
|
2003-11-24 17:46:38 +00:00
|
|
|
sglog().setLogLevels( SG_ALL, SG_ALERT );
|
1998-11-16 13:59:58 +00:00
|
|
|
|
2001-01-11 05:04:17 +00:00
|
|
|
string version;
|
|
|
|
#ifdef FLIGHTGEAR_VERSION
|
|
|
|
version = FLIGHTGEAR_VERSION;
|
|
|
|
#else
|
|
|
|
version = "unknown version";
|
|
|
|
#endif
|
2001-03-24 06:03:11 +00:00
|
|
|
SG_LOG( SG_GENERAL, SG_INFO, "FlightGear: Version "
|
2003-04-15 14:10:47 +00:00
|
|
|
<< version );
|
2002-05-17 16:41:27 +00:00
|
|
|
SG_LOG( SG_GENERAL, SG_INFO, "Built with " << SG_COMPILER_STR << endl );
|
1998-11-20 01:02:35 +00:00
|
|
|
|
2000-10-19 23:09:33 +00:00
|
|
|
// Allocate global data structures. This needs to happen before
|
|
|
|
// we parse command line options
|
2001-01-12 15:37:40 +00:00
|
|
|
|
2000-10-19 21:24:43 +00:00
|
|
|
globals = new FGGlobals;
|
|
|
|
|
2001-01-13 22:06:39 +00:00
|
|
|
// seed the random number generater
|
|
|
|
sg_srandom_time();
|
|
|
|
|
2001-07-22 19:51:16 +00:00
|
|
|
FGControls *controls = new FGControls;
|
|
|
|
globals->set_controls( controls );
|
|
|
|
|
2001-01-26 00:21:36 +00:00
|
|
|
string_list *col = new string_list;
|
|
|
|
globals->set_channel_options_list( col );
|
|
|
|
|
2000-10-04 22:52:34 +00:00
|
|
|
// Scan the config file(s) and command line options to see if
|
|
|
|
// fg_root was specified (ignore all other options for now)
|
|
|
|
fgInitFGRoot(argc, argv);
|
2000-09-25 21:41:50 +00:00
|
|
|
|
2001-07-16 19:17:58 +00:00
|
|
|
// Check for the correct base package version
|
2003-10-24 17:06:39 +00:00
|
|
|
static char required_version[] = "0.9.3";
|
2001-07-16 19:17:58 +00:00
|
|
|
string base_version = fgBasePackageVersion();
|
2002-06-07 23:26:07 +00:00
|
|
|
if ( !(base_version == required_version) ) {
|
2002-02-04 22:06:37 +00:00
|
|
|
// tell the operator how to use this application
|
|
|
|
|
2003-04-15 14:10:47 +00:00
|
|
|
cerr << endl << "Base package check failed ... " \
|
|
|
|
<< "Found version " << base_version << " at: " \
|
2002-09-18 16:13:08 +00:00
|
|
|
<< globals->get_fg_root() << endl;
|
2002-12-12 01:24:48 +00:00
|
|
|
cerr << "Please upgrade to version: " << required_version << endl;
|
2003-04-15 14:10:47 +00:00
|
|
|
exit(-1);
|
2001-07-16 19:17:58 +00:00
|
|
|
}
|
|
|
|
|
2000-09-25 21:41:50 +00:00
|
|
|
// Initialize the Aircraft directory to "" (UIUC)
|
|
|
|
aircraft_dir = "";
|
2000-03-22 22:01:33 +00:00
|
|
|
|
2002-11-16 20:17:11 +00:00
|
|
|
// Load the configuration parameters. (Command line options
|
|
|
|
// overrides config file options. Config file options override
|
|
|
|
// defaults.)
|
1999-06-18 03:42:54 +00:00
|
|
|
if ( !fgInitConfig(argc, argv) ) {
|
2003-04-15 14:10:47 +00:00
|
|
|
SG_LOG( SG_GENERAL, SG_ALERT, "Config option parsing failed ..." );
|
|
|
|
exit(-1);
|
1998-04-24 00:49:17 +00:00
|
|
|
}
|
1999-06-18 03:42:54 +00:00
|
|
|
|
1998-08-20 15:10:33 +00:00
|
|
|
// Initialize the Window/Graphics environment.
|
|
|
|
if( !fgGlutInit(&argc, argv) ) {
|
2003-04-15 14:10:47 +00:00
|
|
|
SG_LOG( SG_GENERAL, SG_ALERT, "GLUT initialization failed ..." );
|
|
|
|
exit(-1);
|
1998-08-20 15:10:33 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Initialize the various GLUT Event Handlers.
|
|
|
|
if( !fgGlutInitEvents() ) {
|
2003-07-25 20:09:30 +00:00
|
|
|
SG_LOG( SG_GENERAL, SG_ALERT,
|
2003-04-15 14:10:47 +00:00
|
|
|
"GLUT event handler initialization failed ..." );
|
|
|
|
exit(-1);
|
1998-08-20 15:10:33 +00:00
|
|
|
}
|
2001-08-21 21:13:55 +00:00
|
|
|
|
|
|
|
// Initialize plib net interface
|
|
|
|
netInit( &argc, argv );
|
|
|
|
|
2000-04-19 21:22:16 +00:00
|
|
|
// Initialize ssg (from plib). Needs to come before we do any
|
|
|
|
// other ssg stuff, but after opengl/glut has been initialized.
|
|
|
|
ssgInit();
|
1998-08-20 15:10:33 +00:00
|
|
|
|
1999-06-18 03:42:54 +00:00
|
|
|
// Initialize the user interface (we need to do this before
|
|
|
|
// passing off control to glut and before fgInitGeneral to get our
|
|
|
|
// fonts !!!
|
1999-05-12 01:11:17 +00:00
|
|
|
guiInit();
|
|
|
|
|
2003-03-29 15:04:52 +00:00
|
|
|
// Read the list of available aircrafts
|
|
|
|
fgReadAircraft();
|
|
|
|
|
2001-05-23 20:54:51 +00:00
|
|
|
#ifdef GL_EXT_texture_lod_bias
|
|
|
|
glTexEnvf( GL_TEXTURE_FILTER_CONTROL_EXT, GL_TEXTURE_LOD_BIAS_EXT, -0.5 ) ;
|
|
|
|
#endif
|
|
|
|
|
2002-10-17 04:34:32 +00:00
|
|
|
// get the address of our OpenGL extensions
|
2002-12-30 21:49:56 +00:00
|
|
|
if ( fgGetBool("/sim/rendering/distance-attenuation") )
|
|
|
|
{
|
2003-06-20 20:18:40 +00:00
|
|
|
if (SGIsOpenGLExtensionSupported("GL_EXT_point_parameters") ) {
|
2003-06-29 17:14:13 +00:00
|
|
|
glPointParameterIsSupported = true;
|
2003-06-20 20:18:40 +00:00
|
|
|
glPointParameterfPtr = (glPointParameterfProc)
|
|
|
|
SGLookupFunction("glPointParameterfEXT");
|
|
|
|
glPointParameterfvPtr = (glPointParameterfvProc)
|
|
|
|
SGLookupFunction("glPointParameterfvEXT");
|
|
|
|
|
|
|
|
} else if ( SGIsOpenGLExtensionSupported("GL_ARB_point_parameters") ) {
|
2003-06-29 17:14:13 +00:00
|
|
|
glPointParameterIsSupported = true;
|
2003-06-20 20:18:40 +00:00
|
|
|
glPointParameterfPtr = (glPointParameterfProc)
|
|
|
|
SGLookupFunction("glPointParameterfARB");
|
|
|
|
glPointParameterfvPtr = (glPointParameterfvProc)
|
|
|
|
SGLookupFunction("glPointParameterfvARB");
|
2003-06-29 17:14:13 +00:00
|
|
|
} else
|
|
|
|
glPointParameterIsSupported = false;
|
2002-12-30 21:49:56 +00:00
|
|
|
}
|
2002-10-17 04:34:32 +00:00
|
|
|
|
2002-11-16 21:34:51 +00:00
|
|
|
// based on the requested presets, calculate the true starting
|
|
|
|
// lon, lat
|
2003-02-21 02:46:07 +00:00
|
|
|
fgInitNav();
|
2002-11-16 21:34:51 +00:00
|
|
|
fgInitPosition();
|
2000-07-21 22:54:14 +00:00
|
|
|
|
2002-02-06 23:31:33 +00:00
|
|
|
SGTime *t = fgInitTime();
|
2000-07-07 20:28:51 +00:00
|
|
|
globals->set_time_params( t );
|
2000-03-16 04:15:22 +00:00
|
|
|
|
1999-06-18 03:42:54 +00:00
|
|
|
// Do some quick general initializations
|
1998-07-27 18:41:23 +00:00
|
|
|
if( !fgInitGeneral()) {
|
2003-04-15 14:10:47 +00:00
|
|
|
SG_LOG( SG_GENERAL, SG_ALERT,
|
|
|
|
"General initializations failed ..." );
|
|
|
|
exit(-1);
|
1998-07-27 18:41:23 +00:00
|
|
|
}
|
|
|
|
|
Andy Ross:
The biggest and coolest patch adds mouse sensitivity to the 3D
cockpits, so we can finally work the radios. This ended up requiring
significant modifications outside of the 3D cockpit code. Stuff folks
will want to look at:
+ The list of all "3D" cockpits is stored statically in the
panelnode.cxx file. This is clumsy, and won't migrate well to a
multiple-aircraft feature. Really, there should be a per-model list
of 3D panels, but I couldn't find a clean place to put this. The
only handle you get back after parsing a model is a generic ssg
node, to which I obviously can't add panel-specific methods.
+ The aircraft model is parsed *very* early in the initialization
order. Earlier, in fact, than the static list of allowable command
bindings is built in fgInitCommands(). This is bad, as it means
that mouse bindings on the instruments can't work yet. I moved the
call to fgInitCommands, but someone should look carefully to see
that I picked the right place. There's a lot of initialization
code, and I got a little lost in there... :)
+ I added yet another "update" hook to the fgRenderFrame routine to
hook the updates for the 3D panels. This is only required for
"mouse press delay", and it's a fairly clumsy mechanism based on
frame rate instead of real time. There appears to be delay handling
already in place in the Input stuff, and there's a discussion going
on about different mouse behavior right now. Maybe this is a good
time to unify these two (now three) approaches?
2002-10-29 19:44:03 +00:00
|
|
|
////////////////////////////////////////////////////////////////////
|
|
|
|
// Initialize the property-based built-in commands
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
|
|
fgInitCommands();
|
|
|
|
|
2002-04-12 12:45:49 +00:00
|
|
|
////////////////////////////////////////////////////////////////////
|
2003-05-28 20:29:05 +00:00
|
|
|
// Initialize the material manager
|
2002-04-12 12:45:49 +00:00
|
|
|
////////////////////////////////////////////////////////////////////
|
2003-05-28 20:29:05 +00:00
|
|
|
globals->set_matlib( new SGMaterialLib );
|
2002-04-12 12:45:49 +00:00
|
|
|
|
2003-05-15 21:35:51 +00:00
|
|
|
globals->set_model_lib(new SGModelLib);
|
2002-04-12 12:45:49 +00:00
|
|
|
|
2004-02-27 16:48:27 +00:00
|
|
|
////////////////////////////////////////////////////////////////////
|
|
|
|
// Initialize the TG scenery subsystem.
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
|
|
globals->set_scenery( new FGScenery );
|
|
|
|
globals->get_scenery()->init();
|
|
|
|
globals->get_scenery()->bind();
|
|
|
|
globals->set_tile_mgr( new FGTileMgr );
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
|
|
// Initialize the general model subsystem.
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
|
|
globals->set_model_mgr(new FGModelMgr);
|
|
|
|
globals->get_model_mgr()->init();
|
|
|
|
globals->get_model_mgr()->bind();
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
|
|
// Initialize the 3D aircraft model subsystem (has a dependency on
|
|
|
|
// the scenery subsystem.)
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
|
|
globals->set_aircraft_model(new FGAircraftModel);
|
|
|
|
globals->get_aircraft_model()->init();
|
|
|
|
globals->get_aircraft_model()->bind();
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
|
|
// Initialize the view manager subsystem.
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
|
|
FGViewMgr *viewmgr = new FGViewMgr;
|
|
|
|
globals->set_viewmgr( viewmgr );
|
|
|
|
viewmgr->init();
|
|
|
|
viewmgr->bind();
|
|
|
|
|
|
|
|
|
2000-03-02 03:03:16 +00:00
|
|
|
// Initialize the sky
|
2001-03-25 14:20:12 +00:00
|
|
|
SGPath ephem_data_path( globals->get_fg_root() );
|
2000-03-16 23:01:57 +00:00
|
|
|
ephem_data_path.append( "Astro" );
|
2000-07-08 05:09:24 +00:00
|
|
|
SGEphemeris *ephem = new SGEphemeris( ephem_data_path.c_str() );
|
|
|
|
ephem->update( globals->get_time_params()->getMjd(),
|
2003-09-15 22:55:39 +00:00
|
|
|
globals->get_time_params()->getLst(),
|
|
|
|
0.0 );
|
2000-07-08 05:09:24 +00:00
|
|
|
globals->set_ephem( ephem );
|
2000-03-16 23:01:57 +00:00
|
|
|
|
2003-09-15 22:55:39 +00:00
|
|
|
// TODO: move to environment mgr
|
2001-05-15 00:01:04 +00:00
|
|
|
thesky = new SGSky;
|
2002-06-05 17:44:39 +00:00
|
|
|
SGPath texture_path(globals->get_fg_root());
|
|
|
|
texture_path.append("Textures");
|
|
|
|
texture_path.append("Sky");
|
|
|
|
for (int i = 0; i < FGEnvironmentMgr::MAX_CLOUD_LAYERS; i++) {
|
2002-12-21 05:01:51 +00:00
|
|
|
SGCloudLayer * layer = new SGCloudLayer(texture_path.str());
|
|
|
|
thesky->add_cloud_layer(layer);
|
2002-06-05 17:44:39 +00:00
|
|
|
}
|
|
|
|
|
2001-03-25 14:20:12 +00:00
|
|
|
SGPath sky_tex_path( globals->get_fg_root() );
|
2000-03-06 23:28:43 +00:00
|
|
|
sky_tex_path.append( "Textures" );
|
|
|
|
sky_tex_path.append( "Sky" );
|
2000-03-16 04:15:22 +00:00
|
|
|
thesky->texture_path( sky_tex_path.str() );
|
2000-03-16 23:01:57 +00:00
|
|
|
|
2003-06-14 09:32:06 +00:00
|
|
|
// The sun and moon diameters are scaled down numbers of the
|
|
|
|
// actual diameters. This was needed to fit bot the sun and the
|
|
|
|
// moon within the distance to the far clip plane.
|
|
|
|
// Moon diameter: 3,476 kilometers
|
|
|
|
// Sun diameter: 1,390,000 kilometers
|
2003-06-11 19:06:48 +00:00
|
|
|
thesky->build( 80000.0, 80000.0,
|
2003-06-14 09:32:06 +00:00
|
|
|
463.3, 361.8,
|
2003-06-09 20:24:50 +00:00
|
|
|
globals->get_ephem()->getNumPlanets(),
|
2003-06-11 19:06:48 +00:00
|
|
|
globals->get_ephem()->getPlanets(),
|
2003-06-09 20:24:50 +00:00
|
|
|
globals->get_ephem()->getNumStars(),
|
2003-06-11 19:06:48 +00:00
|
|
|
globals->get_ephem()->getStars() );
|
2000-07-05 02:39:30 +00:00
|
|
|
|
2000-08-08 00:39:52 +00:00
|
|
|
// Initialize MagVar model
|
|
|
|
SGMagVar *magvar = new SGMagVar();
|
|
|
|
globals->set_mag( magvar );
|
|
|
|
|
2003-07-17 00:06:03 +00:00
|
|
|
|
|
|
|
// kludge to initialize mag compass
|
|
|
|
// (should only be done for in-flight
|
|
|
|
// startup)
|
2003-07-17 00:26:38 +00:00
|
|
|
// update magvar model
|
|
|
|
globals->get_mag()->update( fgGetDouble("/position/longitude-deg")
|
|
|
|
* SGD_DEGREES_TO_RADIANS,
|
|
|
|
fgGetDouble("/position/latitude-deg")
|
|
|
|
* SGD_DEGREES_TO_RADIANS,
|
|
|
|
fgGetDouble("/position/altitude-ft")
|
|
|
|
* SG_FEET_TO_METER,
|
|
|
|
globals->get_time_params()->getJD() );
|
|
|
|
double var = globals->get_mag()->get_magvar() * SGD_RADIANS_TO_DEGREES;
|
|
|
|
fgSetDouble("/instrumentation/heading-indicator/offset-deg", -var);
|
2003-07-17 00:06:03 +00:00
|
|
|
|
2002-03-03 23:20:55 +00:00
|
|
|
// airport = new ssgBranch;
|
|
|
|
// airport->setName( "Airport Lighting" );
|
|
|
|
// lighting->addKid( airport );
|
2000-12-04 05:26:40 +00:00
|
|
|
|
2000-03-02 03:03:16 +00:00
|
|
|
// build our custom render states
|
|
|
|
fgBuildRenderStates();
|
2002-02-17 21:05:27 +00:00
|
|
|
|
1998-04-24 14:19:29 +00:00
|
|
|
// pass control off to the master GLUT event handler
|
1998-04-24 00:49:17 +00:00
|
|
|
glutMainLoop();
|
|
|
|
|
1999-06-18 03:42:54 +00:00
|
|
|
// we never actually get here ... but to avoid compiler warnings,
|
|
|
|
// etc.
|
2002-11-16 20:17:11 +00:00
|
|
|
return false;
|
1998-04-21 17:02:27 +00:00
|
|
|
}
|
The following changes were made to flightgear-0.7.5 code to implement the follow
ing features:
a) ADA Flight model - ADA.cxx, ADA.hxx, flight.hxx
b) Fighter a/c HUD - flight.hxx, hud.hxx, hud.cxx, cockpit.cxx, hud_ladr.c
xx, hud_card.cxx
c) 3-window display - options.hxx, options.cxx, viewer.cxx
d) Moving objects (ship) - main.cxx
e) Patches - main.cxx
ADA.cxx, ADA.hxx
--------------------------
Interface to the external ADA flight dynamics package.
flight.hxx
----------
Included prototypes for accepting additional data fron the External flight
model for fighter aircraft HUD
Hud.hxx
-------
Included prototypes for accepting additional data for fighter HUD from Exernal F
light model.
Defined FIGHTER_HUD pre-processor directive to enable compilation of fighter hud
code.
hud.cxx, cockpit.cxx, hud_ladr.cxx, hud_card.cxx
---------------------------------------
Included code to initialise additional reticles/text for fighter HUD which is co
nditionally
compiled if FIGHTER_HUD is defined.
options.hxx
-----------
Added window_offset, and function to retrieve its value for 3 windows
options.cxx
-----------
Changed few options to suit ADA/CEF projection system/screens and checks for win
dow offset.
views.cxx
---------
Added code to retrieve view offset for window.
Main.cxx
--------
Added code to load and move an aircraft carrier.
Patch to enable clouds from command line until Curtis fixes it. By default cloud
s are disabled.
2000-10-19 19:46:13 +00:00
|
|
|
|
|
|
|
|
2003-11-24 17:46:38 +00:00
|
|
|
// end of main.cxx
|