FGViewMgr::FGViewMgr( void ) :
axis_long(0),
axis_lat(0),
+ inited(false),
view_number(fgGetNode("/sim/current-view/view-number", true)),
config_list(fgGetNode("/sim", true)->getChildren("view")),
- current(0)
+ abs_viewer_position(SGVec3d::zeros()),
+ current(0),
+ current_view_orientation(SGQuatd::zeros()),
+ current_view_or_offset(SGQuatd::zeros()),
+ smgr(globals->get_soundmgr())
{
- smgr = globals->get_soundmgr();
}
// Destructor
void
FGViewMgr::init ()
{
+ if (inited) {
+ SG_LOG(SG_VIEW, SG_WARN, "duplicate init of view manager");
+ return;
+ }
+
+ inited = true;
+
double aspect_ratio_multiplier
= fgGetDouble("/sim/current-view/aspect-ratio-multiplier");
}
copyToCurrent();
+ do_bind();
}
void
typedef double (FGViewMgr::*double_getter)() const;
void
-FGViewMgr::bind ()
+FGViewMgr::bind()
+{
+ // view-manager code was designed to init before bind, so
+ // this is a no-op; init() calls the real bind() impl below
+}
+
+void
+FGViewMgr::do_bind()
{
// these are bound to the current view properties
- fgTie("/sim/current-view/heading-offset-deg", this,
- &FGViewMgr::getViewHeadingOffset_deg,
- &FGViewMgr::setViewHeadingOffset_deg);
+ _tiedProperties.setRoot(fgGetNode("/sim/current-view", true));
+ _tiedProperties.Tie("heading-offset-deg", this,
+ &FGViewMgr::getViewHeadingOffset_deg,
+ &FGViewMgr::setViewHeadingOffset_deg);
fgSetArchivable("/sim/current-view/heading-offset-deg");
- fgTie("/sim/current-view/goal-heading-offset-deg", this,
- &FGViewMgr::getViewGoalHeadingOffset_deg,
- &FGViewMgr::setViewGoalHeadingOffset_deg);
+ _tiedProperties.Tie("goal-heading-offset-deg", this,
+ &FGViewMgr::getViewGoalHeadingOffset_deg,
+ &FGViewMgr::setViewGoalHeadingOffset_deg);
fgSetArchivable("/sim/current-view/goal-heading-offset-deg");
- fgTie("/sim/current-view/pitch-offset-deg", this,
- &FGViewMgr::getViewPitchOffset_deg,
- &FGViewMgr::setViewPitchOffset_deg);
+ _tiedProperties.Tie("pitch-offset-deg", this,
+ &FGViewMgr::getViewPitchOffset_deg,
+ &FGViewMgr::setViewPitchOffset_deg);
fgSetArchivable("/sim/current-view/pitch-offset-deg");
- fgTie("/sim/current-view/goal-pitch-offset-deg", this,
- &FGViewMgr::getGoalViewPitchOffset_deg,
- &FGViewMgr::setGoalViewPitchOffset_deg);
+ _tiedProperties.Tie("goal-pitch-offset-deg", this,
+ &FGViewMgr::getGoalViewPitchOffset_deg,
+ &FGViewMgr::setGoalViewPitchOffset_deg);
fgSetArchivable("/sim/current-view/goal-pitch-offset-deg");
- fgTie("/sim/current-view/roll-offset-deg", this,
- &FGViewMgr::getViewRollOffset_deg,
- &FGViewMgr::setViewRollOffset_deg);
+ _tiedProperties.Tie("roll-offset-deg", this,
+ &FGViewMgr::getViewRollOffset_deg,
+ &FGViewMgr::setViewRollOffset_deg);
fgSetArchivable("/sim/current-view/roll-offset-deg");
- fgTie("/sim/current-view/goal-roll-offset-deg", this,
- &FGViewMgr::getGoalViewRollOffset_deg,
- &FGViewMgr::setGoalViewRollOffset_deg);
+ _tiedProperties.Tie("goal-roll-offset-deg", this,
+ &FGViewMgr::getGoalViewRollOffset_deg,
+ &FGViewMgr::setGoalViewRollOffset_deg);
fgSetArchivable("/sim/current-view/goal-roll-offset-deg");
- fgTie("/sim/current-view/view-number", this,
+ _tiedProperties.Tie("view-number", this,
&FGViewMgr::getView, &FGViewMgr::setView);
- fgSetArchivable("/sim/current-view/view-number", FALSE);
+ fgSetArchivable("/sim/current-view/view-number", false);
- fgTie("/sim/current-view/axes/long", this,
- (double_getter)0, &FGViewMgr::setViewAxisLong);
+ _tiedProperties.Tie("axes/long", this,
+ (double_getter)0, &FGViewMgr::setViewAxisLong);
fgSetArchivable("/sim/current-view/axes/long");
- fgTie("/sim/current-view/axes/lat", this,
- (double_getter)0, &FGViewMgr::setViewAxisLat);
+ _tiedProperties.Tie("axes/lat", this,
+ (double_getter)0, &FGViewMgr::setViewAxisLat);
fgSetArchivable("/sim/current-view/axes/lat");
- fgTie("/sim/current-view/field-of-view", this,
- &FGViewMgr::getFOV_deg, &FGViewMgr::setFOV_deg);
+ _tiedProperties.Tie("field-of-view", this,
+ &FGViewMgr::getFOV_deg, &FGViewMgr::setFOV_deg);
fgSetArchivable("/sim/current-view/field-of-view");
- fgTie("/sim/current-view/aspect-ratio-multiplier", this,
- &FGViewMgr::getARM_deg, &FGViewMgr::setARM_deg);
+ _tiedProperties.Tie("aspect-ratio-multiplier", this,
+ &FGViewMgr::getARM_deg, &FGViewMgr::setARM_deg);
fgSetArchivable("/sim/current-view/field-of-view");
- fgTie("/sim/current-view/ground-level-nearplane-m", this,
- &FGViewMgr::getNear_m, &FGViewMgr::setNear_m);
+ _tiedProperties.Tie("ground-level-nearplane-m", this,
+ &FGViewMgr::getNear_m, &FGViewMgr::setNear_m);
fgSetArchivable("/sim/current-view/ground-level-nearplane-m");
SGPropertyNode *n = fgGetNode("/sim/current-view", true);
- n->tie("viewer-x-m", SGRawValuePointer<double>(&abs_viewer_position[0]));
- n->tie("viewer-y-m", SGRawValuePointer<double>(&abs_viewer_position[1]));
- n->tie("viewer-z-m", SGRawValuePointer<double>(&abs_viewer_position[2]));
+ _tiedProperties.Tie(n->getNode("viewer-x-m", true),SGRawValuePointer<double>(&abs_viewer_position[0]));
+ _tiedProperties.Tie(n->getNode("viewer-y-m", true),SGRawValuePointer<double>(&abs_viewer_position[1]));
+ _tiedProperties.Tie(n->getNode("viewer-z-m", true),SGRawValuePointer<double>(&abs_viewer_position[2]));
+
+ _tiedProperties.Tie("debug/orientation-w", this,
+ &FGViewMgr::getCurrentViewOrientation_w);
+ _tiedProperties.Tie("debug/orientation-x", this,
+ &FGViewMgr::getCurrentViewOrientation_x);
+ _tiedProperties.Tie("debug/orientation-y", this,
+ &FGViewMgr::getCurrentViewOrientation_y);
+ _tiedProperties.Tie("debug/orientation-z", this,
+ &FGViewMgr::getCurrentViewOrientation_z);
+
+ _tiedProperties.Tie("debug/orientation_offset-w", this,
+ &FGViewMgr::getCurrentViewOrOffset_w);
+ _tiedProperties.Tie("debug/orientation_offset-x", this,
+ &FGViewMgr::getCurrentViewOrOffset_x);
+ _tiedProperties.Tie("debug/orientation_offset-y", this,
+ &FGViewMgr::getCurrentViewOrOffset_y);
+ _tiedProperties.Tie("debug/orientation_offset-z", this,
+ &FGViewMgr::getCurrentViewOrOffset_z);
+
+ _tiedProperties.Tie("debug/frame-w", this,
+ &FGViewMgr::getCurrentViewFrame_w);
+ _tiedProperties.Tie("debug/frame-x", this,
+ &FGViewMgr::getCurrentViewFrame_x);
+ _tiedProperties.Tie("debug/frame-y", this,
+ &FGViewMgr::getCurrentViewFrame_y);
+ _tiedProperties.Tie("debug/frame-z", this,
+ &FGViewMgr::getCurrentViewFrame_z);
}
void
FGViewMgr::unbind ()
{
- // FIXME:
- // need to redo these bindings to the new locations (move to viewer?)
- fgUntie("/sim/current-view/heading-offset-deg");
- fgUntie("/sim/current-view/goal-heading-offset-deg");
- fgUntie("/sim/current-view/pitch-offset-deg");
- fgUntie("/sim/current-view/goal-pitch-offset-deg");
- fgUntie("/sim/current-view/field-of-view");
- fgUntie("/sim/current-view/aspect-ratio-multiplier");
- fgUntie("/sim/current-view/view-number");
- fgUntie("/sim/current-view/axes/long");
- fgUntie("/sim/current-view/axes/lat");
- fgUntie("/sim/current-view/ground-level-nearplane-m");
- fgUntie("/sim/current-view/viewer-x-m");
- fgUntie("/sim/current-view/viewer-y-m");
- fgUntie("/sim/current-view/viewer-z-m");
+ _tiedProperties.Untie();
}
void
FGViewMgr::update (double dt)
{
-
FGViewer *loop_view = (FGViewer *)get_current_view();
if (loop_view == 0) return;
setViewTargetYOffset_m(fgGetDouble("/sim/current-view/target-y-offset-m"));
setViewTargetZOffset_m(fgGetDouble("/sim/current-view/target-z-offset-m"));
+ current_view_orientation = loop_view->getViewOrientation();
+ current_view_or_offset = loop_view->getViewOrientationOffset();
+
// Update the current view
do_axes();
loop_view->update(dt);
abs_viewer_position = loop_view->getViewPosition();
// update audio listener values
- // set the viewer posotion in Cartesian coordinates in meters
- smgr->set_position( abs_viewer_position );
- smgr->set_orientation( loop_view->getViewOrientation() );
+ // set the viewer position in Cartesian coordinates in meters
+ smgr->set_position( abs_viewer_position, loop_view->getPosition() );
+ smgr->set_orientation( current_view_orientation );
// get the model velocity
- SGVec3f velocity = SGVec3f::zeros();
+ SGVec3d velocity = SGVec3d::zeros();
if ( !stationary() ) {
velocity = globals->get_aircraft_model()->getVelocity();
}
- smgr->set_velocity(velocity);
+ smgr->set_velocity( velocity );
}
void
FGViewMgr::copyToCurrent()
{
+ if (!inited) {
+ return;
+ }
+
SGPropertyNode *n = config_list[current];
fgSetString("/sim/current-view/name", n->getStringValue("name"));
fgSetString("/sim/current-view/type", n->getStringValue("type"));
newview = 0;
// set new view
- set_view(newview);
+ current = newview;
// copy in view data
copyToCurrent();
-
- // Copy the fdm's position into the SGLocation which is shared with
- // some views ...
- globals->get_aircraft_model()->update(0);
- // Do the update ...
- update(0);
}
void
FGViewMgr::setARM_deg (double aspect_ratio_multiplier)
-{
+{
FGViewer * view = get_current_view();
if (view != 0)
view->set_aspect_ratio_multiplier(aspect_ratio_multiplier);
axis_lat = axis;
}
+// reference frame orientation.
+// This is the view orientation you get when you have no
+// view offset, i.e. the offset operator is the identity.
+//
+// For example, in the familiar "cockpit lookfrom" view,
+// the reference frame is equal to the aircraft attitude,
+// i.e. it is the view looking towards 12:00 straight ahead.
+//
+// FIXME: Somebody needs to figure out what is the reference
+// frame view for the other view modes.
+//
+// Conceptually, this quat represents a rotation relative
+// to the ECEF reference orientation, as described at
+// http://www.av8n.com/physics/coords.htm#sec-orientation
+//
+// See the NOTE concerning reference orientations, below.
+//
+// The components of this quat are expressed in
+// the conventional aviation basis set,
+// i.e. x=forward, y=starboard, z=bottom
+double FGViewMgr::getCurrentViewFrame_w() const{
+ return ((current_view_orientation*conj(fsb2sta())*conj(current_view_or_offset))).w();
+}
+double FGViewMgr::getCurrentViewFrame_x() const{
+ return ((current_view_orientation*conj(fsb2sta())*conj(current_view_or_offset))).x();
+}
+double FGViewMgr::getCurrentViewFrame_y() const{
+ return ((current_view_orientation*conj(fsb2sta())*conj(current_view_or_offset))).y();
+}
+double FGViewMgr::getCurrentViewFrame_z() const{
+ return ((current_view_orientation*conj(fsb2sta())*conj(current_view_or_offset))).z();
+}
+
+
+// view offset.
+// This rotation takes you from the aforementioned
+// reference frame view orientation to whatever
+// actual current view orientation is.
+//
+// The components of this quaternion are expressed in
+// the conventional aviation basis set,
+// i.e. x=forward, y=starboard, z=bottom
+double FGViewMgr::getCurrentViewOrOffset_w() const{
+ return current_view_or_offset.w();
+}
+double FGViewMgr::getCurrentViewOrOffset_x() const{
+ return current_view_or_offset.x();
+}
+double FGViewMgr::getCurrentViewOrOffset_y() const{
+ return current_view_or_offset.y();
+}
+double FGViewMgr::getCurrentViewOrOffset_z() const{
+ return current_view_or_offset.z();
+}
+
+
+// current view orientation.
+// This is a rotation relative to the earth-centered (ec)
+// reference frame.
+//
+// NOTE: Here we remove a factor of fsb2sta so that
+// the components of this quat are displayed using the
+// conventional ECEF basis set. This is *not* the way
+// the view orientation is stored in the views[] array,
+// but is easier for non-graphics hackers to understand.
+// If we did not remove this factor of fsb2sta here and
+// in getCurrentViewFrame, that would be equivalent to
+// the following peculiar reference orientation:
+// Suppose you are over the Gulf of Guinea, at (lat,lon) = (0,0).
+// Then the reference frame orientation can be achieved via:
+// -- The aircraft X-axis (nose) headed south.
+// -- The aircraft Y-axis (starboard wingtip) pointing up.
+// -- The aircraft Z-axis (belly) pointing west.
+// To say the same thing in other words, and perhaps more to the
+// point: If we use the OpenGL camera orientation conventions,
+// i.e. Xprime=starboard, Yprime=top, Zprime=aft, then the
+// aforementioned peculiar reference orientation at (lat,lon)
+// = (0,0) can be described as:
+// -- aircraft Xprime axis (starboard) pointed up
+// -- aircraft Yprime axis (top) pointed east
+// -- aircraft Zprime axis (aft) pointed north
+// meaning the OpenGL axes are aligned with the ECEF axes.
+double FGViewMgr::getCurrentViewOrientation_w() const{
+ return (current_view_orientation * conj(fsb2sta())).w();
+}
+double FGViewMgr::getCurrentViewOrientation_x() const{
+ return (current_view_orientation * conj(fsb2sta())).x();
+}
+double FGViewMgr::getCurrentViewOrientation_y() const{
+ return (current_view_orientation * conj(fsb2sta())).y();
+}
+double FGViewMgr::getCurrentViewOrientation_z() const{
+ return (current_view_orientation * conj(fsb2sta())).z();
+}
+
void
FGViewMgr::do_axes ()
{