📫 Dielectric material

Author: michalbe

src/main.rs

@@ -12,7 +12,7 @@ use vec3D::Vec3D;
 use hitable::HitableList;
 use sphere::Sphere;
 use camera::Camera;
-use material::{ Material, Lambert, Metal };
+use material::{ Material, Lambert, Metal, Dielectric };
 use utils::color;
 
 fn main() {
@@ -47,7 +47,7 @@ fn main() {
     world.list.push(Box::new(Sphere::new(
         Vec3D::new(-1.0, 0.0, -1.0),
         0.5,
-        Material::Metal(Metal::new(Vec3D::new(0.8, 0.8, 0.8), 1.0))
+        Material::Dielectric(Dielectric::new(1.5))
     )));
 
     let camera = Camera::new();

src/material.rs

@@ -4,6 +4,8 @@ use crate::{
     utils::{
         random_in_unit_sphere,
         reflect,
+        refract,
+        schlick,
     },
 };
 
@@ -17,13 +19,15 @@ pub trait Scatter {
 pub enum Material {
     Lambert(Lambert),
     Metal(Metal),
+    Dielectric(Dielectric),
 }
 
 impl Scatter for Material {
     fn scatter(&self, ray_in: &Ray, rec: &HitRecord, attenuation: &mut Vec3D, scattered: &mut Ray) -> bool {
         match self {
             Material::Lambert(material) => material.scatter(ray_in, rec, attenuation, scattered),
             Material::Metal(material) => material.scatter(ray_in, rec, attenuation, scattered),
+            Material::Dielectric(material) => material.scatter(ray_in, rec, attenuation, scattered),
         }
     }
 }
@@ -67,6 +71,7 @@ impl Metal {
         }
     }
 }
+
 impl Scatter for Metal {
     fn scatter(&self, ray_in: &Ray, rec: &HitRecord, attenuation: &mut Vec3D, scattered: &mut Ray) -> bool {
         let reflected = reflect(ray_in.direction.unit(), rec.normal);
@@ -79,3 +84,59 @@ impl Scatter for Metal {
         scattered.direction.dot(rec.normal) > 0.0
     }
 }
+
+#[derive(Clone, Copy)]
+pub struct Dielectric {
+    ref_idx: f64,
+}
+
+impl Dielectric {
+    pub fn new(ref_idx: f64) -> Dielectric {
+        Dielectric {
+            ref_idx
+        }
+    }
+}
+
+impl Scatter for Dielectric {
+    fn scatter(&self, ray_in: &Ray, rec: &HitRecord, attenuation: &mut Vec3D, scattered: &mut Ray) -> bool {
+        let outward_normal: Vec3D;
+        let ni_over_nt: f64;
+        let mut refracted = Vec3D::new(0.0, 0.0, 0.0);
+        let reflect_prob: f64;
+        let cosine: f64;
+
+        let reflected = reflect(ray_in.direction.unit(), rec.normal);
+        attenuation.x = 1.0;
+        attenuation.y = 1.0;
+        attenuation.z = 1.0;
+
+        if ray_in.direction.dot(rec.normal) > 0.0 {
+            outward_normal = rec.normal * -1.0;
+            ni_over_nt = self.ref_idx;
+            cosine = self.ref_idx * ray_in.direction.dot(rec.normal) / ray_in.direction.mag();
+        } else {
+            outward_normal = rec.normal;
+            ni_over_nt = 1.0 / self.ref_idx;
+            cosine = ray_in.direction.dot(rec.normal) * -1.0 / ray_in.direction.mag();
+        }
+
+        if refract(ray_in.direction, outward_normal, ni_over_nt, &mut refracted) {
+            reflect_prob = schlick(cosine, self.ref_idx);
+        } else {
+            reflect_prob = 1.0;
+        }
+
+        if rand::random::<f64>() < reflect_prob {
+            // let new_scattered = Ray::new(rec.p, reflected);
+            scattered.direction = reflected;
+            scattered.origin = rec.p;
+        } else {
+            // let new_scattered = Ray::new(rec.p, refracted);
+            scattered.direction = refracted;
+            scattered.origin = rec.p;
+        }
+
+        true
+    }
+}

src/utils.rs

@@ -46,3 +46,25 @@ pub fn color(ray: Ray, world: &Hitable, depth: i32) -> Vec3D {
 pub fn reflect(v: Vec3D, n: Vec3D) -> Vec3D {
     v - n * v.dot(n) * 2.0
 }
+
+pub fn refract(v: Vec3D, n: Vec3D, ni_over_nt: f64, refracted: &mut Vec3D) -> bool {
+    let uv = v.unit();
+    let dt = uv.dot(n);
+    let discriminant = 1.0 - ni_over_nt * ni_over_nt * (1.0 - dt * dt);
+
+    if discriminant > 0.0 {
+        let new_refracted = (uv - n * dt) * ni_over_nt - n * (discriminant.sqrt());
+        refracted.x = new_refracted.x;
+        refracted.y = new_refracted.y;
+        refracted.z = new_refracted.z;
+        return true;
+    } else {
+        return false;
+    }
+}
+
+pub fn schlick(cosine: f64, ref_idx: f64) -> f64 {
+    let mut r0 = (1.0 - ref_idx) / (1.0 + ref_idx);
+    r0 = r0 * r0;
+    r0 + (1.0 - r0) * (1.0 - cosine).powi(5)
+}