And cones !

README.md

@@ -14,31 +14,31 @@ It is writen in C++ with no STL and use [LodePNG](https://github.com/lvandeve/lo
 Examples outputs
 ----------------
 
-From chapter 05:
+From chapter 05 - Sphere intersections:
 
 ![Chapter 5 rendering test](output/ch5_test.png)
 
-From Chapter 06:
+From Chapter 06 - Phong shading:
 
 ![Chapter 6 rendering test](output/ch6_test.png)
 
-From Chapter 07:
+From Chapter 07 - World / Camera / Scenes:
 
 ![Chapter 7 rendering test](output/ch7_test.png)
 
-From Chapter 08:
+From Chapter 08 - Shadows:
 
 ![Chapter 8 rendering test](output/ch8_test.png)
 
-From Chapter 09:
+From Chapter 09 - Planes:
 
 ![Chapter 9 rendering test](output/ch9_test.png)
 
-From Chapter 10:
+From Chapter 10 - Patterns:
 
 ![Chapter 10 rendering test](output/ch10_test.png)
 
-From Chapter 11:
+From Chapter 11 - Reflections, Transparency & Refractions
 
 ![Chapter 11 reflections rendering test](output/ch11_reflection.png)
 
@@ -46,6 +46,12 @@ From Chapter 11:
 
 ![Chapter 11 rendering test](output/ch11_test.png)
 
-From Chapter 12:
+From Chapter 12 - Cubes:
 
-![Chapter 12 rendering test](output/ch12_test.png)
+![Chapter 12 rendering test](output/ch12_test.png)
+
+From Chapter 13 - Cylinders:
+
+![Chapter 13 rendering test](output/ch13_test.png)
+Bonus:
+![Chapter 13 cone test](output/ch13_cone.png)

source/include/cone.h

@@ -0,0 +1,33 @@
+/*
+ *  DoRayMe - a quick and dirty Raytracer
+ *  Cone header
+ *
+ *  Created by Manoël Trapier
+ *  Copyright (c) 2020 986-Studio.
+ *
+ */
+#ifndef DORAYME_CONE_H
+#define DORAYME_CONE_H
+
+#include <shape.h>
+#include <ray.h>
+#include <intersect.h>
+
+class Cone : public Shape {
+protected:
+    Intersect localIntersect(Ray r);
+
+    Tuple localNormalAt(Tuple point);
+
+    bool checkCap(Ray r, double t, double y);
+    void intersectCaps(Ray r, Intersect &xs);
+
+public:
+    bool isClosed;
+    double minCap;
+    double maxCap;
+
+    Cone() : minCap(-INFINITY), maxCap(INFINITY), isClosed(false), Shape(SHAPE_CONE) {};
+};
+
+#endif /* DORAYME_CONE_H */

source/include/cylinder.h

@@ -0,0 +1,33 @@
+/*
+ *  DoRayMe - a quick and dirty Raytracer
+ *  Cylinder header
+ *
+ *  Created by Manoël Trapier
+ *  Copyright (c) 2020 986-Studio.
+ *
+ */
+#ifndef DORAYME_CYLINDER_H
+#define DORAYME_CYLINDER_H
+
+#include <shape.h>
+#include <ray.h>
+#include <intersect.h>
+
+class Cylinder : public Shape {
+private:
+    Intersect localIntersect(Ray r);
+
+    Tuple localNormalAt(Tuple point);
+
+    bool checkCap(Ray r, double t);
+    void intersectCaps(Ray r, Intersect &xs);
+
+public:
+    bool isClosed;
+    double minCap;
+    double maxCap;
+
+    Cylinder() : minCap(-INFINITY), maxCap(INFINITY), isClosed(false), Shape(SHAPE_CYLINDER) {};
+};
+
+#endif //DORAYME_CYLINDER_H

source/include/material.h

@@ -46,6 +46,7 @@ public:
                                                       double_equal(this->emissive, b.emissive) &&
                                                       double_equal(this->refractiveIndex, b.refractiveIndex) &&
                                                       (this->colour == b.colour); };
+    bool operator!=(const Material &b) const { return !(*this == b); };
 };
 
 

source/include/shape.h

@@ -23,6 +23,7 @@ enum ShapeType
     SHAPE_SPHERE,
     SHAPE_PLANE,
     SHAPE_CUBE,
+    SHAPE_CYLINDER,
     SHAPE_CONE,
 };
 

source/include/tuple.h

@@ -26,6 +26,7 @@ public:
                                                    double_equal(this->y, b.y) &&
                                                    double_equal(this->z, b.z) &&
                                                    double_equal(this->w, b.w); };
+    bool operator!=(const Tuple &b) const { return !(*this == b); };
 
     Tuple operator+(const Tuple &b) const { return Tuple(this->x + b.x, this->y + b.y,
                                                          this->z + b.z, this->w + b.w); };

source/math_helper.cpp

@@ -43,13 +43,8 @@ double min3(double a, double b, double c)
     if (b <= a)
     {
         if (c < b) return c;
-        return b;
     }
-    if (c <= a)
-    {
-        if (b < c) return b;
-    }
-    return c;
+    return b;
 }
 
 double max3(double a, double b, double c)
@@ -62,11 +57,6 @@ double max3(double a, double b, double c)
     if (b >= a)
     {
         if (c > b) return c;
-        return b;
     }
-    if (c >= a)
-    {
-        if (b > c) return b;
-    }
-    return c;
+    return b;
 }

source/shapes/cone.cpp

