UserVehicles.h

Go to the documentation of this file.

/*
 * UserVehicles.h
 *
 * Part of Fly! Legacy project
 *
 * Copyright 2003 Chris Wallace
 *
 * Fly! Legacy is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 2 of the License, or
 *   (at your option) any later version.
 *
 * Fly! Legacy is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 *   along with Fly! Legacy; if not, write to the Free Software
 *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */

#ifndef USERVEHICLES_H
#define USERVEHICLES_H

#include "FlyLegacy.h"
#include "Cameras.h"
#include "Panels.h"
#include "Subsystems.h"
#include "Utility.h"

#include <string>
#include <vector>
#include <map>


//
// Simulated Vehicle
//
// The SVH file contains some key information about the aircraft weight/balance
//   simulation behaviour and
//

class CSimulatedVehicle : public CStreamObject {
public:
  CSimulatedVehicle (const char* svhFilename);

  int   Read (SStream *stream, Tag tag);
  void  ReadFinished (void);
  void  Write (SStream *stream);

// Data members
protected:
  Tag       type;
  unsigned int  mxdt;   // Minimum simulation frame rate
  char      acid[64]; // Default tail number
  char      make[64]; // Manufacturer
  char      name[64]; // Aircraft name (for UI menu)
  float     emas;   // Empty mass (slugs)
  SVector     mine;   // Moments of inertia
  SVector     CofG;   // Default center of gravity
  float     imbl;   // Imbalance limit
  float     iceR;   // Ice accumulation rate
  float     wingarea; // Wing area (sq. ft.)
  float     wingspan; // Wing span (ft.)
  float     meanchord;
  float     ceiling;
  float     maxcruisespeed;
  float     approachspeed;
  float     vne;
  float     aoaL;   // Angle of attack limit
  float     stallaoa;
  float     posG;
  float     negG;
  float     stallspeed;
  float     blst;   // Local velocity at tail at full throttle
  float     wTrbSpeed;  // Wing turbulence
  float     wTrbTimK;
  float     wTrbCeiling;
  float     wTrbDuration;
  float     nTrbSpeed;  // ??? turbulence
  float     nTrbTimK;
  float     nTrbCeiling;
  float     nTrbDuration;
  // CTable   pitd;
  // CTable   acrd;
  // CTable   dieh;
  Tag       sfxdTag;
  char      sfxdFilename[64];

  SMessage    mAlt;
  SMessage    mSpd;
  SMessage    mVsi;
  SMessage    mMag;
  SMessage    mRpm;
};


//
// Fuel Systems
//
// The GAS file contains the configuration of fuel tanks, sources, shutoffs,
//   crossfeeds, etc.
//

class CFuelSystem : public CStreamObject {
public:
  CFuelSystem (const char* gasFilename);
  ~CFuelSystem (void);

  int   Read (SStream *stream, Tag tag);
  void  ReadFinished (void);
  void  Write (SStream *stream);

public:
  EAirportFuelTypes             grad;   // Preferred fuel grade
  std::vector<CFuelSubsystem*>  fsub;   // List of CFuelSubsystem* objects
};


//
// Aerodynamic Model
//
// The WNG file contains the aerodynamic flight model for the aircraft.
//
class CAirfoil : public CStreamObject {
public:
  // Constructors / destructor
  CAirfoil (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
  std::string     name;   // Airfoil name
  float           samn;   // Min stall AOA (rad)
  float           samx;   // Max stall AOA (rad)
  CDataMap        *lift;  // Lift coefficient vs. AOA
  CDataMap        *drag;  // Drag coefficient vs. AOA
};


class CWingFlap : public CStreamObject {
public:
  // Constructors / destructor
  CWingFlap (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
  std::string              chan;       // Control channel name
  std::vector<std::string> partVector; // List of affected external model parts
  bool                     nvrt;       // Invert animation keyframes
  CDataMap                 *lift;      // Lift coefficient delta vs. flap angle
  CDataMap                 *drag;      // Drag coefficient delta vs. flap angle
};


class CWingDamage : public CStreamObject {
public:
  // Constructors / destructor
  CWingDamage (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
  float                 perd;         // Repair cycle (hours)
};


class CWingSection : public CStreamObject {
public:
  // Constructors / destructor
  CWingSection (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
  std::string     foil;   // Airfoil name
  float           area;   // Wing area (sq. ft.)
  float           span;   // Wing span (ft.)
  SVector         bPos;   // Aerodynamic center relative to aircraft MAC
  SVector         bAng;   // Incidence angles (deg)
  bool            grnd;   // Ground effect enabled
  float           geff;   // Ground effect factor
  float           gAGL;   // Ground effect altitued (ft)
  float           idcf;   // Ice drag coefficient
  CWingFlap       *flap;  // Flap data
  CWingDamage     *dmge;  // Wing damage data
  float           load;   // Loading damage rate (damage/sec)
};

class CAerodynamicModel : public CStreamObject {
public:
  // Constructors / destructor
  CAerodynamicModel (const char* wngFilename);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

protected:
  SVector                             dofa;     // Vector distance from empty CG to
                                                //    aerodynamic datum (ft)
  bool                                grnd;     // Global ground effect enabled
  float                               geff;     // Global ground effect factor
  float                               gAGL;     // Global ground effect altitude
  float                               cd;       // ???
  std::map<std::string,CAirfoil*>     foilMap;  // Map of airfoil data
  std::map<std::string,CWingSection*> wingMap;  // Map of wing sections
};


//
// Electrical Subsytems
//
// The AMP file contains a vast array of internal aircraft systems, which define
//   the substantial part of the cockpit avionics and flight displays.  There
//   are typically many (up to hundreds for a complex aircraft) instances of
//   CSubsystem descendents in the subs list within this class.
//

class CElectricalSystem : public CStreamObject {
public:
  CElectricalSystem (const char* ampFilename);
  ~CElectricalSystem (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);
  void  ReadFinished (void);
  void  Write (SStream *stream);

