total internal reflection bugs in "ray tracing in one weekend" - c++

Question

I am following "Ray Tracing in One Weekend" to build a ray tracer on my own. Everything is OK until I met Dilectric Material.
The refraction performs well (I am not sure, we can see it in image 3 and 4), but when I add the total internal reflection, the sphere gets a black edge, the images are listed as below:
img1 - black edge for total internal reflection
img2 - black edge for total internal reflection
img3 - dilectric without total internal reflection
img4 - dilectric without total internal reflection
My analysis
I debuged my program and found that total internal reflection happens at the edge of the sphere, and the ray bounces infinitely inside the sphere until it exceeds boundce limits, so it returns (0.f, 0.f, 0.f) for the result color.
I don't think the infinite bounce of inner relection is right, but i have compared my code with the one in the book, and could not find any problem.
The scatter method is here:
bool Dilectric::scatter(const Ray& input, const HitRecord& rec, glm::vec3& attenuation, Ray& scatterRay) const
{
glm::vec3 dir;
if (rec.frontFace)
{
// ray is from air to inside surface, only refraction happens
float ratio = 1.f / m_refractIndex;
dir = GfxLib::refract(glm::normalize(input.direction()), rec.n, ratio);
}
else
{
// ray is from inside surface to air, need to think of total internal reflection
float ratio = m_refractIndex;
float cosTheta = std::fmin(glm::dot(-input.direction(), rec.n), 1.f);
float sinTheta = std::sqrt(1.f - cosTheta * cosTheta);
bool internalReflection = (ratio * sinTheta) > 1.f;
if (internalReflection)
{
dir = GfxLib::reflect(glm::normalize(input.direction()), rec.n);
}
else
{
dir = GfxLib::refract(glm::normalize(input.direction()), rec.n, ratio);
}
}
scatterRay.setOrigin(rec.pt);
scatterRay.setDirection(dir);
// m_albedo is set to vec3(1.f)
attenuation = m_albedo;
return true;
}
outer method, rayColor is here:
glm::vec3 RrtTest::rayColor(const Ray& ray, const HittableList& objList, int reflectDepth)
{
if (reflectDepth <= 0) return glm::vec3(0.f);
HitRecord rec;
// use 0.001 instead of 0.f to fix shadow acne
if (objList.hit(ray, 0.001f, FLT_MAX, rec) && rec.hitInd >= 0)
{
Ray scatterRay;
glm::vec3 attenu{ 1.f };
std::shared_ptr<Matl> mat = objList.at(rec.hitInd)->getMatl();
if (!mat->scatter(ray, rec, attenu, scatterRay))
return glm::vec3(0.f);
glm::vec3 retColor = rayColor(scatterRay, objList, --reflectDepth);
return attenu * retColor;
}
else
{
glm::vec3 startColor{ 1.f }, endColor{ 0.5f, 0.7f, 1.f };
float t = (ray.direction().y + 1.f) * 0.5f;
return GfxLib::blend(startColor, endColor, t);
}
}
reflect method is here:
glm::vec3 GfxLib::reflect(const glm::vec3& directionIn, const glm::vec3& n)
{
float b = glm::dot(directionIn, n);
glm::vec3 refDir = directionIn - 2 * b * n;
return glm::normalize(refDir);
}
However, I am not sure my analysis is right or not, can any one lend me a hand and give me a solution for it? The main logic of the rendering is here(including the total demo).
i will really appreciate your advice!