Shape is now an abstract class and can't be instanciated.

Change derived shape to only deal with local calculation they don't need anymore to deal with how they've been transformed.

source/include/shape.h

@@ -29,6 +29,10 @@ class Shape
 private:
     ShapeType type;
 
+private:
+    virtual Intersect localIntersect(Ray r) = 0;
+    virtual Tuple localNormalAt(Tuple point) = 0;
+
 public:
     Matrix transformMatrix;
     Matrix inverseTransform;
@@ -37,8 +41,8 @@ public:
 public:
     Shape(ShapeType = SHAPE_NONE);
 
-    virtual Intersect intersect(Ray r);
-    virtual Tuple normalAt(Tuple point);
+    Intersect intersect(Ray r);
+    Tuple normalAt(Tuple point);
 
     void setTransform(Matrix transform);
     void setMaterial(Material material) { this->material = material; };

source/include/sphere.h

@@ -15,11 +15,13 @@
 
 class Sphere : public Shape
 {
+private:
+    Intersect localIntersect(Ray r);
+    Tuple localNormalAt(Tuple point);
+
 public:
     Sphere() : Shape(SHAPE_SPHERE) { };
     /* 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/testshape.h

@@ -0,0 +1,28 @@
+/*
+ *  DoRayMe - a quick and dirty Raytracer
+ *  Test shape header
+ *
+ *  Created by Manoël Trapier
+ *  Copyright (c) 2020 986-Studio.
+ *
+ */
+#ifndef DORAYME_TESTSHAPE_H
+#define DORAYME_TESTSHAPE_H
+
+#include <shape.h>
+#include <ray.h>
+#include <tuple.h>
+
+class TestShape : public Shape
+{
+private:
+    Intersect localIntersect(Ray r);
+    Tuple localNormalAt(Tuple point);
+
+public:
+    Ray localRay;
+
+    TestShape();
+};
+
+#endif //DORAYME_TESTSHAPE_H

source/shapes/shape.cpp

@@ -22,12 +22,21 @@ Shape::Shape(ShapeType type)
 
 Intersect Shape::intersect(Ray r)
 {
-    return Intersect();
+    return this->localIntersect(this->invTransform(r));
 };
 
 Tuple Shape::normalAt(Tuple point)
 {
-    return Vector(0, 0, 0);
+    Tuple local_point = this->inverseTransform * point;
+
+    Tuple local_normal = this->localNormalAt(local_point);
+
+    Tuple world_normal = this->inverseTransform.transpose() * local_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();
 }
 
 void Shape::setTransform(Matrix transform)

source/shapes/sphere.cpp

@@ -13,17 +13,15 @@
 #include <tuple.h>
 #include <intersect.h>
 
-Intersect Sphere::intersect(Ray r)
+Intersect Sphere::localIntersect(Ray r)
 {
     Intersect ret;
     double a, b, c, discriminant;
 
-    Ray transRay = this->invTransform(r);
+    Tuple sphere_to_ray = r.origin - Point(0, 0, 0);
 
-    Tuple sphere_to_ray = transRay.origin - Point(0, 0, 0);
-
-    a = transRay.direction.dot(transRay.direction);
-    b = 2 * transRay.direction.dot(sphere_to_ray);
+    a = r.direction.dot(r.direction);
+    b = 2 * r.direction.dot(sphere_to_ray);
     c = sphere_to_ray.dot(sphere_to_ray) - 1;
 
     discriminant = b * b - 4 * a * c;
@@ -37,14 +35,7 @@ Intersect Sphere::intersect(Ray r)
     return ret;
 }
 
-Tuple Sphere::normalAt(Tuple point)
+Tuple Sphere::localNormalAt(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();
+    return (point - Point(0, 0, 0)).normalise();
 }

source/shapes/testshape.cpp

@@ -0,0 +1,25 @@
+/*
+ *  DoRayMe - a quick and dirty Raytracer
+ *  Test shape implementation
+ *
+ *  Created by Manoël Trapier
+ *  Copyright (c) 2020 986-Studio.
+ *
+ */
+#include <shape.h>
+#include <testshape.h>
+
+TestShape::TestShape() : localRay(Point(0, 0, 0), Vector(0, 0, 0))
+{
+}
+
+Intersect TestShape::localIntersect(Ray r)
+{
+    this->localRay = r;
+    return Intersect();
+}
+
+Tuple TestShape::localNormalAt(Tuple point)
+{
+     return Vector(point.x, point.y, point.z);
+}