【C++碰撞检测实现秘籍】：揭秘高效物理引擎背后的算法核心

第一章：C++碰撞检测技术概述

在游戏开发、物理仿真和机器人路径规划等领域，碰撞检测是确保对象交互行为真实可信的核心技术之一。C++因其高性能与底层控制能力，成为实现高效碰撞检测系统的首选语言。该技术主要目标是判断两个或多个几何体在空间中是否发生重叠，并据此触发相应逻辑，如反弹、停止或伤害计算。

基本原理与应用场景

碰撞检测通常分为粗测（Broad Phase）和精测（Narrow Phase）。粗测用于快速排除明显不相交的对象对，常用方法包括空间分割（如四叉树、八叉树）和扫描线算法；精测则对潜在碰撞对象进行精确几何判断，常见于点、线、面之间的关系运算。

常见几何体检测方式

以下为轴对齐包围盒（AABB）之间的简单碰撞检测代码示例：

// 判断两个AABB是否发生碰撞
struct AABB {
    float minX, maxX;
    float minY, maxY;
};

bool checkCollision(const AABB& a, const AABB& b) {
    return (a.minX <= b.maxX && a.maxX >= b.minX) &&
           (a.minY <= b.maxY && a.maxY >= b.minY);
}

上述函数通过比较边界范围判断矩形是否重叠，适用于2D场景中的快速检测。

常用算法对比

算法类型	适用场景	时间复杂度
AABB	静态或动态简单物体	O(1)
分离轴定理（SAT）	凸多边形碰撞	O(n+m)
GJK	高维凸体	O(log n)

• 实时性要求高的系统常结合多种策略分阶段处理
• 使用空间索引结构可显著减少检测对数
• 浮点精度问题需特别注意，避免误判

第二章：基础碰撞检测算法实现

2.1 轴对齐包围盒（AABB）的理论与C++实现

轴对齐包围盒（Axis-Aligned Bounding Box, AABB）是一种广泛应用于碰撞检测的基础几何结构，其边与坐标轴平行，具有计算简单、判断高效的特点。

数据结构设计

AABB由最小点和最大点定义空间范围，适用于快速排除不相交物体。以下为C++实现：

struct Vector3 {
    float x, y, z;
};

struct AABB {
    Vector3 min;
    Vector3 max;

    bool intersects(const AABB& other) const {
        return min.x <= other.max.x && max.x >= other.min.x &&
               min.y <= other.max.y && max.y >= other.min.y &&
               min.z <= other.max.z && max.z >= other.min.z;
    }
};

该结构体通过intersects方法判断两个AABB是否相交，每轴方向上的区间重叠是相交的必要条件。函数逻辑简洁，仅需6次比较即可完成判定，适合高频调用的物理引擎或渲染剔除系统。

2.2 圆形与球体碰撞检测的数学模型与代码优化

在二维与三维空间中，圆形与球体的碰撞检测依赖于距离判据。若两圆心间距小于半径之和，则发生碰撞。该逻辑可统一表达为欧几里得距离公式。

数学模型基础

设两个球体中心分别为 $ \mathbf{c_1} $ 和 $ \mathbf{c_2} $，半径为 $ r_1 $ 和 $ r_2 $，则碰撞条件为： $$ \|\mathbf{c_1} - \mathbf{c_2}\| \leq r_1 + r_2 $$

高效实现示例

bool checkSphereCollision(
    const Vec3& c1, float r1,
    const Vec3& c2, float r2) {
    float dx = c1.x - c2.x;
    float dy = c1.y - c2.y;
    float dz = c1.z - c2.z;
    float distSq = dx*dx + dy*dy + dz*dz; // 避免开方
    float sumRadius = r1 + r2;
    return distSq <= sumRadius * sumRadius;
}

通过比较距离平方而非实际距离，避免了耗时的 sqrt() 运算，显著提升性能。参数 c1、c2 为三维坐标向量，r1、r2 为对应半径，函数返回布尔值表示是否发生碰撞。

2.3 分离轴定理（SAT）在多边形碰撞中的应用

分离轴定理（Separating Axis Theorem, SAT）是判断两个凸多边形是否发生碰撞的核心算法之一。其基本原理是：若存在一条轴，使得两个多边形在此轴上的投影不重叠，则这两个多边形不相交。

核心判定逻辑

