simple shadow implementation and miscellaneous conversion changes

ex2.cpp

@@ -18,7 +18,7 @@
 int main() {
   // Let's create a simple cornell box scene...
   SimpleScene scene;
-  scene.setEnvironmentMap(std::make_shared<Texture>("data/lion_env.png"));
+  scene.setEnvironmentMap(std::make_shared<Texture>("../data/lion_env.png"));
 
   auto mirror = std::make_shared<MirrorShader>();
   auto glass = std::make_shared<RefractionShader>(1.31f, 1.0f);

light/pointlight.cpp

@@ -6,18 +6,26 @@ PointLight::PointLight(Vector3d const &position, float intensity, Color const &c
 Light::Illumination PointLight::illuminate(Scene const &scene, Ray const &ray) const {
   // IMPLEMENT ME
   // Get the point on the surface
+  Vector3d intersectionPoint = ray.origin + ray.length * ray.direction;
 
   // Create an instance of the Illumination object, fill in the direction (from
   // surface point to light source)
   Light::Illumination illum;
+  illum.direction = normalized(this->position - intersectionPoint);
 
   // Define a secondary ray from the surface point to the light source.
+  Ray lightRay = Ray(intersectionPoint, this->position - intersectionPoint);
 
   // If the target is not in shadow... (use scene.findOcclusion())
 
+  bool inShadow = scene.findOcclusion(lightRay);
+
   // Compute the brightness-color of this light using inverse squared distance
   // to light source (i.e. 1/(d^2)), the color of this light source and the
   // intensity
+  if (!inShadow) {
+      illum.color = (this->intensity / pow(length(this->position - intersectionPoint), 2)) * this->color;
+  }
 
   return illum;
 }

primitive/triangle.cpp

@@ -77,7 +77,7 @@ bool Triangle::intersect(Ray &ray) const {
 
   // Make sure the ray is not parallel to the triangle
   float const det = dotProduct(edge1, pVec);
-  if (fabs(det) < EPSILON)
+  if (std::abs(det) < EPSILON)
     return false;
   float const inv_det = 1.0f / det;
 

shader/refractionshader.cpp

@@ -11,11 +11,10 @@ Color RefractionShader::shade(Scene const &scene, Ray const &ray) const {
     // Send out a new refracted ray into the scene; recursively call traceRay()
 
     if (ray.getRemainingBounces() < 1) {
-        return Color(0,0,0);
+        return {0,0,0};
     }
-
     Vector3d n = ray.normal;
-    double root = sqrt(1 - (indexOutside*indexOutside*(1 - dotProduct(ray.direction, n)
+    float root = std::sqrt(1 - (indexOutside*indexOutside*(1 - dotProduct(ray.direction, n)
             *dotProduct(ray.direction, n)))/(indexInside*indexInside));
 
     Vector3d t = (indexOutside/indexInside)*(ray.direction - dotProduct(ray.direction, n) * n)- n * root;

shader/simpleshadowshader.cpp

@@ -8,5 +8,11 @@ Color SimpleShadowShader::shade(Scene const &scene, Ray const &ray) const {
   // IMPLEMENT ME
   // loop over all light sources to check for visibility and multiply "light
   // strength" with this objects albedo (color)
-  return this->objectColor;
+
+  Color color = Color(0, 0, 0);
+  for (auto light : scene.lights()) {
+      color += this->objectColor * light->illuminate(scene, ray).color;
+  }
+
+  return color;
 }