Merge pull request #15 from EdwardPalmer99/EdwardPalmer99/feature/CSG

Implement Constructive Solid Geometry (CSG)

Author: EdwardPalmer99

examples/BUILD.bazel

@@ -15,4 +15,4 @@ cc_binary(
         "//lib:cphoton"
     ],
     visibility = ["//visibility:private"]
-)
+)

examples/CSG/BUILD.bazel

@@ -0,0 +1,8 @@
+cc_binary(
+    name = "hemisphere",
+    srcs = ["Hemisphere.cpp"],
+    deps = [
+        "//lib:cphoton"
+    ],
+    visibility = ["//visibility:private"]
+)

examples/CSG/Hemisphere.cpp

@@ -0,0 +1,51 @@
+/**
+ * @file Spheres.C
+ * @author Edward Palmer
+ * @date 2025-02-22
+ *
+ * @copyright Copyright (c) 2025
+ *
+ */
+
+extern "C"
+{
+#include "engine/RenderSettings.h"
+}
+
+#include "engine/PhotonEngine.hpp"
+#include "engine/Scene.hpp"
+#include "engine/primitives/CSGNode.hpp"
+#include "engine/primitives/Plane.hpp"
+#include "engine/primitives/Primitive.hpp"
+#include "engine/primitives/Sphere.hpp"
+
+int main(int argc, const char *argv[])
+{
+    gRenderSettings.pixelsWide = 500;
+    gRenderSettings.pixelsHigh = 500;
+
+    parseCLIOptions(argc, argv);
+
+    // Create the camera:
+    const double aspectRatio = ((double)gRenderSettings.pixelsWide / (double)gRenderSettings.pixelsHigh);
+    Camera camera(45.0, aspectRatio, 1, 0, point3(0, 4, 4), point3(0, 1, 0));
+
+    Primitive *sphere1 = new Sphere(point3(0, 1, 0), 1, makeMetal(makeSolidTexture(color3(0, 1, 0)), 0));
+    Primitive *sphere2 = new Sphere(point3(0, 1, 0.5), 1, makeMetal(makeSolidTexture(color3(0, 1, 0)), 0));
+
+    Primitive *plane = new Plane(point3(0, 0, 0), point3(0, 1, 0), makeLambertianWithColor(color3(0.1, 0.1, 0.1)));
+
+    Primitive *CSG = new CSGNode(sphere1, sphere2, CSGNode::CSGDifference);
+
+    Scene scene;
+    scene.addObject(CSG);
+    scene.addObject(plane);
+
+    PhotonEngine engine(gRenderSettings.pixelsWide, gRenderSettings.pixelsHigh);
+
+    PPMImage *outputImage = engine.render(&scene, &camera);
+    writeBinary16BitPPMImage(outputImage, gRenderSettings.outputPath);
+    freePPMImage(outputImage);
+
+    return 0;
+}

lib/engine/AABB.cpp

