Add sample from Chapter 12 :)

it does not render properly, there are some major differences between both engine especially in the material definition. Will need more work, but is not urgent.

README.md

@@ -44,4 +44,8 @@ From Chapter 11:
 
 ![Chapter 11 refraction rendering test](output/ch11_refraction.png)
 
-![Chapter 11 rendering test](output/ch11_test.png)
+![Chapter 11 rendering test](output/ch11_test.png)
+
+From Chapter 12:
+
+![Chapter 12 rendering test](output/ch12_test.png)

source/include/cube.h

@@ -0,0 +1,28 @@
+/*
+ *  DoRayMe - a quick and dirty Raytracer
+ *  Cube header
+ *
+ *  Created by Manoël Trapier
+ *  Copyright (c) 2020 986-Studio.
+ *
+ */
+#ifndef DORAYME_CUBE_H
+#define DORAYME_CUBE_H
+
+#include <shape.h>
+#include <ray.h>
+#include <intersect.h>
+
+class Cube : public Shape {
+private:
+    void checkAxis(double axeOrigine, double axeDirection, double *axeMin, double *axeMax);
+
+    Intersect localIntersect(Ray r);
+
+    Tuple localNormalAt(Tuple point);
+
+public:
+    Cube() : Shape(SHAPE_CUBE) {};
+};
+
+#endif /* DORAYME_CUBE_H */

source/include/material.h

@@ -26,13 +26,14 @@ public:
     double shininess;
     double reflective;
     double transparency;
+    double emissive;
     double refractiveIndex;
 
     Pattern *pattern;
 
 public:
     Material() : colour(Colour(1, 1, 1)), ambient(0.1), diffuse(0.9), specular(0.9), shininess(200),
-           reflective(0.0), transparency(0.0), refractiveIndex(1.0), pattern(nullptr) {};
+           reflective(0.0), transparency(0.0), emissive(0), refractiveIndex(1.0), pattern(nullptr) {};
 
     Colour lighting(Light light, Tuple point, Tuple eyeVector, Tuple normalVector, Shape *hitObject, bool inShadow = false);
 
@@ -40,6 +41,10 @@ public:
                                                       double_equal(this->diffuse,   b.diffuse) &&
                                                       double_equal(this->specular,  b.specular) &&
                                                       double_equal(this->shininess, b.shininess) &&
+                                                      double_equal(this->reflective, b.reflective) &&
+                                                      double_equal(this->transparency, b.transparency) &&
+                                                      double_equal(this->emissive, b.emissive) &&
+                                                      double_equal(this->refractiveIndex, b.refractiveIndex) &&
                                                       (this->colour == b.colour); };
 };
 

source/include/math_helper.h

@@ -18,4 +18,7 @@ bool double_equal(double a, double b);
 
 double deg_to_rad(double deg);
 
+double min3(double a, double b, double c);
+double max3(double a, double b, double c);
+
 #endif /* DORAYME_MATH_HELPER_H */

source/include/shape.h

@@ -22,6 +22,8 @@ enum ShapeType
     SHAPE_NONE,
     SHAPE_SPHERE,
     SHAPE_PLANE,
+    SHAPE_CUBE,
+    SHAPE_CONE,
 };
 
 /* Base class for all object that can be presented in the world */
@@ -38,6 +40,7 @@ public:
     Matrix transformMatrix;
     Matrix inverseTransform;
     Material material;
+    bool dropShadow;
 
 public:
     Shape(ShapeType = SHAPE_NONE);

source/include/world.h

@@ -44,7 +44,7 @@ public:
 
     Tuple shadeHit(Computation comps, uint32_t depthCount = 4);
     Tuple colourAt(Ray r, uint32_t depthCount = 4);
-    bool isShadowed(Tuple point);
+    bool isShadowed(Tuple point, uint32_t light = 0);
 
     Colour reflectColour(Computation comps, uint32_t depthCount = 4);
     Colour refractedColour(Computation comps, uint32_t depthCount = 4);

source/include/worldbuilder.h

@@ -10,6 +10,7 @@
 #define DORAYME_WORLDBUILDER_H
 
 #include <world.h>
+#include <camera.h>
 
 /* Let's keep a single header for now, will see later */
 
@@ -22,7 +23,30 @@ public:
 /* Not implemented yet */
 class Hw3File : public World
 {
+private:
+    Matrix transformStack[50];
+    uint32_t transStackCount;
+
 public:
+    double currentAmbient;
+    double currentShininess;
+    double currentSpecular;
+    double currentDiffuse;
+    double currentEmission;
+    double currentReflective;
+    double currentTransparency;
+    double currentRefIndex;
+
+    Colour currentColour;
+    Matrix cam;
+    double camFoV;
+
+public:
+    Matrix getTransformMatrix();
+    void popTransformMatrix();
+    void pushTransformMatrix();
+    void applyTransformMatrix(Matrix t);
+
     Hw3File(const char *filename);
 };
 

source/math_helper.cpp

@@ -31,4 +31,42 @@ bool double_equal(double a, double b)
 double deg_to_rad(double deg)
 {
    return deg * M_PI / 180.;
+}
+
+double min3(double a, double b, double c)
+{
+    if (a <= b)
+    {
+        if (c < a) return c;
+        return a;
+    }
+    if (b <= a)
+    {
+        if (c < b) return c;
+        return b;
+    }
+    if (c <= a)
+    {
+        if (b < c) return b;
+    }
+    return c;
+}
+
+double max3(double a, double b, double c)
+{
+    if (a >= b)
+    {
+        if (c > a) return c;
+        return a;
+    }
+    if (b >= a)
+    {
+        if (c > b) return c;
+        return b;
+    }
+    if (c >= a)
+    {
+        if (b > c) return b;
+    }
+    return c;
 }

source/shapes/cube.cpp

