2D AABB vs AABB Sweep: Cách tính hit bình thường?

Tôi đã triển khai chương trình quét AABBvsAABB 2D vào trò chơi của mình, tuy nhiên, tôi gặp khó khăn khi tính toán mức độ bình thường của lượt quét.

Tôi có hướng quét, cả vị trí AABB a và b và xy min-max, lần đánh đầu tiên và lần cuối để làm việc, nhưng không phải là (các) cạnh va chạm hoặc hướng thông thường. Tôi chỉ không thể khái niệm một giải pháp hiệu quả cho vấn đề cụ thể này. Bất kỳ ý tưởng? :)

*biên tập

Đây là những gì tôi có cho đến nay - chỉ là một triển khai chung của quét AABB của Gomez và Christer Ericson . Không có cú đánh bình thường, vì vậy trong khi tính toán bình thường là một bí ẩn đối với tôi, tôi không thể tạo ra bất kỳ phản ứng va chạm nào cho bộ điều khiển nhân vật của mình.

bool SweepVelAABBvsAABB(AABB a, AABB b, Vector2 v, out Vector2 outVel, out Vector2 norm )
    {
        outVel = v; //Initialise out velocity
        norm = Vector2.zero;

        if( AABBvsAABB(a,b) ) return true; //return early if a,b overlap

        v = -v;
        float hitTime = 0.0f;
        float outTime = 1.0f;

        if(v.x < 0.0f) //sweep is going right
        {
            if(b.max.x < a.min.x) return false;
            if(a.max.x < b.min.x) hitTime = Mathf.Max( (a.max.x - b.min.x) / v.x, hitTime );
            if(b.max.x > a.min.x) outTime = Mathf.Min( (a.min.x - b.max.x) / v.x, outTime );
        }
        else if(v.x > 0.0f) //sweep is going left
        {
            if(b.min.x > a.max.x) return false;
            if(b.max.x < a.min.x) hitTime = Mathf.Max( (a.min.x - b.max.x) / v.x, hitTime );
            if(a.max.x > b.min.x) outTime = Mathf.Min( (a.max.x - b.min.x) / v.x, outTime );
        }

        if(hitTime > outTime) return false;

        //=================================

        if(v.y < 0.0f) //sweep is going up
        {
            if(b.max.y < a.min.y) return false;
            if(a.max.y < b.min.y) hitTime = Mathf.Max( (a.max.y - b.min.y) / v.y, hitTime );
            if(b.max.y > a.min.y) outTime = Mathf.Min( (a.min.y - b.max.y) / v.y, outTime );
        }
        else if(v.y > 0.0f) //sweep is going down
        {
            if(b.min.y > a.max.y) return false;
            if(b.max.y < a.min.y) hitTime = Mathf.Max( (a.min.y - b.max.y) / v.y, hitTime );
            if(a.max.y > b.min.y) outTime = Mathf.Min( (a.max.y - b.min.y) / v.y, outTime );
        }

        if(hitTime > outTime) return false;

        outVel = -v * hitTime;

        return true;
    }

Tôi đã xoay sở để đưa ra một giải pháp đơn giản và hiệu quả bằng cách quan sát các trục tách biệt.

// Sweep a in the direction of v against b, returns true & info if there was a hit
// ===================================================================
bool SweepBoxBox( AABB a, AABB b, Vector2 v, out Vector2 outVel, out Vector2 hitNormal )
{
    //Initialise out info
    outVel = v;
    hitNormal = Vector2.zero;

    // Return early if a & b are already overlapping
    if( AABBvsAABB(a, b) ) return false;

    // Treat b as stationary, so invert v to get relative velocity
    v = -v;

    float hitTime = 0.0f;
    float outTime = 1.0f;
    Vector2 overlapTime = Vector2.zero;

    // X axis overlap
    if( v.x < 0 )
    {
        if( b.max.x < a.min.x ) return false;
        if( b.max.x > a.min.x ) outTime = Mathf.Min( (a.min.x - b.max.x) / v.x, outTime );

        if( a.max.x < b.min.x )
        {
            overlapTime.x = (a.max.x - b.min.x) / v.x;
            hitTime = Mathf.Max(overlapTime.x, hitTime);
        }
    }
    else if( v.x > 0 )
    {
        if( b.min.x > a.max.x ) return false;
        if( a.max.x > b.min.x ) outTime = Mathf.Min( (a.max.x - b.min.x) / v.x, outTime );

        if( b.max.x < a.min.x )
        {
            overlapTime.x = (a.min.x - b.max.x) / v.x;
            hitTime = Mathf.Max(overlapTime.x, hitTime);
        }
    }

    if( hitTime > outTime ) return false;

    //=================================

    // Y axis overlap
    if( v.y < 0 )
    {
        if( b.max.y < a.min.y ) return false;
        if( b.max.y > a.min.y ) outTime = Mathf.Min( (a.min.y - b.max.y) / v.y, outTime );

        if( a.max.y < b.min.y )
        {
            overlapTime.y = (a.max.y - b.min.y) / v.y;
            hitTime = Mathf.Max(overlapTime.y, hitTime);
        }           
    }
    else if( v.y > 0 )
    {
        if( b.min.y > a.max.y ) return false;
        if( a.max.y > b.min.y ) outTime = Mathf.Min( (a.max.y - b.min.y) / v.y, outTime );

        if( b.max.y < a.min.y )
        {
            overlapTime.y = (a.min.y - b.max.y) / v.y;
            hitTime = Mathf.Max(overlapTime.y, hitTime);
        }
    }

    if( hitTime > outTime ) return false;

    // Scale resulting velocity by normalized hit time
    outVel = -v * hitTime;

    // Hit normal is along axis with the highest overlap time
    if( overlapTime.x > overlapTime.y )
    {
        hitNormal = new Vector2(Mathf.Sign(v.x), 0);
    }
    else
    {
        hitNormal = new Vector2(0, Mathf.Sign(v.y));
    }

    return true;
}

Chú ý cách đánh của A là bình thường sum(Normals of Vectors of Edges on B involved in collision). Theo thứ tự từ:

1. Tìm các cạnh liên quan đến đối tượng chúng ta đang va chạm .
2. Từ có được các đỉnh từ các cạnh.
3. Tính tổng các giá trị của các đỉnh đó.
4. Biến vectơ kết quả thành một vectơ đơn vị (chuẩn hóa).

Hãy nhớ rằng một 'cạnh' thực sự có thể chỉ là một đỉnh ( chúng ta đang va chạm với góc trên một hộp khác).

Bạn cũng sẽ lưu ý rằng điều này áp dụng cho hit của B bình thường.

Nếu tôi hiểu chính xác, thuật toán của bạn cho đến nay tìm thấy vị trí dọc theo chuyển động của A mà A và B chỉ chạm vào nhau.

Với vị trí đó, thực hiện kiểm tra giao cắt một chiều giữa A và B trên cả ba trục. Một (hoặc nhiều hơn trong các trường hợp góc) của các trục này sẽ không có sự chồng chéo; cú đánh bình thường phải song song với trục đó và theo hướng từ B đến A.

Nếu nhiều hơn một trục không có sự chồng chéo, thì bạn đã đạt được một cạnh hoặc góc hoàn hảo; bạn có thể tùy ý chọn một tùy chọn hoặc tổng hợp kết quả cho một góc "làm tròn".