Tôi đã thực hiện SAT dựa trên:
Trên trang 7, trong bảng, nó đề cập đến trục 15 để kiểm tra để chúng ta có thể tìm thấy một vụ va chạm, nhưng chỉ với Axe, Ay và Az, tôi đã bị va chạm.
Tại sao tôi cần phải kiểm tra tất cả các trường hợp khác? Có tình huống nào mà chỉ Ax, Ay và Az không đủ?
Câu trả lời:
Bạn có thể nhận được dương tính giả. Va chạm phát hiện nhưng không thực sự va chạm.
Số 15 đến từ
9 trục được tạo thành từ các sản phẩm chéo của các cạnh của A và các cạnh của B
6 trục đầu tiên (từ các quy tắc khuôn mặt) được sử dụng để kiểm tra xem có một góc của một đối tượng đang giao nhau với một mặt của đối tượng khác hay không. (hoặc chính xác hơn để loại bỏ các loại va chạm này)
Tập hợp 9 trục được hình thành bởi các sản phẩm chéo của các cạnh được sử dụng để xem xét cạnh phát hiện va chạm cạnh, trong đó không có một đỉnh xuyên qua đối tượng khác. Giống như vụ va chạm 'gần như' trong bức ảnh dưới đây. Giả sử cho phần còn lại của câu trả lời này rằng hai hộp trong ảnh không thực sự va chạm, nhưng cách nhau một khoảng nhỏ.
Hãy nhìn vào những gì sẽ xảy ra nếu chúng ta chỉ sử dụng 6 quy tắc khuôn mặt cho SAT. Hình ảnh đầu tiên bên dưới hiển thị một trục từ hộp màu xanh và 2 trục từ hộp màu vàng. Nếu chúng ta chiếu cả hai đối tượng lên các trục này, chúng ta sẽ có sự chồng chéo lên cả ba. Hình ảnh thứ hai bên dưới cho thấy hai trục còn lại của hộp màu xanh và trục còn lại của hộp màu vàng. Một lần nữa chiếu vào các trục này sẽ hiển thị chồng lấp trên cả 3.
Vì vậy, chỉ cần kiểm tra 6 quy tắc khuôn mặt sẽ hiển thị chồng lấp trên tất cả 6 trục, theo SAT, có nghĩa là các đối tượng đang va chạm, vì chúng ta không thể tìm thấy sự phân tách. Nhưng tất nhiên, những vật thể này không va chạm. Lý do chúng tôi không tìm thấy một sự tách biệt là vì chúng tôi đã không nhìn đủ cứng!
Vậy làm thế nào để chúng ta tìm thấy khoảng cách này? Hình ảnh dưới đây cho thấy một trục mà trên đó chiếu của cả hai đối tượng sẽ tiết lộ một sự tách biệt.
Chúng ta lấy trục này từ đâu?
Nếu bạn tưởng tượng trượt một mảnh thẻ cứng vào khoảng trống, thẻ đó sẽ là một phần của mặt phẳng phân tách. Nếu chúng ta chiếu vào bình thường của mặt phẳng đó (mũi tên đen trong hình trên), chúng ta sẽ thấy sự phân tách. Chúng ta biết mặt phẳng đó là gì bởi vì chúng ta có hai vectơ nằm trên mặt phẳng đó) Một vectơ được căn với cạnh màu xanh và vectơ kia được căn với cạnh màu vàng và như chúng ta đều biết bình thường đối với một mặt phẳng chỉ đơn giản là tích chéo của hai vectơ nằm trên mặt phẳng.
Vì vậy, đối với các OOBB, chúng ta cần kiểm tra mọi sự kết hợp (9 trong số đó) các sản phẩm chéo của các cạnh của hai đối tượng để đảm bảo chúng ta không bỏ sót bất kỳ sự tách biệt cạnh-cạnh nào.
Ghi chú câu trả lời của Ken :
9 trục được tạo thành từ các sản phẩm chéo của các cạnh của A và các cạnh của B
Thật khó hiểu khi đề cập đến các cạnh, vì có 12 cạnh so với 6 quy tắc, khi bạn cũng có thể sử dụng ba quy tắc chính cho cùng một đầu ra - các cạnh đều được căn chỉnh với các quy tắc, vì vậy tôi khuyên bạn nên sử dụng chúng thay thế !
Cũng lưu ý rằng các quy tắc chỉ dọc theo cùng một trục, nhưng theo một hướng khác, sẽ bị bỏ qua và do đó chúng ta còn lại ba trục duy nhất.
Một điều nữa tôi muốn thêm vào, đó là bạn có thể tối ưu hóa tính toán này bằng cách thoát sớm nếu bạn tìm thấy một trục tách, trước khi bạn tính toán tất cả các trục bạn muốn kiểm tra. Vì vậy, không, bạn không cần phải kiểm tra tất cả các trục trong mọi trường hợp, nhưng bạn cần phải sẵn sàng để kiểm tra tất cả :)
Dưới đây là danh sách đầy đủ các trục để kiểm tra, đưa ra hai OBB, A và B, trong đó x, y và z tham chiếu đến các vectơ cơ sở / ba quy tắc duy nhất. Trục 0 = x, trục 1 = y, trục 2 = z
Cũng có một chút cảnh báo, mà bạn nên biết.
Sản phẩm chéo sẽ cung cấp cho bạn một vectơ không {0,0,0} khi bất kỳ hai trục giữa các đối tượng cùng hướng.
Ngoài ra, vì phần này bị bỏ qua, đây là phần triển khai của tôi để kiểm tra xem hình chiếu có bị chồng chéo hay không. Có lẽ có một cách tốt hơn, nhưng điều này làm việc cho tôi! (Sử dụng Unity và API C # của nó)
// aCorn and bCorn are arrays containing all corners (vertices) of the two OBBs
private static bool IntersectsWhenProjected( Vector3[] aCorn, Vector3[] bCorn, Vector3 axis ) {
// Handles the cross product = {0,0,0} case
if( axis == Vector3.zero )
return true;
float aMin = float.MaxValue;
float aMax = float.MinValue;
float bMin = float.MaxValue;
float bMax = float.MinValue;
// Define two intervals, a and b. Calculate their min and max values
for( int i = 0; i < 8; i++ ) {
float aDist = Vector3.Dot( aCorn[i], axis );
aMin = ( aDist < aMin ) ? aDist : aMin;
aMax = ( aDist > aMax ) ? aDist : aMax;
float bDist = Vector3.Dot( bCorn[i], axis );
bMin = ( bDist < bMin ) ? bDist : bMin;
bMax = ( bDist > bMax ) ? bDist : bMax;
}
// One-dimensional intersection test between a and b
float longSpan = Mathf.Max( aMax, bMax ) - Mathf.Min( aMin, bMin );
float sumSpan = aMax - aMin + bMax - bMin;
return longSpan < sumSpan; // Change this to <= if you want the case were they are touching but not overlapping, to count as an intersection
}ví dụ làm việc c # dựa trên câu trả lời của Acegikmo (sử dụng một số api đoàn kết):
using UnityEngine;
public class ObbTest : MonoBehaviour
{
public Transform A;
public Transform B;
void Start()
{
Debug.Log(Intersects(ToObb(A), ToObb(B)));
}
static Obb ToObb(Transform t)
{
return new Obb(t.position, t.localScale, t.rotation);
}
class Obb
{
public readonly Vector3[] Vertices;
public readonly Vector3 Right;
public readonly Vector3 Up;
public readonly Vector3 Forward;
public Obb(Vector3 center, Vector3 size, Quaternion rotation)
{
var max = size / 2;
var min = -max;
Vertices = new[]
{
center + rotation * min,
center + rotation * new Vector3(max.x, min.y, min.z),
center + rotation * new Vector3(min.x, max.y, min.z),
center + rotation * new Vector3(max.x, max.y, min.z),
center + rotation * new Vector3(min.x, min.y, max.z),
center + rotation * new Vector3(max.x, min.y, max.z),
center + rotation * new Vector3(min.x, max.y, max.z),
center + rotation * max,
};
Right = rotation * Vector3.right;
Up = rotation * Vector3.up;
Forward = rotation * Vector3.forward;
}
}
static bool Intersects(Obb a, Obb b)
{
if (Separated(a.Vertices, b.Vertices, a.Right))
return false;
if (Separated(a.Vertices, b.Vertices, a.Up))
return false;
if (Separated(a.Vertices, b.Vertices, a.Forward))
return false;
if (Separated(a.Vertices, b.Vertices, b.Right))
return false;
if (Separated(a.Vertices, b.Vertices, b.Up))
return false;
if (Separated(a.Vertices, b.Vertices, b.Forward))
return false;
if (Separated(a.Vertices, b.Vertices, Vector3.Cross(a.Right, b.Right)))
return false;
if (Separated(a.Vertices, b.Vertices, Vector3.Cross(a.Right, b.Up)))
return false;
if (Separated(a.Vertices, b.Vertices, Vector3.Cross(a.Right, b.Forward)))
return false;
if (Separated(a.Vertices, b.Vertices, Vector3.Cross(a.Up, b.Right)))
return false;
if (Separated(a.Vertices, b.Vertices, Vector3.Cross(a.Up, b.Up)))
return false;
if (Separated(a.Vertices, b.Vertices, Vector3.Cross(a.Up, b.Forward)))
return false;
if (Separated(a.Vertices, b.Vertices, Vector3.Cross(a.Forward, b.Right)))
return false;
if (Separated(a.Vertices, b.Vertices, Vector3.Cross(a.Forward, b.Up)))
return false;
if (Separated(a.Vertices, b.Vertices, Vector3.Cross(a.Forward, b.Forward)))
return false;
return true;
}
static bool Separated(Vector3[] vertsA, Vector3[] vertsB, Vector3 axis)
{
// Handles the cross product = {0,0,0} case
if (axis == Vector3.zero)
return false;
var aMin = float.MaxValue;
var aMax = float.MinValue;
var bMin = float.MaxValue;
var bMax = float.MinValue;
// Define two intervals, a and b. Calculate their min and max values
for (var i = 0; i < 8; i++)
{
var aDist = Vector3.Dot(vertsA[i], axis);
aMin = aDist < aMin ? aDist : aMin;
aMax = aDist > aMax ? aDist : aMax;
var bDist = Vector3.Dot(vertsB[i], axis);
bMin = bDist < bMin ? bDist : bMin;
bMax = bDist > bMax ? bDist : bMax;
}
// One-dimensional intersection test between a and b
var longSpan = Mathf.Max(aMax, bMax) - Mathf.Min(aMin, bMin);
var sumSpan = aMax - aMin + bMax - bMin;
return longSpan >= sumSpan; // > to treat touching as intersection
}
}