Performance Optimization Of BepuPhysics in Unity(Ios/Android)

[TalhaEjaz03]

Hi Norbo,
We are using Bepu Physics engine V1 (with Fixed Point Math) for our game in UNITY3D. It is a simple freefall physics based simulation using the default values of the engine for the game(using 0.1 value as timestep & 2 as max timestep). We have achieved and tested complete deterministic results on all three platforms (windows, IOS, Android).

The issues are that we are encountering performance issues on phones, barely holding 30 fps on mid range devices(4gb Ram, octa core processors) and lot of jerking during restarts.
Our scene mostly includes different compound bodies(around 13 in current scene) interacting with each other(bouncing, colliding) without any other external forces (freefall physics).

We have tested on both mono and IL2CPP backend scripting, which works with same performance on both ends(64 and 32 bits).
Below is a snippet showing the values we are using to simulate the BEPU Engine, as well as the code!

We are hoping if you could help us narrow down what and where we are doing performance intensive stuff so we can cut it down and do things the right way.

Thanks Again Norbo!

`using System.Collections;
using BEPUphysics.CollisionTests.CollisionAlgorithms;
using BEPUphysics.CollisionTests.CollisionAlgorithms.GJK;
using BEPUphysics.Constraints;
using BEPUphysics.Materials;
using BEPUphysics.Settings;
using UnityEngine;
using PSpace = BEPUphysics.Space;
using PVector3 = BEPUutilities.Vector3;
using FixMath.NET;
using System.Collections.Generic;
using BEPUphysics.Entities;
using BEPUphysics.NarrowPhaseSystems;
public class PhysicsManager : MonoBehaviour
{

public static PhysicsManager Instance { get; private set; }
public Vector3 gravity = new Vector3(0f, -9.81f, 0f);
public int Bepu_DefaultMinimumIterationCount = 1;
public int Bepu_IterationLimit = 10;
public bool Bepu_UseSimplexCaching = false;
public bool Bepu_UseExtraExpansionForContinuousBoundingBoxes = false;
public float Bepu_VelocityLowerLimit = 0.5f;
public float Bepu_MaximumPenetrationRecoverySpeed = 2.0f;
public float Bepu_BouncinessVelocityThreshold = 2.0f;
public float Bepu_StaticFrictionVelocityThreshold = 0.2f;
public float Bepu_ContactInvalidationLength = 0.1f;
public float Bepu_ContactMinimumSeparationDistance = 0.03f;
public float Bepu_MaximumContactDistance = 0.1f;
public float Bepu_DefaultMargin = 0.04f;
public float Bepu_AllowedPenetration = 0.01f;
public float Bepu_DefaultMinimumImpulse = 0.001f;
public int Bepu_maxTimeStep = 3;
public List<Entity> AllEntities = new List<Entity>();

public PSpace Space { get; set; }

bool GameStart = false;
private void Awake()
{
    GameStart = false;
    if (Instance == null)
    {
        Instance = this;
    }
    else if (Instance != this)
    {
        //Debug.Log("Instance Destroyed");
        Destroy(this.gameObject);
    }


    Init();

}
private void Start()
{
    StartCoroutine(gameStarter());
}
private void Update()
{
   
    if (GameStart == false)
    {
        Space.Update(0);
      
    }
    else
    {           
        Space.Update((Fix64)0.1f);
    }

}

IEnumerator gameStarter()
{
   //stop the game for a countdown timer

    Time.timeScale = 0;
    yield return new WaitForSecondsRealtime(3f);
    GameStart = true;
    Time.timeScale = 1;
    StopAllCoroutines();
    yield return null;
}



private void Init()
{

    Space = new PSpace();
    Space.ForceUpdater.Gravity = new PVector3((Fix64)gravity.x, (Fix64)gravity.y, (Fix64)gravity.z);
    MaterialManager.MaterialBlender = delegate (BEPUphysics.Materials.Material a,
        BEPUphysics.Materials.Material b, out InteractionProperties properties)
    {
        properties.KineticFriction = BEPUutilities.MathHelper.Max(a.KineticFriction, b.KineticFriction);
        properties.StaticFriction = BEPUutilities.MathHelper.Max(a.StaticFriction, b.StaticFriction);
        properties.Bounciness = BEPUutilities.MathHelper.Min(a.Bounciness, b.Bounciness);
    };
    ApplySettings();
}

private void ApplySettings()
{

    SolverSettings.DefaultMinimumIterationCount = Bepu_DefaultMinimumIterationCount;// by def 1
    Space.Solver.IterationLimit = Bepu_IterationLimit;    // by def 10
    Space.TimeStepSettings.MaximumTimeStepsPerFrame = Bepu_maxTimeStep;
    GeneralConvexPairTester.UseSimplexCaching = Bepu_UseSimplexCaching;    // by def False
    MotionSettings.UseExtraExpansionForContinuousBoundingBoxes = Bepu_UseExtraExpansionForContinuousBoundingBoxes;   // by def False

    // Set all the scaling settings back to their defaults.
    Space.DeactivationManager.VelocityLowerLimit = (Fix64)Bepu_VelocityLowerLimit;  // by Def 0.5f
    //Space.DeactivationManager.MaximumDeactivationAttemptsPerFrame = 1000;
    NarrowPhaseHelper.Factories.BoxSphere.EnsureCount(16384);
    NarrowPhaseHelper.Factories.SphereSphere.EnsureCount(16384);//16384
    CollisionResponseSettings.MaximumPenetrationRecoverySpeed = (Fix64)Bepu_MaximumPenetrationRecoverySpeed;   // by def 2
    CollisionResponseSettings.BouncinessVelocityThreshold = (Fix64)Bepu_BouncinessVelocityThreshold;   // by def 1
    CollisionResponseSettings.StaticFrictionVelocityThreshold = (Fix64)Bepu_StaticFrictionVelocityThreshold;    // by def 0.2f
    CollisionDetectionSettings.ContactInvalidationLength = (Fix64)Bepu_ContactInvalidationLength;  // by def 0.1f
    CollisionDetectionSettings.ContactMinimumSeparationDistance = (Fix64)Bepu_ContactMinimumSeparationDistance;    // by def 0.03f
    CollisionDetectionSettings.MaximumContactDistance = (Fix64)Bepu_MaximumContactDistance;    // by def 0.1f
    CollisionDetectionSettings.DefaultMargin = (Fix64)Bepu_DefaultMargin;   //by def 0.04f
    CollisionDetectionSettings.AllowedPenetration = (Fix64)Bepu_AllowedPenetration;    // by def 0.01f
    SolverSettings.DefaultMinimumImpulse = (Fix64)Bepu_DefaultMinimumImpulse;    // by def 0.001f
    // Space epsilons back to defaults

    // Leave below values as they are
    BEPUutilities.Toolbox.Epsilon = (Fix64)1e-7f;
    BEPUutilities.Toolbox.BigEpsilon = (Fix64)1e-5f;
    MPRToolbox.DepthRefinementEpsilon = (Fix64)1e-4f;
    MPRToolbox.RayCastSurfaceEpsilon = (Fix64)1e-9f;
    MPRToolbox.SurfaceEpsilon = (Fix64)1e-7f;
    PairSimplex.DistanceConvergenceEpsilon = (Fix64)1e-7f;
    PairSimplex.ProgressionEpsilon = (Fix64)1e-8f;

}

}
`

