• • 1）如果您只想知道直线 * 是否 * 与三角形相交（不需要实际交点）：**

设p1,p2,p3表示三角形
在两个方向上都非常远的直线上选择两个点q1,q2。
设SignedVolume(a,b,c,d)表示四面体a，b，c，d的有符号体积。
如果SignedVolume(q1,p1,p2,p3)和SignedVolume(q2,p1,p2,p3)具有不同的符号，并且SignedVolume(q1,q2,p1,p2)、SignedVolume(q1,q2,p2,p3)和SignedVolume(q1,q2,p3,p1)具有相同的符号，则存在交集。

SignedVolume(a,b,c,d) = (1.0/6.0)*dot(cross(b-a,c-a),d-a)

• • 2）现在，如果您需要交点，当1）中的测试通过时**

以参数形式写出直线方程：p(t) = q1 + t*(q2-q1)
写出平面的方程：dot(p-p1,N) = 0其中

N = cross(p2-p1, p3-p1)

将p(t)代入平面方程：x1米11米1x
展开：dot(q1-p1,N) + t dot(q2-q1,N) = 0
推导t = -dot(q1-p1,N)/dot(q2-q1,N)
交点为q1 + t*(q2-q1)

• • 3）更有效的算法**

我们现在研究算法：
Möller和Trumbore，"快速、最小存储的光线-三角形相交"，图形工具杂志，第2卷，1997年，第21 - 28页（另请参见：https://en.wikipedia.org/wiki/M%C3%B6ller%E2%80%93Trumbore_intersection_algorithm）
这个算法最终要简单一些（比1）和2）中的指令少一些），但要理解起来稍微复杂一些，让我们一步一步地推导它。
符号：

• O =射线的原点，
• D =射线的方向矢量，
• A,B,C =三角形的顶点

射线上的任意点P可以写成P = O + tD
三角形上的任意点P可以被写为P = A + uE1 + vE2，其中E1 = B-A和E2 = C-A, u>=0, v>=0和(u+v)<=1
写出P的两个表达式得到：

O + tD = A + uE1 + vE2

或：

uE1 + vE2 -tD = O-A

矩阵形式：

[u]
 [E1|E2|-D] [v] = O-A
            [t]

（其中[E1|第二代|- D]是列为E1、E2、-D的3x3矩阵）
使用Cramer公式求解：

[a11 a12 a13][x1]   [b1]
   [a12 a22 a23][x2] = [b2]
   [a31 a32 a33][x3]   [b3]

给出：

|b1 a12 a13|   |a11 a12 a13|
  x1 = |b2 a22 a23| / |a21 a22 a23|
       |b3 a32 a33|   |a31 a32 a33|

       |a11 b1 a13|   |a11 a12 a13|
  x2 = |a21 b2 a23| / |a21 a22 a23|
       |a31 b3 a33|   |a31 a32 a33|

       |a11 a12 b1|   |a11 a12 a13|
  x3 = |a21 a22 b2| / |a21 a22 a23|
       |a31 a32 b3|   |a31 a32 a33|

现在我们得到：

u = (O-A,E2,-D) / (E1,E2,-D)
  v = (E1,O-A,-D) / (E1,E2,-D)
  t = (E1,E2,O-A) / (E1,E2,-D)

其中（A，B，C）表示以A，B，C作为其列向量的3x3矩阵的行列式。
现在我们使用以下标识：

(A,B,C) = dot(A,cross(B,C))  (develop the determinant w.r.t. first column)

  (B,A,C) = -(A,B,C)           (swapping two vectors changes the sign)

  (B,C,A) =  (A,B,C)           (circular permutation does not change the sign)

现在我们得到：

u = -(E2,O-A,D)  / (D,E1,E2)
v =  (E1,O-A,D)  / (D,E1,E2)
t = -(O-A,E1,E2) / (D,E1,E2)

使用：

N=cross(E1,E2);

AO = O-A; 

DAO = cross(D,AO)

我们最终获得以下代码（此处为GLSL，易于翻译为其他语言）：

bool intersect_triangle(
    in Ray R, in vec3 A, in vec3 B, in vec3 C, out float t, 
    out float u, out float v, out vec3 N
) { 
   vec3 E1 = B-A;
   vec3 E2 = C-A;
         N = cross(E1,E2);
   float det = -dot(R.Dir, N);
   float invdet = 1.0/det;
   vec3 AO  = R.Origin - A;
   vec3 DAO = cross(AO, R.Dir);
   u =  dot(E2,DAO) * invdet;
   v = -dot(E1,DAO) * invdet;
   t =  dot(AO,N)  * invdet; 
   return (det >= 1e-6 && t >= 0.0 && u >= 0.0 && v >= 0.0 && (u+v) <= 1.0);
}

当函数返回true时，交点由R.Origin + t * R.Dir给出。三角形中交点的重心坐标为u，v，1-u-v（对Gouraud着色或纹理Map很有用）。好的是你可以免费得到它们!
注意代码是无分支的。它被我的一些着色器在ShaderToy上使用

• https://www.shadertoy.com/view/tl3XRN
• https://www.shadertoy.com/view/3ltSzM

@BrunoLevi：你的算法好像不起作用，看下面的python实现：

