Rigid Bodies Appear More Deterministic in Java Versus C++

[Advay17]

I am working on creating an FRC(FIRST Robotics Competition) library that uses both the Java and C++ bindings of bullet for simulating our robots. When comparing the two simulations, I feel as though the Java bindings are more deterministic in how motion occurs. The plainest example is in stacking sphere objects. When creating a stack of spheres with the same properties in both Java and C++, the C++ stack falls over after a certain number of balls are reached, while the Java stack remains standing. From what I understand, the behaviors should be identical. Is there a reason for this? I can attach videos if necessary

[stephengold]

@Advay17 That's an interesting question.

I don't know the precise reason. There are many possible explanations to consider:

1. There are numerous versions of Bullet and Libbulletjme floating around. Recent releases of Libbulletjme are based on the latest Bullet code from October but have dozens of small changes on top of that.
2. For historical reasons, Libbulletjme has different defaults from Bullet in some cases.
3. Bullet simulation isn't always deterministic. It can vary based on the compiler, compile options, and runtime environment.

Video probably won't help uncover the cause. Someone would need to remove as many causes as possible, then step through the code in a debugger.

[Advay17]

Thanks for the response! I used your C++ version of Bullet for my simulation, so I am pretty confident that that wouldn't be the issue. I am also somewhat(but less so) confident that most compile options are the same, since I am compiling through Gradle using similar tasks for both versions. However, it is possible that I missed a configuration somewhere. As for the defaults, I'm pretty sure the sphere itself was constructed the same in both versions, regardless of different defaults. However, I'll have to do some further analysis. Thanks for the advice!