UE5 BUG: The landing gear position will move backward as the airspeed increases

[jijnt12345]

I found that in the UE5 JSBSim plugin, the position of the landing gear moves backward as the aircraft's speed increases during flight. This causes a discrepancy between the landing gear position and the 3D model of the aircraft, leading to significant collision detection errors during takeoff and landing. Could this be a frame rate issue? I noticed that JSBSim runs at a fixed 120 FPS, but the UE plugin corrects this in the Tick function. When the game thread's frame rate drops below 120 FPS,Could this be the direct cause of the issue. it achieves this through frame interpolation rather than using a separate multi-threaded FRunable class to run at 120 FPS

JF17.mp4

void UJSBSimMovementComponent::TickComponent(float DeltaTime, ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction)
{
	Super::TickComponent(DeltaTime, TickType, ThisTickFunction);
	CalculateCarrierVelocity();
	double Start = FPlatformTime::Seconds();

	if (AircraftLoaded)
	{
		if (AircraftState.Crashed)
		{
			// TODO - Send event
			UE_LOG(LogJSBSim, Display, TEXT("Aircraft crashed..."));
		}
		else
		{

      //calculate sim rate to be 120hz independent of game tick rate(Pseudo fixed rate, dev/user needs to set game to a fixed rate too)
      simDtime = 120.f/(1.f / DeltaTime);
      remainder = remainder + fmodf(simDtime,1);
      simloops = truncf(simDtime) + truncf(remainder);
      remainder = fmodf(remainder,1);

      //jsbsim recommends to step sim at 120hz, eg 1/120 = 0.0083..
      Exec->Setdt(0.008333333333333333);

            // Send Commands and State to JSBSim
			CopyToJSBSim();
			
      //step sim x times per game tick
      for (int i = 0; i < simloops; i++)
      {
        Exec->Run();
      }

            // The CG location in the reference frame can vary over time, for instance when tanks get empty... 
            // Theoretically, we should update the local transforms. But maybe it's overkill to do it each frame...
            UpdateLocalTransforms(); 

            // Get the results from JSBSim
			CopyFromJSBSim();

            // Basic debugging string and symbols
			if (DrawDebug)
			{
				DrawDebugMessage();
				DrawDebugObjects();
			}

            // Transform the aircraft coordinates from ECEF Frame to UE Frame, using the georeferencing plugin.
			if (Parent)
			{
				// Computes Rotation in engine frame
				FTransform ENUTransform = GeoReferencingSystem->GetTangentTransformAtECEFLocation(AircraftState.ECEFLocation);
				FRotator LocalUERotation(AircraftState.LocalEulerAngles);
				LocalUERotation.Yaw = LocalUERotation.Yaw - 90.0; // JSBSim heading is aero heading (0 at north). We have to remove 90 because in UE, 0 is pointing east. 
				FQuat EngineRotationQuat = ENUTransform.TransformRotation(LocalUERotation.Quaternion());
				
				FMatrix EngineRotation;
				EngineRotationQuat.ToMatrix(EngineRotation);
				FVector CGOffsetWorld = EngineRotation.TransformPosition(CGLocalPosition);

				// Computes Location in engine frame
				FVector CGWorldPosition;
				GeoReferencingSystem->ECEFToEngine(AircraftState.ECEFLocation, CGWorldPosition);
				FVector EngineLocation = CGWorldPosition - CGOffsetWorld;

                // Update the ForwardHorizontal vector used for the PFD
				AircraftState.UEForwardHorizontal = ENUTransform.TransformVector(ECEFForwardHorizontal);

				// Apply the transform to the Parent actor			
				Parent->SetActorLocationAndRotation(EngineLocation, EngineRotationQuat,false,nullptr,ETeleportType::TeleportPhysics);
			}
		}
	}

    // Get some stats - TODO - Use the UE Stats system
	double End = FPlatformTime::Seconds();
    TickTime = (End - Start) * 1000.0;
}

I would like to move the logic in Tick to run in a separate FRunable thread. Do you have any specific guidance or suggestions on how to do this？

[gallonmate]

