Raytracing in one weekend in c++

GitHub Repository

Welcome to my adventure following the raytracing in one weekend series in C++.

Part 8

Dielectrics

Fancy word for a type glass/mirror

read this

Here's a better explanation

Dielectric (non-conductive) materials are often used to simulate substances like plastics, glass, water, and other non-metallic surfaces.

These materials interact differently with light compared to conductive materials (metals).

Light can penetrate the surface to some extent, and they have properties like transparency, reflection, and refraction.

Refraction

The refraction is defined by Snell's Law :

$$\eta ·sin\theta =\eta \prime ·sin\theta \prime$$

where:

θ and θ′ are the angles from the normal η and η′ are the refractive indices

useful values :

air = 1.0, glass [1.3; 1.7], diamond = 2.40

We determine the direction of the refracted ray by solving for sin θ′.

$$sin\theta =\frac{\eta }{\eta \prime }·sin\theta \prime$$

On the refracted side of the surface, there is a refracted ray R′ and a normal η′ and there exists an angle, θ′, between them.

We can split η′ into parts that are perpendicular and parallel to η′

$$\mathrm{R\prime }={\mathrm{R\prime }}_{\perp }+{\mathrm{R\prime }}_{\mathrm{||}}$$

Let's solve R

$${\mathrm{R\prime }}_{\perp }=\frac{\eta }{\eta \prime }(R+cos\theta n)$$

$${\mathrm{R\prime }}_{\mathrm{||}}=-\sqrt{1-{\left|{\mathrm{R\prime }}_{\perp }\right|}^2}n$$

We know that the dot product of 2 vectors is

$$a·b=|a||b|cos\theta$$

If we take a and b as unit vectors (of length 1) we get

$$a·b=cos\theta$$

We can now rewrite R’ perpendicular as

$${\mathrm{R\prime }}_{\perp }=\frac{\eta }{\eta \prime }(R+(-R·n)n)$$

in code

inline Vector3 Reflect(const Vector3& direction, const Vector3& normal)
{
   return direction - 2 * Dot(direction, normal) * normal;
}

inline Vector3 Refract(const Vector3& unitVector, const Vector3& normal, double refractionRatio)
{
   double cosTheta = fmin(Dot(-unitVector, normal), 1.0);
   Vector3 rayOutPerpendicular = refractionRatio * (unitVector + cosTheta * normal);
   Vector3 rayOutParallel = -sqrt(fabs(1.0 - rayOutPerpendicular.SquaredLength())) * normal;
   return rayOutPerpendicular + rayOutParallel;
}

Dielectrics Material

#pragma once

#include "Material.h"

class DielectricMaterial : public Material
{
private:
   double refractionIndex;

public:
   DielectricMaterial(double refIndex): refractionIndex(refIndex){}
   bool Scatter(const Ray& rRayIn, const HitInfo& hitInfo, Color& attenuation, Ray& scattered) const override;
};

the dielectric material will refract when possible

#include "DielectricMaterial.h"

#include "Hittable.h"

bool DielectricMaterial::Scatter(const Ray& rRayIn, const HitInfo& hitInfo, Color& attenuation, Ray& scattered) const
{
   attenuation = Color(1.0, 1.0, 1.0);
   double refractionRatio = hitInfo.frontFace ? (1.0 / refractionIndex) : refractionIndex;
  
   Vector3 unitDirection = Unit(rRayIn.GetDirection());
   double cosTheta = fmin(Dot(-unitDirection, hitInfo.normal), 1.0);
   double sinTheta = sqrt(1.0 - cosTheta * cosTheta);

   bool cannotRefract = refractionRatio * sinTheta > 1.0;
   Vector3 direction;

   if(cannotRefract) direction = Reflect(unitDirection, hitInfo.normal);
   else direction = Refract(unitDirection, hitInfo.normal, refractionRatio);

   scattered = Ray(hitInfo.coordinates, direction);
   
   return true;
}

Let's add it to the main

