Add support for point light and materials.

Add material to objects.

source/CMakeLists.txt

@@ -5,8 +5,10 @@ add_library(rayonnement STATIC)
 
 set(RAY_HEADERS include/tuple.h include/math_helper.h include/colour.h include/canvas.h
         include/matrix.h include/transformation.h include/intersect.h include/intersection.h
+        include/light.h include/material.h
         include/object.h include/ray.h include/sphere.h)
 set(RAY_SOURCES tuple.cpp math_helper.cpp colour.cpp canvas.cpp matrix.cpp transformation.cpp intersect.cpp
+        objects/light.cpp objects/material.cpp
         objects/object.cpp objects/ray.cpp objects/sphere.cpp)
 
 target_include_directories(rayonnement PUBLIC include)

source/include/light.h

@@ -0,0 +1,32 @@
+/*
+ *  DoRayMe - a quick and dirty Raytracer
+ *  Light header
+ *
+ *  Created by Manoël Trapier
+ *  Copyright (c) 2020 986-Studio.
+ *
+ */
+#ifndef DORAYME_LIGHT_H
+#define DORAYME_LIGHT_H
+
+#include <tuple.h>
+#include <colour.h>
+
+enum LightType
+{
+    POINT_LIGHT = 0,
+};
+
+class Light
+{
+public:
+    Colour intensity;
+    Tuple position;
+    LightType type;
+
+public:
+    Light(LightType type = POINT_LIGHT, Tuple position=Point(0, 0, 0),
+          Colour intensity=Colour(1, 1, 1)) : type(type), position(position), intensity(intensity) { };
+};
+
+#endif //DORAYME_LIGHT_H

source/include/material.h

@@ -0,0 +1,37 @@
+/*
+ *  DoRayMe - a quick and dirty Raytracer
+ *  Material header
+ *
+ *  Created by Manoël Trapier
+ *  Copyright (c) 2020 986-Studio.
+ *
+ */
+#ifndef DORAYME_MATERIAL_H
+#define DORAYME_MATERIAL_H
+
+#include <tuple.h>
+#include <colour.h>
+#include <light.h>
+
+class Material
+{
+public:
+    Colour colour;
+    double ambient;
+    double diffuse;
+    double specular;
+    double shininess;
+
+public:
+    Material() : colour(Colour(1, 1, 1)), ambient(0.1), diffuse(0.9), specular(0.9), shininess(200) {};
+
+    Colour lighting(Light light, Tuple point, Tuple eyeVector, Tuple normalVector);
+
+    bool operator==(const Material &b) const { return double_equal(this->ambient,   b.ambient) &&
+                                                      double_equal(this->diffuse,   b.diffuse) &&
+                                                      double_equal(this->specular,  b.specular) &&
+                                                      double_equal(this->shininess, b.shininess) &&
+                                                      (this->colour == b.colour); };
+};
+
+#endif //DORAYME_MATERIAL_H

source/include/object.h

@@ -15,6 +15,7 @@ class Object;
 #include <tuple.h>
 #include <matrix.h>
 #include <intersect.h>
+#include <material.h>
 
 /* Base class for all object that can be presented in the world */
 class Object
@@ -22,12 +23,16 @@ class Object
 public:
     Matrix transformMatrix;
     Matrix inverseTransform;
+    Material material;
 
 public:
     Object();
 
     virtual Intersect intersect(Ray r);
+    virtual Tuple normalAt(Tuple point);
+
     void setTransform(Matrix transform);
+    void setMaterial(Material material) { this->material = material; };
     Ray transform(Ray r) {  return Ray(this->transformMatrix * r.origin, this->transformMatrix * r.direction); };
     Ray invTransform(Ray r) {  return Ray(this->inverseTransform * r.origin, this->inverseTransform * r.direction); };
 };

source/include/sphere.h

@@ -18,6 +18,7 @@ class Sphere : public Object
 public:
     /* All sphere are at (0, 0, 0) and radius 1 in the object space */
     virtual Intersect intersect(Ray r);
+    virtual Tuple normalAt(Tuple point);
 };
 
 #endif //DORAYME_SPHERE_H

source/include/tuple.h

@@ -41,8 +41,8 @@ public:
     double magnitude();
     Tuple normalise();
     double dot(const Tuple &b);
-
     Tuple cross(const Tuple &b) const;
+    Tuple reflect(const Tuple &normal);
 };
 
 class Point: public Tuple