@@ -0,0 +1,76 @@
+/*
+ *  DoRayMe - a quick and dirty Raytracer
+ *  Cube implementation
+ *
+ *  Created by Manoël Trapier
+ *  Copyright (c) 2020 986-Studio.
+ *
+ */
+#include <tuple.h>
+#include <ray.h>
+#include <shape.h>
+#include <cube.h>
+#include <math_helper.h>
+
+void Cube::checkAxis(double axeOrigin, double axeDirection, double *axeMin, double *axeMax)
+{
+    double tMinNumerator = (-1 - axeOrigin);
+    double tMaxNumerator = (1 - axeOrigin);
+
+    if (fabs(axeDirection) >= getEpsilon())
+    {
+        *axeMin = tMinNumerator / axeDirection;
+        *axeMax = tMaxNumerator / axeDirection;
+    }
+    else
+    {
+        *axeMin = tMinNumerator * INFINITY;
+        *axeMax = tMaxNumerator * INFINITY;
+    }
+
+    if (*axeMin > *axeMax)
+    {
+        double swap = *axeMax;
+        *axeMax = *axeMin;
+        *axeMin = swap;
+    }
+}
+
+Intersect Cube::localIntersect(Ray r)
+{
+    Intersect ret;
+
+    double xtMin, xtMax, ytMin, ytMax, ztMin, ztMax;
+    double tMin, tMax;
+
+    this->checkAxis(r.origin.x, r.direction.x, &xtMin, &xtMax);
+    this->checkAxis(r.origin.y, r.direction.y, &ytMin, &ytMax);
+    this->checkAxis(r.origin.z, r.direction.z, &ztMin, &ztMax);
+
+    tMin = max3(xtMin, ytMin, ztMin);
+    tMax = min3(xtMax, ytMax, ztMax);
+
+    if (tMin <= tMax)
+    {
+        ret.add(Intersection(tMin, this));
+        ret.add(Intersection(tMax, this));
+    }
+
+    return ret;
+}
+
+Tuple Cube::localNormalAt(Tuple point)
+{
+    double maxC = max3(fabs(point.x), fabs(point.y), fabs(point.z));
+
+    if (maxC == fabs(point.x))
+    {
+        return Vector(point.x, 0, 0);
+    }
+    else if (maxC == fabs(point.y))
+    {
+        return Vector(0, point.y, 0);
+    }
+
+    return Vector(0, 0, point.z);
+}

source/shapes/material.cpp

@@ -25,6 +25,7 @@ Colour Material::lighting(Light light, Tuple point, Tuple eyeVector, Tuple norma
 
     Tuple effectiveColour = pointColor * light.intensity;
     Tuple ambientColour = Colour(0, 0, 0);
+    Tuple emissiveColour = Colour(0, 0, 0);
     Tuple diffuseColour = Colour(0, 0, 0);
     Tuple specularColour = Colour(0, 0, 0);
     Tuple finalColour = Colour(0, 0, 0);
@@ -33,6 +34,8 @@ Colour Material::lighting(Light light, Tuple point, Tuple eyeVector, Tuple norma
 
     ambientColour = effectiveColour * this->ambient;
 
+    emissiveColour = pointColor * this->emissive;
+
     if (!inShadow)
     {
         lightDotNormal = lightVector.dot(normalVector);
@@ -60,7 +63,7 @@ Colour Material::lighting(Light light, Tuple point, Tuple eyeVector, Tuple norma
             }
         }
     }
-    finalColour = ambientColour + diffuseColour + specularColour;
+    finalColour = emissiveColour + ambientColour + diffuseColour + specularColour;
 
     return Colour(finalColour.x, finalColour.y, finalColour.z);
 }

source/shapes/shape.cpp

@@ -15,6 +15,7 @@
 
 Shape::Shape(ShapeType type)
 {
+    this->dropShadow = true;
     this->type = type;
     this->transformMatrix = Matrix4().identity();
     this->inverseTransform = this->transformMatrix.inverse();

source/world.cpp

@@ -94,13 +94,17 @@ Intersect World::intersect(Ray r)
 
 Tuple World::shadeHit(Computation comps, uint32_t depthCount)
 {
-    /* TODO: Add support for more than one light */
+    uint32_t lightIndex;
 
-    bool isThereAnObstacle = this->isShadowed(comps.overHitPoint);
+    Tuple surface = Colour(0, 0, 0);
 
-    Tuple surface = comps.object->material.lighting(*this->lightList[0], comps.overHitPoint, comps.eyeVector,
-            comps.normalVector, comps.object, isThereAnObstacle);
+    for(lightIndex = 0; lightIndex < this->lightCount; lightIndex++)
+    {
+        bool isThereAnObstacle = this->isShadowed(comps.overHitPoint, lightIndex);
 
+        surface = surface + comps.object->material.lighting(*this->lightList[lightIndex], comps.overHitPoint, comps.eyeVector,
+                                                        comps.normalVector, comps.object, isThereAnObstacle);
+    }
     Tuple reflected = this->reflectColour(comps, depthCount);
     Tuple refracted = this->refractedColour(comps, depthCount);
 
@@ -109,7 +113,6 @@ Tuple World::shadeHit(Computation comps, uint32_t depthCount)
         double reflectance = comps.schlick();
 
         return surface + reflected * reflectance + refracted * (1 - reflectance);
-
     }
 
     return surface + reflected + refracted;
@@ -130,22 +133,27 @@ Tuple World::colourAt(Ray r, uint32_t depthCount)
     }
 }
 
-bool World::isShadowed(Tuple point)
+bool World::isShadowed(Tuple point, uint32_t light)
 {
-    /* TODO: Add support for more than one light */
-
-    Tuple v = this->lightList[0]->position - point;
+    Tuple v = this->lightList[light]->position - point;
     double distance = v.magnitude();
     Tuple direction = v.normalise();
 
     Ray r = Ray(point, direction);
-    Intersection h = this->intersect(r).hit();
+    Intersect xs = this->intersect(r);
 
-    if (!h.nothing() && (h.t < distance))
+    int i;
+    for(i = 0; i < xs.count(); i++)
     {
-        return true;
-    }
+        Intersection h = xs[i];
 
+        if (h.t < 0) continue;
+
+        if ((h.object->dropShadow == true) && (h.t < distance))
+        {
+            return true;
+        }
+    }
     return false;
 }
 

source/worldbuilder/hw3file.cpp

@@ -7,18 +7,20 @@
  *
  */
 /* Don't build for now */
-#if 0
+
 /* This file is parsing a text format from another raytracer I made in the past. */
 #include <stdio.h>
-#include <stdlib.h>
 #include <string.h>
-#include <stdint.h>
 #include <ctype.h>
-#include <math.h>
+
+#include <worldbuilder.h>
+#include <sphere.h>
+#include <matrix.h>
+#include <transformation.h>
 
 #define IS_CMD(_cmd) (strncmp(buffer, _cmd, sizeof(_cmd)) == 0)
 
-typedef void (*cmdFunc)(scene *sc, uint32_t curLine, char *first, float argv[15]);
+typedef void (*cmdFunc)(Hw3File *w, uint32_t curLine, double argv[15]);
 
 typedef struct cmd_def
 {
@@ -27,111 +29,127 @@ typedef struct cmd_def
     cmdFunc f;
 } cmd_def;
 
-void cmdCamera   (scene *sc, uint32_t curLine, char *first, float argv[15])
+static void cmdCamera   (Hw3File *w, uint32_t curLine, double argv[15])
 {
-    sc->cam.seteye(point(argv[0], argv[1], argv[2]));
-    sc->cam.setat(point(argv[3], argv[4], argv[5]));
-    sc->cam.setup(vector(argv[6], argv[7], argv[8]));
-    sc->cam.setfovy(argv[9]);
+    w->cam = viewTransform(Point(argv[0], argv[1], argv[2]),
+                                      Point(argv[3], argv[4], argv[5]),
+                                      Vector(argv[6], argv[7], argv[8]));
+
+    w->camFoV = deg_to_rad(argv[9]);
 }
 
