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,6 +23,7 @@ class Object
 public:
     Matrix transformMatrix;
     Matrix inverseTransform;
+    Material material;
 
 public:
     Object();
@@ -30,6 +32,7 @@ public:
     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/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);
+}