enum {NumEEGSSegments = 24};   // (Starts one segment away from ownship)
 enum {EEGSTimePerSegment = 200};  // ms.  200 means each segment is 1/5 second long.
 enum {EEGSTimeLength = (NumEEGSSegments) * EEGSTimePerSegment}; // milliseconds
 enum {EEGSUpdateTime = 33};   // Limit how often we can grab new data (ms)
 enum {NumEEGSFrames = EEGSTimeLength / EEGSUpdateTime + 1};

  private:
 VirtualDisplay*      display; // The renderer we are to draw upon
 AircraftClass*       ownship; // Points to the AircraftClass we're riding upon
 FireControlComputer* FCC;  // Points to ownship->FCC.  Repeated here to save one dereference.
 SimObjectType*       targetPtr;
 SimObjectLocalData*  targetData;
 int      curRwy;
 VuEntity*            curAirbase;

 static int  flash;

 void DrawFPM(void);
 void DrawHorizonLine(void);
 void DrawPitchLadder(void);
 void DrawAirspeed(void);
 void DrawAltitude(void);
 void DrawHeading(void);
 void DrawTDBox(void);
 void DrawTDCircle(void);
 void DrawBoresightCross(void);
 void DrawAlphaNumeric(void);
 void DrawILS (void);
 void DrawNav (void);
 void DrawWaypoint(void);
 enum DesignateShape {Circle, Square};
 void DrawDesignateMarker (DesignateShape shape, float az, float el, float dRoll);
 void TimeToSteerpoint(void);
 void RangeToSteerpoint(void);
 void DrawTadpole (void);

 // A-A Missile modes
 void DrawAirMissile (void);
 void DrawDogfight (void);
 void DrawMissileOverride (void);
 void DrawMissileReticle(float radius, int showRange, int showAspect);
 void DrawAim9Diamond(void);
 void DrawAim120Diamond(void);
 void DrawAim9DLZ(void);
 void DrawAim120DLZ(void);
 void DrawAim120ASE(void);
 void CheckBreakX(void);
 void DrawDLZSymbol(float percentRange, char* tmpStr, float rMin, float rMax, float rNeMin, float rNeMax, BOOL aaMode);

 // A-G Missile/Bomb Modes
 void DrawAirGroundGravity(void);
 void DrawTargetingPod(void);
 void DrawGroundMissile (void);
 void DrawHarm (void);
 void DrawCCIP (void);
 void DrawCCRP (void);
 void DrawRCKT (void);
 void DrawDTOSS (void);
 void DrawLADD (void);
 void DrawStrafe(void);
 void DrawHTSDLZ(void);
 void DrawAGMDLZ(void);
 void DrawSteeringToRelease(void);
   void  DrawRPod(void);

 // A-A Gun modes
 void DrawGuns(void);
 void DrawEEGS (void);
 void DrawFunnel (void);
 void DrawMRGS (void);
 void DrawLCOS (void);
 void DrawSnapshot (void);
 void DrawTSymbol (void);
 void FlyBullets(void);

 float lastPipperX, lastPipperY;
 float bulletH[NumEEGSSegments], bulletV[NumEEGSSegments], bulletRange[NumEEGSSegments];
 float funnel1X[NumEEGSSegments], funnel1Y[NumEEGSSegments];
 float funnel2X[NumEEGSSegments], funnel2Y[NumEEGSSegments];

 struct {
  SIM_LONG time;
  float  x;
  float  y;
  float  z;
  float  vx;
  float  vy;
  float  vz;
 } eegsFrameArray[NumEEGSFrames];
 int   eegsFrameNum;
 SIM_LONG lastEEGSstepTime;

 // Time interpolation from sampled EEGS data to the specified time ago
 float EEGShistory( SIM_LONG dt, int *beforeIndex, int *afterIndex );
 float HudClass::EEGSvalueX( float t, int before, int after )
    { return eegsFrameArray[after].x + t * (eegsFrameArray[before].x-eegsFrameArray[after].x); };
 float HudClass::EEGSvalueY( float t, int before, int after )
    { return eegsFrameArray[after].y + t * (eegsFrameArray[before].y-eegsFrameArray[after].y); };
 float HudClass::EEGSvalueZ( float t, int before, int after )
    { return eegsFrameArray[after].z + t * (eegsFrameArray[before].z-eegsFrameArray[after].z); };
 float HudClass::EEGSvalueVX( float t, int before, int after )
    { return eegsFrameArray[after].vx + t * (eegsFrameArray[before].vx-eegsFrameArray[after].vx); };
 float HudClass::EEGSvalueVY( float t, int before, int after )
    { return eegsFrameArray[after].vy + t * (eegsFrameArray[before].vy-eegsFrameArray[after].vy); };
 float HudClass::EEGSvalueVZ( float t, int before, int after )
    { return eegsFrameArray[after].vz + t * (eegsFrameArray[before].vz-eegsFrameArray[after].vz); };
 

 void DrawWindowString (int, char *, int = 0);
 float MRToHudUnits (float mr);
 float RadToHudUnits (float mr);
 float HudUnitsToRad (float mr);
 float maxGs;
 float halfAngle, degreesForScreen;
   float pixelXCenter, pixelYCenter, sightRadius;
   float alphaHudUnits, betaHudUnits;
 

 ScalesSwitch  scalesSwitch;
 FPMSwitch   fpmSwitch;
 DEDSwitch   dedSwitch;
 VelocitySwitch  velocitySwitch;
 RadarSwitch   radarSwitch;
 BrightnessSwitch brightnessSwitch;

 // For HUD coloring
 static const DWORD *hudColor;
 static const int NumHudColors;
 DWORD    curHudColor;
 int     curColorIdx;

  public:
 HudClass(void);
 ~HudClass(void);

 void   SetOwnship (AircraftClass* ownship);
 AircraftClass* Ownship(void) {return ownship;};
 void   SetTarget (SimObjectType* newTarget);
 void   ClearTarget (void);

 void   GetBoresightPos (float*, float*);
 void   SetHalfAngle (float);
 VirtualDisplay* GetDisplay (void) {return privateDisplay;};
 void   Display (VirtualDisplay*);
 void   DisplayInit (ImageBuffer*);

 VuEntity*   CanSeeTarget (int wid, VuEntity* entity, FalconEntity* platform); // Note: This is specific to the RECON pod

 void PushButton (int whichButton, int whichMFD = 0);
 void SetEEGSData (float x, float y, float z,
      float gamma, float sigma,
      float theta, float psi, float vt);

 DWORD GetHudColor(void);
   void  SetHudColor(DWORD);
 void HudColorStep (void);
 void SetLightLevel(void);
 void CalculateBrightness(float, DWORD*);

 int  GetScalesSwitch(void);
 void SetScalesSwitch(ScalesSwitch);
 void CycleScalesSwitch(void);

 int  GetFPMSwitch(void);
 void SetFPMSwitch(FPMSwitch);
 void CycleFPMSwitch(void);

 int  GetDEDSwitch(void);
 void SetDEDSwitch(DEDSwitch);
 void CycleDEDSwitch(void);

 int  GetVelocitySwitch(void);
 void SetVelocitySwitch(VelocitySwitch);
 void CycleVelocitySwitch(void);

 int  GetRadarSwitch(void);
 void SetRadarSwitch(RadarSwitch);
 void CycleRadarSwitch(void);

 int  GetBrightnessSwitch(void);
 void SetBrightnessSwitch(BrightnessSwitch);
 void CycleBrightnessSwitch(void);

 float waypointX, waypointY, waypointZ;
 float waypointAz, waypointEl, waypointSpeed;
 float waypointArrival, waypointBearing, waypointRange;
 int  waypointNum;
 char waypointValid;

 int       dedRepeat;
 float      lowAltWarning;
 enum { High, Low, Off } headingPos;
 int       doPitchLadder;
 HudDataType     HudData;

class HudDataType

 HudDataType (void);

 float tgtAz, tgtEl, tgtAta, tgtDroll;
 float radarAz, radarEl;
 int  tgtId;
 int  flags;
 int  IsSet (int testFlag) { return (flags & testFlag ? TRUE : FALSE); };
 void Set (int testFlag)  { flags |= testFlag; };
 void Clear (int testFlag) { flags &= ~testFlag; };
};