  // CElectricalSystem methods
  void  Timeslice (float dT);
  void  Print (FILE *f);

public:
  std::vector<CSubsystem*>    subs;   // List of electrical subsystems

  // Shortcut pointers to special subsystem types
  CAileronControl       *pAileron;
  CElevatorControl      *pElevator;
  CRudderControl        *pRudder;
  CAileronTrimControl   *pAileronTrim;
  CElevatorTrimControl  *pElevatorTrim;
  CRudderTrimControl    *pRudderTrim;
};


//
// Pitot-Static System
//
// The PSS file contains specifications for the system of pitot and static
//   ports on the aircraft.  These special subsystems are used by traditional
//   "steam" gauge subsystems such as altimeters and speed indicators,
//   as well as high-tech air data computers.
//

class CPitotStaticSystem : public CStreamObject {
public:
  CPitotStaticSystem (const char* pssFilename);
  ~CPitotStaticSystem (void);

  int   Read (SStream *stream, Tag tag);
  void  ReadFinished (void);
  void  Write (SStream *stream);

public:
  float                           iceT;   // Icing condition duration
  std::vector<CPitotStaticPort*>  ports;  // List of CPitotStaticPort*
};


//
// Ground Suspension
//
// The WHL file contains the ground handling model parameters.
//

class CGroundSuspension : public CStreamObject {
public:
  CGroundSuspension (const char* whlFilename);

  int   Read (SStream *stream, Tag tag);
  void  ReadFinished (void);
  void  Write (SStream *stream);

public:
};


//
// Loadout Unit
//
// This class represents a single loadout station
//
class CLoadoutUnit : public CStreamObject {
public:
  CLoadoutUnit (void);

  int   Read (SStream *stream, Tag tag);
  void  ReadFinished (void);
  void  Write (SStream *stream);

protected:
  char  name[64];   // Name of loadout position
  SVector bPos;     // Offset from default center of gravity
  float load;     // Default load value, in pounds
  float hiLm;     // Maximum load value, in pounds
  char  utyp[64];   // UI type
};


//
// Variable Loadouts
//
// The VLD file contains variable loadout positions such as aircrew, passenger
//   and cargo spaces which can affect aircraft weight/balance
//

class CVariableLoadouts : public CStreamObject {
public:
  CVariableLoadouts (const char* vldFilename);
  ~CVariableLoadouts (void);

  int   Read (SStream *stream, Tag tag);
  void  ReadFinished (void);
  void  Write (SStream *stream);

protected:
  std::vector<CLoadoutUnit*>  unit;   // List of loadout stations
};


//
// Cockpit Manager
//
// The PIT file contains the cockpit manager, which determines which interior
//   panel views exist for the user vehicle, and how they are linked together
//

class CCockpitManager : public CStreamObject {
public:
  CCockpitManager (const char* pitFilename);
  ~CCockpitManager (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);
  void  ReadFinished ();

  // CCockpitManager methods
  CPanel* GetCurrentPanel (void);
  void  SetPanel (Tag tag);
  Tag   GetPanel (void);
  void  Draw (void);

protected:
  std::map<Tag,CPanel*>  ckpt;   // List of cockpit panels indexed by unique tag

  // Pointer to current CPanel
  CPanel*       pPanel;
};


//
// Camera Manager
//
// CCameraManager links together all of the various static and interactive
//   panel views defined in the CCockpitManager (.PIT file).
//

class CCameraManager : public CStreamObject {
public:
  CCameraManager (const char* whlFilename);
  ~CCameraManager (void);

  // CStreamObject methods
  virtual int   Read (SStream *stream, Tag tag);
  virtual void  ReadFinished (void);

