Chapter 7: color function, stack overflow

[krzysztofKKW]

I've gotten to chapter seven, when my program has stopped at 20% of image generation with exit code 3221225725.
Above number is 0xc00000fd in hex, which is stack overflow error in windows.

Dev C++'s debugger shows me quite an interesting trace:

Here's the code I've written:

vec3 rius(mt19937_64 rng) {
	vec3 p;
	do {
		p = 2.0*vec3(unif(rng), unif(rng), unif(rng)) - vec3(1,1,1);
	} while (p.squaredLength() >= 1.0);
	return p;
}

vec3 color(const ray & r, hitable *world, mt19937_64 rng)
{
	HitRecord rec;
	if (world->hit(r, 0.0, FLT_MAX, rec))
	{
		vec3 target = rec.p	+ rec.normal + rius(rng);
		return 0.5*color(ray(rec.p, target-rec.p), world, rng);
	}
	else
	{
		vec3 unitDirection = unit(r.direction());
		float t = 0.5 * (unitDirection.y() + 1.0);
		return (1.0-t)*vec3(1.0, 1.0, 1.0) + t*vec3(0.2, 0.5, 1.0);
	}	
}

rng is just me passing a random number generator engine not to have scope issues.

From the backtrace provided, it would seem that the ray perhaps has hit the sphere on the inside?
The trace is very long and consists solely of the color() function, which would suggest me that it's due to function recursion.

Any help is appreciated, as I can't find any errors with the code above.

[ArionTT]

`
bool sphere::hit(ray & r, float t_min, float t_max, hit_record & record)
{
vec3 cen(center);
vec3 o( r.origin);
vec3 oc(o - cen);
float a = dot(r.dir, r.dir);
float b = dot(oc, r.dir);
float c = dot(oc, oc) - radius * radius;
float discriminant = b * b - a * c;
if (discriminant > 0) {
float temp = (-b - sqrt(discriminant)) / a;
if (temp < t_max && temp > t_min) {
record.t = temp;
record.pos = r.ray_point(record.t);
record.normal = (record.pos - center) / radius;
return true;
}

            // this codes
	//temp = (-b + sqrt(discriminant)) / a;
	//if (temp < t_max && temp > t_min) {
	//	record.t = temp;
	//	record.pos = r.ray_point(record.t);
	//	record.normal = (record.pos - center) / radius;
	//	return true;
	//}
}
return false;

}
`
I found that code is a error. It is a another answer of equation. When that line is true, it mean the ray enter the sphere and while reflect many time until stack overflow. I comment this lines ( the code comment ) and the code run well.

[hollasch]

Note: In Markdown (what Git uses for formatting) use either triple backticks (```) on a line to begin and then to end a code block, or indent four spaces. The single backtick character is for inline code.

Here's the above code formatted:

bool sphere::hit(ray & r, float t_min, float t_max, hit_record & record)
{
    vec3 cen(center);
    vec3 o( r.origin);
    vec3 oc(o - cen);

    float a = dot(r.dir, r.dir);
    float b = dot(oc, r.dir);
    float c = dot(oc, oc) - radius * radius;

    float discriminant = b * b - a * c;

    if (discriminant > 0) {
        float temp = (-b - sqrt(discriminant)) / a;
        if (temp < t_max && temp > t_min) {
            record.t = temp;
            record.pos = r.ray_point(record.t);
            record.normal = (record.pos - center) / radius;
            return true;
        }
//      temp = (-b + sqrt(discriminant)) / a;
//      if (temp < t_max && temp > t_min) {
//          record.t = temp;
//          record.pos = r.ray_point(record.t);
//          record.normal = (record.pos - center) / radius;
//          return true;
//      }
    }
    return false;
}

Probable dupe of other surface acne bugs: #137, RayTracing/InOneWeekend#23.

[hollasch]

Note that commenting out the second point of the intersection pair above means that rays with origin inside the sphere will never intersect the sphere.

[hollasch]

I think I see the problem here. The color function is updated to a recursive form in chapter 8 (Diffuse Materials). In chapter 9 (Metal), the color function is updated again to account for ray depth, and to limit the depth to a maximum of 50.

If, due to surface acne, the intersection point is just inside the sphere, and without depth limiting, the ray will bounce around inside the sphere forever, or until surface acne provides an escape.

The proposed fix: introduce depth limiting at the same time as recursive ray generation.

[hollasch]

Resolved in PR #243, development branch.