[RossNordby]

My first guess would be Space.Update((Fix64)0.1f);. The default Space.TimeStepSettings.TimeStepDuration is 1/60, which means passing 0.1 will take 6 or Space.TimeStepSettings.MaximumTimeStepsPerFrame time steps per Update call, whichever is lower. So if it's 3, then Space.Update is doing 3x more work.

The Space.Update(dt) overload uses internal timestepping based on an accumulator. If you want to take a single step of 0.1 length per call, set the Space.TimeStepSettings.TimeStepDuration = 0.1 and call Space.Update() without a dt parameter.

[TalhaEjaz03]

Thnx Ross,
After applying the time-step settings that u suggested, the things are going pretty well. Actually we are trying to get 30Fps Lock on all devices using the (Application.Targetframerate = 30;) in Unity, so we used (Space.TimeStepSettings.TimeStepDuration = 0.03) . It works pretty well!

If there are any more settings that we can add in our code to improve the performance on BEPU Physics for instance adding the code line,
NarrowPhaseHelper.Factories.BoxSphere.EnsureCount(16384);
NarrowPhaseHelper.Factories.SphereSphere.EnsureCount(16384);

Helped us gain more performance... If there are any more options or values that we can fiddle around with that can help us squeeze more performance out of the engine would be very very helpful!!!