def intersect_line_triangle(q1,q2,p1,p2,p3):
    def signed_tetra_volume(a,b,c,d):
        return np.sign(np.dot(np.cross(b-a,c-a),d-a)/6.0)

    s1 = signed_tetra_volume(q1,p1,p2,p3)
    s2 = signed_tetra_volume(q2,p1,p2,p3)

    if s1 != s2:
        s3 = signed_tetra_volume(q1,q2,p1,p2)
        s4 = signed_tetra_volume(q1,q2,p2,p3)
        s5 = signed_tetra_volume(q1,q2,p3,p1)
        if s3 == s4 and s4 == s5:
            n = np.cross(p2-p1,p3-p1)
            t = -np.dot(q1,n-p1) / np.dot(q1,q2-q1)
            return q1 + t * (q2-q1)
    return None

我的测试代码是：

q0 = np.array([0.0,0.0,1.0])
q1 = np.array([0.0,0.0,-1.0])
p0 = np.array([-1.0,-1.0,0.0])
p1 = np.array([1.0,-1.0,0.0])
p2 = np.array([0.0,1.0,0.0])

print(intersect_line_triangle(q0,q1,p0,p1,p2))

给出：

[ 0.  0. -3.]

而不是预期的

[ 0.  0. 0.]

看着这条线

t = np.dot(q1,n-p1) / np.dot(q1,q2-q1)

从法线减去p1对我来说没有意义，你想从q1投影到三角形的平面上，所以你需要沿着法线投影，投影距离正比于q1到平面的距离和q1-q2沿着法线的距离的比值，对吗？
以下代码修复了此问题：

n = np.cross(p2-p1,p3-p1)
t = np.dot(p1-q1,n) / np.dot(q2-q1,n)
return q1 + t * (q2-q1)

若要在3D中查找直线和三角形之间的交点，请遵循以下方法：

• 计算支撑三角形的平面，
• 将直线与支撑三角形的平面相交：
• 如果没有交点，那么与三角形也没有交点。
• 如果存在交点，请验证交点是否确实位于三角形中：
• 三角形的每条边与支撑三角形的平面的法线一起确定界定三角形内部的半空间（可以从法线和边顶点导出对应的界定平面），
• 确认交点位于所有边半空间的内侧。

下面是一些示例代码，其中包含应该可以工作的详细计算：

// Compute the plane supporting the triangle (p1, p2, p3)
//     normal: n
//     offset: d
//
// A point P lies on the supporting plane iff n.dot(P) + d = 0
//
ofVec3f v21 = p2 - p1;
ofVec3f v31 = p3 - p1;

ofVec3f n = v21.getCrossed(v31);
float d = -n.dot(p1);

// A point P belongs to the line from P1 to P2 iff
//     P = P1 + t * (P2 - P1)
//
// Find the intersection point P(t) between the line and
// the plane supporting the triangle:
//     n.dot(P) + d = 0
//                  = n.dot(P1 + t (P2 - P1)) + d
//                  = n.dot(P1) + t n.dot(P2 - P1) + d
//
//     t = -(n.dot(P1) + d) / n.dot(P2 - P1)
//
ofVec3f P21 = P2 - P1;
float nDotP21 = n.dot(P21);

// Ignore line parallel to (or lying in) the plane
if (fabs(nDotP21) < Epsilon)
    return false;

float t = -(n.dot(P1) + d) / nDotP21;
ofVec3f P = P1 + t * P21;

// Plane bounding the inside half-space of edge (p1, p2): 
//     normal: n21 = n x (p2 - p1)
//     offset: d21 = -n21.dot(p1)
//
// A point P is in the inside half-space iff n21.dot(P) + d21 > 0
//

// Edge (p1, p2)
ofVec3f n21 = n.cross(v21);
float d21 = -n21.dot(p1);

if (n21.dot(P) + d21 <= 0)
    return false;

// Edge (p2, p3)
ofVec3f v32 = p3 - p2;
ofVec3f n32 = n.cross(v32);
float d32 = -n32.dot(p2);

if (n32.dot(P) + d32 <= 0)
    return false;

// Edge (p3, p1)
ofVec3f n13 = n.cross(-v31);
float d13 = -n13.dot(p3);

if (n13.dot(P) + d13 <= 0)
    return false;

return true;

对随问题发布的代码的一些评论：

• ofVec3f的预定义运算（几何积的.dot()和.cross()等）应优先使用（可读性更强、避免实现错误等），
• 代码最初遵循上述方法，但随后仅检查交点是否在线段[P1，P2]的3D轴对齐边界框中。这与其他可能的错误结合起来可以解释结果不正确的原因。
• 可以验证交点是否在（整个）三角形的3D轴对齐边界框中。虽然这不足以保证相交，但它可以用于剔除明显不相交的点，并避免进一步的复杂计算。

我有一个不同的方法来做这件事，我发现在我的渲染器是远远快于第一种方式由BrunoLevy。（我还没有实现第二种方式）
点A、B、C是三角形的顶点
O是射线的原点
D是射线的方向（不需要规格化，只是比三角形更靠近原点）
检查方向（D+O）是否在四面体A、B、C、O内部

bool SameSide(vec3 A, vec3 B, vec3 C, vec3 D, vec3 p)
{
    vec3 normal = cross(B - A, C - A);
    float dotD = dot(normal, D - A);
    float dotP = dot(normal, p - A);
    return signbit(dotD) == signbit(dotP);
}

bool LineIntersectTri(vec3 A, vec3 B, vec3 C, vec3 O, vec3 D)
{
    return SameSide(A, B, C, O, O+D) &&
           SameSide(B, C, O, A, O+D) &&
           SameSide(C, O, A, B, O+D) &&
           SameSide(O, A, B, C, O+D);               
}

如果D变化，而其他一切保持不变（例如在光线投射渲染器中），那么normal和dotP不需要重新计算;这就是为什么我发现它这么快
代码来自此答案https://stackoverflow.com/a/25180294/18244401