Solution for tri, ellipse, annulus primitives

Adding this for reference. To be removed in the following commit, since
we won't be using these.

Author: hollasch

src/TheNextWeek/main.cc

@@ -325,16 +325,38 @@ void quad_test(scene& scene_desc) {
     scene_desc.max_depth         = 4;
 
     scene_desc.cam.aperture = 0.0;
-    scene_desc.cam.vfov     = 30.0;
+    scene_desc.cam.vfov     = 20.0;
     scene_desc.cam.lookfrom = point3(0,0,12);
     scene_desc.cam.lookat   = point3(0,0,0);
 
-    scene_desc.background   = color(0.80, 0.80, 0.80);
+    scene_desc.background   = color(0.90, 0.90, 0.90);
 
     auto earth_texture = make_shared<image_texture>("earthmap.jpg");
     auto mat = make_shared<lambertian>(earth_texture);
 
-    scene_desc.world.add(make_shared<quad>(point3(-2,-1,0), vec3(4,0,0), vec3(0,2,0), mat));
+    shared_ptr<hittable> thing;
+    switch (0) {
+        default:
+        case 0:
+            thing = make_shared<quad>(point3(-2,-1,0), vec3(4,0,0), vec3(0,2,0), mat);
+            break;
+        case 1:
+            scene_desc.cam.vfov = 30.0;
+            scene_desc.cam.lookat = point3(1,0,0);
+            thing = make_shared<quad>(point3(-2,-1,0), vec3(4,0,0), vec3(2,2,0), mat);
+            break;
+        case 2:
+            thing = make_shared<tri>(point3(-2,-1,0), vec3(4,0,0), vec3(0,2,0), mat);
+            break;
+        case 3:
+            thing = make_shared<ellipse>(point3(0,0,0), vec3(2,0,0), vec3(0,1,0), mat);
+            break;
+        case 4:
+            thing = make_shared<annulus>(point3(0,0,0), vec3(2,0,0), vec3(0,1,0), 0.60, mat);
+            break;
+    }
+
+    scene_desc.world.add(thing);
 }
 
 

src/TheNextWeek/quad.h

@@ -113,4 +113,70 @@ inline shared_ptr<hittable_list> box(const point3& a, const point3& b, shared_pt
 }
 
 
+class tri : public quad {
+  public:
+    tri(const point3& o, const vec3& aa, const vec3& ab, shared_ptr<material> m)
+      : quad(o, aa, ab, m)
+    {}
+
+    virtual bool hit_ab(double a, double b, hit_record& rec) const override {
+        if ((a < 0) || (b < 0) || (a + b > 1))
+            return false;
+
+        rec.u = a;
+        rec.v = b;
+        return true;
+    }
+};
+
+
+class ellipse : public quad {
+  public:
+    ellipse(
+        const point3& center, const vec3& side_A, const vec3& side_B, shared_ptr<material> m
+    ) : quad(center, side_A, side_B, m)
+    {}
+
+    virtual void set_bounding_box() override {
+        bbox = aabb(plane_origin - axis_A - axis_B, plane_origin + axis_A + axis_B).pad();
+    }
+
+    virtual bool hit_ab(double a, double b, hit_record& rec) const override {
+        if ((a*a + b*b) > 1)
+            return false;
+
+        rec.u = a/2 + 0.5;
+        rec.v = b/2 + 0.5;
+        return true;
+    }
+};
+
+
+class annulus : public quad {
+  public:
+    annulus(
+        const point3& center, const vec3& side_A, const vec3& side_B, double _inner,
+        shared_ptr<material> m)
+      : quad(center, side_A, side_B, m), inner(_inner)
+    {}
+
+    virtual void set_bounding_box() override {
+        bbox = aabb(plane_origin - axis_A - axis_B, plane_origin + axis_A + axis_B).pad();
+    }
+
+    virtual bool hit_ab(double a, double b, hit_record& rec) const override {
+        auto center_dist = sqrt(a*a + b*b);
+        if ((center_dist < inner) || (center_dist > 1))
+            return false;
+
+        rec.u = a/2 + 0.5;
+        rec.v = b/2 + 0.5;
+        return true;
+    }
+
+  private:
+    double inner;
+};
+
+
 #endif