src/Controls/controls.hxx

   1 // controls.hxx -- defines a standard interface to all flight sim controls
   2 //
   3 // Written by Curtis Olson, started May 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 _CONTROLS_HXX
  25 #define _CONTROLS_HXX
  26
  27 #include <simgear/misc/props.hxx>
  28
  29 #include <Main/fgfs.hxx>
  30 #include <Main/globals.hxx>
  31
  32 #ifndef __cplusplus
  33 # error This library requires C++
  34 #endif
  35
  36
  37 // Define a structure containing the control parameters
  38
  39 class FGControls : public FGSubsystem
  40 {
  41
  42 public:
  43
  44     enum
  45     {
  46         ALL_ENGINES = -1,
  47         MAX_ENGINES = 10
  48     };
  49
  50     enum
  51     {
  52         ALL_WHEELS = -1,
  53         MAX_WHEELS = 3
  54     };
  55
  56 private:
  57
  58     double aileron;
  59     double aileron_trim;
  60     double elevator;
  61     double elevator_trim;
  62     double rudder;
  63     double rudder_trim;
  64     double flaps;
  65     double throttle[MAX_ENGINES];
  66     double mixture[MAX_ENGINES];
  67     double prop_advance[MAX_ENGINES];
  68     double brake[MAX_WHEELS];
  69     int magnetos[MAX_ENGINES];
  70     bool throttle_idle;
  71     bool starter[MAX_ENGINES];
  72     bool gear_down;
  73
  74     SGPropertyNode * auto_coordination;
  75
  76     inline void CLAMP(double *x, double min, double max ) {
  77         if ( *x < min ) { *x = min; }
  78         if ( *x > max ) { *x = max; }
  79     }
  80
  81     inline void CLAMP(int *i, int min, int max ) {
  82         if ( *i < min ) { *i = min; }
  83         if ( *i > max ) { *i = max; }
  84     }
  85
  86 public:
  87
  88     FGControls();
  89     ~FGControls();
  90
  91     // Implementation of FGSubsystem.
  92     void init ();
  93     void bind ();
  94     void unbind ();
  95     void update (int dt);
  96
  97     // Reset function
  98     void reset_all(void);
  99
 100     // Query functions
 101     inline double get_aileron() const { return aileron; }
 102     inline double get_aileron_trim() const { return aileron_trim; }
 103     inline double get_elevator() const { return elevator; }
 104     inline double get_elevator_trim() const { return elevator_trim; }
 105     inline double get_rudder() const { return rudder; }
 106     inline double get_rudder_trim() const { return rudder_trim; }
 107     inline double get_flaps() const { return flaps; }
 108     inline double get_throttle(int engine) const { return throttle[engine]; }
 109     inline double get_mixture(int engine) const { return mixture[engine]; }
 110     inline double get_prop_advance(int engine) const {
 111         return prop_advance[engine];
 112     }
 113     inline double get_brake(int wheel) const { return brake[wheel]; }
 114     inline int get_magnetos(int engine) const { return magnetos[engine]; }
 115     inline bool get_starter(int engine) const { return starter[engine]; }
 116     inline bool get_gear_down() const { return gear_down; }
 117
 118     // Update functions
 119     inline void set_aileron( double pos ) {
 120         aileron = pos;
 121         CLAMP( &aileron, -1.0, 1.0 );
 122
 123         // check for autocoordination
 124         if ( auto_coordination->getBoolValue() )
 125         {
 126             set_rudder( aileron / 2.0 );
 127         }
 128     }
 129     inline void move_aileron( double amt ) {
 130         aileron += amt;
 131         CLAMP( &aileron, -1.0, 1.0 );
 132
 133         // check for autocoordination
 134         if ( auto_coordination->getBoolValue() )
 135         {
 136             set_rudder( aileron / 2.0 );
 137         }
 138     }
 139     inline void set_aileron_trim( double pos ) {
 140         aileron_trim = pos;
 141         CLAMP( &aileron_trim, -1.0, 1.0 );
 142     }
 143     inline void move_aileron_trim( double amt ) {
 144         aileron_trim += amt;
 145         CLAMP( &aileron_trim, -1.0, 1.0 );
 146     }
 147     inline void set_elevator( double pos ) {
 148         elevator = pos;
 149         CLAMP( &elevator, -1.0, 1.0 );
 150     }
 151     inline void move_elevator( double amt ) {
 152         elevator += amt;
 153         CLAMP( &elevator, -1.0, 1.0 );
 154     }
 155     inline void set_elevator_trim( double pos ) {
 156         elevator_trim = pos;
 157         CLAMP( &elevator_trim, -1.0, 1.0 );
 158     }
 159     inline void move_elevator_trim( double amt ) {
 160         elevator_trim += amt;
 161         CLAMP( &elevator_trim, -1.0, 1.0 );
 162     }
 163     inline void set_rudder( double pos ) {
 164         rudder = pos;
 165         CLAMP( &rudder, -1.0, 1.0 );
 166     }
 167     inline void move_rudder( double amt ) {
 168         rudder += amt;
 169         CLAMP( &rudder, -1.0, 1.0 );
 170     }
 171     inline void set_rudder_trim( double pos ) {
 172         rudder_trim = pos;
 173         CLAMP( &rudder_trim, -1.0, 1.0 );
 174     }
 175     inline void move_rudder_trim( double amt ) {
 176         rudder_trim += amt;
 177         CLAMP( &rudder_trim, -1.0, 1.0 );
 178     }
 179     inline void set_flaps( double pos ) {
 180         flaps = pos;
 181         CLAMP( &flaps, 0.0, 1.0 );
 182     }
 183     inline void move_flaps( double amt ) {
 184         flaps += amt;
 185         CLAMP( &flaps, 0.0, 1.0 );
 186     }
 187     inline void set_throttle( int engine, double pos ) {
 188         if ( engine == ALL_ENGINES ) {
 189             for ( int i = 0; i < MAX_ENGINES; i++ ) {
 190                 throttle[i] = pos;
 191                 CLAMP( &throttle[i], 0.0, 1.0 );
 192             }
 193         } else {
 194             if ( (engine >= 0) && (engine < MAX_ENGINES) ) {
 195                 throttle[engine] = pos;
 196                 CLAMP( &throttle[engine], 0.0, 1.0 );
 197             }
 198         }
 199     }
 200     inline void move_throttle( int engine, double amt ) {
 201         if ( engine == ALL_ENGINES ) {
 202             for ( int i = 0; i < MAX_ENGINES; i++ ) {
 203                 throttle[i] += amt;
 204                 CLAMP( &throttle[i], 0.0, 1.0 );
 205             }
 206         } else {
 207             if ( (engine >= 0) && (engine < MAX_ENGINES) ) {
 208                 throttle[engine] += amt;
 209                 CLAMP( &throttle[engine], 0.0, 1.0 );
 210             }
 211         }
 212     }
 213     inline void set_mixture( int engine, double pos ) {
 214         if ( engine == ALL_ENGINES ) {
 215             for ( int i = 0; i < MAX_ENGINES; i++ ) {
 216                 mixture[i] = pos;
 217                 CLAMP( &mixture[i], 0.0, 1.0 );
 218             }
 219         } else {
 220             if ( (engine >= 0) && (engine < MAX_ENGINES) ) {
 221                 mixture[engine] = pos;
 222                 CLAMP( &mixture[engine], 0.0, 1.0 );
 223             }
 224         }
 225     }
 226     inline void move_mixture( int engine, double amt ) {
 227         if ( engine == ALL_ENGINES ) {
 228             for ( int i = 0; i < MAX_ENGINES; i++ ) {
 229                 mixture[i] += amt;
 230                 CLAMP( &mixture[i], 0.0, 1.0 );
 231             }
 232         } else {
 233             if ( (engine >= 0) && (engine < MAX_ENGINES) ) {
 234                 mixture[engine] += amt;
 235                 CLAMP( &mixture[engine], 0.0, 1.0 );
 236             }
 237         }
 238     }
 239     inline void set_prop_advance( int engine, double pos ) {
 240         if ( engine == ALL_ENGINES ) {
 241             for ( int i = 0; i < MAX_ENGINES; i++ ) {
 242                 prop_advance[i] = pos;
 243                 CLAMP( &prop_advance[i], 0.0, 1.0 );
 244             }
 245         } else {
 246             if ( (engine >= 0) && (engine < MAX_ENGINES) ) {
 247                 prop_advance[engine] = pos;
 248                 CLAMP( &prop_advance[engine], 0.0, 1.0 );
 249             }
 250         }
 251     }
 252     inline void move_prop_advance( int engine, double amt ) {
 253         if ( engine == ALL_ENGINES ) {
 254             for ( int i = 0; i < MAX_ENGINES; i++ ) {
 255                 prop_advance[i] += amt;
 256                 CLAMP( &prop_advance[i], 0.0, 1.0 );
 257             }
 258         } else {
 259             if ( (engine >= 0) && (engine < MAX_ENGINES) ) {
 260                 prop_advance[engine] += amt;
 261                 CLAMP( &prop_advance[engine], 0.0, 1.0 );
 262             }
 263         }
 264     }
 265     inline void set_magnetos( int engine, int pos ) {
 266         if ( engine == ALL_ENGINES ) {
 267             for ( int i = 0; i < MAX_ENGINES; i++ ) {
 268                 magnetos[i] = pos;
 269                 CLAMP( &magnetos[i], 0, 3 );
 270             }
 271         } else {
 272             if ( (engine >= 0) && (engine < MAX_ENGINES) ) {
 273                 magnetos[engine] = pos;
 274                 CLAMP( &magnetos[engine], 0, 3 );
 275             }
 276         }
 277     }
 278     inline void move_magnetos( int engine, int amt ) {
 279         if ( engine == ALL_ENGINES ) {
 280             for ( int i = 0; i < MAX_ENGINES; i++ ) {
 281                 magnetos[i] += amt;
 282                 CLAMP( &magnetos[i], 0, 3 );
 283             }
 284         } else {
 285             if ( (engine >= 0) && (engine < MAX_ENGINES) ) {
 286                 magnetos[engine] += amt;
 287                 CLAMP( &magnetos[engine], 0, 3 );
 288             }
 289         }
 290     }
 291     inline void set_starter( int engine, bool flag ) {
 292         if ( engine == ALL_ENGINES ) {
 293             for ( int i = 0; i < MAX_ENGINES; i++ ) {
 294                 starter[i] = flag;
 295             }
 296         } else {
 297             if ( (engine >= 0) && (engine < MAX_ENGINES) ) {
 298                 starter[engine] = flag;
 299             }
 300         }
 301     }
 302     inline void set_brake( int wheel, double pos ) {
 303         if ( wheel == ALL_WHEELS ) {
 304             for ( int i = 0; i < MAX_WHEELS; i++ ) {
 305                 brake[i] = pos;
 306                 CLAMP( &brake[i], 0.0, 1.0 );
 307             }
 308         } else {
 309             if ( (wheel >= 0) && (wheel < MAX_WHEELS) ) {
 310                 brake[wheel] = pos;
 311                 CLAMP( &brake[wheel], 0.0, 1.0 );
 312             }
 313         }
 314     }
 315     inline void move_brake( int wheel, double amt ) {
 316         if ( wheel == ALL_WHEELS ) {
 317             for ( int i = 0; i < MAX_WHEELS; i++ ) {
 318                 brake[i] += amt;
 319                 CLAMP( &brake[i], 0.0, 1.0 );
 320             }
 321         } else {
 322             if ( (wheel >= 0) && (wheel < MAX_WHEELS) ) {
 323                 brake[wheel] += amt;
 324                 CLAMP( &brake[wheel], 0.0, 1.0 );
 325             }
 326         }
 327     }
 328     inline void set_gear_down( bool gear ) { gear_down = gear; }
 329 };
 330
 331
 332 #endif // _CONTROLS_HXX
 333
 334