fly/flightgear
1
0
Fork 0
Code Activity

Merge branches 'jmt/navradio', 'jmt/cleanup' and 'torsten/gps-fix'

Browse source
This commit is contained in:
Tim Moore 2009-10-01 15:17:24 +02:00
commit 8b10bb12f5
23 changed files with 245 additions and 374 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
src/Cockpit/cockpit.cxx
View file

@ -44,6 +44,7 @@
#include <Main/globals.hxx>
#include <Main/fg_props.hxx>
#include <Main/viewmgr.hxx>
#include <Main/viewer.hxx>
#include <Scenery/scenery.hxx>
#include <GUI/gui.h>

1
src/Cockpit/hud.cxx
View file

@ -48,6 +48,7 @@
#include <Main/globals.hxx>
#include <Scenery/scenery.hxx>
#include <Airports/runways.hxx>
#include <Main/viewer.hxx>
#include "hud.hxx"

2
src/Cockpit/hud_ladr.cxx
View file

@ -6,7 +6,7 @@
#include "hud.hxx"
#include "panel.hxx"
#include <Main/viewer.hxx>
// FIXME
extern float get_roll(void);

1
src/Cockpit/hud_rwy.cxx
View file

@ -31,6 +31,7 @@
#include <Environment/environment.hxx>
#include <Environment/environment_mgr.hxx>
#include <ATCDCL/ATCutils.hxx>
#include <Main/viewer.hxx>
#include <osg/GLU>

6
src/Cockpit/panel.cxx
View file

@ -31,6 +31,8 @@
# include <config.h>
#endif
#include "panel.hxx"
#include <stdio.h> // sprintf
#include <string.h>
#include <iostream>
@ -55,9 +57,11 @@
#include <Main/viewmgr.hxx>
#include <Time/light.hxx>
#include <GUI/new_gui.hxx> // FGFontCache
#include <Main/viewer.hxx>
#include <Instrumentation/dclgps.hxx>
#include "hud.hxx"
#include "panel.hxx"
#define WIN_X 0
#define WIN_Y 0

62
src/Cockpit/panel.hxx
View file

@ -21,21 +21,10 @@
#ifndef __PANEL_HXX
#define __PANEL_HXX
#ifndef __cplusplus
# error This library requires C++
#endif
#ifdef HAVE_CONFIG_H
# include <config.h>
#endif
#include <osg/ref_ptr>
#include <osg/StateSet>
#include <osg/Texture2D>
#include <plib/fnt.h>
#include <simgear/compiler.h>
#include <simgear/props/props.hxx>
#include <simgear/structure/subsystem_mgr.hxx>
@ -48,16 +37,11 @@
#include <map>
#include <Main/fg_props.hxx>
#include <Instrumentation/dclgps.hxx>
using std::vector;
using std::map;
class FGPanelInstrument;
class fntFont;
class DCLGPS;
////////////////////////////////////////////////////////////////////////
// Texture management.
////////////////////////////////////////////////////////////////////////
@ -71,11 +55,11 @@ class FGPanelInstrument;
class FGTextureManager
{
public:
static osg::Texture2D* createTexture(const string &relativePath,
static osg::Texture2D* createTexture(const std::string &relativePath,
bool staticTexture = true);
static void addTexture(const string &relativePath, osg::Texture2D* texture);
static void addTexture(const std::string &relativePath, osg::Texture2D* texture);
private:
static map<string,osg::ref_ptr<osg::Texture2D> > _textureMap;
static std::map<std::string,osg::ref_ptr<osg::Texture2D> > _textureMap;
};
@ -89,14 +73,14 @@ class FGCroppedTexture
public:
FGCroppedTexture ();
FGCroppedTexture (const string &path,
FGCroppedTexture (const std::string &path,
float _minX = 0.0, float _minY = 0.0,
float _maxX = 1.0, float _maxY = 1.0);
virtual ~FGCroppedTexture ();
virtual void setPath (const string &path) { _path = path; }
virtual void setPath (const std::string &path) { _path = path; }
virtual const string &getPath () const { return _path; }
virtual const std::string &getPath () const { return _path; }
virtual osg::StateSet* getTexture ();
@ -111,7 +95,7 @@ public:
private:
string _path;
std::string _path;
osg::ref_ptr<osg::StateSet> _texture;
float _minX, _minY, _maxX, _maxY;
};
@ -199,7 +183,7 @@ private:
mutable int _mouseButton, _mouseX, _mouseY;
mutable int _mouseDelay;
mutable FGPanelInstrument * _mouseInstrument;
typedef vector<FGPanelInstrument *> instrument_list_type;
typedef std::vector<FGPanelInstrument *> instrument_list_type;
int _width;
int _height;
int _view_height;
@ -273,7 +257,7 @@ public:
virtual bool doAction (int updown);
private:
typedef vector<SGBinding *> binding_list_t;
typedef std::vector<SGBinding *> binding_list_t;
int _button;
int _x;
@ -356,7 +340,7 @@ public:
protected:
int _w, _h;
typedef vector<FGPanelTransformation *> transformation_list;
typedef std::vector<FGPanelTransformation *> transformation_list;
transformation_list _transformations;
};
@ -403,7 +387,7 @@ public:
protected:
int _x, _y, _w, _h;
typedef vector<FGPanelAction *> action_list_type;
typedef std::vector<FGPanelAction *> action_list_type;
action_list_type _actions;
};
@ -430,7 +414,7 @@ public:
virtual void addTransformation (FGPanelTransformation * transformation);
protected:
typedef vector<FGInstrumentLayer *> layer_list;
typedef std::vector<FGInstrumentLayer *> layer_list;
layer_list _layers;
};
@ -473,7 +457,7 @@ public:
// transfer pointer ownership
virtual void addLayer (FGInstrumentLayer * layer);
protected:
vector<FGInstrumentLayer *> _layers;
std::vector<FGInstrumentLayer *> _layers;
};
@ -526,17 +510,17 @@ public:
class Chunk : public SGConditional
{
public:
Chunk (const string &text, const string &fmt = "%s");
Chunk (const std::string &text, const std::string &fmt = "%s");
Chunk (ChunkType type, const SGPropertyNode * node,
const string &fmt = "", float mult = 1.0, float offs = 0.0,
const std::string &fmt = "", float mult = 1.0, float offs = 0.0,
bool truncation = false);
const char * getValue () const;
private:
ChunkType _type;
string _text;
std::string _text;
SGConstPropertyNode_ptr _node;
string _fmt;
std::string _fmt;
float _mult;
float _offs;
bool _trunc;
@ -552,20 +536,20 @@ public:
virtual void addChunk (Chunk * chunk);
virtual void setColor (float r, float g, float b);
virtual void setPointSize (float size);
virtual void setFontName ( const string &name );
virtual void setFontName ( const std::string &name );
virtual void setFont (fntFont * font);
private:
void recalc_value () const;
typedef vector<Chunk *> chunk_list;
typedef std::vector<Chunk *> chunk_list;
chunk_list _chunks;
float _color[4];
float _pointSize;
mutable string _font_name;
mutable string _value;
mutable std::string _font_name;
mutable std::string _value;
mutable SGTimeStamp _then;
mutable SGTimeStamp _now;
};