@@ -0,0 +1,124 @@
+/*
+ *  DoRayMe - a quick and dirty Raytracer
+ *  Cone implementation
+ *
+ *  Created by Manoël Trapier
+ *  Copyright (c) 2020 986-Studio.
+ *
+ */
+#include <tuple.h>
+#include <ray.h>
+#include <shape.h>
+#include <cone.h>
+#include <math_helper.h>
+
+bool Cone::checkCap(Ray r, double t, double y)
+{
+    /* Helping function to reduce duplication.
+     * Checks to see if the intersection ot t is within a radius
+     * of 1 (the radius of our Cone from the y axis
+     */
+    double x = r.origin.x + t * r.direction.x;
+    double z = r.origin.z + t * r.direction.z;
+    return (x * x + z * z) <= fabs(y);
+}
+
+void Cone::intersectCaps(Ray r, Intersect &xs)
+{
+    /* Caps only mattter is the Cone is closed, and might possibly be
+     * intersected by the ray
+     */
+    if ((this->isClosed) && (fabs(r.direction.y) > getEpsilon()))
+    {
+        double t;
+        /* Check for an intersection with the lower end cap by intersecting
+         * the ray with the plan at y = this->minCap
+         */
+        t = (this->minCap - r.origin.y) / r.direction.y;
+        if (this->checkCap(r, t, this->minCap))
+        {
+            xs.add(Intersection(t, this));
+        }
+
+        /* Check for an intersection with the upper end cap by intersecting
+         * the ray with the plan at y = this->maxCap
+         */
+        t = (this->maxCap - r.origin.y) / r.direction.y;
+        if (this->checkCap(r, t, this->maxCap))
+        {
+            xs.add(Intersection(t, this));
+        }
+    }
+}
+
+Intersect Cone::localIntersect(Ray r)
+{
+    Intersect ret;
+
+    double A = pow(r.direction.x, 2) -
+               pow(r.direction.y, 2) +
+               pow(r.direction.z, 2);
+    double B = (2 * r.origin.x * r.direction.x) -
+               (2 * r.origin.y * r.direction.y) +
+               (2 * r.origin.z * r.direction.z);
+
+    double C = pow(r.origin.x, 2) -
+               pow(r.origin.y, 2) +
+               pow(r.origin.z, 2);
+
+    if ((fabs(A) <= getEpsilon()) && (fabs(B) >= getEpsilon()))
+    {
+        double t = -C / (2*B);
+        ret.add(Intersection(t, this));
+    }
+    else if (fabs(A) >= getEpsilon())
+    {
+
+        double disc = pow(B, 2) - 4 * A * C;
+
+        if (disc >= 0)
+        {
+            double t0 = (-B - sqrt(disc)) / (2 * A);
+            double t1 = (-B + sqrt(disc)) / (2 * A);
+
+            double y0 = r.origin.y + t0 * r.direction.y;
+            if ((this->minCap < y0) && (y0 < this->maxCap))
+            {
+                ret.add(Intersection(t0, this));
+            }
+
+            double y1 = r.origin.y + t1 * r.direction.y;
+            if ((this->minCap < y1) && (y1 < this->maxCap))
+            {
+                ret.add(Intersection(t1, this));
+            }
+        }
+    }
+
+    this->intersectCaps(r, ret);
+
+    return ret;
+}
+
+Tuple Cone::localNormalAt(Tuple point)
+{
+    /* Compute the square of the distance from the Y axis */
+    double dist = point.x * point.x + point.z * point.z;
+
+    if ((dist < 1) && (point.y >= (this->maxCap - getEpsilon())))
+    {
+        return Vector(0, 1, 0);
+    }
+
+    if ((dist < 1) && (point.y <= this->minCap + getEpsilon()))
+    {
+        return Vector(0, -1, 0);
+    }
+
+    double y = sqrt(point.x * point.x + point.z * point.z);
+    if (point.y > 0)
+    {
+        y = -y;
+    }
+    return Vector(point.x, y, point.z);
+}

source/shapes/cylinder.cpp

@@ -0,0 +1,109 @@
+/*
+ *  DoRayMe - a quick and dirty Raytracer
+ *  Cylinder implementation
+ *
+ *  Created by Manoël Trapier
+ *  Copyright (c) 2020 986-Studio.
+ *
+ */
+#include <tuple.h>
+#include <ray.h>
+#include <shape.h>
+#include <cylinder.h>
+#include <math_helper.h>
+
+bool Cylinder::checkCap(Ray r, double t)
+{
+    /* Helping function to reduce duplication.
+     * Checks to see if the intersection ot t is within a radius
+     * of 1 (the radius of our cylinder from the y axis
+     */
+    double x = r.origin.x + t * r.direction.x;
+    double z = r.origin.z + t * r.direction.z;
+    return (x * x + z * z) <= 1;
+}
+
+void Cylinder::intersectCaps(Ray r, Intersect &xs)
+{
+    /* Caps only mattter is the cylinder is closed, and might possibly be
+     * intersected by the ray
+     */
+    if ((this->isClosed) && (fabs(r.direction.y) > getEpsilon()))
+    {
+        double t;
+        /* Check for an intersection with the lower end cap by intersecting
+         * the ray with the plan at y = this->minCap
+         */
+        t = (this->minCap - r.origin.y) / r.direction.y;
+        if (this->checkCap(r, t))
+        {
+            xs.add(Intersection(t, this));
+        }
+
+        /* Check for an intersection with the upper end cap by intersecting
+         * the ray with the plan at y = this->maxCap
+         */
+        t = (this->maxCap - r.origin.y) / r.direction.y;
+        if (this->checkCap(r, t))
+        {
+            xs.add(Intersection(t, this));
+        }
+    }
+}
+
+Intersect Cylinder::localIntersect(Ray r)
+{
+    Intersect ret;
+
+    double A = r.direction.x * r.direction.x + r.direction.z * r.direction.z;
+
+    /* Ray is parallel to the Y axis */
+    if (A >= getEpsilon())
+    {
+        double B = 2 * r.origin.x * r.direction.x +
+                   2 * r.origin.z * r.direction.z;
+        double C = r.origin.x * r.origin.x + r.origin.z * r.origin.z - 1;
+
+        double disc = B * B - 4 * A * C;
+
+        if (disc >= 0)
+        {
+            double t0 = (-B - sqrt(disc)) / (2 * A);
+            double t1 = (-B + sqrt(disc)) / (2 * A);
+
+            double y0 = r.origin.y + t0 * r.direction.y;
+            if ((this->minCap < y0) && (y0 < this->maxCap))
+            {
+                ret.add(Intersection(t0, this));
+            }
+
+            double y1 = r.origin.y + t1 * r.direction.y;
+            if ((this->minCap < y1) && (y1 < this->maxCap))
+            {
+                ret.add(Intersection(t1, this));
+            }
+        }
+    }
+
+    this->intersectCaps(r, ret);
+
+    return ret;
+}
+
+Tuple Cylinder::localNormalAt(Tuple point)
+{
+    /* Compute the square of the distance from the Y axis */
+    double dist = point.x * point.x + point.z * point.z;
+
+    if ((dist < 1) && (point.y >= (this->maxCap - getEpsilon())))
+    {
+        return Vector(0, 1, 0);
+    }
+
+    if ((dist < 1) && (point.y <= this->minCap + getEpsilon()))
+    {
+        return Vector(0, -1, 0);
+    }
+
+    return Vector(point.x, 0, point.z);
+}