对于每对凸多边形，需检测所有可能的分离轴——即每个边的法向量方向。若在所有轴上的投影均重叠，则判定为碰撞。

• 仅适用于凸多边形
• 需归一化投影轴向量
• 投影通过点积计算顶点在轴上的坐标

function projectPolygon(vertices, axis) {
  let min = dot(vertices[0], axis);
  let max = min;
  for (let i = 1; i < vertices.length; i++) {
    const p = dot(vertices[i], axis);
    if (p < min) min = p;
    if (p > max) max = p;
  }
  return { min, max };
}

上述代码计算多边形在指定轴上的投影区间。参数 `vertices` 为顶点数组，`axis` 为单位法向量。通过点积获取各顶点在轴上的标量投影，返回最小和最大值构成的区间，用于后续重叠判断。

2.4 射线与几何体交点检测的高效实现策略

在实时渲染与物理仿真中，射线与几何体的交点检测是核心运算之一。为提升性能，需结合数学优化与空间数据结构。

包围盒预筛选

采用轴对齐包围盒（AABB）进行初步剔除，大幅减少精确检测次数：

• 先判断射线是否与AABB相交
• 仅当通过测试时才进入三角面片级检测

向量化解析计算

使用Möller-Trumbore算法高效求解射线与三角形交点：

bool rayTriangleIntersect(const Vec3 &ro, const Vec3 &rd, 
                          const Vec3 &v0, const Vec3 &v1, const Vec3 &v2,
                          float &t, float &u, float &v) {
    Vec3 edge1 = v1 - v0, edge2 = v2 - v0;
    Vec3 pvec = cross(rd, edge2);
    float det = dot(edge1, pvec);
    if (fabs(det) < EPS) return false;
    float inv_det = 1.0f / det;
    Vec3 tvec = ro - v0;
    u = dot(tvec, pvec) * inv_det;
    if (u < 0 || u > 1) return false;
    Vec3 qvec = cross(tvec, edge1);
    v = dot(rd, qvec) * inv_det;
    if (v < 0 || u + v > 1) return false;
    t = dot(edge2, qvec) * inv_det;
    return t > EPS;
}

该函数通过叉积与点积联合判定交点参数 t、u、v，避免开方运算，显著提升计算效率。

2.5 碰撞响应与最小穿透向量的计算实践

在物理引擎中，碰撞响应的核心是分离重叠物体并施加合理力。最小穿透向量（Minimum Translation Vector, MTV）提供了将两物体刚好分离所需的最短位移。

MTV 的计算逻辑

通过分离轴定理（SAT）检测到碰撞后，需记录所有投影轴上的穿透深度，选择最小穿透值对应的轴作为MTV方向。

struct Vector2 {
    float x, y;
};

// 计算两个AABB之间的MTV
Vector2 calculateMTV(const AABB& a, const AABB& b) {
    float overlapX = std::min(a.max.x, b.max.x) - std::max(a.min.x, b.min.x);
    float overlapY = std::min(a.max.y, b.max.y) - std::max(a.min.y, b.min.y);

    if (overlapX > 0 && overlapY > 0) {
        return (std::abs(overlapX) < std::abs(overlapY)) ?
               Vector2{overlapX, 0} : Vector2{0, overlapY};
    }
    return {0, 0}; // 无重叠
}

该函数返回最小穿透方向和距离。若X轴穿透更小，则沿X轴调整位置，反之亦然，确保物体快速分离而不嵌入。

第三章：空间划分技术加速碰撞检测

3.1 网格哈希表在大规模对象管理中的C++实现

在处理大规模动态对象时，传统哈希表面临空间浪费与查询效率下降的问题。网格哈希表通过将空间划分为固定大小的网格单元，结合哈希映射机制，显著提升对象定位速度。

核心数据结构设计

采用二维网格索引与桶式哈希结合的方式，每个网格对应一个对象链表：

struct GridCell {
    std::vector objects;
};
std::unordered_map gridMap;
// 哈希键由坐标(x,y)映射：key = x * stride + y

其中，int64_t 键由世界坐标的行列号生成，避免浮点精度误差，stride 通常取2^20以保证唯一性。

性能对比

方案	插入延迟(μs)	查询速度
全局哈希表	120	O(n)
网格哈希表	35	O(k), k≪n

3.2 四叉树与八叉树的构建与查询性能对比

