[Unity]几何碰撞检测:SAT 分离轴定理详解(从数学原理到 C# 实现)

从数学原理到 C# 实现 图解版

通过边法线、点积投影和一维区间比较,判断两个二维凸多边形是否相交。本文保留完整 Unity C# 示例,并用原文坐标逐步展示分离轴的计算过程。

一 前言

在 Unity 游戏开发中,经常会遇到判断两个图形是否相交的需求。

例如:

  • 两个圆形是否发生碰撞?
  • 一个三角形和一个矩形是否相交?
  • 两个任意凸多边形是否发生重叠?
  • 不使用 Unity Collider,如何自己实现碰撞检测?

对于圆形,可以通过圆心距离和半径之和进行判断。

对于矩形,可以使用 AABB(轴对齐包围盒)进行判断。

但是,如果两个图形是不规则的凸多边形,例如三角形、五边形、六边形等,应该如何判断?

这时就可以使用一个经典的几何算法:

SAT (Separating Axis Theorem ),分离轴定理。

本文从数学基础开始,结合三角形与正方形的具体案例,逐步讲解 SAT 的原理,并最终使用 Unity C# 实现一个通用的凸多边形碰撞检测方法。

二 什么是 SAT 分离轴定理

SAT 的全称是 Separating Axis Theorem,中文叫分离轴定理。

它的核心思想是:

如果两个凸多边形不相交,那么一定存在一个方向,使两个多边形在该方向上的投影区间完全分离。

反过来说:

  • 如果找到一条轴,使两个图形的投影区间不重叠,那么两个图形一定不相交。
  • 如果检查所有必要的候选轴,投影区间都存在重叠,那么两个凸多边形相交。

这里有两个关键概念:

  1. 投影

  2. 分离轴

2.1 什么是投影

可以把投影理解为:把一个二维图形沿着某个方向压缩到一条直线上,得到它在这条直线上的范围。

例如,有两个图形 A 和 B,我们选择水平方向作为投影轴。

将两个图形投影到 X 轴后,就可以得到两个一维区间:

图形 A 的投影:1, 4

图形 B 的投影:6, 9

由于两个区间没有重叠:

A: 1, 4

B: 6, 9

因此可以直接判断两个图形不相交。

需要注意:

某一个方向上的投影重叠,并不能说明两个图形一定相交。

例如,两个图形可能在水平方向上有重叠,但在斜向或者竖直方向上完全分离。

所以 SAT 需要检查多个方向。

图 1 水平投影存在间隙时 可以直接判定两个图形分离

2.2 什么是分离轴

能够让两个图形投影区间完全分离的方向,就叫作分离轴。

SAT 的关键就在于:

对于两个凸多边形,不需要检查所有可能的方向,只需要检查两个多边形所有边的法线方向。

假设:

  • 三角形有 3 条边。
  • 正方形有 4 条边。

那么最多需要检查 7 个候选轴。

其中,平行的边可能产生相同或相反方向的轴,因此实际可以进行去重优化。

三 理解 SAT 需要掌握的数学知识

在看 Unity 代码之前,建议先理解三个基础知识:

  1. 向量

  2. 法向量

  3. 点积

3.1 什么是向量

向量有两个基本属性:

  • 方向
  • 大小(模长)

例如:

Vector2 a = new Vector2(3, 2);

表示一个从原点出发,指向 (3,2) 的向量。

它的长度为:

|a|= 3 2 + 2 2 = 13

Unity 中可以通过以下方式获取向量长度:

float length = a.magnitude;

需要注意:

向量不等于线段。

例如:

  • 从 (0,0) 到 (3,2) 的线段。
  • 从 (5,5) 到 (8,7) 的线段。

它们虽然位置不同,但是方向向量都是 (3,2)。

在 SAT 中,我们主要使用向量来描述多边形边的方向。

3.2 什么是法向量

法向量(Normal Vector)是相对于某个几何对象而言的、与其垂直的向量。

例如,一条直线的方向向量是:

a=(3,2)

那么与它垂直的向量可以是:

n=(-2,3)

验证:

a· n=3×(-2)+2×3=0

点积为 0,说明两个向量垂直。

这里需要注意:

  • 法向量本身也有长度。
  • 法向量可以有正负两个方向。
  • 法向量不一定是单位向量。
  • 在 SAT 中,我们通常只关心法向量的方向。

对于二维向量 (x,y),有一个非常方便的规律:

逆时针旋转 90°:

(x,y)→(-y,x)

顺时针旋转 90°:

(x,y)→(y,-x)

所以,给定一个二维边向量:

Vector2 edge = new Vector2(3, 2);

可以直接得到它的法向量:

Vector2 normal = new Vector2(-edge.y, edge.x);

结果为:

edge = (3, 2)

normal = (-2, 3)

验证:

float dot = Vector2.Dot(edge, normal);

// dot = 0

这就是 SAT 中计算法向量最常用的方法。

图 2 法线通过将边向量旋转 90° 得到

3.3 什么是点积

点积(Dot Product)是 SAT 中另一个非常重要的数学知识。

假设有两个二维向量:

A=( a x , a y )

B=( b x , b y )

它们的点积为:

A· B= a x b x + a y b y

Unity 中对应:

float dot = Vector2.Dot(A, B);

点积还有一个几何意义:

A· B=|A||B|cosθ

其中,θ 是两个向量之间的夹角。

当 B 是单位向量时:

A· B=|A|cosθ

这个结果就是 A 在 B 方向上的有符号投影长度。

例如:

Vector2 point = new Vector2(3, 4);

Vector2 axis = new Vector2(1, 0);

float projection = Vector2.Dot(point, axis);

计算:

3×1+4×0=3

结果为 3。

如果投影轴换成:

Vector2 axis = new Vector2(0, 1);

那么结果就是 4。

这也就解释了:

为什么可以通过 Vector2.Dot ,将二维顶点转换成一个一维投影值。

注意:如果投影轴不是单位向量,点积结果会按照轴的长度进行缩放。但 SAT 只比较投影区间是否重叠,因此不需要强制归一化。

图 3 使用单位轴时 点积给出有符号投影长度

四 SAT 的核心步骤

下面通过一个具体案例,逐步理解整个算法。

假设有一个三角形和一个正方形。

三角形的三个顶点:

A = (0, 0)

B = (4, 0)

C = (2, 3)

正方形的四个顶点:

D = (5, 1)

E = (7, 1)

F = (7, 3)

G = (5, 3)

两个图形的所有坐标都处于同一个二维坐标系中。

图 4 案例顶点坐标与三角形边法线

4.1 第一步 获取多边形的所有边

三角形有三个顶点:

A → B → C → A

因此有三条边:

第一条边:

AB=B-A=(4,0)

第二条边:

BC=C-B=(-2,3)

第三条边:

CA=A-C=(-2,-3)

这里有一个很重要的细节:

多边形顶点必须按照轮廓顺序排列。

可以顺时针排列,也可以逆时针排列,但不能随意打乱。

为什么?

因为 SAT 需要通过相邻顶点计算每一条边。

如果顶点顺序混乱,计算出来的边就可能不是多边形真实轮廓上的边,从而遗漏正确的候选轴。

4.2 第二步 计算每条边的法向量

有了边向量之后,就可以通过旋转 90° 得到法向量。

三角形:

边方向向量 法向量
(4,0) (0,4)
(-2,3) (-3,-2)
(-2,-3) (3,-2)

正方形:

边方向向量 法向量
(2,0) (0,2)
(0,2) (-2,0)
(-2,0) (0,-2)
(0,-2) (2,0)

因此,总共需要检查 7 个候选轴。

注意,正方形的对边平行,所以实际上只有两个不同的轴方向。

4.3 第三步 将两个多边形投影到轴上

现在我们已经得到了候选轴。

接下来选择其中一条轴,将两个多边形的所有顶点分别投影上去。

首先选择三角形第一条边的法向量:

N 1 =(0,4)

三角形三个顶点的投影:

顶点 点积计算 投影值
A(0,0) 0×0+0×4 0
B(4,0) 4×0+0×4 0
C(2,3) 2×0+3×4 12

因此三角形的投影区间:

0,12

接着计算正方形:

顶点 点积计算 投影值
D(5,1) 5×0+1×4 4
E(7,1) 7×0+1×4 4
F(7,3) 7×0+3×4 12
G(5,3) 5×0+3×4 12

正方形的投影区间:

4,12

两个区间存在重叠。

因此,当前轴不能证明两个图形不相交。

注意:这也不代表两个图形一定相交,只能说明当前方向没有找到分离轴。

图 5 在 N₁ 上的区间重叠 不能据此确认相交

4.4 第四步 检查其他候选轴

接下来使用三角形第二条边的法向量:

N 2 =(-3,-2)

计算三角形投影:

顶点 点积计算 投影值
A(0,0) 0 0
B(4,0) 4×(-3)+0×(-2) -12
C(2,3) 2×(-3)+3×(-2) -12

三角形投影区间:

-12,0

计算正方形投影:

顶点 点积计算 投影值
D(5,1) 5×(-3)+1×(-2) -17
E(7,1) 7×(-3)+1×(-2) -23
F(7,3) 7×(-3)+3×(-2) -27
G(5,3) 5×(-3)+3×(-2) -21

正方形投影区间:

-27,-17

将两个区间放在一起:

正方形:-27, -17

三角形:-12, 0

可以发现:

-17<-12

两个区间完全分离。

因此找到了分离轴,可以直接判断:

三角形与正方形不相交。

后面的候选轴不需要再检查。

图 6 在 N₂ 上的区间完全分离 提前结束检查

4.5 第五步 区间是否重叠的判断条件

假设两个图形的投影区间分别是:

A: minA, maxA

B: minB, maxB

判断是否分离:

if (maxA < minB || maxB < minA)

{

return false;

}

两个条件分别表示:

  1. A 完全位于 B 左侧。

  2. B 完全位于 A 左侧。

只要满足其中一个条件,就说明当前轴上存在分离。

如果所有候选轴都没有出现区间分离,那么两个凸多边形相交。

这里使用严格小于号,因此边界刚好接触时,会被视为相交。

图 7 严格小于号将边界接触视为相交

五 Unity C# 完整实现

理解了数学原理之后,再来看实际代码。

5.1 完整代码

输入前提 顶点需按轮廓顺序排列,且构成非退化的凸多边形。示例中的 IsValidPolygon 只检查空引用与顶点数量,不验证凸性、自交或面积;代码保留原文实现。

using UnityEngine;

public static class PolygonCollision

{

/// <summary>

/// 判断两个凸多边形是否相交

/// </summary>

public static bool IsIntersect(

Vector2\[\] polygonA,

Vector2\[\] polygonB)

{

if (!IsValidPolygon(polygonA) ||

!IsValidPolygon(polygonB))

{

return false;

}

return CheckAxes(polygonA, polygonB) &&

CheckAxes(polygonB, polygonA);

}

/// <summary>

/// 检查一个多边形的所有边法线

/// </summary>

private static bool CheckAxes(

Vector2\[\] polygonA,

Vector2\[\] polygonB)

{

for (int i = 0; i < polygonA.Length; i++)

{

// 当前边的起点

Vector2 p1 = polygonAi;

// 当前边的终点

Vector2 p2 =

polygonA(i + 1) % polygonA.Length;

// 计算边方向向量

Vector2 edge = p2 - p1;

// 计算法向量,旋转90度

Vector2 axis =

new Vector2(-edge.y, edge.x);

// 跳过零长度边

if (axis.sqrMagnitude < 0.000001f)

continue;

// 分别计算两个多边形的投影区间

Project(polygonA, axis,

out float minA, out float maxA);

Project(polygonB, axis,

out float minB, out float maxB);

// 存在分离轴

if (maxA < minB || maxB < minA)

{

return false;

}

}

// 当前多边形的所有边法线均未分离

return true;

}

/// <summary>

/// 将多边形所有顶点投影到指定轴

/// </summary>

private static void Project(

Vector2\[\] polygon,

Vector2 axis,

out float min,

out float max)

{

min = max = Vector2.Dot(polygon0, axis);

for (int i = 1; i < polygon.Length; i++)

{

float value =

Vector2.Dot(polygoni, axis);

min = Mathf.Min(min, value);

max = Mathf.Max(max, value);

}

}

private static bool IsValidPolygon(Vector2\[\] polygon)

{

return polygon != null && polygon.Length >= 3;

}

}

5.2 为什么要调用两次 CheckAxes

看这段代码:

return CheckAxes(polygonA, polygonB) &&

CheckAxes(polygonB, polygonA);

这是 SAT 非常重要的一点。

第一次:

CheckAxes(polygonA, polygonB)

使用 A 多边形的所有边法线作为候选轴,检查 A 和 B 的投影。

第二次:

CheckAxes(polygonB, polygonA)

使用 B 多边形的所有边法线作为候选轴,再次检查两个图形。

为什么不能只检查 A?

因为分离轴可能来自 B 的边法线。

所以必须检查双方的候选轴,才能保证不遗漏分离轴。

5.3 为什么使用 (i + 1) % polygon.Length

这是多边形边遍历中一个非常常见的写法。

Vector2 p1 = polygoni;

Vector2 p2 =

polygon(i + 1) % polygon.Length;

假设三角形有三个顶点:

i p1 (i+1)%3 p2
0 A 1 B
1 B 2 C
2 C 0 A

最后一次循环:

(2 + 1) % 3 = 0

自动将最后一个顶点连接回第一个顶点。

这样就能遍历所有边,而不需要额外处理最后一条边。

5.4 为什么不需要 Normalize

很多人在第一次接触 SAT 时,会有一个疑问:

为什么法向量不需要归一化?

例如:

Vector2 axis =

new Vector2(-edge.y, edge.x);

为什么不写:

axis.Normalize();

原因是:

SAT 只需要比较投影区间是否重叠。

假设投影轴为:

N=(-2,3)

将它放大两倍:

N'=(-4,6)

所有顶点的投影值也会放大两倍,但区间是否重叠不会改变。

所以,不归一化并不会影响最终判断。

如果后续需要计算实际的穿透深度、最小平移向量等,则需要进一步处理法线长度。

六 使用示例

Vector2\[\] triangle =

{

new Vector2(0, 0),

new Vector2(4, 0),

new Vector2(2, 3)

};

Vector2\[\] square =

{

new Vector2(5, 1),

new Vector2(7, 1),

new Vector2(7, 3),

new Vector2(5, 3)

};

bool intersect = PolygonCollision.IsIntersect(

triangle,

square

);

Debug.Log($"是否相交:{intersect}");

输出:

是否相交:False

如果顶点来自 Unity 的 Transform 局部坐标,需要先转换到同一个坐标系。

例如:

Vector3 worldPoint =

transform.TransformPoint(localPoint);

转换到世界坐标后,再传入 SAT 算法。

七 SAT 的适用范围与注意事项

SAT 并不是所有多边形都可以直接使用。

7.1 只适用于凸多边形

SAT 的标准边法线检测适用于凸多边形。

凸多边形的特点是:

任意两个内部点连成的线段,都完全位于多边形内部或边界上。

例如:

  • 三角形
  • 正方形
  • 矩形
  • 凸五边形
  • 凸六边形

其中五边形、六边形也必须满足凸性,才能直接使用本文实现。

但是,如果是凹多边形,例如 L 形:

不能直接使用本文的 SAT 实现。

通常需要先将凹多边形拆分成多个凸多边形,再分别进行碰撞检测。

图 8 标准边法线 SAT 要求图形为凸多边形

7.2 顶点必须按轮廓顺序排列

可以顺时针,也可以逆时针。

但是不能随意打乱顶点顺序,否则相邻顶点计算出来的边就可能不正确。

7.3 所有顶点必须处于同一坐标系

不能一个多边形使用局部坐标,另一个使用世界坐标。

否则投影计算没有意义。

7.4 边界接触如何处理

本文代码:

if (maxA < minB || maxB < minA)

使用严格小于号。

因此两个图形边界刚好接触时,会返回相交。

如果业务需求是只有实际面积重叠才算相交,可以根据需求调整边界判断,但需要考虑浮点数精度。

7.5 性能如何

假设两个凸多边形分别有 N 和 M 个顶点。

候选轴数量最多为:

N+M

每条轴需要分别遍历两个多边形的所有顶点。

所以整体时间复杂度为:

O((N+M ) 2 )

对于顶点数量不多的游戏多边形,这种实现通常足够使用。

如果图形数量特别多,可以进一步使用 AABB 进行宽阶段过滤,减少 SAT 的调用次数。

八 SAT 与其他碰撞检测方法的区别

算法 适用对象 特点
圆形距离检测 圆形 实现简单,计算量小
AABB 轴对齐矩形 非常适合宽阶段碰撞检测
OBB 旋转矩形 可以处理旋转矩形
SAT 凸多边形 通用性较好
凸分解 + SAT 凹多边形 通过拆分支持凹多边形

实际 Unity 项目中,可以根据碰撞对象的类型选择合适的算法。

不需要所有图形都使用 SAT。

九 面试中如何回答 SAT

如果面试官问:

如何判断两个任意凸多边形是否相交?

可以这样回答:

我会使用 SAT,也就是分离轴定理。

核心思想是将二维多边形投影到多个候选轴上,判断两个图形的投影区间是否存在分离。

具体实现分为几个步骤:

  1. 遍历两个多边形的所有边。

  2. 根据边的方向向量计算法向量,作为候选投影轴。

  3. 使用向量点积,将两个多边形的所有顶点投影到当前轴上。

  4. 分别计算两个投影区间的最小值和最大值。

  5. 如果任意一条轴上两个区间完全分离,就可以直接判断不相交。

  6. 如果所有候选轴都没有分离,则两个凸多边形相交。

算法不依赖 Unity 物理系统,适合实现自定义的二维凸多边形碰撞检测。

如果是凹多边形,则需要先进行凸分解,再使用 SAT。

十 总结

SAT 的核心并不复杂,真正需要理解的是三个数学知识点:

1. 向量相减:

通过两个顶点相减,得到多边形边的方向向量。

2. 旋转 90° :

通过:

new Vector2(-edge.y, edge.x)

得到边的法向量。

3. 点积投影:

通过:

Vector2.Dot(point, axis)

将二维顶点转换成一维投影值。

最后比较两个多边形的投影区间。

记住一句话:

SAT 就是将二维凸多边形碰撞问题,转换成多个方向上的一维区间重叠检测。

理解了向量、法向量和点积,就能理解整套 SAT 算法。

参考资料

  • Separating Axis Theorem(分离轴定理)
  • Unity Vector2.Dot API
  • Unity Vector2.Normalize API
相关推荐
汤姆宝库14 小时前
BPE分词器的完整实现:字节对合并与词表构建
开发语言·人工智能·c#
Risehuxyc18 小时前
C# 发展历史
开发语言·c#
kyle~20 小时前
C# --- 反射
开发语言·c#
暴走约伯2 天前
【VFX工具链源码拆解 09】终极工业化闭环:基于 ID 规则驱动的全自动场景建档、骨骼挂载与男转女场景迁移
unity·c#·游戏引擎·材质
用户788477316343 天前
WinForms 迁移 WPF:Upgrade Assistant 覆盖 30%,剩下 70% 我手写了六周
c#
寂寞的船3 天前
【Unity知识速递】第13期 Unity 内存泄漏排查实战:从 Memory Profiler 到 Lua 引用泄漏的生产级全链路诊断
unity·junit·c#·游戏引擎·lua
用户3721574261354 天前
C# 提取 PDF 附件:包括文档附件和页面注释附件
c#
寂寞的船4 天前
【Unity Bug挑战】第12期 Awaitable 二次 await 死锁之谜 —— 为什么同一个异步操作等两次就卡死?
unity·c#·游戏引擎·bug
探求虚无5 天前
用 AI 在 Unity 里做一款 RTS:最难的不是生成代码,而是证明它真的能玩
人工智能·unity·游戏引擎