AABB求交 slab算法

核心思路，轻量化场景时替换射线：

 function intersectUnitCube(ray) {
        const min = -0.5;
        const max = 0.5;
        let tMin = -Infinity;
        let tMax = Infinity;
        let entryAxis = -1;
        let entrySign = 0;
        let exitAxis = -1;
        let exitSign = 0;

        for (let axis = 0; axis < 3; axis += 1) {
          const origin = ray.origin.getComponent(axis);
          const direction = ray.direction.getComponent(axis);

          if (Math.abs(direction) < 1e-8) {
            if (origin < min || origin > max) return null;
            continue;
          }

          let near = (min - origin) / direction;
          let far = (max - origin) / direction;
          let nearSign = -1;
          let farSign = 1;
          console.log((near - far) * direction, direction);
          if (near > far) {
            [near, far] = [far, near];
            [nearSign, farSign] = [farSign, nearSign];
          }

          if (near > tMin) {
            tMin = near;
            entryAxis = axis;
            entrySign = nearSign;
          }

          if (far < tMax) {
            tMax = far;
            exitAxis = axis;
            exitSign = farSign;
          }

          if (tMin > tMax) return null;
        }

        const t = tMin >= 0 ? tMin : tMax;
        if (t < 0) return null;
        const axis = tMin >= 0 ? entryAxis : exitAxis;
        const sign = tMin >= 0 ? entrySign : exitSign;

        return {
          distance: t,
          faceIndex: faceIndexFromAxisSign(axis, sign),
          point: ray.at(t, tempVectorC),
        };
      }

求面：

  function faceIndexFromAxisSign(axis, sign) {
        if (axis === 0) return sign > 0 ? 2 : 3;
        if (axis === 1) return sign > 0 ? 4 : 5;
        return sign > 0 ? 0 : 1;
      }