扫描线算法：游戏碰撞检测的高效解决方案

1. 扫描线算法：从游戏卡顿到高效碰撞检测的蜕变

2003年那个让游戏公司崩溃的夜晚，至今仍是算法优化领域的经典案例。当屏幕上角色数量超过20个时，游戏帧率从流畅的60帧暴跌至个位数，核心问题直指碰撞检测的O(N²)复杂度诅咒。这个真实故事完美诠释了算法选择对系统性能的决定性影响。

扫描线算法（Sweep and Prune）之所以能成为游戏物理引擎的标配，关键在于它将暴力检测的O(N²)复杂度降到了接近O(N log N)。这种提升不是简单的量变，而是质变——当角色数量从20个增加到100个时，暴力算法需要处理的检测对数从190激增至4950，而扫描线算法仅需约460次操作（N=100时，N log N ≈ 460）。

2. 碰撞检测的两阶段哲学

2.1 宽相与窄相的分工艺术

现代碰撞检测采用分而治之的策略，将过程明确划分为两个阶段：

宽相（Broad Phase）：

• 核心任务：快速筛选可能碰撞的物体对
• 技术特点：使用AABB（轴对齐包围盒）等简单近似形状
• 设计原则：允许假阳性（false positive），但绝不能漏报（false negative）
• 典型算法：扫描线算法、均匀网格、BVH（层次包围盒树）

窄相（Narrow Phase）：

• 核心任务：对宽相筛选的候选对进行精确检测
• 技术特点：采用GJK（Gilbert-Johnson-Keerthi）或SAT（分离轴定理）等精确算法
• 设计原则：必须准确，不能有任何误判
• 典型实现：多边形精确相交检测、连续碰撞检测（CCD）

这种分工类似于医院的分诊制度：宽相相当于分诊护士，快速判断哪些病人需要进一步检查；窄相则是专科医生，对疑似病例进行精确诊断。

2.2 AABB：宽相的基石

轴对齐包围盒（AABB）之所以成为宽相检测的标准选择，源于其三大优势：

1. 存储效率：只需保存min和max两个三维坐标（共6个浮点数）
2. 检测高效：二维AABB相交仅需4次比较，三维也只需6次

   python复制# 二维AABB相交检测伪代码
   def aabb_intersect(a, b):
       return (a.x_min <= b.x_max and b.x_min <= a.x_max and
               a.y_min <= b.y_max and b.y_min <= a.y_max)
   

3. 通用性强：任何复杂形状都能找到对应的AABB近似

虽然AABB会带来约20-30%的过估计（两个AABB相交但实际物体未碰撞），但这正是宽相设计所允许的——用少量冗余换取检测效率的大幅提升。

3. 扫描线算法的精妙设计

3.1 一维扫描线的核心思想

扫描线算法的智慧源于一个简单观察：两个AABB要在空间中相交，必须在所有坐标轴上都重叠。算法首先在x轴上实施"过滤"：

1. 事件生成：为每个AABB创建两个事件点（进入和离开）
2. 排序处理：按x坐标排序所有事件点
3. 活跃集合：维护当前与扫描线相交的AABB集合
4. 候选对生成：新AABB进入时，与活跃集合中所有AABB形成候选对

cpp复制// 简化版扫描线算法流程
vector<Event> events;
for (const AABB& box : boxes) {
    events.emplace_back(box.x_min, box.id, ENTER);
    events.emplace_back(box.x_max, box.id, EXIT);
}
sort(events.begin(), events.end());

unordered_set<int> active_set;
vector<Pair> candidates;

for (const Event& e : events) {
    if (e.type == ENTER) {
        for (int active_id : active_set) {
            candidates.emplace_back(e.id, active_id);
        }
        active_set.insert(e.id);
    } else {
        active_set.erase(e.id);
    }
}

3.2 二维/三维扩展策略

将一维扫描线扩展到更高维度时，通常采用两种策略：

两次过滤法：

1. 第一轮x轴扫描生成候选对
2. 对候选对进行y轴重叠检测
3. （三维情况下）再进行z轴检测

SAP（Sweep and Prune）算法：