source/objects/light.cpp

@@ -0,0 +1,8 @@
+/*
+ *  DoRayMe - a quick and dirty Raytracer
+ *  Light implementation
+ *
+ *  Created by Manoël Trapier
+ *  Copyright (c) 2020 986-Studio.
+ *
+ */

source/objects/material.cpp

@@ -0,0 +1,56 @@
+/*
+ *  DoRayMe - a quick and dirty Raytracer
+ *  Material implementation
+ *
+ *  Created by Manoël Trapier
+ *  Copyright (c) 2020 986-Studio.
+ *
+ */
+#include <tuple.h>
+#include <material.h>
+#include <colour.h>
+
+Colour Material::lighting(Light light, Tuple point, Tuple eyeVector, Tuple normalVector)
+{
+    Tuple lightVector = (light.position - point).normalise();
+    Tuple reflectVector = Tuple(0, 0, 0, 0);
+
+    Tuple effectiveColour = this->colour * light.intensity;
+    Tuple ambientColour = Colour(0, 0, 0);
+    Tuple diffuseColour = Colour(0, 0, 0);
+    Tuple specularColour = Colour(0, 0, 0);
+    Tuple finalColour = Colour(0, 0, 0);
+
+    double lightDotNormal, reflectDotEye;
+
+    ambientColour = effectiveColour * this->ambient;
+
+    lightDotNormal = lightVector.dot(normalVector);
+
+    if (lightDotNormal < 0)
+    {
+        diffuseColour = Colour(0, 0, 0);
+        specularColour = Colour(0, 0, 0);
+    }
+    else
+    {
+        diffuseColour = effectiveColour * this->diffuse * lightDotNormal;
+        reflectVector = -lightVector.reflect(normalVector);
+
+        reflectDotEye = reflectVector.dot(eyeVector);
+
+        if (reflectDotEye < 0)
+        {
+            specularColour = Colour(0, 0, 0);
+        }
+        else
+        {
+            double factor = pow(reflectDotEye, this->shininess);
+            specularColour = light.intensity * this->specular * factor;
+        }
+    }
+
+    finalColour = ambientColour + diffuseColour + specularColour;
+
+    return Colour(finalColour.x, finalColour.y, finalColour.z);
+}

source/objects/object.cpp

@@ -24,6 +24,11 @@ Intersect Object::intersect(Ray r)
     return Intersect();
 };
 
+Tuple Object::normalAt(Tuple point)
+{
+    return Vector(0, 0, 0);
+}
+
 void Object::setTransform(Matrix transform)
 {
     this->transformMatrix = transform;

source/objects/sphere.cpp

@@ -35,4 +35,16 @@ Intersect Sphere::intersect(Ray r)
     }
 
     return ret;
+}
+
+Tuple Sphere::normalAt(Tuple point)
+{
+    Tuple object_point = this->inverseTransform * point;
+    Tuple object_normal = (object_point - Point(0, 0, 0)).normalise();
+    Tuple world_normal = this->inverseTransform.transpose() * object_normal;
+
+    /* W may get wrong, so hack it. This is perfectly normal as we are using a 4x4 matrix instead of a 3x3 */
+    world_normal.w = 0;
+
+    return world_normal.normalise();
 }

source/tuple.cpp

@@ -33,4 +33,9 @@ Tuple Tuple::cross(const Tuple &b) const
                  this->z * b.x - this->x * b.z,
                  this->x * b.y - this->y * b.x,
                  0);
+}
+
+Tuple Tuple::reflect(const Tuple &normal)
+{
+    return *this - normal * 2 * this->dot(normal);
 }

tests/CMakeLists.txt

@@ -4,7 +4,7 @@ set(THREADS_PREFER_PTHREAD_FLAG ON)
 find_package(Threads REQUIRED)
 
 set(TESTS_SRC tuple_test.cpp colour_test.cpp canvas_test.cpp matrix_test.cpp transformation_test.cpp ray_test.cpp
-        intersect_test.cpp sphere_test.cpp)
+        intersect_test.cpp sphere_test.cpp light_test.cpp material_test.cpp)
 
 add_executable(testMyRays)
 target_include_directories(testMyRays PUBLIC ${gtest_SOURCE_DIR}/include ${gtest_SOURCE_DIR})

tests/ch5_test.cpp

