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

diff --git a/src/Main/viewer.hxx b/src/Main/viewer.hxx
index d0fc616cd..107401a37 100644
--- a/src/Main/viewer.hxx
+++ b/src/Main/viewer.hxx
@@ -31,19 +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>
-
-
-FG_USING_STD(list);
-
 
 #define FG_FOV_MIN 0.1
 #define FG_FOV_MAX 179.9
@@ -52,56 +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;
 
     // geodetic view position
-    Point3D geod_view_pos;
-
-    // radius to sea level from center of the earth (m)
-    double sea_level_radius;
+    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;
-
-    // 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;
+    sgVec3 view_pos;
 
-    // view orientation (heading, pitch, roll)
-    sgVec3 hpr;
+    // 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;
+    sgVec3 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;
+    // height ASL of the terrain for our current view position
+    // (future?) double ground_elev;
 
-    // surface direction to go to head towards sun
-    sgVec3 surface_to_sun;
-
-    // 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;
@@ -110,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;
-
-    // the vector pointing straight out the nose of the aircraft
-    sgVec3 view_forward;
-
-    // Transformation matrix for the view direction offset relative to
-    // the AIRCRAFT matrix
-    sgMat4 VIEW_OFFSET;
+    sgVec3 world_up;
 
     // sg versions of our friendly matrices
-    sgMat4 LOCAL, UP, VIEW_ROT, TRANS, VIEW, LARC_TO_SSG;
+    sgMat4 VIEW, VIEW_ROT, UP;
+
+    inline void set_dirty() { dirty = true; }
+    inline void set_clean() { dirty = false; }
 
     // Update the view volume, position, and orientation
-    void update();
+    virtual void update() = 0;
 
 public:
 
@@ -137,75 +124,86 @@ public:
     FGViewer( void );
 
     // Destructor
-    ~FGViewer( void );
-
-    // Initialize a view class
-    void init( void );
-
-    // Transform a vector from world coordinates to the local plane
-    void CurrentNormalInLocalPlane(sgVec3 dst, sgVec3 src);
+    virtual ~FGViewer( void );
 
     //////////////////////////////////////////////////////////////////////
     // setter functions
     //////////////////////////////////////////////////////////////////////
-    inline void set_geod_view_pos( double lon, double lat, double alt ) {
-	// data should be in radians and meters asl
-	dirty = true;
-	// cout << "set_geod_view_pos = " << lon << ", " << lat << ", " << alt
-	//      << endl;
-	geod_view_pos = Point3D( lon, lat, alt );
-    }
-    inline void set_sea_level_radius( double r ) {
-	// data should be in meters from the center of the earth
-	dirty = true;
-	sea_level_radius = r;
-    }
-    inline void set_hpr( double h, double p, double r ) {
-	// data should be in radians
-	dirty = true;
-	sgSetVec3( hpr, h, p, r );
-    }
-    inline void set_pilot_offset( float x, float y, float z ) {
-	dirty = true;
-	sgSetVec3( pilot_offset, x, y, z );
-    }
+    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 ) {
-	dirty = true;
+	set_dirty();
 	view_offset = a;
     }
     inline void inc_view_offset( double amt ) {
-	dirty = true;
+	set_dirty();
 	view_offset += amt;
     }
     inline void set_goal_view_offset( double a) {
-	dirty = true;
+	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 bool get_reverse_view_offset() const { return reverse_view_offset; }
     inline double get_goal_view_offset() const { return goal_view_offset; }
+    inline double *get_geod_view_pos() { return geod_view_pos; }
     inline float *get_pilot_offset() { return pilot_offset; }
     inline double get_sea_level_radius() const { return sea_level_radius; }
-    inline float *get_hpr() { return hpr; }
 
     //////////////////////////////////////////////////////////////////////
     // derived values accessor functions
     //////////////////////////////////////////////////////////////////////
-    inline Point3D get_abs_view_pos() {
+    inline double *get_abs_view_pos() {
 	if ( dirty ) { update(); }
 	return abs_view_pos;
     }
-    inline Point3D get_view_pos() {
+    inline float *get_view_pos() {
 	if ( dirty ) { update(); }
 	return view_pos;
     }
-    inline Point3D get_cur_zero_elev() {
+    inline float *get_zero_elev() {
 	if ( dirty ) { update(); }
-	return cur_zero_elev;
+	return zero_elev;
     }
+    // (future?)
+    // inline double get_ground_elev() {
+    //  if ( dirty ) { update(); }
+    //	return ground_elev;
+    // }
     inline float *get_surface_south() {
 	if ( dirty ) { update(); }
 	return surface_south;
@@ -214,13 +212,9 @@ public:
 	if ( dirty ) { update(); }
 	return surface_east;
     }
-    inline float *get_local_up() {
+    inline float *get_world_up() {
 	if ( dirty ) { update(); }
-	return local_up;
-    }
-    inline float *get_view_forward() {
-	if ( dirty ) { update(); }
-	return view_forward;
+	return world_up;
     }
     inline const sgVec4 *get_VIEW() {
 	if ( dirty ) { update(); }
@@ -230,25 +224,9 @@ public:
 	if ( dirty ) { update(); }
 	return VIEW_ROT;
     }
-
-    //////////////////////////////////////////////////////////////////////
-    // need to fix these
-    //////////////////////////////////////////////////////////////////////
-    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_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_to_moon() { return to_moon; }
-    inline void set_to_moon( float x, float y, float z) {
-	sgSetVec3( to_moon, x, y, z );
-    }
-    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 const sgVec4 *get_UP() {
+	if ( dirty ) { update(); }
+	return UP;
     }
 };