• 维护三个独立排序的坐标轴列表（x,y,z）
• 使用增量更新策略保持列表有序
• 只有当三个轴都重叠时才判定为候选对

python复制# 二维扫描线实现示例
def sweep_and_prune(boxes):
    # 生成x轴事件
    events = []
    for i, box in enumerate(boxes):
        events.append((box.x_min, 'start', i))
        events.append((box.x_max, 'end', i))
    
    # 排序事件
    events.sort(key=lambda x: (x[0], 0 if x[1] == 'start' else 1))
    
    active = set()
    x_pairs = set()
    
    for event in events:
        if event[1] == 'start':
            for other in active:
                x_pairs.add(frozenset({event[2], other}))
            active.add(event[2])
        else:
            active.remove(event[2])
    
    # y轴过滤
    final_pairs = []
    for pair in x_pairs:
        a, b = pair
        if boxes[a].y_min <= boxes[b].y_max and boxes[b].y_min <= boxes[a].y_max:
            final_pairs.append((a, b))
    
    return final_pairs

4. 算法复杂度与性能对比

4.1 复杂度分析的金字塔

扫描线算法的性能优势体现在其复杂度曲线上：

实际游戏场景中，由于物体通常不会完全重叠，扫描线表现接近O(N log N)。当配合空间划分时，甚至可以达到接近线性的O(N)性能。

4.2 真实引擎中的性能数据

在Unity物理引擎的测试场景中（2018年数据）：

优化后的扫描线算法（使用SIMD+SoA）相比暴力算法有100-1000倍的性能提升，这正是现代游戏能支持大规模物理模拟的基础。

5. 工程实现的关键优化

5.1 数据布局的革命：SoA vs AoS

数据结构布局对性能的影响常被低估，但实际测试表明差异可达10倍：

AoS（Array of Structures）：

cpp复制struct GameObject {
    float x_min, x_max;
    float y_min, y_max;
    // 其他数十个属性...
};
GameObject objects[10000];

• 缓存不友好：访问x_min时会加载整个结构体
• SIMD不友好：数据不连续，难以向量化

SoA（Structure of Arrays）：

cpp复制struct PhysicsWorld {
    float x_min[10000];
    float x_max[10000];
    float y_min[10000];
    // 其他属性分开存储...
};

• 缓存友好：连续访问同一属性，缓存命中率高
• SIMD友好：数据连续排列，适合批量处理

5.2 SIMD指令的威力

现代CPU的SIMD指令集（如AVX2）可以同时处理8个浮点比较：

cpp复制// 传统标量代码
for (int i = 0; i < count; ++i) {
    if (a_min[i] <= b_max[i] && b_min[i] <= a_max[i]) {
        results[i] = true;
    }
}

// AVX2向量化代码
__m256 threshold = _mm256_set1_ps(0.0f);
for (int i = 0; i < count; i += 8) {
    __m256 a_min_vec = _mm256_load_ps(&a_min[i]);
    __m256 b_max_vec = _mm256_load_ps(&b_max[i]);
    __m256 cmp1 = _mm256_cmp_ps(a_min_vec, b_max_vec, _CMP_LE_OQ);
    
    __m256 b_min_vec = _mm256_load_ps(&b_min[i]);
    __m256 a_max_vec = _mm256_load_ps(&a_max[i]);
    __m256 cmp2 = _mm256_cmp_ps(b_min_vec, a_max_vec, _CMP_LE_OQ);
    
    __m256 result = _mm256_and_ps(cmp1, cmp2);
    _mm256_store_ps(&results[i], result);
}

实测表明，在Intel i7-11800H处理器上，SIMD优化能使扫描线算法的核心检测部分提速3-4倍。

5.3 量化与内存优化

坐标量化：
将浮点坐标映射到整型空间，避免浮点比较的精度问题：

cpp复制int quantize(float value, float min, float max) {
    const int BITS = 16;
    const float scale = (1 << BITS) / (max - min);
    return static_cast<int>((value - min) * scale);
}

内存预取：
主动预取下一批需要处理的数据，减少缓存未命中：

cpp复制for (int i = 0; i < count; i += 8) {
    _mm_prefetch(&data[i + 16], _MM_HINT_T0);
    // 处理当前数据...
}

