fly/flightgear
1
0
Fork 0
Code Activity

Added bfi.[ch]xx (Big Flat Interface) to give a consistant access point

Browse source 
to shared state inside Flight Gear.
This commit is contained in:
curt 2000-02-26 18:01:13 +00:00
parent d0623c435e
commit c2226f6e34
6 changed files with 1247 additions and 389 deletions

334
src/Cockpit/panel.cxx
View file

@ -35,6 +35,7 @@
#include <simgear/debug/logstream.hxx>
#include <simgear/misc/fgpath.hxx>
#include <Main/options.hxx>
#include <Main/bfi.hxx>
#include <Objects/texload.h>
#include <Autopilot/autopilot.hxx>
#include <Time/fg_time.hxx>
@ -60,120 +61,6 @@ extern fgAPDataPtr APDataGlobal;
// or BFI (Big Friendly Interface).
////////////////////////////////////////////////////////////////////////
/**
* Return the indicated airspeed in knots.
*/
static double
panelGetSpeed ()
{
return get_speed();
}
/**
* Return the roll in degrees.
*/
static double
panelGetRoll ()
{
return get_roll() * RAD_TO_DEG;
}
/**
* Return the pitch in degrees.
*/
static double
panelGetPitch ()
{
return get_pitch() * RAD_TO_DEG;
}
/**
* Return the altitude in feet.
*/
static double
panelGetAltitude ()
{
return get_altitude();
}
/**
* Return the sideslip (units unknown).
*/
static double
panelGetSideSlip ()
{
return get_sideslip();
}
/**
* Return the heading in degrees.
*/
static double
panelGetHeading ()
{
return get_heading();
}
/**
* Return the current autopilot heading in degrees.
*/
static double
panelGetAPHeading ()
{
return fgAPget_TargetHeading();
}
/**
* Return the climb rate in feet/minute.
*/
static double
panelGetVerticalVelocity ()
{
return get_climb_rate();
}
/**
* Return the throttle setting (0.0 - 1.0).
*/
static double
panelGetThrottle ()
{
return get_throttleval();
}
/**
* Return the flaps setting (0.0 - 1.0).
*/
static double
panelGetFlaps ()
{
return controls.get_flaps();
}
static double
panelGetAileron ()
{
return controls.get_aileron();
}
static double
panelGetRudder ()
{
return controls.get_rudder();
}
static double
panelGetElevator ()
{
return controls.get_elevator();
}
static double
panelGetElevatorTrim ()
{
return controls.get_elevator_trim();
}
static char * panelGetTime (char * buf)
{
struct tm * t = FGTime::cur_time_params->getGmt();
@ -192,23 +79,29 @@ static char * panelGetTime (char * buf)
// they're hard-coded.
////////////////////////////////////////////////////////////////////////
static ssgTexture *
createTexture (const char * relativePath)
{
return FGPanel::OurPanel->createTexture(relativePath);
}
/**
* Construct an airspeed indicator for a single-engine prop.
*/
static FGPanelInstrument *
makeAirspeedIndicator (int x, int y)
createAirspeedIndicator (int x, int y)
{
FGLayeredInstrument * inst = new FGLayeredInstrument(x, y, SIX_W, SIX_W);
// Layer 0: gauge background.
inst->addLayer(0, "Textures/Panel/airspeed.rgb");
inst->addLayer(0, createTexture("Textures/Panel/airspeed.rgb"));
// Layer 1: needle.
// Rotates with airspeed.
inst->addLayer(1, "Textures/Panel/long-needle.rgb");
inst->addLayer(1, createTexture("Textures/Panel/long-needle.rgb"));
inst->addTransformation(1, FGInstrumentLayer::ROTATION,
panelGetSpeed,
FGBFI::getAirspeed,
30.0, 220.0, 36.0 / 20.0, -54.0);
return inst;
}
@ -218,37 +111,37 @@ makeAirspeedIndicator (int x, int y)
* Construct an artificial horizon.
*/
static FGPanelInstrument *
makeHorizon (int x, int y)
createHorizon (int x, int y)
{
FGLayeredInstrument * inst = new FGLayeredInstrument(x, y, SIX_W, SIX_W);
// Layer 0: coloured background
// moves with roll only
inst->addLayer(0, "Textures/Panel/horizon-bg.rgb");
inst->addLayer(0, createTexture("Textures/Panel/horizon-bg.rgb"));
inst->addTransformation(0, FGInstrumentLayer::ROTATION,
panelGetRoll,
FGBFI::getRoll,
-360.0, 360.0, -1.0, 0.0);
// Layer 1: floating horizon
// moves with roll and pitch
inst->addLayer(1, "Textures/Panel/horizon-float.rgb");
inst->addLayer(1, createTexture("Textures/Panel/horizon-float.rgb"));
inst->addTransformation(1, FGInstrumentLayer::ROTATION,
panelGetRoll,
FGBFI::getRoll,
-360.0, 360.0, -1.0, 0.0);
inst->addTransformation(1, FGInstrumentLayer::YSHIFT,
panelGetPitch,
FGBFI::getPitch,
-20.0, 20.0, -(1.5 / 160.0) * SIX_W, 0.0);
// Layer 2: rim
// moves with roll only
inst->addLayer(2, "Textures/Panel/horizon-rim.rgb");
inst->addLayer(2, createTexture("Textures/Panel/horizon-rim.rgb"));
inst->addTransformation(2, FGInstrumentLayer::ROTATION,
panelGetRoll,
FGBFI::getRoll,
-360.0, 360.0, -1.0, 0.0);
// Layer 3: glass front of gauge
// fixed, with markings
inst->addLayer(3, "Textures/Panel/horizon-fg.rgb");
inst->addLayer(3, createTexture("Textures/Panel/horizon-fg.rgb"));
return inst;
}
@ -258,32 +151,32 @@ makeHorizon (int x, int y)
* Construct an altimeter.
*/
static FGPanelInstrument *
makeAltimeter (int x, int y)
createAltimeter (int x, int y)
{
FGLayeredInstrument * inst = new FGLayeredInstrument(x, y, SIX_W, SIX_W);
// Layer 0: gauge background
inst->addLayer(0, "Textures/Panel/altimeter.rgb");
inst->addLayer(0, createTexture("Textures/Panel/altimeter.rgb"));
// Layer 1: hundreds needle (long)
// moves with altitude
inst->addLayer(1, "Textures/Panel/long-needle.rgb");
inst->addLayer(1, createTexture("Textures/Panel/long-needle.rgb"));
inst->addTransformation(1, FGInstrumentLayer::ROTATION,
panelGetAltitude,
FGBFI::getAltitude,
0.0, 100000.0, 360.0 / 1000.0, 0.0);
// Layer 2: thousands needle (short)
// moves with altitude
inst->addLayer(2, "Textures/Panel/short-needle.rgb");
inst->addLayer(2, createTexture("Textures/Panel/short-needle.rgb"));
inst->addTransformation(2, FGInstrumentLayer::ROTATION,
panelGetAltitude,
FGBFI::getAltitude,
0.0, 100000.0, 360.0 / 10000.0, 0.0);
// Layer 3: ten thousands bug (outside)
// moves with altitude
inst->addLayer(3, "Textures/Panel/bug.rgb");
inst->addLayer(3, createTexture("Textures/Panel/bug.rgb"));
inst->addTransformation(3, FGInstrumentLayer::ROTATION,
panelGetAltitude,
FGBFI::getAltitude,
0.0, 100000.0, 360.0 / 100000.0, 0.0);
return inst;
@ -294,25 +187,25 @@ makeAltimeter (int x, int y)
* Construct a turn coordinator.
*/
static FGPanelInstrument *
makeTurnCoordinator (int x, int y)
createTurnCoordinator (int x, int y)
{
FGLayeredInstrument * inst = new FGLayeredInstrument(x, y, SIX_W, SIX_W);
// Layer 0: background
inst->addLayer(0, "Textures/Panel/turn-bg.rgb");
inst->addLayer(0, createTexture("Textures/Panel/turn-bg.rgb"));
// Layer 1: little plane
// moves with roll
inst->addLayer(1, "Textures/Panel/turn.rgb");
inst->addLayer(1, createTexture("Textures/Panel/turn.rgb"));
inst->addTransformation(1, FGInstrumentLayer::ROTATION,
panelGetRoll,
FGBFI::getRoll,
-30.0, 30.0, 1.0, 0.0);
// Layer 2: little ball
// moves with slip/skid
inst->addLayer(2, "Textures/Panel/ball.rgb");
inst->addLayer(2, createTexture("Textures/Panel/ball.rgb"));
inst->addTransformation(2, FGInstrumentLayer::ROTATION,
panelGetSideSlip,
FGBFI::getSideSlip,
-0.1, 0.1, 450.0, 0.0);
return inst;
@ -323,29 +216,29 @@ makeTurnCoordinator (int x, int y)
* Construct a gyro compass.
*/
static FGPanelInstrument *
makeGyroCompass (int x, int y)
createGyroCompass (int x, int y)
{
FGLayeredInstrument * inst = new FGLayeredInstrument(x, y, SIX_W, SIX_W);
// Layer 0: compass background
// rotates with heading
inst->addLayer(0, "Textures/Panel/gyro-bg.rgb");
inst->addLayer(0, createTexture("Textures/Panel/gyro-bg.rgb"));
inst->addTransformation(0, FGInstrumentLayer::ROTATION,
panelGetHeading,
FGBFI::getHeading,
-360.0, 360.0, -1.0, 0.0);
// Layer 1: heading bug
// rotates with heading and AP heading
inst->addLayer(1, "Textures/Panel/bug.rgb");
inst->addLayer(1, createTexture("Textures/Panel/bug.rgb"));
inst->addTransformation(1, FGInstrumentLayer::ROTATION,
panelGetHeading,
FGBFI::getHeading,
-360.0, 360.0, -1.0, 0.0);
inst->addTransformation(1, FGInstrumentLayer::ROTATION,
panelGetAPHeading,
FGBFI::getAPHeading,
-360.0, 360.0, 1.0, 0.0);
// Layer 2: fixed center
inst->addLayer(2, "Textures/Panel/gyro-fg.rgb");
inst->addLayer(2, createTexture("Textures/Panel/gyro-fg.rgb"));
return inst;
}
@ -355,18 +248,18 @@ makeGyroCompass (int x, int y)
* Construct a vertical velocity indicator.
*/
static FGPanelInstrument *
makeVerticalVelocity (int x, int y)
createVerticalVelocity (int x, int y)
{
FGLayeredInstrument * inst = new FGLayeredInstrument(x, y, SIX_W, SIX_W);
// Layer 0: gauge background
inst->addLayer(0, "Textures/Panel/vertical.rgb");
inst->addLayer(0, createTexture("Textures/Panel/vertical.rgb"));
// Layer 1: needle
// moves with vertical velocity
inst->addLayer(1, "Textures/Panel/long-needle.rgb");
inst->addLayer(1, createTexture("Textures/Panel/long-needle.rgb"));
inst->addTransformation(1, FGInstrumentLayer::ROTATION,
panelGetVerticalVelocity,
FGBFI::getVerticalSpeed,
-2000.0, 2000.0, 42.0/500.0, 270.0);
return inst;
@ -377,18 +270,18 @@ makeVerticalVelocity (int x, int y)
* Construct an RPM gauge.
*/
static FGPanelInstrument *
makeRPMGauge (int x, int y)
createRPMGauge (int x, int y)
{
FGLayeredInstrument * inst = new FGLayeredInstrument(x, y, SMALL_W, SMALL_W);
// Layer 0: gauge background
inst->addLayer(0, "Textures/Panel/rpm.rgb");
inst->addLayer(0, createTexture("Textures/Panel/rpm.rgb"));
// Layer 1: long needle
// FIXME: moves with throttle (for now)
inst->addLayer(1, "Textures/Panel/long-needle.rgb");
inst->addLayer(1, createTexture("Textures/Panel/long-needle.rgb"));
inst->addTransformation(1, FGInstrumentLayer::ROTATION,
panelGetThrottle,
FGBFI::getThrottle,
0.0, 100.0, 300.0, -150.0);
return inst;
@ -399,32 +292,32 @@ makeRPMGauge (int x, int y)
* Construct a flap position indicator.
*/
static FGPanelInstrument *
makeFlapIndicator (int x, int y)
createFlapIndicator (int x, int y)
{
FGLayeredInstrument * inst = new FGLayeredInstrument(x, y, SMALL_W, SMALL_W);
// Layer 0: gauge background
inst->addLayer(0, "Textures/Panel/flaps.rgb");
inst->addLayer(0, createTexture("Textures/Panel/flaps.rgb"));
// Layer 1: long needle
// shifted over, rotates with flap position
inst->addLayer(1, "Textures/Panel/long-needle.rgb");
inst->addLayer(1, createTexture("Textures/Panel/long-needle.rgb"));
inst->addTransformation(1, FGInstrumentLayer::XSHIFT,
-(SMALL_W / 4) + (SMALL_W / 16));
inst->addTransformation(1, FGInstrumentLayer::ROTATION,
panelGetFlaps,
FGBFI::getFlaps,
0.0, 1.0, 120.0, 30.0);
return inst;
}
static FGPanelInstrument *
makeChronometer (int x, int y)
createChronometer (int x, int y)
{
FGLayeredInstrument * inst = new FGLayeredInstrument(x, y, SMALL_W, SMALL_W);
// Layer 0: gauge background
inst->addLayer(0, "Textures/Panel/clock.rgb");
inst->addLayer(0, createTexture("Textures/Panel/clock.rgb"));
// Layer 1: text
// displays current GMT
@ -445,42 +338,42 @@ makeChronometer (int x, int y)
* Construct control-position indicators.
*/
static FGPanelInstrument *
makeControls (int x, int y)
createControls (int x, int y)
{
FGLayeredInstrument * inst = new FGLayeredInstrument(x, y, SMALL_W, SMALL_W);
// Layer 0: gauge background
inst->addLayer(0, "Textures/Panel/controls.rgb");
inst->addLayer(0, createTexture("Textures/Panel/controls.rgb"));
// Layer 1: bug
// moves left-right with aileron
inst->addLayer(1, "Textures/Panel/bug.rgb");
inst->addTransformation(1, FGInstrumentLayer::XSHIFT, panelGetAileron,
inst->addLayer(1, createTexture("Textures/Panel/bug.rgb"));
inst->addTransformation(1, FGInstrumentLayer::XSHIFT, FGBFI::getAileron,
-1.0, 1.0, SMALL_W * .75 / 2.0, 0.0);
// Layer 2: bug
// moves left-right with rudder
inst->addLayer(2, "Textures/Panel/bug.rgb");
inst->addLayer(2, createTexture("Textures/Panel/bug.rgb"));
inst->addTransformation(2, FGInstrumentLayer::ROTATION, 180.0);
inst->addTransformation(2, FGInstrumentLayer::XSHIFT, panelGetRudder,
inst->addTransformation(2, FGInstrumentLayer::XSHIFT, FGBFI::getRudder,
-1.0, 1.0, -SMALL_W * .75 / 2.0, 0.0);
// Layer 3: bug
// moves up-down with elevator trim
inst->addLayer(3, "Textures/Panel/bug.rgb");
inst->addLayer(3, createTexture("Textures/Panel/bug.rgb"));
inst->addTransformation(3, FGInstrumentLayer::ROTATION, 270.0);
inst->addTransformation(3, FGInstrumentLayer::YSHIFT,
-SMALL_W * (3.0 / 8.0));
inst->addTransformation(3, FGInstrumentLayer::XSHIFT, panelGetElevatorTrim,
inst->addTransformation(3, FGInstrumentLayer::XSHIFT, FGBFI::getElevatorTrim,
-1.0, 1.0, SMALL_W * .75 / 2.0, 0.0);
// Layer 4: bug
// moves up-down with elevator
inst->addLayer(4, "Textures/Panel/bug.rgb");
inst->addLayer(4, createTexture("Textures/Panel/bug.rgb"));
inst->addTransformation(4, FGInstrumentLayer::ROTATION, 90.0);
inst->addTransformation(4, FGInstrumentLayer::YSHIFT,
-SMALL_W * (3.0 / 8.0));
inst->addTransformation(4, FGInstrumentLayer::XSHIFT, panelGetElevator,
inst->addTransformation(4, FGInstrumentLayer::XSHIFT, FGBFI::getElevator,
-1.0, 1.0, -SMALL_W * .75 / 2.0, 0.0);
return inst;
@ -491,12 +384,12 @@ makeControls (int x, int y)
* Construct a NAV1 gauge (dummy for now).
*/
static FGPanelInstrument *
makeNAV1 (int x, int y)
createNAV1 (int x, int y)
{
FGLayeredInstrument * inst = new FGLayeredInstrument(x, y, SIX_W, SIX_W);
// Layer 0: background
inst->addLayer(0, "Textures/Panel/gyro-bg.rgb");
inst->addLayer(0, createTexture("Textures/Panel/gyro-bg.rgb"));
return inst;
}
@ -506,12 +399,12 @@ makeNAV1 (int x, int y)
* Construct a NAV2 gauge (dummy for now).
*/
static FGPanelInstrument *
makeNAV2 (int x, int y)
createNAV2 (int x, int y)
{
FGLayeredInstrument * inst = new FGLayeredInstrument(x, y, SIX_W, SIX_W);
// Layer 0: background
inst->addLayer(0, "Textures/Panel/gyro-bg.rgb");
inst->addLayer(0, createTexture("Textures/Panel/gyro-bg.rgb"));
return inst;
}
@ -521,12 +414,12 @@ makeNAV2 (int x, int y)
* Construct an ADF gauge (dummy for now).
*/
static FGPanelInstrument *
makeADF (int x, int y)
createADF (int x, int y)
{
FGLayeredInstrument * inst = new FGLayeredInstrument(x, y, SIX_W, SIX_W);
// Layer 0: background
inst->addLayer(0, "Textures/Panel/gyro-bg.rgb");
inst->addLayer(0, createTexture("Textures/Panel/gyro-bg.rgb"));
return inst;
}
@ -551,46 +444,44 @@ FGPanel::FGPanel ()
int x = SIX_X;
int y = SIX_Y;
FGPath tpath(current_options.get_fg_root());
tpath.append("Textures/Panel/panel-bg.rgb");
_bg = new ssgTexture((char *)tpath.c_str(), false, false);
_bg = createTexture("Textures/Panel/panel-bg.rgb");
// Chronometer alone at side
x = SIX_X - SIX_SPACING - 8;
_instruments.push_back(makeChronometer(x, y));
_instruments.push_back(createChronometer(x, y));
// Top row
x = SIX_X;
_instruments.push_back(makeAirspeedIndicator(x, y));
_instruments.push_back(createAirspeedIndicator(x, y));
x += SIX_SPACING;
_instruments.push_back(makeHorizon(x, y));
_instruments.push_back(createHorizon(x, y));
x += SIX_SPACING;
_instruments.push_back(makeAltimeter(x, y));
_instruments.push_back(createAltimeter(x, y));
x += SIX_SPACING + 20;
_instruments.push_back(makeNAV1(x, y));
_instruments.push_back(createNAV1(x, y));
// Middle row
x = SIX_X;
y -= SIX_SPACING;
_instruments.push_back(makeTurnCoordinator(x, y));
_instruments.push_back(createTurnCoordinator(x, y));
x += SIX_SPACING;
_instruments.push_back(makeGyroCompass(x, y));
_instruments.push_back(createGyroCompass(x, y));
x += SIX_SPACING;
_instruments.push_back(makeVerticalVelocity(x, y));
_instruments.push_back(createVerticalVelocity(x, y));
x += SIX_SPACING + 20;
_instruments.push_back(makeNAV2(x, y));
_instruments.push_back(createNAV2(x, y));
// Bottom row
x = SIX_X;
y -= SIX_SPACING + 10;
_instruments.push_back(makeControls(x, y));
_instruments.push_back(createControls(x, y));
x += SIX_SPACING;
_instruments.push_back(makeFlapIndicator(x, y));
_instruments.push_back(createFlapIndicator(x, y));
x += SIX_SPACING;
_instruments.push_back(makeRPMGauge(x, y));
_instruments.push_back(createRPMGauge(x, y));
x += SIX_SPACING + 20;
y += 10;
_instruments.push_back(makeADF(x, y));
_instruments.push_back(createADF(x, y));
}
FGPanel::~FGPanel ()
@ -668,6 +559,24 @@ FGPanel::Update () const
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
}
ssgTexture *
FGPanel::createTexture (const char * relativePath)
{
ssgTexture *texture;
texture = _textureMap[relativePath];
if (texture == 0) {
FGPath tpath(current_options.get_fg_root());
tpath.append(relativePath);
texture = new ssgTexture((char *)tpath.c_str(), false, false);
_textureMap[relativePath] = texture;
cerr << "Created texture " << relativePath
<< " handle=" << texture->getHandle() << endl;
}
return texture;
}
////////////////////////////////////////////////////////////////////////
@ -751,9 +660,9 @@ FGLayeredInstrument::addLayer (FGInstrumentLayer *layer)
}
void
FGLayeredInstrument::addLayer (int layer, const char *textureName)
FGLayeredInstrument::addLayer (int layer, ssgTexture * texture)
{
addLayer(new FGTexturedInstrumentLayer(textureName, _w, _h, layer));
addLayer(new FGTexturedInstrumentLayer(texture, _w, _h, layer));
}
void
@ -781,8 +690,8 @@ FGInstrumentLayer::FGInstrumentLayer (int w, int h, int z)
FGInstrumentLayer::~FGInstrumentLayer ()
{
transformation_list::iterator it;
transformation_list::iterator end;
transformation_list::iterator it = _transformations.begin();
transformation_list::iterator end = _transformations.end();
while (it != end) {
delete *it;
it++;
@ -843,12 +752,12 @@ FGInstrumentLayer::addTransformation (transform_type type,
// Implementation of FGTexturedInstrumentLayer.
////////////////////////////////////////////////////////////////////////
FGTexturedInstrumentLayer::FGTexturedInstrumentLayer (const char *tname,
int w, int h, int z)
: FGInstrumentLayer(w, h, z)
{
setTexture(tname);
}
// FGTexturedInstrumentLayer::FGTexturedInstrumentLayer (const char *tname,
// int w, int h, int z)
// : FGInstrumentLayer(w, h, z)
// {
// setTexture(tname);
// }
FGTexturedInstrumentLayer::FGTexturedInstrumentLayer (ssgTexture * texture,
int w, int h, int z)
@ -881,15 +790,14 @@ FGTexturedInstrumentLayer::draw () const
glPopMatrix();
}
void
FGTexturedInstrumentLayer::setTexture (const char *textureName)
{
FGPath tpath(current_options.get_fg_root());
tpath.append(textureName);
ssgTexture * texture = new ssgTexture((char *)tpath.c_str(), false, false);
cerr << "Loaded texture " << textureName << endl;
setTexture(texture);
}
// void
// FGTexturedInstrumentLayer::setTexture (const char *textureName)
// {
// FGPath tpath(current_options.get_fg_root());
// tpath.append(textureName);
// ssgTexture * texture = new ssgTexture((char *)tpath.c_str(), false, false);
// setTexture(texture);
// }

19
src/Cockpit/panel.hxx
View file

@ -38,13 +38,14 @@
#include <plib/ssg.h>
#include <vector>
#include <hash_map>
#include <plib/fnt.h>
FG_USING_STD(vector);
FG_USING_STD(hash_map);
class FGPanelInstrument;
////////////////////////////////////////////////////////////////////////
// Instrument panel class.
@ -54,11 +55,11 @@ class FGPanel
{
public:
typedef vector<FGPanelInstrument *> instrument_list_type;
FGPanel ();
virtual ~FGPanel ();
virtual ssgTexture * createTexture (const char * relativePath);
// Legacy interface from old panel.
static FGPanel * OurPanel;
virtual float get_height () const;
@ -66,11 +67,18 @@ public:
virtual void Update () const;
private:
typedef vector<FGPanelInstrument *> instrument_list_type;
int _x, _y, _w, _h;
int _panel_h;
ssgTexture * _bg;
// Internalization table.
hash_map<const char *,ssgTexture *> _textureMap;
// List of instruments in panel.
instrument_list_type _instruments;
};
@ -173,7 +181,7 @@ public:
virtual void draw () const;
virtual void addLayer (FGInstrumentLayer *layer);
virtual void addLayer (int i, const char *textureName);
virtual void addLayer (int i, ssgTexture * texture);
virtual void addTransformation (int layer,
FGInstrumentLayer::transform_type type,
FGInstrumentLayer::transform_func func,
@ -205,15 +213,12 @@ protected:
class FGTexturedInstrumentLayer : public FGInstrumentLayer
{
public:
FGTexturedInstrumentLayer (const char * textureName,
int w, int h, int z);
FGTexturedInstrumentLayer (ssgTexture * texture,
int w, int h, int z);
virtual ~FGTexturedInstrumentLayer ();
virtual void draw () const;
virtual void setTexture (const char *textureName);
virtual void setTexture (ssgTexture * texture) { _texture = texture; }
private:

1
src/Main/Makefile.am
View file

@ -32,6 +32,7 @@ bin_PROGRAMS = fgfs
bin_SCRIPTS = runfgfs runfgfs.bat
fgfs_SOURCES = \
bfi.cxx bfi.hxx \
fg_init.cxx fg_init.hxx \
fg_io.cxx fg_io.hxx \
keyboard.cxx keyboard.hxx \

850
src/Main/bfi.cxx Normal file
View file

@ -0,0 +1,850 @@
// bfi.cxx - Big Friendly Interface implementation
//
// Written by David Megginson, started February, 2000.
//
// Copyright (C) 2000 David Megginson - david@megginson.com
//
// 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$
#ifdef HAVE_CONFIG_H
# include <config.h>
#endif
#if defined( FG_HAVE_NATIVE_SGI_COMPILERS )
# include <iostream.h>
#else
# include <iostream>
#endif
#include <simgear/constants.h>
#include <simgear/math/fg_types.hxx>
#include <Aircraft/aircraft.hxx>
#include <Controls/controls.hxx>
#include <Autopilot/autopilot.hxx>
#include <Time/fg_time.hxx>
#include <Astro/solarsystem.hxx>
#ifndef FG_OLD_WEATHER
# include <WeatherCM/FGLocalWeatherDatabase.h>
#else
# include <Weather/weather.hxx>
#endif
#include "options.hxx"
#include "save.hxx"
#include "fg_init.hxx"
FG_USING_NAMESPACE(std);
// FIXME: these are not part of the
// published interface!!!
extern fgAPDataPtr APDataGlobal;
extern void fgAPAltitudeSet (double new_altitude);
extern void fgAPHeadingSet (double new_heading);
#include "bfi.hxx"
////////////////////////////////////////////////////////////////////////
// Static variables.
////////////////////////////////////////////////////////////////////////
bool FGBFI::_needReinit = false;
////////////////////////////////////////////////////////////////////////
// Local functions
////////////////////////////////////////////////////////////////////////
/**
* Reinitialize FGFS if required.
*
* Some changes (especially those in aircraft position) require that
* FGFS be reinitialized afterwards. Rather than reinitialize after
* every change, the setter methods simply set a flag so that there
* can be a single reinit at the end of the frame.
*/
void
FGBFI::update ()
{
if (_needReinit) {
reinit();
}
}
/**
* Reinitialize FGFS to use the new BFI settings.
*/
void
FGBFI::reinit ()
{
// Save the state of everything
// that's going to get clobbered
// when we reinit the subsystems.
// TODO: add more AP stuff
double elevator = getElevator();
double aileron = getAileron();
double rudder = getRudder();
double throttle = getThrottle();
double elevator_trim = getElevatorTrim();
double flaps = getFlaps();
double brake = getBrake();
bool apHeadingLock = getAPHeadingLock();
double apHeading = getAPHeading();
bool apAltitudeLock = getAPAltitudeLock();
double apAltitude = getAPAltitude();
const string &targetAirport = getTargetAirport();
bool gpsLock = getGPSLock();
double gpsLatitude = getGPSTargetLatitude();
double gpsLongitude = getGPSTargetLongitude();
fgReInitSubsystems();
solarSystemRebuild();
cur_light_params.Update();
// Restore all of the old states.
setElevator(elevator);
setAileron(aileron);
setRudder(rudder);
setThrottle(throttle);
setElevatorTrim(elevator_trim);
setFlaps(flaps);
setBrake(brake);
setAPHeadingLock(apHeadingLock);
setAPHeading(apHeading);
setAPAltitudeLock(apAltitudeLock);
setAPAltitude(apAltitude);
setTargetAirport(targetAirport);
setGPSLock(gpsLock);
setGPSTargetLatitude(gpsLatitude);
setGPSTargetLongitude(gpsLongitude);
_needReinit = false;
}
////////////////////////////////////////////////////////////////////////
// Simulation.
////////////////////////////////////////////////////////////////////////
/**
* Return the flight model as an integer.
*
* TODO: use a string instead.
*/
int
FGBFI::getFlightModel ()
{
return current_options.get_flight_model();
}
/**
* Set the flight model as an integer.
*
* TODO: use a string instead.
*/
void
FGBFI::setFlightModel (int model)
{
current_options.set_flight_model(model);
needReinit();
}
/**
* Return the current Zulu time.
*/
time_t
FGBFI::getTimeGMT ()
{
// FIXME: inefficient
return mktime(FGTime::cur_time_params->getGmt());
}
/**
* Set the current Zulu time.
*/
void
FGBFI::setTimeGMT (time_t time)
{
// FIXME: need to update lighting
// and solar system
current_options.set_time_offset(time);
current_options.set_time_offset_type(fgOPTIONS::FG_TIME_GMT_ABSOLUTE);
FGTime::cur_time_params->init(*cur_fdm_state);
FGTime::cur_time_params->update(*cur_fdm_state);
needReinit();
}
/**
* Return true if the HUD is visible.
*/
bool
FGBFI::getHUDVisible ()
{
return current_options.get_hud_status();
}
/**
* Ensure that the HUD is visible or hidden.
*/
void
FGBFI::setHUDVisible (bool visible)
{
current_options.set_hud_status(visible);
}
/**
* Return true if the 2D panel is visible.
*/
bool
FGBFI::getPanelVisible ()
{
return current_options.get_panel_status();
}
/**
* Ensure that the 2D panel is visible or hidden.
*/
void
FGBFI::setPanelVisible (bool visible)
{
if (current_options.get_panel_status() != visible) {
current_options.toggle_panel();
}
}
////////////////////////////////////////////////////////////////////////
// Position
////////////////////////////////////////////////////////////////////////
/**
* Return the current latitude in degrees (negative for south).
*/
double
FGBFI::getLatitude ()
{
return current_aircraft.fdm_state->get_Latitude() * RAD_TO_DEG;
}
/**
* Set the current latitude in degrees (negative for south).
*/
void
FGBFI::setLatitude (double latitude)
{
current_options.set_lat(latitude);
needReinit();
}
/**
* Return the current longitude in degrees (negative for west).
*/
double
FGBFI::getLongitude ()
{
return current_aircraft.fdm_state->get_Longitude() * RAD_TO_DEG;
}
/**
* Set the current longitude in degrees (negative for west).
*/
void
FGBFI::setLongitude (double longitude)
{
current_options.set_lon(longitude);
needReinit();
}
/**
* Return the current altitude in feet.
*/
double
FGBFI::getAltitude ()
{
return current_aircraft.fdm_state->get_Altitude();
}
/**
* Set the current altitude in feet.
*/
void
FGBFI::setAltitude (double altitude)
{
current_options.set_altitude(altitude * FEET_TO_METER);
needReinit();
}
////////////////////////////////////////////////////////////////////////
// Attitude
////////////////////////////////////////////////////////////////////////
/**
* Return the current heading in degrees.
*/
double
FGBFI::getHeading ()
{
return current_aircraft.fdm_state->get_Psi() * RAD_TO_DEG;
}
/**
* Set the current heading in degrees.
*/
void
FGBFI::setHeading (double heading)
{
current_options.set_heading(heading);
needReinit();
}
/**
* Return the current pitch in degrees.
*/
double
FGBFI::getPitch ()
{
return current_aircraft.fdm_state->get_Theta() * RAD_TO_DEG;
}
/**
* Set the current pitch in degrees.
*/
void
FGBFI::setPitch (double pitch)
{
current_options.set_pitch(pitch);
needReinit();
}
/**
* Return the current roll in degrees.
*/
double
FGBFI::getRoll ()
{
return current_aircraft.fdm_state->get_Phi() * RAD_TO_DEG;
}
/**
* Set the current roll in degrees.
*/
void
FGBFI::setRoll (double roll)
{
current_options.set_roll(roll);
needReinit();
}
////////////////////////////////////////////////////////////////////////
// Velocities
////////////////////////////////////////////////////////////////////////
/**
* Return the current airspeed in knots.
*/
double
FGBFI::getAirspeed ()
{
// FIXME: should we add speed-up?
return current_aircraft.fdm_state->get_V_calibrated_kts();
}
/**
* Return the current sideslip (FIXME: units unknown).
*/
double
FGBFI::getSideSlip ()
{
return current_aircraft.fdm_state->get_Beta();
}
/**
* Return the current climb rate in feet/second (FIXME: verify).
*/
double
FGBFI::getVerticalSpeed ()
{
// What about meters?
return current_aircraft.fdm_state->get_Climb_Rate() * 60.0;
}
/**
* Get the current north velocity (units??).
*/
double
FGBFI::getSpeedNorth ()
{
return current_aircraft.fdm_state->get_V_north();
}
/**
* Set the current north velocity (units??).
*/
void
FGBFI::setSpeedNorth (double speed)
{
current_options.set_uBody(speed);
needReinit();
}
/**
* Get the current east velocity (units??).
*/
double
FGBFI::getSpeedEast ()
{
return current_aircraft.fdm_state->get_V_east();
}
/**
* Set the current east velocity (units??).
*/
void
FGBFI::setSpeedEast (double speed)
{
current_options.set_vBody(speed);
needReinit();
}
/**
* Get the current down velocity (units??).
*/
double
FGBFI::getSpeedDown ()
{
return current_aircraft.fdm_state->get_V_down();
}
/**
* Set the current down velocity (units??).
*/
void
FGBFI::setSpeedDown (double speed)
{
current_options.set_wBody(speed);
needReinit();
}
////////////////////////////////////////////////////////////////////////
// Controls
////////////////////////////////////////////////////////////////////////
/**
* Get the throttle setting, from 0.0 (none) to 1.0 (full).
*/
double
FGBFI::getThrottle ()
{
// FIXME: add throttle selector
return controls.get_throttle(0);
}
/**
* Set the throttle, from 0.0 (none) to 1.0 (full).
*/
void
FGBFI::setThrottle (double throttle)
{
// FIXME: allow throttle selection
// FIXME: clamp?
controls.set_throttle(0, throttle);
}
/**
* Get the flaps setting, from 0.0 (none) to 1.0 (full).
*/
double
FGBFI::getFlaps ()
{
return controls.get_flaps();
}
/**
* Set the flaps, from 0.0 (none) to 1.0 (full).
*/
void
FGBFI::setFlaps (double flaps)
{
// FIXME: clamp?
controls.set_flaps(flaps);
}
/**
* Get the aileron, from -1.0 (left) to 1.0 (right).
*/
double
FGBFI::getAileron ()
{
return controls.get_aileron();
}
/**
* Set the aileron, from -1.0 (left) to 1.0 (right).
*/
void
FGBFI::setAileron (double aileron)
{
// FIXME: clamp?
controls.set_aileron(aileron);
}
/**
* Get the rudder setting, from -1.0 (left) to 1.0 (right).
*/
double
FGBFI::getRudder ()
{
return controls.get_rudder();
}
/**
* Set the rudder, from -1.0 (left) to 1.0 (right).
*/
void
FGBFI::setRudder (double rudder)
{
// FIXME: clamp?
controls.set_rudder(rudder);
}
/**
* Get the elevator setting, from -1.0 (down) to 1.0 (up).
*/
double
FGBFI::getElevator ()
{
return controls.get_elevator();
}
/**
* Set the elevator, from -1.0 (down) to 1.0 (up).
*/
void
FGBFI::setElevator (double elevator)
{
// FIXME: clamp?
controls.set_elevator(elevator);
}
/**
* Get the elevator trim, from -1.0 (down) to 1.0 (up).
*/
double
FGBFI::getElevatorTrim ()
{
return controls.get_elevator_trim();
}
/**
* Set the elevator trim, from -1.0 (down) to 1.0 (up).
*/
void
FGBFI::setElevatorTrim (double trim)
{
// FIXME: clamp?
controls.set_elevator_trim(trim);
}
/**
* Get the brake setting, from 0.0 (none) to 1.0 (full).
*/
double
FGBFI::getBrake ()
{
// FIXME: add brake selector
return controls.get_brake(0);
}
/**
* Set the brake, from 0.0 (none) to 1.0 (full).
*/
void
FGBFI::setBrake (double brake)
{
// FIXME: clamp?
// FIXME: allow brake selection
controls.set_brake(0, brake);
}
////////////////////////////////////////////////////////////////////////
// Autopilot
////////////////////////////////////////////////////////////////////////
/**
* Get the autopilot altitude lock (true=on).
*/
bool
FGBFI::getAPAltitudeLock ()
{
return fgAPAltitudeEnabled();
}
/**
* Set the autopilot altitude lock (true=on).
*/
void
FGBFI::setAPAltitudeLock (bool lock)
{
APDataGlobal->altitude_hold = lock;
}
/**
* Get the autopilot target altitude in feet.
*/
double
FGBFI::getAPAltitude ()
{
return fgAPget_TargetAltitude() * METER_TO_FEET;
}
/**
* Set the autopilot target altitude in feet.
*/
void
FGBFI::setAPAltitude (double altitude)
{
fgAPAltitudeSet(altitude);
}
/**
* Get the autopilot heading lock (true=on).
*/
bool
FGBFI::getAPHeadingLock ()
{
return fgAPHeadingEnabled();
}
/**
* Set the autopilot heading lock (true=on).
*/
void
FGBFI::setAPHeadingLock (bool lock)
{
APDataGlobal->heading_hold = lock;
}
/**
* Get the autopilot target heading in degrees.
*/
double
FGBFI::getAPHeading ()
{
return fgAPget_TargetHeading();
}
/**
* Set the autopilot target heading in degrees.
*/
void
FGBFI::setAPHeading (double heading)
{
fgAPHeadingSet(heading);
}
////////////////////////////////////////////////////////////////////////
// GPS
////////////////////////////////////////////////////////////////////////
/**
* Get the autopilot GPS lock (true=on).
*/
bool
FGBFI::getGPSLock ()
{
return fgAPWayPointEnabled();
}
/**
* Set the autopilot GPS lock (true=on).
*/
void
FGBFI::setGPSLock (bool lock)
{
APDataGlobal->waypoint_hold = lock;
}
/**
* Get the GPS target airport code.
*/
const string
FGBFI::getTargetAirport ()
{
return current_options.get_airport_id();
}
/**
* Set the GPS target airport code.
*/
void
FGBFI::setTargetAirport (const string &airportId)
{
current_options.set_airport_id(airportId);
}
/**
* Get the GPS target latitude in degrees (negative for south).
*/
double
FGBFI::getGPSTargetLatitude ()
{
return fgAPget_TargetLatitude();
}
/**
* Set the GPS target latitude in degrees (negative for south).
*/
void
FGBFI::setGPSTargetLatitude (double latitude)
{
APDataGlobal->TargetLatitude = latitude;
}
/**
* Get the GPS target longitude in degrees (negative for west).
*/
double
FGBFI::getGPSTargetLongitude ()
{
return fgAPget_TargetLongitude();
}
/**
* Set the GPS target longitude in degrees (negative for west).
*/
void
FGBFI::setGPSTargetLongitude (double longitude)
{
APDataGlobal->TargetLongitude = longitude;
}
////////////////////////////////////////////////////////////////////////
// Weather
////////////////////////////////////////////////////////////////////////
/**
* Get the current visible (units??).
*/
double
FGBFI::getVisibility ()
{
#ifndef FG_OLD_WEATHER
return WeatherDatabase->getWeatherVisibility();
#else
return current_weather.get_visibility();
#endif
}
/**
* Set the current visibility (units??).
*/
void
FGBFI::setVisibility (double visibility)
{
#ifndef FG_OLD_WEATHER
WeatherDatabase->setWeatherVisibility(visibility);
#else
current_weather.set_visibility(visibility);
#endif
}
// end of bfi.cxx

152
src/Main/bfi.hxx Normal file
View file

@ -0,0 +1,152 @@
// bfi.hxx - Big Flat Interface
//
// Written by David Megginson, started February, 2000.
//
// Copyright (C) 2000 David Megginson - david@megginson.com
//
// 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$
#include <time.h>
#include <string>
FG_USING_NAMESPACE(std);
/**
* Big Flat Interface
*
* This class implements the Facade design pattern (GOF p.185) to provide
* a single, (deceptively) simple flat interface for the FlightGear
* subsystems.
*
* To help cut down on interdependence, subsystems should
* use the BFI whenever possible for inter-system communication.
*
* TODO:
* - add selectors to switch the current plane, throttle, brake, etc.
* - add more autopilot settings
*/
class FGBFI
{
public:
// Reinit if necessary.
static void update ();
// Simulation
static int getFlightModel ();
static time_t getTimeGMT ();
static bool getHUDVisible ();
static bool getPanelVisible ();
static void setFlightModel (int flightModel);
static void setTimeGMT (time_t time);
static void setHUDVisible (bool hudVisible);
static void setPanelVisible (bool panelVisible);
// Position
static double getLatitude ();
static double getLongitude ();
static double getAltitude ();
static void setLatitude (double latitude);
static void setLongitude (double longitude);
static void setAltitude (double altitude);
// Attitude
static double getHeading ();
static double getPitch ();
static double getRoll ();
static void setHeading (double heading);
static void setPitch (double pitch);
static void setRoll (double roll);
// Velocities
static double getAirspeed ();
static double getSideSlip ();
static double getVerticalSpeed ();
static double getSpeedNorth ();
static double getSpeedEast ();
static double getSpeedDown ();
static void setSpeedNorth (double speed);
static void setSpeedEast (double speed);
static void setSpeedDown (double speed);
// Controls
static double getThrottle ();
static double getFlaps ();
static double getAileron ();
static double getRudder ();
static double getElevator ();
static double getElevatorTrim ();
static double getBrake ();
static void setThrottle (double throttle);
static void setFlaps (double flaps);
static void setAileron (double aileron);
static void setRudder (double rudder);
static void setElevator (double elevator);
static void setElevatorTrim (double trim);
static void setBrake (double brake);
// Autopilot
static bool getAPAltitudeLock ();
static double getAPAltitude ();
static bool getAPHeadingLock ();
static double getAPHeading ();
static void setAPAltitudeLock (bool lock);
static void setAPAltitude (double altitude);
static void setAPHeadingLock (bool lock);
static void setAPHeading (double heading);
// GPS
static const string getTargetAirport ();
static bool getGPSLock ();
static double getGPSTargetLatitude ();
static double getGPSTargetLongitude ();
static void setTargetAirport (const string &targetAirport);
static void setGPSLock (bool lock);
static void setGPSTargetLatitude (double latitude);
static void setGPSTargetLongitude (double longitude);
// Weather
static double getVisibility ();
static void setVisibility (double visiblity);
private:
// Will cause a linking error if invoked.
FGBFI ();
static void reinit ();
static void needReinit () { _needReinit = true; }
static bool _needReinit;
};
// end of bfi.hxx

280
src/Main/save.cxx
View file

@ -22,10 +22,6 @@
/*
CHANGES:
- time is now working
- autopilot is working (even with GPS)
TODO:
- use a separate options object so that we can roll back on error
- use proper FGFS logging
@ -41,28 +37,10 @@ TODO:
#include <simgear/constants.h>
#include <simgear/math/fg_types.hxx>
#include <Aircraft/aircraft.hxx>
#include <Controls/controls.hxx>
#include <Autopilot/autopilot.hxx>
#include <Time/fg_time.hxx>
#ifndef FG_OLD_WEATHER
# include <WeatherCM/FGLocalWeatherDatabase.h>
#else
# include <Weather/weather.hxx>
#endif
#include "options.hxx"
#include "save.hxx"
#include "fg_init.hxx"
#include "bfi.hxx"
FG_USING_NAMESPACE(std);
// FIXME: these are not part of the
// published interface!!!
extern fgAPDataPtr APDataGlobal;
extern void fgAPAltitudeSet (double new_altitude);
extern void fgAPHeadingSet (double new_heading);
#define SAVE(name, value) { output << name << ": " << value << endl; }
/**
@ -71,80 +49,72 @@ extern void fgAPHeadingSet (double new_heading);
bool
fgSaveFlight (ostream &output)
{
char tb[100];
const FGInterface * f = current_aircraft.fdm_state;
struct tm *t = FGTime::cur_time_params->getGmt();
output << "#!fgfs" << endl;
//
// Simulation
//
SAVE("flight-model", current_options.get_flight_model());
SAVE("time", mktime(t));
SAVE("hud", current_options.get_hud_status());
SAVE("panel", current_options.get_panel_status());
SAVE("flight-model", FGBFI::getFlightModel());
SAVE("time", FGBFI::getTimeGMT());
SAVE("hud", FGBFI::getHUDVisible());
SAVE("panel", FGBFI::getPanelVisible());
//
// Location
//
SAVE("latitude", (f->get_Latitude() * RAD_TO_DEG));
SAVE("longitude", (f->get_Longitude() * RAD_TO_DEG));
SAVE("altitude", f->get_Altitude());
SAVE("latitude", FGBFI::getLatitude());
SAVE("longitude", FGBFI::getLongitude());
SAVE("altitude", FGBFI::getAltitude());
//
// Orientation
//
SAVE("heading", (f->get_Psi() * RAD_TO_DEG));
SAVE("pitch", (f->get_Theta() * RAD_TO_DEG));
SAVE("roll", (f->get_Phi() * RAD_TO_DEG));
SAVE("heading", FGBFI::getHeading());
SAVE("pitch", FGBFI::getPitch());
SAVE("roll", FGBFI::getRoll());
//
// Velocities
//
SAVE("speed-north", f->get_V_north());
SAVE("speed-east", f->get_V_east());
SAVE("speed-down", f->get_V_down());
SAVE("speed-north", FGBFI::getSpeedNorth());
SAVE("speed-east", FGBFI::getSpeedEast());
SAVE("speed-down", FGBFI::getSpeedDown());
//
// Primary controls
//
SAVE("elevator", controls.get_elevator());
SAVE("aileron", controls.get_aileron());
SAVE("rudder", controls.get_rudder());
SAVE("elevator", FGBFI::getElevator());
SAVE("aileron", FGBFI::getAileron());
SAVE("rudder", FGBFI::getRudder());
// FIXME: save each throttle separately
SAVE("throttle", controls.get_throttle(0));
SAVE("throttle", FGBFI::getThrottle());
//
// Secondary controls
//
SAVE("elevator-trim", controls.get_elevator_trim());
SAVE("flaps", controls.get_flaps());
SAVE("elevator-trim", FGBFI::getElevatorTrim());
SAVE("flaps", FGBFI::getFlaps());
// FIXME: save each brake separately
SAVE("brake", controls.get_brake(0));
SAVE("brake", FGBFI::getBrake());
//
// Navigation.
//
if (current_options.get_airport_id().length() > 0) {
SAVE("target-airport", current_options.get_airport_id());
if (FGBFI::getTargetAirport().length() > 0) {
SAVE("target-airport", FGBFI::getTargetAirport());
}
SAVE("autopilot-altitude-lock", fgAPAltitudeEnabled());
SAVE("autopilot-altitude", fgAPget_TargetAltitude() * METER_TO_FEET);
SAVE("autopilot-heading-lock", fgAPHeadingEnabled());
SAVE("autopilot-heading", fgAPget_TargetHeading());
SAVE("autopilot-gps-lock", fgAPWayPointEnabled());
SAVE("autopilot-gps-lat", fgAPget_TargetLatitude());
SAVE("autopilot-gps-lon", fgAPget_TargetLongitude());
SAVE("autopilot-altitude-lock", FGBFI::getAPAltitudeLock());
SAVE("autopilot-altitude", FGBFI::getAPAltitude());
SAVE("autopilot-heading-lock", FGBFI::getAPHeadingLock());
SAVE("autopilot-heading", FGBFI::getAPHeading());
SAVE("autopilot-gps-lock", FGBFI::getGPSLock());
SAVE("autopilot-gps-lat", FGBFI::getGPSTargetLatitude());
SAVE("autopilot-gps-lon", FGBFI::getGPSTargetLongitude());
//
// Environment.
//
#ifndef FG_OLD_WEATHER
SAVE("visibility", WeatherDatabase->getWeatherVisibility());
#else
SAVE("visibility", current_weather.get_visibility());
#endif
SAVE("visibility", FGBFI::getVisibility());
return true;
}
@ -156,32 +126,11 @@ fgSaveFlight (ostream &output)
bool
fgLoadFlight (istream &input)
{
FGInterface * f = current_aircraft.fdm_state;
// FGInterface * f = current_aircraft.fdm_state;
string text;
double n;
long int i;
double elevator = controls.get_elevator();
double aileron = controls.get_aileron();
double rudder = controls.get_rudder();
double throttle = controls.get_throttle(0);
double elevator_trim = controls.get_elevator_trim();
double flaps = controls.get_flaps();
double brake = controls.get_brake(FGControls::ALL_WHEELS);
bool ap_heading_lock = false;
double ap_heading = 0;
bool ap_altitude_lock = false;
double ap_altitude = 0;
bool ap_gps_lock = false;
double ap_gps_lat = 0;
double ap_gps_lon = 0;
string airport_id = current_options.get_airport_id();
current_options.set_airport_id("");
current_options.set_time_offset(0);
current_options.set_time_offset_type(fgOPTIONS::FG_TIME_GMT_OFFSET);
if (!input.good() || input.eof()) {
cout << "Stream is no good!\n";
return false;
@ -189,7 +138,7 @@ fgLoadFlight (istream &input)
input >> text;
if (text != "#!fgfs") {
printf("Bad save file format!\n");
cerr << "Bad save file format!\n";
return false;
}
@ -204,30 +153,25 @@ fgLoadFlight (istream &input)
if (text == "flight-model:") {
input >> i;
cout << "flight model is " << i << endl;
current_options.set_flight_model(i);
FGBFI::setFlightModel(i);
}
else if (text == "time:") {
input >> i;
cout << "saved time is " << i << endl;
current_options.set_time_offset(i);
current_options.set_time_offset_type(fgOPTIONS::FG_TIME_GMT_ABSOLUTE);
FGTime::cur_time_params->init(*cur_fdm_state);
FGTime::cur_time_params->update(*cur_fdm_state);
FGBFI::setTimeGMT(i);
}
else if (text == "hud:") {
input >> i;
cout << "hud status is " << i << endl;
current_options.set_hud_status(i);
FGBFI::setHUDVisible(i);
}
else if (text == "panel:") {
input >> i;
cout << "panel status is " << i << endl;
if (current_options.get_panel_status() != i) {
current_options.toggle_panel();
}
FGBFI::setPanelVisible(i);
}
//
@ -237,15 +181,19 @@ fgLoadFlight (istream &input)
else if (text == "latitude:") {
input >> n;
cout << "latitude is " << n << endl;
current_options.set_lat(n);
} else if (text == "longitude:") {
FGBFI::setLatitude(n);
}
else if (text == "longitude:") {
input >> n;
cout << "longitude is " << n << endl;
current_options.set_lon(n);
} else if (text == "altitude:") {
FGBFI::setLongitude(n);
}
else if (text == "altitude:") {
input >> n;
cout << "altitude is " << n << endl;
current_options.set_altitude(n * FEET_TO_METER);
FGBFI::setAltitude(n);
}
//
@ -255,15 +203,19 @@ fgLoadFlight (istream &input)
else if (text == "heading:") {
input >> n;
cout << "heading is " << n << endl;
current_options.set_heading(n);
} else if (text == "pitch:") {
FGBFI::setHeading(n);
}
else if (text == "pitch:") {
input >> n;
cout << "pitch is " << n << endl;
current_options.set_pitch(n);
} else if (text == "roll:") {
FGBFI::setPitch(n);
}
else if (text == "roll:") {
input >> n;
cout << "roll is " << n << endl;
current_options.set_roll(n);
FGBFI::setRoll(n);
}
//
@ -273,15 +225,19 @@ fgLoadFlight (istream &input)
else if (text == "speed-north:") {
input >> n;
cout << "speed north is " << n << endl;
current_options.set_uBody(n);
} else if (text == "speed-east:") {
FGBFI::setSpeedNorth(n);
}
else if (text == "speed-east:") {
input >> n;
cout << "speed east is " << n << endl;
current_options.set_vBody(n);
} else if (text == "speed-down:") {
FGBFI::setSpeedEast(n);
}
else if (text == "speed-down:") {
input >> n;
cout << "speed down is " << n << endl;
current_options.set_wBody(n);
FGBFI::setSpeedDown(n);
}
//
@ -289,42 +245,49 @@ fgLoadFlight (istream &input)
//
else if (text == "elevator:") {
input >> elevator;
cout << "elevator is " << elevator << endl;
input >> n;
cout << "elevator is " << n << endl;
FGBFI::setElevator(n);
}
else if (text == "aileron:") {
input >> aileron;
cout << "aileron is " << aileron << endl;
input >> n;
cout << "aileron is " << n << endl;
FGBFI::setAileron(n);
}
else if (text == "rudder:") {
input >> rudder;
cout << "rudder is " << rudder << endl;
input >> n;
cout << "rudder is " << n << endl;
FGBFI::setRudder(n);
}
// FIXME: assumes single engine
else if (text == "throttle:") {
input >> throttle;
cout << "throttle is " << throttle << endl;
input >> n;
cout << "throttle is " << n << endl;
FGBFI::setThrottle(n);
}
//
// Secondary controls
else if (text == "elevator-trim:") {
input >> elevator_trim;
cout << "elevator trim is " << elevator_trim << endl;
input >> n;
cout << "elevator trim is " << n << endl;
FGBFI::setElevatorTrim(n);
}
else if (text == "flaps:") {
input >> flaps;
cout << "flaps are " << flaps << endl;
input >> n;
cout << "flaps are " << n << endl;
FGBFI::setFlaps(n);
}
else if (text == "brake:") {
input >> brake;
cout << "brake is " << brake << endl;
input >> n;
cout << "brake is " << n << endl;
FGBFI::setBrake(n);
}
//
@ -332,41 +295,51 @@ fgLoadFlight (istream &input)
//
else if (text == "target-airport:") {
input >> airport_id;
cout << "target airport is " << airport_id << endl;
input >> text;
cout << "target airport is " << text << endl;
FGBFI::setTargetAirport(text);
}
else if (text == "autopilot-altitude-lock:") {
input >> ap_altitude_lock;
cout << "autopilot altitude lock is " << ap_altitude_lock << endl;
input >> i;
cout << "autopilot altitude lock is " << i << endl;
FGBFI::setAPAltitudeLock(i);
}
else if (text == "autopilot-altitude:") {
input >> ap_altitude;
cout << "autopilot altitude is " << ap_altitude << endl;
input >> n;
cout << "autopilot altitude is " << n << endl;
FGBFI::setAPAltitude(n);
}
else if (text == "autopilot-heading-lock:") {
input >> ap_heading_lock;
cout << "autopilot heading lock is " << ap_heading_lock << endl;
input >> i;
cout << "autopilot heading lock is " << i << endl;
FGBFI::setAPHeadingLock(i);
}
else if (text == "autopilot-heading:") {
input >> ap_heading;
cout << "autopilot heading is " << ap_heading << endl;
input >> n;
cout << "autopilot heading is " << n << endl;
FGBFI::setAPHeading(n);
}
else if (text == "autopilot-gps-lock:") {
input >> ap_gps_lock;
cout << "autopilot GPS lock is " << ap_gps_lock << endl;
input >> i;
cout << "autopilot GPS lock is " << i << endl;
FGBFI::setGPSLock(i);
}
else if (text == "autopilot-gps-lat:") {
input >> ap_gps_lat;
input >> n;
cout << "GPS target latitude is " << n << endl;
FGBFI::setGPSTargetLatitude(n);
}
else if (text == "autopilot-gps-lon:") {
input >> ap_gps_lon;
input >> n;
cout << "GPS target longitude is " << n << endl;
FGBFI::setGPSTargetLongitude(n);
}
//
@ -376,12 +349,7 @@ fgLoadFlight (istream &input)
else if (text == "visibility:") {
input >> n;
cout << "visibility is " << n << endl;
#ifndef FG_OLD_WEATHER
WeatherDatabase->setWeatherVisibility(n);
#else
current_weather.set_visibility(n);
#endif
FGBFI::setVisibility(n);
}
//
@ -394,33 +362,7 @@ fgLoadFlight (istream &input)
}
}
fgReInitSubsystems();
// Set airport and controls after the
// re-init.
current_options.set_airport_id(airport_id);
// The controls have to be set after
// the reinit
controls.set_elevator(elevator);
controls.set_aileron(aileron);
controls.set_rudder(rudder);
controls.set_throttle(FGControls::ALL_ENGINES, throttle);
controls.set_elevator_trim(elevator_trim);
controls.set_flaps(flaps);
controls.set_brake(FGControls::ALL_WHEELS, brake);
// Ditto for the autopilot.
// FIXME: shouldn't have to use
// APDataGlobal.
APDataGlobal->heading_hold = ap_heading_lock;
APDataGlobal->altitude_hold = ap_altitude_lock;
fgAPHeadingSet(ap_heading);
fgAPAltitudeSet(ap_altitude);
// GPS overrides heading
APDataGlobal->waypoint_hold = ap_gps_lock;
APDataGlobal->TargetLatitude = ap_gps_lat;
APDataGlobal->TargetLongitude = ap_gps_lon;
FGBFI::update();
return true;
}