-void cmdSphere   (scene *sc, uint32_t curLine, char *first, float argv[15])
+/* 0: X, 1: Y, 2: Z
+ * 3: Radius
+ */
+static void cmdSphere   (Hw3File *w, uint32_t curLine, double argv[15])
 {
+    printf("Adding a sphere...\n");
     /* Instanciate a sphere */
-    sphere *sp     = new sphere(point(argv[0], argv[1], argv[2]), argv[3], sc->getMatrix());
-    sp->ambient    = sc->ambient;
-    sp->diffuse    = sc->diffuse;
-    sp->specular   = sc->specular;
-    sp->emission   = sc->emission;
-    sp->shininess  = sc->shininess;
-    sp->sourceLine = curLine;
-    sc->o[sc->o_count] = sp;
-    sc->o_count++;
+    Sphere *shape  = new Sphere();
+
+    Matrix pos = translation(argv[0], argv[1], argv[2]) * scaling(argv[3], argv[3], argv[3]);
+
+    shape->setTransform(w->getTransformMatrix() * pos);
+    
+    shape->material.ambient = w->currentAmbient;
+    shape->material.reflective = w->currentReflective;
+    shape->material.shininess = w->currentShininess;
+    shape->material.specular = w->currentSpecular;
+    shape->material.diffuse = w->currentDiffuse;
+    shape->material.colour = w->currentColour;
+    shape->material.transparency = w->currentTransparency;
+    shape->material.refractiveIndex = w->currentRefIndex;
+
+    w->addObject(shape);
 }
 
-void cmdCube     (scene *sc, uint32_t curLine, char *first, float argv[15])
+static void cmdCube     (Hw3File *w, uint32_t curLine, double argv[15])
 {
 }
 
+static void cmdTrans    (Hw3File *w, uint32_t curLine, double argv[15])
+{
+    Matrix m = translation(argv[0], argv[1], argv[2]);
+    w->applyTransformMatrix(m);
+}
+
+static void cmdRotate   (Hw3File *w, uint32_t curLine, double argv[15])
+{
+    Matrix m = Matrix4().identity();
+    if (argv[2] != 0)
+    {
+        m = m * rotationZ(argv[3]);
+    }
+    if (argv[1] != 0)
+    {
+        m = m * rotationY(argv[3]);
+    }
+    if (argv[0] != 0)
+    {
+        m = m * rotationX(argv[3]);
+    }
+
+    w->applyTransformMatrix(m);
+}
+
+static void cmdScale    (Hw3File *w, uint32_t curLine, double argv[15])
+{
+    Matrix m = scaling(argv[0], argv[1], argv[2]);
+
+    w->applyTransformMatrix(m);
+}
+
+static void cmdPushT    (Hw3File *w, uint32_t curLine, double argv[15])
+{
+    w->pushTransformMatrix();
+}
+
+static void cmdPopT     (Hw3File *w, uint32_t curLine, double argv[15])
+{
+    w->popTransformMatrix();
+}
+
+static void cmdLPoint   (Hw3File *w, uint32_t curLine, double argv[15])
+{
+    /* create point light */
+    Light *l = new Light(POINT_LIGHT, Point(argv[0], argv[1], argv[2]), Colour(argv[3], argv[4], argv[5]));
+
+    w->addLight(l);
+}
+
+static void cmdAmbient  (Hw3File *w, uint32_t curLine, double argv[15])
+{
+    //w->currentAmbient = (argv[0] + argv[1] + argv[2]) / 3;
+    w->currentColour = Colour(argv[0], argv[1], argv[2]);
+}
+
+static void cmdColour  (Hw3File *w, uint32_t curLine, double argv[15])
+{
+    w->currentColour = Colour(argv[0], argv[1], argv[2]);
+}
+
+static void cmdDiffuse  (Hw3File *w, uint32_t curLine, double argv[15])
+{
+    w->currentDiffuse = (argv[0] + argv[1] + argv[2]) / 3;
+}
+
+static void cmdSpecular (Hw3File *w, uint32_t curLine, double argv[15])
+{
+    w->currentSpecular = (argv[0] + argv[1] + argv[2]) / 3;
+}
+
+static void cmdShine    (Hw3File *w, uint32_t curLine, double argv[15])
+{
+    w->currentReflective = argv[0];
+}
+
+static void cmdEmission (Hw3File *w, uint32_t curLine, double argv[15])
+{
+    w->currentEmission = (argv[0] + argv[1] + argv[2]) / 3;
+}
+
 #if 0
-void cmdMaxVerts (scene *sc, uint32_t curLine, char *first, float argv[15])
-{
-    sc->vertexCount = (uint32_t) argv[0];
-    sc->vertex = new point[sc->vertexCount];
-    sc->curVertex = 0;
-}
-
-void cmdMaxVertN (scene *sc, uint32_t curLine, char *first, float argv[15])
-{
-    /* ignore for now */
-}
-
-void cmdVertex   (scene *sc, uint32_t curLine, char *first, float argv[15])
-{
-    sc->vertex[sc->curVertex].set(argv[0], argv[1], argv[2]);
-    sc->curVertex++;
-}
-
-void cmdVertexN  (scene *sc, uint32_t curLine, char *first, float argv[15])
-{
-    /* ignore for now */
-}
-
-void cmdTri      (scene *sc, uint32_t curLine, char *first, float argv[15])
-{
-    /* arg are vertex numbers */
-    triangle *tr   = new triangle(sc->vertex[(int)argv[0]], sc->vertex[(int)argv[1]], sc->vertex[(int)argv[2]], sc->getMatrix());
-    tr->ambient    = sc->ambient;
-    tr->diffuse    = sc->diffuse;
-    tr->specular   = sc->specular;
-    tr->emission   = sc->emission;
-    tr->shininess  = sc->shininess;
-    tr->sourceLine = curLine;
-    sc->o[sc->o_count] = tr;
-    sc->o_count++;
-}
-
-void cmdTriN     (scene *sc, uint32_t curLine, char *first, float argv[15])
-{
-    /* ignore for noz */
-}
-#endif
-
-void cmdTrans    (scene *sc, uint32_t curLine, char *first, float argv[15])
-{
-    matrix m;
-    m.translation(argv[0], argv[1], argv[2]);
-    sc->applyTransform(m);
-}
-
-void cmdRotate   (scene *sc, uint32_t curLine, char *first, float argv[15])
-{
-    matrix m;
-    vector axis;
-    axis.set(argv[0], argv[1], argv[2]);
-    m.rotation(axis, argv[3]);
-    sc->applyTransform(m);
-}
-
-void cmdScale    (scene *sc, uint32_t curLine, char *first, float argv[15])
-{
-    matrix m;
-    m.scale(argv[0], argv[1], argv[2]);
-    sc->applyTransform(m);
-}
-
-void cmdPushT    (scene *sc, uint32_t curLine, char *first, float argv[15])
-{
-    sc->pushMatrix();
-}
-
-void cmdPopT     (scene *sc, uint32_t curLine, char *first, float argv[15])
-{
-    sc->popMatrix();
-}
-
-#if 0
-void cmdLDire    (scene *sc, uint32_t curLine, char *first, float argv[15])
+static void cmdLDire    (Hw3File *w, uint32_t curLine, double argv[15])
 {
     /* create directional light */
     light *cur = new light();
@@ -145,163 +163,184 @@ void cmdLDire    (scene *sc, uint32_t curLine, char *first, float argv[15])
     sc->l[sc->l_count] = cur;
     sc->l_count++;
 }
