SweepCast behaves inconsistently with different speeds when used for kinematic movement

[HuangMiu]

Description

I want to fully control the movement of my object, so I am using a Kinematic Body and only relying on physics queries. The object's position is updated manually by my code.

In the code below, Body is a Kinematic Body, and the other objects in the scene are Static Components.

Problem

When using the SweepCast API, I encountered the following behavior:

• When speed is set to 5, the sweep sometimes fails to detect other objects and the body passes directly through them.
• When speed is set to 10, the sweep always detects the collision, but the body stops with a noticeable gap from the other object.
• If I further increase speed, the gap between the body and the obstacle when it stops becomes larger.
• If I try to compensate the movement using result.Distance, the body will pass directly through the other object.

Expected Behavior

What I want to achieve is the following:

• The object should be able to move at any speed.
• When the object hits another object, it should stop right next to it.
• There should be no visible gap between the objects.
• The object should never pass through other objects.

Question

I am not sure whether my understanding or usage of SweepCast is incorrect.

Could someone explain the correct way to use SweepCast for manual kinematic movement?

Code

public class BoxTester : SyncScript, ISimulationUpdate
{
    public BodyComponent Body;

    Vector3 Velocity;

    public override void Update()
    {

    }

    #region ISimulationUpdate

    Entity ISimulationUpdate.Entity => Entity;

    void ISimulationUpdate.SimulationUpdate(BepuSimulation simulation, float simTimeStep)
    {
        Vector3 dir = Vector3.Zero;
        if (Input.IsKeyDown(Keys.S))
            dir.Y = -1;
        else if (Input.IsKeyDown(Keys.D))
            dir.X = 1;
        else if (Input.IsKeyDown(Keys.A))
            dir.X = -1;
        else if (Input.IsKeyDown(Keys.W))
            dir.Y = 1;

        float speed = 10;
        Velocity = dir * speed;

        if (Body.Collider is CompoundCollider compoundCollider)
        {
            var collider = compoundCollider.Colliders.First() as BoxCollider;
            if (collider is not null)
            {
                Box box = new(collider.Size.X, collider.Size.Y, collider.Size.Z);
                Entity.Transform.GetWorldTransformation(out var worldPosition, out var worldRotate, out _);
                RigidPose pose = new(worldPosition, worldRotate);
                float maxDistance = (Velocity * simTimeStep).Length() + 0.02f;
                BodyVelocity velocity = new(Velocity, Vector3.Zero);
                bool hasHit = simulation.SweepCast(box, pose, velocity, maxDistance, out var result);
                if (!hasHit)
                {
                    Body.Teleport(Body.Position + Velocity * simTimeStep, Body.Orientation);
                }
                else
                {
                    Body.Teleport(Body.Position + result.Distance, Body.Orientation);    
                }
                DebugText.Print($"Has Hit:{hasHit}\r\n" +
                                $"Hit Dis:{result.Distance}\r\n" +
                                $"Max Dis:{maxDistance}", new(200, 200));
            }
        }
    }

    void ISimulationUpdate.AfterSimulationUpdate(BepuSimulation simulation, float simTimeStep)
    {

    }

    #endregion
}

[Eideren]

You're mixing two different positions; as the documentation for Body.Position specifies,

[Body.Position] is slightly offset from this entity's Transform.Position based on its CenterOfMass

Don't use Entity.Transform.GetWorldTransformation(out var worldPosition, out var worldRotate, out _);, instead use the bodies' position and rotation.

You're starting the sweep from inside the body you're moving, you're very likely occasionally hitting your own collision there, use a collision mask, or do a penetrating one with your own body filtered out.

Also not sure that max distance is correct there, should be just the delta time if I remember right, unless you normalize velocity.

Body.Position + result.Distance doesn't do what you think it does, I think you meant to use Body.Position + result.Distance * Velocity or Body.Position + result.Distance * Vector3.Normalize(Velocity)

If you're not entirely familiar with the internals of bepu and our physics layer, you're better off using Body.SetTargetPose instead of doing the physics query and moving the body yourself; teleporting does not work with body interpolation, it won't push other bodies away, and may trigger collision enter and exit events every tick when done against a collision. Body.SetTargetPose complies with all of those.

[HuangMiu]

Thank you for your reply!
But after using delta time as the max distance, the SweepCast fails to detect any collisions.

Box box = new(collider.Size.X, collider.Size.Y, collider.Size.Z);
RigidPose pose = new(Body.Position, Body.Orientation);
float maxDistance = simTimeStep;
BodyVelocity velocity = new(Velocity, Vector3.Zero);
bool hasHit = simulation.SweepCast(box, pose, velocity, maxDistance, out var result);
if (!hasHit)
{
    Body.SetTargetPose(Body.Position + Velocity * simTimeStep, Body.Orientation);
}
else
{
    //Body.SetTargetPose(Body.Position + result.Distance, Body.Orientation);    
}