CODEWITHSUNDEEP
c++openglmath3dintersection
Pavlo Muratov
Pavlo Muratov

Reputation: 317

Ray transformation in a Ray - OBB intersection test

I've implemented an algorithm that tests for a Ray - AABB intersection and it works fine. But when I try to transform Ray to the AABB's local space (making this a Ray - OBB test), I can't get correct results. I've studied several forums and other resources, but still missing something. (Some sources suggesting to apply inverted transformation to the ray origin and its end, and only then calc. direction, other - to apply transformation to origin and direction). Can someone point in the right direction (no pun intended)?

Here goes two functions responsible for the math:

1) Calculating inverses and other things to perform tests

bool Ray::intersectsMesh(const Mesh& mesh, const Transformation& transform) {
        float largestNearIntersection = std::numeric_limits<float>::min();
        float smallestFarIntersection = std::numeric_limits<float>::max();
        glm::mat4 modelTransformMatrix = transform.modelMatrix();
        Box boundingBox = mesh.boundingBox();

        glm::mat4 inverse = glm::inverse(transform.modelMatrix());

        glm::vec4 newOrigin = inverse * glm::vec4(mOrigin, 1.0);
        newOrigin /= newOrigin.w;
        mOrigin = newOrigin;
        mDirection = glm::normalize(inverse * glm::vec4(mDirection, 0.0));

        glm::vec3 xAxis = glm::vec3(glm::column(modelTransformMatrix, 0));
        glm::vec3 yAxis = glm::vec3(glm::column(modelTransformMatrix, 1));
        glm::vec3 zAxis = glm::vec3(glm::column(modelTransformMatrix, 2));

        glm::vec3 OBBTranslation = glm::vec3(glm::column(modelTransformMatrix, 3));
        printf("trans x %f y %f z %f\n", OBBTranslation.x, OBBTranslation.y, OBBTranslation.z);
        glm::vec3 delta = OBBTranslation - mOrigin;

        bool earlyFalseReturn = false;

        calculateIntersectionDistances(xAxis, delta, boundingBox.min.x, boundingBox.max.x, &largestNearIntersection, &smallestFarIntersection, &earlyFalseReturn);
        if (smallestFarIntersection < largestNearIntersection || earlyFalseReturn) { return false; }

        calculateIntersectionDistances(yAxis, delta, boundingBox.min.y, boundingBox.max.y, &largestNearIntersection, &smallestFarIntersection, &earlyFalseReturn);
        if (smallestFarIntersection < largestNearIntersection || earlyFalseReturn) { return false; }

        calculateIntersectionDistances(zAxis, delta, boundingBox.min.z, boundingBox.max.z, &largestNearIntersection, &smallestFarIntersection, &earlyFalseReturn);
        if (smallestFarIntersection < largestNearIntersection || earlyFalseReturn) { return false; }

        return true;
    }

2) Helper function (probably not needed here as its relates only to AABB tests and works fine)

void Ray::calculateIntersectionDistances(const glm::vec3& axis,
                                             const glm::vec3& delta,
                                             float minPointOnAxis,
                                             float maxPointOnAxis,
                                             float *largestNearIntersection,
                                             float *smallestFarIntersection,
                                             bool *earlyFalseRerutn)
    {
        float divident = glm::dot(axis, delta);
        float denominator = glm::dot(mDirection, axis);

        if (fabs(denominator) > 0.001f) {
            float t1 = (divident + minPointOnAxis) / denominator;
            float t2 = (divident + maxPointOnAxis) / denominator;

            if (t1 > t2) { std::swap(t1, t2); }

            *smallestFarIntersection = std::min(t2, *smallestFarIntersection);
            *largestNearIntersection = std::max(t1, *largestNearIntersection);
        } else if (-divident + minPointOnAxis > 0.0 || -divident + maxPointOnAxis < 0.0) {
            *earlyFalseRerutn = true;
        }
    }

Upvotes: 0

Views: 2211

Answers (1)

Pavlo Muratov
Pavlo Muratov

Reputation: 317

As it turned out, the ray's world -> model transformation was correct. The bug was in the intersection test. I had to completely replace the intersection code, because I wasn't able to identify the bug in the old code, unfortunately.

Ray transformation code:

glm::mat4 inverse = glm::inverse(transform.modelMatrix());
glm::vec4 start = inverse * glm::vec4(mOrigin, 1.0);
glm::vec4 direction = inverse * glm::vec4(mDirection, 0.0);
direction = glm::normalize(direction);

And the Ray - AABB test was stolen from here

Upvotes: 1

Related Questions