]> git.mxchange.org Git - flightgear.git/blob - src/Main/viewmgr.cxx
Melchior FRANZ:
[flightgear.git] / src / Main / viewmgr.cxx
1 // viewmgr.cxx -- class for managing all the views in the flightgear world.
2 //
3 // Written by Curtis Olson, started October 2000.
4 //   partially rewritten by Jim Wilson March 2002
5 //
6 // Copyright (C) 2000  Curtis L. Olson  - http://www.flightgear.org/~curt
7 //
8 // This program is free software; you can redistribute it and/or
9 // modify it under the terms of the GNU General Public License as
10 // published by the Free Software Foundation; either version 2 of the
11 // License, or (at your option) any later version.
12 //
13 // This program is distributed in the hope that it will be useful, but
14 // WITHOUT ANY WARRANTY; without even the implied warranty of
15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16 // General Public License for more details.
17 //
18 // You should have received a copy of the GNU General Public License
19 // along with this program; if not, write to the Free Software
20 // Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 //
22 // $Id$
23
24 #include <string.h>             // strcmp
25
26 #include <plib/sg.h>
27
28 #include "viewmgr.hxx"
29 #include "fg_props.hxx"
30
31
32 // Constructor
33 FGViewMgr::FGViewMgr( void ) :
34   axis_long(0),
35   axis_lat(0),
36   current(0)
37 {
38 }
39
40
41 // Destructor
42 FGViewMgr::~FGViewMgr( void ) {
43 }
44
45 void
46 FGViewMgr::init ()
47 {
48   char stridx [ 20 ];
49   string viewpath, nodepath, strdata;
50   bool from_model = false;
51   bool at_model = false;
52   int from_model_index = 0;
53   int at_model_index = 0;
54   // double damp_alt;
55   double damp_roll = 0.0, damp_pitch = 0.0, damp_heading = 0.0;
56   double x_offset_m, y_offset_m, z_offset_m, fov_deg;
57   double heading_offset_deg, pitch_offset_deg, roll_offset_deg;
58   double target_x_offset_m, target_y_offset_m, target_z_offset_m;
59   double near_m;
60   bool internal;
61
62   for (int i = 0; i < fgGetInt("/sim/number-views"); i++) {
63     viewpath = "/sim/view";
64     sprintf(stridx, "[%d]", i);
65     viewpath += stridx;
66
67     // find out what type of view this is...
68     nodepath = viewpath;
69     nodepath += "/type";
70     strdata = fgGetString(nodepath.c_str());
71
72     // find out if this is an internal view (e.g. in cockpit, low near plane)
73     internal = false; // default
74     nodepath = viewpath;
75     nodepath += "/internal";
76     internal = fgGetBool(nodepath.c_str());
77
78     // FIXME:
79     // this is assumed to be an aircraft model...we will need to read
80     // model-from-type as well.
81     // find out if this is a model we are looking from...
82     nodepath = viewpath;
83     nodepath += "/config/from-model";
84     from_model = fgGetBool(nodepath.c_str());
85
86     // get model index (which model)
87     if (from_model) {
88       nodepath = viewpath;
89       nodepath += "/config/from-model-idx";
90       from_model_index = fgGetInt(nodepath.c_str());     
91     }
92
93     if ( strcmp("lookat",strdata.c_str()) == 0 ) {
94       // find out if this is a model we are looking at...
95       nodepath = viewpath;
96       nodepath += "/config/at-model";
97       at_model = fgGetBool(nodepath.c_str());
98
99       // get model index (which model)
100       if (at_model) {
101         nodepath = viewpath;
102         nodepath += "/config/at-model-idx";
103         at_model_index = fgGetInt(nodepath.c_str());
104
105         nodepath = viewpath;
106         nodepath += "/config/at-model-roll-damping";
107         damp_roll = fgGetDouble(nodepath.c_str(), 0.0);
108         nodepath = viewpath;
109         nodepath += "/config/at-model-pitch-damping";
110         damp_pitch = fgGetDouble(nodepath.c_str(), 0.0);
111         nodepath = viewpath;
112         nodepath += "/config/at-model-heading-damping";
113         damp_heading = fgGetDouble(nodepath.c_str(), 0.0);
114       }
115     }
116
117     nodepath = viewpath;
118     nodepath += "/config/x-offset-m";
119     x_offset_m = fgGetDouble(nodepath.c_str());
120     nodepath = viewpath;
121     nodepath += "/config/y-offset-m";
122     y_offset_m = fgGetDouble(nodepath.c_str());
123     nodepath = viewpath;
124     nodepath += "/config/z-offset-m";
125     z_offset_m = fgGetDouble(nodepath.c_str());
126     nodepath = viewpath;
127     nodepath += "/config/pitch-offset-deg";
128     pitch_offset_deg = fgGetDouble(nodepath.c_str());
129     fgSetDouble(nodepath.c_str(),pitch_offset_deg);
130     nodepath = viewpath;
131     nodepath += "/config/heading-offset-deg";
132     heading_offset_deg = fgGetDouble(nodepath.c_str());
133     fgSetDouble(nodepath.c_str(),heading_offset_deg);
134     nodepath = viewpath;
135     nodepath += "/config/roll-offset-deg";
136     roll_offset_deg = fgGetDouble(nodepath.c_str());
137     fgSetDouble(nodepath.c_str(),roll_offset_deg);
138     nodepath = viewpath;
139     nodepath += "/config/default-field-of-view-deg";
140     fov_deg = fgGetDouble(nodepath.c_str());
141
142     // target offsets for lookat mode only...
143     nodepath = viewpath;
144     nodepath += "/config/target-x-offset-m";
145     target_x_offset_m = fgGetDouble(nodepath.c_str());
146     nodepath = viewpath;
147     nodepath += "/config/target-y-offset-m";
148     target_y_offset_m = fgGetDouble(nodepath.c_str());
149     nodepath = viewpath;
150     nodepath += "/config/target-z-offset-m";
151     target_z_offset_m = fgGetDouble(nodepath.c_str());
152
153     nodepath = viewpath;
154     nodepath += "/config/ground-level-nearplane-m";
155     near_m = fgGetDouble(nodepath.c_str());
156
157     // supporting two types now "lookat" = 1 and "lookfrom" = 0
158     if ( strcmp("lookat",strdata.c_str()) == 0 )
159       add_view(new FGViewer ( FG_LOOKAT, from_model, from_model_index,
160                               at_model, at_model_index,
161                               damp_roll, damp_pitch, damp_heading,
162                               x_offset_m, y_offset_m,z_offset_m,
163                               heading_offset_deg, pitch_offset_deg,
164                               roll_offset_deg, fov_deg,
165                               target_x_offset_m, target_y_offset_m,
166                               target_z_offset_m, near_m, internal ));
167     else
168       add_view(new FGViewer ( FG_LOOKFROM, from_model, from_model_index,
169                               false, 0, 0.0, 0.0, 0.0,
170                               x_offset_m, y_offset_m, z_offset_m,
171                               heading_offset_deg, pitch_offset_deg,
172                               roll_offset_deg, fov_deg, 0, 0, 0, near_m,
173                               internal ));
174   }
175
176   copyToCurrent();
177   
178 }
179
180 void
181 FGViewMgr::reinit ()
182 {
183   char stridx [ 20 ];
184   string viewpath, nodepath, strdata;
185   double fov_deg;
186
187   // reset offsets and fov to configuration defaults
188
189   for (int i = 0; i < fgGetInt("/sim/number-views"); i++) {
190     viewpath = "/sim/view";
191     sprintf(stridx, "[%d]", i);
192     viewpath += stridx;
193
194     setView(i);
195
196     nodepath = viewpath;
197     nodepath += "/config/x-offset-m";
198     fgSetDouble("/sim/current-view/x-offset-m",fgGetDouble(nodepath.c_str()));
199
200     nodepath = viewpath;
201     nodepath += "/config/y-offset-m";
202     fgSetDouble("/sim/current-view/y-offset-m",fgGetDouble(nodepath.c_str()));
203
204     nodepath = viewpath;
205     nodepath += "/config/z-offset-m";
206     fgSetDouble("/sim/current-view/z-offset-m",fgGetDouble(nodepath.c_str()));
207
208     nodepath = viewpath;
209     nodepath += "/config/pitch-offset-deg";
210     fgSetDouble("/sim/current-view/pitch-offset-deg",
211                 fgGetDouble(nodepath.c_str()));
212
213     nodepath = viewpath;
214     nodepath += "/config/heading-offset-deg";
215     fgSetDouble("/sim/current-view/heading-offset-deg",
216                 fgGetDouble(nodepath.c_str()));
217
218     nodepath = viewpath;
219     nodepath += "/config/roll-offset-deg";
220     fgSetDouble("/sim/current-view/roll-offset-deg",
221                 fgGetDouble(nodepath.c_str()));
222
223     nodepath = viewpath;
224     nodepath += "/config/default-field-of-view-deg";
225     fov_deg = fgGetDouble(nodepath.c_str());
226     if (fov_deg < 10.0) {
227       fov_deg = 55.0;
228     }
229     fgSetDouble("/sim/current-view/field-of-view",fov_deg);
230
231     // target offsets for lookat mode only...
232     nodepath = viewpath;
233     nodepath += "/config/target-x-offset-m";
234     fgSetDouble("/sim/current-view/target-x-offset-deg",
235                 fgGetDouble(nodepath.c_str()));
236
237     nodepath = viewpath;
238     nodepath += "/config/target-y-offset-m";
239     fgSetDouble("/sim/current-view/target-y-offset-deg",
240                 fgGetDouble(nodepath.c_str()));
241
242     nodepath = viewpath;
243     nodepath += "/config/target-z-offset-m";
244     fgSetDouble("/sim/current-view/target-z-offset-deg",
245                 fgGetDouble(nodepath.c_str()));
246
247  }
248
249     setView(0);
250
251 }
252
253 typedef double (FGViewMgr::*double_getter)() const;
254
255 void
256 FGViewMgr::bind ()
257 {
258   // these are bound to the current view properties
259   fgTie("/sim/current-view/heading-offset-deg", this,
260         &FGViewMgr::getViewHeadingOffset_deg,
261         &FGViewMgr::setViewHeadingOffset_deg);
262   fgSetArchivable("/sim/current-view/heading-offset-deg");
263   fgTie("/sim/current-view/goal-heading-offset-deg", this,
264         &FGViewMgr::getViewGoalHeadingOffset_deg,
265         &FGViewMgr::setViewGoalHeadingOffset_deg);
266   fgSetArchivable("/sim/current-view/goal-heading-offset-deg");
267   fgTie("/sim/current-view/pitch-offset-deg", this,
268         &FGViewMgr::getViewPitchOffset_deg,
269         &FGViewMgr::setViewPitchOffset_deg);
270   fgSetArchivable("/sim/current-view/pitch-offset-deg");
271   fgTie("/sim/current-view/goal-pitch-offset-deg", this,
272         &FGViewMgr::getGoalViewPitchOffset_deg,
273         &FGViewMgr::setGoalViewPitchOffset_deg);
274   fgSetArchivable("/sim/current-view/goal-pitch-offset-deg");
275   fgTie("/sim/current-view/roll-offset-deg", this,
276         &FGViewMgr::getViewRollOffset_deg,
277         &FGViewMgr::setViewRollOffset_deg);
278   fgSetArchivable("/sim/current-view/roll-offset-deg");
279   fgTie("/sim/current-view/goal-roll-offset-deg", this,
280         &FGViewMgr::getGoalViewRollOffset_deg,
281         &FGViewMgr::setGoalViewRollOffset_deg);
282   fgSetArchivable("/sim/current-view/goal-roll-offset-deg");
283
284   fgTie("/sim/current-view/view-number", this, 
285                       &FGViewMgr::getView, &FGViewMgr::setView);
286   fgSetArchivable("/sim/current-view/view-number", FALSE);
287
288   fgTie("/sim/current-view/axes/long", this,
289         (double_getter)0, &FGViewMgr::setViewAxisLong);
290   fgSetArchivable("/sim/current-view/axes/long");
291
292   fgTie("/sim/current-view/axes/lat", this,
293         (double_getter)0, &FGViewMgr::setViewAxisLat);
294   fgSetArchivable("/sim/current-view/axes/lat");
295
296   fgTie("/sim/current-view/field-of-view", this,
297         &FGViewMgr::getFOV_deg, &FGViewMgr::setFOV_deg);
298   fgSetArchivable("/sim/current-view/field-of-view");
299
300   fgTie("/sim/current-view/ground-level-nearplane-m", this,
301         &FGViewMgr::getNear_m, &FGViewMgr::setNear_m);
302   fgSetArchivable("/sim/current-view/ground-level-nearplane-m");
303
304 }
305
306 void
307 FGViewMgr::unbind ()
308 {
309   // FIXME:
310   // need to redo these bindings to the new locations (move to viewer?)
311   fgUntie("/sim/current-view/heading-offset-deg");
312   fgUntie("/sim/current-view/goal-heading-offset-deg");
313   fgUntie("/sim/current-view/pitch-offset-deg");
314   fgUntie("/sim/current-view/goal-pitch-offset-deg");
315   fgUntie("/sim/field-of-view");
316   fgUntie("/sim/current-view/view-number");
317   fgUntie("/sim/current-view/axes/long");
318   fgUntie("/sim/current-view/axes/lat");
319   fgUntie("/sim/current-view/ground-level-nearplane-m");
320 }
321
322 void
323 FGViewMgr::update (double dt)
324 {
325   char stridx [20];
326   string viewpath, nodepath;
327   double lon_deg, lat_deg, alt_ft, roll_deg, pitch_deg, heading_deg;
328
329   FGViewer * view = get_current_view();
330   if (view == 0)
331     return;
332
333   // 
334   int i = current;
335   viewpath = "/sim/view";
336   sprintf(stridx, "[%d]", i);
337   viewpath += stridx;
338
339   FGViewer *loop_view = (FGViewer *)get_view( i );
340
341                 // Set up view location and orientation
342
343   nodepath = viewpath;
344   nodepath += "/config/from-model";
345   if (!fgGetBool(nodepath.c_str())) {
346     nodepath = viewpath;
347     nodepath += "/config/eye-lon-deg-path";
348     lon_deg = fgGetDouble(fgGetString(nodepath.c_str()));
349     nodepath = viewpath;
350     nodepath += "/config/eye-lat-deg-path";
351     lat_deg = fgGetDouble(fgGetString(nodepath.c_str()));
352     nodepath = viewpath;
353     nodepath += "/config/eye-alt-ft-path";
354     alt_ft = fgGetDouble(fgGetString(nodepath.c_str()));
355     nodepath = viewpath;
356     nodepath += "/config/eye-roll-deg-path";
357     roll_deg = fgGetDouble(fgGetString(nodepath.c_str()));
358     nodepath = viewpath;
359     nodepath += "/config/eye-pitch-deg-path";
360     pitch_deg = fgGetDouble(fgGetString(nodepath.c_str()));
361     nodepath = viewpath;
362     nodepath += "/config/eye-heading-deg-path";
363     heading_deg = fgGetDouble(fgGetString(nodepath.c_str()));
364     loop_view->setPosition(lon_deg, lat_deg, alt_ft);
365     loop_view->setOrientation(roll_deg, pitch_deg, heading_deg);
366   } else {
367     // force recalc in viewer
368     loop_view->set_dirty();
369   }
370
371   // if lookat (type 1) then get target data...
372   if (loop_view->getType() == FG_LOOKAT) {
373     nodepath = viewpath;
374     nodepath += "/config/from-model";
375     if (!fgGetBool(nodepath.c_str())) {
376       nodepath = viewpath;
377       nodepath += "/config/target-lon-deg-path";
378       lon_deg = fgGetDouble(fgGetString(nodepath.c_str()));
379       nodepath = viewpath;
380       nodepath += "/config/target-lat-deg-path";
381       lat_deg = fgGetDouble(fgGetString(nodepath.c_str()));
382       nodepath = viewpath;
383       nodepath += "/config/target-alt-ft-path";
384       alt_ft = fgGetDouble(fgGetString(nodepath.c_str()));
385       nodepath = viewpath;
386       nodepath += "/config/target-roll-deg-path";
387       roll_deg = fgGetDouble(fgGetString(nodepath.c_str()));
388       nodepath = viewpath;
389       nodepath += "/config/target-pitch-deg-path";
390       pitch_deg = fgGetDouble(fgGetString(nodepath.c_str()));
391       nodepath = viewpath;
392       nodepath += "/config/target-heading-deg-path";
393       heading_deg = fgGetDouble(fgGetString(nodepath.c_str()));
394
395       loop_view->setTargetPosition(lon_deg, lat_deg, alt_ft);
396       loop_view->setTargetOrientation(roll_deg, pitch_deg, heading_deg);
397     } else {
398       loop_view->set_dirty();
399     }
400   }
401
402   setViewXOffset_m(fgGetDouble("/sim/current-view/x-offset-m"));
403   setViewYOffset_m(fgGetDouble("/sim/current-view/y-offset-m"));
404   setViewZOffset_m(fgGetDouble("/sim/current-view/z-offset-m"));
405
406   setViewTargetXOffset_m(fgGetDouble("/sim/current-view/target-x-offset-m"));
407   setViewTargetYOffset_m(fgGetDouble("/sim/current-view/target-y-offset-m"));
408   setViewTargetZOffset_m(fgGetDouble("/sim/current-view/target-z-offset-m"));
409
410                                 // Update the current view
411   do_axes();
412   view->update(dt);
413 }
414
415 void
416 FGViewMgr::copyToCurrent()
417 {
418     char stridx [20];
419     string viewpath, nodepath;
420
421     int i = current;
422     viewpath = "/sim/view";
423     sprintf(stridx, "[%d]", i);
424     viewpath += stridx;
425
426     // copy certain view config data for default values
427     nodepath = viewpath;
428     nodepath += "/config/default-heading-offset-deg";
429     fgSetDouble("/sim/current-view/config/heading-offset-deg",
430                 fgGetDouble(nodepath.c_str()));
431
432     nodepath = viewpath;
433     nodepath += "/config/pitch-offset-deg";
434     fgSetDouble("/sim/current-view/config/pitch-offset-deg",
435                 fgGetDouble(nodepath.c_str()));
436
437     nodepath = viewpath;
438     nodepath += "/config/roll-offset-deg";
439     fgSetDouble("/sim/current-view/config/roll-offset-deg",
440                 fgGetDouble(nodepath.c_str()));
441
442     nodepath = viewpath;
443     nodepath += "/config/default-field-of-view-deg";
444     fgSetDouble("/sim/current-view/config/default-field-of-view-deg",
445                 fgGetDouble(nodepath.c_str()));
446
447     nodepath = viewpath;
448     nodepath += "/config/from-model";
449     fgSetBool("/sim/current-view/config/from-model",
450                 fgGetBool(nodepath.c_str()));
451
452
453     // copy view data
454     fgSetDouble("/sim/current-view/x-offset-m", getViewXOffset_m());
455     fgSetDouble("/sim/current-view/y-offset-m", getViewYOffset_m());
456     fgSetDouble("/sim/current-view/z-offset-m", getViewZOffset_m());
457     fgSetDouble("/sim/current-view/goal-heading-offset-deg",
458                 get_current_view()->getGoalHeadingOffset_deg());
459     fgSetDouble("/sim/current-view/goal-pitch-offset-deg",
460                 get_current_view()->getGoalPitchOffset_deg());
461     fgSetDouble("/sim/current-view/goal-roll-offset-deg",
462                 get_current_view()->getRollOffset_deg());
463     fgSetDouble("/sim/current-view/heading-offset-deg",
464                 get_current_view()->getHeadingOffset_deg());
465     fgSetDouble("/sim/current-view/pitch-offset-deg",
466                 get_current_view()->getPitchOffset_deg());
467     fgSetDouble("/sim/current-view/roll-offset-deg",
468                 get_current_view()->getRollOffset_deg());
469     fgSetDouble("/sim/current-view/target-x-offset-m",
470                 get_current_view()->getTargetXOffset_m());
471     fgSetDouble("/sim/current-view/target-y-offset-m",
472                 get_current_view()->getTargetYOffset_m());
473     fgSetDouble("/sim/current-view/target-z-offset-m",
474                 get_current_view()->getTargetZOffset_m());
475
476     fgSetBool("/sim/current-view/internal",
477                 get_current_view()->getInternal());
478
479 }
480
481
482 double
483 FGViewMgr::getViewHeadingOffset_deg () const
484 {
485   const FGViewer * view = get_current_view();
486   return (view == 0 ? 0 : view->getHeadingOffset_deg());
487 }
488
489 void
490 FGViewMgr::setViewHeadingOffset_deg (double offset)
491 {
492   FGViewer * view = get_current_view();
493   if (view != 0) {
494     view->setGoalHeadingOffset_deg(offset);
495     view->setHeadingOffset_deg(offset);
496   }
497 }
498
499 double
500 FGViewMgr::getViewGoalHeadingOffset_deg () const
501 {
502   const FGViewer * view = get_current_view();
503   return (view == 0 ? 0 : view->getGoalHeadingOffset_deg());
504 }
505
506 void
507 FGViewMgr::setViewGoalHeadingOffset_deg (double offset)
508 {
509   FGViewer * view = get_current_view();
510   if (view != 0)
511     view->setGoalHeadingOffset_deg(offset);
512 }
513
514 double
515 FGViewMgr::getViewPitchOffset_deg () const
516 {
517   const FGViewer * view = get_current_view();
518   return (view == 0 ? 0 : view->getPitchOffset_deg());
519 }
520
521 void
522 FGViewMgr::setViewPitchOffset_deg (double tilt)
523 {
524   FGViewer * view = get_current_view();
525   if (view != 0) {
526     view->setGoalPitchOffset_deg(tilt);
527     view->setPitchOffset_deg(tilt);
528   }
529 }
530
531 double
532 FGViewMgr::getGoalViewPitchOffset_deg () const
533 {
534   const FGViewer * view = get_current_view();
535   return (view == 0 ? 0 : view->getGoalPitchOffset_deg());
536 }
537
538 void
539 FGViewMgr::setGoalViewPitchOffset_deg (double tilt)
540 {
541   FGViewer * view = get_current_view();
542   if (view != 0)
543     view->setGoalPitchOffset_deg(tilt);
544 }
545
546 double
547 FGViewMgr::getViewRollOffset_deg () const
548 {
549   const FGViewer * view = get_current_view();
550   return (view == 0 ? 0 : view->getRollOffset_deg());
551 }
552
553 void
554 FGViewMgr::setViewRollOffset_deg (double tilt)
555 {
556   FGViewer * view = get_current_view();
557   if (view != 0) {
558     view->setGoalRollOffset_deg(tilt);
559     view->setRollOffset_deg(tilt);
560   }
561 }
562
563 double
564 FGViewMgr::getGoalViewRollOffset_deg () const
565 {
566   const FGViewer * view = get_current_view();
567   return (view == 0 ? 0 : view->getGoalRollOffset_deg());
568 }
569
570 void
571 FGViewMgr::setGoalViewRollOffset_deg (double tilt)
572 {
573   FGViewer * view = get_current_view();
574   if (view != 0)
575     view->setGoalRollOffset_deg(tilt);
576 }
577
578 double
579 FGViewMgr::getViewXOffset_m () const
580 {
581   const FGViewer * view = get_current_view();
582   if (view != 0) {
583     return ((FGViewer *)view)->getXOffset_m();
584   } else {
585     return 0;
586   }
587 }
588
589 void
590 FGViewMgr::setViewXOffset_m (double x)
591 {
592   FGViewer * view = get_current_view();
593   if (view != 0) {
594     view->setXOffset_m(x);
595   }
596 }
597
598 double
599 FGViewMgr::getViewYOffset_m () const
600 {
601   const FGViewer * view = get_current_view();
602   if (view != 0) {
603     return ((FGViewer *)view)->getYOffset_m();
604   } else {
605     return 0;
606   }
607 }
608
609 void
610 FGViewMgr::setViewYOffset_m (double y)
611 {
612   FGViewer * view = get_current_view();
613   if (view != 0) {
614     view->setYOffset_m(y);
615   }
616 }
617
618 double
619 FGViewMgr::getViewZOffset_m () const
620 {
621   const FGViewer * view = get_current_view();
622   if (view != 0) {
623     return ((FGViewer *)view)->getZOffset_m();
624   } else {
625     return 0;
626   }
627 }
628
629 void
630 FGViewMgr::setViewZOffset_m (double z)
631 {
632   FGViewer * view = get_current_view();
633   if (view != 0) {
634     view->setZOffset_m(z);
635   }
636 }
637
638 double
639 FGViewMgr::getViewTargetXOffset_m () const
640 {
641   const FGViewer * view = get_current_view();
642   if (view != 0) {
643     return ((FGViewer *)view)->getTargetXOffset_m();
644   } else {
645     return 0;
646   }
647 }
648
649 void
650 FGViewMgr::setViewTargetXOffset_m (double x)
651 {
652   FGViewer * view = get_current_view();
653   if (view != 0) {
654     view->setTargetXOffset_m(x);
655   }
656 }
657
658 double
659 FGViewMgr::getViewTargetYOffset_m () const
660 {
661   const FGViewer * view = get_current_view();
662   if (view != 0) {
663     return ((FGViewer *)view)->getTargetYOffset_m();
664   } else {
665     return 0;
666   }
667 }
668
669 void
670 FGViewMgr::setViewTargetYOffset_m (double y)
671 {
672   FGViewer * view = get_current_view();
673   if (view != 0) {
674     view->setTargetYOffset_m(y);
675   }
676 }
677
678 double
679 FGViewMgr::getViewTargetZOffset_m () const
680 {
681   const FGViewer * view = get_current_view();
682   if (view != 0) {
683     return ((FGViewer *)view)->getTargetZOffset_m();
684   } else {
685     return 0;
686   }
687 }
688
689 void
690 FGViewMgr::setViewTargetZOffset_m (double z)
691 {
692   FGViewer * view = get_current_view();
693   if (view != 0) {
694     view->setTargetZOffset_m(z);
695   }
696 }
697
698 int
699 FGViewMgr::getView () const
700 {
701   return ( current );
702 }
703
704 void
705 FGViewMgr::setView (int newview )
706 {
707   // if newview number too low wrap to last view...
708   if ( newview < 0 ) {
709     newview = (int)views.size() -1;
710   }
711   // if newview number to high wrap to zero...
712   if ( newview > ((int)views.size() -1) ) {
713     newview = 0;
714   }
715   // set new view
716   set_view( newview );
717   // copy in view data
718   copyToCurrent ();
719 }
720
721
722 double
723 FGViewMgr::getFOV_deg () const
724 {
725   const FGViewer * view = get_current_view();
726   return (view == 0 ? 0 : view->get_fov());
727 }
728
729 void
730 FGViewMgr::setFOV_deg (double fov)
731 {
732   FGViewer * view = get_current_view();
733   if (view != 0)
734     view->set_fov(fov);
735 }
736
737 double
738 FGViewMgr::getNear_m () const
739 {
740   const FGViewer * view = get_current_view();
741   return (view == 0 ? 0.5f : view->getNear_m());
742 }
743
744 void
745 FGViewMgr::setNear_m (double near_m)
746 {
747   FGViewer * view = get_current_view();
748   if (view != 0)
749     view->setNear_m(near_m);
750 }
751
752 void
753 FGViewMgr::setViewAxisLong (double axis)
754 {
755   axis_long = axis;
756 }
757
758 void
759 FGViewMgr::setViewAxisLat (double axis)
760 {
761   axis_lat = axis;
762 }
763
764 void
765 FGViewMgr::do_axes ()
766 {
767                                 // Take no action when hat is centered
768   if ( ( axis_long <  0.01 ) &&
769        ( axis_long > -0.01 ) &&
770        ( axis_lat  <  0.01 ) &&
771        ( axis_lat  > -0.01 )
772      )
773     return;
774
775   double viewDir = 999;
776
777   /* Do all the quick and easy cases */
778   if (axis_long < 0) {          // Longitudinal axis forward
779     if (axis_lat == axis_long)
780       viewDir = fgGetDouble("/sim/view/config/front-left-direction-deg");
781     else if (axis_lat == - axis_long)
782       viewDir = fgGetDouble("/sim/view/config/front-right-direction-deg");
783     else if (axis_lat == 0)
784       viewDir = fgGetDouble("/sim/view/config/front-direction-deg");
785   } else if (axis_long > 0) {   // Longitudinal axis backward
786     if (axis_lat == - axis_long)
787       viewDir = fgGetDouble("/sim/view/config/back-left-direction-deg");
788     else if (axis_lat == axis_long)
789       viewDir = fgGetDouble("/sim/view/config/back-right-direction-deg");
790     else if (axis_lat == 0)
791       viewDir = fgGetDouble("/sim/view/config/back-direction-deg");
792   } else if (axis_long == 0) {  // Longitudinal axis neutral
793     if (axis_lat < 0)
794       viewDir = fgGetDouble("/sim/view/config/left-direction-deg");
795     else if (axis_lat > 0)
796       viewDir = fgGetDouble("/sim/view/config/right-direction-deg");
797     else return; /* And assertion failure maybe? */
798   }
799
800                                 // Do all the difficult cases
801   if ( viewDir > 900 )
802     viewDir = SGD_RADIANS_TO_DEGREES * atan2 ( -axis_lat, -axis_long );
803   if ( viewDir < -1 ) viewDir += 360;
804
805   get_current_view()->setGoalHeadingOffset_deg(viewDir);
806 }