496 lines
18 KiB
C++
496 lines
18 KiB
C++
/*!
|
|
* 13_cylinders.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: 18/03/2024
|
|
*
|
|
*/
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
|
|
#include <catch2/catch_test_macros.hpp>
|
|
|
|
#include "raytracing.h"
|
|
|
|
#include "common_data.h"
|
|
|
|
using namespace Raytracer;
|
|
|
|
/* ------------------------------------------------------------------------- */
|
|
|
|
SCENARIO("A Ray misses a cylinder", "[features/cylinders.feature]")
|
|
{
|
|
// | origin | direction |
|
|
// | point(1, 0, 0) | vector(0, 1, 0) |
|
|
// | point(0, 0, 0) | vector(0, 1, 0) |
|
|
// | point(0, 0, -5) | vector(1, 1, 1) |
|
|
DataOrigDirT0T1 the_test[] = {
|
|
{Tuple::Point(1, 0, 0), Tuple::Vector(0, 1, 0)},
|
|
{Tuple::Point(0, 0, 0), Tuple::Vector(0, 1, 0)},
|
|
{Tuple::Point(0, 0, -5), Tuple::Vector(1, 1, 1)}
|
|
};
|
|
|
|
GIVEN("cyl <- cylinder()")
|
|
{
|
|
Cylinder cyl;
|
|
AND_GIVEN("r <- ray(<origin>, <direction>)")
|
|
{
|
|
WHEN("xs <- local_intersect(cyl,r)")
|
|
{
|
|
for (int i = 0; i < 3; i++)
|
|
{
|
|
Ray r(the_test[i].origin, the_test[i].direction);
|
|
Intersections xs = cyl.local_intersect(r);
|
|
THEN("xs.count = 0")
|
|
{
|
|
REQUIRE(xs.count() == 0);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------- */
|
|
|
|
SCENARIO("A Ray strikes a cylinder", "[features/cylinders.feature]")
|
|
{
|
|
// | origin | direction | t0 | t1 |
|
|
// | point(1, 0, -5) | vector(0, 0, 1) | 5 | 5 |
|
|
// | point(0, 0, -5) | vector(0, 0, 1) | 4 | 6 |
|
|
// | point(0.5, 0, -5) | vector(0.1, 1, 1) | 6.80798 | 7.08872 |
|
|
DataOrigDirT0T1 the_test[] = {
|
|
{ Tuple::Point(1, 0, -5), Tuple::Vector(0, 0, 1), 5, 5},
|
|
{ Tuple::Point(0, 0, -5), Tuple::Vector(0, 0, 1), 4, 6},
|
|
{Tuple::Point(0.5, 0, -5), Tuple::Vector(0.1, 1, 1), 6.80798, 7.08872}
|
|
};
|
|
GIVEN("cyl <- cylinder()")
|
|
{
|
|
Cylinder cyl;
|
|
AND_GIVEN("direction <- normalize(<direction>)")
|
|
{
|
|
AND_GIVEN("r <- ray(<origin>, direction)")
|
|
{
|
|
WHEN("xs <- local_intersect(cyl,r)")
|
|
{
|
|
for (int i = 0; i < 3; i++)
|
|
{
|
|
Tuple direction = the_test[i].direction.normalize();
|
|
Ray r(the_test[i].origin, direction);
|
|
Intersections xs = cyl.local_intersect(r);
|
|
THEN("xs.count = 2")
|
|
{
|
|
REQUIRE(xs.count() == 2);
|
|
}
|
|
AND_THEN("xs[0].t = <t1>")
|
|
{
|
|
REQUIRE(xs[0].distance_t() == the_test[i].t0);
|
|
}
|
|
AND_THEN("xs[1].t = <t2>")
|
|
{
|
|
REQUIRE(xs[1].distance_t() == the_test[i].t1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------- */
|
|
|
|
SCENARIO("Normal vector on a cylinder", "[features/cylinders.feature]")
|
|
{
|
|
// | point | normal |
|
|
// | point(1, 0, 0) | vector(1, 0, 0) |
|
|
// | point(0, 5, -1) | vector(0, 0, -1) |
|
|
// | point(0, -2, 1) | vector(0, 0, 1) |
|
|
// | point(-1, 1, 0) | vector(-1, 0, 0) |
|
|
DataPointNormal the_test[] = {
|
|
{ Tuple::Point(1, 0, 0), Tuple::Vector(1, 0, 0)},
|
|
{ Tuple::Point(0, 5, -1), Tuple::Vector(0, 0, -1)},
|
|
{ Tuple::Point(0, -2, 1), Tuple::Vector(0, 0, 1)},
|
|
{Tuple::Point(-1, 1, 0), Tuple::Vector(-1, 0, 0)}
|
|
};
|
|
|
|
GIVEN("cyl <- cylinder()")
|
|
{
|
|
Cylinder cyl;
|
|
WHEN("n <- local_normal_at(cyl,<point>)")
|
|
{
|
|
for (int i = 0; i < 4; i++)
|
|
{
|
|
Tuple p = the_test[i].point;
|
|
Tuple normal = cyl.local_normal_at(p);
|
|
THEN("n = <normal>")
|
|
{
|
|
REQUIRE(normal == the_test[i].normal);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------- */
|
|
|
|
SCENARIO("The default minimum and maximum for a cylinder", "[features/cylinders.feature]")
|
|
{
|
|
GIVEN("cyl <- cylinder()")
|
|
{
|
|
Cylinder cyl;
|
|
THEN("cym.minimum = -infinity")
|
|
{
|
|
REQUIRE(cyl.minimum() == -std::numeric_limits<double>::infinity());
|
|
}
|
|
AND_THEN("cym.maximum = infinity")
|
|
{
|
|
REQUIRE(cyl.maximum() == std::numeric_limits<double>::infinity());
|
|
}
|
|
}
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------- */
|
|
|
|
SCENARIO("Intersecting a constrained cylinder", "[features/cylinders.feature]")
|
|
{
|
|
// | | point | direction | count |
|
|
// | 1 | point(0, 1.5, 0) | vector(0.1, 1, 0) | 0 |
|
|
// | 2 | point(0, 3, -5) | vector(0, 0, 1) | 0 |
|
|
// | 3 | point(0, 0, -5) | vector(0, 0, 1) | 0 |
|
|
// | 4 | point(0, 2, -5) | vector(0, 0, 1) | 0 |
|
|
// | 5 | point(0, 1, -5) | vector(0, 0, 1) | 0 |
|
|
// | 6 | point(0, 1.5, -2) | vector(0, 0, 1) | 2 |
|
|
DataPointDirCount the_test[] = {
|
|
{Tuple::Point(0, 1.5, 0), Tuple::Vector(0.1, 1, 0), 0},
|
|
{Tuple::Point(0, 3, -5), Tuple::Vector(0, 0, 1), 0},
|
|
{Tuple::Point(0, 0, -5), Tuple::Vector(0, 0, 1), 0},
|
|
{Tuple::Point(0, 2, -5), Tuple::Vector(0, 0, 1), 0},
|
|
{Tuple::Point(0, 1, -5), Tuple::Vector(0, 0, 1), 0},
|
|
{Tuple::Point(0, 1.5, -20), Tuple::Vector(0, 0, 1), 2}
|
|
};
|
|
GIVEN("cyl <- cylinder()")
|
|
{
|
|
Cylinder cyl;
|
|
AND_GIVEN("cyl.minimum <- 1")
|
|
{
|
|
cyl.set_minimum(1);
|
|
AND_GIVEN("cyl.maximum <- 2")
|
|
{
|
|
cyl.set_maximum(2);
|
|
AND_GIVEN("direction <- normalize(<direction>)")
|
|
{
|
|
AND_GIVEN("r <- ray(<point>, direction)")
|
|
{
|
|
WHEN("xs <- local_intersect(cyl,r)")
|
|
{
|
|
for (int i = 0; i < 6; i++)
|
|
{
|
|
Tuple direction = the_test[i].direction.normalize();
|
|
Ray r(the_test[i].point, direction);
|
|
Intersections xs = cyl.local_intersect(r);
|
|
THEN("xs.count = <count>")
|
|
{
|
|
REQUIRE(xs.count() == the_test[i].count);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------- */
|
|
|
|
SCENARIO("The default closed value for a cylinder", "[features/cylinders.feature]")
|
|
{
|
|
GIVEN("cyl <- cylinder()")
|
|
{
|
|
Cylinder cyl;
|
|
THEN("cyl.closed = false")
|
|
{
|
|
REQUIRE(cyl.closed() == false);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------- */
|
|
|
|
SCENARIO("Intersecting the caps of a closed cylinder", "[features/cylinders.feature]")
|
|
{
|
|
// | | point | direction | count |
|
|
// | 1 | point(0, 3, 0) | vector(0, -1, 0) | 2 |
|
|
// | 2 | point(0, 3, -2) | vector(0, -1, 2) | 2 |
|
|
// | 3 | point(0, 4, -2) | vector(0, -1, 1) | 2 | # corner case
|
|
// | 4 | point(0, 0, -2) | vector(0, 1, 2) | 2 |
|
|
// | 5 | point(0, -1, -2) | vector(0, 1, 1) | 2 | # corner case
|
|
DataPointDirCount the_test[] = {
|
|
{Tuple::Point(0, 3, 0), Tuple::Vector(0, -1, 0), 2},
|
|
{Tuple::Point(0, 3, -2), Tuple::Vector(0, -1, 2), 2},
|
|
{Tuple::Point(0, 4, -2), Tuple::Vector(0, -1, 1), 2},
|
|
{Tuple::Point(0, 0, -2), Tuple::Vector(0, 1, 2), 2},
|
|
{Tuple::Point(0, -1, -2), Tuple::Vector(0, 1, 1), 2}
|
|
};
|
|
GIVEN("cyl <- cylinder()")
|
|
{
|
|
Cylinder cyl;
|
|
AND_GIVEN("cyl.minimum <- 1")
|
|
{
|
|
cyl.set_minimum(1);
|
|
AND_GIVEN("cyl.maximum <- 2")
|
|
{
|
|
cyl.set_maximum(2);
|
|
AND_GIVEN("cyl.closed <- true")
|
|
{
|
|
cyl.set_closed(true);
|
|
AND_GIVEN("direction <- normalize(<direction>)")
|
|
{
|
|
AND_GIVEN("r <- ray(<point>, direction)")
|
|
{
|
|
WHEN("xs <- local_intersect(cyl,r)")
|
|
{
|
|
for (int i = 0; i < 5; i++)
|
|
{
|
|
Tuple direction = the_test[i].direction.normalize();
|
|
Ray r(the_test[i].point, direction);
|
|
Intersections xs = cyl.local_intersect(r);
|
|
THEN("xs.count = <count>")
|
|
{
|
|
REQUIRE(xs.count() == the_test[i].count);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------- */
|
|
|
|
SCENARIO("The normal vector on the cylinder's end caps", "[features/cylinders.feature]")
|
|
{
|
|
// | point | normal |
|
|
// | point(0, 1, 0) | vector(0, -1, 0) |
|
|
// | point(0.5, 1, 0) | vector(0, -1, 0) |
|
|
// | point(0, 1, 0.5) | vector(0, -1, 0) |
|
|
// | point(0, 2, 0) | vector(0, 1, 0) |
|
|
// | point(0.5, 2, 0) | vector(0, 1, 0) |
|
|
// | point(0, 2, 0.5) | vector(0, 1, 0) |
|
|
DataPointNormal the_test[] = {
|
|
{ Tuple::Point(0, 1, 0), Tuple::Vector(0, -1, 0)},
|
|
{Tuple::Point(0.5, 1, 0), Tuple::Vector(0, -1, 0)},
|
|
{ Tuple::Point(0, 1, 0.5), Tuple::Vector(0, -1, 0)},
|
|
{ Tuple::Point(0, 2, 0), Tuple::Vector(0, 1, 0)},
|
|
{Tuple::Point(0.5, 2, 0), Tuple::Vector(0, 1, 0)},
|
|
{ Tuple::Point(0, 2, 0.5), Tuple::Vector(0, 1, 0)}
|
|
};
|
|
GIVEN("cyl <- cylinder()")
|
|
{
|
|
Cylinder cyl;
|
|
AND_GIVEN("cyl.minimum <- 1")
|
|
{
|
|
cyl.set_minimum(1);
|
|
AND_GIVEN("cyl.maximum <- 2")
|
|
{
|
|
cyl.set_maximum(2);
|
|
AND_GIVEN("cyl.closed <- true")
|
|
{
|
|
cyl.set_closed(true);
|
|
WHEN("n <- local_normal_at(cyl,<point>)")
|
|
{
|
|
for (int i = 0; i < 6; i++)
|
|
{
|
|
Tuple p = the_test[i].point;
|
|
Tuple normal = cyl.local_normal_at(p);
|
|
THEN("n = <normal>")
|
|
{
|
|
REQUIRE(normal == the_test[i].normal);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------- */
|
|
|
|
SCENARIO("Intersecting a cone with a ray", "[features/cones.feature]")
|
|
{
|
|
// | origin | direction | t0 | t1 |
|
|
// | point(0, 0, -5) | vector(0, 0, 1) | 5 | 5 |
|
|
// | point(0, 0, -5) | vector(1, 1, 1) | 8.66025 | 8.66025 |
|
|
// | point(1, 1, -5) | vector(-0.5, -1, 1) | 4.55006 | 49.44994 |
|
|
DataOrigDirT0T1 the_test[] = {
|
|
{Tuple::Point(0, 0, -5), Tuple::Vector(0, 0, 1), 5, 5},
|
|
{Tuple::Point(0, 0, -5), Tuple::Vector(1, 1, 1), 8.66025, 8.66025},
|
|
{Tuple::Point(1, 1, -5), Tuple::Vector(-0.5, -1, 1), 4.55006, 49.44994}
|
|
};
|
|
GIVEN("shape <- cone()")
|
|
{
|
|
Cone shape;
|
|
AND_GIVEN("direction <- normalize(<direction>)")
|
|
{
|
|
AND_GIVEN("r <- ray(<origin>, direction)")
|
|
{
|
|
WHEN("xs <- local_intersect(shape, r)")
|
|
{
|
|
for (int i = 0; i < 5; i++)
|
|
{
|
|
Tuple direction = the_test[i].direction.normalize();
|
|
Ray r(the_test[i].origin, direction);
|
|
Intersections xs = shape.local_intersect(r);
|
|
THEN("xs.count = 2")
|
|
{
|
|
REQUIRE(xs.count() == 2);
|
|
}
|
|
AND_THEN("xs[0].t = <t1>")
|
|
{
|
|
REQUIRE(xs[0].distance_t() == the_test[i].t0);
|
|
}
|
|
AND_THEN("xs[1].t = <t2>")
|
|
{
|
|
REQUIRE(xs[1].distance_t() == the_test[i].t1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------- */
|
|
|
|
SCENARIO("Intersecting a cone with a ray parallel ton one of its halves", "[features/cones.feature]")
|
|
{
|
|
GIVEN("shape <- cone()")
|
|
{
|
|
Cone shape;
|
|
AND_GIVEN("direction <- normalize(vector(0, 1, 1))")
|
|
{
|
|
Tuple direction = Tuple::Vector(0, 1, 1).normalize();
|
|
AND_GIVEN("r <- ray(point(0, 0, -1), direction)")
|
|
{
|
|
Ray r(Tuple::Point(0, 0, -1), direction);
|
|
WHEN("xs <- local_intersect(shape, r)")
|
|
{
|
|
Intersections xs = shape.local_intersect(r);
|
|
THEN("xs.count = 1")
|
|
{
|
|
REQUIRE(xs.count() == 1);
|
|
}
|
|
AND_THEN("xs[0].t = 0.35355")
|
|
{
|
|
REQUIRE(double_equal(xs[0].distance_t(), 0.35355));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------- */
|
|
|
|
SCENARIO("Intersecting a cone's end caps", "[features/cones.feature]")
|
|
{
|
|
// | origin | direction | count |
|
|
// | point(0, 0, -5) | vector(0, 1, 0) | 0 |
|
|
// | point(0, 0, -0.25) | vector(0, 1, 1) | 2 |
|
|
// | point(0, 0, -0.25) | vector(0, 1, 0) | 4 |
|
|
|
|
DataOrigDirCount the_test[] = {
|
|
{Tuple::Point(0, 0, -5), Tuple::Vector(0, 1, 0), 0},
|
|
{Tuple::Point(0, 0, -0.25), Tuple::Vector(0, 1, 1), 2},
|
|
{Tuple::Point(0, 0, -0.25), Tuple::Vector(0, 1, 0), 4}
|
|
};
|
|
GIVEN("shape <- cone()")
|
|
{
|
|
Cone shape;
|
|
AND_GIVEN("shape.minimum <- 0.5")
|
|
{
|
|
shape.set_minimum(0.5);
|
|
AND_GIVEN("shape.maximum <- 0.5")
|
|
{
|
|
shape.set_maximum(0.5);
|
|
AND_GIVEN("shape.closed <- true")
|
|
{
|
|
shape.set_closed(true);
|
|
AND_GIVEN("direction <- normalize(<direction>)")
|
|
{
|
|
AND_GIVEN("r <- ray(<origin>, direction)")
|
|
{
|
|
WHEN("xs <- local_intersect(shape,r)")
|
|
{
|
|
for (int i = 0; i < 5; i++)
|
|
{
|
|
Tuple direction = the_test[i].direction.normalize();
|
|
Ray r(the_test[i].origin, direction);
|
|
Intersections xs = shape.local_intersect(r);
|
|
THEN("xs.count = <count>")
|
|
{
|
|
REQUIRE(xs.count() == the_test[i].count);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------- */
|
|
|
|
SCENARIO("Computing the normal vector on a cone", "[features/cones.feature]")
|
|
{
|
|
// | point | normal |
|
|
// | point(0, 0, 0) | vector(0, 0, 0) |
|
|
// | point(1, 1, 1) | vector(1, -sqrt(2), 1) |
|
|
// | point(-1, -1, 0) | vector(-1, 1, 0) |
|
|
DataPointNormal the_test[] = {
|
|
{ Tuple::Point(0, 0, 0), Tuple::Vector(0, 0, 0)},
|
|
{ Tuple::Point(1, 1, 1), Tuple::Vector(1, -sqrt(2), 1)},
|
|
{Tuple::Point(-1, -1, 0), Tuple::Vector(-1, 1, 0)}
|
|
};
|
|
|
|
GIVEN("shape <- cone()")
|
|
{
|
|
Cone shape;
|
|
WHEN("n <- local_normal_at(shape, <point>)")
|
|
{
|
|
for (int i = 0; i < 3; i++)
|
|
{
|
|
Tuple p = the_test[i].point;
|
|
Tuple normal = shape.local_normal_at(p);
|
|
THEN("n = <normal>")
|
|
{
|
|
REQUIRE(normal == the_test[i].normal);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|