src/Main/views.hxx

   1 // views.hxx -- data structures and routines for managing and view parameters.
   2 //
   3 // Written by Curtis Olson, started August 1997.
   4 //
   5 // Copyright (C) 1997  Curtis L. Olson  - curt@infoplane.com
   6 //
   7 // This program is free software; you can redistribute it and/or
   8 // modify it under the terms of the GNU General Public License as
   9 // published by the Free Software Foundation; either version 2 of the
  10 // License, or (at your option) any later version.
  11 //
  12 // This program is distributed in the hope that it will be useful, but
  13 // WITHOUT ANY WARRANTY; without even the implied warranty of
  14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15 // General Public License for more details.
  16 //
  17 // You should have received a copy of the GNU General Public License
  18 // along with this program; if not, write to the Free Software
  19 // Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20 //
  21 // $Id$
  22
  23
  24 #ifndef _VIEWS_HXX
  25 #define _VIEWS_HXX
  26
  27
  28 #ifndef __cplusplus
  29 # error This library requires C++
  30 #endif
  31
  32 #include <Include/compiler.h>
  33
  34 #include <list>
  35
  36 #include <sg.h>                 // plib include
  37
  38 #include <FDM/flight.hxx>
  39 #include <Math/point3d.hxx>
  40 #include <Time/fg_time.hxx>
  41 #include <Time/light.hxx>
  42
  43 #include "options.hxx"
  44
  45 FG_USING_STD(list);
  46
  47
  48 // used in views.cxx and tilemgr.cxx
  49 #define USE_FAST_FOV_CLIP
  50
  51
  52 // Define a structure containing view information
  53 class FGView {
  54
  55 public:
  56
  57     // the current offset from forward for viewing
  58     double view_offset;
  59
  60     // the goal view offset for viewing (used for smooth view changes)
  61     double goal_view_offset;
  62
  63     // flag forcing update of fov related stuff
  64     bool update_fov;
  65
  66     // fov of view is specified in the y direction, win_ratio is used to
  67     // calculate the fov in the X direction = width/height
  68     double win_ratio;
  69
  70     // width & height of window
  71     int winWidth, winHeight;
  72
  73     // sin and cos of (fov / 2) in Y axis
  74     double sin_fov_y, cos_fov_y;
  75     double sinlon, coslon;
  76
  77     // slope of view frustum edge in eye space Y axis
  78     double slope_y;
  79
  80     // sin and cos of (fov / 2) in X axis
  81     double sin_fov_x, cos_fov_x;
  82
  83     // slope of view frustum edge in eye space X axis
  84     double slope_x;
  85
  86 #if defined( USE_FAST_FOV_CLIP )
  87     double fov_x_clip, fov_y_clip;
  88 #endif // USE_FAST_FOV_CLIP
  89
  90     // View frustum cull ratio (% of tiles culled ... used for
  91     // reporting purposes)
  92     double vfc_ratio;
  93
  94     // Number of triangles rendered;
  95     int tris_rendered;
  96     int tris_culled;
  97
  98     // absolute view position
  99     Point3D abs_view_pos;
 100
 101     // view position translated to scenery.center
 102     Point3D view_pos;
 103
 104     // pilot offset from center of gravity.  The X axis is positive
 105     // out the tail, Y is out the right wing, and Z is positive up.
 106     // Distances in meters of course.
 107     sgVec3 pilot_offset;
 108
 109     // cartesion coordinates of current lon/lat if at sea level
 110     // translated to scenery.center
 111     Point3D cur_zero_elev;
 112
 113     // vector in cartesian coordinates from current position to the
 114     // postion on the earth's surface the sun is directly over
 115     sgVec3 to_sun;
 116
 117     // surface direction to go to head towards sun
 118     sgVec3 surface_to_sun;
 119
 120     // vector in cartesian coordinates from current position to the
 121     // postion on the earth's surface the moon is directly over
 122     sgVec3 to_moon;
 123
 124     // surface direction to go to head towards moon
 125     sgVec3 surface_to_moon;
 126
 127     // surface vector heading south
 128     sgVec3 surface_south;
 129
 130     // surface vector heading east (used to unambiguously align sky
 131     // with sun)
 132     sgVec3 surface_east;
 133
 134     // local up vector (normal to the plane tangent to the earth's
 135     // surface at the spot we are directly above
 136     sgVec3 local_up;
 137
 138     // up vector for the view (usually point straight up through the
 139     // top of the aircraft
 140     sgVec3 view_up;
 141
 142     // the vector pointing straight out the nose of the aircraft
 143     sgVec3 view_forward;
 144
 145     // Transformation matrix for eye coordinates to aircraft coordinates
 146     // sgMat4 AIRCRAFT;
 147
 148     // Transformation matrix for the view direction offset relative to
 149     // the AIRCRAFT matrix
 150     sgMat4 VIEW_OFFSET;
 151
 152     // Current model view matrix;
 153     GLfloat MODEL_VIEW[16];
 154
 155     // sg versions of our friendly matrices
 156     sgMat4 LOCAL, UP, VIEW_ROT, TRANS, VIEW, LARC_TO_SSG;
 157
 158 public:
 159
 160     // Constructor
 161     FGView( void );
 162
 163     // Destructor
 164     ~FGView( void );
 165
 166     // Initialize a view class
 167     void Init( void );
 168
 169     // Update the view volume, position, and orientation
 170     void UpdateViewParams( const FGInterface& f );
 171
 172     // Flag to request that UpdateFOV() be called next time
 173     // UpdateViewMath() is run.
 174     inline void force_update_fov_math() { update_fov = true; }
 175
 176     // Update the view parameters
 177     void UpdateViewMath( const FGInterface& f );
 178
 179     // Update the field of view coefficients
 180     void UpdateFOV( const fgOPTIONS& o );
 181
 182     // accessor functions
 183     inline double get_view_offset() const { return view_offset; }
 184     inline void set_view_offset( double a ) { view_offset = a; }
 185     inline void inc_view_offset( double amt ) { view_offset += amt; }
 186     inline double get_goal_view_offset() const { return goal_view_offset; }
 187     inline void set_goal_view_offset( double a) { goal_view_offset = a; }
 188     inline double get_win_ratio() const { return win_ratio; }
 189     inline void set_win_ratio( double r ) { win_ratio = r; }
 190     inline int get_winWidth() const { return winWidth; }
 191     inline void set_winWidth( int w ) { winWidth = w; }
 192     inline int get_winHeight() const { return winHeight; }
 193     inline void set_winHeight( int h ) { winHeight = h; }
 194     inline double get_slope_y() const { return slope_y; }
 195     inline double get_slope_x() const { return slope_x; }
 196 #if defined( USE_FAST_FOV_CLIP )
 197     inline double get_fov_x_clip() const { return fov_x_clip; }
 198     inline double get_fov_y_clip() const { return fov_y_clip; }
 199 #endif // USE_FAST_FOV_CLIP
 200     inline double get_vfc_ratio() const { return vfc_ratio; }
 201     inline void set_vfc_ratio(double r) { vfc_ratio = r; }
 202     inline int get_tris_rendered() const { return tris_rendered; }
 203     inline void set_tris_rendered( int tris) { tris_rendered = tris; }
 204     inline int get_tris_culled() const { return tris_culled; }
 205     inline void set_tris_culled( int tris) { tris_culled = tris; }
 206     inline Point3D get_abs_view_pos() const { return abs_view_pos; }
 207     inline Point3D get_view_pos() const { return view_pos; }
 208     inline float *get_pilot_offset() { return pilot_offset; }
 209     inline void set_pilot_offset( float x, float y, float z ) {
 210         sgSetVec3( pilot_offset, x, y, z );
 211     }
 212     inline Point3D get_cur_zero_elev() const { return cur_zero_elev; }
 213     inline float *get_to_sun() { return to_sun; }
 214     inline void set_to_sun( float x, float y, float z ) {
 215         sgSetVec3( to_sun, x, y, z );
 216     }
 217     inline float *get_surface_to_sun() { return surface_to_sun; }
 218     inline void set_surface_to_sun( float x, float y, float z) {
 219         sgSetVec3( surface_to_sun, x, y, z );
 220     }
 221     inline float *get_to_moon() { return to_moon; }
 222     inline void set_to_moon( float x, float y, float z) {
 223         sgSetVec3( to_moon, x, y, z );
 224     }
 225     inline float *get_surface_to_moon() { return surface_to_moon; }
 226     inline void set_surface_to_moon( float x, float y, float z) {
 227         sgSetVec3( surface_to_moon, x, y, z );
 228     }
 229     inline float *get_surface_south() { return surface_south; }
 230     inline float *get_surface_east() { return surface_east; }
 231     inline float *get_local_up() { return local_up; }
 232     inline float *get_view_forward() { return view_forward; }
 233     inline GLfloat *get_MODEL_VIEW() { return MODEL_VIEW; }
 234 };
 235
 236
 237 extern FGView pilot_view;
 238 extern FGView current_view;
 239
 240
 241 #endif // _VIEWS_HXX
 242
 243