6. 不同场景下的算法选型

6.1 动态场景 vs 静态场景

动态场景（角色、子弹等）：

• 首选：SAP扫描线算法
• 优势：增量更新效率高（接近O(N)）
• 实现要点：
  • 维护三个排序轴列表
  • 使用插入排序处理小位移
  • 定期全排序防止累积误差

静态场景（地形、建筑）：

• 首选：BVH（层次包围盒树）
• 优势：查询效率高（O(log N)）
• 实现要点：
  • SAH（Surface Area Heuristic）构建策略
  • 采用旋转优化树结构
  • 支持懒更新和部分重建

6.2 混合场景的平衡术

现代游戏引擎通常采用混合策略：

1. 空间划分：
   • 静态物体存入KD-Tree或BVH
   • 动态物体使用扫描线管理
2. 层级检测：
   • 第一层：空间划分粗筛
   • 第二层：扫描线精细管理
3. 线程分工：
   • 主线程：增量更新动态物体
   • 工作线程：静态结构维护和复杂检测

mermaid复制graph TD
    A[碰撞检测系统] --> B{场景类型}
    B -->|动态为主| C[SAP扫描线]
    B -->|静态为主| D[BVH]
    B -->|混合场景| E[分层结构]
    E --> F[静态: BVH]
    E --> G[动态: SAP]
    C --> H[增量更新]
    D --> I[批量构建]

7. 进阶话题与前沿发展

7.1 连续碰撞检测（CCD）

为防止高速物体穿透，CCD计算物体在帧间的运动轨迹：

扫掠体检测：

• 将物体沿运动路径扫掠形成体积
• 检测扫掠体与其他物体的相交
• 适用于简单形状（球体、胶囊体）

时间步进法（TOI）：

python复制def compute_toi(objA, objB, t_start, t_end, threshold):
    while t_end - t_start > threshold:
        t_mid = (t_start + t_end) / 2
        if check_collision_at_time(objA, objB, t_mid):
            t_end = t_mid
        else:
            t_start = t_mid
    return t_end

7.2 GPU加速方案

对于超大规模场景（>10万物体），GPU并行化成为必然选择：

CUDA实现要点：

1. 将AABB数据拷贝到显存
2. 使用网格-块-线程三级并行
3. 原子操作处理候选对收集

cpp复制__global__ void sap_kernel(float* x_mins, float* x_maxs, int* pairs, int n) {
    int i = blockIdx.x * blockDim.x + threadIdx.x;
    if (i >= n) return;
    
    for (int j = i + 1; j < n; j++) {
        bool overlap = (x_mins[i] <= x_maxs[j]) && (x_mins[j] <= x_maxs[i]);
        if (overlap) {
            int idx = atomicAdd(pair_count, 1);
            pairs[2*idx] = i;
            pairs[2*idx+1] = j;
        }
    }
}

7.3 机器学习的新思路

近年来的研究开始探索机器学习在碰撞检测中的应用：

1. 预测候选对：

   • 使用GNN（图神经网络）预测可能碰撞的物体对
   • 减少不必要的精确检测

2. 自适应参数调整：

   • 基于场景特征自动选择最优算法参数
   • 动态调整网格大小或树深度

3. 碰撞概率预测：

   • 对低概率碰撞对延迟检测
   • 实现质量-性能的弹性平衡

8. 实战：手写简化版物理引擎

8.1 核心数据结构设计

cpp复制class PhysicsWorld {
    struct Body {
        uint32_t id;
        float x_min, x_max;
        float y_min, y_max;
        // 其他物理属性...
    };

    std::vector<Body> bodies;
    std::vector<std::pair<uint32_t, uint32_t>> collision_pairs;
    
    // SAP专用数据结构
    struct Edge {
        float position;
        uint32_t body_id;
        bool is_start;
    };
    std::vector<Edge> x_edges;
    std::vector<Edge> y_edges;
};

8.2 SAP算法完整实现