@@ -29,7 +29,7 @@ int main()
         double worldY = (wallSize / 2) - pixelSize * y;
         for(x = 0; x < c.width; x++)
         {
-            double worldX = (wallSize / 2) - pixelSize * x;
+            double worldX = -(wallSize / 2) + pixelSize * x;
             Point position = Point(worldX, worldY, wallDistance);
             Ray r = Ray(cameraOrigin, (position - cameraOrigin).normalise());
             Intersect xs = s.intersect(r);

tests/light_test.cpp

@@ -0,0 +1,24 @@
+/*
+ *  DoRayMe - a quick and dirty Raytracer
+ *  Light unit tests
+ *
+ *  Created by Manoël Trapier
+ *  Copyright (c) 2020 986-Studio.
+ *
+ */
+#include <light.h>
+#include <math.h>
+#include <colour.h>
+#include <tuple.h>
+#include <gtest/gtest.h>
+
+TEST(LightTest, A_point_lighthas_a_position_and_intensity)
+{
+    Colour intensity = Colour(1, 1, 1);
+    Point position = Point(0, 0, 0);
+
+    Light light = Light(POINT_LIGHT, position, intensity);
+
+    ASSERT_EQ(light.position, position);
+    ASSERT_EQ(light.intensity, intensity);
+}

tests/material_test.cpp

@@ -0,0 +1,90 @@
+/*
+ *  DoRayMe - a quick and dirty Raytracer
+ *  Material unit tests
+ *
+ *  Created by Manoël Trapier
+ *  Copyright (c) 2020 986-Studio.
+ *
+ */
+#include <material.h>
+#include <math.h>
+#include <colour.h>
+#include <gtest/gtest.h>
+
+TEST(MaterialTest, The_default_material)
+{
+    Material m = Material();
+
+    ASSERT_EQ(m.colour, Colour(1, 1, 1));
+    ASSERT_EQ(m.ambient, 0.1);
+    ASSERT_EQ(m.diffuse, 0.9);
+    ASSERT_EQ(m.specular, 0.9);
+    ASSERT_EQ(m.shininess, 200.0);
+}
+
+// This is used by the next tests
+static Material m = Material();
+static Point position = Point(0, 0, 0);
+
+TEST(MaterialTest, Lighting_with_the_eye_between_the_light_and_the_surface)
+{
+    Vector eyev = Vector(0, 0, -1);
+    Vector normalv = Vector(0, 0, -1);
+    Light light = Light(POINT_LIGHT, Point(0, 0, -10), Colour(1, 1, 1));
+
+    Colour result = m.lighting(light, position, eyev, normalv);
+
+    ASSERT_EQ(result, Colour(1.9, 1.9, 1.9));
+}
+
+TEST(MaterialTest, Lighting_with_the_eye_between_the_light_and_the_surface_eye_offset_by_45)
+{
+    Vector eyev = Vector(0, -sqrt(2)/2, -sqrt(2)/2);
+    Vector normalv = Vector(0, 0, -1);
+    Light light = Light(POINT_LIGHT, Point(0, 0, -10), Colour(1, 1, 1));
+
+    Colour result = m.lighting(light, position, eyev, normalv);
+
+    ASSERT_EQ(result, Colour(1.0, 1.0, 1.0));
+}
+
+TEST(MaterialTest, Lighting_with_the_eye_opposite_surface_light_offset_45)
+{
+    Vector eyev = Vector(0, 0, -1);
+    Vector normalv = Vector(0, 0, -1);
+    Light light = Light(POINT_LIGHT, Point(0, 10, -10), Colour(1, 1, 1));
+
+    Colour result = m.lighting(light, position, eyev, normalv);
+
+    set_equal_precision(0.0001);
+
+    ASSERT_EQ(result, Colour(0.7364, 0.7364, 0.7364));
+
+    set_equal_precision(FLT_EPSILON);
+}
+
+TEST(MaterialTest, Lighting_with_the_eye_in_the_path_of_the_reflection_vector)
+{
+    Vector eyev = Vector(0, -sqrt(2)/2, -sqrt(2)/2);
+    Vector normalv = Vector(0, 0, -1);
+    Light light = Light(POINT_LIGHT, Point(0, 10, -10), Colour(1, 1, 1));
+
+    Colour result = m.lighting(light, position, eyev, normalv);
+
+    set_equal_precision(0.0001);
+
+    ASSERT_EQ(result, Colour(1.6364, 1.6364, 1.6364));
+
+    set_equal_precision(FLT_EPSILON);
+}
+
+TEST(MaterialTest, Lighting_with_the_light_behind_the_surface)
+{
+    Vector eyev = Vector(0, 0, -1);
+    Vector normalv = Vector(0, 0, -1);
+    Light light = Light(POINT_LIGHT, Point(0, 0, 10), Colour(1, 1, 1));
+
+    Colour result = m.lighting(light, position, eyev, normalv);
+
+    ASSERT_EQ(result, Colour(0.1, 0.1, 0.1));
+}

tests/sphere_test.cpp

@@ -8,6 +8,7 @@
  */
 #include <ray.h>
 #include <sphere.h>
+#include <material.h>
 #include <transformation.h>
 #include <gtest/gtest.h>
 
@@ -105,4 +106,96 @@ TEST(SphereTest, Intersecting_a_translated_sphere_with_a_ray)
     Intersect xs = s.intersect(r);
 
     ASSERT_EQ(xs.count(), 0);
+}
+
+TEST(SphereTest, The_normal_on_a_sphere_at_a_point_on_the_X_axis)
+{
+    Sphere s = Sphere();
+    Tuple n = s.normalAt(Point(1, 0, 0));
+
+    ASSERT_EQ(n, Vector(1, 0, 0));
+}
+
+TEST(SphereTest, The_normal_on_a_sphere_at_a_point_on_the_Y_axis)
+{
+    Sphere s = Sphere();
+    Tuple n = s.normalAt(Point(0, 1, 0));
+
+    ASSERT_EQ(n, Vector(0, 1, 0));
+}
+
+TEST(SphereTest, The_normal_on_a_sphere_at_a_point_on_the_Z_axis)
+{
+    Sphere s = Sphere();
+    Tuple n = s.normalAt(Point(0, 0, 1));
+
+    ASSERT_EQ(n, Vector(0, 0, 1));
+}
+
+TEST(SphereTest, The_normal_on_a_sphere_at_a_nonaxial_point)
+{
+    Sphere s = Sphere();
+    Tuple n = s.normalAt(Point(sqrt(3)/3, sqrt(3)/3, sqrt(3)/3));
+
+    ASSERT_EQ(n, Vector(sqrt(3)/3, sqrt(3)/3, sqrt(3)/3));
+}
+
+TEST(SphereTest, The_normal_is_a_normalise_vector)
+{
+    Sphere s = Sphere();
+    Tuple n = s.normalAt(Point(sqrt(3)/3, sqrt(3)/3, sqrt(3)/3));
+
+    ASSERT_EQ(n, n.normalise());
+}
+
+TEST(SphereTest, Computing_the_normal_on_a_translated_sphere)
+{
+    Sphere s = Sphere();
+
+    s.setTransform(translation(0, 1, 0));
+
+    Tuple n = s.normalAt(Point(0, 1.70711, -0.70711));
+
+    set_equal_precision(0.0001);
+
+    ASSERT_EQ(n, Vector(0, 0.70711, -0.70711));
+
+    /* Revert to default */
+    set_equal_precision(FLT_EPSILON);
+}
+
+TEST(SphereTest, Computing_the_normal_on_a_tranformed_sphere)
+{
+    Sphere s = Sphere();
+
+    s.setTransform(scaling(1, 0.5, 1) * rotation_z(M_PI / 5));
+
+    Tuple n = s.normalAt(Point(0, sqrt(2)/2, -sqrt(2)/2));
+
+    set_equal_precision(0.0001);
+
+    ASSERT_EQ(n, Vector(0, 0.97014, -0.24254));
+
+    /* Revert to default */
+    set_equal_precision(FLT_EPSILON);
+}
+
+TEST(SphereTest, A_sphere_have_a_default_material)
+{
+    Sphere s = Sphere();
+    Material m = Material();
+
+    ASSERT_EQ(s.material, m);
+}
+
+TEST(SphereTest, A_sphere_may_be_assigned_a_material)
+{
+    Sphere s = Sphere();
+
+    Material m = Material();
+    m.ambient = 1;
+
+    s.setMaterial(m);
+
+    ASSERT_EQ(s.material, m);
 }

