triangle_intersect_x4.glsl

    else if (aData.x < 0) // leaf node (containg triangles)
    {
      ivec4 aTrg0 = texelFetch (uGeometryTriangTexture, (aData.y + 0) + TRG_OFFSET (aSubTree));
      ivec4 aTrg1 = texelFetch (uGeometryTriangTexture, (aData.y + 1) + TRG_OFFSET (aSubTree));
      ivec4 aTrg2 = texelFetch (uGeometryTriangTexture, (aData.y + 2) + TRG_OFFSET (aSubTree));
      ivec4 aTrg3 = texelFetch (uGeometryTriangTexture, (aData.y + 3) + TRG_OFFSET (aSubTree));

      vec3 aTrg0Vrt0 = texelFetch (uGeometryVertexTexture, aTrg0.x += VRT_OFFSET (aSubTree)).xyz;
      vec3 aTrg0Vrt1 = texelFetch (uGeometryVertexTexture, aTrg0.y += VRT_OFFSET (aSubTree)).xyz;
      vec3 aTrg0Vrt2 = texelFetch (uGeometryVertexTexture, aTrg0.z += VRT_OFFSET (aSubTree)).xyz;
      vec3 aTrg1Vrt0 = texelFetch (uGeometryVertexTexture, aTrg1.x += VRT_OFFSET (aSubTree)).xyz;
      vec3 aTrg1Vrt1 = texelFetch (uGeometryVertexTexture, aTrg1.y += VRT_OFFSET (aSubTree)).xyz;
      vec3 aTrg1Vrt2 = texelFetch (uGeometryVertexTexture, aTrg1.z += VRT_OFFSET (aSubTree)).xyz;
      vec3 aTrg2Vrt0 = texelFetch (uGeometryVertexTexture, aTrg2.x += VRT_OFFSET (aSubTree)).xyz;
      vec3 aTrg2Vrt1 = texelFetch (uGeometryVertexTexture, aTrg2.y += VRT_OFFSET (aSubTree)).xyz;
      vec3 aTrg2Vrt2 = texelFetch (uGeometryVertexTexture, aTrg2.z += VRT_OFFSET (aSubTree)).xyz;
      vec3 aTrg3Vrt0 = texelFetch (uGeometryVertexTexture, aTrg3.x += VRT_OFFSET (aSubTree)).xyz;
      vec3 aTrg3Vrt1 = texelFetch (uGeometryVertexTexture, aTrg3.y += VRT_OFFSET (aSubTree)).xyz;
      vec3 aTrg3Vrt2 = texelFetch (uGeometryVertexTexture, aTrg3.z += VRT_OFFSET (aSubTree)).xyz;

      vec3 aTrg0Edge0 = aTrg0Vrt1 - aTrg0Vrt0;
      vec3 aTrg0Edge1 = aTrg0Vrt0 - aTrg0Vrt2;
      vec3 aTrg1Edge0 = aTrg1Vrt1 - aTrg1Vrt0;
      vec3 aTrg1Edge1 = aTrg1Vrt0 - aTrg1Vrt2;
      vec3 aTrg2Edge0 = aTrg2Vrt1 - aTrg2Vrt0;
      vec3 aTrg2Edge1 = aTrg2Vrt0 - aTrg2Vrt2;
      vec3 aTrg3Edge0 = aTrg3Vrt1 - aTrg3Vrt0;
      vec3 aTrg3Edge1 = aTrg3Vrt0 - aTrg3Vrt2;

      vec4 e0x = vec4 (aTrg0Edge0.x, aTrg1Edge0.x, aTrg2Edge0.x, aTrg3Edge0.x);
      vec4 e0y = vec4 (aTrg0Edge0.y, aTrg1Edge0.y, aTrg2Edge0.y, aTrg3Edge0.y);
      vec4 e0z = vec4 (aTrg0Edge0.z, aTrg1Edge0.z, aTrg2Edge0.z, aTrg3Edge0.z);
      vec4 e1x = vec4 (aTrg0Edge1.x, aTrg1Edge1.x, aTrg2Edge1.x, aTrg3Edge1.x);
      vec4 e1y = vec4 (aTrg0Edge1.y, aTrg1Edge1.y, aTrg2Edge1.y, aTrg3Edge1.y);
      vec4 e1z = vec4 (aTrg0Edge1.z, aTrg1Edge1.z, aTrg2Edge1.z, aTrg3Edge1.z);

      vec4 nx = e1y * e0z - e1z * e0y;
      vec4 ny = e1z * e0x - e1x * e0z;
      vec4 nz = e1x * e0y - e1y * e0x;

      vec4 invNdotD = vec4 (1.f) / (nx * aSubTree.TrsfRay.Direct.xxxx +
                                    ny * aSubTree.TrsfRay.Direct.yyyy + 
                                    nz * aSubTree.TrsfRay.Direct.zzzz);

      vec4 e2x = vec4 (aTrg0Vrt0.x, aTrg1Vrt0.x, aTrg2Vrt0.x, aTrg3Vrt0.x) - aSubTree.TrsfRay.Origin.xxxx;
      vec4 e2y = vec4 (aTrg0Vrt0.y, aTrg1Vrt0.y, aTrg2Vrt0.y, aTrg3Vrt0.y) - aSubTree.TrsfRay.Origin.yyyy;
      vec4 e2z = vec4 (aTrg0Vrt0.z, aTrg1Vrt0.z, aTrg2Vrt0.z, aTrg3Vrt0.z) - aSubTree.TrsfRay.Origin.zzzz;

      e2x *= invNdotD;
      e2y *= invNdotD;
      e2z *= invNdotD;

      vec4 t = nx * e2x + ny * e2y + nz * e2z;

      vec4 vx = aSubTree.TrsfRay.Direct.yyyy * e2z - aSubTree.TrsfRay.Direct.zzzz * e2y;
      vec4 vy = aSubTree.TrsfRay.Direct.zzzz * e2x - aSubTree.TrsfRay.Direct.xxxx * e2z;
      vec4 vz = aSubTree.TrsfRay.Direct.xxxx * e2y - aSubTree.TrsfRay.Direct.yyyy * e2x;

      vec4 u = vx * e1x + vy * e1y + vz * e1z;
      vec4 v = vx * e0x + vy * e0y + vz * e0z;

      ivec4 res = ivec4 (greaterThanEqual (t, vec4 (0.0))) &
                  ivec4 (greaterThanEqual (u, vec4 (0.0))) &
                  ivec4 (greaterThanEqual (v, vec4 (0.0))) &
                  ivec4 (lessThanEqual    (u + v, vec4 (1.0)));

      t = mix (vec4 (MAXFLOAT), t, bvec4 (res));

      if (t.x < theHit.Time)
      {
        aTriIndex = aTrg0;
        theTrsfId = TRS_OFFSET (aSubTree);
        theHit = SIntersect (t.x, vec2 (u.x, v.x), vec3 (nx.x, ny.x, nz.x));
      }

      if (t.y < theHit.Time)
      {
        aTriIndex = aTrg1;
        theTrsfId = TRS_OFFSET (aSubTree);
        theHit = SIntersect (t.y, vec2 (u.y, v.y), vec3 (nx.y, ny.y, nz.y));
      }

      if (t.z < theHit.Time)
      {
        aTriIndex = aTrg2;
        theTrsfId = TRS_OFFSET (aSubTree);
        theHit = SIntersect (t.z, vec2 (u.z, v.z), vec3 (nx.z, ny.z, nz.z));
      }

      if (t.w < theHit.Time)
      {
        aTriIndex = aTrg3;
        theTrsfId = TRS_OFFSET (aSubTree);
        theHit = SIntersect (t.w, vec2 (u.w, v.w), vec3 (nx.w, ny.w, nz.w));
      }

      ///////////////////////////////////////////////////////

      toContinue = (aHead >= 0);

      if (aHead == aStop) // go to top-level BVH
      {
        aStop = -1; aSubTree = SSubTree (theRay, theInverse, EMPTY_ROOT);
      }

      aNode = Stack[abs (aHead)]; --aHead;
    }