¿Qué tan ineficiente es mi algoritmo de intersección de rayos y cajas?

Estoy experimentando un poco con shaders y el cálculo de una colisión entre un rayo y una caja, que se realiza de la siguiente manera:

inline bool hitsCube(in Ray ray,            in Cube cube, 
                     out float tMin,        out float tMax,
                     out float3 signMin,    out float3 signMax)
{
    float3 biggerThan0 = ray.odir > 0; // ray.odir = (1.0/ray.dir)
    float3 lessThan0 = 1.0f - biggerThan0;

    float3 tMinXYZ = cube.center + biggerThan0 * cube.minSize + lessThan0 * cube.maxSize;
    float3 tMaxXZY = cube.center + biggerThan0 * cube.maxSize + lessThan0 * cube.minSize;

    float3 rMinXYZ = (tMinXYZ - ray.origin) * ray.odir;
    float3 rMaxXYZ = (tMaxXZY - ray.origin) * ray.odir;

    float minV = max(rMinXYZ.x, max(rMinXYZ.y, rMinXYZ.z));
    float maxV = min(rMaxXYZ.x, min(rMaxXYZ.y, rMaxXYZ.z));

    tMin = minV;
    tMax = maxV;

    signMin = (rMinXYZ == minV) * lessThan0; // cálculo importante para otro algoritmo, pero sin contexto proporcionado aquí
    signMax = (rMaxXYZ == maxV) * lessThan0;

    return maxV > minV * (minV + maxV >= 0); // la última multiplicación asegura que el origen del rayo está fuera de la caja
}

Considerando que esta función puede ser llamada muchas veces dentro de un shader hlsl (digamos, al menos 200/300 veces para algunos píxeles): ¿Es eficiente mi implementación de la lógica de colisión?