-#endif
 
-void cmdLPoint   (scene *sc, uint32_t curLine, char *first, float argv[15])
+static void cmdAtten    (Hw3File *w, uint32_t curLine, double argv[15])
 {
-    /* create point light */
-    light *cur = new light();
-
-    cur->type = LIGHT_POINT;
-    cur->attenuation = sc->attenuation;
-
-    cur->position.set(argv[0], argv[1], argv[2]);
-    cur->lightcolor.set(argv[3], argv[4], argv[5]);
-    sc->l[sc->l_count] = cur;
-    sc->l_count++;
+    sc->attenuation = Vector(argv[0], argv[1], argv[2]);
 }
 
-#if 0
-void cmdAtten    (scene *sc, uint32_t curLine, char *first, float argv[15])
+static void cmdMaxVerts (Hw3File *w, uint32_t curLine, double argv[15])
 {
-    sc->attenuation = vector(argv[0], argv[1], argv[2]);
+    sc->vertexCount = (uint32_t) argv[0];
+    sc->vertex = new point[sc->vertexCount];
+    sc->curVertex = 0;
+}
+
+static void cmdMaxVertN (Hw3File *w, uint32_t curLine, double argv[15])
+{
+    /* ignore for now */
+}
+
+static void cmdVertex   (Hw3File *w, uint32_t curLine, double argv[15])
+{
+    sc->vertex[sc->curVertex].set(argv[0], argv[1], argv[2]);
+    sc->curVertex++;
+}
+
+static void cmdVertexN  (Hw3File *w, uint32_t curLine, double argv[15])
+{
+    /* ignore for now */
+}
+
+static void cmdTri      (Hw3File *w, uint32_t curLine, double argv[15])
+{
+    /* arg are vertex numbers */
+    triangle *tr   = new triangle(sc->vertex[(int)argv[0]], sc->vertex[(int)argv[1]], sc->vertex[(int)argv[2]], sc->getMatrix());
+    tr->ambient    = sc->ambient;
+    tr->diffuse    = sc->diffuse;
+    tr->specular   = sc->specular;
+    tr->emission   = sc->emission;
+    tr->shininess  = sc->shininess;
+    tr->sourceLine = curLine;
+    sc->o[sc->o_count] = tr;
+    sc->o_count++;
 }
 #endif
 
-void cmdAmbient  (scene *sc, uint32_t curLine, char *first, float argv[15])
+static cmd_def commandList[] =
 {
-    sc->ambient = color(argv[0], argv[1], argv[2]);
-}
-
-void cmdDiffuse  (scene *sc, uint32_t curLine, char *first, float argv[15])
-{
-    sc->diffuse = color(argv[0], argv[1], argv[2]);
-}
-
-void cmdSpecular (scene *sc, uint32_t curLine, char *first, float argv[15])
-{
-    sc->specular = color(argv[0], argv[1], argv[2]);
-}
-
-void cmdShine    (scene *sc, uint32_t curLine, char *first, float argv[15])
-{
-    sc->shininess = argv[0];
-}
-
-void cmdEmission (scene *sc, uint32_t curLine, char *first, float argv[15])
-{
-    sc->emission = color(argv[0], argv[1], argv[2]);
-}
-
-cmd_def commandList[] =
-        {
-                /* Camera                         */
-                { "camera",       10, cmdCamera   },
-                /* Geometry                       */
-                { "sphere",        4, cmdSphere   },
-                //{ "maxverts",      1, cmdMaxVerts },
-                //{ "maxvertnorms",  1, cmdMaxVertN },
-                //{ "vertex",        3, cmdVertex   },
-                //{ "vertexnormal",  6, cmdVertexN  },
-                //{ "tri",           3, cmdTri      },
-                //{ "trinormal",     3, cmdTriN     },
-                //{ "cube",          1, cmdCube     },
-                /* transformation                 */
-                { "translate",     3, cmdTrans    },
-                { "rotate",        4, cmdRotate   },
-                { "scale",         3, cmdScale    },
-                { "pushTransform", 0, cmdPushT    },
-                { "popTransform",  0, cmdPopT     },
-                /* Lights                         */
-                //{ "directional",   6, cmdLDire    },
-                { "point",         6, cmdLPoint   },
-                //{ "attenuation",   3, cmdAtten    },
-                /* Materials */
-                { "ambient",       3, cmdAmbient  },
-                { "diffuse",       3, cmdDiffuse  },
-                { "specular",      3, cmdSpecular },
-                { "shininess",     1, cmdShine    },
-                { "emission",      3, cmdEmission },
-        };
+    /* Camera                         */
+    {"camera",        10, cmdCamera},
+    /* Geometry                       */
+    {"sphere",        4,  cmdSphere},
+    //{ "maxverts",      1, cmdMaxVerts },
+    //{ "maxvertnorms",  1, cmdMaxVertN },
+    //{ "vertex",        3, cmdVertex   },
+    //{ "vertexnormal",  6, cmdVertexN  },
+    //{ "tri",           3, cmdTri      },
+    //{ "trinormal",     3, cmdTriN     },
+    //{ "cube",          1, cmdCube     },
+    /* transformation                 */
+    {"translate",     3,  cmdTrans},
+    {"rotate",        4,  cmdRotate},
+    {"scale",         3,  cmdScale},
+    {"pushTransform", 0,  cmdPushT},
+    {"popTransform",  0,  cmdPopT},
+    /* Lights                         */
+    //{ "directional",   6, cmdLDire    },
+    {"point",         6,  cmdLPoint},
+    //{ "attenuation",   3, cmdAtten    },
+    /* Materials */
+    {"color",         3,  cmdColour},
+    {"ambient",       3,  cmdAmbient},
+    {"diffuse",       3,  cmdDiffuse},
+    {"specular",      3,  cmdSpecular},
+    {"shininess",     1,  cmdShine},
+    {"emission",      3,  cmdEmission},
+};
 #define CMD_COUNT (sizeof(commandList) / sizeof(cmd_def))
 
 
