【算法漫谈】GJK 碰撞检测：几何空间的 “精准捕手”

原创于 2025-06-12 10:57:09 发布 · 1.8k 阅读

8 ·

CC 4.0 BY-SA版权

文章标签：

#算法

算法专栏收录该内容

93 篇文章

订阅专栏

一、为何需要 GJK？从游戏中的 “穿墙 BUG” 说起

想象你正在玩一款 3D 动作游戏，角色却离奇穿过墙壁；或是设计机器人路径规划时，机械臂与障碍物 “视而不见”。这些尴尬场景背后，都暴露出碰撞检测的重要性。传统的碰撞检测方法，如逐像素检测或包围盒碰撞检测，要么计算量过大，要么精度不足。而 GJK（Gilbert-Johnson-Keerthi）算法，就像一位几何空间的 “精准捕手”，以高效、精确的特性，成为处理复杂形状碰撞检测的利器，广泛应用于游戏引擎、物理模拟和机器人运动规划等领域。

二、GJK 算法的核心思想：用 “单纯形” 步步逼近

GJK 算法的核心逻辑基于一个简单却巧妙的数学概念 ——单纯形。在二维空间中，单纯形是点、线段或三角形；在三维空间中，则是点、线段、三角形或四面体。GJK 算法通过不断构建和迭代单纯形，逐步逼近两个物体间的最短距离，从而判断它们是否发生碰撞。

具体过程可类比为 “探路寻宝”：

起点选择：从两个物体上各选一个点，构建初始单纯形（一个点）。

方向探索：寻找从单纯形到另一个物体的最远距离方向，沿此方向在两个物体上分别找到对应点，连接这些点，扩展单纯形（从点变为线段）。

迭代优化：重复上述步骤，不断扩展单纯形（从线段变为三角形，再到四面体），每次迭代都让单纯形更接近两个物体间的最短距离。

结果判断：若在某一次迭代中，单纯形包含原点（在以两个物体的相对位置为坐标系的空间中），则说明两个物体发生了碰撞；反之，单纯形与原点的距离即为两个物体间的最短距离。

整个过程如同在黑暗中摸索一条通往目标的道路，通过不断调整方向和路径，最终找到答案。

三、GJK 算法的 Java 实现：从理论到代码

以下是一个简化版的 GJK 算法 Java 实现，用于演示核心逻辑（实际应用中需根据具体需求优化和扩展）：


import java.util.ArrayList;
import java.util.List;

// 三维向量类
class Vector3 {
    double x, y, z;

    public Vector3(double x, double y, double z) {
        this.x = x;
        this.y = y;
        this.z = z;
    }

    // 向量加法
    public Vector3 add(Vector3 other) {
        return new Vector3(x + other.x, y + other.y, z + other.z);
    }

    // 向量减法
    public Vector3 subtract(Vector3 other) {
        return new Vector3(x - other.x, y - other.y, z - other.z);
    }

    // 向量点乘
    public double dot(Vector3 other) {
        return x * other.x + y * other.y + z * other.z;
    }

    // 向量长度
    public double magnitude() {
        return Math.sqrt(x * x + y * y + z * z);
    }

    // 归一化向量
    public Vector3 normalize() {
        double mag = magnitude();
        return new Vector3(x / mag, y / mag, z / mag);
    }
}

// 单纯形节点类
class SimplexNode {
    Vector3 a;
    Vector3 b;

    public SimplexNode(Vector3 a, Vector3 b) {
        this.a = a;
        this.b = b;
    }
}

// GJK算法类
class GJK {
    // 获取闵可夫斯基差集在某方向上的支持点
    private static Vector3 getSupportPoint(List<Vector3> shapeA, List<Vector3> shapeB, Vector3 direction) {
        Vector3 furthestA = null;
        double maxDotA = Double.NEGATIVE_INFINITY;
        for (Vector3 point : shapeA) {
            double dot = point.dot(direction);
            if (dot > maxDotA) {
                maxDotA = dot;
                furthestA = point;
            }
        }

        Vector3 furthestB = null;
        double maxDotB = Double.NEGATIVE_INFINITY;
        for (Vector3 point : shapeB) {
            double dot = point.dot(direction.negate());
            if (dot > maxDotB) {
                maxDotB = dot;
                furthestB = point;
            }
        }

        return furthestA.subtract(furthestB);
    }

    // 判断两个形状是否发生碰撞
    public static boolean gjkCollision(List<Vector3> shapeA, List<Vector3> shapeB) {
        List<SimplexNode> simplex = new ArrayList<>();
        Vector3 direction = new Vector3(1, 0, 0); // 初始方向

        Vector3 support = getSupportPoint(shapeA, shapeB, direction);
        if (support.dot(direction) <= 0) {
            return false; // 无碰撞
        }

        simplex.add(new SimplexNode(support, null));

        direction = support.negate();

        while (true) {
            support = getSupportPoint(shapeA, shapeB, direction);
            if (support.dot(direction) <= 0) {
                return false; // 无碰撞
            }

            simplex.add(new SimplexNode(support, null));

            if (simplex.size() == 2) {
                // 二维单纯形（线段）处理
                Vector3 ab = simplex.get(0).a.subtract(simplex.get(1).a);
                Vector3 ao = simplex.get(1).a.negate();

                double dotABAO = ab.dot(ao);
                if (dotABAO <= 0) {
                    // 原点在线段AB的A侧
                    simplex.remove(0);
                    direction = ao;
                } else {
                    // 原点在线段AB的B侧
                    Vector3 abNorm = ab.normalize();
                    double projLength = abNorm.dot(ao);
                    if (projLength <= ab.magnitude()) {
                        // 原点在线段AB上
                        direction = ao.subtract(abNorm.multiply(projLength));
                    } else {
                        // 原点在线段AB的B外侧
                        simplex.remove(1);
                        direction = ao;
                    }
                }
            } else if (simplex.size() == 3) {
                // 三维单纯形（三角形）处理，此处简化未完整实现
                // 需根据三角形与原点的位置关系更新单纯形和方向
                return true; // 假设三角形情况直接认为碰撞
            }
        }
    }
}

你可以使用以下方式测试：


public class Main {
    public static void main(String[] args) {
        List<Vector3> shapeA = new ArrayList<>();
        shapeA.add(new Vector3(0, 0, 0));
        shapeA.add(new Vector3(1, 0, 0));
        shapeA.add(new Vector3(0, 1, 0));

        List<Vector3> shapeB = new ArrayList<>();
        shapeB.add(new Vector3(0.5, 0.5, 0));
        shapeB.add(new Vector3(1.5, 0.5, 0));
        shapeB.add(new Vector3(0.5, 1.5, 0));

        boolean isColliding = GJK.gjkCollision(shapeA, shapeB);
        System.out.println("Are shapes colliding? " + isColliding);
    }
}