Raytracing program fails to detect intersections in c++

Question

I am working on a simple raytracer in c++. I am currently implementing an intersection function but have encountered some issues.

For some reason, the collision detection only works for a tiny rectangle in my image. In the image below you can see that it draws the room quite fine for a small part of the screen but fails to do so for the rest of the scene. Only a small section gets drawn correctly.

Why does my intersection detection not work? I have included the code for the intersection and draw function below.

    LoadTestModel(m_Model);
    m_Light.position = glm::vec3(0.0f, -1.0f, 0.0);
    m_Light.color = glm::vec3(0.f, 0.f, 0.f);
    m_Light.ambient = glm::vec3(0.5f, 0.5f, 0.5f);
    m_Camera.position = glm::vec3(0.0, 0.0, -2.0);
    m_Camera.yaw = 0.0f;
}

void Lab2Scene::Draw(Window& window)
{
    if (!m_RenderNext) return;
    m_RenderNext = false;

    for (uint32_t y = 0; y < window.GetHeight(); ++y)
    {
        for (uint32_t x = 0; x < window.GetWidth(); ++x)
        {
            Ray ray = {};
            glm::vec3 d(x - (window.GetWidth() / 2), y - (window.GetHeight() / 2), (window.GetHeight() / 2));
            d = glm::normalize(d);
            ray.direction = d * m_Camera.GetRotationY();
            ray.start = m_Camera.position;
            // Find the closest intersection of the casted ray.
            Intersection nearest_intersection = {};
            if (ClosestIntersection(ray, m_Model, nearest_intersection))
            {
                //window.PutPixel(x, y, glm::vec3(1.f, 0.f, 0.f));
                window.PutPixel(x, y, DirectLight(m_Light, nearest_intersection, m_Model) + m_Model[nearest_intersection.triangleIndex].color * m_Light.ambient); // DirectLight(m_Light, intersection, m_Model)
            }
            else
            {
                window.PutPixel(x, y, m_Light.color);
            }
        }
    }
}



bool Lab2Scene::ClosestIntersection(const Ray& ray, const std::vector<Triangle>& triangles, Intersection& intersection)
{
    float m = std::numeric_limits<float>::max();
    intersection.distance = m;
    bool inters = false;
    for (int i = 0; i < triangles.size(); ++i) {
        float dot = glm::dot(ray.direction, triangles[i].normal);
        if (dot != 0) {
            using glm::vec3;
            using glm::mat3;
            vec3 v0 = triangles[i].v0;
            vec3 v1 = triangles[i].v1;
            vec3 v2 = triangles[i].v2;
            vec3 e1 = v1 - v0;
            vec3 e2 = v2 - v0;
            vec3 b = ray.start - v0;
            mat3 A(-ray.direction, e1, e2);
            vec3 x = glm::inverse(A) * b;
            if (x[1] >= 0 && x[2] >= 0 && x[1] + x[2] <= 1 && x[0] >= 0) {
                vec3 intersect = ray.start + (x[0] * ray.direction);
                if (glm::distance(ray.start, intersect) <= intersection.distance) {
                    intersection.position = intersect;
                    intersection.distance = glm::distance(ray.start, intersect);
                    intersection.triangleIndex = i;
                    inters = true;
                }
            }
        }
    }
    return inters;
}