-scene *readfile::read(char *filename)
+Hw3File::Hw3File(const char *filename) : transStackCount(0), currentColour(Colour(1, 1, 1)),
+                                         currentEmission(0), currentShininess(200), currentAmbient(0.1),
+                                         currentDiffuse(0.9), currentSpecular(0.9), camFoV(0)
 {
     FILE *fp;
-    scene *sc = new scene;
-    if (sc != NULL)
+
+    this->popTransformMatrix();
+
+    fp = fopen(filename, "rt");
+    if (fp != NULL)
     {
-        fp = fopen(filename, "rt");
-        if (fp == NULL)
+        char buffer[512];
+        int line = 0;
+        while(!feof(fp))
         {
-            delete sc;
-            sc = NULL;
-        }
-        else
-        {
-            char buffer[512];
-            int line = 0;
-            while(!feof(fp))
+            uint32_t i;
+
+            line++;
+
+            memset(buffer, 0, 512);
+            fgets(buffer, 512, fp);
+
+            if ((buffer[0] == '#') || (strlen(buffer) < 2))
             {
-                uint32_t i;
-                line++;
-                memset(buffer, 0, 512);
-                fgets(buffer, 512, fp);
-                if ((buffer[0] == '#') || (strlen(buffer) < 2))
-                    continue; /* Ingore empty line or commented lines */
-                //printf("::%d:> %s", strlen(buffer), buffer);
-                for (i = 0; i < CMD_COUNT; i++)
+                continue; /* Ingore empty line or commented lines */
+            }
+
+            for (i = 0; i < CMD_COUNT; i++)
+            {
+                if (strncmp(buffer, commandList[i].name, strlen(commandList[i].name)) == 0)
                 {
-                    if (strncmp(buffer, commandList[i].name, strlen(commandList[i].name)) == 0)
+                    char first[512];
+                    double value[15];
+                    if (commandList[i].numparam != 0)
                     {
-                        char first[512];
-                        float value[15];
-                        if (commandList[i].numparam != 0)
+                        size_t j;
+                        int k = 0, l = 0;
+                        char buff[512];
+                        for(j = strlen(commandList[i].name); j < strlen(buffer); j++)
                         {
-                            size_t j;
-                            int k = 0, l = 0;
-                            char buff[512];
-                            for(j = strlen(commandList[i].name); j < strlen(buffer); j++)
+                            if (!isspace(buffer[j]))
                             {
-                                if (!isspace(buffer[j]))
-                                {
-                                    buff[l++] = buffer[j];
-                                }
-                                else
-                                {
-                                    buff[l] = 0;
-                                    l = 0;
-                                    if (k == 0)
-                                    {
-                                        strcpy(first, buff);
-                                    }
-                                    if (strlen(buff) > 0)
-                                    {
-                                        value[k++] = atof(buff);
-                                    }
-                                }
+                                buff[l++] = buffer[j];
                             }
-                            if (k != abs(commandList[i].numparam))
+                            else
                             {
-                                printf("line %d malformed: given %d parameter, expected %d\n%s", line, k, abs(commandList[i].numparam), buffer);
-                                sc = NULL;
-                                goto exit;
+                                buff[l] = 0;
+                                l = 0;
+                                if (k == 0)
+                                {
+                                    strcpy(first, buff);
+                                }
+                                if (strlen(buff) > 0)
+                                {
+                                    value[k++] = atof(buff);
+                                }
                             }
                         }
-                        commandList[i].f(sc, line, first, value);
-                        break;
+                        if (k != abs(commandList[i].numparam))
+                        {
+                            printf("line %d malformed: given %d parameter, expected %d\n%s", line, k, abs(commandList[i].numparam), buffer);
+                            goto exit;
+                        }
                     }
+                    commandList[i].f(this, line, value);
+                    break;
                 }
             }
-#ifdef USE_OCTREE
-            sc->createOctree();
-#endif
         }
     }
 
 exit:
-    return sc;
+    return;
 }
 
-#endif
+Matrix Hw3File::getTransformMatrix()
+{
+    return this->transformStack[this->transStackCount];
+}
+
+void Hw3File::popTransformMatrix()
+{
+    if (this->transStackCount == 0)
+    {
+        this->transformStack[0] = Matrix4().identity();
+    }
+    else
+    {
+        this->transformStack[this->transStackCount] = Matrix4().identity();
+        this->transStackCount --;
+    }
+}
+
+void Hw3File::pushTransformMatrix()
+{
+    this->transStackCount ++;
+    this->transformStack[this->transStackCount] = this->transformStack[this->transStackCount - 1];
+}
+
+void Hw3File::applyTransformMatrix(Matrix t)
+{
+    this->transformStack[this->transStackCount] = this->transformStack[this->transStackCount] * t;
+}

tests/CMakeLists.txt

@@ -3,9 +3,9 @@ project(DoRayTested)
 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 light_test.cpp material_test.cpp world_test.cpp camera_test.cpp
-        shape_test.cpp plane_test.cpp pattern_test.cpp)
+set(TESTS_SRC math_test.cpp tuple_test.cpp colour_test.cpp canvas_test.cpp matrix_test.cpp transformation_test.cpp
+        ray_test.cpp intersect_test.cpp sphere_test.cpp light_test.cpp material_test.cpp world_test.cpp camera_test.cpp
+        shape_test.cpp plane_test.cpp pattern_test.cpp cube_test.cpp)
 
 add_executable(testMyRays)
 target_include_directories(testMyRays PUBLIC ${gtest_SOURCE_DIR}/include ${gtest_SOURCE_DIR})
@@ -19,6 +19,11 @@ gtest_discover_tests(testMyRays
    )
 
 
+add_executable(hw3render)
+target_include_directories(hw3render PUBLIC ../source/include)
+target_sources(hw3render PRIVATE hw3render.cpp)
+target_link_libraries(hw3render rayonnement)
+
 add_executable(ch5_test)
 target_include_directories(ch5_test PUBLIC ../source/include)
 target_sources(ch5_test PRIVATE ch5_test.cpp)
@@ -59,6 +64,11 @@ target_include_directories(ch11_test PUBLIC ../source/include)
 target_sources(ch11_test PRIVATE ch11_test.cpp)
 target_link_libraries(ch11_test rayonnement)
 
+add_executable(ch12_test)
+target_include_directories(ch12_test PUBLIC ../source/include)
+target_sources(ch12_test PRIVATE ch12_test.cpp)
+target_link_libraries(ch12_test rayonnement)
+
 add_test(NAME Chapter05_Test COMMAND $<TARGET_FILE:ch5_test>)
 add_test(NAME Chapter06_Test COMMAND $<TARGET_FILE:ch6_test>)
 add_test(NAME Chapter07_Test COMMAND $<TARGET_FILE:ch7_test>)
