X-Git-Url: https://git.mxchange.org/?a=blobdiff_plain;f=src%2FMain%2Fviewer.hxx;h=107401a373fa572b73e82251c09718a63caaa104;hb=4141c6f8bb42b3491502f5e6b82595367da9fb69;hp=b42d4bb801613230876cd70f8d675e36da462a9b;hpb=ce574d59f536512931fa27a439d001863219f40b;p=flightgear.git

diff --git a/src/Main/viewer.hxx b/src/Main/viewer.hxx
index b42d4bb80..107401a37 100644
--- a/src/Main/viewer.hxx
+++ b/src/Main/viewer.hxx
@@ -31,20 +31,9 @@
 #endif                                   
 
 #include <simgear/compiler.h>
-#include <simgear/math/point3d.hxx>
-#include <simgear/timing/sg_time.hxx>
-
-#include <list>
 
 #include <plib/sg.h>		// plib include
 
-#include <FDM/flight.hxx>
-#include <Time/light.hxx>
-
-#include "options.hxx"
-
-FG_USING_STD(list);
-
 
 #define FG_FOV_MIN 0.1
 #define FG_FOV_MAX 179.9
@@ -53,54 +42,61 @@ FG_USING_STD(list);
 // Define a structure containing view information
 class FGViewer {
 
+public:
+
+    enum fgViewType {
+	FG_RPH = 0,
+	FG_LOOKAT = 1,
+	FG_HPR = 2
+    };
+
 private:
 
+    // flag forcing a recalc of derived view parameters
+    bool dirty;
+
+protected:
+
+    fgViewType _type;
+
+    // the field of view in the x (width) direction
+    double fov; 
+
+    // ratio of x and y fov's; fov(y) = fov(x) * win_ratio
+    double win_ratio;
+
     // the current view offset angle from forward (rotated about the
     // view_up vector)
     double view_offset;
+    bool reverse_view_offset;
 
     // the goal view offset angle  (used for smooth view changes)
     double goal_view_offset;
 
-    // flag forcing update of fov related stuff
-    bool update_fov;
-	
-    // fov of view is specified in the X direction, win_ratio is used to
-    // calculate the fov in the Y direction.  fov(y) = fov(x) * win_ratio
-    double win_ratio;
-
-    // width & height of window
-    int winWidth, winHeight;
+    // geodetic view position
+    sgdVec3 geod_view_pos;
 
     // absolute view position in earth coordinates
-    Point3D abs_view_pos;
+    sgdVec3 abs_view_pos;
 
     // view position in opengl world coordinates (this is the
     // abs_view_pos translated to scenery.center)
-    Point3D view_pos;
+    sgVec3 view_pos;
 
-    // pilot offset from center of gravity.  The X axis is positive
-    // out the tail, Y is out the right wing, and Z is positive up.
-    // Distances in meters of course.
-    sgVec3 pilot_offset;
+    // radius to sea level from center of the earth (m)
+    double sea_level_radius;
 
     // cartesion coordinates of current lon/lat if at sea level
     // translated to scenery.center
-    Point3D cur_zero_elev;
-
-    // vector in cartesian coordinates from current position to the
-    // postion on the earth's surface the sun is directly over
-    sgVec3 to_sun;
+    sgVec3 zero_elev;
 
-    // surface direction to go to head towards sun
-    sgVec3 surface_to_sun;
+    // height ASL of the terrain for our current view position
+    // (future?) double ground_elev;
 
-    // vector in cartesian coordinates from current position to the
-    // postion on the earth's surface the moon is directly over
-    sgVec3 to_moon;
-  
-    // surface direction to go to head towards moon
-    sgVec3 surface_to_moon;
+    // pilot offset from center of gravity.  The X axis is positive
+    // out the tail, Y is out the right wing, and Z is positive up.
+    // Distances in meters of course.
+    sgVec3 pilot_offset;
 
     // surface vector heading south
     sgVec3 surface_south;
@@ -109,26 +105,18 @@ private:
     // with sun)
     sgVec3 surface_east;
 
-    // local up vector (normal to the plane tangent to the earth's
+    // world up vector (normal to the plane tangent to the earth's
     // surface at the spot we are directly above
-    sgVec3 local_up;
-
-    // up vector for the view (usually point straight up through the
-    // top of the aircraft
-    sgVec3 view_up;
+    sgVec3 world_up;
 
-    // the vector pointing straight out the nose of the aircraft
-    sgVec3 view_forward;
-
-    // Transformation matrix for eye coordinates to aircraft coordinates
-    // sgMat4 AIRCRAFT;
+    // sg versions of our friendly matrices
+    sgMat4 VIEW, VIEW_ROT, UP;
 
-    // Transformation matrix for the view direction offset relative to
-    // the AIRCRAFT matrix
-    sgMat4 VIEW_OFFSET;
+    inline void set_dirty() { dirty = true; }
+    inline void set_clean() { dirty = false; }
 
-    // sg versions of our friendly matrices
-    sgMat4 LOCAL, UP, VIEW_ROT, TRANS, VIEW, LARC_TO_SSG;
+    // Update the view volume, position, and orientation
+    virtual void update() = 0;
 
 public:
 
@@ -136,71 +124,113 @@ public:
     FGViewer( void );
 
     // Destructor
-    ~FGViewer( void );
-
-    // Initialize a view class
-    void Init( void );
-
-    // Update the view volume, position, and orientation
-    void UpdateViewParams( const FGInterface& f );
-
-    // Flag to request that UpdateFOV() be called next time
-    // UpdateViewMath() is run.
-    inline void force_update_fov_math() { update_fov = true; }
-
-    // Update the view parameters
-    void UpdateViewMath( const FGInterface& f );
-
-    // Update the field of view coefficients
-    void UpdateFOV( const fgOPTIONS& o );
+    virtual ~FGViewer( void );
 
-    // Transform a vector from world coordinates to the local plane
-    void CurrentNormalInLocalPlane(sgVec3 dst, sgVec3 src);
+    //////////////////////////////////////////////////////////////////////
+    // setter functions
+    //////////////////////////////////////////////////////////////////////
+    inline void set_fov( double amount ) { fov = amount; }
+    inline void set_win_ratio( double r ) { win_ratio = r; }
+    inline void set_view_offset( double a ) {
+	set_dirty();
+	view_offset = a;
+    }
+    inline void inc_view_offset( double amt ) {
+	set_dirty();
+	view_offset += amt;
+    }
+    inline void set_goal_view_offset( double a) {
+	set_dirty();
+	goal_view_offset = a;
+	while ( goal_view_offset < 0 ) {
+	    goal_view_offset += 360.0;
+	}
+	while ( goal_view_offset > 360.0 ) {
+	    goal_view_offset -= 360.0;
+	}
+    }
+    inline void set_reverse_view_offset( bool val ) {
+	reverse_view_offset = val;
+    }
+    inline void set_geod_view_pos( double lon, double lat, double alt ) {
+	// data should be in radians and meters asl
+	set_dirty();
+	// cout << "set_geod_view_pos = " << lon << ", " << lat << ", " << alt
+	//      << endl;
+	sgdSetVec3( geod_view_pos, lon, lat, alt );
+    }
+    inline void set_pilot_offset( float x, float y, float z ) {
+	set_dirty();
+	sgSetVec3( pilot_offset, x, y, z );
+    }
+    inline void set_sea_level_radius( double r ) {
+	// data should be in meters from the center of the earth
+	set_dirty();
+	sea_level_radius = r;
+    }
 
+    //////////////////////////////////////////////////////////////////////
     // accessor functions
+    //////////////////////////////////////////////////////////////////////
+    inline int get_type() const { return _type ; }
+    inline int is_a( int t ) const { return get_type() == t ; }
+    inline bool is_dirty() const { return dirty; }
+    inline double get_fov() const { return fov; }
+    inline double get_win_ratio() const { return win_ratio; }
     inline double get_view_offset() const { return view_offset; }
-    inline void set_view_offset( double a ) { view_offset = a; }
-    inline void inc_view_offset( double amt ) { view_offset += amt; }
+    inline bool get_reverse_view_offset() const { return reverse_view_offset; }
     inline double get_goal_view_offset() const { return goal_view_offset; }
-    inline void set_goal_view_offset( double a) { goal_view_offset = a; }
-    inline double get_win_ratio() const { return win_ratio; }
-    inline void set_win_ratio( double r ) { win_ratio = r; }
-    inline int get_winWidth() const { return winWidth; }
-    inline void set_winWidth( int w ) { winWidth = w; }
-    inline int get_winHeight() const { return winHeight; }
-    inline void set_winHeight( int h ) { winHeight = h; }
-    inline Point3D get_abs_view_pos() const { return abs_view_pos; }
-    inline Point3D get_view_pos() const { return view_pos; }
+    inline double *get_geod_view_pos() { return geod_view_pos; }
     inline float *get_pilot_offset() { return pilot_offset; }
-    inline void set_pilot_offset( float x, float y, float z ) {
-	sgSetVec3( pilot_offset, x, y, z );
+    inline double get_sea_level_radius() const { return sea_level_radius; }
+
+    //////////////////////////////////////////////////////////////////////
+    // derived values accessor functions
+    //////////////////////////////////////////////////////////////////////
+    inline double *get_abs_view_pos() {
+	if ( dirty ) { update(); }
+	return abs_view_pos;
     }
-    inline Point3D get_cur_zero_elev() const { return cur_zero_elev; }
-    inline float *get_to_sun() { return to_sun; }
-    inline void set_to_sun( float x, float y, float z ) {
-	sgSetVec3( to_sun, x, y, z );
+    inline float *get_view_pos() {
+	if ( dirty ) { update(); }
+	return view_pos;
     }
-    inline float *get_surface_to_sun() { return surface_to_sun; }
-    inline void set_surface_to_sun( float x, float y, float z) {
-	sgSetVec3( surface_to_sun, x, y, z );
+    inline float *get_zero_elev() {
+	if ( dirty ) { update(); }
+	return zero_elev;
     }
-    inline float *get_to_moon() { return to_moon; }
-    inline void set_to_moon( float x, float y, float z) {
-	sgSetVec3( to_moon, x, y, z );
+    // (future?)
+    // inline double get_ground_elev() {
+    //  if ( dirty ) { update(); }
+    //	return ground_elev;
+    // }
+    inline float *get_surface_south() {
+	if ( dirty ) { update(); }
+	return surface_south;
     }
-    inline float *get_surface_to_moon() { return surface_to_moon; }
-    inline void set_surface_to_moon( float x, float y, float z) {
-	sgSetVec3( surface_to_moon, x, y, z );
+    inline float *get_surface_east() {
+	if ( dirty ) { update(); }
+	return surface_east;
+    }
+    inline float *get_world_up() {
+	if ( dirty ) { update(); }
+	return world_up;
+    }
+    inline const sgVec4 *get_VIEW() {
+	if ( dirty ) { update(); }
+	return VIEW;
+    }
+    inline const sgVec4 *get_VIEW_ROT() {
+	if ( dirty ) { update(); }
+	return VIEW_ROT;
+    }
+    inline const sgVec4 *get_UP() {
+	if ( dirty ) { update(); }
+	return UP;
     }
-    inline float *get_surface_south() { return surface_south; }
-    inline float *get_surface_east() { return surface_east; }
-    inline float *get_local_up() { return local_up; }
-    inline float *get_view_forward() { return view_forward; }
-
-    inline const sgVec4 *get_VIEW() { return VIEW; }
-    inline const sgVec4 *get_VIEW_ROT() { return VIEW_ROT; }
 };
 
+
 #endif // _VIEWER_HXX