#include "Camera.h"
#include "DielectricMaterial.h"
#include "HittableCollection.h"
#include "LambertianMaterial.h"
#include "MetalMaterial.h"
#include "Sphere.h"

using namespace std;

int main(int argc, char* argv[])
{
   // World
   HittableCollection world;
   shared_ptr<Material> groundMat = make_shared<LambertianMaterial>(Color(0.8, 0.8, 0.0));
   shared_ptr<Material> leftMat = make_shared<DielectricMaterial>(1.5);
   shared_ptr<Material> centerMat = make_shared<LambertianMaterial>(Color(0.1, 0.2, 0.5));
   shared_ptr<Material> rightMat = make_shared<MetalMaterial>(Color(0.8, 0.6, 0.2), 0.0);
   
   world.Add(make_shared<Sphere>(Position(0,-100.5,-1), 100, groundMat));
   world.Add(make_shared<Sphere>(Position(0,0,-1), 0.5, centerMat));
   world.Add(make_shared<Sphere>(Position(-1,0,-1), 0.5, leftMat));
   world.Add(make_shared<Sphere>(Position(1, 0,-1), 0.5, rightMat));

  
   Camera camera(400, 16.0/9.0, 100, 50);
   camera.Render(world);
   
   return 0;
}

cool right, but we're not done yet

Schlick's Approximation

We know that the reflexivity of glass is impacted by the angle, the steeper the angle, the more reflective.

For example, if you look at the widow or a framed photo from the side, it will look like a mirror but if you are in front of it you will see through

Let's talk about Christophe Schlick's Approximation, it's a formula for approximating the contribution of the Fresnel factor in the specular reflection of light from a non-conducting interface (surface) between two media.

This makes it easier to simulate the way glass reflects light without having to use the complexity of real light.

Let's add this to code

#pragma once

#include "Material.h"

class DielectricMaterial : public Material
{
private:
   double refractionIndex;
   static double Reflectance(double cosine, double pRefractionIndex);
public:
   DielectricMaterial(double refIndex): refractionIndex(refIndex){}
   bool Scatter(const Ray& rRayIn, const HitInfo& hitInfo, Color& attenuation, Ray& scattered) const override;
  
};

#include "DielectricMaterial.h"

#include "Hittable.h"

double DielectricMaterial::Reflectance(double cosine, double pRefractionIndex)
{
   // Schlick approximation of reflectance
   double reflectance = (1 - pRefractionIndex) / (1 + pRefractionIndex);
   reflectance *= reflectance;
   return reflectance + (1 - reflectance)*pow((1 - cosine), 5);
}

bool DielectricMaterial::Scatter(const Ray& rRayIn, const HitInfo& hitInfo, Color& attenuation, Ray& scattered) const
{
   attenuation = Color(1.0, 1.0, 1.0);
   double refractionRatio = hitInfo.frontFace ? (1.0 / refractionIndex) : refractionIndex;
  
   Vector3 unitDirection = Unit(rRayIn.GetDirection());
   double cosTheta = fmin(Dot(-unitDirection, hitInfo.normal), 1.0);
   double sinTheta = sqrt(1.0 - cosTheta * cosTheta);

   bool cannotRefract = refractionRatio * sinTheta > 1.0;
   Vector3 direction;

   if(cannotRefract || Reflectance(cosTheta, refractionRatio) > RandomDouble()) direction = Reflect(unitDirection, hitInfo.normal);
   else direction = Refract(unitDirection, hitInfo.normal, refractionRatio);

   scattered = Ray(hitInfo.coordinates, direction);
   
   return true;
}

we can now add a "hollow" sphere to main

world.Add(make_shared<Sphere>(Position(0,-100.5,-1), 100, groundMat));
world.Add(make_shared<Sphere>(Position(0,0,-1), 0.5, centerMat));
world.Add(make_shared<Sphere>(Position(-1,0,-1), 0.5, leftMat));
world.Add(make_shared<Sphere>(Position(-1,0,-1), -0.4, leftMat));  // Hollow
world.Add(make_shared<Sphere>(Position(1, 0,-1), 0.5, rightMat));

Next up is a better camera

See ya