在空间索引结构中，四叉树适用于二维场景，八叉树扩展至三维，二者在构建复杂度与查询效率上存在显著差异。

构建时间与空间开销

随着节点数量增加，八叉树因每层最多划分8个子节点，树高增长慢但单层分支多，导致内存占用更高。四叉树在二维平面中划分更紧凑，构建速度通常更快。

查询性能对比

struct Octant {
    BoundingBox bounds;
    vector objects;
    vector children;
    
    bool intersect(const Ray& ray) {
        return bounds.intersects(ray);
    }
};

上述八叉树节点实现中，包围盒判断是查询关键。由于八叉树深度较浅，射线相交查询平均访问节点数更少，理论上查询更快，但需更多内存支持。

结构	维数	平均查询时间	内存占用
四叉树	2D	O(log₄N)	较低
八叉树	3D	O(log₈N)	较高

3.3 动态场景下空间索引的更新与内存优化

在高频更新的动态环境中，传统静态空间索引结构面临性能瓶颈。为提升实时性，采用增量式更新策略替代全量重建，显著降低计算开销。

惰性更新机制

通过延迟非关键节点的结构调整，减少锁竞争与内存分配频率。仅在查询精度下降至阈值时触发批量优化。

// UpdateEntry 增量更新空间对象位置
func (tree *RStarTree) UpdateEntry(id string, newBox Box) {
    oldNode := tree.findLeaf(newBox)
    if oldNode != nil && oldNode.box.Contains(newBox) {
        oldNode.updateEntry(id, newBox) // 就地修改
    } else {
        tree.Delete(id)
        tree.Insert(id, newBox)
    }
}

该方法优先尝试局部更新，避免频繁的插入删除操作，提升缓存命中率。

内存池复用策略

使用预分配内存池管理节点对象，减少GC压力。常见配置如下：

参数	说明
poolSize	初始池容量，通常设为预期峰值节点数的70%
growthRate	扩容倍数，推荐1.5以平衡内存与性能

第四章：复杂形状与连续碰撞检测

4.1 GJK算法原理及其在凸体检测中的C++实现

GJK（Gilbert-Johnson-Keerthi）算法是一种高效判断两个凸体是否相交的几何算法，核心思想是通过闵可夫斯基差构造单纯形，并迭代寻找包含原点的最小单纯形。

算法基本流程

• 从初始方向开始，寻找两凸体在该方向上的最远点差
• 更新单纯形并计算最接近原点的方向
• 若新点无法更接近原点，则判定不相交

C++实现关键代码

struct Vector3 {
    float x, y, z;
    Vector3 operator-(const Vector3& b) const { return {x-b.x, y-b.y, z-b.z}; }
    float dot(const Vector3& b) const { return x*b.x + y*b.y + z*b.z; }
};

Vector3 support(const std::vector<Vector3>& a, const std::vector<Vector3>& b, Vector3 d) {
    auto farthest = [](const std::vector<Vector3>& verts, Vector3 d) {
        return *std::max_element(verts.begin(), verts.end(),
            [d](const Vector3& a, const Vector3& b) { return a.dot(d) < b.dot(d); });
    };
    return farthest(a, d) - farthest(b, -d);
}

上述代码定义了三维向量操作与支持函数。support函数在闵可夫斯基差中查找沿方向d的最远点，为GJK迭代提供基础。dot表示点积，用于方向投影比较。

4.2 EPA算法解析与穿透深度计算实战

EPA（Expanding Polytope Algorithm）是碰撞检测中用于精确计算穿透深度的核心算法，常用于GJK算法检测到相交后进一步求解分离方向与最小穿透量。

算法核心流程

• 从GJK生成的单纯形出发，在多面体上逐步扩展顶点
• 寻找当前多面体中最接近原点的面
• 通过迭代添加新顶点逼近最优穿透方向

穿透深度计算示例

Vector3 EPA::getPenetrationDepth(const Simplex& simplex) {
    // 初始化多面体网格
    initializePolytope(simplex);
    while (iterations < MAX_ITER) {
        Face* closestFace = findClosestFaceToOrigin();
        Vector3 supportPoint = supportFunction(closestFace->normal);
        real distance = dot(supportPoint, closestFace->normal);
        if (distance - closestFace->distance < EPSILON)
            return { closestFace->normal, distance };
        addSupportPoint(supportPoint);
    }
}