2
src/Environment/environment.cxx
View file

@ -29,8 +29,6 @@
#include <boost/tuple/tuple.hpp>
#include <plib/sg.h>
#include <simgear/constants.h>
#include <simgear/debug/logstream.hxx>
#include <simgear/math/interpolater.hxx>

37
src/FDM/LaRCsim/LaRCsimIC.hxx
View file

@ -30,8 +30,6 @@
INCLUDES
*******************************************************************************/
#include <plib/sg.h>
#include "ls_constants.h"
#include "ls_types.h"
@ -43,6 +41,7 @@ CLASS DECLARATION
#define M_TO_FT 3.2808399
#define DEFAULT_AGL_ALT 3.758099
#define DEFAULT_PITCH_ON_GROUND 0.0074002
#define DEGREES_TO_RADIANS (M_PI / 180.0)
enum lsspeedset { lssetvt, lssetvc, lssetve, lssetmach, lssetuvw, lssetned };
enum lsaltset { lssetasl, lssetagl };
@ -71,7 +70,7 @@ public:
void SetAltitudeAGLFtIC(SCALAR tt);
//"vertical" flight path, recalculate theta
inline void SetFlightPathAngleDegIC(SCALAR tt) { SetFlightPathAngleRadIC(tt*SGD_DEGREES_TO_RADIANS); }
inline void SetFlightPathAngleDegIC(SCALAR tt) { SetFlightPathAngleRadIC(tt*DEGREES_TO_RADIANS); }
void SetFlightPathAngleRadIC(SCALAR tt);
//set speed first
@ -79,26 +78,26 @@ public:
void SetClimbRateFpsIC(SCALAR tt);
//use currently stored gamma, recalcualte theta
inline void SetAlphaDegIC(SCALAR tt) { alpha=tt*SGD_DEGREES_TO_RADIANS; getTheta(); }
inline void SetAlphaDegIC(SCALAR tt) { alpha=tt*DEGREES_TO_RADIANS; getTheta(); }
inline void SetAlphaRadIC(SCALAR tt) { alpha=tt; getTheta(); }
//use currently stored gamma, recalcualte alpha
inline void SetPitchAngleDegIC(SCALAR tt) { SetPitchAngleRadIC(tt*SGD_DEGREES_TO_RADIANS); }
inline void SetPitchAngleDegIC(SCALAR tt) { SetPitchAngleRadIC(tt*DEGREES_TO_RADIANS); }
void SetPitchAngleRadIC(SCALAR tt);
inline void SetBetaDegIC(SCALAR tt) { beta=tt*SGD_DEGREES_TO_RADIANS; getTheta();}
inline void SetBetaDegIC(SCALAR tt) { beta=tt*DEGREES_TO_RADIANS; getTheta();}
inline void SetBetaRadIC(SCALAR tt) { beta=tt; getTheta(); }
inline void SetRollAngleDegIC(SCALAR tt) { phi=tt*SGD_DEGREES_TO_RADIANS; getTheta(); }
inline void SetRollAngleDegIC(SCALAR tt) { phi=tt*DEGREES_TO_RADIANS; getTheta(); }
inline void SetRollAngleRadIC(SCALAR tt) { phi=tt; getTheta(); }
inline void SetHeadingDegIC(SCALAR tt) { psi=tt*SGD_DEGREES_TO_RADIANS; }
inline void SetHeadingDegIC(SCALAR tt) { psi=tt*DEGREES_TO_RADIANS; }
inline void SetHeadingRadIC(SCALAR tt) { psi=tt; }
inline void SetLatitudeGDDegIC(SCALAR tt) { SetLatitudeGDRadIC(tt*SGD_DEGREES_TO_RADIANS); }
inline void SetLatitudeGDDegIC(SCALAR tt) { SetLatitudeGDRadIC(tt*DEGREES_TO_RADIANS); }
void SetLatitudeGDRadIC(SCALAR tt);
inline void SetLongitudeDegIC(SCALAR tt) { longitude=tt*SGD_DEGREES_TO_RADIANS; }
inline void SetLongitudeDegIC(SCALAR tt) { longitude=tt*DEGREES_TO_RADIANS; }
inline void SetLongitudeRadIC(SCALAR tt) { longitude=tt; }
void SetRunwayAltitudeFtIC(SCALAR tt);
@ -114,32 +113,32 @@ public:
inline SCALAR GetRunwayAltitudeFtIC(void) { return runway_altitude; }
inline SCALAR GetFlightPathAngleDegIC(void) { return gamma*SGD_RADIANS_TO_DEGREES; }
inline SCALAR GetFlightPathAngleDegIC(void) { return gamma*DEGREES_TO_RADIANS; }
inline SCALAR GetFlightPathAngleRadIC(void) { return gamma; }
inline SCALAR GetClimbRateFpmIC(void) { return hdot*60; }
inline SCALAR GetClimbRateFpsIC(void) { return hdot; }
inline SCALAR GetAlphaDegIC(void) { return alpha*SGD_RADIANS_TO_DEGREES; }
inline SCALAR GetAlphaDegIC(void) { return alpha*DEGREES_TO_RADIANS; }
inline SCALAR GetAlphaRadIC(void) { return alpha; }
inline SCALAR GetPitchAngleDegIC(void) { return theta*SGD_RADIANS_TO_DEGREES; }
inline SCALAR GetPitchAngleDegIC(void) { return theta*DEGREES_TO_RADIANS; }
inline SCALAR GetPitchAngleRadIC(void) { return theta; }
inline SCALAR GetBetaDegIC(void) { return beta*SGD_RADIANS_TO_DEGREES; }
inline SCALAR GetBetaRadIC(void) { return beta*SGD_RADIANS_TO_DEGREES; }
inline SCALAR GetBetaDegIC(void) { return beta*DEGREES_TO_RADIANS; }
inline SCALAR GetBetaRadIC(void) { return beta*DEGREES_TO_RADIANS; }
inline SCALAR GetRollAngleDegIC(void) { return phi*SGD_RADIANS_TO_DEGREES; }
inline SCALAR GetRollAngleDegIC(void) { return phi*DEGREES_TO_RADIANS; }
inline SCALAR GetRollAngleRadIC(void) { return phi; }
inline SCALAR GetHeadingDegIC(void) { return psi*SGD_RADIANS_TO_DEGREES; }
inline SCALAR GetHeadingDegIC(void) { return psi*DEGREES_TO_RADIANS; }
inline SCALAR GetHeadingRadIC(void) { return psi; }
inline SCALAR GetLatitudeGDDegIC(void) { return latitude_gd*SGD_RADIANS_TO_DEGREES; }
inline SCALAR GetLatitudeGDDegIC(void) { return latitude_gd*DEGREES_TO_RADIANS; }
inline SCALAR GetLatitudeGDRadIC(void) { return latitude_gd; }
inline SCALAR GetLongitudeDegIC(void) { return longitude*SGD_RADIANS_TO_DEGREES; }
inline SCALAR GetLongitudeDegIC(void) { return longitude*DEGREES_TO_RADIANS; }
inline SCALAR GetLongitudeRadIC(void) { return longitude; }
inline SCALAR GetUBodyFpsIC(void) { return vt*cos(alpha)*cos(beta); }