tests/tuple_test.cpp

@@ -10,7 +10,7 @@
 #include <math.h>
 #include <gtest/gtest.h>
 
-TEST(TuplesTests, Tuple_With_w_equal_1_and_is_point)
+TEST(TupleTest, Tuple_With_w_equal_1_and_is_point)
 {
     Tuple a = Tuple(4.3, -4.2, 3.1, 1.0);
 
@@ -22,7 +22,7 @@ TEST(TuplesTests, Tuple_With_w_equal_1_and_is_point)
     ASSERT_FALSE(a.isVector());
 }
 
-TEST(TuplesTests, Tuple_With_w_equal_0_and_is_vector)
+TEST(TupleTest, Tuple_With_w_equal_0_and_is_vector)
 {
     Tuple a = Tuple(4.3, -4.2, 3.1, 0.0);
 
@@ -34,21 +34,21 @@ TEST(TuplesTests, Tuple_With_w_equal_0_and_is_vector)
     ASSERT_TRUE(a.isVector());
 }
 
-TEST(TuplesTests, Point_create_tuples_with_w_equal_1)
+TEST(TupleTest, Point_create_tuples_with_w_equal_1)
 {
     Tuple a = Point(4, -4, 3);
 
     ASSERT_EQ(a, Tuple(4, -4, 3, 1));
 }
 