上述代码段中，findClosestFaceToOrigin定位最近面，supportFunction在指定方向获取支撑点，通过距离差判断收敛条件，最终返回法向与穿透深度。

4.3 时间步进下的连续碰撞检测（CCD）防穿透机制

在高速运动物体的物理仿真中，离散时间步进常导致物体“跳过”碰撞过程，引发穿透问题。连续碰撞检测（CCD）通过追踪物体在时间步内的运动轨迹，有效防止此类现象。

基于扫掠体积的碰撞预测

CCD通过计算物体从当前帧到下一帧的运动路径，判断是否与障碍物发生交集。常见方法包括扫掠球、扫掠AABB等。

• 扫掠AABB：沿速度方向扩展包围盒形成柱状区域
• 时间区间求交：求解两个扫掠体最早接触时间点（TOI）

代码实现示例

struct CCDResult {
    bool hasCollision;
    float timeOfImpact;
};

CCDResult checkSweptAABB(const AABB& a, const Vec3& va, const AABB& b) {
    // 计算A沿va移动时与B的最早碰撞时间
    float tMin = 0.0f, tMax = 1.0f;
    for (int axis = 0; axis < 3; axis++) {
        if (va[axis] == 0) continue;
        float inv = 1.0f / va[axis];
        float t1 = (b.min[axis] - a.max[axis]) * inv;
        float t2 = (b.max[axis] - a.min[axis]) * inv;
        tMin = std::max(tMin, std::min(t1, t2));
        tMax = std::max(tMax, std::max(t1, t2));
    }
    return { tMin <= tMax, tMin };
}

该函数通过分离轴定理计算两AABB在移动过程中的最早交集时间。若tMin ≤ tMax且tMin ∈ [0,1]，则发生碰撞。va为相对速度，返回值用于提前终止积分或调整位置。

4.4 多阶段碰撞检测架构设计与性能调优

在高性能物理仿真系统中，多阶段碰撞检测通过分层过滤机制显著降低计算复杂度。首先采用轴对齐包围盒（AABB）树进行粗检，快速剔除无交集的物体对。

粗测阶段：AABB 树遍历

struct AABB {
    Vector3 min, max;
    bool intersects(const AABB& other) const {
        return min.x <= other.max.x && max.x >= other.min.x &&
               min.y <= other.max.y && max.y >= other.min.y &&
               min.z <= other.max.z && max.z >= other.min.z;
    }
};

该结构通过六次比较判断包围盒是否相交，时间复杂度为 O(1)，适合大规模预筛。

精测优化策略

• 使用空间哈希划分场景，减少潜在碰撞对数量
• 引入时间相干性缓存上一帧的接触点信息
• 基于距离场的细测算法提升曲面检测精度

结合批量处理与SIMD指令优化，整体性能提升达3倍以上。

第五章：总结与物理引擎集成展望

实际应用中的性能优化策略

在高并发模拟场景中，物理引擎的计算负载往往成为瓶颈。通过空间分区（如四叉树）减少碰撞检测复杂度，可显著提升性能。例如，在Unity中结合ECS架构与Job System进行并行处理：

[BurstCompile]
struct CollisionJob : IJobParallelFor
{
    public NativeArray positions;
    public void Execute(int index)
    {
        // 并行执行碰撞检测逻辑
        for (int i = index + 1; i < positions.Length; i++)
        {
            float dist = Vector3.Distance(positions[index], positions[i]);
            if (dist < 1.0f) HandleCollision(index, i);
        }
    }
}

跨平台物理中间件选型建议

不同项目需求对物理引擎的精度、性能和扩展性提出差异化要求。以下是主流引擎对比：

引擎	适用平台	特点	集成难度
Bullet Physics	PC, Mobile, VR	开源，支持软体动力学	中等
NVIDIA PhysX	PC, Console, UE	GPU加速，丰富工具链	低（UE内置）
Box2D	2D游戏，移动端	轻量，稳定	低

未来集成方向：实时物理与AI协同仿真

将物理引擎与机器学习训练环境结合，已成为强化学习领域的重要趋势。例如使用PyTorch连接MuJoCo进行机器人控制训练，通过物理精确模拟提供真实反馈信号。此类系统要求低延迟数据交换，常采用共享内存或gRPC实现进程间通信。