  // CCameraManager
  virtual void    UpdateCamera (SPosition *targetPosition,
                                  SVector *targetOrientation,
                    SPosition *eyePosition,
                    SVector *eyeOrientation,
                    const float dT);
  virtual CCamera*  GetActiveCamera (void);
  virtual void    SelectCamera (Tag id);
  virtual void    NextCamera (void);
  virtual void    PrevCamera (void);
  virtual void    Print (FILE *f);

private:
  void ActivateCamera (void);

protected:
  std::vector<CCamera*>           came;     // List of cameras
  std::vector<CCamera*>::iterator iActive;  // Currently active camera
  Tag                             defaultCamera;  // Tag of default camera

  // Current camera parameters
  SPosition eyePos, tgtPos;
  SVector   eyeOrient, tgtOrient;
  sgVec4    ssgCameraEye;
};


//
// CLevelOfDetail represents an external model that has a number of varyingly-detailed
//   models for the same object.  High-detail models are typically displayed when
//   the object is close up, and lower-detail models when the object is farther away.
//
// An SSG tree is generated as follows:
//  + ssgSelector daynight
//    + ssgSelector day
//      + ssgTransform day1
//        - ssgLeaf...
//      + ssgTransform day2 ...
//        - ssgLeaf...
//      + ssgTransform dayshadow
//        - ssgLeaf...
//    + ssgSelector night
//      + ssgTransform night1
//        - ssgLeaf...
//      + ssgTransform night2 ...
//        - ssgLeaf...
//      + ssgTransform nightshadow
//        - ssgLeaf...


class CLevelOfDetail : public CStreamObject {
public:
  // Constructors / Destructor
  CLevelOfDetail (const char* lodFilename);
  ~CLevelOfDetail (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

  // CLevelOfDetail methods
  ssgEntity *GetSSGEntity (void);

public:
  ssgRoot   *root;    // Root of LOD model
  ssgSelector *daynight;  // Selector for either day or night models
  ssgSelector *day;   // Selector for day models based on LOD
  ssgSelector *night;   // Selector for night models based on LOD

  std::vector<CModelACM*>  modelAcm;     // Daytime models
  CModelACM                *shadowAcm;   // Shadow model
};


//
// Radio Manager
//
class CRadioManager : public CStreamObject {
public:
  CRadioManager (const char* rdoFilename);

  int   Read (SStream *stream, Tag tag);
//  void  ReadFinished (void);
//  void  Write (SStream *stream);

public:
};


//
// External Lights
//
class CExternalLights : public CStreamObject {
public:
  CExternalLights (const char* eltFilename);

  int   Read (SStream *stream, Tag tag);
  void  ReadFinished (void);
  void  Write (SStream *stream);

public:
};


//
// Engine Manager
//
class CEngineManager : public CStreamObject {
public:
  CEngineManager (const char* eltFilename);

  int   Read (SStream *stream, Tag tag);
  void  ReadFinished (void);
  void  Write (SStream *stream);

public:
};


//
// Control Mixer
//
class CControlMixer : public CStreamObject {
public:
  CControlMixer (const char* mixFilename);

  int   Read (SStream *stream, Tag tag);
  void  ReadFinished (void);
  void  Write (SStream *stream);

public:
};


//
// Checklists
//
class CChecklists : public CStreamObject {
public:
  CChecklists (const char* eltFilename);

  int   Read (SStream *stream, Tag tag);
  void  ReadFinished (void);
  void  Write (SStream *stream);

public:
};


//
// Flight Control System
//
// The FCS file contains the specification for the automated flight control
//   system, aka "autopilot".
//
class CFlightControlSystem : public CStreamObject {
public:
  CFlightControlSystem (const char* fcsFilename);

  int   Read (SStream *stream, Tag tag);
  void  ReadFinished (void);
  void  Write (SStream *stream);

public:
};


//
// Slope Wind Data
//
class CSlopeWindData : public CStreamObject {
public:
  CSlopeWindData (const char* swdFilename);

  int   Read (SStream *stream, Tag tag);
  void  ReadFinished (void);
  void  Write (SStream *stream);

public:
};


/*
 * User Vehicles
 */


class CHelicopter : CStreamObject {
public:
  CHelicopter (const char* nfoFilename);

  int   Read (SStream *stream, Tag tag);
  void  ReadFinished (void);
  void  Write (SStream *stream);

protected:
  char  make[64];     // Make/model of aircraft, used as the text for
                              //   aircraft in selection menu
  char  iconFilename[64]; // Filename of PBM file for aircraft select menu
  int   classification;
  int   usage;
  char  svhFilename[64];
  char  gasFilename[64];
  char  wngFilename[64];
  char  ampFilename[64];
  char  pssFilename[64];
  char  whlFilename[64];
  char  vldFilename[64];
  char  pitFilename[64];
  char  camFilename[64];
  char  lodFilename[64];
  char  rdoFilename[64];
  char  eltFilename[64];
  char  engFilename[64];
  char  rtrFilename[64];
  char  mixFilename[64];
  char  cklFilename[64];
  char  fcsFilename[64];
  char  swdFilename[64];
  char  sitFilename[64];
};

#endif // USERVEHICLES_H

Documentation generated by