-TEST(TuplesTests, Vector_create_tuples_with_w_equal_0)
+TEST(TupleTest, Vector_create_tuples_with_w_equal_0)
 {
     Tuple a = Vector(4, -4, 3);
 
     ASSERT_EQ(a, Tuple(4, -4, 3, 0));
 }
 
-TEST(TuplesTests, Adding_two_tuples)
+TEST(TupleTest, Adding_two_tuples)
 {
     Tuple a1 = Tuple(3, -2, 5, 1);
     Tuple a2 = Tuple(-2, 3, 1, 0);
@@ -56,7 +56,7 @@ TEST(TuplesTests, Adding_two_tuples)
     ASSERT_EQ(a1 + a2, Tuple(1, 1, 6, 1));
 }
 
-TEST(TuplesTests, Substracting_two_points)
+TEST(TupleTest, Substracting_two_points)
 {
     Point p1 = Point(3, 2, 1);
     Point p2 = Point(5, 6, 7);
@@ -64,7 +64,7 @@ TEST(TuplesTests, Substracting_two_points)
     ASSERT_EQ(p1 - p2, Vector(-2, -4, -6));
 }
 
-TEST(TuplesTests, Substracting_a_vector_from_a_point)
+TEST(TupleTest, Substracting_a_vector_from_a_point)
 {
     Point p = Point(3, 2, 1);
     Vector v = Vector(5, 6, 7);
@@ -72,7 +72,7 @@ TEST(TuplesTests, Substracting_a_vector_from_a_point)
     ASSERT_EQ(p - v, Point(-2, -4, -6));
 }
 
-TEST(TuplesTests, Substracting_two_vectors)
+TEST(TupleTest, Substracting_two_vectors)
 {
     Vector v1 = Vector(3, 2, 1);
     Vector v2 = Vector(5, 6, 7);
@@ -80,7 +80,7 @@ TEST(TuplesTests, Substracting_two_vectors)
     ASSERT_EQ(v1 - v2, Vector(-2, -4, -6));
 }
 
-TEST(TuplesTests, Substracting_a_vector_from_zero_vector)
+TEST(TupleTest, Substracting_a_vector_from_zero_vector)
 {
     Vector zero = Vector(0, 0, 0);
     Vector v = Vector(1, -2, 3);
@@ -88,84 +88,84 @@ TEST(TuplesTests, Substracting_a_vector_from_zero_vector)
     ASSERT_EQ(zero - v, Vector(-1, 2, -3));
 }
 
-TEST(TuplesTests, Negating_a_tuple)
+TEST(TupleTest, Negating_a_tuple)
 {
     Tuple a = Tuple(1, -2, 3, -4);
 
     ASSERT_EQ(-a, Tuple(-1, 2, -3, 4));
 }
 
-TEST(TuplesTests, Multiplying_a_tuple_by_a_scalar)
+TEST(TupleTest, Multiplying_a_tuple_by_a_scalar)
 {
     Tuple a = Tuple(1, -2, 3, -4);
 
     ASSERT_EQ(a * 3.5, Tuple(3.5, -7, 10.5, -14));
 }
 
-TEST(TuplesTests, Multiplying_a_tuple_by_a_fraction)
+TEST(TupleTest, Multiplying_a_tuple_by_a_fraction)
 {
     Tuple a = Tuple(1, -2, 3, -4);
 
     ASSERT_EQ(a * 0.5, Tuple(0.5, -1, 1.5, -2));
 }
 
