From b5ee92c5447b352cd98fe6da648824ceefdb720d Mon Sep 17 00:00:00 2001 From: Godzil Date: Fri, 6 Mar 2020 19:00:31 +0000 Subject: [PATCH] And CSG! \o/ Still working on a nice scene for it. --- source/camera.cpp | 4 +- source/include/csg.h | 52 +++++++++ source/include/group.h | 2 + source/include/objfile.h | 2 + source/include/renderstat.h | 7 +- source/include/shape.h | 10 +- source/renderstat.cpp | 8 ++ source/shapes/csg.cpp | 133 +++++++++++++++++++++ source/shapes/group.cpp | 29 +++++ source/shapes/objfile.cpp | 16 +++ tests/CMakeLists.txt | 6 +- tests/ch16_test.cpp | 105 +++++++++++++++++ tests/csg_test.cpp | 226 ++++++++++++++++++++++++++++++++++++ 13 files changed, 591 insertions(+), 9 deletions(-) create mode 100644 source/include/csg.h create mode 100644 source/shapes/csg.cpp create mode 100644 tests/ch16_test.cpp create mode 100644 tests/csg_test.cpp diff --git a/source/camera.cpp b/source/camera.cpp index 90bef2c..0f0170e 100644 --- a/source/camera.cpp +++ b/source/camera.cpp @@ -62,9 +62,9 @@ Canvas Camera::render(World world, uint32_t depth) uint32_t x, y; Canvas image = Canvas(this->horizontalSize, this->verticalSize); -#pragma omp parallel private(x, y) shared(image, stats) + #pragma omp parallel default(shared) private(x, y) shared(image, stats) { -#pragma omp for + #pragma omp for schedule(dynamic, 5) for (y = 0 ; y < this->verticalSize ; y++) { for (x = 0 ; x < this->horizontalSize ; x++) diff --git a/source/include/csg.h b/source/include/csg.h new file mode 100644 index 0000000..51f505f --- /dev/null +++ b/source/include/csg.h @@ -0,0 +1,52 @@ +/* + * DoRayMe - a quick and dirty Raytracer + * CSG header + * + * Created by Manoël Trapier + * Copyright (c) 2020 986-Studio. + * + */ +#ifndef DORAYME_CSG_H +#define DORAYME_CSG_H + +#include + +class CSG : public Shape +{ +public: + enum OperationType + { + UNION, + DIFFERENCE, + INTERSECTION + }; + +protected: + Shape *left; + Shape *right; + OperationType operation; + BoundingBox bounds; + +protected: + Intersect localIntersect(Ray r); + Tuple localNormalAt(Tuple point, Intersection *hit = nullptr); + BoundingBox getLocalBounds(); + + bool intersectionAllowed(bool leftHit, bool inLeft, bool inRight); + + Intersect filterIntersections(Intersect &xs); + + void updateBoundingBox(); + BoundingBox getBounds(); + +public: + CSG(OperationType operation, Shape *left, Shape *right); + + bool includes(Shape *b); + + void updateTransform(); + + void dumpMe(FILE *fp); +}; + +#endif /* DORAYME_CSG_H */ diff --git a/source/include/group.h b/source/include/group.h index a389cf0..1be9802 100644 --- a/source/include/group.h +++ b/source/include/group.h @@ -44,6 +44,8 @@ public: void updateBoundingBox(); void updateTransform(); + bool includes(Shape *b); + Group(); void dumpMe(FILE * fp); diff --git a/source/include/objfile.h b/source/include/objfile.h index 1920ae7..7cb3849 100644 --- a/source/include/objfile.h +++ b/source/include/objfile.h @@ -61,6 +61,8 @@ public: BoundingBox getLocalBounds(); BoundingBox getBounds(); + bool includes(Shape *b); + void updateBoundingBox(); void updateTransform(); diff --git a/source/include/renderstat.h b/source/include/renderstat.h index b485541..e9df33c 100644 --- a/source/include/renderstat.h +++ b/source/include/renderstat.h @@ -24,6 +24,7 @@ private: uint64_t triangleCount; /* Total number of triangle */ uint64_t smoothTriangleCount; /* Total number of smooth triangle */ uint64_t objfileCount; /* Total number of OBJ File */ + uint64_t csgCount; /* Total number of CSG */ uint64_t pixelCount; /* Total number of rendered pixels */ uint64_t rayCount; /* Total number of rays */ @@ -42,7 +43,7 @@ public: RenderStats() : coneCount(0), cylinderCount(0), cubeCount(0), groupCount(0), lightCount(0), planeCount(0), sphereCount(0), triangleCount(0), pixelCount(0), rayCount(0), lightRayEmitedCount(0), reflectionRayCount(0), refractedRayCount(0), intersectCount(0), intersectionCount(0), reallocCallCount(0), mallocCallCount(0), smoothTriangleCount(0), - discardedIntersectCount(0), maxDepthAttained(UINT64_MAX), maxIntersectOnARay(0), objfileCount(0) {}; + discardedIntersectCount(0), maxDepthAttained(UINT64_MAX), maxIntersectOnARay(0), objfileCount(0), csgCount(0) {}; #ifdef RENDER_STATS void addCone(); void addCylinder(); @@ -51,6 +52,7 @@ public: void addLight(); void addPlane(); void addSphere(); + void addCsg(); void addOBJFile(); void addTriangle(); void addSmoothTriangle(); @@ -90,7 +92,8 @@ public: static void addMalloc() {}; static void addRealloc() {}; static void setMaxIntersect(uint32_t count) {}; - static void void RenderStats::addOBJFile() {}; + static void addOBJFile() {}; + static void addCsg() {}; #endif }; diff --git a/source/include/shape.h b/source/include/shape.h index 072996d..42c68de 100644 --- a/source/include/shape.h +++ b/source/include/shape.h @@ -31,6 +31,7 @@ enum ShapeType SHAPE_TRIANGLE, SHAPE_OBJFILE, SHAPE_SMOOTHTRIANGLE, + SHAPE_CSG, }; /* Base class for all object that can be presented in the world */ @@ -58,7 +59,6 @@ public: Shape(ShapeType = SHAPE_NONE); virtual Intersect intersect(Ray r); - virtual Intersect intersectOOB(Ray r) { return this->intersect(r); }; Tuple normalAt(Tuple point, Intersection *hit = nullptr); /* Bounding box points are always world value */ @@ -68,6 +68,8 @@ public: virtual void updateTransform(); + virtual bool includes(Shape *b) { return this == b; }; + virtual void dumpMe(FILE *fp); Tuple worldToObject(Tuple point) { return this->inverseTransform * point; }; @@ -75,9 +77,9 @@ public: Tuple normalToWorld(Tuple normalVector); void setTransform(Matrix transform); - void setMaterial(Material material) { this->material = material; }; - Ray transform(Ray r) { return Ray(this->transformMatrix * r.origin, this->transformMatrix * r.direction); }; - Ray invTransform(Ray r) { return Ray(this->inverseTransform * r.origin, this->inverseTransform * r.direction); }; + void setMaterial(Material material) { this->material = material; this->materialSet = true; }; + Ray transform(Ray r) { return Ray(this->transformMatrix * r.origin, this->transformMatrix * r.direction); }; + Ray invTransform(Ray r) { return Ray(this->inverseTransform * r.origin, this->inverseTransform * r.direction); }; bool operator==(const Shape &b) const { return this->material == b.material && this->type == b.type && diff --git a/source/renderstat.cpp b/source/renderstat.cpp index 1c1113f..46d1f0d 100644 --- a/source/renderstat.cpp +++ b/source/renderstat.cpp @@ -133,6 +133,13 @@ void RenderStats::addDiscardedIntersect() this->discardedIntersectCount++; }; +void RenderStats::addCsg() +{ +#pragma omp atomic + this->csgCount++; +}; + + void RenderStats::setMaxDepth(uint32_t depth) { if (this->maxDepthAttained > depth) @@ -162,6 +169,7 @@ void RenderStats::printStats() printf("Triangles : %lld\n", this->triangleCount); printf("Smooth Triangles : %lld\n", this->smoothTriangleCount); printf("OBJ File : %lld\n", this->objfileCount); + printf("CSG : %lld\n", this->csgCount); printf("==================================================\n"); printf("Pixel rendered : %lld\n", this->pixelCount); printf("Ray casted : %lld\n", this->rayCount); diff --git a/source/shapes/csg.cpp b/source/shapes/csg.cpp new file mode 100644 index 0000000..ce11bc7 --- /dev/null +++ b/source/shapes/csg.cpp @@ -0,0 +1,133 @@ +/* + * DoRayMe - a quick and dirty Raytracer + * Constructive Solid Geometry (CSG) implementation + * + * Created by Manoël Trapier + * Copyright (c) 2020 986-Studio. + * + */ +#include +#include +#include +#include +#include + + +CSG::CSG(OperationType operation, Shape *left, Shape *right) : Shape(SHAPE_CSG), operation(operation), left(left), right(right) +{ + stats.addCsg(); + + this->left->parent = this; + this->right->parent = this; + + this->bounds | this->left->getBounds(); + this->bounds | this->right->getBounds(); +} + +Intersect CSG::localIntersect(Ray r) +{ + int i; + Intersect leftxs = this->left->intersect(r); + Intersect rightxs = this->right->intersect(r); + + for(i = 0; i < rightxs.count(); i++) + { + leftxs.add(rightxs[i]); + } + + Intersect ret = this->filterIntersections(leftxs); + + return ret; +} + +Tuple CSG::localNormalAt(Tuple point, Intersection *hit) +{ + return Vector(1, 0, 0); +} + +BoundingBox CSG::getLocalBounds() +{ + return this->bounds; +} + +BoundingBox CSG::getBounds() +{ + if (this->bounds.isEmpty()) { this->updateBoundingBox(); } + return this->bounds; +} + +void CSG::updateBoundingBox() +{ + this->bounds.reset(); + + this->bounds | this->left->getBounds(); + this->bounds | this->right->getBounds(); +} + +void CSG::updateTransform() +{ + Shape::updateTransform(); + + this->left->updateTransform(); + this->right->updateTransform(); + + /* Once the full stack being notified of the changes, let's update the + * bounding box + */ + this->updateBoundingBox(); +} + +bool CSG::includes(Shape *b) +{ + if (this->left->includes(b)) { return true; } + if (this->right->includes(b)) { return true; } + if (this == b) { return true; } + return false; +} + +bool CSG::intersectionAllowed(bool leftHit, bool inLeft, bool inRight) +{ + switch(this->operation) + { + case CSG::UNION: return (leftHit && !inRight) || (!leftHit && !inLeft); + case CSG::INTERSECTION: return (!leftHit && inLeft) || (leftHit && inRight); + case CSG::DIFFERENCE: return (leftHit && !inRight) || (!leftHit && inLeft); + } + return false; +} + +Intersect CSG::filterIntersections(Intersect &xs) +{ + bool inl = false; + bool inr = false; + + Intersect ret = Intersect(); + + int i; + + for(i = 0; i < xs.count(); i++) + { + bool lhit = this->left->includes(xs[i].object); + + if (this->intersectionAllowed(lhit, inl, inr)) + { + ret.add(xs[i]); + } + + if (lhit) + { + inl = !inl; + } + else + { + inr = !inr; + } + } + + return ret; +} + +void CSG::dumpMe(FILE *fp) +{ + +} diff --git a/source/shapes/group.cpp b/source/shapes/group.cpp index 7ce62ff..d040135 100644 --- a/source/shapes/group.cpp +++ b/source/shapes/group.cpp @@ -67,6 +67,35 @@ Intersect Group::intersect(Ray r) return ret; } +bool Group::includes(Shape *b) +{ + if (this->objectCount > 0) + { + int i; + for (i = 0 ; i < this->objectCount ; i++) + { + if (this->objectList[i] == b) + { + return true; + } + } + } + + /* We are force to do them all the time */ + if (this->unboxableObjectCount > 0) + { + int i; + for(i = 0; i < this->unboxableObjectCount; i++) + { + if (this->unboxableObjectList[i] == b) + { + return true; + } + } + } + return false; +} + Intersect Group::localIntersect(Ray r) { return Intersect(); diff --git a/source/shapes/objfile.cpp b/source/shapes/objfile.cpp index 50896c4..2db80ae 100644 --- a/source/shapes/objfile.cpp +++ b/source/shapes/objfile.cpp @@ -130,6 +130,22 @@ Intersect OBJFile::intersect(Ray r) return ret; } +bool OBJFile::includes(Shape *b) +{ + int i; + if (this->faceGroupCount > 0) + { + for (i = 0 ; i < this->faceGroupCount ; i++) + { + if (this->faceGroupList[i] == b) + { + return true; + } + } + } + return false; +} + Intersect OBJFile::localIntersect(Ray r) { return Intersect(); diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index a1cb74d..6290501 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -10,7 +10,7 @@ link_libraries(rayonnement) 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 cylinder_test.cpp cone_test.cpp group_test.cpp - boundingbox_test.cpp triangle_test.cpp sequence_test.cpp objfile_test.cpp smoothtriangle_test.cpp) + boundingbox_test.cpp triangle_test.cpp sequence_test.cpp objfile_test.cpp smoothtriangle_test.cpp csg_test.cpp) add_executable(testMyRays) target_include_directories(testMyRays PUBLIC ${gtest_SOURCE_DIR}/include ${gtest_SOURCE_DIR}) @@ -81,6 +81,9 @@ add_custom_command( ${CMAKE_CURRENT_BINARY_DIR}/ ) +add_executable(ch16_test) +target_sources(ch16_test PRIVATE ch16_test.cpp) + add_executable(arealight_test) target_sources(arealight_test PRIVATE arealight_test.cpp) @@ -148,6 +151,7 @@ add_test(NAME Chapter13_Test COMMAND $) add_test(NAME Chapter13_ConeBonus COMMAND $) add_test(NAME Chapter14_Test COMMAND $) add_test(NAME Chapter15_Teapots COMMAND $) +add_test(NAME Chapter16_Test COMMAND $) add_test(NAME AreaLight_Test COMMAND $) add_test(NAME UVMap_CheckeredSphere COMMAND $) add_test(NAME UVMap_CheckeredPlane COMMAND $) diff --git a/tests/ch16_test.cpp b/tests/ch16_test.cpp new file mode 100644 index 0000000..56e2589 --- /dev/null +++ b/tests/ch16_test.cpp @@ -0,0 +1,105 @@ +/* + * DoRayMe - a quick and dirty Raytracer + * Render test for CSG in chapter 16. + * + * Created by Manoël Trapier + * Copyright (c) 2020 986-Studio. + * + */ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +#include + +int main() +{ + World w = World(); + + /* Add lights */ + Light light1 = Light(POINT_LIGHT, Point(100, 100, -100), Colour(1, 1, 1)); + w.addLight(&light1); + + /* ----------------------------- */ + + /* White background */ + Plane p = Plane(); + p.setTransform(translation(0, 0, 100) * rotationX(1.5708)); + p.material.colour = Colour(1, 1, 1); + p.material.ambient = 1; + p.material.diffuse = 0; + p.material.specular = 0; + w.addObject(&p); + + + Cylinder c1 = Cylinder(); + c1.minCap = -2; + c1.maxCap = 2; + c1.isClosed = true; + c1.material.colour = Colour(1, 0, 0); + c1.setTransform(scaling(0.4, 1, 0.4)); + c1.materialSet = true; + + Cylinder c2 = Cylinder(); + c2.minCap = -2; + c2.maxCap = 2; + c2.isClosed = true; + c2.material.colour = Colour(0, 1, 0); + c2.setTransform(rotationX(M_PI/2) * scaling(0.4, 1, 0.4)); + c2.materialSet = true; + + CSG leaf1 = CSG(CSG::UNION, &c1, &c2); + + Cylinder c3 = Cylinder(); + c3.minCap = -2; + c3.maxCap = 2; + c3.isClosed = true; + c3.material.colour = Colour(0, 0, 1); + c3.setTransform(rotationZ(M_PI/2) * scaling(0.4, 1, 0.4)); + c3.materialSet = true; + + CSG leaf2 = CSG(CSG::UNION, &leaf1, &c3); + + Cube cb = Cube(); + //cb.materialSet = true; + //cb.material.reflective = 1; + + Sphere sp = Sphere(); + sp.setTransform(scaling(1.35, 1.35, 1.35)); + CSG leaf3 = CSG(CSG::INTERSECTION, &sp, &cb); + + CSG leaf4 = CSG(CSG::DIFFERENCE, &leaf3, &leaf2); + + w.addObject(&leaf4); + + /* ----------------------------- */ + + /* Set the camera */ + Camera camera = Camera(800, 400, M_PI / 2); + camera.setTransform(viewTransform(Point(-4, 4, -9), + Point(0, 1, 0), + Vector(0, 1, 0))); + + /* Now render it */ + Canvas image = camera.render(w, 5); + + image.SaveAsPNG("ch16_test.png"); + + return 0; +} \ No newline at end of file diff --git a/tests/csg_test.cpp b/tests/csg_test.cpp new file mode 100644 index 0000000..5301678 --- /dev/null +++ b/tests/csg_test.cpp @@ -0,0 +1,226 @@ +/* + * DoRayMe - a quick and dirty Raytracer + * CSG unit tests + * + * Created by Manoël Trapier + * Copyright (c) 2020 986-Studio. + * + */ +#include +#include +#include +#include +#include +#include +#include + +/* Proxy class to get access to protected functions / members */ +class CSGTest : public CSG +{ +public: + Intersect doLocalIntersect(Ray r) { + return this->localIntersect(r); + }; + Tuple doLocalNormalAt(Tuple point, Intersection *hit = nullptr) { + return this->localNormalAt(point, hit); + }; + BoundingBox doGetLocalBounds() { + return this->getLocalBounds(); + }; + bool doIntersectionAllowed(bool leftHit, bool inLeft, bool inRight) { + return this->intersectionAllowed(leftHit, inLeft, inRight); + }; + + Intersect doFilterIntersections(Intersect &xs) { + return this->filterIntersections(xs); + } + + CSGTest(OperationType operation, Shape *left, Shape *right) : CSG(operation, left, right) {}; + + + Shape *getLeft() { return this->left; }; + Shape *getRight() { return this->right; }; + OperationType getOperation() { return this->operation; }; + void setOperation(OperationType operation) { this->operation = operation; }; +}; + +TEST(CSGTest, Csg_is_created_with_an_operation_and_two_shape) +{ + Sphere s1 = Sphere(); + Cube s2 = Cube(); + + CSGTest c = CSGTest(CSG::UNION, &s1, &s2); + + ASSERT_EQ(c.getOperation(), CSG::UNION); + ASSERT_EQ(*c.getLeft(), s1); + ASSERT_EQ(*c.getRight(), s2); + + ASSERT_EQ(*s1.parent, c); + ASSERT_EQ(*s2.parent, c); +} + +TEST(CSGTest, Evaluating_the_rules_for_a_csg_operation) +{ + Sphere s1 = Sphere(); + Cube s2 = Cube(); + CSGTest c = CSGTest(CSG::UNION, &s1, &s2); + + CSG::OperationType testList2[] = { + CSG::UNION, CSG::UNION, + CSG::UNION, CSG::UNION, + CSG::UNION, CSG::UNION, + CSG::UNION, CSG::UNION, + + CSG::INTERSECTION, CSG::INTERSECTION, + CSG::INTERSECTION, CSG::INTERSECTION, + CSG::INTERSECTION, CSG::INTERSECTION, + CSG::INTERSECTION, CSG::INTERSECTION, + + CSG::DIFFERENCE, CSG::DIFFERENCE, + CSG::DIFFERENCE, CSG::DIFFERENCE, + CSG::DIFFERENCE, CSG::DIFFERENCE, + CSG::DIFFERENCE, CSG::DIFFERENCE, + }; + + bool testList[][3] = { + /* lhit, inl, inr */ +/* UNION */ { true, true, true }, + { true, true, false }, + { true, false, true }, + { true, false, false }, + { false, true, true }, + { false, true, false }, + { false, false, true }, + { false, false, false }, + +/* INTER */ { true, true, true }, + { true, true, false }, + { true, false, true }, + { true, false, false }, + { false, true, true }, + { false, true, false }, + { false, false, true }, + { false, false, false }, + +/* DIFFE */ { true, true, true }, + { true, true, false }, + { true, false, true }, + { true, false, false }, + { false, true, true }, + { false, true, false }, + { false, false, true }, + { false, false, false }, + }; + + bool testResults[] { + /* Unions */ + false, + true, + false, + true, + false, + false, + true, + true, + /* Intersection */ + true, + false, + true, + false, + true, + true, + false, + false, + /* difference */ + false, + true, + false, + true, + true, + true, + false, + false + }; + + int testCount = sizeof(testList)/sizeof((testList)[0]); + int i; + + for(i = 0; i < testCount; i++) + { + c.setOperation(testList2[i]); + ASSERT_EQ(c.doIntersectionAllowed(testList[i][0], testList[i][1], testList[i][2]), testResults[i]); + } +} + +TEST(CSGTest, Filtering_a_list_of_intersections) +{ + Sphere s1 = Sphere(); + Cube s2 = Cube(); + CSGTest c = CSGTest(CSG::UNION, &s1, &s2); + + CSG::OperationType testList[] = { + CSG::UNION, + CSG::INTERSECTION, + CSG::DIFFERENCE, + }; + + uint32_t testResults[][2] = { + {0, 3}, + {1, 2}, + {0, 1}, + }; + + int testCount = sizeof(testList)/sizeof((testList)[0]); + int i; + + Intersect xs = Intersect(); + Intersection i1 = Intersection(1, &s1); + Intersection i2 = Intersection(2, &s2); + Intersection i3 = Intersection(3, &s1); + Intersection i4 = Intersection(4, &s2); + xs.add(i1); + xs.add(i2); + xs.add(i3); + xs.add(i4); + + for(i = 0; i < testCount; i++) + { + c.setOperation(testList[i]); + Intersect result = c.doFilterIntersections(xs); + + ASSERT_EQ(result.count(), 2); + ASSERT_EQ(result[0], xs[testResults[i][0]]); + ASSERT_EQ(result[1], xs[testResults[i][1]]); + } +} + +TEST(CSGTest, A_ray_misses_a_csg_object) +{ + Sphere s1 = Sphere(); + Cube s2 = Cube(); + CSGTest c = CSGTest(CSG::UNION, &s1, &s2); + + Ray r = Ray(Point(0, 2, -5), Vector(0, 0, 1)); + Intersect xs = c.doLocalIntersect(r); + + ASSERT_EQ(xs.count(), 0); +} + +TEST(CSGTest, A_ray_hits_a_csg_object) +{ + Sphere s1 = Sphere(); + Sphere s2 = Sphere(); + + s2.setTransform(translation(0, 0, 0.5)); + + CSGTest c = CSGTest(CSG::UNION, &s1, &s2); + + Ray r = Ray(Point(0, 0, -5), Vector(0, 0, 1)); + Intersect xs = c.doLocalIntersect(r); + + ASSERT_EQ(xs.count(), 2); + ASSERT_TRUE(double_equal(xs[0].t, 4)); + ASSERT_EQ(xs[0].object, &s1); + ASSERT_TRUE(double_equal(xs[1].t, 6.5)); + ASSERT_EQ(xs[1].object, &s2); +} \ No newline at end of file