1
src/Instrumentation/HUD/HUD.cxx
View file

@ -35,6 +35,7 @@
#include <Main/globals.hxx>
#include <Main/viewmgr.hxx>
#include <Main/viewer.hxx>
#include "HUD.hxx"

5
src/Instrumentation/gps.cxx
View file

@ -476,8 +476,9 @@ GPS::updateTTWNode(UpdateContext& ctx, double distance_m, SGPropertyNode_ptr nod
// increase. Makes most sense when travelling directly towards
// the waypoint.
double TTW = 0.0;
if (ctx.speed_kt > 0.0 && distance_m > 0.0) {
TTW = (distance_m * SG_METER_TO_NM) / (ctx.speed_kt / 3600);
double speed_nm_per_second = ctx.speed_kt / 3600;
if (speed_nm_per_second > SGLimitsd::min() && distance_m > 0.0) {
TTW = (distance_m * SG_METER_TO_NM) / speed_nm_per_second;
}
if (TTW < 356400.5) { // That's 99 hours
unsigned int TTW_seconds = (int) (TTW + 0.5);

1
src/Instrumentation/mag_compass.cxx
View file

@ -10,7 +10,6 @@
# include <config.h>
#endif
#include <plib/sg.h>
#include <simgear/sg_inlines.h>
#include "mag_compass.hxx"

69
src/Instrumentation/render_area_2d.cxx
View file

@ -28,11 +28,6 @@
#include "render_area_2d.hxx"
static const float dummy_normals[][3] = {{0.0f, 0.0f, 0.0f},
{0.0f, 0.0f, 0.0f},
{0.0f, 0.0f, 0.0f},
{0.0f, 0.0f, 0.0f}};
RA2DPrimitive::RA2DPrimitive() {
invert = false;
debug = false;
@ -184,13 +179,13 @@ void RenderArea2D::oldDrawPixel(int x, int y, bool invert) {
//cout << "DP: " << fx1 << ", " << fy1 << " ... " << fx2 << ", " << fy2 << '\n';
doSetColor(invert ? _backgroundColor : _pixelColor);
sgVec2 corners[4];
sgSetVec2(corners[0], fx1, fy1);
sgSetVec2(corners[1], fx2, fy1);
sgSetVec2(corners[2], fx2, fy2);
sgSetVec2(corners[3], fx1, fy2);
//cout << "Drawing pixel, x,y is " << x << ", " << y << ", fx is [x1,x2,y1,y2] " << fx1 << ", " << fx2 << ", " << fy1 << ", " << fy2 << '\n';
doDrawQuad(&corners[0], dummy_normals);
SGVec2f corners[4] = {
SGVec2f(fx1, fy1),
SGVec2f(fx2, fy1),
SGVec2f(fx2, fy2),
SGVec2f(fx1, fy2)
};
doDrawQuad(corners);
}
void RenderArea2D::DrawLine(int x1, int y1, int x2, int y2) {
@ -314,12 +309,13 @@ void RenderArea2D::oldDrawQuad(int x1, int y1, int x2, int y2, bool invert) {
//cout << "DP: " << fx1 << ", " << fy1 << " ... " << fx2 << ", " << fy2 << '\n';
doSetColor(invert ? _backgroundColor : _pixelColor);
sgVec2 corners[4];
sgSetVec2(corners[0], fx1, fy1);
sgSetVec2(corners[1], fx2, fy1);
sgSetVec2(corners[2], fx2, fy2);
sgSetVec2(corners[3], fx1, fy2);
doDrawQuad(&corners[0], dummy_normals);
SGVec2f corners[4] = {
SGVec2f(fx1, fy1),
SGVec2f(fx2, fy1),
SGVec2f(fx2, fy2),
SGVec2f(fx1, fy2)
};
doDrawQuad(corners);
}
void RenderArea2D::DrawBackground() {
@ -328,12 +324,14 @@ void RenderArea2D::DrawBackground() {
void RenderArea2D::oldDrawBackground() {
doSetColor(_backgroundColor);
sgVec2 corners[4];
sgSetVec2(corners[0], (float)_posx, (float)_posy);
sgSetVec2(corners[1], (float)(_posx + _sizex), (float)_posy);
sgSetVec2(corners[2], (float)(_posx + _sizex), (float)(_posy + _sizey));
sgSetVec2(corners[3], (float)_posx, (float)(_posy + _sizey));
doDrawQuad(&corners[0], dummy_normals);
SGVec2f corners[4] = {
SGVec2f(_posx, _posy),
SGVec2f(_posx + _sizex, _posy),
SGVec2f(_posx + _sizex, _posy + _sizey),
SGVec2f(_posx, _posy + _sizey)
};
doDrawQuad(corners);
}
void RenderArea2D::Flush() {
@ -351,20 +349,23 @@ void RenderArea2D::doSetColor( const float *rgba ) {
glColor4fv( rgba );
}
void RenderArea2D::doDrawQuad( const sgVec2 *p, const sgVec3 *normals ) {
void RenderArea2D::doDrawQuad( const SGVec2f *p) {
glBegin(GL_QUADS);
glNormal3fv( normals[0] ); glVertex2fv( p[0] );
glNormal3fv( normals[1] ); glVertex2fv( p[1] );
glNormal3fv( normals[2] ); glVertex2fv( p[2] );
glNormal3fv( normals[3] ); glVertex2fv( p[3] );
glNormal3f(0.0f, 0.0f, 0.0f);
glVertex2fv( p[0].data() );
glVertex2fv( p[1].data() );
glVertex2fv( p[2].data() );
glVertex2fv( p[3].data() );
glEnd();
}
void RenderArea2D::doDrawQuad( const sgVec2 *p, const sgVec3 *normals, const sgVec4 *color ) {
void RenderArea2D::doDrawQuad( const SGVec2f *p, const SGVec4f *color ) {
glBegin(GL_QUADS);
glColor4fv( color[0] );glNormal3fv( normals[0] ); glVertex2fv( p[0] );
glColor4fv( color[1] );glNormal3fv( normals[1] ); glVertex2fv( p[1] );
glColor4fv( color[2] );glNormal3fv( normals[2] ); glVertex2fv( p[2] );
glColor4fv( color[3] );glNormal3fv( normals[3] ); glVertex2fv( p[3] );
glNormal3f(0.0f, 0.0f, 0.0f);
glColor4fv( color[0].data() ); glVertex2fv( p[0].data() );
glColor4fv( color[1].data() ); glVertex2fv( p[1].data() );
glColor4fv( color[2].data() ); glVertex2fv( p[2].data() );
glColor4fv( color[3].data() ); glVertex2fv( p[3].data() );
glEnd();
}

6
src/Instrumentation/render_area_2d.hxx
View file

@ -32,8 +32,8 @@
#include <osg/State>
#include <osg/StateSet>
#include <plib/sg.h>
#include <simgear/compiler.h>
#include <simgear/math/SGMath.hxx>
#include <vector>
@ -106,8 +106,8 @@ private:
// Actual drawing routines copied from Atlas
void doSetColor( const float *rgb );
void doDrawQuad( const sgVec2 *p, const sgVec3 *normals );
void doDrawQuad( const sgVec2 *p, const sgVec3 *normals, const sgVec4 *color );
void doDrawQuad( const SGVec2f *p);
void doDrawQuad( const SGVec2f *p, const SGVec4f *color );
vector<RA2DPrimitive> drawing_list;

1
src/Main/fg_commands.cxx
View file

@ -47,6 +47,7 @@
#include "util.hxx"
#include "viewmgr.hxx"
#include "main.hxx"
#include <Main/viewer.hxx>
using std::string;
using std::ifstream;

2
src/Main/fg_props.hxx
View file

@ -12,7 +12,7 @@
#include <simgear/math/SGMath.hxx>
#include <Main/globals.hxx>
////////////////////////////////////////////////////////////////////////
// Property management.
////////////////////////////////////////////////////////////////////////

130
src/Main/main.cxx
View file

@ -63,6 +63,7 @@
#include <Scenery/tilemgr.hxx>
#include <Sound/beacon.hxx>
#include <Sound/morse.hxx>
#include <Sound/fg_fx.hxx>
#include <FDM/flight.hxx>
#include <ATCDCL/ATCmgr.hxx>
#include <ATCDCL/AIMgr.hxx>
@ -81,7 +82,7 @@
#include "fg_init.hxx"
#include "fg_os.hxx"
#include "WindowSystemAdapter.hxx"
#include <Main/viewer.hxx>
static double real_delta_time_sec = 0.0;
double delta_time_sec = 0.0;
@ -451,13 +452,6 @@ static void fgMainLoop( void ) {
"Elapsed time is zero ... we're zinging" );
}
// Run audio scheduler
#ifdef ENABLE_AUDIO_SUPPORT
if ( globals->get_soundmgr()->is_working() ) {
globals->get_soundmgr()->update( delta_time_sec );
}
#endif
globals->get_subsystem_mgr()->update(delta_time_sec);
//
@ -466,7 +460,6 @@ static void fgMainLoop( void ) {
// we may want to move this to its own class at some point
//
double visibility_meters = fgGetDouble("/environment/visibility-m");
FGViewer *current_view = globals->get_current_view();
globals->get_tile_mgr()->prep_ssg_nodes( visibility_meters );
// update tile manager for view...
@ -484,123 +477,10 @@ static void fgMainLoop( void ) {
// update the view angle as late as possible, but before sound calculations
globals->get_viewmgr()->update(real_delta_time_sec);
// Run audio scheduler
#ifdef ENABLE_AUDIO_SUPPORT
if ( globals->get_soundmgr()->is_working() ) {
// Right now we make a simplifying assumption that the primary
// aircraft is the source of all sounds and that all sounds are
// positioned in the aircraft base
static sgdVec3 last_listener_pos = {0, 0, 0};
static sgdVec3 last_model_pos = {0, 0, 0};
// get the orientation
const SGQuatd view_or = current_view->getViewOrientation();
SGQuatd surf_or = SGQuatd::fromLonLat(current_view->getPosition());
SGQuatd model_or = SGQuatd::fromYawPitchRollDeg(
globals->get_aircraft_model()->get3DModel()->getHeadingDeg(),
globals->get_aircraft_model()->get3DModel()->getPitchDeg(),
globals->get_aircraft_model()->get3DModel()->getRollDeg());
// get the up and at vector in the aircraft base
// (ok, the up vector is a down vector, but the coordinates
// are finally calculated in a left hand system and openal
// lives in a right hand system. Therefore we need to pass
// the down vector to get correct stereo sound.)
SGVec3d sgv_up = model_or.rotateBack(
surf_or.rotateBack(view_or.rotate(SGVec3d(0, 1, 0))));
sgVec3 up;
sgSetVec3(up, sgv_up[0], sgv_up[1], sgv_up[2]);
SGVec3d sgv_at = model_or.rotateBack(
surf_or.rotateBack(view_or.rotate(SGVec3d(0, 0, 1))));
sgVec3 at;
sgSetVec3(at, sgv_at[0], sgv_at[1], sgv_at[2]);
// get the location data for the primary FDM (now hardcoded to ac model)...
SGGeod geodPos = globals->get_aircraft_model()->get3DModel()->getPosition();
SGVec3d model_pos = SGVec3d::fromGeod(geodPos);
// Calculate speed of listener and model. This code assumes the
// listener is either tracking the model at the same speed or
// stationary.
sgVec3 listener_vel, model_vel;
SGVec3d SGV3d_help;
sgdVec3 sgdv3_help;
sgdVec3 sgdv3_null = {0, 0, 0};
// the aircraft velocity as reported by the fdm (this will not
// vary or be affected by frame rates or timing jitter.)
sgVec3 fdm_vel_vec;
sgSetVec3( fdm_vel_vec,
vn_fps->getDoubleValue() * SG_FEET_TO_METER,
ve_fps->getDoubleValue() * SG_FEET_TO_METER,
vd_fps->getDoubleValue() * SG_FEET_TO_METER );
double fdm_vel = sgLengthVec3(fdm_vel_vec);
// compute the aircraft velocity vector and scale it to the length
// of the fdm velocity vector. This gives us a vector in the
// proper coordinate system, but also with the proper time
// invariant magnitude.
sgdSubVec3( sgdv3_help,
last_model_pos, model_pos.data());
sgdAddVec3( last_model_pos, sgdv3_null, model_pos.data());
SGV3d_help = model_or.rotateBack(
surf_or.rotateBack(SGVec3d(sgdv3_help[0],
sgdv3_help[1], sgdv3_help[2])));
sgSetVec3( model_vel, SGV3d_help[0], SGV3d_help[1], SGV3d_help[2]);
float vel = sgLengthVec3(model_vel);
if ( fabs(vel) > 0.0001 ) {
if ( fabs(fdm_vel / vel) > 0.0001 ) {
sgScaleVec3( model_vel, fdm_vel / vel );
}
}
// check for moving or stationary listener (view position)
sgdSubVec3( sgdv3_help,
last_listener_pos, current_view->get_view_pos().data());
sgdAddVec3( last_listener_pos,
sgdv3_null, current_view->get_view_pos().data());
if ( sgdLengthVec3(sgdv3_help) > 0.2 ) {
sgCopyVec3( listener_vel, model_vel );
} else {
sgSetVec3( listener_vel, 0.0, 0.0, 0.0 );
}
globals->get_soundmgr()->set_listener_vel( listener_vel );
// set positional offset for sources
sgdVec3 dsource_pos_offset;
sgdSubVec3( dsource_pos_offset,
current_view->get_view_pos().data(),
model_pos.data() );
SGVec3d sgv_dsource_pos_offset = model_or.rotateBack(
surf_or.rotateBack(SGVec3d(dsource_pos_offset[0],
dsource_pos_offset[1], dsource_pos_offset[2])));
sgVec3 source_pos_offset;
sgSetVec3(source_pos_offset, sgv_dsource_pos_offset[0],
sgv_dsource_pos_offset[1], sgv_dsource_pos_offset[2]);
globals->get_soundmgr()->set_source_pos_all( source_pos_offset );
float orient[6];
for (int i = 0; i < 3; i++) {
orient[i] = sgv_at[i];
orient[i + 3] = sgv_up[i];
}
globals->get_soundmgr()->set_listener_orientation( orient );
// set the velocity
// all sources are defined to be in the model
globals->get_soundmgr()->set_source_vel_all( model_vel );
// The listener is always positioned at the origin.
sgVec3 listener_pos;
sgSetVec3( listener_pos, 0.0, 0.0, 0.0 );
globals->get_soundmgr()->set_listener_pos( listener_pos );
}
FGFX* fx = (FGFX*) globals->get_subsystem("fx");
fx->update_fx_late(delta_time_sec);
#endif
// END Tile Manager udpates

2
src/Main/options.cxx
View file

@ -60,7 +60,7 @@
#include "options.hxx"
#include "util.hxx"
#include "viewmgr.hxx"
#include <Main/viewer.hxx>
using std::string;
using std::sort;

1
src/Main/renderer.cxx
View file

@ -99,6 +99,7 @@
#include "main.hxx"
#include "CameraGroup.hxx"
#include "FGEventHandler.hxx"
#include <Main/viewer.hxx>
using namespace osg;
using namespace simgear;

7
src/Main/viewer.hxx
View file

@ -25,12 +25,7 @@
#ifndef _VIEWER_HXX
#define _VIEWER_HXX
#ifndef __cplusplus
# error This library requires C++
#endif
#define _VIEWER_HXX
namespace flightgear
{

72
src/Main/viewmgr.cxx
View file

@ -25,14 +25,14 @@
# include "config.h"
#endif
#include "viewmgr.hxx"
#include <string.h> // strcmp
#include <simgear/compiler.h>
#include <Model/acmodel.hxx>
#include "viewmgr.hxx"
#include <Main/viewer.hxx>
#include <Main/fg_props.hxx>
// Constructor
FGViewMgr::FGViewMgr( void ) :
@ -341,7 +341,71 @@ FGViewMgr::copyToCurrent()
get_current_view()->getInternal());
}
void FGViewMgr::clear()
{
views.clear();
}
FGViewer*
FGViewMgr::get_current_view()
{
if ( current < (int)views.size() ) {
return views[current];
} else {
return NULL;
}
}
const FGViewer*
FGViewMgr::get_current_view() const
{
if ( current < (int)views.size() ) {
return views[current];
} else {
return NULL;
}
}
FGViewer*
FGViewMgr::get_view( int i )
{
if ( i < 0 ) { i = 0; }
if ( i >= (int)views.size() ) { i = views.size() - 1; }
return views[i];
}
const FGViewer*
FGViewMgr::get_view( int i ) const
{
if ( i < 0 ) { i = 0; }
if ( i >= (int)views.size() ) { i = views.size() - 1; }
return views[i];
}
FGViewer*
FGViewMgr::next_view()
{
setView((current+1 < (int)views.size()) ? (current + 1) : 0);
view_number->fireValueChanged();
return views[current];
}
FGViewer*
FGViewMgr::prev_view()
{
setView((0 < current) ? (current - 1) : (views.size() - 1));
view_number->fireValueChanged();
return views[current];
}
void
FGViewMgr::add_view( FGViewer * v )
{
views.push_back(v);
v->init();
}
double
FGViewMgr::getViewHeadingOffset_deg () const
{

68
src/Main/viewmgr.hxx
View file

@ -28,16 +28,11 @@
#include <simgear/compiler.h>
#include <simgear/structure/subsystem_mgr.hxx>
#include <simgear/math/SGMath.hxx>
#ifdef HAVE_CONFIG_H
# include <config.h>
#endif
#include "fg_props.hxx"
#include "viewer.hxx"
using std::vector;
// forward decls
class FGViewer;
typedef SGSharedPtr<FGViewer> FGViewerPtr;
// Define a structure containing view information
class FGViewMgr : public SGSubsystem
@ -60,48 +55,21 @@ public:
// getters
inline int size() const { return views.size(); }
inline int get_current() const { return current; }
inline FGViewer *get_current_view() {
if ( current < (int)views.size() ) {
return views[current];
} else {
return NULL;
}
}
inline const FGViewer *get_current_view() const {
if ( current < (int)views.size() ) {
return views[current];
} else {
return NULL;
}
}
inline FGViewer *get_view( int i ) {
if ( i < 0 ) { i = 0; }
if ( i >= (int)views.size() ) { i = views.size() - 1; }
return views[i];
}
inline const FGViewer *get_view( int i ) const {
if ( i < 0 ) { i = 0; }
if ( i >= (int)views.size() ) { i = views.size() - 1; }
return views[i];
}
inline FGViewer *next_view() {
setView((current+1 < (int)views.size()) ? (current + 1) : 0);
view_number->fireValueChanged();
return views[current];
}
inline FGViewer *prev_view() {
setView((0 < current) ? (current - 1) : (views.size() - 1));
view_number->fireValueChanged();
return views[current];
}
FGViewer *get_current_view();
const FGViewer *get_current_view() const;
FGViewer *get_view( int i );
const FGViewer *get_view( int i ) const;
FGViewer *next_view();
FGViewer *prev_view();
// setters
inline void clear() { views.clear(); }
void clear();
inline void set_view( const int v ) { current = v; }
inline void add_view( FGViewer * v ) {
views.push_back(v);
v->init();
}
void add_view( FGViewer * v );
// copies current offset settings to current-view path...
void copyToCurrent ();
@ -150,7 +118,7 @@ private:
SGPropertyNode_ptr view_number;
vector<SGPropertyNode_ptr> config_list;
typedef vector<SGSharedPtr<FGViewer> > viewer_list;
typedef std::vector<FGViewerPtr> viewer_list;
viewer_list views;
SGVec3d abs_viewer_position;

119
src/Sound/fg_fx.cxx
View file

@ -29,11 +29,14 @@
# include <config.h>
#endif
#include "fg_fx.hxx"
#include <simgear/debug/logstream.hxx>
#include <simgear/structure/exception.hxx>
#include <simgear/misc/sg_path.hxx>
#include <simgear/props/props.hxx>
#include <simgear/sound/xmlsound.hxx>
#include <simgear/sound/soundmgr_openal.hxx>
#include <Main/fg_props.hxx>
@ -41,17 +44,14 @@
#include <Model/acmodel.hxx>
#include <Main/viewer.hxx>
#include "fg_fx.hxx"
FGFX::FGFX () :
last_visitor_pos(SGVec3d::zeros()),
last_model_pos(SGVec3d::zeros()),
last_pause( true ),
last_volume( 0.0 ),
_pause( fgGetNode("/sim/sound/pause") ),
_volume( fgGetNode("/sim/sound/volume") )
{
sgdSetVec3(last_visitor_pos, 0, 0, 0);
sgdSetVec3(last_model_pos, 0, 0, 0);
}
FGFX::~FGFX ()
@ -137,12 +137,6 @@ FGFX::update (double dt)
return;
}
#if 0
// moved back to the mainloop to prevent audio problems
smgr->update(dt);
update_pos_and_orientation(smgr, dt);
#endif
// command sound manger
bool pause = _pause->getBoolValue();
if ( pause != last_pause ) {
@ -190,6 +184,18 @@ FGFX::update (double dt)
}
}
void
FGFX::update_fx_late(double dt)
{
SGSoundMgr *smgr = globals->get_soundmgr();
if (!smgr->is_working()) {
return;
}
smgr->update(dt);
update_pos_and_orientation(smgr, dt);
}
/**
* add a sound sample to the message queue which is played sequentially
* in order.
@ -200,7 +206,7 @@ FGFX::play_message( SGSoundSample *_sample )
_samplequeue.push( _sample );
}
void
FGFX::play_message( const string path, const string fname, double volume )
FGFX::play_message( const std::string& path, const std::string& fname, double volume )
{
if (globals->get_soundmgr()->is_working() == true) {
SGSoundSample *sample;
@ -237,87 +243,50 @@ FGFX::update_pos_and_orientation(SGSoundMgr *smgr, double dt)
// are finally calculated in a left hand system and openal
// lives in a right hand system. Therefore we need to pass
// the down vector to get correct stereo sound.)
SGVec3d sgv_up, sgv_at;
sgVec3 up, at;
sgv_up
SGVec3d sgv_up
= model_or.rotateBack(surf_or.rotateBack(view_or.rotate(SGVec3d(0,1,0))));
sgSetVec3(up, sgv_up[0], sgv_up[1], sgv_up[2]);
sgv_at
SGVec3d sgv_at
= model_or.rotateBack(surf_or.rotateBack(view_or.rotate(SGVec3d(0,0,1))));
sgSetVec3(at, sgv_at[0], sgv_at[1], sgv_at[2]);
// get the location data for the primary FDM (now hardcoded to ac model)...
// EMH: to add multiple sound sources this should be replaced
SGVec3d absolute_view_pos = SGVec3d::fromGeod(model->getPosition());
// calculate speed of visitor and model
sgVec3 listener_vel, model_vel;
SGVec3d SGV3d_help;
sgdVec3 sgdv3_help;
sgdVec3 sgdv3_null = {0, 0, 0};
SGVec3d moved = last_visitor_pos - observer->get_view_pos();
last_visitor_pos = observer->get_view_pos();
SGVec3f listener_vel(model_or.rotateBack(surf_or.rotateBack(moved)));
moved = last_model_pos - absolute_view_pos;
last_model_pos = absolute_view_pos;
SGVec3f model_vel(model_or.rotateBack(surf_or.rotateBack(moved)));
sgdSubVec3(sgdv3_help,
last_visitor_pos, (double *)&observer->get_view_pos());
sgdAddVec3(last_visitor_pos,
sgdv3_null, (double *)&observer->get_view_pos());
SGV3d_help = model_or.rotateBack(
surf_or.rotateBack(
SGVec3d(sgdv3_help[0], sgdv3_help[1], sgdv3_help[2])
));
sgSetVec3(listener_vel, SGV3d_help[0], SGV3d_help[1], SGV3d_help[2]);
sgdSubVec3(sgdv3_help, last_model_pos, absolute_view_pos.data());
sgdAddVec3(last_model_pos, sgdv3_null, absolute_view_pos.data());
SGV3d_help = model_or.rotateBack(
surf_or.rotateBack(
SGVec3d(sgdv3_help[0], sgdv3_help[1], sgdv3_help[2])
));
sgSetVec3( model_vel, SGV3d_help[0], SGV3d_help[1], SGV3d_help[2]);
if (dt > 0) {
sgScaleVec3( model_vel, 1 / dt );
sgScaleVec3( listener_vel, 1 / dt );
model_vel /= dt;
listener_vel /= dt;
}
// checking, if the listener pos has moved suddenly
if (sgLengthVec3(listener_vel) > 1000)
{
if (length(listener_vel) > 1000) {
// check if the relative speed model vs listener has moved suddenly, too
sgVec3 delta_vel;
sgSubVec3(delta_vel, listener_vel, model_vel);
if (sgLengthVec3(delta_vel) > 1000)
SGVec3f delta_vel = listener_vel - model_vel;
if (length(delta_vel) > 1000)
// a sane value
sgSetVec3(listener_vel, model_vel[0], model_vel[1], model_vel[2]);
smgr->set_listener_vel(model_vel.data());
else
smgr->set_listener_vel(listener_vel);
smgr->set_listener_vel(listener_vel.data());
} else {
smgr->set_listener_vel( listener_vel.data());
}
else
smgr->set_listener_vel( listener_vel );
// set positional offset for sources
sgdVec3 dsource_pos_offset;
sgdSubVec3( dsource_pos_offset,
(double*) &observer->get_view_pos(),
absolute_view_pos.data() );
SGVec3d sgv_dsource_pos_offset;
sgv_dsource_pos_offset = model_or.rotateBack(
surf_or.rotateBack(
SGVec3d(dsource_pos_offset[0],
dsource_pos_offset[1],
dsource_pos_offset[2])
SGVec3d dsource_pos_offset = observer->get_view_pos() - absolute_view_pos;
dsource_pos_offset = model_or.rotateBack(surf_or.rotateBack(
dsource_pos_offset
));
sgVec3 source_pos_offset;
sgSetVec3(source_pos_offset,
sgv_dsource_pos_offset[0],
sgv_dsource_pos_offset[1],
sgv_dsource_pos_offset[2]);
smgr->set_source_pos_all( source_pos_offset );
smgr->set_source_vel_all( model_vel );
smgr->set_source_pos_all( SGVec3f(dsource_pos_offset).data() );
smgr->set_source_vel_all(model_vel.data() );
float orient[6];
for (int i = 0; i < 3; i++) {
@ -327,9 +296,7 @@ FGFX::update_pos_and_orientation(SGSoundMgr *smgr, double dt)
smgr->set_listener_orientation( orient );
// The listener is always positioned at the origin.
sgVec3 listener_pos;
sgSetVec3( listener_pos, 0.0, 0.0, 0.0 );
smgr->set_listener_pos( listener_pos );
smgr->set_listener_pos( SGVec3f::zeros().data() );
}
// end of fg_fx.cxx

23
src/Sound/fg_fx.hxx
View file

@ -29,13 +29,12 @@
#include <queue>
#include <vector>
#include <simgear/sound/sample_openal.hxx>
#include <simgear/structure/subsystem_mgr.hxx>
using std::queue;
using std::vector;
#include <simgear/math/SGMath.hxx>
class SGXmlSound;
class SGSoundSample;
class SGSoundMgr;
/**
* Generator for FlightGear sound effects.
@ -72,16 +71,22 @@ public:
* in order.
*/
void play_message( SGSoundSample *_sample );
void play_message( const string path, const string fname, double volume );
void play_message( const std::string& path, const std::string& fname, double volume );
/**
* Explicit late update hook, to avoid problems which occur if done during
* normal SGSubsytem updating.
*/
void update_fx_late(double dt);
private:
void update_pos_and_orientation(SGSoundMgr *smgr, double dt);
sgdVec3 last_visitor_pos;
sgdVec3 last_model_pos;
SGVec3d last_visitor_pos;
SGVec3d last_model_pos;
vector<SGXmlSound *> _sound;
queue<SGSoundSample *> _samplequeue;
std::vector<SGXmlSound *> _sound;
std::queue<SGSoundSample *> _samplequeue;
bool last_pause;
double last_volume;