Renaming Object to Shape (part 1)

source/shapes/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/shapes/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/shapes/object.cpp

@@ -0,0 +1,36 @@
+/*
+ *  DoRayMe - a quick and dirty Raytracer
+ *  Object implementation
+ *
+ *  Created by Manoël Trapier
+ *  Copyright (c) 2020 986-Studio.
+ *
+ */
+
+#include <ray.h>
+#include <object.h>
+#include <matrix.h>
+#include <tuple.h>
+#include <intersect.h>
+
+Shape::Shape()
+{
+    this->transformMatrix = Matrix4().identity();
+    this->inverseTransform = this->transformMatrix.inverse();
+}
+
+Intersect Shape::intersect(Ray r)
+{
+    return Intersect();
+};
+
+Tuple Shape::normalAt(Tuple point)
+{
+    return Vector(0, 0, 0);
+}
+
+void Shape::setTransform(Matrix transform)
+{
+    this->transformMatrix = transform;
+    this->inverseTransform = transform.inverse();
+}

source/shapes/ray.cpp

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

source/shapes/sphere.cpp

@@ -0,0 +1,50 @@
+/*
+ *  DoRayMe - a quick and dirty Raytracer
+ *  Sphere implementation
+ *
+ *  Created by Manoël Trapier
+ *  Copyright (c) 2020 986-Studio.
+ *
+ */
+#include <math.h>
+
+#include <sphere.h>
+#include <ray.h>
+#include <tuple.h>
+#include <intersect.h>
+
+Intersect Sphere::intersect(Ray r)
+{
+    Intersect ret;
+    double a, b, c, discriminant;
+
+    Ray transRay = this->invTransform(r);
+
+    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;
+
+    if (discriminant >= 0)
+    {
+        ret.add(Intersection((-b - sqrt(discriminant)) / (2 * a), this));
+        ret.add(Intersection((-b + sqrt(discriminant)) / (2 * a), this));
+    }
+
+    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();
+}