The game we are building is currently 2D physics being rendered in a 3D environment, for which we are locking the rotations in X,Y and locking the positions in Z axis.

**using UnityEngine;
using BEPUphysics.Entities;
using FixMath.NET;
using BEPUutilities;

public abstract class CustomCompoundBody : MonoBehaviour
{
public abstract Entity MyEntityBox(float mass);
[Header("Physics Material")]
public PhysicMaterial physicMaterial;
private UnityEngine.Vector3 tPos;
private UnityEngine.Quaternion tRot;
public Entity Entity { get; private set; }
[Header("Parent Object")]
public GameObject parent;
public BEPUutilities.Vector3 ePos;
public BEPUutilities.Quaternion eRot;

private void OnEnable()
{

    var pb = GetComponent<PhysicsBody>();
    Entity = MyEntityBox(pb != null ? pb.mass : 0f);
    PhysicsManager.Instance.Space.Add(Entity);

    Entity.localInertiaTensorInverse.M11 = 0;        //
    Entity.localInertiaTensorInverse.M12 = 0;        //
    Entity.localInertiaTensorInverse.M13 = 0;        //     CONSTRAINTS 
    Entity.localInertiaTensorInverse.M21 = 0;        //
    Entity.localInertiaTensorInverse.M22 = 0;        //
    Entity.localInertiaTensorInverse.M23 = 0;        //

    Entity.Material.KineticFriction = (Fix64)physicMaterial.dynamicFriction;
    Entity.Material.StaticFriction = (Fix64)physicMaterial.staticFriction;
    Entity.Material.Bounciness = (Fix64)physicMaterial.bounciness;

    if (pb != null)
    {
        Entity.LinearDamping = (Fix64)pb.damping;
        Entity.AngularDamping = (Fix64)pb.angularDamping;
    }
}


private void Update()
{

//FORCING POSITIONS IN LOCK
Entity.position.Z = 0;
Entity.orientation.X = 0;
Entity.orientation.Y = 0;

//SETTING VALUES TO UNITY OBJECTS
ePos = Entity.Position;
tPos.Set((float)ePos.X, (float)ePos.Y, (float)ePos.Z);
eRot = Entity.Orientation;
tRot.Set((float)eRot.X, (float)eRot.Y, (float)(eRot.Z), (float)eRot.W);
transform.position = tPos;
transform.rotation = tRot;
}
}
**

If by any chance we can reduce the physics being calculated on the Z axis or in rotations we aren't using could also help gain some performance?

[RossNordby]

Worth noting that NarrowPhaseHelper.Factories.BoxSphere.EnsureCount(16384); is much, much more than it sounds like you need- that preallocates 16384 box-sphere pairs. If your simulation never requires 16384 pairs, it's just adding initialization and GC overhead.

If there are any more options or values that we can fiddle around with that can help us squeeze more performance out of the engine would be very very helpful!!!

There aren't a ton of degrees of freedoms at the level of global tuning. You could drop the minimum solver iterations to 0, but that's not going to help much at all if there aren't many constraints to solve.

If the compound bodies are very complex, it may be worth simplifying them.

I would make sure any measurements being performed are done with optimizations enabled to rule those sorts of issues out.

It's hard to give much other advice without more information. Fixed point carries a big overhead and being blocked from using multithreading will hurt.

Given the small scene size, would it be possible to instead just sync states incrementally? That would let you use either the non-fixed point version, or just the built in Unity solutions which should be faster than v1, especially the single threaded fixed point version.

If by any chance we can reduce the physics being calculated on the Z axis or in rotations we aren't using could also help gain some performance?

Nope- it always does calculations assuming it's fully 3D.