cpp复制void PhysicsWorld::update_sap() {
    // 1. 更新边缘数据
    x_edges.clear();
    y_edges.clear();
    for (const auto& body : bodies) {
        x_edges.push_back({body.x_min, body.id, true});
        x_edges.push_back({body.x_max, body.id, false});
        y_edges.push_back({body.y_min, body.id, true});
        y_edges.push_back({body.y_max, body.id, false});
    }
    
    // 2. 排序边缘（使用lambda自定义比较）
    auto edge_compare = [](const Edge& a, const Edge& b) {
        if (a.position != b.position) 
            return a.position < b.position;
        return a.is_start && !b.is_start; // 开始边缘优先
    };
    std::sort(x_edges.begin(), x_edges.end(), edge_compare);
    std::sort(y_edges.begin(), y_edges.end(), edge_compare);
    
    // 3. x轴扫描
    std::unordered_set<uint32_t> active_x;
    std::unordered_set<std::pair<uint32_t, uint32_t>> x_pairs;
    for (const auto& edge : x_edges) {
        if (edge.is_start) {
            for (uint32_t other : active_x) {
                x_pairs.insert({std::min(edge.body_id, other), 
                               std::max(edge.body_id, other)});
            }
            active_x.insert(edge.body_id);
        } else {
            active_x.erase(edge.body_id);
        }
    }
    
    // 4. y轴扫描验证
    collision_pairs.clear();
    std::unordered_set<uint32_t> active_y;
    std::unordered_map<uint32_t, AABB> body_map;
    for (const auto& body : bodies) {
        body_map[body.id] = {body.x_min, body.x_max, body.y_min, body.y_max};
    }
    
    for (const auto& edge : y_edges) {
        if (edge.is_start) {
            for (uint32_t other : active_y) {
                auto pair = std::make_pair(std::min(edge.body_id, other), 
                                          std::max(edge.body_id, other));
                if (x_pairs.count(pair)) {
                    const auto& a = body_map[pair.first];
                    const auto& b = body_map[pair.second];
                    if (a.y_min <= b.y_max && b.y_min <= a.y_max) {
                        collision_pairs.push_back(pair);
                    }
                }
            }
            active_y.insert(edge.body_id);
        } else {
            active_y.erase(edge.body_id);
        }
    }
}

8.3 性能优化实战

热点分析：

1. 排序操作（占35%时间）
2. 活跃集合遍历（占25%）
3. 候选对验证（占40%）

优化措施：

1. 增量排序：利用帧间连贯性，90%以上的边缘位置变化微小

   cpp复制void incremental_sort(std::vector<Edge>& edges) {
       for (size_t i = 1; i < edges.size(); ++i) {
           Edge key = edges[i];
           int j = i - 1;
           while (j >= 0 && edge_compare(key, edges[j])) {
               edges[j+1] = edges[j];
               j--;
           }
           edges[j+1] = key;
       }
   }
   

2. 并行验证：使用多线程处理y轴验证

   cpp复制std::mutex mtx;
   std::vector<std::pair<uint32_t, uint32_t>> thread_results[THREAD_COUNT];
   
   auto worker = [&](int thread_id, const auto& pairs) {
       for (size_t i = thread_id; i < pairs.size(); i += THREAD_COUNT) {
           const auto& pair = pairs[i];
           const auto& a = body_map[pair.first];
           const auto& b = body_map[pair.second];
           if (a.y_min <= b.y_max && b.y_min <= a.y_max) {
               thread_results[thread_id].push_back(pair);
           }
       }
   };
   

3. 内存池：避免频繁内存分配

   cpp复制ObjectPool<Edge> edge_pool;
   ObjectPool<std::pair<uint32_t, uint32_t>> pair_pool;
   

9. 不同游戏类型的适配策略

9.1 FPS射击游戏

特点：

• 大量高速运动的子弹
• 角色与环境的精确碰撞
• 对延迟敏感（<5ms）

解决方案：

1. 子弹使用特殊的CCD通道
2. 角色-环境分离检测：
   • 环境：预烘焙的BVH
   • 角色：SAP动态管理
3. 伤害检测异步处理

9.2 RTS大规模战斗

特点：

• 数百个单位同时移动
• 群体碰撞响应
• 中等精度要求

解决方案：

1. 分层检测：
   • 单位组级别：粗略空间划分
   • 单个单位：SAP精细管理