@@ -67,3 +77,4 @@ add_test(NAME Chapter10_Test COMMAND $<TARGET_FILE:ch10_test>)
 add_test(NAME Chapter11_Reflection COMMAND $<TARGET_FILE:ch11_reflection>)
 add_test(NAME Chapter11_Refraction COMMAND $<TARGET_FILE:ch11_refraction>)
 add_test(NAME Chapter11_Test COMMAND $<TARGET_FILE:ch11_test>)
+add_test(NAME Chapter12_Test COMMAND $<TARGET_FILE:ch12_test>)

tests/ch10_test.cpp

@@ -79,7 +79,7 @@ int main()
     w.addLight(&light);
 
     /* Set the camera */
-    Camera camera = Camera(1920, 1080, M_PI / 3);
+    Camera camera = Camera(100, 50, M_PI / 3);
     camera.setTransform(viewTransform(Point(0, 1.5, -5),
                                       Point(0, 1, 0),
                                       Vector(0, 1, 0)));

tests/ch11_test.cpp

@@ -145,7 +145,7 @@ int main()
     w.addLight(&light);
 
     /* Set the camera */
-    Camera camera = Camera(400, 100, 1.152);
+    Camera camera = Camera(400, 200, 1.152);
     camera.setTransform(viewTransform(Point(-2.6, 1.5, -3.9),
                                       Point(-0.6, 1, -0.8),
                                       Vector(0, 1, 0)));

tests/ch12_test.cpp

@@ -0,0 +1,213 @@
+/*
+ *  DoRayMe - a quick and dirty Raytracer
+ *  Render test for reflection in chapter 12.
+ *
+ *  Created by Manoël Trapier
+ *  Copyright (c) 2020 986-Studio.
+ *
+ */
+#include <world.h>
+#include <light.h>
+#include <sphere.h>
+#include <plane.h>
+#include <cube.h>
+#include <material.h>
+#include <colour.h>
+#include <canvas.h>
+#include <camera.h>
+
+#include <pattern.h>
+#include <strippattern.h>
+#include <gradientpattern.h>
+#include <checkerspattern.h>
+#include <ringpattern.h>
+
+#include <transformation.h>
+
+int main()
+{
+    World w = World();
+
+    /* Add light */
+    Light light = Light(POINT_LIGHT, Point(0, 6.9, -5), Colour(1, 1, 0.9));
+    w.addLight(&light);
+
+    /* ----------------------------- */
+
+    /* The floor / ceiling */
+    Cube floor = Cube();
+    floor.setTransform( scaling(20, 7, 20) * translation(0, 1, 0));
+    floor.material.pattern = new CheckersPattern(Colour(0, 0, 0), Colour(0.25, 0.25, 0.25));
+    floor.material.pattern->setTransform(scaling(0.07, 0.07, 0.07));
+    floor.material.ambient = 0.25;
+    floor.material.diffuse = 0.7;
+    floor.material.specular = 0.9;
+    floor.material.shininess = 300;
+    floor.material.reflective = 0.1;
+    w.addObject(&floor);
+
+    /* Walls */
+    Cube walls = Cube();
+    walls.setTransform(scaling(10, 10, 10));
+    walls.material.pattern = new CheckersPattern(Colour( 0.4863, 0.3765, 0.2941), Colour(0.3725, 0.2902, 0.2275 ));
+    walls.material.pattern->setTransform(scaling(0.05, 20, 0.05));
+    walls.material.ambient = 0.1;
+    walls.material.diffuse = 0.7;
+    walls.material.specular = 0.9;
+    walls.material.shininess = 300;
+    walls.material.reflective = 0.1;
+    w.addObject(&walls);
+
+    /* Table top */
+    Cube tableTop = Cube();
+    tableTop.setTransform(translation(0, 3.1, 0) * scaling(3, 0.1, 2));
+    tableTop.material.pattern = new StripPattern(Colour(0.5529, 0.4235, 0.3255), Colour(0.6588, 0.5098, 0.4000 ));
+    tableTop.material.pattern->setTransform(scaling(0.05, 0.05, 0.05) * rotationY(0.1));
+    tableTop.material.ambient = 0.1;
+    tableTop.material.diffuse = 0.7;
+    tableTop.material.specular = 0.9;
+    tableTop.material.shininess = 300;
+    tableTop.material.reflective = 0.2;
+    w.addObject(&tableTop);
+
+    /* Leg 1 */
+    Cube leg1 = Cube();
+    leg1.setTransform(translation(2.7, 1.5, -1.7) * scaling(0.1, 1.5, 0.1));
+    leg1.material.colour = Colour(0.5529, 0.4235, 0.3255);
+    leg1.material.ambient = 0.2;
+    leg1.material.diffuse = 0.7;
+    w.addObject(&leg1);
+
+    /* Leg 2 */
+    Cube leg2 = Cube();
+    leg2.setTransform(translation(2.7, 1.5, 1.7) * scaling(0.1, 1.5, 0.1));
+    leg2.material.colour = Colour(0.5529, 0.4235, 0.3255);
+    leg2.material.ambient = 0.2;
+    leg2.material.diffuse = 0.7;
+    w.addObject(&leg2);
+
+    /* Leg 3 */
+    Cube leg3 = Cube();
+    leg3.setTransform(translation(-2.7, 1.5, -1.7) * scaling(0.1, 1.5, 0.1));
+    leg3.material.colour = Colour(0.5529, 0.4235, 0.3255);
+    leg3.material.ambient = 0.2;
+    leg3.material.diffuse = 0.7;
+    w.addObject(&leg3);
+
+    /* Leg 4 */
+    Cube leg4 = Cube();
+    leg4.setTransform(translation(-2.7, 1.5, 1.7) * scaling(0.1, 1.5, 0.1));
+    leg4.material.colour = Colour(0.5529, 0.4235, 0.3255);
+    leg4.material.ambient = 0.2;
+    leg4.material.diffuse = 0.7;
+    w.addObject(&leg4);
+
+    /* ----------------------------- */
+
+    /* Glass cube */
+    Cube glassCube = Cube();
+    glassCube.setTransform(translation(0, 3.45001, 0) * rotationY(0.2) * scaling(0.25, 0.25, 0.25));
+    glassCube.dropShadow = false;
+    glassCube.material.colour = Colour(1, 1, 0.8);
+    glassCube.material.ambient = 0;
+    glassCube.material.diffuse = 0.3;
+    glassCube.material.specular = 0.9;
+    glassCube.material.shininess = 300;
+    glassCube.material.reflective = 0.7;
+    glassCube.material.transparency = 0.7;
+    glassCube.material.refractiveIndex = 1.5;
+    w.addObject(&glassCube);
+
+    /* Little cube 1 */
+    Cube lilCube1 = Cube();
+    lilCube1.setTransform(translation(1, 3.25, -0.9) *
+                           rotationY(-0.4) *
+                           scaling(0.15, 0.15, 0.15));
+    lilCube1.material.colour = Colour(1, 0.5, 0.5);
+    lilCube1.material.reflective = 0.6;
+    lilCube1.material.diffuse = 0.4;
+    w.addObject(&lilCube1);
+
+    /* Little cube 2 */
+    Cube lilCube2 = Cube();
+    lilCube2.setTransform(translation(-1.5, 3.27, 0.3) *
+                          rotationY(0.4) *
+                          scaling(0.15, 0.07, 0.15));
+    lilCube2.material.colour = Colour(1, 1, 0.5);
+    w.addObject(&lilCube2);
+
+    /* Little cube 3 */
+    Cube lilCube3 = Cube();
+    lilCube3.setTransform(translation(0, 3.25, 1) *
+                          rotationY(0.4) *
+                          scaling(0.2, 0.05, 0.05));
+    lilCube3.material.colour = Colour(0.5, 1, 0.5);
+    w.addObject(&lilCube3);
+
+    /* Little cube 4 */
+    Cube lilCube4 = Cube();
+    lilCube4.setTransform(translation(-0.6, 3.4, -1) *
+                          rotationY(0.8) *
+                          scaling(0.05, 0.2, 0.05));
+    lilCube4.material.colour = Colour(0.5, 0.5, 1);
+    w.addObject(&lilCube4);
+
+    /* Little cube 5 */
+    Cube lilCube5 = Cube();
+    lilCube5.setTransform(translation(2, 3.4, 1) *
+                          rotationY(0.8) *
+                          scaling(0.05, 0.2, 0.05));
+    lilCube5.material.colour = Colour(0.5, 1, 1);
+    w.addObject(&lilCube5);
+
+    /* ----------------------------- */
+
+    /* Frame 1 */
+    Cube frame1 = Cube();
+    frame1.setTransform(translation(-10, 4, 1) * scaling(0.05, 1, 1));
+    frame1.material.colour = Colour(0.7098, 0.2471, 0.2196);
+    frame1.material.diffuse = 0.6;
+    w.addObject(&frame1);
+
+    /* Frame 2 */
+    Cube frame2 = Cube();
+    frame2.setTransform(translation(-10, 3.4, 2.7) * scaling(0.05, 0.4, 0.4));
+    frame2.material.colour = Colour(0.2667, 0.2706, 0.6902);
+    frame2.material.diffuse = 0.6;
+    w.addObject(&frame2);
+
+    /* Frame 3 */
+    Cube frame3 = Cube();
+    frame3.setTransform(translation(-10, 4.6, 2.7) * scaling(0.05, 0.4, 0.4));
+    frame3.material.colour = Colour(0.3098, 0.5961, 0.3098);
+    frame3.material.diffuse = 0.6;
+    w.addObject(&frame3);
+
+    /* ----------------------------- */
+
+    /* Mirror */
+    Cube mirror = Cube();
+    mirror.setTransform(translation(-2, 3.5, 9.95) * scaling(4.8, 1.4, 0.06));
+    mirror.material.colour = Colour(0, 0, 0);
+    mirror.material.diffuse = 0;
+    mirror.material.ambient = 0;
+    mirror.material.specular = 1;
+    mirror.material.shininess = 300;
+    mirror.material.reflective = 1;
+    w.addObject(&mirror);
+
+    /* ----------------------------- */
+
+    /* Set the camera */
+    Camera camera = Camera(400, 200, 0.785);
+    camera.setTransform(viewTransform(Point(8, 6, -8),
+                                      Point(0, 3, 0),
+                                      Vector(0, 1, 0)));
+
+    /* Now render it */
+    Canvas image = camera.render(w, 4);
+
+    image.SaveAsPNG("ch12_test.png");
+
+    return 0;
+}

