Add transformation to objects.

source/include/object.h

@@ -12,13 +12,24 @@
 class Object;
 
 #include <ray.h>
+#include <tuple.h>
+#include <matrix.h>
 #include <intersect.h>
 
 /* Base class for all object that can be presented in the world */
 class Object
 {
 public:
+    Matrix transformMatrix;
+    Matrix inverseTransform;
+
+public:
+    Object();
+
     virtual Intersect intersect(Ray r);
+    void setTransform(Matrix transform);
+    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); };
 };
 
 #endif //DORAYME_OBJECT_H

source/objects/object.cpp

@@ -9,9 +9,23 @@
 
 #include <ray.h>
 #include <object.h>
+#include <matrix.h>
+#include <tuple.h>
 #include <intersect.h>
 
+Object::Object()
+{
+    this->transformMatrix = Matrix4().identity();
+    this->inverseTransform = this->transformMatrix.inverse();
+}
+
 Intersect Object::intersect(Ray r)
 {
     return Intersect();
-};
+};
+
+void Object::setTransform(Matrix transform)
+{
+    this->transformMatrix = transform;
+    this->inverseTransform = transform.inverse();
+}

source/objects/sphere.cpp

@@ -17,10 +17,13 @@ Intersect Sphere::intersect(Ray r)
 {
     Intersect ret;
     double a, b, c, discriminant;
-    Tuple sphere_to_ray = r.origin - Point(0, 0, 0);
 
-    a = r.direction.dot(r.direction);
+    Ray transRay = this->invTransform(r);
-    b = 2 * r.direction.dot(sphere_to_ray);
+
+    Tuple sphere_to_ray = transRay.origin - Point(0, 0, 0);
+
+    a = transRay.direction.dot(transRay.direction);
+    b = 2 * transRay.direction.dot(sphere_to_ray);
     c = sphere_to_ray.dot(sphere_to_ray) - 1;
 
     discriminant = b * b - 4 * a * c;

tests/ray_test.cpp

@@ -7,6 +7,8 @@
  *
  */
 #include <ray.h>
+#include <transformation.h>
+#include <object.h>
 #include <gtest/gtest.h>
 
 
@@ -29,4 +31,34 @@ TEST(RayTest, Computing_a_point_from_a_distance)
     ASSERT_EQ(r.position(1), Point(3, 3, 4));
     ASSERT_EQ(r.position(-1), Point(1, 3, 4));
     ASSERT_EQ(r.position(2.5), Point(4.5, 3, 4));
+}
+
+TEST(RayTest, Translating_a_ray)
+{
+    Ray r = Ray(Point(1, 2, 3), Vector(0, 1, 0));
+
+    Matrix m = translation(3, 4, 5);
+    Object o = Object();
+
+    o.setTransform(m);
+
+    Ray r2 = o.transform(r);
+
+    ASSERT_EQ(r2.origin, Point(4, 6, 8));
+    ASSERT_EQ(r2.direction, Vector(0, 1, 0));
+}
+
+TEST(RayTest, Scaling_a_ray)
+{
+    Ray r = Ray(Point(1, 2, 3), Vector(0, 1, 0));
+
+    Matrix m = scaling(2, 3, 4);
+    Object o = Object();
+
+    o.setTransform(m);
+
+    Ray r2 = o.transform(r);
+
+    ASSERT_EQ(r2.origin, Point(2, 6, 12));
+    ASSERT_EQ(r2.direction, Vector(0, 3, 0));
 }

tests/sphere_test.cpp

@@ -8,6 +8,7 @@
  */
 #include <ray.h>
 #include <sphere.h>
+#include <transformation.h>
 #include <gtest/gtest.h>
 
 
@@ -62,4 +63,46 @@ TEST(SphereTest, A_sphere_is_behind_a_ray)
     ASSERT_EQ(xs.count(), 2);
     ASSERT_EQ(xs[0].t, -6.0);
     ASSERT_EQ(xs[1].t, -4.0);
+}
+
+TEST(SphereTest, A_sphere_default_transformation)
+{
+    Sphere s = Sphere();
+    ASSERT_EQ(s.transformMatrix, Matrix4().identity());
+}
+
+TEST(SphereTest, Changing_a_sphere_transformation)
+{
+    Sphere s = Sphere();
+    Matrix t = translation(2, 3, 4);
+
+    s.setTransform(t);
+
+    ASSERT_EQ(s.transformMatrix, t);
+}
+
+TEST(SphereTest, Intersecting_a_scaled_sphere_with_a_ray)
+{
+    Ray r = Ray(Point(0, 0, -5), Vector(0, 0, 1));
+    Sphere s = Sphere();
+
+    s.setTransform(scaling(2, 2, 2));
+
+    Intersect xs = s.intersect(r);
+
+    ASSERT_EQ(xs.count(), 2);
+    ASSERT_EQ(xs[0].t, 3.0);
+    ASSERT_EQ(xs[1].t, 7.0);
+}
+
+TEST(SphereTest, Intersecting_a_translated_sphere_with_a_ray)
+{
+    Ray r = Ray(Point(0, 0, -5), Vector(0, 0, 1));
+    Sphere s = Sphere();
+
+    s.setTransform(translation(5, 0, 0));
+
+    Intersect xs = s.intersect(r);
+
+    ASSERT_EQ(xs.count(), 0);
 }