So, I read about raytracing on the net and started writing a Raytracer from scratch in my spare time. I'm using C++, which I've been learning for about a month now. I have read up on the theory of raytracing on the net and so far its working quite well. Its just a basic Raytracer, that uses neither models or textures.
At first it made a Raycaster and was quite pleased with the result.
So then I tried multiple objects and it worked too. I just used diffuse shading in this implementation and added to the colour of the light to the object colour at the points it is not shaded.
Unfortunately this Code did not work for multiple light sources. So then I started to rewrite my code, so that it supports multiple lights.
I also read up on Phong illumination and got to work:
It even works with multiple lights:
So far I'm pleased, but now my I'm kinda stuck. I've tried fixing this for quite some time but I came up with nothing. When I add a second Sphere or even a third, only the last Sphere is illuminated. By last I mean the object in my array where I store all objects.See code below.
Clearly the purple Sphere should have a similar illumination, since their center lie in the same plane. To my surprise the sphere only has the ambient illumination --> shaded, which should not be the case.
So now my trace function:
Colour raytrace(const Ray &r, const int &depth)
{
//first find the nearest intersection of a ray with an object
//go through all objects an find the one with the lowest parameter
double t, t_min = INFINITY;
int index_nearObj = -1;//-1 to know if obj found
for(int i = 0; i < objSize; i++)
{
//skip light src
if(!dynamic_cast<Light *>(objects[i]))
{
t = objects[i]->findParam(r);
if(t > 0 && t < t_min) //if there is an intersection and
//its distance is lower than the current min --> new min
{
t_min = t;
index_nearObj = i;
}
}
}
//now that we have the nearest intersection, calc the intersection point
//and the normal at that point
//r.position + t * r.direction
if(t_min < 0 || t_min == INFINITY) //no intersection --> return background Colour
return White;
Vector intersect = r.getOrigin() + r.getDirection()*t;
Vector normal = objects[index_nearObj]->NormalAtIntersect(intersect);
//then calculate light ,shading and colour
Ray shadowRay;
Ray rRefl;//reflected ray
bool shadowed;
double t_light = -1;
Colour finalColour = White;
Colour objectColor = objects[index_nearObj]->getColour();
Colour localColour;
Vector tmpv;
//get material properties
double ka = 0.1; //ambient coefficient
double kd; //diffuse coefficient
double ks; //specular coefficient
Colour ambient = ka * objectColor; //ambient component
//the minimum Colour the obj has, even if object is not hit by light
Colour diffuse, specular;
double brightness;
int index = -1;
localColour = ambient;
//look if the object is in shadow or light
//do this by casting a ray from the obj and
// check if there is an intersection with another obj
for(int i = 0; i < objSize; i++)
{
if(dynamic_cast<Light *>(objects[i])) //if object is a light
{//for each light
shadowed = false;
//create Ray to light
//its origin is the intersection point
//its direction is the position of the light - intersection
tmpv = objects[i]->getPosition() - intersect;
shadowRay = Ray(intersect + (!tmpv) * BIAS, tmpv);
//the ray construcor automatically normalizes its direction
t_light = objects[i]->findParam(shadowRay);
if(t_light < 0) //no imtersect, which is quite impossible
continue;
//then we check if that Ray intersects one object that is not a light
for(int j = 0; j < objSize; j++)
{
if(!dynamic_cast<Light *>(objects[j]))//if obj is not a light
{
//we compute the distance to the object and compare it
//to the light distance, for each light seperately
//if it is smaller we know the light is behind the object
//--> shadowed by this light
t = objects[j]->findParam(shadowRay);
if(t < 0) // no intersection
continue;
if(t < t_light) // intersection that creates shadow
shadowed = true;
else
{
shadowed = false;
index = j;//not using the index now,maybe later
break;
}
}
}
//we know if intersection is shadowed or not
if(!shadowed)// if obj is not shadowed
{
rRefl = objects[index_nearObj]->calcReflectingRay(shadowRay, intersect); //reflected ray from ligh src, for ks
kd = maximum(0.0, (normal|shadowRay.getDirection()));
ks = pow(maximum(0.0, (r.getDirection()|rRefl.getDirection())), objects[index_nearObj]->getMaterial().shininess);
diffuse = kd * objectColor;// * objects[i]->getColour();
specular = ks * objects[i]->getColour();//not sure if obj needs specular colour
brightness = 1 /(1 + t_light * DISTANCE_DEPENDENCY_LIGHT);
localColour += brightness * (diffuse + specular);
}
}
}
//handle reflection
//handle transmission
//combine colours
//localcolour+reflectedcolour*refl_coeff + transmittedcolor*transmission coeff
finalColour = localColour; //+reflcol+ transmcol
return finalColour;
}
Next is the render function:
for(uint32_t y = 0; y < h; y++)
{
for(uint32_t x = 0; x < w; x++)
{
//pixel coordinates for the scene, depends on implementation...here camera on z axis
pixel.X() = ((x+0.5)/w-0.5)*aspectRatio *angle;
pixel.Y() = (0.5 - (y+0.5)/w)*angle;
pixel.Z() = look_at.getZ();//-1, cam at 0,0,0
rTmp = Ray(cam.getOrigin(), pixel - cam.getOrigin());
cTmp = raytrace(rTmp, depth);//depth == 0
pic.setPixel(y, x, cTmp);//writes colour of pixel in picture
}
}
So here are my intersect functions:
double Sphere::findParam(const Ray &r) const
{
Vector rorig = r.getOrigin();
Vector rdir = r.getDirection();
Vector center = getPosition();
double det, t0 , t1; // det is the determinant of the quadratic equation: B² - 4AC;
double a = (rdir|rdir);
//one could optimize a away cause rdir is a unit vector
double b = ((rorig - center)|rdir)*2;
double c = ((rorig - center)|(rorig - center)) - radius*radius;
det = b*b - 4*c*a;
if(det < 0)
return -1;
t0 = (-b - sqrt(det))/(2*a);
if(det == 0)//one ontersection, no need to compute the second param!, is same
return t0;
t1 = (-b + sqrt(det))/(2*a);
//two intersections, if t0 or t1 is neg, the intersection is behind the origin!
if(t0 < 0 && t1 < 0) return -1;
else if(t0 > 0 && t1 < 0) return t0;
else if(t0 < 0 && t1 > 0) return t1;
if(t0 < t1)
return t0;
return t1;
}
Ray Sphere::calcReflectingRay(const Ray &r, const Vector &intersection)const
{
Vector rdir = r.getDirection();
Vector normal = NormalAtIntersect(intersection);
Vector dir = rdir - 2 * (rdir|normal) * normal;
return Ray(intersection, !dir);
}
//Light intersection(point src)
double Light::findParam(const Ray &r) const
{
double t;
Vector rorig = r.getOrigin();
Vector rdir = r.getDirection();
t = (rorig - getPosition())|~rdir; //~inverts a Vector
//if I dont do this, then both spheres are not illuminated-->ambient
if(t > 0)
return t;
return -1;
}
Here is the abstract Object class. Each sphere, light, etc. is an object.
class Object
{
Colour color;
Vector pos;
//Colour specular;not using right now
Material_t mat;
public:
Object();
Object(const Colour &);
Object(const Colour &, const Vector &);
Object(const Colour &, const Vector &, const Material_t &);
virtual ~Object()=0;
virtual double findParam(const Ray &) const =0;
virtual Ray calcReflectingRay(const Ray &, const Vector &)const=0;
virtual Ray calcRefractingRay(const Ray &, const Vector &)const=0;
virtual Vector NormalAtIntersect(const Vector &)const=0;
Colour getColour()const {return color;}
Colour & colour() {return color;}
Vector getPosition()const {return pos;}
Vector & Position() {return pos;}
Material_t getMaterial()const {return mat;}
Material_t & material() {return mat;}
friend bool operator!=(const Object &obj1, const Object &obj2)
{//compares only references!
if(&obj1 != &obj2)
return true;
return false;
}
};
I use a global array of Object Pointers to store all lights, spheres, etc of a world:
Object *objects[objSize];
I know my code is a mess, but if anybody has an idea what is going on, I'd be very grateful.
EDIT 1 I added pictures.
EDIT 2 Updated code, fixed a minor Error. Still no solution.
Update: Added render code, which creates rays.
Answer
Problem found
I managed to debug your ray tracer using Linux and gcc.
Regarding the problem, well... once I found it I felt the urge to bash my head repeatedly against my keyboard. :)
Your algorithm is correct, except for a little sneaky detail:
Vector intersect = r.getOrigin() + r.getDirection()*t;
When you calculate the intersection point, you use t instead of t_min.
The fix consists in changing the above line to:
Vector intersect = r.getOrigin() + r.getDirection()*t_min;
The correct output is the following:
Other suggestions
I think the problem lies in your shadow ray loop:
//then we check if that Ray intersects one object that is not a light
for(int j = 0; j < objSize; j++)
{
if(!dynamic_cast<Light *>(objects[j]))//if obj is not a light
{
//we compute the distance to the object and compare it
//to the light distance, for each light seperately
//if it is smaller we know the light is behind the object
//--> shadowed by this light
t = objects[j]->findParam(shadowRay);
if(t < 0) // no intersection
continue;
if(t < t_light) // intersection that creates shadow
shadowed = true;
else
{
shadowed = false;
index = j;//not using the index now,maybe later
break;
}
}
}
Basically, when an intersection is found, you set the shadowed flag to true, BUT you continue the cycle: this is both inefficient and incorrect.
When an intersection is found, there is no need to search for another.
My guess is that your shadow flag is set to false again because you don't stop the loop.
Also, when t >= t_light you interrupt the cycle, which is also incorrect (it's just like t < 0).
I would change the code to the following:
//then we check if that Ray intersects one object that is not a light
for (int j = 0; j < objSize; j++)
{
// Exclude lights AND the closest object found
if(j != index_nearObj && !dynamic_cast<Light *>(objects[j]))
{
//we compute the distance to the object and compare it
//to the light distance, for each light seperately
//if it is smaller we know the light is behind the object
//--> shadowed by this light
t = objects[j]->findParam(shadowRay);
// If the intersection point lies between the object and the light source,
// then the object is in shadow!
if (t >= 0 && t < t_light)
{
// Set the flag and stop the cycle
shadowed = true;
break;
}
}
}
Some other suggestions:
Refactor your rendering code by adding a function which given a ray finds the closest/first intersection with the scene. This avoids code duplication.
Don't overload operators for dot product and normalization: use instead dedicated functions.
Try to reduce the scope of your variables as much as possible: this improves code readability.
Keep exploring raytracing stuff because it's awesome :D