tests/cube_test.cpp

@@ -0,0 +1,117 @@
+/*
+ *  DoRayMe - a quick and dirty Raytracer
+ *  Cube unit tests
+ *
+ *  Created by Manoël Trapier
+ *  Copyright (c) 2020 986-Studio.
+ *
+ */
+#include <intersect.h>
+#include <intersection.h>
+#include <cube.h>
+#include <transformation.h>
+#include <gtest/gtest.h>
+
+TEST(CubeTest, A_ray_intersects_a_cube)
+{
+    Cube c = Cube();
+
+    Point Origins[] = {
+            Point(5, 0.5, 0),
+            Point(-5, 0.5, 0),
+            Point(0.5, 5, 0),
+            Point(0.5, -5, 0),
+            Point(0.5, 0, 5),
+            Point(0.5, 0, -5),
+            Point(0, 0.5, 0),
+    };
+
+    Vector Directions[] = {
+            Vector(-1, 0, 0),
+            Vector(1, 0, 0),
+            Vector(0, -1, 0),
+            Vector(0, 1, 0),
+            Vector(0, 0, -1),
+            Vector(0, 0, 1),
+            Vector(0, 0, 1),
+    };
+
+    double t1[] = { 4, 4, 4, 4, 4, 4, -1 };
+    double t2[] = { 6, 6, 6, 6, 6, 6, 1 };
+
+    int i;
+    for(i = 0; i < 7; i++)
+    {
+        Ray r = Ray(Origins[i], Directions[i]);
+        Intersect xs = c.intersect(r);
+
+        ASSERT_EQ(xs.count(), 2);
+        EXPECT_EQ(xs[0].t, t1[i]);
+        EXPECT_EQ(xs[1].t, t2[i]);
+    }
+}
+
+TEST(CubeTest, A_ray_miss_a_cube)
+{
+    Cube c = Cube();
+
+    Point Origins[] = {
+            Point(-2, 0, 0),
+            Point(0, -2, 0),
+            Point(0, 0, -2),
+            Point(2, 0, 2),
+            Point(0, 2, 2),
+            Point(2, 2, 0),
+    };
+
+    Vector Directions[] = {
+            Vector(0.2673, 0.5345, 0.8018),
+            Vector(0.8018, 0.2673, 0.5345),
+            Vector(0.5345, 0.8018, 0.2673),
+            Vector(0, 0, -1),
+            Vector(0, -1, 0),
+            Vector(-1, 0, 0),
+    };
+
+    int i;
+    for(i = 0; i < 6; i++)
+    {
+        Ray r = Ray(Origins[i], Directions[i]);
+        Intersect xs = c.intersect(r);
+
+        ASSERT_EQ(xs.count(), 0);
+    }
+}
+
+TEST(CubeTest, The_normal_on_the_surface_of_a_cube)
+{
+    Cube c = Cube();
+
+    Point HitPoints[] = {
+            Point(1, 0.5, -0.8),
+            Point(-1, -0.2, 0.9),
+            Point(-0.4, 1, -0.1),
+            Point(0.3, -1, -0.7),
+            Point(-0.6, 0.3, 1),
+            Point(0.4, 0.4, -1),
+            Point(1, 1, 1),
+            Point(-1, -1, -1),
+    };
+
+    Vector ExpectedNormals[] = {
+            Vector(1, 0, 0),
+            Vector(-1, 0, 0),
+            Vector(0, 1, 0),
+            Vector(0, -1, 0),
+            Vector(0, 0, 1),
+            Vector(0, 0, -1),
+            Vector(1, 0, 0),
+            Vector(-1, 0, 0),
+    };
+
+    int i;
+    for(i = 0; i < 8; i++)
+    {
+        ASSERT_EQ(c.normalAt(HitPoints[i]), ExpectedNormals[i]);
+    }
+}