source/tuple.cpp

@@ -19,6 +19,11 @@ double Tuple::magnitude()
 Tuple Tuple::normalise()
 {
     double mag = this->magnitude();
+    if (mag == 0)
+    {
+        return Tuple(0, 0, 0, 0);
+    }
+
     return Tuple(this->x / mag, this->y / mag, this->z / mag, this->w / mag);
 }
 

tests/CMakeLists.txt

@@ -5,7 +5,7 @@ find_package(Threads REQUIRED)
 
 set(TESTS_SRC math_test.cpp tuple_test.cpp colour_test.cpp canvas_test.cpp matrix_test.cpp transformation_test.cpp
         ray_test.cpp intersect_test.cpp sphere_test.cpp light_test.cpp material_test.cpp world_test.cpp camera_test.cpp
-        shape_test.cpp plane_test.cpp pattern_test.cpp cube_test.cpp)
+        shape_test.cpp plane_test.cpp pattern_test.cpp cube_test.cpp cylinder_test.cpp cone_test.cpp)
 
 add_executable(testMyRays)
 target_include_directories(testMyRays PUBLIC ${gtest_SOURCE_DIR}/include ${gtest_SOURCE_DIR})
@@ -69,6 +69,16 @@ target_include_directories(ch12_test PUBLIC ../source/include)
 target_sources(ch12_test PRIVATE ch12_test.cpp)
 target_link_libraries(ch12_test rayonnement)
 
+add_executable(ch13_test)
+target_include_directories(ch13_test PUBLIC ../source/include)
+target_sources(ch13_test PRIVATE ch13_test.cpp)
+target_link_libraries(ch13_test rayonnement)
+
+add_executable(ch13_cone)
+target_include_directories(ch13_cone PUBLIC ../source/include)
+target_sources(ch13_cone PRIVATE ch13_cone.cpp)
+target_link_libraries(ch13_cone rayonnement)
+
 add_test(NAME Chapter05_Test COMMAND $<TARGET_FILE:ch5_test>)
 add_test(NAME Chapter06_Test COMMAND $<TARGET_FILE:ch6_test>)
 add_test(NAME Chapter07_Test COMMAND $<TARGET_FILE:ch7_test>)
@@ -77,4 +87,7 @@ add_test(NAME Chapter10_Test COMMAND $<TARGET_FILE:ch10_test>)
 add_test(NAME Chapter11_Reflection COMMAND $<TARGET_FILE:ch11_reflection>)
 add_test(NAME Chapter11_Refraction COMMAND $<TARGET_FILE:ch11_refraction>)
 add_test(NAME Chapter11_Test COMMAND $<TARGET_FILE:ch11_test>)
-add_test(NAME Chapter12_Test COMMAND $<TARGET_FILE:ch12_test>)
+add_test(NAME Chapter12_Test COMMAND $<TARGET_FILE:ch12_test>)
+add_test(NAME Chapter13_Test COMMAND $<TARGET_FILE:ch13_test>)
+add_test(NAME Chapter13_ConeBonus COMMAND $<TARGET_FILE:ch13_cone>)
+add_test(NAME Hw3Render COMMAND $<TARGET_FILE:hw3render> ${CMAKE_CURRENT_SOURCE_DIR}/test.hw3scene)

tests/ch12_test.cpp

@@ -120,7 +120,7 @@ int main()
 
     /* Little cube 1 */
     Cube lilCube1 = Cube();