I don't see how putting this on a separate thread will change anything regarding the trailing/lagging gear positions. But if you want to easily test this first before you add a separate thread, you can just bypass the fixed rate code and run JSBSim 1:1 with Unreal Tick.
Pasted below is the original plugin code that did run Unreal and JSBSim 1:1. So JBSim would run at whatever your UE frame rate is.
But I don't think the tick rate or difference is the problem. If fixes it, great but I don't think it will. While I haven't looked closer, I just always assumed it's due to order of operations.

	Super::TickComponent(DeltaTime, TickType, ThisTickFunction);

	double Start = FPlatformTime::Seconds();

	if (AircraftLoaded)
	{
		if (AircraftState.Crashed)
		{
			// TODO - Send event
			UE_LOG(LogJSBSim, Display, TEXT("Aircraft crashed..."));
		}
		else
		{
            // TODO - Stepping JSBSim model with a potentially variable step might be a bad idea. 
            // Maybe step the model with a fixed step in another thread
			Exec->Setdt(DeltaTime); 


            // Send Commands and State to JSBSim
			CopyToJSBSim();

            // Step model
			Exec->Run(); 
			
            // The CG location in the reference frame can vary over time, for instance when tanks get empty... 
            // Theoretically, we should update the local transforms. But maybe it's overkill to do it each frame...
            UpdateLocalTransforms(); 

            // Get the results from JSBSim
			CopyFromJSBSim();

[jijnt12345]

This Tick logic has issues and does not work properly.

[gallonmate]

What issues? It's literally copy pasted from the original plugin before the 120hz change:

jsbsim/UnrealEngine/Plugins/JSBSimFlightDynamicsModel/Source/JSBSimFlightDynamicsModel/Private/JSBSimMovementComponent.cpp

Lines 178 to 249 in 57f7974

	void UJSBSimMovementComponent::TickComponent(float DeltaTime, ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction)
	{
	Super::TickComponent(DeltaTime, TickType, ThisTickFunction);
	double Start = FPlatformTime::Seconds();
	if (AircraftLoaded)
	{
	if (AircraftState.Crashed)
	{
	// TODO - Send event
	UE_LOG(LogJSBSim, Display, TEXT("Aircraft crashed..."));
	}
	else
	{
	// TODO - Stepping JSBSim model with a potentially variable step might be a bad idea.
	// Maybe step the model with a fixed step in another thread
	Exec->Setdt(DeltaTime);
	// Send Commands and State to JSBSim
	CopyToJSBSim();
	// Step model
	Exec->Run();
	// The CG location in the reference frame can vary over time, for instance when tanks get empty...
	// Theoretically, we should update the local transforms. But maybe it's overkill to do it each frame...
	UpdateLocalTransforms();
	// Get the results from JSBSim
	CopyFromJSBSim();
	// Basic debugging string and symbols
	if (DrawDebug)
	{
	DrawDebugMessage();
	DrawDebugObjects();
	}
	// Transform the aircraft coordinates from ECEF Frame to UE Frame, using the georeferencing plugin.
	if (Parent)
	{
	// Computes Rotation in engine frame
	FTransform ENUTransform = GeoReferencingSystem->GetTangentTransformAtECEFLocation(AircraftState.ECEFLocation);
	FRotator LocalUERotation(AircraftState.LocalEulerAngles);
	LocalUERotation.Yaw = LocalUERotation.Yaw - 90.0; // JSBSim heading is aero heading (0 at north). We have to remove 90 because in UE, 0 is pointing east.
	FQuat EngineRotationQuat = ENUTransform.TransformRotation(LocalUERotation.Quaternion());
	FMatrix EngineRotation;
	EngineRotationQuat.ToMatrix(EngineRotation);
	FVector CGOffsetWorld = EngineRotation.TransformPosition(CGLocalPosition);
	// Computes Location in engine frame
	FVector CGWorldPosition;
	GeoReferencingSystem->ECEFToEngine(AircraftState.ECEFLocation, CGWorldPosition);
	FVector EngineLocation = CGWorldPosition - CGOffsetWorld;
	// Update the ForwardHorizontal vector used for the PFD
	AircraftState.UEForwardHorizontal = ENUTransform.TransformVector(ECEFForwardHorizontal);
	// Apply the transform to the Parent actor
	Parent->SetActorLocationAndRotation(EngineLocation, EngineRotationQuat);
	}
	}
	}
	// Get some stats - TODO - Use the UE Stats system
	double End = FPlatformTime::Seconds();
	TickTime = (End - Start) * 1000.0;
	}

[gallonmate]

Anyways, I tested the original code where JSBSim and Unreal run together 1:1 each tick and the problem is still there. So the issue is located somewhere else unrelated to tick/frequency.

[seanmcleod]

collision detection errors during takeoff and landing.

You haven't mentioned it explicitly in this discussion, but based on your comments in #1158 (waiting for an answer to my last question there) and CalculateCarrierVelocity(); in your code above it seems as if you're dealing with a moving aircraft carrier.

I think your issue is that you're only updating the carrier's position, velocity etc. at UE5's game frate rate, e.g. 30Hz and not at JSBSim's frame rate of 120Hz.

So you should move the call to CalculateCarrierVelocity(); inside this loop:

      //step sim x times per game tick
      for (int i = 0; i < simloops; i++)
      {
        CalculateCarrierVelocity();
        Exec->Run();
      }

That way, during each iteration of JSBSim's time step when JSBSim calls you back in terms of the ground callback the aircraft carrier's position, velocity etc. will be in sync and not be X frames behind.

[jijnt12345]

It is unrelated to whether it is on an aircraft carrier; the debug position of the landing gear moves backward as the aircraft's speed increases during takeoff on the ground or in-flight, deviating from the original landing gear position.

[seanmcleod]

Even if the offset of the red lines indicating gear position isn't related to the aircraft carrier, my comment still stands in terms of you are going to have discrepancies in terms of ground reactions if the position of the aircraft carrier is updating at the game frame rate, e.g. 30Hz and not at JSBSim's update rate of 120Hz that is being used.

I don't have Unreal installed, so I can't run and double-check things, so just reading the code I wonder if the offset of the red lines relative to the aircraft's 3D model is because the rendering of the gear red lines is done on line 298.

jsbsim/UnrealEngine/Plugins/JSBSimFlightDynamicsModel/Source/JSBSimFlightDynamicsModel/Private/JSBSimMovementComponent.cpp

Line 298 in 8e4803b

DrawDebugObjects();

But the aircraft's position is updated later on line 323.

jsbsim/UnrealEngine/Plugins/JSBSimFlightDynamicsModel/Source/JSBSimFlightDynamicsModel/Private/JSBSimMovementComponent.cpp

Line 323 in 8e4803b

Parent->SetActorLocationAndRotation(EngineLocation, EngineRotationQuat);

So the red gear lines are a rendering of the gear's position before the results of multiple, potentially 90 time-steps if for example the game frame rate is 30Hz versus 120Hz for JSBSim is applied.

jsbsim/UnrealEngine/Plugins/JSBSimFlightDynamicsModel/Source/JSBSimFlightDynamicsModel/Private/JSBSimMovementComponent.cpp

Lines 281 to 285 in 8e4803b

	//step sim x times per game tick
	for (int i = 0; i < simloops; i++)
	{
	Exec->Run();
	}

So the red lines are rendered for an old JSBSim position, the aircraft's position is updated, then UE renders the aircraft's 3D model using the updated position. So the faster the aircraft is moving, the larger the delta you'll see.

Now @gallonmate mentioned:

Anyways, I tested the original code where JSBSim and Unreal run together 1:1 each tick and the problem is still there. So the issue is located somewhere else unrelated to tick/frequency.

However, looking at his 1:1 code above, there is still a difference, albeit of only 1 JSBSim sim frame between the position of the red lines versus the aircraft's latest position. So if my hypothesis is correct @gallonmate would be seeing a much smaller delta between the red lines and the aircraft's 3D model.

So I'd suggest moving the DrawDebug code later so that it executes after Parent->SetActorLocationAndRotation(EngineLocation, EngineRotationQuat); and see if that makes a difference.

[jijnt12345]

Everything is fine now. Thank you very much!

[seanmcleod]

What did you do to make everything fine? Just move the DrawDebug later? If so, then it was simply a draw/visual timing issue in terms of rendering debug info. Which doesn't match with your comment:

leading to significant collision detection errors during takeoff and landing.

Or did you just assume there would be significant collision detection errors based on what you saw with the debug lines being rendered?

Or did you also start updating the aircraft carrier's position at 120Hz in sync with JSBSim instead of only updating it based on the graphic engine's frame rate?

[jijnt12345]

if (Parent)
{
  // Computes Rotation in engine frame
  FTransform ENUTransform = GeoReferencingSystem->GetTangentTransformAtECEFLocation(AircraftState.ECEFLocation);
  FRotator LocalUERotation(AircraftState.LocalEulerAngles);
  LocalUERotation.Yaw = LocalUERotation.Yaw - 90.0; // JSBSim heading is aero heading (0 at north). We have to remove 90 because in UE, 0 is pointing east. 
  FQuat EngineRotationQuat = ENUTransform.TransformRotation(LocalUERotation.Quaternion());
  
  FMatrix EngineRotation;
  EngineRotationQuat.ToMatrix(EngineRotation);
  FVector CGOffsetWorld = EngineRotation.TransformPosition(CGLocalPosition);
  
  // Computes Location in engine frame
  FVector CGWorldPosition;
  GeoReferencingSystem->ECEFToEngine(AircraftState.ECEFLocation, CGWorldPosition);
  FVector EngineLocation = CGWorldPosition - CGOffsetWorld;
  
              // Update the ForwardHorizontal vector used for the PFD
  AircraftState.UEForwardHorizontal = ENUTransform.TransformVector(ECEFForwardHorizontal);
  
  // Apply the transform to the Parent actor			
  Parent->SetActorLocationAndRotation(EngineLocation, EngineRotationQuat,false,nullptr,ETeleportType::TeleportPhysics);
}
	
// Basic debugging string and symbols
if (DrawDebug)
{
  DrawDebugMessage();
  DrawDebugObjects();
}

[seanmcleod]

@jijnt12345 @gallonmate I've submitted a pull request, see - #1161 to render the debug data/lines after the actor's pose has been updated.