-TEST(TuplesTests, Dividing_a_tuple_by_a_scalar)
+TEST(TupleTest, Dividing_a_tuple_by_a_scalar)
 {
     Tuple a = Tuple(1, -2, 3, -4);
 
     ASSERT_EQ(a / 2, Tuple(0.5, -1, 1.5, -2));
 }
 
-TEST(TuplesTests, Computing_the_magnitude_of_vector_1_0_0)
+TEST(TupleTest, Computing_the_magnitude_of_vector_1_0_0)
 {
     Vector v = Vector(1, 0, 0);
 
     ASSERT_EQ(v.magnitude(), 1);
 }
 
-TEST(TuplesTests, Computing_the_magnitude_of_vector_0_1_0)
+TEST(TupleTest, Computing_the_magnitude_of_vector_0_1_0)
 {
     Vector v = Vector(0, 1, 0);
 
     ASSERT_EQ(v.magnitude(), 1);
 }
 
-TEST(TuplesTests, Computing_the_magnitude_of_vector_0_0_1)
+TEST(TupleTest, Computing_the_magnitude_of_vector_0_0_1)
 {
     Vector v = Vector(0, 0, 1);
 
     ASSERT_EQ(v.magnitude(), 1);
 }
 
-TEST(TuplesTests, Computing_the_magnitude_of_vector_1_2_3)
+TEST(TupleTest, Computing_the_magnitude_of_vector_1_2_3)
 {
     Vector v = Vector(1, 2, 3);
 
     ASSERT_EQ(v.magnitude(), sqrt(14));
 }
 
-TEST(TuplesTests, Computing_the_magnitude_of_vector_n1_n2_n3)
+TEST(TupleTest, Computing_the_magnitude_of_vector_n1_n2_n3)
 {
     Vector v = Vector(-1, -2, -3);
 
     ASSERT_EQ(v.magnitude(), sqrt(14));
 }
 
-TEST(TuplesTests, Nomilise_vector_4_0_0_give_1_0_0)
+TEST(TupleTest, Nomilise_vector_4_0_0_give_1_0_0)
 {
     Vector v = Vector(4, 0, 0);
 
     ASSERT_EQ(v.normalise(), Vector(1, 0, 0));
 }
 
-TEST(TuplesTests, Nomilise_vector_1_2_3)
+TEST(TupleTest, Nomilise_vector_1_2_3)
 {
     Vector v = Vector(1, 2, 3);
 
     ASSERT_EQ(v.normalise(), Vector(1 / sqrt(14), 2 / sqrt(14), 3 / sqrt(14)));
 }
 
-TEST(TuplesTests, Dot_product_of_two_tuples)
+TEST(TupleTest, Dot_product_of_two_tuples)
 {
     Vector a = Vector(1, 2, 3);
     Vector b = Vector(2, 3, 4);
@@ -173,7 +173,7 @@ TEST(TuplesTests, Dot_product_of_two_tuples)
     ASSERT_EQ(a.dot(b), 20);
 }
 
-TEST(TuplesTests, Cross_product_of_two_vector)
+TEST(TupleTest, Cross_product_of_two_vector)
 {
     Vector a = Vector(1, 2, 3);
     Vector b = Vector(2, 3, 4);
@@ -181,3 +181,23 @@ TEST(TuplesTests, Cross_product_of_two_vector)
     ASSERT_EQ(a.cross(b), Vector(-1, 2, -1));
     ASSERT_EQ(b.cross(a), Vector(1, -2, 1));
 }
+
+TEST(TupleTest, Reflecting_a_vector_approaching_at_45)
+{
+    Vector v = Vector(1, -1, 0); /* Vector */
+    Vector n = Vector(0, 1, 0); /* Normal */
+
+    Tuple r = v.reflect(n);
+
+    ASSERT_EQ(r, Vector(1, 1, 0));
+}
+
+TEST(TupleTest, Reflecting_a_vector_off_a_slanted_surface)
+{
+    Vector v = Vector(0, -1, 0); /* Vector */
+    Vector n = Vector(sqrt(2)/2, sqrt(2)/2, 0); /* Normal */
+
+    Tuple r = v.reflect(n);
+
+    ASSERT_EQ(r, Vector(1, 0, 0));
+}