JSBSim Unreal Crossplatform support

[demonixis]

Hello,
I'm working on a multiplatform game made with Unreal which uses JSBSim. Today the plugin is only compatible with Windows, I'm working on a PR which will add support for Macos and then later Android and Linux. But JSBSim is not yet compatible with other platforms supported by Unreal. The problem is that it's impossible to compile the plugin on those platform. The best trick to do is to add define blocs and spawn the actor component on supported platform only.

I would like to submit a PR that addresses that problem adding a new JSBSIM_SUPPORTED symbol in the Unreal Plugin. That way the plugin can be compiled on every platforms without any hacks. The downside of the this solution is that it adds many #if JSBSIM_SUPPORTED lines in the plugin.

What do you think? Are you interested by this PR? I already did it in my project. Or is it too specific?

[gallonmate]

I think your work is great for the community and would be appreciated by anyone that wants to support other platforms!
Can you upload it to your Repo so others can take a look at how many #if checks there are? I think it's only a concern if it makes the plugin code hard to read or it makes the plugin harder to maintain throughout the future.

If it seems the changes are hard to read or maintain then I'd suggest just adding a link to your Repo in the official Unreal Plugin Read Me. There also might be other solutions that someone else has to suggest. For example maybe a new folder in this repo with just the plugin/files needed?

Anyways great work!

[demonixis]

Thank you. I'll finish my PR with Macos/Unix support and then upload the code on my fork. I've a very modified version of the plugin on my project, so it can takes some time to get the repo clean and up to date. Every JSBSimXXXX.build.cs contains the following lines at the beginig

bool bSupported = Target.Platform == UnrealTargetPlatform.Win64 ||
		                  Target.Platform == UnrealTargetPlatform.Mac;
		
PublicDefinitions.Add($"JSBSIM_SUPPORTED={(bSupported ? 1 : 0)}");

• JSBSimMovementComponent.h 2 uses
• JSBSimMovementComponent.cpp 25 uses (Every functions are impacted, I think it's possible to reduce a bit this number, but the idea is to not break the API. However it's perfectly possible to mask the unsupported API and use a compilation bloc in the game code instead)
• JSBSimGroundCallback.h 3 uses
• JSBSimGroundCallback.cpp 1 use

The Idea is to keep the API structure to be able to silently use it, even if it's not suported.

Today here is how I handle multplatform

UPROPERTY(BlueprintReadWrite, EditAnywhere, Category="Aircraft|Physics")
UActorComponent* JsbSimComponent;

#if PLATFORM_WINDOWS || PLATFORM_MAC
JsbSimComponent = CreateDefaultSubobject<UJSBSimMovementComponent>(TEXT("JSBSimComponent"));
AddOwnedComponent(JsbSimComponent);
#endif

void AAircraft::UpdateJSBSim(const float DeltaTime)
{
#if PLATFORM_WINDOWS || PLATFORM_MAC
	UJSBSimMovementComponent* JsbSimFdm = Cast<UJSBSimMovementComponent>(JsbSimComponent);

	if (JsbSimFdm == nullptr) return;

	// Update Commands
	FFlightControlCommands& Commands = JsbSimFdm->Commands;
	Commands.Aileron = RollInput;
        // Rest of the code
}

It works, but it's not great because I've to cast at every frame.

[bcoconni]

It works, but it's not great because I've to cast at every frame.

Why can't the cast be done in the class constructor ?

class B;

class A {
#ifdef PLATFORM_WINDOWS
B_w* x;
A(C* _x) {
  x = Cast<B_w>(_x);
}
#else if defined(PLATFORM_MAC)
B_m* x;

A(C* _x) {
  x = Cast<B_m>(_x);
}
#endif

void update(double time) {
  x->method();
}
}

[demonixis]

The problem is that the ActorComponent is declared with a UPROPERTY macro and it is not possible to use preprocessors with Unreal's macro. So this solution is not possible.

[seanmcleod]

But JSBSim is not yet compatible with other platforms supported by Unreal. The problem is that it's impossible to compile the plugin on those platform.

JSBSim is currently built for Mac OSX and Linux so excluding Android it's not a JSBSim issue per se right? It's an issue more specifically in terms of the Unreal plugin?

[demonixis]

Yes it's an issue with the Unreal engine plugin, not JSBSim. That's why I ask if you're OK if I send a PR that fix that.

[seanmcleod]

Yep, just double-checking if there really were any JSBSim specific issues at the moment given your first sentence that "But JSBSim is not yet compatible..."

[gallonmate]

bool bSupported = Target.Platform == UnrealTargetPlatform.Win64 ||
		                  Target.Platform == UnrealTargetPlatform.Mac;
		
PublicDefinitions.Add($"JSBSIM_SUPPORTED={(bSupported ? 1 : 0)}");

JSBSimMovementComponent.cpp 25 uses (Every functions are impacted,

The Idea is to keep the API structure to be able to silently use it, even if it's not supported.

Wait, now I'm confused. Why add all these checks to allow the plugin to compile for platforms that don't even work with the plugin? I don't understand the goal.

What's wrong with just using #if platform check where it's needed to make some function work for that platform, like you originally were doing? Unless a lot of the functions need to be changed for linux and android to work? In which case, it will be interesting to see when you're finished your work!

[demonixis]

The main problem is that you can't just disable the plugin on unsupported platforms. It is not dev friendly to deal with many blocks of code. Many API works like that with a silent call if it's not supported. The FDM integration is not a small thing where you can put one or two #if. It's a deep integration into a projet.

Another solution which can be OK for me, could be to mask functions where it's not supported and only makes the ActorComponent visible.

[gallonmate]

Yes but I'm confused why you are packaging a game with the plugin for unsupported platforms in the first place.

[demonixis]

If you're using JSBSim in a blueprint project only it's fine, you can safely disable the plugin to build on other non supported platform.
If you're using JSBSim in a C++ project and reference a the MovementComponent using a UPROPERTY macro, which is required. You can't add preprocessor because it is not allowed by Unreal.

For instance you've an Aircraft class

UPROPERTY()
JSBSimMovementComponent* JsbSimComponent;

You are not allowed to write

#if PLATFORM_WINDOWS
UPROPERTY()
JSBSimMovementComponent* JsbSimComponent;
#endif

That means today, the Unreal plugin is Windows Only and forces you to compile only on Windows if you use the plugin from C++.

[gallonmate]

I'm still confused.

"You can safely disable the plugin to build on other non supported platform."

Why would you want to keep the plugin in the project if you're trying to disable it anyways?

[demonixis]

All right.. To be clear

• The UE plugin can ONLY be built on Windows
• IF you try to build on another platform, the compilation fails, because the plugin is not supported

So yes, you can disable the plugin to compile on other platform. It is fine if you deal with Blueprint (but it can brake what you did).

If you use a C++ project and use the plugin into your C++ project, you can't use preprocessor to only compile some of your work for the supported platform. UPROPERTY can't be placed between preprocessor.

You're free to use preprocessor into the .cpp, but it's impossible to use it in the header if the object uses the UPROPERTY macro, which is the case of JSBSimMovementComponent.

That means you can't disable the plugin to build on another platform.

Why would you build your project with JSBSim on a non supported platform? Because my project have two FDM, JSBSim on supported platform and a custom one for everything else.

Finally why is it fine to expose the JSBSimMovementComponent to every platform, even if the internal API is silent? Because that way we can continue to use UPROPERTY, keep the plugin, which will only have the Editor/Runtime parts to be built and not JSBSim.

I hope you're no more confused.
Best,