462 lines
14 KiB
C++
462 lines
14 KiB
C++
/*!
|
|
* 06_light_shading.cpp
|
|
*
|
|
* Copyright (c) 2015-2024, NADAL Jean-Baptiste. All rights reserved.
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
|
|
* MA 02110-1301 USA
|
|
*
|
|
* @Author: NADAL Jean-Baptiste
|
|
* @Date: 14/02/2024
|
|
*
|
|
*/
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
|
|
#include <cmath>
|
|
|
|
#include <catch2/catch_test_macros.hpp>
|
|
|
|
#include "raytracing.h"
|
|
|
|
using namespace Raytracer;
|
|
|
|
/* ------------------------------------------------------------------------- */
|
|
|
|
SCENARIO("The normal on a sphere at point a on the x axis", "[features/spheres.feature]")
|
|
{
|
|
GIVEN("s <- sphere()")
|
|
{
|
|
Sphere s;
|
|
WHEN("n <- normal_at(s, point(1, 0, 0))")
|
|
{
|
|
Tuple n = s.normal_at(Tuple::Point(1, 0, 0));
|
|
THEN("n = vector(1, 0, 0)")
|
|
{
|
|
REQUIRE(n == Tuple::Vector(1, 0, 0));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------- */
|
|
|
|
SCENARIO("The normal on a sphere at point a on the y axis", "[features/spheres.feature]")
|
|
{
|
|
GIVEN("s <- sphere()")
|
|
{
|
|
Sphere s;
|
|
WHEN("n <- normal_at(s, point(0, 1, 0))")
|
|
{
|
|
Tuple n = s.normal_at(Tuple::Point(0, 1, 0));
|
|
THEN("n = vector(0, 1, 0)")
|
|
{
|
|
REQUIRE(n == Tuple::Vector(0, 1, 0));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------- */
|
|
|
|
SCENARIO("The normal on a sphere at point a on the z axis", "[features/spheres.feature]")
|
|
{
|
|
GIVEN("s <- sphere()")
|
|
{
|
|
Sphere s;
|
|
WHEN("n <- normal_at(s, point(0, 0, 1))")
|
|
{
|
|
Tuple n = s.normal_at(Tuple::Point(0, 0, 1));
|
|
THEN("n = vector(0, 0, 1)")
|
|
{
|
|
REQUIRE(n == Tuple::Vector(0, 0, 1));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------- */
|
|
|
|
SCENARIO("The normal on a sphere at a nonaxial point", "[features/spheres.feature]")
|
|
{
|
|
GIVEN("s <- sphere()")
|
|
{
|
|
Sphere s;
|
|
WHEN("n <- normal_at(s, point(sqrt(3)/3, sqrt(3)/3, sqrt(3)/3))")
|
|
{
|
|
Tuple n = s.normal_at(Tuple::Point(sqrt(3) / 3, sqrt(3) / 3, sqrt(3) / 3));
|
|
THEN("n = vector(sqrt(3)/3, sqrt(3)/3, sqrt(3)/3))")
|
|
{
|
|
REQUIRE(n == Tuple::Vector(sqrt(3) / 3, sqrt(3) / 3, sqrt(3) / 3));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------- */
|
|
|
|
SCENARIO("The normal is a normalized vector", "[features/spheres.feature]")
|
|
{
|
|
GIVEN("s <- sphere()")
|
|
{
|
|
Sphere s;
|
|
WHEN("n <- normal_at(s, point(sqrt(3)/3, sqrt(3)/3, sqrt(3)/3))")
|
|
{
|
|
Tuple n = s.normal_at(Tuple::Point(sqrt(3) / 3, sqrt(3) / 3, sqrt(3) / 3));
|
|
THEN("n = normalize(n)")
|
|
{
|
|
REQUIRE(n == n.normalize());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------- */
|
|
|
|
SCENARIO("Computing the normal on a translated sphere", "[features/spheres.feature]")
|
|
{
|
|
GIVEN("s <- sphere()")
|
|
{
|
|
Sphere s;
|
|
AND_GIVEN("set_transform(s, translation(0, 1, 0))")
|
|
{
|
|
s.set_transform(Matrix::translation(0, 1, 0));
|
|
WHEN("n <- normal_at(s,point(0, 1.70711, -0.70711))")
|
|
{
|
|
Tuple n = s.normal_at(Tuple::Point(0, 1.70711, -0.70711));
|
|
THEN("n = vector(0, 0.70711, -0.70711)")
|
|
{
|
|
REQUIRE(n == Tuple::Vector(0, 0.70711, -0.70711));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------- */
|
|
|
|
SCENARIO("Computing the normal on a transformed sphere", "[features/spheres.feature]")
|
|
{
|
|
GIVEN("s <- sphere()")
|
|
{
|
|
Sphere s;
|
|
AND_GIVEN("m <- scaling(1, 0. 5,1) * rotation_z(pi/5)")
|
|
{
|
|
Matrix m = Matrix::scaling(1, 0.5, 1) * Matrix::rotation_z(std::numbers::pi / 5);
|
|
AND_GIVEN("set_transform(s, m)")
|
|
{
|
|
s.set_transform(m);
|
|
WHEN("n <- normal_at(s,point(0, sqrt(2)/2, sqrt(2)/2))")
|
|
{
|
|
Tuple n = s.normal_at(Tuple::Point(0, sqrt(2) / 2, -sqrt(2) / 2));
|
|
THEN("n = vector(0,97014, -0.24254)")
|
|
{
|
|
REQUIRE(n == Tuple::Vector(0, 0.97014, -0.24254));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------- */
|
|
|
|
SCENARIO("Reflecting a vector approaching at 45°", "[features/tuples.feature]")
|
|
{
|
|
GIVEN("v <-vector(1, -1, 0)")
|
|
{
|
|
Tuple v = Tuple::Vector(1, -1, 0);
|
|
AND_GIVEN("n <-vector(0, 1, 0)")
|
|
{
|
|
Tuple n = Tuple::Vector(0, 1, 0);
|
|
WHEN("r <- reflect(v, n)")
|
|
{
|
|
Tuple r = v.reflect(n);
|
|
THEN("r = vector(1, 1, 0)")
|
|
{
|
|
REQUIRE(r == Tuple::Vector(1, 1, 0));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------- */
|
|
|
|
SCENARIO("Reflecting a vector off a slanted surface", "[features/tuples.feature]")
|
|
{
|
|
GIVEN("v <-vector(0, -1, 0)")
|
|
{
|
|
Tuple v = Tuple::Vector(0, -1, 0);
|
|
AND_GIVEN("n <-vector(sqrt(2)/2, sqrt(2)/2, 0)")
|
|
{
|
|
Tuple n = Tuple::Vector(sqrt(2) / 2, sqrt(2) / 2, 0);
|
|
WHEN("r <- reflect(v, n)")
|
|
{
|
|
Tuple r = v.reflect(n);
|
|
THEN("r = vector(1, 0, 0)")
|
|
{
|
|
REQUIRE(r == Tuple::Vector(1, 0, 0));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------- */
|
|
|
|
SCENARIO("A point light has a position and intensity", "[features/lights.feature]")
|
|
{
|
|
GIVEN("intensity <- color(1, 1, 1)")
|
|
{
|
|
Color intensity(1, 1, 1);
|
|
AND_GIVEN("position <- point(0, 0, 0)")
|
|
{
|
|
Tuple position = Tuple::Point(0, 0, 0);
|
|
WHEN("light <- point_light(position(position, intensity))")
|
|
{
|
|
PointLight light = PointLight(position, intensity);
|
|
THEN("light.position = position")
|
|
{
|
|
REQUIRE(light.position() == position);
|
|
}
|
|
AND_THEN("light.intensity = intensity")
|
|
{
|
|
REQUIRE(light.intensity() == intensity);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------- */
|
|
|
|
SCENARIO("The default material", "[features/materials.feature]")
|
|
{
|
|
GIVEN("m <- material()")
|
|
{
|
|
Material m;
|
|
THEN("m.color = color(1, 1, 1)")
|
|
{
|
|
REQUIRE(m.color() == Color(1, 1, 1));
|
|
}
|
|
AND_THEN("m.ambient = 0.1")
|
|
{
|
|
REQUIRE(m.ambient() == 0.1);
|
|
}
|
|
AND_THEN("m.diffuse = 0.9")
|
|
{
|
|
REQUIRE(m.diffuse() == 0.9);
|
|
}
|
|
AND_THEN("m.specular = 0.9")
|
|
{
|
|
REQUIRE(m.specular() == 0.9);
|
|
}
|
|
AND_THEN("m.shininess = 200.0")
|
|
{
|
|
REQUIRE(m.shininess() == 200.0);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------- */
|
|
|
|
SCENARIO("A sphere has a default material", "[features/spheres.feature]")
|
|
{
|
|
GIVEN("s <- sphere()")
|
|
{
|
|
Sphere s;
|
|
WHEN("m <- s.material")
|
|
{
|
|
Material m = s.material();
|
|
THEN("m = material()")
|
|
{
|
|
REQUIRE(m == Material());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------- */
|
|
|
|
SCENARIO("A sphere may be assigned a material", "[features/spheres.feature]")
|
|
{
|
|
GIVEN("s <- sphere()")
|
|
{
|
|
Sphere s;
|
|
AND_GIVEN("m <- material")
|
|
{
|
|
Material m;
|
|
AND_GIVEN("m.ambient <- 1")
|
|
{
|
|
m.set_ambient(1);
|
|
WHEN("s.material <- m")
|
|
{
|
|
s.set_material(m);
|
|
THEN("s.material = m")
|
|
{
|
|
s.material() == m;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------- */
|
|
|
|
SCENARIO("Lighting with the eye between the light and the surface", "[features/materials.feature]")
|
|
{
|
|
Tuple position = Tuple::Point(0, 0, 0);
|
|
Material m;
|
|
|
|
GIVEN("eyev <- vector(0, 0, -1)")
|
|
{
|
|
Tuple eyev = Tuple::Vector(0, 0, -1);
|
|
AND_GIVEN("normalv <- vector(0, 0, -1)")
|
|
{
|
|
Tuple normalv = Tuple::Vector(0, 0, -1);
|
|
AND_GIVEN("light <- point_light(point(0, 0, -10),color(1, 1, 1))")
|
|
{
|
|
PointLight light = PointLight(Tuple::Point(0, 0, -10), Color(1, 1, 1));
|
|
WHEN("result <- lighting(m, light, position, eyev, normalv)")
|
|
{
|
|
Color result = m.lighting(nullptr, light, position, eyev, normalv, false);
|
|
THEN("result = color(1.9, 1.9, 1.9)")
|
|
{
|
|
REQUIRE(result == Color(1.9, 1.9, 1.9));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------- */
|
|
|
|
SCENARIO("Lighting with eye between the light & surface, eye offset 45°", "[features/materials.feature]")
|
|
{
|
|
Tuple position = Tuple::Point(0, 0, 0);
|
|
Material m;
|
|
|
|
GIVEN("eyev <- vector(0, sqrt(2)/2, -sqrt(2)/2)")
|
|
{
|
|
Tuple eyev = Tuple::Vector(0, sqrt(2) / 2, -sqrt(2) / 2);
|
|
AND_GIVEN("normalv <- vector(0, 0, -1)")
|
|
{
|
|
Tuple normalv = Tuple::Vector(0, 0, -1);
|
|
AND_GIVEN("light <- point_light(point(0, 0, -10),color(1, 1, 1))")
|
|
{
|
|
PointLight light = PointLight(Tuple::Point(0, 0, -10), Color(1, 1, 1));
|
|
WHEN("result <- lighting(m, light, position, eyev, normalv)")
|
|
{
|
|
Color result = m.lighting(nullptr, light, position, eyev, normalv, false);
|
|
THEN("result = color(1.0, 1.0, 1.0)")
|
|
{
|
|
REQUIRE(result == Color(1.0, 1.0, 1.0));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------- */
|
|
|
|
SCENARIO("Lighting with the eye opposite surface, light offset 45°", "[features/materials.feature]")
|
|
{
|
|
Tuple position = Tuple::Point(0, 0, 0);
|
|
Material m;
|
|
|
|
GIVEN("eyev <- vector(0, 0, -1")
|
|
{
|
|
Tuple eyev = Tuple::Vector(0, 0, -1);
|
|
AND_GIVEN("normalv <- vector(0, 0, -1)")
|
|
{
|
|
Tuple normalv = Tuple::Vector(0, 0, -1);
|
|
AND_GIVEN("light <- point_light(point(0, 10, -10),color(1, 1, 1))")
|
|
{
|
|
PointLight light = PointLight(Tuple::Point(0, 10, -10), Color(1, 1, 1));
|
|
WHEN("result <- lighting(m, light, position, eyev, normalv)")
|
|
{
|
|
Color result = m.lighting(nullptr, light, position, eyev, normalv, false);
|
|
THEN("result = color(0.7364, 0.7364, 0.7364)")
|
|
{
|
|
REQUIRE(result == Color(0.7364, 0.7364, 0.7364));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------- */
|
|
|
|
SCENARIO("Lighting with the eye in the path of the reflection vector", "[features/materials.feature]")
|
|
{
|
|
Tuple position = Tuple::Point(0, 0, 0);
|
|
Material m;
|
|
|
|
GIVEN("eyev <- vector(0, -sqrt(2)/2, -sqrt(2)/2")
|
|
{
|
|
Tuple eyev = Tuple::Vector(0, -sqrt(2) / 2, -sqrt(2) / 2);
|
|
AND_GIVEN("normalv <- vector(0, 0, -1)")
|
|
{
|
|
Tuple normalv = Tuple::Vector(0, 0, -1);
|
|
AND_GIVEN("light <- point_light(point(0, 10, -10),color(1, 1, 1))")
|
|
{
|
|
PointLight light = PointLight(Tuple::Point(0, 10, -10), Color(1, 1, 1));
|
|
WHEN("result <- lighting(m, light, position, eyev, normalv)")
|
|
{
|
|
Color result = m.lighting(nullptr, light, position, eyev, normalv, false);
|
|
THEN("result = color(1.6364, 1.6364, 1.6364)")
|
|
{
|
|
REQUIRE(result == Color(1.6364, 1.6364, 1.6364));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------- */
|
|
|
|
SCENARIO("Lighting with the light behind the surface", "[features/materials.feature]")
|
|
{
|
|
Tuple position = Tuple::Point(0, 0, 0);
|
|
Material m;
|
|
|
|
GIVEN("eyev <- vector(0, 0, -1")
|
|
{
|
|
Tuple eyev = Tuple::Vector(0, 0, -1);
|
|
AND_GIVEN("normalv <- vector(0, 0, -1)")
|
|
{
|
|
Tuple normalv = Tuple::Vector(0, 0, -1);
|
|
AND_GIVEN("light <- point_light(point(0, 0, 10),color(1, 1, 1))")
|
|
{
|
|
PointLight light = PointLight(Tuple::Point(0, 0, 10), Color(1, 1, 1));
|
|
WHEN("result <- lighting(m, light, position, eyev, normalv)")
|
|
{
|
|
Color result = m.lighting(nullptr, light, position, eyev, normalv, false);
|
|
THEN("result = color(0.1, 0.1, 0.1)")
|
|
{
|
|
REQUIRE(result == Color(0.1, 0.1, 0.1));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|