Android Studio中LibGDX+Box2D小球碰撞预测射线精度优化求助

问题背景 #

使用Android Studio搭配Java、LibGDX和Box2D开发，需求是可视化小球接下来至少两次碰撞的运动轨迹预测。当前代码可正常运行，但预测轨迹存在明显偏移（见下图），需要提升预测准确性。

当前实现代码 #

public static void debugBallNextCollisions(MyGame game, World world, Viewport viewport, Body ball, float maxPredictionDistance, int qtyRecursions) {
    Array<Vector2[]> raysVector2 = getNextCollisionsRay(world, ball, maxPredictionDistance, qtyRecursions);

    game.shapeRenderer.end();
    game.shapeRenderer.setProjectionMatrix(viewport.getCamera().combined);
    Gdx.gl.glEnable(GL20.GL_BLEND); 
    game.shapeRenderer.begin(ShapeRenderer.ShapeType.Line);

    for(Vector2[] vector2s : new Array.ArrayIterator<>(raysVector2)) {
        game.shapeRenderer.line(vector2s[0].x, vector2s[0].y, vector2s[1].x, vector2s[1].y);
    }

    game.shapeRenderer.end();
}

public static Array<Vector2[]> getNextCollisionsRay(World world, Body ball, float maxPredictionDistance, int qtyRecursions) {
    Array<Vector2[]> collisionRays = new Array<>();

    Vector2 velocity = ball.getLinearVelocity();

    if (!velocity.isZero()) {
        Vector2 vector2start = new Vector2(ball.getPosition());
        Vector2 vector2End = new Vector2(vector2start).add(velocity.nor().scl(maxPredictionDistance));

        getNextCollisionsRayRecursive(world, vector2start, vector2End, velocity, maxPredictionDistance, String.valueOf(ball.getUserData()), collisionRays, qtyRecursions);
    }

    return collisionRays;
}

private static void getNextCollisionsRayRecursive(World world, Vector2 startPos, Vector2 endPos, Vector2 velocity, float maxPredictionDistance, String bodyId, Array<Vector2[]> collisionRays, int qtyRecursions) {
    DetailedRayCastCallback callback2 = new DetailedRayCastCallback(startPos, endPos, bodyId);

    Vector2 vector2start2 = new Vector2(startPos);
    Vector2 vector2End2 = new Vector2(vector2start2).add(velocity.nor().scl(maxPredictionDistance));

    world.rayCast(callback2, vector2start2, vector2End2);

    if (callback2.closestHit != null) {
        CollisionInfo hit2 = callback2.closestHit;

        collisionRays.add(new Vector2[]{new Vector2(vector2start2.x, vector2start2.y), new Vector2(hit2.collisionPoint.x, hit2.collisionPoint.y)});

        if(--qtyRecursions > 0) {
            Vector2 endPos2 = new Vector2(hit2.reflectedVector).scl(maxPredictionDistance).add(hit2.collisionPoint);
            getNextCollisionsRayRecursive(world, hit2.collisionPoint, endPos2, hit2.reflectedVector, maxPredictionDistance, bodyId, collisionRays, qtyRecursions);
        }
    }
    else {
        Vector2 velocityEnd2 = new Vector2(vector2start2).add(velocity);
        collisionRays.add(new Vector2[]{new Vector2(vector2start2.x, vector2start2.y), new Vector2(velocityEnd2.x, velocityEnd2.y)});
    }
}

private static class DetailedRayCastCallback implements RayCastCallback {
    public CollisionInfo closestHit;
    private Vector2 position;
    private Vector2 velocity;
    private String bodyId;

    public DetailedRayCastCallback(Vector2 position, Vector2 velocity, String bodyId) {
        this.position = new Vector2(position);
        this.velocity = new Vector2(velocity);
        this.bodyId = bodyId;
    }

    @Override
    public float reportRayFixture(Fixture fixture, Vector2 point, Vector2 normal, float fraction) {
        if (fixture.getBody().getUserData() == bodyId) return -1;
        Vector2 reflectedVelocity = calculateReflection(velocity, normal);

        closestHit = new CollisionInfo(position, point, normal, reflectedVelocity, fixture);

        return fraction;
    }
}

private static class CollisionInfo {
    public Vector2 initialPoint;
    public Vector2 collisionPoint;
    public Vector2 surfaceNormal;
    public Vector2 reflectedVector;