-    lilCube1.setTransform(translation(1, 3.25, -0.9) *
+    lilCube1.setTransform(translation(1, 3.35, -0.9) *
                            rotationY(-0.4) *
                            scaling(0.15, 0.15, 0.15));
     lilCube1.material.colour = Colour(1, 0.5, 0.5);

tests/ch13_cone.cpp

@@ -0,0 +1,204 @@
+/*
+ *  DoRayMe - a quick and dirty Raytracer
+ *  Render test for reflection in chapter 13.
+ *
+ *  Created by Manoël Trapier
+ *  Copyright (c) 2020 986-Studio.
+ *
+ */
+#include <world.h>
+#include <light.h>
+#include <sphere.h>
+#include <plane.h>
+#include <cube.h>
+#include <cylinder.h>
+#include <cone.h>
+#include <material.h>
+#include <colour.h>
+#include <canvas.h>
+#include <camera.h>
+
+#include <pattern.h>
+#include <strippattern.h>
+#include <gradientpattern.h>
+#include <checkerspattern.h>
+#include <ringpattern.h>
+
+#include <transformation.h>
+
+int main()
+{
+    World w = World();
+
+    /* Add light */
+    Light light = Light(POINT_LIGHT, Point(1, 6.9, -4.9), Colour(1, 1, 1));
+    w.addLight(&light);
+
+    /* ----------------------------- */
+
+    /* The floor */
+    Plane floor = Plane();
+    floor.material.pattern = new CheckersPattern(Colour(0.5, 0.5, 0.5), Colour(0.75, 0.75, 0.75));
+    floor.material.pattern->setTransform(rotationY(0.3) * scaling(0.25, 0.25, 0.25));
+    w.addObject(&floor);
+
+    Plane ceiling = Plane();
+    ceiling.material.pattern = new CheckersPattern(Colour(0.5, 0.2, 0.5), Colour(0.75, 0.4, 0.75));
+    ceiling.material.pattern->setTransform(rotationY(0.3));
+    ceiling.setTransform(translation(0, 8, 0));
+    w.addObject(&ceiling);
+
+    /* ----------------------------- */
+
+    Cone cyl1 = Cone();
+    cyl1.minCap = -1;
+    cyl1.maxCap = 0;
+    cyl1.isClosed = true;
+    cyl1.setTransform(translation(-1, 0, 1) * scaling(0.5, 1, 0.5) * translation(0, 1, 0));
+    cyl1.material.colour = Colour(0, 1, 0.6);
+    cyl1.material.diffuse = 0.1;
+    cyl1.material.specular = 0.9;
+    cyl1.material.shininess = 300;
+    cyl1.material.reflective = 0.3;
+    w.addObject(&cyl1);
+
+    /* ----------------------------- */
+
+    /* Concentrics */
+    Cylinder cons1 = Cylinder();
+    cons1.minCap = 0;
+    cons1.maxCap = 0.2;
+    cons1.isClosed = false;
+    cons1.setTransform(translation(1, 0, 0) * scaling(0.8, 1, 0.8));
+    cons1.material.colour = Colour(1, 1, 0.3);
+    cons1.material.ambient = 0.1;
+    cons1.material.diffuse = 0.8;
+    cons1.material.specular = 0.9;
+    cons1.material.shininess = 300;
+    cons1.material.reflective = 0.2;
+    w.addObject(&cons1);
+
+    Cylinder cons2 = Cylinder();
+    cons2.minCap = 0;
+    cons2.maxCap = 0.3;
+    cons2.isClosed = false;
+    cons2.setTransform(translation(1, 0, 0) * scaling(0.6, 1, 0.6));
+    cons2.material.colour = Colour(1, 0.9, 0.4);
+    cons2.material.ambient = 0.1;
+    cons2.material.diffuse = 0.8;
+    cons2.material.specular = 0.9;
+    cons2.material.shininess = 300;
+    cons2.material.reflective = 0.2;
+    w.addObject(&cons2);
+
+    Cylinder cons3 = Cylinder();
+    cons3.minCap = 0;
+    cons3.maxCap = 0.4;
+    cons3.isClosed = false;
+    cons3.setTransform(translation(1, 0, 0) * scaling(0.4, 1, 0.4));
+    cons3.material.colour = Colour(1, 0.8, 0.5);
+    cons3.material.ambient = 0.1;
+    cons3.material.diffuse = 0.8;
+    cons3.material.specular = 0.9;
+    cons3.material.shininess = 300;
+    cons3.material.reflective = 0.2;
+    w.addObject(&cons3);
+
+    Cylinder cons4 = Cylinder();
+    cons4.minCap = 0;
+    cons4.maxCap = 0.5;
+    cons4.isClosed = true;
+    cons4.setTransform(translation(1, 0, 0) * scaling(0.2, 1, 0.2));
+    cons4.material.colour = Colour(1, 0.7, 0.6);
+    cons4.material.ambient = 0.1;
+    cons4.material.diffuse = 0.8;
+    cons4.material.specular = 0.9;
+    cons4.material.shininess = 300;
+    cons4.material.reflective = 0.2;
+    w.addObject(&cons4);
+
+    /* ----------------------------- */
+
+    /* decoratives cylinders */
+    Cylinder deco1 = Cylinder();
+    deco1.minCap = 0;
+    deco1.maxCap = 0.3;
+    deco1.isClosed = true;
+    deco1.setTransform(translation(0, 0, -0.75) * scaling(0.05, 1, 0.05));
+    deco1.material.colour = Colour(1, 0, 0);
+    deco1.material.ambient = 0.1;
+    deco1.material.diffuse = 0.9;
+    deco1.material.specular = 0.9;
+    deco1.material.shininess = 300;
+    deco1.material.reflective = 0.5;
+    w.addObject(&deco1);
+
+    Cylinder deco2 = Cylinder();
+    deco2.minCap = 0;
+    deco2.maxCap = 0.3;
+    deco2.isClosed = true;
+    deco2.setTransform(translation(0, 0, -2.25) * rotationY(-0.15) * translation(0, 0, 1.5) * scaling(0.05, 1, 0.05));
+    deco2.material.colour = Colour(1, 1, 0);
+    deco2.material.ambient = 0.1;
+    deco2.material.diffuse = 0.9;
+    deco2.material.specular = 0.9;
+    deco2.material.shininess = 300;
+    deco2.material.reflective = 0.5;
+    w.addObject(&deco2);
+
+    Cylinder deco3 = Cylinder();
+    deco3.minCap = 0;
+    deco3.maxCap = 0.3;
+    deco3.isClosed = true;
+    deco3.setTransform(translation(0, 0, -2.25) * rotationY(-0.3) * translation(0, 0, 1.5) * scaling(0.05, 1, 0.05));
+    deco3.material.colour = Colour(0, 1, 0);
+    deco3.material.ambient = 0.1;
+    deco3.material.diffuse = 0.9;
+    deco3.material.specular = 0.9;
+    deco3.material.shininess = 300;
+    deco3.material.reflective = 0.5;
+    w.addObject(&deco3);
+
+    Cylinder deco4 = Cylinder();
+    deco4.minCap = 0;
+    deco4.maxCap = 0.3;
+    deco4.isClosed = true;
+    deco4.setTransform(translation(0, 0, -2.25) * rotationY(-0.45) * translation(0, 0, 1.5) * scaling(0.05, 1, 0.05));
+    deco4.material.colour = Colour(0, 1, 1);
+    deco4.material.ambient = 0.1;
+    deco4.material.diffuse = 0.9;
+    deco4.material.specular = 0.9;
+    deco4.material.shininess = 300;
+    deco4.material.reflective = 0.5;
+    w.addObject(&deco4);
+
+    /* ----------------------------- */
+
+    Cone glassCylinder = Cone();
+    glassCylinder.minCap = 0.001;
+    glassCylinder.maxCap = 1;
+    glassCylinder.isClosed = true;
+    glassCylinder.dropShadow = false;
+    glassCylinder.setTransform(translation(0, 0, -1.5) * scaling(0.33, 1, 0.33));
+    glassCylinder.material.colour = Colour(0.2, 0.63, 0.24);
+    glassCylinder.material.diffuse = 0.1;
+    glassCylinder.material.specular = 0.9;
+    glassCylinder.material.shininess = 300;
+    glassCylinder.material.reflective = 0.3;
+    w.addObject(&glassCylinder);
+
+    /* ----------------------------- */
+
+    /* Set the camera */
+    Camera camera = Camera(400, 200, 0.314);
+    camera.setTransform(viewTransform(Point(8, 3.5, -9),
+                                      Point(0, 0.3, 0),
+                                      Vector(0, 1, 0)));
+
+    /* Now render it */
+    Canvas image = camera.render(w, 20);
+
+    image.SaveAsPNG("ch13_cone.png");
+
+    return 0;
+}

tests/ch13_test.cpp

@@ -0,0 +1,191 @@
+/*
+ *  DoRayMe - a quick and dirty Raytracer
+ *  Render test for reflection in chapter 13.
+ *
+ *  Created by Manoël Trapier
+ *  Copyright (c) 2020 986-Studio.
+ *
+ */
+#include <world.h>
+#include <light.h>
+#include <sphere.h>
+#include <plane.h>
+#include <cube.h>
+#include <cylinder.h>
+#include <material.h>
+#include <colour.h>
+#include <canvas.h>
+#include <camera.h>
+
+#include <pattern.h>
+#include <strippattern.h>
+#include <gradientpattern.h>
+#include <checkerspattern.h>
+#include <ringpattern.h>
+
+#include <transformation.h>
+
+int main()
+{
+    World w = World();
+
+    /* Add light */
+    Light light = Light(POINT_LIGHT, Point(1, 6.9, -4.9), Colour(1, 1, 1));
+    w.addLight(&light);
+
+    /* ----------------------------- */
+
+    /* The floor / ceiling */
+    Plane floor = Plane();
+    floor.material.pattern = new CheckersPattern(Colour(0.5, 0.5, 0.5), Colour(0.75, 0.75, 0.75));
+    floor.material.pattern->setTransform(rotationY(0.3) * scaling(0.25, 0.25, 0.25));
+    w.addObject(&floor);
+
+    /* ----------------------------- */
+
+    Cylinder cyl1 = Cylinder();
+    cyl1.minCap = 0;
+    cyl1.maxCap = 0.75;
+    cyl1.isClosed = true;
+    cyl1.setTransform(translation(-1, 0, 1) * scaling(0.5, 1, 0.5));
+    cyl1.material.colour = Colour(0, 0, 0.6);
+    cyl1.material.diffuse = 0.1;
+    cyl1.material.specular = 0.9;
+    cyl1.material.shininess = 300;
+    cyl1.material.reflective = 0.9;
+    w.addObject(&cyl1);
+
+    /* ----------------------------- */
+
+    /* Concentrics */
+    Cylinder cons1 = Cylinder();
+    cons1.minCap = 0;
+    cons1.maxCap = 0.2;
+    cons1.isClosed = false;
+    cons1.setTransform(translation(1, 0, 0) * scaling(0.8, 1, 0.8));
+    cons1.material.colour = Colour(1, 1, 0.3);
+    cons1.material.ambient = 0.1;
+    cons1.material.diffuse = 0.8;
+    cons1.material.specular = 0.9;
+    cons1.material.shininess = 300;
+    w.addObject(&cons1);
+
+    Cylinder cons2 = Cylinder();
+    cons2.minCap = 0;
+    cons2.maxCap = 0.3;
+    cons2.isClosed = false;
+    cons2.setTransform(translation(1, 0, 0) * scaling(0.6, 1, 0.6));
+    cons2.material.colour = Colour(1, 0.9, 0.4);
+    cons2.material.ambient = 0.1;
+    cons2.material.diffuse = 0.8;
+    cons2.material.specular = 0.9;
+    cons2.material.shininess = 300;
+    w.addObject(&cons2);
+
+    Cylinder cons3 = Cylinder();
+    cons3.minCap = 0;
+    cons3.maxCap = 0.4;
+    cons3.isClosed = false;
+    cons3.setTransform(translation(1, 0, 0) * scaling(0.4, 1, 0.4));
+    cons3.material.colour = Colour(1, 0.8, 0.5);
+    cons3.material.ambient = 0.1;
+    cons3.material.diffuse = 0.8;
+    cons3.material.specular = 0.9;
+    cons3.material.shininess = 300;
+    w.addObject(&cons3);
+
+    Cylinder cons4 = Cylinder();
+    cons4.minCap = 0;
+    cons4.maxCap = 0.5;
+    cons4.isClosed = true;
+    cons4.setTransform(translation(1, 0, 0) * scaling(0.2, 1, 0.2));
+    cons4.material.colour = Colour(1, 0.7, 0.6);
+    cons4.material.ambient = 0.1;
+    cons4.material.diffuse = 0.8;
+    cons4.material.specular = 0.9;
+    cons4.material.shininess = 300;
+    w.addObject(&cons4);
+
+    /* ----------------------------- */
+
+    /* decoratives cylinders */
+    Cylinder deco1 = Cylinder();
+    deco1.minCap = 0;
+    deco1.maxCap = 0.3;
+    deco1.isClosed = true;
+    deco1.setTransform(translation(0, 0, -0.75) * scaling(0.05, 1, 0.05));
+    deco1.material.colour = Colour(1, 0, 0);
+    deco1.material.ambient = 0.1;
+    deco1.material.diffuse = 0.9;
+    deco1.material.specular = 0.9;
+    deco1.material.shininess = 300;
+    w.addObject(&deco1);
+
+    Cylinder deco2 = Cylinder();
+    deco2.minCap = 0;
+    deco2.maxCap = 0.3;
+    deco2.isClosed = true;
+    deco2.setTransform(translation(0, 0, -2.25) * rotationY(-0.15) * translation(0, 0, 1.5) * scaling(0.05, 1, 0.05));
+    deco2.material.colour = Colour(1, 1, 0);
+    deco2.material.ambient = 0.1;
+    deco2.material.diffuse = 0.9;
+    deco2.material.specular = 0.9;
+    deco2.material.shininess = 300;
+    w.addObject(&deco2);
+
+    Cylinder deco3 = Cylinder();
+    deco3.minCap = 0;
+    deco3.maxCap = 0.3;
+    deco3.isClosed = true;
+    deco3.setTransform(translation(0, 0, -2.25) * rotationY(-0.3) * translation(0, 0, 1.5) * scaling(0.05, 1, 0.05));
+    deco3.material.colour = Colour(0, 1, 0);
+    deco3.material.ambient = 0.1;
+    deco3.material.diffuse = 0.9;
+    deco3.material.specular = 0.9;
+    deco3.material.shininess = 300;
+    w.addObject(&deco3);
+
+    Cylinder deco4 = Cylinder();
+    deco4.minCap = 0;
+    deco4.maxCap = 0.3;
+    deco4.isClosed = true;
+    deco4.setTransform(translation(0, 0, -2.25) * rotationY(-0.45) * translation(0, 0, 1.5) * scaling(0.05, 1, 0.05));
+    deco4.material.colour = Colour(0, 1, 1);
+    deco4.material.ambient = 0.1;
+    deco4.material.diffuse = 0.9;
+    deco4.material.specular = 0.9;
+    deco4.material.shininess = 300;
+    w.addObject(&deco4);
+
+    /* ----------------------------- */
+
+    /* glass cylinder */
+    Cylinder glassCylinder = Cylinder();
+    glassCylinder.minCap = 0.0001;
+    glassCylinder.maxCap = 0.5;
+    glassCylinder.isClosed = true;
+    glassCylinder.setTransform(translation(0, 0, -1.5) * scaling(0.33, 1, 0.33));
+    glassCylinder.material.colour = Colour(0.25, 0, 0);
+    glassCylinder.material.diffuse = 0.1;
+    glassCylinder.material.specular = 0.9;
+    glassCylinder.material.shininess = 300;
+    glassCylinder.material.reflective = 0.9;
+    glassCylinder.material.transparency = 0.9;
+    glassCylinder.material.refractiveIndex = 1.5;
+    w.addObject(&glassCylinder);
+
+    /* ----------------------------- */
+
+    /* Set the camera */
+    Camera camera = Camera(400, 200, 0.314);
+    camera.setTransform(viewTransform(Point(8, 3.5, -9),
+                                      Point(0, 0.3, 0),
+                                      Vector(0, 1, 0)));
+
+    /* Now render it */
+    Canvas image = camera.render(w, 20);
+
+    image.SaveAsPNG("ch13_test.png");
+
+    return 0;
+}

tests/cone_test.cpp

@@ -0,0 +1,132 @@
+/*
+ *  DoRayMe - a quick and dirty Raytracer
+ *  Cone unit tests
+ *
+ *  Created by Manoël Trapier
+ *  Copyright (c) 2020 986-Studio.
+ *
+ */
+#include <intersect.h>
+#include <intersection.h>
+#include <cone.h>
+#include <transformation.h>
+#include <gtest/gtest.h>
+
+class ConeTest : public Cone
+{
+public:
+    Tuple doLocalNormalAt(Tuple point)
+    {
+        return localNormalAt(point);
+    }
+};
+
+TEST(ConeTest, Intersecting_a_cone_with_a_ray)
+{
+    Cone cone = Cone();
+
+    Point Origins[] = {
+            Point(0, 0, -5),
+            Point(0, 0, -5),
+            Point(1, 1, -5),
+    };
+
+    Vector Directions[] = {
+            Vector(0, 0, 1),
+            Vector(1, 1, 1),
+            Vector(-0.5, -1, 1),
+    };
+
+    double t0s[] = { 5, 8.66025, 4.55006 };
+    double t1s[] = { 5, 8.66025, 49.44994 };
+
+    int i;
+    for(i = 0; i < 3; i++)
+    {
+        Tuple direction = Directions[i].normalise();
+        Ray r = Ray(Origins[i], direction);
+
+        Intersect xs = cone.intersect(r);
+
+        /* Temporary lower the precision */
+        set_equal_precision(0.00001);
+
+        ASSERT_EQ(xs.count(), 2);
+        EXPECT_TRUE(double_equal(xs[0].t, t0s[i]));
+        EXPECT_TRUE(double_equal(xs[1].t, t1s[i]));
+
+        set_equal_precision(FLT_EPSILON);
+    }
+}
+
+TEST(ConeTest, Intersecting_a_cone_with_a_ray_parall_to_one_of_its_halves)
+{
+    Cone cone = Cone();
+    Tuple direction = Vector(0, 1, 1).normalise();
+    Ray r = Ray(Point(0, 0, -1), direction);
+    Intersect xs = cone.intersect(r);
+    ASSERT_EQ(xs.count(), 1);
+
+    /* Temporary lower the precision */
+    set_equal_precision(0.00001);
+
+    ASSERT_TRUE(double_equal(xs[0].t, 0.35355));
+
+    set_equal_precision(FLT_EPSILON);
+
+}
+TEST(ConeTest, Intersecting_a_cone_end_cap)
+{
+    Point Origins[] = {
+            Point(0, 0, -5),
+            Point(0, 0, -0.25),
+            Point(0, 0, -0.25),
+    };
+    
+    Vector Directions[] = {
+            Vector(0, 1, 0),
+            Vector(0, 1, 1),
+            Vector(0, 1, 0),
+    };
+    
+    uint32_t Counts[] = { 0, 2, 4 };
+    
+    Cone cone = Cone();
+    cone.minCap = -0.5;
+    cone.maxCap = 0.5;
+    cone.isClosed = true;
+    
+    int i;
+    for(i = 0; i < 3; i++)
+    {
+        Tuple direction = Directions[i].normalise();
+        Ray r = Ray(Origins[i], direction);
+
+        Intersect xs = cone.intersect(r);
+
+        ASSERT_EQ(xs.count(), Counts[i]);
+    }
+}
+
+TEST(ConeTest, Computing_the_normal_vector_on_a_cone)
+{
+    ConeTest cone = ConeTest();
+
+    Point HitPointss[] = {
+            Point(0, 0, 0),
+            Point(1, 1, 1),
+            Point(-1, -1, 0),
+    };
+
+    Vector Normals[] = {
+            Vector(0, 0, 0),
+            Vector(1, -sqrt(2), 1),
+            Vector(-1, 1, 0),
+    };
+
+    int i;
+    for(i = 0; i < 3; i++)
+    {
+        ASSERT_EQ(cone.doLocalNormalAt(HitPointss[i]), Normals[i]);
+    }
+}

tests/cylinder_test.cpp

@@ -0,0 +1,223 @@
+/*
+ *  DoRayMe - a quick and dirty Raytracer
+ *  Cylinder unit tests
+ *
+ *  Created by Manoël Trapier
+ *  Copyright (c) 2020 986-Studio.
+ *
+ */
+#include <intersect.h>
+#include <intersection.h>
+#include <cylinder.h>
+#include <transformation.h>
+#include <gtest/gtest.h>
+
+TEST(CylinderTest, A_ray_miss_a_cylinder)
+{
+    Cylinder cyl = Cylinder();
+
+    Point Origins[] = {
+            Point(1, 0, 0),
+            Point(0, 0, 0),
+            Point(0, 0, -5),
+    };
+
+    Vector Directions[] = {
+            Vector(0, 1, 0),
+            Vector(0, 1, 0),
+            Vector(1, 1, 1),
+    };
+
+    int i;
+    for(i = 0; i < 3; i++)
+    {
+        Tuple direction = Directions[i].normalise();
+        Ray r = Ray(Origins[i], direction);
+
+        Intersect xs = cyl.intersect(r);
+
+        ASSERT_EQ(xs.count(), 0);
+    }
+}
+
+TEST(CylinderTest, A_ray_hit_a_cylinder)
+{
+    Cylinder cyl = Cylinder();
+
+    Point Origins[] = {
+            Point(1, 0, -5),
+            Point(0, 0, -5),
+            Point(0.5, 0, -5),
+    };
+
+    Vector Directions[] = {
+            Vector(0, 0, 1),
+            Vector(0, 0, 1),
+            Vector(0.1, 1, 1),
+    };
+
+    double t0s[] = { 5, 4, 6.80798 };
+    double t1s[] = { 5, 6, 7.08872 };
+
+    int i, j;
+    for(i = 0; i < 3; i++)
+    {
+        Tuple direction = Directions[i].normalise();
+        Ray r = Ray(Origins[i], direction);
+
+        Intersect xs = cyl.intersect(r);
+
+        /* Temporary lower the precision */
+        set_equal_precision(0.00001);
+
+        ASSERT_EQ(xs.count(), 2);
+        EXPECT_TRUE(double_equal(xs[0].t, t0s[i]));
+        EXPECT_TRUE(double_equal(xs[1].t, t1s[i]));
+
+        set_equal_precision(FLT_EPSILON);
+    }
+}
+
+TEST(CylinderTest, Normal_vector_on_a_cylinder)
+{
+    Cylinder cyl = Cylinder();
+
+    Point HitPointss[] = {
+            Point(1, 0, 0),
+            Point(0, 5, -1),
+            Point(0, -2, 1),
+            Point(-1, 1, 0),
+    };
+
+    Vector Normals[] = {
+            Vector(1, 0, 0),
+            Vector(0, 0, -1),
+            Vector(0, 0, 1),
+            Vector(-1, 0, 0),
+    };
+
+    int i;
+    for(i = 0; i < 4; i++)
+    {
+        ASSERT_EQ(cyl.normalAt(HitPointss[i]), Normals[i]);
+    }
+}
+
+TEST(CylinderTest, The_default_minimum_and_maximum_for_a_cylinder)
+{
+    Cylinder cyl = Cylinder();
+    ASSERT_EQ(cyl.minCap, -INFINITY);
+    ASSERT_EQ(cyl.maxCap, INFINITY);
+}
+
+TEST(CylinderTest, Intersecting_a_constrained_cylinder)
+{
+    Point Origins[] = {
+            Point(0, 1.5, 0),
+            Point(0, 3, -5),
+            Point(0, 0, -5),
+            Point(0, 2, -5),
+            Point(0, 1, -5),
+            Point(0, 1.5, -2),
+    };
+
+    Vector Directions[] = {
+            Vector(0.1, 1, 0),
+            Vector(0, 0, 1),
+            Vector(0, 0, 1),
+            Vector(0, 0, 1),
+            Vector(0, 0, 1),
+            Vector(0., 0, 1),
+    };
+
+    uint32_t Counts[] = { 0, 0, 0, 0, 0, 2 };
+
+    Cylinder cyl = Cylinder();
+    cyl.minCap = 1;
+    cyl.maxCap = 2;
+
+    int i;
+    for(i = 0; i < 6; i++)
+    {
+        Tuple direction = Directions[i].normalise();
+        Ray r = Ray(Origins[i], direction);
+
+        Intersect xs = cyl.intersect(r);
+
+        ASSERT_EQ(xs.count(), Counts[i]);
+    }
+}
+
+TEST(CylinderTest, The_default_closed_value_for_a_cylinder)
+{
+    Cylinder cyl = Cylinder();
+    ASSERT_EQ(cyl.isClosed, false);
+}
+TEST(CylinderTest, Intersecting_the_caps_of_a_close_cylinder)
+{
+    Point Origins[] = {
+            Point(0, 3, 0),
+            Point(0, 3, -2),
+            Point(0, 4, -2),  /* Edge case */
+            Point(0, 0, -5),
+            Point(0, -1, -2), /* Edge case */
+    };
+
+    Vector Directions[] = {
+            Vector(0, -1, 0),
+            Vector(0, -1, 2),
+            Vector(0, -1, 1),
+            Vector(0, 1, 2),
+            Vector(0, 1, 1),
+     };
+
+    uint32_t Counts[] = { 2, 2, 2, 2, 2 };
+
+    Cylinder cyl = Cylinder();
+    cyl.minCap = 1;
+    cyl.maxCap = 2;
+    cyl.isClosed = true;
+
+    int i;
+    for(i = 0; i < 5; i++)
+    {
+        Tuple direction = Directions[i].normalise();
+        Ray r = Ray(Origins[i], direction);
+
+        Intersect xs = cyl.intersect(r);
+        ASSERT_EQ(xs.count(), Counts[i]);
+    }
+}
+
+TEST(CylinderTest, The_normal_on_a_cylinder_end_cap)
+{
+    Cylinder cyl = Cylinder();
+
+    Point HitPointss[] = {
+            Point(0, 1, 0),
+            Point(0.5, 1, 0),
+            Point(0, 1, 0.5),
+            Point(0, 2, 0),
+            Point(0.5, 2, 0),
+            Point(0, 2, 0.5),
+    };
+
+    Vector Normals[] = {
+            Vector(0, -1, 0),
+            Vector(0, -1, 0),
+            Vector(0, -1, 0),
+            Vector(0, 1, 0),
+            Vector(0, 1, 0),
+            Vector(0, 1, 0),
+    };
+
+    cyl.minCap = 1;
+    cyl.maxCap = 2;
+    cyl.isClosed = true;
+
+    int idx;
+    for(idx = 0; idx < 6; idx++)
+    {
+        ASSERT_EQ(cyl.normalAt(HitPointss[idx]), Normals[idx]);
+    }
+}

tests/material_test.cpp

@@ -121,4 +121,47 @@ TEST(MaterialTest, Transparency_and_refractive_index_for_the_default_material)
 
     ASSERT_EQ(m.transparency, 0.0);
     ASSERT_EQ(m.refractiveIndex, 1.0);
+}
+
+TEST(MaterialTest, Equality_tests)
+{
+    Material m = Material();
+    Material m2 = Material();
+
+    ASSERT_EQ(m, m2);
+
+    m.ambient = 42;
+    ASSERT_NE(m, m2);
+    m.ambient = m2.ambient;
+
+    m.diffuse = 42;
+    ASSERT_NE(m, m2);
+    m.diffuse = m2.diffuse;
+
+    m.specular = 42;
+    ASSERT_NE(m, m2);
+    m.specular = m2.specular;
+
+    m.shininess = 42;
+    ASSERT_NE(m, m2);
+    m.shininess = m2.shininess;
+
+    m.reflective = 42;
+    ASSERT_NE(m, m2);
+    m.reflective = m2.reflective;
+
+    m.transparency = 42;
+    ASSERT_NE(m, m2);
+    m.transparency = m2.transparency;
+
+    m.emissive = 42;
+    ASSERT_NE(m, m2);
+    m.emissive = m2.emissive;
+
+    m.refractiveIndex = 42;
+    ASSERT_NE(m, m2);
+    m.refractiveIndex = m2.refractiveIndex;
+
+    m.colour = Colour(32, 32, 32);
+    ASSERT_NE(m, m2);
 }

