diff --git a/raytracing/CMakeLists.txt b/raytracing/CMakeLists.txt index 8695024..05d25bf 100644 --- a/raytracing/CMakeLists.txt +++ b/raytracing/CMakeLists.txt @@ -37,6 +37,7 @@ add_library(raytracing src/shapes/cone.cpp src/shapes/cube.cpp src/shapes/cylinder.cpp + src/shapes/group.cpp src/shapes/plane.cpp src/shapes/shape.cpp src/shapes/sphere.cpp diff --git a/raytracing/include/raytracing.h b/raytracing/include/raytracing.h index 3aad06c..ae19d62 100644 --- a/raytracing/include/raytracing.h +++ b/raytracing/include/raytracing.h @@ -49,5 +49,6 @@ #include "shapes/cone.h" #include "shapes/cube.h" #include "shapes/cylinder.h" +#include "shapes/group.h" #include "shapes/plane.h" #include "shapes/sphere.h" \ No newline at end of file diff --git a/raytracing/src/shapes/group.cpp b/raytracing/src/shapes/group.cpp new file mode 100644 index 0000000..15cdcc5 --- /dev/null +++ b/raytracing/src/shapes/group.cpp @@ -0,0 +1,61 @@ +/*! + * group.cpp + * + * Copyright (c) 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: 22/03/2024 + * + */ + +// This is an independent project of an individual developer. Dear PVS-Studio, please check it. +// PVS-Studio Static Code Analyzer for C, C++, C#, and Java: http://www.viva64.com + +/* ------------------------------------------------------------------------- */ + +#include + +#include "core/common.h" +#include "core/intersections.h" + +#include "group.h" + +using namespace Raytracer; + +/* ------------------------------------------------------------------------- */ + +Intersections Group::local_intersect(const Ray &a_ray) +{ + Intersections the_intersections; + + return the_intersections; +} + +/* ------------------------------------------------------------------------- */ + +Tuple Group::local_normal_at(const Tuple &a_local_point) const +{ + return Tuple::Vector(0, 1, 0); +} + +/* ------------------------------------------------------------------------- */ + +bool Group::is_empty(void) +{ + return m_data.size() == 0; +} diff --git a/raytracing/src/shapes/group.h b/raytracing/src/shapes/group.h new file mode 100644 index 0000000..d54bfe1 --- /dev/null +++ b/raytracing/src/shapes/group.h @@ -0,0 +1,55 @@ +/*! + * group.h + * + * Copyright (c) 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: 22/03/2024 + * + */ + +#ifndef _RAYTRACER_GROUP_H +#define _RAYTRACER_GROUP_H + +/* ------------------------------------------------------------------------- */ + +#include + +#include + +#include "shapes/shape.h" + +/* ------------------------------------------------------------------------- */ + +namespace Raytracer +{ + class Group : public Shape + { + public: + Group(void) = default; + Intersections local_intersect(const Ray &a_ray) override; + Tuple local_normal_at(const Tuple &a_local_point) const override; + + bool is_empty(void); + + private: + std::vector m_data; + }; +}; // namespace Raytracer + +#endif // _RAYTRACER_GROUP_H diff --git a/raytracing/src/shapes/shape.cpp b/raytracing/src/shapes/shape.cpp index 4af9b3b..cf453c8 100644 --- a/raytracing/src/shapes/shape.cpp +++ b/raytracing/src/shapes/shape.cpp @@ -41,7 +41,8 @@ using namespace Raytracer; /* ------------------------------------------------------------------------- */ Shape::Shape(void) : - m_transform(Matrix::identity()) + m_transform(Matrix::identity()), + m_parent(nullptr) { } @@ -49,7 +50,8 @@ Shape::Shape(void) : Shape::Shape(Shape &a_copy) : m_transform(a_copy.m_transform), - m_material(a_copy.m_material) + m_material(a_copy.m_material), + m_parent(nullptr) { } @@ -57,7 +59,8 @@ Shape::Shape(Shape &a_copy) : Shape::Shape(const Shape &a_copy) : m_transform(a_copy.m_transform), - m_material(a_copy.m_material) + m_material(a_copy.m_material), + m_parent(nullptr) { } @@ -72,6 +75,7 @@ const Shape &Shape::operator=(const Shape &a_shape) m_transform = a_shape.m_transform; m_material = a_shape.m_material; + m_parent = a_shape.m_parent; return *this; } @@ -80,14 +84,14 @@ const Shape &Shape::operator=(const Shape &a_shape) bool Shape::operator==(const Shape &a_shape) const { - return (m_transform == a_shape.m_transform) && (m_material == a_shape.m_material); + return (m_transform == a_shape.m_transform) && (m_material == a_shape.m_material) && (m_parent == a_shape.m_parent); } /* ------------------------------------------------------------------------- */ bool Shape::operator==(const Shape *a_shape) const { - return (m_transform == a_shape->m_transform) && (m_material == a_shape->m_material); + return (m_transform == a_shape->m_transform) && (m_material == a_shape->m_material) && (m_parent == a_shape->m_parent); } /* ------------------------------------------------------------------------- */ @@ -134,6 +138,20 @@ void Shape::set_material(const Material &a_material) /* ------------------------------------------------------------------------- */ +Shape *Shape::parent(void) +{ + return m_parent; +} + +/* ------------------------------------------------------------------------- */ + +void Shape::set_parent(Shape *a_shape) +{ + m_parent = a_shape; +} + +/* ------------------------------------------------------------------------- */ + Tuple Shape::normal_at(const Tuple &a_world_point) const { Tuple the_local_point = m_transform.inverse() * a_world_point; diff --git a/raytracing/src/shapes/shape.h b/raytracing/src/shapes/shape.h index 91effd6..9ce0c98 100644 --- a/raytracing/src/shapes/shape.h +++ b/raytracing/src/shapes/shape.h @@ -61,6 +61,9 @@ namespace Raytracer const Material &material(void) const; void set_material(const Material &a_material); + Shape *parent(void); + void set_parent(Shape *a_shape); + Tuple normal_at(const Tuple &a_point) const; virtual Tuple local_normal_at(const Tuple &a_local_point) const; @@ -70,6 +73,7 @@ namespace Raytracer private: Matrix m_transform; Material m_material; + Shape *m_parent; }; }; // namespace Raytracer diff --git a/tests/00_common_data.cpp b/tests/00_common_data.cpp new file mode 100644 index 0000000..91b808a --- /dev/null +++ b/tests/00_common_data.cpp @@ -0,0 +1,54 @@ +/*! + * 00_common_data.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: 22/03/2024 + * + */ + +/*---------------------------------------------------------------------------*/ + +#include + +#include "common_data.h" + +using namespace Raytracer; + +/* ------------------------------------------------------------------------- */ + +Intersections TestShape::local_intersect(const Ray &a_ray) +{ + saved_ray = a_ray; + return Intersections(); +} + +/* ------------------------------------------------------------------------- */ + +Tuple TestShape::local_normal_at(const Tuple &a_local_point) const +{ + return Tuple::Vector(a_local_point.x(), a_local_point.y(), a_local_point.z()); +} + +/* ------------------------------------------------------------------------- */ + +const Color TestPattern::pattern_at(const Tuple &a_point) const +{ + return Color(a_point.x(), a_point.y(), a_point.z()); +} diff --git a/tests/09_planes.cpp b/tests/09_planes.cpp index 4aecfb1..6daed8f 100644 --- a/tests/09_planes.cpp +++ b/tests/09_planes.cpp @@ -31,38 +31,12 @@ #include "raytracing.h" +#include "common_data.h" + using namespace Raytracer; /* ------------------------------------------------------------------------- */ -class TestShape : public Shape -{ -public: - TestShape(void) = default; - - Intersections local_intersect(const Ray &a_ray) override - { - saved_ray = a_ray; - return Intersections(); - } - - Tuple local_normal_at(const Tuple &a_local_point) const override - { - return Tuple::Vector(a_local_point.x(), a_local_point.y(), a_local_point.z()); - } - - Ray saved_ray; -}; - -/* ------------------------------------------------------------------------- */ - -TestShape test_shape(void) -{ - return TestShape(); -} - -/* ------------------------------------------------------------------------- */ - SCENARIO("The default transformation", "[features/shapes.feature]") { GIVEN("s <- test_shape()") diff --git a/tests/10_patterns.cpp b/tests/10_patterns.cpp index c41545e..c4e3ce5 100644 --- a/tests/10_patterns.cpp +++ b/tests/10_patterns.cpp @@ -29,23 +29,12 @@ #include "raytracing.h" +#include "common_data.h" + using namespace Raytracer; /* ------------------------------------------------------------------------- */ -class TestPattern : public Pattern -{ -public: - TestPattern(void) = default; - - const Color pattern_at(const Tuple &a_point) const override - { - return Color(a_point.x(), a_point.y(), a_point.z()); - } -}; - -/* ------------------------------------------------------------------------- */ - SCENARIO("Creating a stripe pattern", "[features/patterns.feature]") { GIVEN("pattern <- stripe_pattern(white, black)") diff --git a/tests/11_reflection_refraction.cpp b/tests/11_reflection_refraction.cpp index 8a01127..8cdad99 100644 --- a/tests/11_reflection_refraction.cpp +++ b/tests/11_reflection_refraction.cpp @@ -31,23 +31,12 @@ #include "raytracing.h" +#include "common_data.h" + using namespace Raytracer; /* ------------------------------------------------------------------------- */ -class TestPattern : public Pattern -{ -public: - TestPattern(void) = default; - - const Color pattern_at(const Tuple &a_point) const override - { - return Color(a_point.x(), a_point.y(), a_point.z()); - } -}; - -/* ------------------------------------------------------------------------- */ - SCENARIO("Reflectivity for the default material", "[features/materials.feature]") { GIVEN("m <- material()") diff --git a/tests/12_cubes.cpp b/tests/12_cubes.cpp index f0b61bc..3ff4daa 100644 --- a/tests/12_cubes.cpp +++ b/tests/12_cubes.cpp @@ -29,30 +29,12 @@ #include "raytracing.h" +#include "common_data.h" + using namespace Raytracer; /* ------------------------------------------------------------------------- */ -class CubeTestIntersect -{ -public: - Tuple origin; - Tuple direction; - double t1; - double t2; -}; - -/* ------------------------------------------------------------------------- */ - -class CubeTestNormal -{ -public: - Tuple point; - Tuple normal; -}; - -/* ------------------------------------------------------------------------- */ - SCENARIO("A Ray intersects a cube", "[features/cubes.feature]") { // | | origin | direction | t1 | t2 | @@ -63,7 +45,7 @@ SCENARIO("A Ray intersects a cube", "[features/cubes.feature]") // | +z | point(0.5, 0, 5) | vector( 0, 0,-1) | 4 | 6 | // | -z | point(0.5, 0, -5) | vector( 0, 0, 1) | 4 | 6 | // | inside | point(0, 0.5, 0) | vector( 0, 0, 1) | -1 | -1 | - CubeTestIntersect the_test[] = { + DataOrigDirT1T2 the_test[] = { { Tuple::Point(5.0, 0.5, 0.0), Tuple::Vector(-1, 0, 0), 4, 6}, {Tuple::Point(-5.0, 0.5, 0.0), Tuple::Vector(1, 0, 0), 4, 6}, { Tuple::Point(0.5, 5.0, 0.0), Tuple::Vector(0, -1, 0), 4, 6}, @@ -113,7 +95,7 @@ SCENARIO("A Ray misses a cube", "[features/cubes.feature]") // | point(2, 0, 2) | vector(0, 0, -1) | // | point(0, 2, 2) | vector(0, -1, 0) | // | point(2, 2, 0) | vector(-1, 0, 0) | - CubeTestIntersect the_test[] = { + DataOrigDirT1T2 the_test[] = { {Tuple::Point(-2, 0, 0), Tuple::Vector(0.2673, 0.5345, 0.8018), -1, -1}, { Tuple::Point(0, -2, 0), Tuple::Vector(0.8018, 0.2673, 0.5345), -1, -1}, { Tuple::Point(0, 0, -2), Tuple::Vector(0.5345, 0.8018, 0.2673), -1, -1}, @@ -155,7 +137,7 @@ SCENARIO("The normal on the surface of a cube", "[features/cubes.feature]") // | point(0.4, 0.4, -1) | vector(0, 0, -1) | // | point(1, 1, -1) | vector(1, 0, 0) | // | point(-1,-1, -1) | vector(-1, 0, 0) | - CubeTestNormal the_test[] = { + DataPointNormal the_test[] = { { Tuple::Point(1, 0.5, -0.8), Tuple::Vector(1, 0, 0)}, { Tuple::Point(-1, -0.2, 0.9), Tuple::Vector(-1, 0, 0)}, {Tuple::Point(-0.4, 1, -0.1), Tuple::Vector(0, 1, 0)}, diff --git a/tests/13_cylinders.cpp b/tests/13_cylinders.cpp index a82bfef..15182bc 100644 --- a/tests/13_cylinders.cpp +++ b/tests/13_cylinders.cpp @@ -29,57 +29,19 @@ #include "raytracing.h" +#include "common_data.h" + using namespace Raytracer; /* ------------------------------------------------------------------------- */ -class CylinderTestIntersect -{ -public: - Tuple origin; - Tuple direction; - double t0 = -1; - double t1 = -1; -}; - -/* ------------------------------------------------------------------------- */ - -class CylinderTestNormal -{ -public: - Tuple point; - Tuple normal; -}; - -/* ------------------------------------------------------------------------- */ - -class CylinderTestConstrained -{ -public: - Tuple point; - Tuple direction; - uint16_t count; -}; - -/* ------------------------------------------------------------------------- */ - -class ConeTestConstrained -{ -public: - Tuple origin; - Tuple direction; - uint16_t count; -}; - -/* ------------------------------------------------------------------------- */ - 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) | - CylinderTestIntersect the_test[] = { + 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)} @@ -114,7 +76,7 @@ SCENARIO("A Ray strikes a cylinder", "[features/cylinders.feature]") // | 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 | - CylinderTestIntersect the_test[] = { + 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} @@ -161,7 +123,7 @@ SCENARIO("Normal vector on a cylinder", "[features/cylinders.feature]") // | point(0, 5, -1) | vector(0, 0, -1) | // | point(0, -2, 1) | vector(0, 0, 1) | // | point(-1, 1, 0) | vector(-1, 0, 0) | - CylinderTestNormal the_test[] = { + 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)}, @@ -215,7 +177,7 @@ SCENARIO("Intersecting a constrained cylinder", "[features/cylinders.feature]") // | 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 | - CylinderTestConstrained the_test[] = { + 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}, @@ -280,7 +242,7 @@ SCENARIO("Intersecting the caps of a closed cylinder", "[features/cylinders.feat // | 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 - CylinderTestConstrained the_test[] = { + 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}, @@ -335,7 +297,7 @@ SCENARIO("The normal vector on the cylinder's end caps", "[features/cylinders.fe // | 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) | - CylinderTestNormal the_test[] = { + 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)}, @@ -381,7 +343,7 @@ SCENARIO("Intersecting a cone with a ray", "[features/cones.feature]") // | 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 | - CylinderTestIntersect the_test[] = { + 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} @@ -458,7 +420,7 @@ SCENARIO("Intersecting a cone's end caps", "[features/cones.feature]") // | point(0, 0, -0.25) | vector(0, 1, 1) | 2 | // | point(0, 0, -0.25) | vector(0, 1, 0) | 4 | - ConeTestConstrained the_test[] = { + 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} @@ -508,7 +470,7 @@ SCENARIO("Computing the normal vector on a cone", "[features/cones.feature]") // | 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) | - CylinderTestNormal the_test[] = { + 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)} diff --git a/tests/14_groups.cpp b/tests/14_groups.cpp new file mode 100644 index 0000000..6650b03 --- /dev/null +++ b/tests/14_groups.cpp @@ -0,0 +1,66 @@ +/*! + * 14_groups.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: 21/03/2024 + * + */ + +/*---------------------------------------------------------------------------*/ + +#include + +#include "raytracing.h" + +#include "common_data.h" + +using namespace Raytracer; + +/* ------------------------------------------------------------------------- */ + +SCENARIO("Creating a new group", "[features/groups.feature]") +{ + GIVEN("g <- group()") + { + Group g; + THEN("g.transform = identity_matrix") + { + REQUIRE(g.transform() == Matrix::identity()); + } + AND_THEN("g is empty") + { + REQUIRE(g.is_empty() == true); + } + } +} + +/* ------------------------------------------------------------------------- */ + +SCENARIO("A shape has a parent attribute", "[features/shapes.feature]") +{ + GIVEN("s <- test_shape()") + { + TestShape s; + THEN("s.parent is nothing") + { + REQUIRE(s.parent() == nullptr); + } + } +} diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index b205bfc..839f8a5 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -12,6 +12,7 @@ set(CMAKE_CXX_STANDARD_REQUIRED ON) add_executable(raytracing_test main_test.cpp + 00_common_data.cpp 01_tuples.cpp 02_1_colors.cpp 02_2_canvas.cpp @@ -26,6 +27,7 @@ add_executable(raytracing_test 11_reflection_refraction.cpp 12_cubes.cpp 13_cylinders.cpp + 14_groups.cpp ) include_directories("${CMAKE_SOURCE_DIR}/tests") diff --git a/tests/common_data.h b/tests/common_data.h new file mode 100644 index 0000000..f4070cb --- /dev/null +++ b/tests/common_data.h @@ -0,0 +1,114 @@ +/*! + * sphere.h + * + * Copyright (c) 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: 22/03/2024 + * + */ + +#ifndef _RAYTRACER_COMMON_DATA_H +#define _RAYTRACER_COMMON_DATA_H + +/* ------------------------------------------------------------------------- */ + +#include +#include +#include + +/* ------------------------------------------------------------------------- */ + +namespace Raytracer +{ + class TestShape : public Shape + { + public: + TestShape(void) = default; + + Intersections local_intersect(const Ray &a_ray) override; + + Tuple local_normal_at(const Tuple &a_local_point) const override; + + Ray saved_ray; + }; + + /* ------------------------------------------------------------------------- */ + + class TestPattern : public Pattern + { + public: + TestPattern(void) = default; + + const Color pattern_at(const Tuple &a_point) const override; + }; + + /* ------------------------------------------------------------------------- */ + + class DataOrigDirT1T2 + { + public: + Tuple origin; + Tuple direction; + double t1; + double t2; + }; + + /* ------------------------------------------------------------------------- */ + + class DataOrigDirT0T1 + { + public: + Tuple origin; + Tuple direction; + double t0 = -1; + double t1 = -1; + }; + + /* ------------------------------------------------------------------------- */ + + class DataPointNormal + { + public: + Tuple point; + Tuple normal; + }; + + /* ------------------------------------------------------------------------- */ + + class DataPointDirCount + { + public: + Tuple point; + Tuple direction; + uint16_t count; + }; + + /* ------------------------------------------------------------------------- */ + + class DataOrigDirCount + { + public: + Tuple origin; + Tuple direction; + uint16_t count; + }; + +} // namespace Raytracer + +#endif // _RAYTRACER_COMMON_DATA_H