tests/hw3render.cpp

@@ -0,0 +1,42 @@
+/*
+ *  DoRayMe - a quick and dirty Raytracer
+ *  Renderer using hw3 files as world builder.
+ *
+ *  Created by Manoël Trapier
+ *  Copyright (c) 2020 986-Studio.
+ *
+ */
+#include <stdio.h>
+
+#include <world.h>
+#include <worldbuilder.h>
+#include <light.h>
+#include <sphere.h>
+#include <material.h>
+#include <colour.h>
+#include <canvas.h>
+#include <camera.h>
+#include <transformation.h>
+
+int main(int argc, char *argv[])
+{
+    if(argc != 2)
+    {
+        printf("usage: %s file.hw3\n", argv[0]);
+        return -1;
+    }
+
+    Hw3File world = Hw3File(argv[1]);
+
+    /* Set the camera resolution */
+    Camera cam = Camera(640, 480, world.camFoV);
+
+    cam.setTransform(world.cam);
+
+    /* Now render it */
+    Canvas image = cam.render(world);
+
+    image.SaveAsPNG("hw3render.png");
+
+    return 0;
+}

tests/math_test.cpp

@@ -0,0 +1,97 @@
+/*
+ *  DoRayMe - a quick and dirty Raytracer
+ *  Math helper unit tests
+ *
+ *  Created by Manoël Trapier
+ *  Copyright (c) 2020 986-Studio.
+ *
+ */
+#include <math_helper.h>
+#include <gtest/gtest.h>
+
+TEST(MathTest, Default_epsilon)
+{
+    ASSERT_EQ(getEpsilon(), FLT_EPSILON);
+}
+
+TEST(MathTest, Check_setting_epsilon)
+{
+    set_equal_precision(0.00001);
+
+    ASSERT_EQ(getEpsilon(), 0.00001);
+
+    set_equal_precision(FLT_EPSILON);
+}
+
+TEST(MathTest, Check_double_equal_is_working)
+{
+    ASSERT_TRUE(double_equal(0 - DBL_EPSILON, 0));
+
+    ASSERT_FALSE(double_equal(0 - FLT_EPSILON, 0));
+    ASSERT_TRUE(double_equal(0 - FLT_EPSILON/2.0, 0));
+
+    ASSERT_FALSE(double_equal(0 - 0.001, 0));
+    ASSERT_FALSE(double_equal(0 - 0.00001, 0));
+    ASSERT_FALSE(double_equal(0 - 0.000001, 0));
+
+    set_equal_precision(0.00001);
+    ASSERT_TRUE(double_equal(0 - FLT_EPSILON*2, 0));
+    ASSERT_FALSE(double_equal(0 - 0.001, 0));
+    ASSERT_FALSE(double_equal(0 - 0.00001, 0));
+    ASSERT_TRUE(double_equal(0 - 0.000001, 0));
+
+    set_equal_precision(FLT_EPSILON);
+}
+
+
+
+TEST(MathTest, Check_that_deg_to_rad_is_working)
+{
+    double angle180 = deg_to_rad(180);
+    double angle90 = deg_to_rad(90);
+    double angle270 = deg_to_rad(270);
+
+    ASSERT_EQ(angle180, M_PI);
+    ASSERT_EQ(angle90, M_PI / 2.);
+    ASSERT_EQ(angle270, M_PI * 1.5);
+}
+
+TEST(MathTest, Min_is_working)
+{
+    ASSERT_EQ(min3(1, 2, 3), 1);
+    ASSERT_EQ(min3(1, 3, 2), 1);
+    ASSERT_EQ(min3(2, 1, 3), 1);
+    ASSERT_EQ(min3(2, 3, 1), 1);
+    ASSERT_EQ(min3(3, 1, 2), 1);
+    ASSERT_EQ(min3(3, 2, 1), 1);
+
+    ASSERT_EQ(min3(1, 2, 2), 1);
+    ASSERT_EQ(min3(2, 1, 2), 1);
+    ASSERT_EQ(min3(2, 2, 1), 1);
+
+    ASSERT_EQ(min3(3, 2, 2), 2);
+    ASSERT_EQ(min3(2, 3, 2), 2);
+    ASSERT_EQ(min3(2, 2, 3), 2);
+
+    ASSERT_EQ(min3(2, 2, 2), 2);
+}
+
+TEST(MathTest, Max_is_working)
+{
+    ASSERT_EQ(max3(1, 2, 3), 3);
+    ASSERT_EQ(max3(1, 3, 2), 3);
+    ASSERT_EQ(max3(2, 1, 3), 3);
+    ASSERT_EQ(max3(2, 3, 1), 3);
+    ASSERT_EQ(max3(3, 1, 2), 3);
+    ASSERT_EQ(max3(3, 2, 1), 3);
+
+    ASSERT_EQ(max3(1, 2, 2), 2);
+    ASSERT_EQ(max3(2, 1, 2), 2);
+    ASSERT_EQ(max3(2, 2, 1), 2);
+
+    ASSERT_EQ(max3(3, 2, 2), 3);
+    ASSERT_EQ(max3(2, 3, 2), 3);
+    ASSERT_EQ(max3(2, 2, 3), 3);
+
+    ASSERT_EQ(max3(2, 2, 2), 2);
+}

tests/transformation_test.cpp

@@ -245,14 +245,4 @@ TEST(TransformationTest, An_arbitrary_view_transformation)
     set_equal_precision(FLT_EPSILON);
 }
 
-TEST(TransformationTest, Check_that_deg_to_rad_is_working)
-{
-    double angle180 = deg_to_rad(180);
-    double angle90 = deg_to_rad(90);
-    double angle270 = deg_to_rad(270);
-
-    ASSERT_EQ(angle180, M_PI);
-    ASSERT_EQ(angle90, M_PI / 2.);
-    ASSERT_EQ(angle270, M_PI * 1.5);
-}