tests/test.hw3scene

@@ -0,0 +1,9 @@
+# A ball lit by 3 lights
+camera 0 0 -1 0 0 0 0 1 0 45
+
+point 0 4 0 .7 .2 .2
+#point 4 0 4 .5 .5 .5
+point 4 -4 0 .2 .7 .2
+point -4 -4 0 .2 .2 .7
+
+sphere 0 0 0 .3

tests/tuple_test.cpp

@@ -22,6 +22,22 @@ TEST(TupleTest, Tuple_With_w_equal_1_and_is_point)
     ASSERT_FALSE(a.isVector());
 }
 
+TEST(TupleTest, Two_tuples_are_equal)
+{
+    Tuple a = Tuple(1, 2, 3, 4);
+    Tuple b = Tuple(1, 2, 3, 4);
+    Tuple c = Tuple(4, 3, 2, 1);
+    Tuple d = Tuple(1, 2, 3, 5);
+    Tuple e = Tuple(1, 2, 5, 5);
+    Tuple f = Tuple(1, 5, 5, 5);
+
+    ASSERT_EQ(a, b);
+    ASSERT_NE(a, c);
+    ASSERT_NE(a, d);
+    ASSERT_NE(a, e);
+    ASSERT_NE(a, f);
+}
+
 TEST(TupleTest, Tuple_With_w_equal_0_and_is_vector)
 {
     Tuple a = Tuple(4.3, -4.2, 3.1, 0.0);