Wierd Raytracing Artifacts

Question

I am trying to create a ray tracer using Qt, but I have some really weird artifacts going on.

Before I implemented shading, I just had 4 spheres, 3 triangles and 2 bounded planes in my scene. They all showed up as expected and as the color expected however, for my planes, I would see dots the same color as the background. These dots would stay static from my view position, so if I moved the camera around the dots would move around as well. However they only affected the planes and triangles and would never appear on the spheres. One I implemented shading the issue got worse. The dots now also appear on spheres in the light source, so any part affected by the diffuse. Also, my one plane of pure blue (RGB 0,0,255) has gone straight black. Since I have two planes I switched their colors and again the blue one went black, so it's a color issue and not a plane issue.

If anyone has any suggestions as to what the problem could be or wants to see any particular code let me know.

#include "plane.h"
#include "intersection.h"

#include <math.h>
#include <iostream>

Plane::Plane(QVector3D bottomLeftVertex, QVector3D topRightVertex, QVector3D normal, QVector3D point, Material *material)
{
    minCoords_.setX(qMin(bottomLeftVertex.x(),topRightVertex.x()));
    minCoords_.setY(qMin(bottomLeftVertex.y(),topRightVertex.y()));
    minCoords_.setZ(qMin(bottomLeftVertex.z(),topRightVertex.z()));
    maxCoords_.setX(qMax(bottomLeftVertex.x(),topRightVertex.x()));
    maxCoords_.setY(qMax(bottomLeftVertex.y(),topRightVertex.y()));
    maxCoords_.setZ(qMax(bottomLeftVertex.z(),topRightVertex.z()));
    normal_ = normal;
    normal_.normalize();
    point_ = point;
    material_ = material;
}

Plane::~Plane()
{

}

void Plane::intersect(QVector3D rayOrigin, QVector3D rayDirection, Intersection* result)
{
    if(normal_ == QVector3D(0,0,0)) //plane is degenerate
    {
        cout << "degenerate plane" << endl;
        return;
    }
    float minT;
    //t = -Normal*(Origin-Point) / Normal*direction
    float numerator = (-1)*QVector3D::dotProduct(normal_, (rayOrigin - point_));
    float denominator = QVector3D::dotProduct(normal_, rayDirection);
    if (fabs(denominator) < 0.0000001) //plane orthogonal to view
    {
        return;
    }
    minT = numerator / denominator;
    if (minT < 0.0)
    {
        return;
    }
    QVector3D intersectPoint = rayOrigin + (rayDirection * minT);
    //check inside plane dimensions
    if(intersectPoint.x() < minCoords_.x() || intersectPoint.x() > maxCoords_.x() ||
       intersectPoint.y() < minCoords_.y() || intersectPoint.y() > maxCoords_.y() ||
       intersectPoint.z() < minCoords_.z() || intersectPoint.z() > maxCoords_.z())
    {
        return;
    }
    //only update if closest object
    if(result->distance_ > minT)
    {
        result->hit_ = true;
        result->intersectPoint_ = intersectPoint;
        result->normalAtIntersect_ = normal_;
        result->distance_ = minT;
        result->material_ = material_;
    }
}

QVector3D MainWindow::traceRay(QVector3D rayOrigin, QVector3D rayDirection, int depth)
{
    if(depth > maxDepth)
    {
        return backgroundColour;
    }
    Intersection* rayResult = new Intersection();
    foreach (Shape* shape, shapeList)
    {
        shape->intersect(rayOrigin, rayDirection, rayResult);
    }
    if(rayResult->hit_ == false)
    {
        return backgroundColour;
    }
    else
    {
        QVector3D intensity = QVector3D(0,0,0);
        QVector3D shadowRay = pointLight - rayResult->intersectPoint_;
        shadowRay.normalize();
        Intersection* shadowResult = new Intersection();
        foreach (Shape* shape, shapeList)
        {
            shape->intersect(rayResult->intersectPoint_, shadowRay, shadowResult);
        }
        if(shadowResult->hit_ == true)
        {
            intensity += shadowResult->material_->diffuse_ * intensityAmbient;
        }
        else
        {
            intensity += rayResult->material_->ambient_ * intensityAmbient;
            // Diffuse
            intensity += rayResult->material_->diffuse_ * intensityLight * qMax(QVector3D::dotProduct(rayResult->normalAtIntersect_,shadowRay), 0.0f);
            // Specular
            QVector3D R = ((2*(QVector3D::dotProduct(rayResult->normalAtIntersect_,shadowRay))* rayResult->normalAtIntersect_) - shadowRay);
            R.normalize();
            QVector3D V = rayOrigin - rayResult->intersectPoint_;
            V.normalize();
            intensity += rayResult->material_->specular_ * intensityLight * pow(qMax(QVector3D::dotProduct(R,V), 0.0f), rayResult->material_->specularExponent_);
        }
        return intensity;
    }
}

Answer 1

So I figured out my issues. They are due to float being terrible at precision, any check for < 0.0 would intermittently fail because of floats precision. I had to add an offset to all my checks so that I was checking for < 0.001.