2. LOD碰撞体：
   • 远距离：简化碰撞体
   • 近距离：高精度模型
3. 群体行为优化：
   • 群体路径规划减少碰撞可能

9.3 物理解谜游戏

特点：

• 复杂形状的精确交互
• 大量堆叠和接触
• 需要稳定性和准确性

解决方案：

1. 复合碰撞体：
   • 复杂物体分解为简单形状组合
2. 连续检测：
   • 对所有动态物体启用CCD
3. 接触持久化：
   • 缓存接触点减少抖动

10. 性能调优实战手册

10.1 诊断工具链

CPU性能分析：

• VTune：检测热点函数
• LLVM XRay：函数调用跟踪
• perf：Linux下的全能工具

内存分析：

• Heaptrack：堆内存分析
• Cachegrind：缓存命中率检测

可视化工具：

• Chrome Tracing：展示时间线
• Remotery：轻量级GPU/CPU监控

10.2 优化检查清单

1. 数据结构：

   • [ ] 是否使用SoA布局？
   • [ ] 是否有不必要的缓存失效？
   • [ ] 内存访问模式是否连续？

2. 算法：

   • [ ] 是否选择了适合场景的算法？
   • [ ] 能否利用帧间连贯性？
   • [ ] 是否有提前退出的机会？

3. 并行化：

   • [ ] 是否充分利用多核？
   • [ ] 任务划分是否均衡？
   • [ ] 锁竞争是否激烈？

4. 指令集：

   • [ ] 是否启用AVX/NEON？
   • [ ] 分支预测是否友好？
   • [ ] 是否有不必要的依赖链？

10.3 常见陷阱与解决方案

问题1：排序消耗过多时间

• 原因：每帧全排序
• 解决：改用增量排序或基数排序

问题2：候选对验证成为瓶颈

• 原因：y轴检测未优化
• 解决：先快速拒绝明显不重叠的对

问题3：动态物体移动导致频繁更新

• 原因：AABB扩张策略激进
• 解决：采用预测性AABB（根据速度扩展）

问题4：内存带宽受限

• 原因：AoS布局导致低效访问
• 解决：重组为SoA布局，使用SIMD加载

11. 未来展望与进阶学习

11.1 行业发展趋势

1. 硬件加速：

   • GPU通用计算在物理引擎中的应用
   • 专用物理加速硬件（如NVIDIA PhysX PPU）

2. 混合算法：

   • 机器学习辅助的候选对预测
   • 自适应算法选择框架

3. 云端物理：

   • 分布式碰撞检测
   • 延迟敏感的云端协同计算

11.2 推荐学习路径

1. 基础夯实：

   • 《Real-Time Collision Detection》Christer Ericson
   • 《Game Physics Engine Development》Ian Millington

2. 源码研究：

   • Bullet Physics源码（特别是btDbvtBroadphase和btAxisSweep3）
   • Box2D的动态树实现

3. 前沿论文：

   • "Optimized Spatial Hashing for Collision Detection"（2003）
   • "Parallel Continuous Collision Detection for High-Performance GPU Computing"（2020）

4. 实践项目：

   • 实现简化版物理引擎
   • 对比不同算法的性能特性
   • 尝试GPU加速方案

12. 从理论到实践的思维转变

在游戏开发一线工作十余年，我深刻体会到扫描线算法教会我们的不仅是技术本身，更是一种优化思维：

1. 观察比计算重要：算法优化的第一课是发现"大多数检测其实不需要"

2. 有序带来高效：排序的O(N log N)代价常常能换来更大的复杂度降低

3. 局部性决定性能：现代CPU的性能秘密在于缓存，而不只是算法复杂度

4. 增量优于全量：利用时间连贯性往往比推倒重来更高效

5. 适合胜过完美：没有放之四海皆优的算法，只有最适合场景的解决方案

回到那个2003年的游戏崩溃案例，最终的解决方案不是升级硬件，而是改变算法思维——这正是每个程序员都应该内化的核心能力。当你下次面临性能瓶颈时，不妨先问自己：这里是否存在不必要的计算？能否通过排序和结构化来降维打击？