Intersection problems with ray-sphere intersection <p>I'm writing a simple ray tracer and to keep it simple for now I've decided to just have spheres in my scene. I am at a stage now where I merely want to confirm that my rays are intersecting a sphere in the scene properly, nothing else. I've created a Ray and Sphere class and then a function in my main file which goes through each pixel to see if there's an intersection (relevant code will be posted below). The problem is that the whole intersection with the sphere is acting rather strangely. If I create a sphere with center (0, 0, -20) and a radius of 1 then I get only one intersection which is always at the very first pixel of what would be my image (upper-left corner). Once I reach a radius of 15 I suddenly get three intersections in the upper-left region. A radius of 18 gives me six intersections and once I reach a radius of 20+ I suddenly get an intersection for EACH pixel so something is acting as it's not supposed to do. </p> <p>I was suspicious that my ray-sphere intersection code might be at fault here but having looked through it and looked through the net for more information most solutions describe the very same approach I use so I assume it shouldn't(!) be at fault here. So...I am not exactly sure what I am doing wrong, it could be my intersection code or it could be something else causing the problems. I just can't seem to find it. Could it be that I am thinking wrong when giving values for the sphere and rays? Below is relevant code</p> <p><strong>Sphere class:</strong></p> <pre><code>Sphere::Sphere(glm::vec3 center, float radius) : m_center(center), m_radius(radius), m_radiusSquared(radius*radius) { } //Sphere-ray intersection. Equation: (P-C)^2 - R^2 = 0, P = o+t*d //(P-C)^2 - R^2 =&gt; (o+t*d-C)^2-R^2 =&gt; o^2+(td)^2+C^2+2td(o-C)-2oC-R^2 //=&gt; at^2+bt+c, a = d*d, b = 2d(o-C), c = (o-C)^2-R^2 //o = ray origin, d = ray direction, C = sphere center, R = sphere radius bool Sphere::intersection(Ray&amp; ray) const { //Squared distance between ray origin and sphere center float squaredDist = glm::dot(ray.origin()-m_center, ray.origin()-m_center); //If the distance is less than the squared radius of the sphere... if(squaredDist &lt;= m_radiusSquared) { //Point is in sphere, consider as no intersection existing //std::cout &lt;&lt; "Point inside sphere..." &lt;&lt; std::endl; return false; } //Will hold solution to quadratic equation float t0, t1; //Calculating the coefficients of the quadratic equation float a = glm::dot(ray.direction(),ray.direction()); // a = d*d float b = 2.0f*glm::dot(ray.direction(),ray.origin()-m_center); // b = 2d(o-C) float c = glm::dot(ray.origin()-m_center, ray.origin()-m_center) - m_radiusSquared; // c = (o-C)^2-R^2 //Calculate discriminant float disc = (b*b)-(4.0f*a*c); if(disc &lt; 0) //If discriminant is negative no intersection happens { //std::cout &lt;&lt; "No intersection with sphere..." &lt;&lt; std::endl; return false; } else //If discriminant is positive one or two intersections (two solutions) exists { float sqrt_disc = glm::sqrt(disc); t0 = (-b - sqrt_disc) / (2.0f * a); t1 = (-b + sqrt_disc) / (2.0f * a); } //If the second intersection has a negative value then the intersections //happen behind the ray origin which is not considered. Otherwise t0 is //the intersection to be considered if(t1&lt;0) { //std::cout &lt;&lt; "No intersection with sphere..." &lt;&lt; std::endl; return false; } else { //std::cout &lt;&lt; "Intersection with sphere..." &lt;&lt; std::endl; return true; } } </code></pre> <p><strong>Program:</strong></p> <pre><code>#include "Sphere.h" #include "Ray.h" void renderScene(const Sphere&amp; s); const int imageWidth = 400; const int imageHeight = 400; int main() { //Create sphere with center in (0, 0, -20) and with radius 10 Sphere testSphere(glm::vec3(0.0f, 0.0f, -20.0f), 10.0f); renderScene(testSphere); return 0; } //Shoots rays through each pixel and check if there's an intersection with //a given sphere. If an intersection exists then the counter is increased. void renderScene(const Sphere&amp; s) { //Ray r(origin, direction) Ray r(glm::vec3(0.0f), glm::vec3(0.0f)); //Will hold the total amount of intersections int counter = 0; //Loops through each pixel... for(int y=0; y&lt;imageHeight; y++) { for(int x=0; x&lt;imageWidth; x++) { //Change ray direction for each pixel being processed r.setDirection(glm::vec3(((x-imageWidth/2)/(float)imageWidth), ((imageHeight/2-y)/(float)imageHeight), -1.0f)); //If current ray intersects sphere... if(s.intersection(r)) { //Increase counter counter++; } } } std::cout &lt;&lt; counter &lt;&lt; std::endl; } </code></pre>