internal TerrainHeightCalculator(
TerrainDB terrainDB,
IColumnAndRowElevationPostRecordRetriever columnAndRowElevationPostRecordRetriever = null,
IDistanceBetweenElevationPostsCalculator distanceBetweenElevationPostsCalculator = null,
INearestElevationPostColumnAndRowCalculator nearestElevationPostColumnAndRowCalculator = null)
{
_terrainDB = terrainDB;
_columnAndRowElevationPostRecordRetriever = columnAndRowElevationPostRecordRetriever ?? new ColumnAndRowElevationPostRecordRetriever(_terrainDB);
_distanceBetweenElevationPostsCalculator = distanceBetweenElevationPostsCalculator ?? new DistanceBetweenElevationPostsCalculator(_terrainDB);
_nearestElevationPostColumnAndRowCalculator = nearestElevationPostColumnAndRowCalculator ?? new NearestElevationPostColumnAndRowCalculator(_terrainDB);
}
private void EnsureTerrainIsLoaded()
{
if (_terrainDB == null)
{
_terrainDB = _terrainDBFactory.Create(false);
if (_terrainDB != null)
{
_theaterMapRetriever = new TheaterMapRetriever(_terrainDB, Manager.Client);
PublishTheaterMapForClients();
}
}
}
public MovingMap(
TerrainDB terrainDB,
IF16CPDClient client,
ITheaterMapRetriever theaterMapRetriever = null,
IMapRingRenderer mapRingRenderer = null,
ICenterAirplaneRenderer centerAirplaneRenderer = null
)
{
_mapRingRenderer = mapRingRenderer ?? new MapRingRenderer();
_centerAirplaneRenderer = centerAirplaneRenderer ?? new CenterAirplaneRenderer();
_theaterMapRetriever = theaterMapRetriever ?? new TheaterMapRetriever(terrainDB, client);
}
private void ExecuteOneCycle(int pollingDelay)
{
var thisLoopStartTime = DateTime.UtcNow;
Application.DoEvents();
ProcessNetworkMessages();
if (State.SimRunning || State.OptionsFormIsShowing || State.NetworkMode == NetworkMode.Client)
{
var currentFlightData = _flightDataRetriever.GetFlightData();
SetFlightData(currentFlightData);
if (_terrainDB == null && State.NetworkMode != NetworkMode.Client)
{
string bmsBaseDir = currentFlightData.StringData.data.Where(x => (x.strId == (uint)StringIdentifier.BmsBasedir)).First().value;
_terrainDB = _terrainDBFactory.Create(bmsBaseDir, false);
}
_flightDataUpdater.UpdateRendererStatesFromFlightData(_instruments, currentFlightData, _terrainDB,
_ehsiStateTracker.UpdateEHSIBrightnessLabelVisibility, _texSmReader);
}
else
{
var flightDataToSet = new FlightData {
hsiBits = int.MaxValue
};
SetFlightData(flightDataToSet);
_flightDataUpdater.UpdateRendererStatesFromFlightData(_instruments, flightDataToSet, _terrainDB,
_ehsiStateTracker.UpdateEHSIBrightnessLabelVisibility, _texSmReader);
}
Parallel.ForEach(_instruments.Values, x => x.Render());
Application.DoEvents();
var thisLoopFinishTime = DateTime.UtcNow;
var timeElapsed = thisLoopFinishTime.Subtract(thisLoopStartTime);
var millisToSleep = pollingDelay - (int)timeElapsed.TotalMilliseconds;
if (millisToSleep < 5)
{
millisToSleep = 5;
}
if (!State.SimRunning && State.NetworkMode != NetworkMode.Client && !State.OptionsFormIsShowing)
{
millisToSleep += 50;
}
Thread.Sleep(millisToSleep);
}
public float ComputeRadarAltitude(FlightData flightData, TerrainDB terrainDB, uint lod = 2)
{
var terrainHeight = terrainDB?.CalculateTerrainHeight(flightData.x, flightData.y, lod) ?? 0;
var ralt = -flightData.z - terrainHeight;
//reset AGL altitude to zero if we're on the ground
if (WeightOnWheels(flightData) || OnGround(flightData))
{
ralt = 0;
}
if (ralt < 0)
{
ralt = 0;
}
return(ralt);
}
private void Dispose(bool disposing)
{
if (!_isDisposed)
{
if (disposing)
{
//dispose of managed resources here
Common.Util.DisposeObject(_keyFile);
_keyFile = null;
Common.Util.DisposeObject(_sharedMemReader);
_sharedMemReader = null;
Common.Util.DisposeObject(_texSharedMemReader);
_texSharedMemReader = null;
Common.Util.DisposeObject(_pendingComboKeys);
_pendingComboKeys = null;
Common.Util.DisposeObject(_terrainDB);
_terrainDB = null;
}
}
// Code to dispose the un-managed resources of the class
_isDisposed = true;
}
private void EnsureTerrainIsLoaded()
{
if (_terrainDB == null)
{
var curFlightData = ReadF4SharedMem();
if (curFlightData == null)
{
return;
}
string bmsBaseDir = curFlightData.StringData.data.Where(x => (x.strId == (uint)StringIdentifier.BmsBasedir)).First().value;
if (string.IsNullOrEmpty(bmsBaseDir))
{
return;
}
_terrainDB = _terrainDBFactory.Create(bmsBaseDir, false);
if (_terrainDB != null)
{
_theaterMapRetriever = new TheaterMapRetriever(_terrainDB, Manager.Client);
PublishTheaterMapForClients();
}
}
}
public void UpdateRendererStatesFromFlightData(
IDictionary <InstrumentType, IInstrument> instruments,
FlightData flightData,
TerrainDB terrainDB,
Action updateEHSIBrightnessLabelVisibility,
F4TexSharedMem.IReader texSharedmemReader)
{
if (flightData == null || (Extractor.State.NetworkMode != NetworkMode.Client && !Extractor.State.SimRunning))
{
flightData = new FlightData {
hsiBits = Int32.MaxValue
};
}
var hsi = instruments[InstrumentType.HSI].Renderer as IHorizontalSituationIndicator;
var ehsi = instruments[InstrumentType.EHSI].Renderer as IEHSI;
var adi = instruments[InstrumentType.ADI].Renderer as IADI;
var isis = instruments[InstrumentType.ISIS].Renderer as IISIS;
if (Extractor.State.SimRunning || Extractor.State.NetworkMode == NetworkMode.Client || Extractor.State.OptionsFormIsShowing)
{
var hsibits = ((HsiBits)flightData.hsiBits);
if (Extractor.State.NetworkMode != NetworkMode.Client)
{
var altitudeAgl = _radarAltitudeCalculator.ComputeRadarAltitude(flightData, terrainDB);
if (flightData.ExtensionData == null)
{
flightData.ExtensionData = new FlightDataExtensionData();
}
(flightData.ExtensionData as FlightDataExtensionData).AltitudeAGL = altitudeAgl;
}
_flightDataAdapterSet.ISIS.Adapt(instruments[InstrumentType.ISIS].Renderer as IISIS, flightData);
_flightDataAdapterSet.VVI.Adapt(instruments[InstrumentType.VVI].Renderer as IVerticalVelocityIndicator, flightData);
_flightDataAdapterSet.Altimeter.Adapt(instruments[InstrumentType.Altimeter].Renderer as IAltimeter, flightData);
_flightDataAdapterSet.AirspeedIndicator.Adapt(instruments[InstrumentType.ASI].Renderer as IAirspeedIndicator, flightData);
_flightDataAdapterSet.Compass.Adapt(instruments[InstrumentType.Compass].Renderer as ICompass, flightData);
_flightDataAdapterSet.AOAIndicator.Adapt(instruments[InstrumentType.AOAIndicator].Renderer as IAngleOfAttackIndicator, flightData);
_flightDataAdapterSet.AOAIndexer.Adapt(instruments[InstrumentType.AOAIndexer].Renderer as IAngleOfAttackIndexer, flightData);
UpdateADI(instruments[InstrumentType.ADI].Renderer as IADI, hsibits);
_flightDataAdapterSet.StandbyADI.Adapt(instruments[InstrumentType.BackupADI].Renderer as IStandbyADI, flightData);
UpdateHSI(instruments[InstrumentType.HSI].Renderer as IHorizontalSituationIndicator, instruments[InstrumentType.EHSI].Renderer as IEHSI, hsibits, flightData);
//***** UPDATE SOME COMPLEX HSI/ADI VARIABLES
if (ADIIsTurnedOff(hsibits))
{
SetADIToOffState(instruments[InstrumentType.ADI].Renderer as IADI);
SetISISToOffState(instruments[InstrumentType.ISIS].Renderer as IISIS);
}
else
{
SetADIPitchAndRoll(instruments[InstrumentType.ADI].Renderer as IADI, flightData);
SetISISPitchAndRoll(instruments[InstrumentType.ISIS].Renderer as IISIS, flightData);
//The following floating data is also crossed up in the flightData.h File:
//float AdiIlsHorPos; // Position of horizontal ILS bar ----Vertical
//float AdiIlsVerPos; // Position of vertical ILS bar-----horizontal
var commandBarsOn = ((float)(Math.Abs(Math.Round(flightData.AdiIlsHorPos, 4))) != 0.1745f);
if ((Math.Abs((flightData.AdiIlsVerPos / Common.Math.Constants.RADIANS_PER_DEGREE)) > 1.0f)
||
(Math.Abs((flightData.AdiIlsHorPos / Common.Math.Constants.RADIANS_PER_DEGREE)) > 5.0f))
{
commandBarsOn = false;
}
hsi.InstrumentState.ShowToFromFlag = true;
ehsi.InstrumentState.ShowToFromFlag = true;
//if the TOTALFLAGS flag is off, then we're most likely in NAV mode
if ((hsibits & HsiBits.TotalFlags) != HsiBits.TotalFlags)
{
hsi.InstrumentState.ShowToFromFlag = false;
ehsi.InstrumentState.ShowToFromFlag = false;
}
//if the TO/FROM flag is showing in shared memory, then we are most likely in TACAN mode
else if ((((hsibits & HsiBits.ToTrue) == HsiBits.ToTrue)
||
((hsibits & HsiBits.FromTrue) == HsiBits.FromTrue)))
{
if (!commandBarsOn) //better make sure we're not in any ILS mode too though
{
hsi.InstrumentState.ShowToFromFlag = true;
ehsi.InstrumentState.ShowToFromFlag = true;
}
}
//if the glideslope or localizer flags on the ADI are turned on, then we must be in an ILS mode and therefore we
//know we don't need to show the HSI TO/FROM flags.
if (((hsibits & HsiBits.ADI_GS) == HsiBits.ADI_GS)
||
((hsibits & HsiBits.ADI_LOC) == HsiBits.ADI_LOC))
{
hsi.InstrumentState.ShowToFromFlag = false;
ehsi.InstrumentState.ShowToFromFlag = false;
}
if (commandBarsOn)
{
hsi.InstrumentState.ShowToFromFlag = false;
ehsi.InstrumentState.ShowToFromFlag = false;
}
adi.InstrumentState.ShowCommandBars = commandBarsOn;
adi.InstrumentState.GlideslopeDeviationDegrees = flightData.AdiIlsVerPos / Common.Math.Constants.RADIANS_PER_DEGREE;
adi.InstrumentState.LocalizerDeviationDegrees = flightData.AdiIlsHorPos / Common.Math.Constants.RADIANS_PER_DEGREE;
isis.InstrumentState.ShowCommandBars = commandBarsOn;
isis.InstrumentState.GlideslopeDeviationDegrees = flightData.AdiIlsVerPos / Common.Math.Constants.RADIANS_PER_DEGREE;
isis.InstrumentState.LocalizerDeviationDegrees = flightData.AdiIlsHorPos / Common.Math.Constants.RADIANS_PER_DEGREE;
}
UpdateNavigationMode(hsi, ehsi, adi, isis, flightData);
if (((hsibits & HsiBits.HSI_OFF) == HsiBits.HSI_OFF))
{
TurnOffHSI(hsi);
TurnOffEHSI(ehsi);
}
else
{
UpdateHSIFlightData(hsi, flightData, hsibits);
UpdateEHSIFlightData(ehsi, flightData, hsibits);
}
UpdateHSIAndEHSICourseDeviationAndToFromFlags(hsi, ehsi);
UpdateEHSI(updateEHSIBrightnessLabelVisibility);
_flightDataAdapterSet.HYDA.Adapt(instruments[InstrumentType.HYDA].Renderer as IHydraulicPressureGauge, flightData);
_flightDataAdapterSet.HYDB.Adapt(instruments[InstrumentType.HYDB].Renderer as IHydraulicPressureGauge, flightData);
_flightDataAdapterSet.CabinPress.Adapt(instruments[InstrumentType.CabinPress].Renderer as ICabinPressureAltitudeIndicator, flightData);
_flightDataAdapterSet.RollTrim.Adapt(instruments[InstrumentType.RollTrim].Renderer as IRollTrimIndicator, flightData);
_flightDataAdapterSet.PitchTrim.Adapt(instruments[InstrumentType.PitchTrim].Renderer as IPitchTrimIndicator, flightData);
_flightDataAdapterSet.AzimuthIndicator.Adapt(instruments[InstrumentType.AzimuthIndicator].Renderer as IAzimuthIndicator, flightData);
_flightDataAdapterSet.RWR.Adapt(instruments[InstrumentType.RWR].Renderer as IRWRRenderer, flightData);
_flightDataAdapterSet.CautionPanel.Adapt(instruments[InstrumentType.CautionPanel].Renderer as ICautionPanel, flightData);
_flightDataAdapterSet.CMDS.Adapt(instruments[InstrumentType.CMDS].Renderer as ICMDSPanel, flightData);
_flightDataAdapterSet.DED.Adapt(instruments[InstrumentType.DED].Renderer as IDataEntryDisplayPilotFaultList, flightData);
_flightDataAdapterSet.PFL.Adapt(instruments[InstrumentType.PFL].Renderer as IDataEntryDisplayPilotFaultList, flightData);
_flightDataAdapterSet.EPUFuel.Adapt(instruments[InstrumentType.EPUFuel].Renderer as IEPUFuelGauge, flightData);
_flightDataAdapterSet.FuelFlow.Adapt(instruments[InstrumentType.FuelFlow].Renderer as IFuelFlow, flightData);
_flightDataAdapterSet.FuelQuantity.Adapt(instruments[InstrumentType.FuelQuantity].Renderer as IFuelQuantityIndicator, flightData);
_flightDataAdapterSet.LandingGearLights.Adapt(instruments[InstrumentType.GearLights].Renderer as ILandingGearWheelsLights, flightData);
_flightDataAdapterSet.NWS.Adapt(instruments[InstrumentType.NWSIndexer].Renderer as INosewheelSteeringIndexer, flightData);
_flightDataAdapterSet.Speedbrake.Adapt(instruments[InstrumentType.Speedbrake].Renderer as ISpeedbrakeIndicator, flightData);
_flightDataAdapterSet.RPM1.Adapt(instruments[InstrumentType.RPM1].Renderer as ITachometer, flightData);
_flightDataAdapterSet.RPM2.Adapt(instruments[InstrumentType.RPM2].Renderer as ITachometer, flightData);
_flightDataAdapterSet.FTIT1.Adapt(instruments[InstrumentType.FTIT1].Renderer as IFanTurbineInletTemperature, flightData);
_flightDataAdapterSet.FTIT2.Adapt(instruments[InstrumentType.FTIT2].Renderer as IFanTurbineInletTemperature, flightData);
_flightDataAdapterSet.NOZ1.Adapt(instruments[InstrumentType.NOZ1].Renderer as INozzlePositionIndicator, flightData);
_flightDataAdapterSet.NOZ2.Adapt(instruments[InstrumentType.NOZ2].Renderer as INozzlePositionIndicator, flightData);
_flightDataAdapterSet.OIL1.Adapt(instruments[InstrumentType.OIL1].Renderer as IOilPressureGauge, flightData);
_flightDataAdapterSet.OIL2.Adapt(instruments[InstrumentType.OIL2].Renderer as IOilPressureGauge, flightData);
_flightDataAdapterSet.Accelerometer.Adapt(instruments[InstrumentType.Accelerometer].Renderer as IAccelerometer, flightData);
}
else //Falcon's not running
{
if (instruments[InstrumentType.VVI].Renderer is IVerticalVelocityIndicatorEU)
{
((IVerticalVelocityIndicatorEU)instruments[InstrumentType.VVI].Renderer).InstrumentState.OffFlag = true;
}
else if (instruments[InstrumentType.VVI].Renderer is IVerticalVelocityIndicatorUSA)
{
((IVerticalVelocityIndicatorUSA)instruments[InstrumentType.VVI].Renderer).InstrumentState.OffFlag = true;
}
((IAngleOfAttackIndicator)(instruments[InstrumentType.AOAIndicator].Renderer)).InstrumentState.OffFlag = true;
hsi.InstrumentState.OffFlag = true;
ehsi.InstrumentState.NoDataFlag = true;
((IADI)instruments[InstrumentType.ADI].Renderer).InstrumentState.OffFlag = true;
((IStandbyADI)instruments[InstrumentType.BackupADI].Renderer).InstrumentState.OffFlag = true;
((IAzimuthIndicator)instruments[InstrumentType.AzimuthIndicator].Renderer).InstrumentState.RWRPowerOn = false;
((IISIS)instruments[InstrumentType.ISIS].Renderer).InstrumentState.RadarAltitudeAGL = 0;
((IISIS)instruments[InstrumentType.ISIS].Renderer).InstrumentState.OffFlag = true;
updateEHSIBrightnessLabelVisibility();
}
_flightDataAdapterSet.LMFD.Adapt(instruments[InstrumentType.LMFD], texSharedmemReader, _textureTexturesSharedMemoryImageCoordinates.LMFD, InstrumentType.LMFD);
_flightDataAdapterSet.RMFD.Adapt(instruments[InstrumentType.RMFD], texSharedmemReader, _textureTexturesSharedMemoryImageCoordinates.RMFD, InstrumentType.RMFD);
_flightDataAdapterSet.MFD3.Adapt(instruments[InstrumentType.MFD3], texSharedmemReader, _textureTexturesSharedMemoryImageCoordinates.MFD3, InstrumentType.MFD3);
_flightDataAdapterSet.MFD4.Adapt(instruments[InstrumentType.MFD4], texSharedmemReader, _textureTexturesSharedMemoryImageCoordinates.MFD4, InstrumentType.MFD4);
_flightDataAdapterSet.HUD.Adapt(instruments[InstrumentType.HUD], texSharedmemReader, _textureTexturesSharedMemoryImageCoordinates.HUD, InstrumentType.HUD);
}
public TheaterMapRetriever(TerrainDB terrainDB, IF16CPDClient client, IResourceBundleReader resourceBundleReader = null)
{
_terrainDB = terrainDB;
_client = client;
_resourceBundleReader = resourceBundleReader ?? new ResourceBundleReader();
}
public DistanceBetweenElevationPostsCalculator(TerrainDB terrainDB)
{
_terrainDB = terrainDB;
}
public void UpdateManagerFlightData()
{
GetNextMorseCodeUnit();
if (Settings.Default.RunAsClient)
{
PerformClientSideFlightDataUpdates();
return;
}
FlightData flightData = Manager.FlightData;
string exePath = F4Utils.Process.Util.GetFalconExePath();
CreateSharedMemReaderIfNotExists();
F4SharedMem.FlightData fromFalcon = ReadF4SharedMem();
if (_keyFile == null)
{
LoadCurrentKeyFile();
}
EnsureTerrainIsLoaded();
if (exePath != null && ((_sharedMemReader != null && _sharedMemReader.IsFalconRunning)))
{
IsSimRunning = true;
if (fromFalcon == null)
{
fromFalcon = new F4SharedMem.FlightData();
}
var hsibits = ((HsiBits)fromFalcon.hsiBits);
flightData.VviOffFlag = ((hsibits & HsiBits.VVI) == HsiBits.VVI);
flightData.AoaOffFlag = ((hsibits & HsiBits.AOA) == HsiBits.AOA);
flightData.HsiOffFlag = ((hsibits & HsiBits.HSI_OFF) == HsiBits.HSI_OFF);
flightData.AdiOffFlag = ((hsibits & HsiBits.ADI_OFF) == HsiBits.ADI_OFF);
flightData.PfdOffFlag = false;
UpdateCpdPowerState(flightData, fromFalcon);
flightData.RadarAltimeterOffFlag = ((fromFalcon.lightBits & (int)LightBits.RadarAlt) ==
(int)LightBits.RadarAlt);
flightData.BarometricPressure = (fromFalcon.AltCalReading / 100.00f);
flightData.AltimeterUnits = (((AltBits)fromFalcon.altBits & AltBits.CalType) == AltBits.CalType) ? AltimeterUnits.Hg : AltimeterUnits.hPa;
flightData.AltimeterMode = (((AltBits)fromFalcon.altBits & AltBits.PneuFlag) == AltBits.PneuFlag) ? AltimeterMode.Pneumatic : AltimeterMode.Electronic;
switch (fromFalcon.navMode)
{
case (byte)F4SharedMem.Headers.NavModes.ILS_NAV:
flightData.NavMode = NavModes.IlsNav;
break;
case (byte)F4SharedMem.Headers.NavModes.ILS_TACAN:
flightData.NavMode = NavModes.IlsTcn;
break;
case (byte)F4SharedMem.Headers.NavModes.TACAN:
flightData.NavMode = NavModes.Tcn;
break;
case (byte)F4SharedMem.Headers.NavModes.NAV:
flightData.NavMode = NavModes.Nav;
break;
}
UpdateIndicatedAltitude(flightData, fromFalcon);
UpdateAltitudeAGL(flightData, fromFalcon);
UpdateIndicatedAirspeed(flightData, fromFalcon);
UpdateALOW(flightData, fromFalcon);
flightData.TrueAirspeedInDecimalFeetPerSecond = fromFalcon.vt;
flightData.MachNumber = fromFalcon.mach;
flightData.GroundSpeedInDecimalFeetPerSecond =
(float)Math.Sqrt((fromFalcon.xDot * fromFalcon.xDot) + (fromFalcon.yDot * fromFalcon.yDot));
flightData.MagneticHeadingInDecimalDegrees = (360 +
(fromFalcon.yaw / Common.Math.Constants.RADIANS_PER_DEGREE)) %
360;
UpdateVerticalVelocity(flightData, fromFalcon, hsibits);
flightData.AngleOfAttackInDegrees = ((hsibits & HsiBits.AOA) == HsiBits.AOA) ? 0 : fromFalcon.alpha;
flightData.AdiAuxFlag = ((hsibits & HsiBits.ADI_AUX) == HsiBits.ADI_AUX);
flightData.AdiGlideslopeInvalidFlag = ((hsibits & HsiBits.ADI_GS) == HsiBits.ADI_GS);
flightData.AdiLocalizerInvalidFlag = ((hsibits & HsiBits.ADI_LOC) == HsiBits.ADI_LOC);
UpdateMarkerBeaconLight(flightData, fromFalcon);
if (((hsibits & HsiBits.ADI_OFF) == HsiBits.ADI_OFF))
{
TurnOffADI(flightData);
}
else
{
flightData.PitchAngleInDecimalDegrees = ((fromFalcon.pitch / Common.Math.Constants.RADIANS_PER_DEGREE));
flightData.RollAngleInDecimalDegrees = fromFalcon.roll / Common.Math.Constants.RADIANS_PER_DEGREE;
flightData.BetaAngleInDecimalDegrees = fromFalcon.beta;
flightData.GammaAngleInDecimalDegrees = fromFalcon.gamma / Common.Math.Constants.RADIANS_PER_DEGREE;
flightData.WindOffsetToFlightPathMarkerInDecimalDegrees = fromFalcon.windOffset /
Common.Math.Constants.RADIANS_PER_DEGREE;
flightData.AdiIlsGlideslopeDeviationInDecimalDegrees = fromFalcon.AdiIlsVerPos /
Common.Math.Constants.RADIANS_PER_DEGREE;
flightData.AdiIlsLocalizerDeviationInDecimalDegrees = fromFalcon.AdiIlsHorPos /
Common.Math.Constants.RADIANS_PER_DEGREE;
UpdateHSIToFromFlagVisibilityAndADICommandBarsVisibilityBasedOnBMS4NavMode(flightData, fromFalcon);
}
UpdateHSIData(flightData, fromFalcon, hsibits);
flightData.RateOfTurnInDecimalDegreesPerSecond = _indicatedRateOfTurnCalculator.DetermineIndicatedRateOfTurn(flightData.MagneticHeadingInDecimalDegrees);
UpdateTACANChannel(flightData, fromFalcon);
UpdateMapPosition(flightData, fromFalcon);
flightData.LMFDImage = GetLMFDImage();
flightData.RMFDImage = GetRMFDImage();
}
else //Falcon's not running
{
IsSimRunning = false;
if (Settings.Default.ShutoffIfFalconNotRunning)
{
TurnOffAllInstruments(flightData);
}
if (_sharedMemReader != null)
{
Common.Util.DisposeObject(_sharedMemReader);
_sharedMemReader = null;
}
if (_texSharedMemReader != null)
{
Common.Util.DisposeObject(_texSharedMemReader);
_texSharedMemReader = null;
}
Common.Util.DisposeObject(_keyFile);
Common.Util.DisposeObject(_terrainDB);
_keyFile = null;
_terrainDB = null;
}
//if running in server mode, send updated flight data to client
if (Settings.Default.RunAsServer)
{
F16CPDServer.SetSimProperty("F4FlightData", Common.Serialization.Util.ToRawBytes(flightData));
}
}
public ElevationPostCoordinateClamper(TerrainDB terrainDB)
{
_terrainDB = terrainDB;
}