@@ -0,0 +1,109 @@
+/**
+ * @file AABB.cpp
+ * @author Edward Palmer
+ * @date 2025-03-03
+ *
+ * @copyright Copyright (c) 2025
+ *
+ */
+
+#include "AABB.hpp"
+
+#define swap(val1, val2)                                                                                               \
+    ({                                                                                                                 \
+        double temp = (val1);                                                                                          \
+        (val1) = (val2);                                                                                               \
+        (val2) = temp;                                                                                                 \
+    })
+    
+
+AABB::AABB()
+{
+    reset();
+}
+
+
+AABB::AABB(Point3 min_, Point3 max_) : min(min_), max(max_)
+{
+}
+
+
+void AABB::reset()
+{
+    min = point3(INFINITY, INFINITY, INFINITY);
+    max = point3(-INFINITY, -INFINITY, -INFINITY);
+}
+
+
+void AABB::addPoint(Point3 pt)
+{
+    if (pt.x < min.x) min.x = pt.x;
+    if (pt.x > max.x) max.x = pt.x;
+
+    if (pt.y < min.y) min.y = pt.y;
+    if (pt.y > max.y) max.y = pt.y;
+
+    if (pt.z < min.z) min.z = pt.z;
+    if (pt.z > max.z) max.z = pt.z;
+}
+
+
+AABB AABB::addBoundingBoxes(const AABB &box0, const AABB &box1)
+{
+    Point3 newMin =
+        point3(std::min(box0.min.x, box1.min.x), std::min(box0.min.y, box1.min.y), std::min(box0.min.z, box1.min.z));
+    Point3 newMax =
+        point3(std::max(box0.max.x, box1.max.x), std::max(box0.max.y, box1.max.y), std::max(box0.max.z, box1.max.z));
+
+    return AABB(newMin, newMax);
+}
+
+
+AABB AABB::operator+(const AABB &other)
+{
+    return addBoundingBoxes(*this, other);
+}
+
+
+bool AABB::hit(Ray *ray, double tmin, double tmax)
+{
+    Point3 origin = ray->origin;
+
+    // Now test against x-direction.
+    double invD = 1.0 / ray->direction.x;
+    double t0 = (min.x - origin.x) * invD;
+    double t1 = (max.x - origin.x) * invD;
+
+    if (invD < 0.0) swap(t0, t1);
+
+    tmin = std::max(t0, tmin);
+    tmax = std::min(t1, tmax);
+
+    if (tmax <= tmin) return false;
+
+    // Now test against y-direction.
+    invD = 1.0 / ray->direction.y;
+    t0 = (min.y - origin.y) * invD;
+    t1 = (max.y - origin.y) * invD;
+
+    if (invD < 0.0) swap(t0, t1);
+
+    tmin = std::max(t0, tmin);
+    tmax = std::min(t1, tmax);
+
+    if (tmax <= tmin) return false;
+
+    // Now test against z-direction:
+    invD = 1.0 / ray->direction.z;
+    t0 = (min.z - origin.z) * invD;
+    t1 = (max.z - origin.z) * invD;
+
+    if (invD < 0.0) swap(t0, t1);
+
+    tmin = std::max(t0, tmin);
+    tmax = std::min(t1, tmax);
+
+    if (tmax <= tmin) return false;
+
+    return true;
+}

lib/engine/AABB.hpp

@@ -0,0 +1,64 @@
+/**
+ * @file AABB.hpp
+ * @author Edward Palmer
+ * @date 2025-03-03
+ *
+ * @copyright Copyright (c) 2025
+ *
+ */
+
+#pragma once
+
+extern "C"
+{
+#include "engine/Ray.h"
+#include "utility/Vector3.h"
+}
+
+/**
+ * Axis-aligned bounding box.
+ */
+class AABB
+{
+public:
+    AABB();
+    AABB(Point3 min, Point3 max);
+
+    /** Resets bounding box. */
+    void reset();
+
+    /** Adds new point to bounding box. Recalculates size. */
+    void addPoint(Point3 pt);
+
+    /* Add bounding boxes */
+    AABB operator+(const AABB &other);
+
+    constexpr Point3 &minPt()
+    {
+        return min;
+    }
+
+    constexpr Point3 &maxPt()
+    {
+        return max;
+    }
+
+    constexpr const Point3 &minPt() const
+    {
+        return min;
+    }
+
+    constexpr const Point3 &maxPt() const
+    {
+        return max;
+    }
+
+    /** Returns true if box is hit by ray in range [tmin, tmax]. */
+    bool hit(Ray *ray, double tmin, double tmax);
+
+protected:
+    /** Adds two bounding boxes and returns the result. */
+    static AABB addBoundingBoxes(const AABB &box0, const AABB &box1);
+
+    Point3 min, max;
+};

lib/engine/Material.c

@@ -198,7 +198,9 @@ static inline bool refractRay(Ray *incidentRay, HitRec *hit, Ray *scatteredRay,
     // If it's the front face, we're going into the object otherwise we're leaving
     // and exiting into the air.
     const double ir = hit->material->indexOfRefraction;
-    const double refractionRatio = hit->frontFace ? (1.0 / ir) : ir;
+    const double refractionRatio =
+        hit->frontFace ? (1.0 / ir) : ir; // TODO: - we can calculate based on incident ray and normal whether this was
+                                          // inside or outside object. Don't need this.
 
     // Total internal reflection:
     bool cannotRefract = (refractionRatio * sinTheta > 1.0);