X-Git-Url: https://git.mxchange.org/?a=blobdiff_plain;f=src%2FMain%2Fviewmgr.cxx;h=6859c8f412ee5306ddaf1d91630b717149ce77d4;hb=fdbfd6fd0b789eecf2c532d048a75d15f8d35ad8;hp=2d8b3f7ebe17a06ee16fd4ce42da82bb01b5aaa2;hpb=ec6888d4a4d119c11f62bc27292a8f17fb8a18af;p=flightgear.git diff --git a/src/Main/viewmgr.cxx b/src/Main/viewmgr.cxx index 2d8b3f7eb..6859c8f41 100644 --- a/src/Main/viewmgr.cxx +++ b/src/Main/viewmgr.cxx @@ -3,7 +3,7 @@ // Written by Curtis Olson, started October 2000. // partially rewritten by Jim Wilson March 2002 // -// Copyright (C) 2000 Curtis L. Olson - curt@flightgear.org +// Copyright (C) 2000 Curtis L. Olson - http://www.flightgear.org/~curt // // This program is free software; you can redistribute it and/or // modify it under the terms of the GNU General Public License as @@ -17,31 +17,35 @@ // // 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. +// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. // // $Id$ -#include // strcmp - -#include - -#include // FIXME: this should NOT be needed +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif #include "viewmgr.hxx" -#include "fg_props.hxx" -// strings -string viewpath, nodepath, strdata; +#include // strcmp + +#include +#include +#include +#include
+#include
// Constructor FGViewMgr::FGViewMgr( void ) : axis_long(0), axis_lat(0), + view_number(fgGetNode("/sim/current-view/view-number", true)), + config_list(fgGetNode("/sim", true)->getChildren("view")), current(0) { + smgr = globals->get_soundmgr(); } - // Destructor FGViewMgr::~FGViewMgr( void ) { } @@ -49,19 +53,108 @@ FGViewMgr::~FGViewMgr( void ) { void FGViewMgr::init () { - char stridx [ 20 ]; - for (int i = 0; i < fgGetInt("/sim/number-views"); i++) { - nodepath = "/sim/view"; - sprintf(stridx, "[%d]", i); - nodepath += stridx; - nodepath += "/type"; - strdata = fgGetString(nodepath.c_str()); - // supporting two types now "lookat" = 1 and "lookfrom" = 1 - if ( strcmp("lookat",strdata.c_str()) == 0 ) - add_view(new FGViewer, 1); - else - add_view(new FGViewer, 0); + double aspect_ratio_multiplier + = fgGetDouble("/sim/current-view/aspect-ratio-multiplier"); + + for (unsigned int i = 0; i < config_list.size(); i++) { + SGPropertyNode *n = config_list[i]; + + // find out if this is an internal view (e.g. in cockpit, low near plane) + bool internal = n->getBoolValue("internal", false); + + // FIXME: + // this is assumed to be an aircraft model...we will need to read + // model-from-type as well. + + // find out if this is a model we are looking from... + bool from_model = n->getBoolValue("config/from-model"); + int from_model_index = n->getIntValue("config/from-model-idx"); + + double x_offset_m = n->getDoubleValue("config/x-offset-m"); + double y_offset_m = n->getDoubleValue("config/y-offset-m"); + double z_offset_m = n->getDoubleValue("config/z-offset-m"); + + double heading_offset_deg = n->getDoubleValue("config/heading-offset-deg"); + n->setDoubleValue("config/heading-offset-deg", heading_offset_deg); + double pitch_offset_deg = n->getDoubleValue("config/pitch-offset-deg"); + n->setDoubleValue("config/pitch-offset-deg", pitch_offset_deg); + double roll_offset_deg = n->getDoubleValue("config/roll-offset-deg"); + n->setDoubleValue("config/roll-offset-deg", roll_offset_deg); + + double fov_deg = n->getDoubleValue("config/default-field-of-view-deg"); + double near_m = n->getDoubleValue("config/ground-level-nearplane-m"); + + // supporting two types "lookat" = 1 and "lookfrom" = 0 + const char *type = n->getStringValue("type"); + if (!strcmp(type, "lookat")) { + + bool at_model = n->getBoolValue("config/at-model"); + int at_model_index = n->getIntValue("config/at-model-idx"); + + double damp_roll = n->getDoubleValue("config/at-model-roll-damping"); + double damp_pitch = n->getDoubleValue("config/at-model-pitch-damping"); + double damp_heading = n->getDoubleValue("config/at-model-heading-damping"); + + double target_x_offset_m = n->getDoubleValue("config/target-x-offset-m"); + double target_y_offset_m = n->getDoubleValue("config/target-y-offset-m"); + double target_z_offset_m = n->getDoubleValue("config/target-z-offset-m"); + + add_view(new FGViewer ( FG_LOOKAT, from_model, from_model_index, + at_model, at_model_index, + damp_roll, damp_pitch, damp_heading, + x_offset_m, y_offset_m,z_offset_m, + heading_offset_deg, pitch_offset_deg, + roll_offset_deg, fov_deg, aspect_ratio_multiplier, + target_x_offset_m, target_y_offset_m, + target_z_offset_m, near_m, internal )); + } else { + add_view(new FGViewer ( FG_LOOKFROM, from_model, from_model_index, + false, 0, 0.0, 0.0, 0.0, + x_offset_m, y_offset_m, z_offset_m, + heading_offset_deg, pitch_offset_deg, + roll_offset_deg, fov_deg, aspect_ratio_multiplier, + 0, 0, 0, near_m, internal )); + } + } + + copyToCurrent(); +} + +void +FGViewMgr::reinit () +{ + // reset offsets and fov to configuration defaults + for (unsigned int i = 0; i < config_list.size(); i++) { + SGPropertyNode *n = config_list[i]; + setView(i); + + fgSetDouble("/sim/current-view/x-offset-m", + n->getDoubleValue("config/x-offset-m")); + fgSetDouble("/sim/current-view/y-offset-m", + n->getDoubleValue("config/y-offset-m")); + fgSetDouble("/sim/current-view/z-offset-m", + n->getDoubleValue("config/z-offset-m")); + fgSetDouble("/sim/current-view/pitch-offset-deg", + n->getDoubleValue("config/pitch-offset-deg")); + fgSetDouble("/sim/current-view/heading-offset-deg", + n->getDoubleValue("config/heading-offset-deg")); + fgSetDouble("/sim/current-view/roll-offset-deg", + n->getDoubleValue("config/roll-offset-deg")); + + double fov_deg = n->getDoubleValue("config/default-field-of-view-deg"); + if (fov_deg < 10.0) + fov_deg = 55.0; + fgSetDouble("/sim/current-view/field-of-view", fov_deg); + + // target offsets for lookat mode only... + fgSetDouble("/sim/current-view/target-x-offset-m", + n->getDoubleValue("config/target-x-offset-m")); + fgSetDouble("/sim/current-view/target-y-offset-m", + n->getDoubleValue("config/target-y-offset-m")); + fgSetDouble("/sim/current-view/target-z-offset-m", + n->getDoubleValue("config/target-z-offset-m")); } + setView(0); } typedef double (FGViewMgr::*double_getter)() const; @@ -69,36 +162,92 @@ typedef double (FGViewMgr::*double_getter)() const; void FGViewMgr::bind () { - // FIXME: - // need to redo these bindings to the new locations (move to viewer?) - fgTie("/sim/view/offset-deg", this, - &FGViewMgr::getViewOffset_deg, &FGViewMgr::setViewOffset_deg); - fgSetArchivable("/sim/view/offset-deg"); - fgTie("/sim/view/goal-offset-deg", this, - &FGViewMgr::getGoalViewOffset_deg, &FGViewMgr::setGoalViewOffset_deg); - fgSetArchivable("/sim/view/goal-offset-deg"); - fgTie("/sim/view/tilt-deg", this, - &FGViewMgr::getViewTilt_deg, &FGViewMgr::setViewTilt_deg); - fgSetArchivable("/sim/view/tilt-deg"); - fgTie("/sim/view/goal-tilt-deg", this, - &FGViewMgr::getGoalViewTilt_deg, &FGViewMgr::setGoalViewTilt_deg); - fgSetArchivable("/sim/view/goal-tilt-deg"); - fgTie("/sim/view/pilot/x-offset-m", this, - &FGViewMgr::getPilotXOffset_m, &FGViewMgr::setPilotXOffset_m); - fgSetArchivable("/sim/view/pilot/x-offset-m"); - fgTie("/sim/view/pilot/y-offset-m", this, - &FGViewMgr::getPilotYOffset_m, &FGViewMgr::setPilotYOffset_m); - fgSetArchivable("/sim/view/pilot/y-offset-m"); - fgTie("/sim/view/pilot/z-offset-m", this, - &FGViewMgr::getPilotZOffset_m, &FGViewMgr::setPilotZOffset_m); - fgSetArchivable("/sim/view/pilot/z-offset-m"); - fgTie("/sim/field-of-view", this, - &FGViewMgr::getFOV_deg, &FGViewMgr::setFOV_deg); - fgSetArchivable("/sim/field-of-view"); - fgTie("/sim/view/axes/long", this, + // these are bound to the current view properties + fgTie("/sim/current-view/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); + fgSetArchivable("/sim/current-view/goal-heading-offset-deg"); + fgTie("/sim/current-view/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); + fgSetArchivable("/sim/current-view/goal-pitch-offset-deg"); + fgTie("/sim/current-view/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); + fgSetArchivable("/sim/current-view/goal-roll-offset-deg"); + + fgTie("/sim/current-view/view-number", this, + &FGViewMgr::getView, &FGViewMgr::setView); + fgSetArchivable("/sim/current-view/view-number", false); + + fgTie("/sim/current-view/axes/long", this, (double_getter)0, &FGViewMgr::setViewAxisLong); - fgTie("/sim/view/axes/lat", this, + fgSetArchivable("/sim/current-view/axes/long"); + + fgTie("/sim/current-view/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); + fgSetArchivable("/sim/current-view/field-of-view"); + + fgTie("/sim/current-view/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); + fgSetArchivable("/sim/current-view/ground-level-nearplane-m"); + + SGPropertyNode *n = fgGetNode("/sim/current-view", true); + n->tie("viewer-x-m", SGRawValuePointer(&abs_viewer_position[0])); + n->tie("viewer-y-m", SGRawValuePointer(&abs_viewer_position[1])); + n->tie("viewer-z-m", SGRawValuePointer(&abs_viewer_position[2])); + +// for automatic untying: +#define x(str) ((void)tied_props.push_back(str), str) + + fgTie(x("/sim/current-view/debug/orientation-w"), this, + &FGViewMgr::getCurrentViewOrientation_w); + fgTie(x("/sim/current-view/debug/orientation-x"), this, + &FGViewMgr::getCurrentViewOrientation_x); + fgTie(x("/sim/current-view/debug/orientation-y"), this, + &FGViewMgr::getCurrentViewOrientation_y); + fgTie(x("/sim/current-view/debug/orientation-z"), this, + &FGViewMgr::getCurrentViewOrientation_z); + + fgTie(x("/sim/current-view/debug/orientation_offset-w"), this, + &FGViewMgr::getCurrentViewOrOffset_w); + fgTie(x("/sim/current-view/debug/orientation_offset-x"), this, + &FGViewMgr::getCurrentViewOrOffset_x); + fgTie(x("/sim/current-view/debug/orientation_offset-y"), this, + &FGViewMgr::getCurrentViewOrOffset_y); + fgTie(x("/sim/current-view/debug/orientation_offset-z"), this, + &FGViewMgr::getCurrentViewOrOffset_z); + + fgTie(x("/sim/current-view/debug/frame-w"), this, + &FGViewMgr::getCurrentViewFrame_w); + fgTie(x("/sim/current-view/debug/frame-x"), this, + &FGViewMgr::getCurrentViewFrame_x); + fgTie(x("/sim/current-view/debug/frame-y"), this, + &FGViewMgr::getCurrentViewFrame_y); + fgTie(x("/sim/current-view/debug/frame-z"), this, + &FGViewMgr::getCurrentViewFrame_z); + +#undef x } void @@ -106,113 +255,220 @@ FGViewMgr::unbind () { // FIXME: // need to redo these bindings to the new locations (move to viewer?) - fgUntie("/sim/view/offset-deg"); - fgUntie("/sim/view/goal-offset-deg"); - fgUntie("/sim/view/tilt-deg"); - fgUntie("/sim/view/goal-tilt-deg"); - fgUntie("/sim/view/pilot/x-offset-m"); - fgUntie("/sim/view/pilot/y-offset-m"); - fgUntie("/sim/view/pilot/z-offset-m"); - fgUntie("/sim/field-of-view"); - fgUntie("/sim/view/axes/long"); - fgUntie("/sim/view/axes/lat"); + 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"); + + list::const_iterator it; + for (it = tied_props.begin(); it != tied_props.end(); it++){ + fgUntie(*it); + } + } void -FGViewMgr::update (int dt) +FGViewMgr::update (double dt) { - char stridx [20]; - FGViewer * view = get_current_view(); - if (view == 0) - return; + FGViewer *loop_view = (FGViewer *)get_current_view(); + if (loop_view == 0) return; + + SGPropertyNode *n = config_list[current]; + double lon_deg, lat_deg, alt_ft, roll_deg, pitch_deg, heading_deg; + + // Set up view location and orientation + + if (!n->getBoolValue("config/from-model")) { + lon_deg = fgGetDouble(n->getStringValue("config/eye-lon-deg-path")); + lat_deg = fgGetDouble(n->getStringValue("config/eye-lat-deg-path")); + alt_ft = fgGetDouble(n->getStringValue("config/eye-alt-ft-path")); + roll_deg = fgGetDouble(n->getStringValue("config/eye-roll-deg-path")); + pitch_deg = fgGetDouble(n->getStringValue("config/eye-pitch-deg-path")); + heading_deg = fgGetDouble(n->getStringValue("config/eye-heading-deg-path")); - for (int i = 0; i < fgGetInt("/sim/number-views"); i++) { - viewpath = "/sim/view"; - sprintf(stridx, "[%d]", i); - viewpath += stridx; - - - FGViewer *loop_view = (FGViewer *)get_view( i ); - - // Set up view - nodepath = viewpath; - nodepath += "/config/eye-lon-deg-path"; - double lon_deg = fgGetDouble(fgGetString(nodepath.c_str())); - nodepath = viewpath; - nodepath += "/config/eye-lat-deg-path"; - double lat_deg = fgGetDouble(fgGetString(nodepath.c_str())); - nodepath = viewpath; - nodepath += "/config/eye-alt-ft-path"; - double alt_ft = fgGetDouble(fgGetString(nodepath.c_str())); - nodepath = viewpath; - nodepath += "/config/eye-roll-deg-path"; - double roll_deg = fgGetDouble(fgGetString(nodepath.c_str())); - nodepath = viewpath; - nodepath += "/config/eye-pitch-deg-path"; - double pitch_deg = fgGetDouble(fgGetString(nodepath.c_str())); - nodepath = viewpath; - nodepath += "/config/eye-heading-deg-path"; - double heading_deg = fgGetDouble(fgGetString(nodepath.c_str())); - loop_view->setPosition(lon_deg, lat_deg, alt_ft); loop_view->setOrientation(roll_deg, pitch_deg, heading_deg); + } else { + // force recalc in viewer + loop_view->set_dirty(); + } - // if lookat (type 1) then get target data... - if (loop_view->getType() == 1) { - nodepath = viewpath; - nodepath += "/config/target-lon-deg-path"; - lon_deg = fgGetDouble(fgGetString(nodepath.c_str())); - nodepath = viewpath; - nodepath += "/config/target-lat-deg-path"; - lat_deg = fgGetDouble(fgGetString(nodepath.c_str())); - nodepath = viewpath; - nodepath += "/config/target-alt-ft-path"; - alt_ft = fgGetDouble(fgGetString(nodepath.c_str())); - nodepath = viewpath; - nodepath += "/config/target-roll-deg-path"; - roll_deg = fgGetDouble(fgGetString(nodepath.c_str())); - nodepath = viewpath; - nodepath += "/config/target-pitch-deg-path"; - pitch_deg = fgGetDouble(fgGetString(nodepath.c_str())); - nodepath = viewpath; - nodepath += "/config/target-heading-deg-path"; - heading_deg = fgGetDouble(fgGetString(nodepath.c_str())); - - loop_view ->setTargetPosition(lon_deg, lat_deg, alt_ft); + // if lookat (type 1) then get target data... + if (loop_view->getType() == FG_LOOKAT) { + if (!n->getBoolValue("config/from-model")) { + lon_deg = fgGetDouble(n->getStringValue("config/target-lon-deg-path")); + lat_deg = fgGetDouble(n->getStringValue("config/target-lat-deg-path")); + alt_ft = fgGetDouble(n->getStringValue("config/target-alt-ft-path")); + roll_deg = fgGetDouble(n->getStringValue("config/target-roll-deg-path")); + pitch_deg = fgGetDouble(n->getStringValue("config/target-pitch-deg-path")); + heading_deg = fgGetDouble(n->getStringValue("config/target-heading-deg-path")); + + loop_view->setTargetPosition(lon_deg, lat_deg, alt_ft); loop_view->setTargetOrientation(roll_deg, pitch_deg, heading_deg); + } else { + loop_view->set_dirty(); } } - // Set up the chase view - // FIXME: - // Gotta change sgVec3Slider so that it takes xyz values as inputs - // instead of spherical coordinates. - FGViewer *chase_view = (FGViewer *)get_view( 1 ); - - // get xyz Position offsets directly from GUI/sgVec3Slider - // FIXME: change GUI/sgVec3Slider to store the xyz in properties - // it would probably be faster than the way PilotOffsetGet() - // triggers a recalc all the time. - sgVec3 *pPO = PilotOffsetGet(); - sgVec3 zPO; - sgCopyVec3( zPO, *pPO ); - chase_view->setPositionOffsets(zPO[1], zPO[0], zPO[2] ); - - // Update the current view + setViewXOffset_m(fgGetDouble("/sim/current-view/x-offset-m")); + setViewYOffset_m(fgGetDouble("/sim/current-view/y-offset-m")); + setViewZOffset_m(fgGetDouble("/sim/current-view/z-offset-m")); + + setViewTargetXOffset_m(fgGetDouble("/sim/current-view/target-x-offset-m")); + 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(); - view->update(dt); + 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, loop_view->getPosition() ); + smgr->set_orientation( current_view_orientation ); + + // get the model velocity + SGVec3d velocity = SGVec3d::zeros(); + if ( !stationary() ) { + velocity = globals->get_aircraft_model()->getVelocity(); + } + smgr->set_velocity( velocity ); +} + +void +FGViewMgr::copyToCurrent() +{ + SGPropertyNode *n = config_list[current]; + fgSetString("/sim/current-view/name", n->getStringValue("name")); + fgSetString("/sim/current-view/type", n->getStringValue("type")); + + // copy certain view config data for default values + fgSetDouble("/sim/current-view/config/heading-offset-deg", + n->getDoubleValue("config/default-heading-offset-deg")); + fgSetDouble("/sim/current-view/config/pitch-offset-deg", + n->getDoubleValue("config/pitch-offset-deg")); + fgSetDouble("/sim/current-view/config/roll-offset-deg", + n->getDoubleValue("config/roll-offset-deg")); + fgSetDouble("/sim/current-view/config/default-field-of-view-deg", + n->getDoubleValue("config/default-field-of-view-deg")); + fgSetBool("/sim/current-view/config/from-model", + n->getBoolValue("config/from-model")); + + // copy view data + fgSetDouble("/sim/current-view/x-offset-m", getViewXOffset_m()); + fgSetDouble("/sim/current-view/y-offset-m", getViewYOffset_m()); + fgSetDouble("/sim/current-view/z-offset-m", getViewZOffset_m()); + + fgSetDouble("/sim/current-view/goal-heading-offset-deg", + get_current_view()->getGoalHeadingOffset_deg()); + fgSetDouble("/sim/current-view/goal-pitch-offset-deg", + get_current_view()->getGoalPitchOffset_deg()); + fgSetDouble("/sim/current-view/goal-roll-offset-deg", + get_current_view()->getRollOffset_deg()); + fgSetDouble("/sim/current-view/heading-offset-deg", + get_current_view()->getHeadingOffset_deg()); + fgSetDouble("/sim/current-view/pitch-offset-deg", + get_current_view()->getPitchOffset_deg()); + fgSetDouble("/sim/current-view/roll-offset-deg", + get_current_view()->getRollOffset_deg()); + fgSetDouble("/sim/current-view/target-x-offset-m", + get_current_view()->getTargetXOffset_m()); + fgSetDouble("/sim/current-view/target-y-offset-m", + get_current_view()->getTargetYOffset_m()); + fgSetDouble("/sim/current-view/target-z-offset-m", + get_current_view()->getTargetZOffset_m()); + fgSetBool("/sim/current-view/internal", + 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::getViewOffset_deg () const +FGViewMgr::getViewHeadingOffset_deg () const { const FGViewer * view = get_current_view(); return (view == 0 ? 0 : view->getHeadingOffset_deg()); } void -FGViewMgr::setViewOffset_deg (double offset) +FGViewMgr::setViewHeadingOffset_deg (double offset) { FGViewer * view = get_current_view(); if (view != 0) { @@ -222,14 +478,14 @@ FGViewMgr::setViewOffset_deg (double offset) } double -FGViewMgr::getGoalViewOffset_deg () const +FGViewMgr::getViewGoalHeadingOffset_deg () const { const FGViewer * view = get_current_view(); return (view == 0 ? 0 : view->getGoalHeadingOffset_deg()); } void -FGViewMgr::setGoalViewOffset_deg (double offset) +FGViewMgr::setViewGoalHeadingOffset_deg (double offset) { FGViewer * view = get_current_view(); if (view != 0) @@ -237,14 +493,14 @@ FGViewMgr::setGoalViewOffset_deg (double offset) } double -FGViewMgr::getViewTilt_deg () const +FGViewMgr::getViewPitchOffset_deg () const { const FGViewer * view = get_current_view(); return (view == 0 ? 0 : view->getPitchOffset_deg()); } void -FGViewMgr::setViewTilt_deg (double tilt) +FGViewMgr::setViewPitchOffset_deg (double tilt) { FGViewer * view = get_current_view(); if (view != 0) { @@ -254,14 +510,14 @@ FGViewMgr::setViewTilt_deg (double tilt) } double -FGViewMgr::getGoalViewTilt_deg () const +FGViewMgr::getGoalViewPitchOffset_deg () const { const FGViewer * view = get_current_view(); return (view == 0 ? 0 : view->getGoalPitchOffset_deg()); } void -FGViewMgr::setGoalViewTilt_deg (double tilt) +FGViewMgr::setGoalViewPitchOffset_deg (double tilt) { FGViewer * view = get_current_view(); if (view != 0) @@ -269,71 +525,212 @@ FGViewMgr::setGoalViewTilt_deg (double tilt) } double -FGViewMgr::getPilotXOffset_m () const +FGViewMgr::getViewRollOffset_deg () const +{ + const FGViewer * view = get_current_view(); + return (view == 0 ? 0 : view->getRollOffset_deg()); +} + +void +FGViewMgr::setViewRollOffset_deg (double tilt) +{ + FGViewer * view = get_current_view(); + if (view != 0) { + view->setGoalRollOffset_deg(tilt); + view->setRollOffset_deg(tilt); + } +} + +double +FGViewMgr::getGoalViewRollOffset_deg () const +{ + const FGViewer * view = get_current_view(); + return (view == 0 ? 0 : view->getGoalRollOffset_deg()); +} + +void +FGViewMgr::setGoalViewRollOffset_deg (double tilt) +{ + FGViewer * view = get_current_view(); + if (view != 0) + view->setGoalRollOffset_deg(tilt); +} + +double +FGViewMgr::getViewXOffset_m () const +{ + const FGViewer * view = get_current_view(); + if (view != 0) { + return ((FGViewer *)view)->getXOffset_m(); + } else { + return 0; + } +} + +void +FGViewMgr::setViewXOffset_m (double x) +{ + FGViewer * view = get_current_view(); + if (view != 0) { + view->setXOffset_m(x); + } +} + +double +FGViewMgr::getViewYOffset_m () const +{ + const FGViewer * view = get_current_view(); + if (view != 0) { + return ((FGViewer *)view)->getYOffset_m(); + } else { + return 0; + } +} + +void +FGViewMgr::setViewYOffset_m (double y) +{ + FGViewer * view = get_current_view(); + if (view != 0) { + view->setYOffset_m(y); + } +} + +double +FGViewMgr::getViewZOffset_m () const { - // FIXME: hard-coded pilot view position - const FGViewer * pilot_view = get_view(0); - if (pilot_view != 0) { - return ((FGViewer *)pilot_view)->getXOffset_m(); + const FGViewer * view = get_current_view(); + if (view != 0) { + return ((FGViewer *)view)->getZOffset_m(); } else { return 0; } } void -FGViewMgr::setPilotXOffset_m (double x) +FGViewMgr::setViewZOffset_m (double z) { - // FIXME: hard-coded pilot view position - FGViewer * pilot_view = get_view(0); - if (pilot_view != 0) { - pilot_view->setXOffset_m(x); + FGViewer * view = get_current_view(); + if (view != 0) { + view->setZOffset_m(z); } } +bool +FGViewMgr::stationary () const +{ + const FGViewer * view = get_current_view(); + if (view != 0) { + if (((FGViewer *)view)->getXOffset_m() == 0.0 && + ((FGViewer *)view)->getYOffset_m() == 0.0 && + ((FGViewer *)view)->getZOffset_m() == 0.0) + return true; + } + + return false; +} + double -FGViewMgr::getPilotYOffset_m () const +FGViewMgr::getViewTargetXOffset_m () const { - // FIXME: hard-coded pilot view position - const FGViewer * pilot_view = get_view(0); - if (pilot_view != 0) { - return ((FGViewer *)pilot_view)->getYOffset_m(); + const FGViewer * view = get_current_view(); + if (view != 0) { + return ((FGViewer *)view)->getTargetXOffset_m(); } else { return 0; } } void -FGViewMgr::setPilotYOffset_m (double y) +FGViewMgr::setViewTargetXOffset_m (double x) { - // FIXME: hard-coded pilot view position - FGViewer * pilot_view = get_view(0); - if (pilot_view != 0) { - pilot_view->setYOffset_m(y); + FGViewer * view = get_current_view(); + if (view != 0) { + view->setTargetXOffset_m(x); + } +} + +double +FGViewMgr::getViewTargetYOffset_m () const +{ + const FGViewer * view = get_current_view(); + if (view != 0) { + return ((FGViewer *)view)->getTargetYOffset_m(); + } else { + return 0; + } +} + +void +FGViewMgr::setViewTargetYOffset_m (double y) +{ + FGViewer * view = get_current_view(); + if (view != 0) { + view->setTargetYOffset_m(y); } } double -FGViewMgr::getPilotZOffset_m () const +FGViewMgr::getViewTargetZOffset_m () const { - // FIXME: hard-coded pilot view position - const FGViewer * pilot_view = get_view(0); - if (pilot_view != 0) { - return ((FGViewer *)pilot_view)->getZOffset_m(); + const FGViewer * view = get_current_view(); + if (view != 0) { + return ((FGViewer *)view)->getTargetZOffset_m(); } else { return 0; } } void -FGViewMgr::setPilotZOffset_m (double z) +FGViewMgr::setViewTargetZOffset_m (double z) +{ + FGViewer * view = get_current_view(); + if (view != 0) { + view->setTargetZOffset_m(z); + } +} + +int +FGViewMgr::getView () const +{ + return ( current ); +} + +void +FGViewMgr::setView (int newview) { - // FIXME: hard-coded pilot view position - FGViewer * pilot_view = get_view(0); - if (pilot_view != 0) { - pilot_view->setZOffset_m(z); + // negative numbers -> set view with node index -newview + if (newview < 0) { + for (int i = 0; i < (int)config_list.size(); i++) { + int index = -config_list[i]->getIndex(); + if (index == newview) + newview = i; + } + if (newview < 0) + return; } + + // if newview number too low wrap to last view... + if (newview < 0) + newview = (int)views.size() - 1; + + // if newview number to high wrap to zero... + if (newview >= (int)views.size()) + newview = 0; + + // set new view + set_view(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); } + double FGViewMgr::getFOV_deg () const { @@ -349,6 +746,36 @@ FGViewMgr::setFOV_deg (double fov) view->set_fov(fov); } +double +FGViewMgr::getARM_deg () const +{ + const FGViewer * view = get_current_view(); + return (view == 0 ? 0 : view->get_aspect_ratio_multiplier()); +} + +void +FGViewMgr::setARM_deg (double aspect_ratio_multiplier) +{ + FGViewer * view = get_current_view(); + if (view != 0) + view->set_aspect_ratio_multiplier(aspect_ratio_multiplier); +} + +double +FGViewMgr::getNear_m () const +{ + const FGViewer * view = get_current_view(); + return (view == 0 ? 0.5f : view->getNear_m()); +} + +void +FGViewMgr::setNear_m (double near_m) +{ + FGViewer * view = get_current_view(); + if (view != 0) + view->setNear_m(near_m); +} + void FGViewMgr::setViewAxisLong (double axis) { @@ -361,6 +788,101 @@ FGViewMgr::setViewAxisLat (double axis) 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 () { @@ -377,23 +899,23 @@ FGViewMgr::do_axes () /* Do all the quick and easy cases */ if (axis_long < 0) { // Longitudinal axis forward if (axis_lat == axis_long) - viewDir = 45; + viewDir = fgGetDouble("/sim/view/config/front-left-direction-deg"); else if (axis_lat == - axis_long) - viewDir = 315; + viewDir = fgGetDouble("/sim/view/config/front-right-direction-deg"); else if (axis_lat == 0) - viewDir = 0; + viewDir = fgGetDouble("/sim/view/config/front-direction-deg"); } else if (axis_long > 0) { // Longitudinal axis backward if (axis_lat == - axis_long) - viewDir = 135; + viewDir = fgGetDouble("/sim/view/config/back-left-direction-deg"); else if (axis_lat == axis_long) - viewDir = 225; + viewDir = fgGetDouble("/sim/view/config/back-right-direction-deg"); else if (axis_lat == 0) - viewDir = 180; + viewDir = fgGetDouble("/sim/view/config/back-direction-deg"); } else if (axis_long == 0) { // Longitudinal axis neutral if (axis_lat < 0) - viewDir = 90; + viewDir = fgGetDouble("/sim/view/config/left-direction-deg"); else if (axis_lat > 0) - viewDir = 270; + viewDir = fgGetDouble("/sim/view/config/right-direction-deg"); else return; /* And assertion failure maybe? */ } @@ -404,4 +926,3 @@ FGViewMgr::do_axes () get_current_view()->setGoalHeadingOffset_deg(viewDir); } -