    public CollisionInfo(Vector2 initial, Vector2 collision, Vector2 normal, Vector2 reflected, Fixture hitFixture) {
        this.initialPoint = new Vector2(initial);
        this.collisionPoint = new Vector2(collision);
        this.surfaceNormal = new Vector2(normal);
        this.reflectedVector = new Vector2(reflected);
    }
}

private static Vector2 calculateReflection(Vector2 incomingVector, Vector2 surfaceNormal) {
    float dotProduct = incomingVector.dot(surfaceNormal);
    Vector2 reflection = new Vector2(incomingVector).sub(surfaceNormal.scl(2 * dotProduct));
    return reflection;
}

// 调用代码
debugBallNextCollisions(game, world, viewport, ball.body, WORLD_HEIGHT, 5);

精度优化方案 #

1. 修正射线起点：考虑小球半径 #

当前射线从球心出发，但实际碰撞发生在球的表面而非球心。需要将射线起点沿速度方向偏移小球半径，确保射线检测的是球表面的碰撞点：

// 在getNextCollisionsRay方法中修改起点计算
Vector2 velocityDir = velocity.nor();
float ballRadius = ball.getFixtureList().get(0).getShape().getRadius();
// 从球表面而非球心开始射线
Vector2 vector2start = new Vector2(ball.getPosition()).add(velocityDir.scl(ballRadius));
Vector2 vector2End = new Vector2(vector2start).add(velocityDir.scl(maxPredictionDistance));

2. 修正反射速度：保留原速度大小与物理参数 #

当前反射向量丢失了原速度的大小，且未考虑碰撞表面的弹性系数，需补充：

private static Vector2 calculateReflection(Vector2 incomingVector, Vector2 surfaceNormal, float restitution) {
    float speed = incomingVector.len(); // 保留原速度大小
    float dotProduct = incomingVector.dot(surfaceNormal);
    // 应用弹性系数修正反弹速度
    Vector2 reflection = new Vector2(incomingVector)
        .sub(surfaceNormal.scl(2 * dotProduct))
        .nor()
        .scl(speed * restitution);
    return reflection;
}

在回调中调用时传入碰撞表面的弹性系数：

Vector2 reflectedVelocity = calculateReflection(velocity, normal, fixture.getRestitution());

3. 递归时使用剩余预测距离 #

当前每次递归都使用固定的maxPredictionDistance，需改为使用剩余距离（总距离减去已走过的距离）：

// 在getNextCollisionsRayRecursive的递归调用处修改
if(--qtyRecursions > 0) {
    float usedDistance = vector2start2.dst(hit2.collisionPoint);
    float remainingDistance = maxPredictionDistance - usedDistance;
    if(remainingDistance <= 0) return;
    
    Vector2 endPos2 = new Vector2(hit2.reflectedVector).nor().scl(remainingDistance).add(hit2.collisionPoint);
    getNextCollisionsRayRecursive(world, hit2.collisionPoint, endPos2, hit2.reflectedVector, remainingDistance, bodyId, collisionRays, qtyRecursions);
}

4. 正确筛选最近碰撞点 #

当前回调会覆盖碰撞点，需保留fraction最小的最近碰撞点：

// 修改DetailedRayCastCallback的reportRayFixture方法
@Override
public float reportRayFixture(Fixture fixture, Vector2 point, Vector2 normal, float fraction) {
    if (fixture.getBody().getUserData() == bodyId) return -1;
    
    // 只保留最近的碰撞点
    if(closestHit == null || fraction < closestHit.fraction) {
        Vector2 reflectedVelocity = calculateReflection(velocity, normal, fixture.getRestitution());
        closestHit = new CollisionInfo(position, point, normal, reflectedVelocity, fixture);
        closestHit.fraction = fraction; // 需要在CollisionInfo中添加float fraction字段
    }
    
    // 返回1.0f让Box2D继续检查所有可能的碰撞点
    return 1.0f;
}

5. 模拟重力与阻尼的影响 #

如果小球受重力或阻尼影响，预测时需要逐步更新速度：

// 在递归方法中，每次计算轨迹前应用重力和阻尼
Vector2 updatedVelocity = new Vector2(velocity);
// 应用重力（假设world的重力为gravity）
updatedVelocity.add(world.getGravity().scl(Gdx.graphics.getDeltaTime()));
// 应用阻尼
updatedVelocity.scl(1 - ball.getLinearDamping() * Gdx.graphics.getDeltaTime());

内容的提问来源于stack exchange，提问作者user2342558