基础光线追踪(5) - 法向量及多个球

#ifndef _BASIC_RAY_TRACING_COLLIDE_H_
#define _BASIC_RAY_TRACING_COLLIDE_H_
#include "../Chapter3/Ray.h"

struct CollideRecord {
    float t;
    Point3f p;
    Vector3f normal;
};

struct Collisible {
    virtual bool collide(const Ray &r, float tMin, float tMax, CollideRecord &rec) const = 0;
    virtual ~Collisible() {}
};
#endif

#ifndef _BASIC_RAY_TRACING_SPHERE_H_
#define _BASIC_RAY_TRACING_SPHERE_H_
#include "Collide.h"

struct Sphere : Collisible {
    Point3f center;
    float radius;

    Sphere() : center(), radius() {}
    Sphere(const Point3f &center, float radius) : center(center), radius(radius) {}

    bool collide(const Ray &r, float tMin, float tMax, CollideRecord &rec) const override {
        Vector3f p = r.getOrigin() - center;
        float b = 2.0f * dot(r.getDir(), p);
        float c = p.length2() - radius * radius;
        float delta = b * b - 4 * c;
        if (delta > 0) {
            float t = (-b - sqrtf(delta)) / 2.0f;
            if (tMin < t && t < tMax) {
                rec.t = t;
                rec.p = r.get(t);
                rec.normal = (rec.p - center).normalize();
                return true;
            }
            t = (-b + sqrtf(delta)) / 2.0f;
            if (tMin < t && t < tMax) {
                rec.t = t;
                rec.p = r.get(t);
                rec.normal = (rec.p - center).normalize();
                return true;
            }
        }
        return false;
    }
};
#endif

#ifndef _BASIC_RAY_TRACING_COLLISIBLE_LIST_H_
#define _BASIC_RAY_TRACING_COLLISIBLE_LIST_H_
#include "Collide.h"
#include <vector>

struct CollisibleList : Collisible {
    std::vector<Collisible *> d;

    void add(Collisible *x) { d.push_back(x); }

    bool collide(const Ray &r, float tMin, float tMax, CollideRecord &rec) const override {
        bool flag = false;
        float closest = tMax;
        CollideRecord tmpRec;

        for (const auto &i : d) {
            if (i->collide(r, tMin, closest, tmpRec)) {
                flag = true;
                closest = tmpRec.t;
                rec = tmpRec;
            }
        }

        return flag;
    }
};
#endif

#include "../3rdParty/svpng/svpng.inc"
#include "Sphere.h"
#include "CollisibleList.h"
#include <cstdio>
#include <limits>

const int WIDTH = 640;
const int HEIGHT = 480;

using byte = unsigned char;

void paint(byte *d, int x, int y, Color3f color, float alpha) {
    d += 4 * ((HEIGHT - y - 1) * WIDTH + x);
    d[0] = 255 * color.r;
    d[1] = 255 * color.g;
    d[2] = 255 * color.b;
    d[3] = 255 * alpha;
}

Color3f mix(const Color3f &a, const Color3f &b, float t) { return a * (1.0f - t) + b * t; }

Color3f paint(const Ray &r, const Collisible &obj) {
    CollideRecord rec;
    if (obj.collide(r, 0.0f, std::numeric_limits<float>::max(), rec))
        return 0.5f * (rec.normal + Vector3f(1.0f, 1.0f, 1.0f));

    Vector3f dir = r.getDir();
    float t = 0.5f * (dir.y + 1.0f);
    return mix({1.0f, 1.0f, 1.0f}, {0.5f, 0.7f, 1.0f}, t);
}

int main() {
    byte d[4 * WIDTH * HEIGHT];
    FILE *f = fopen("ch5.png", "wb");
    Point3f lowerLeftCorner(-2.0f, -1.5f, -1.0f);
    Vector3f horizonal(4.0f, 0.0f, 0.0f);
    Vector3f vertical(0.0f, 3.0f, 0.0f);
    Point3f origin(0.0f, 0.0f, 0.0f);

    CollisibleList list;
    Collisible *obj[2];
    obj[0] = new Sphere({0, 0, -1}, 0.5);
    obj[1] = new Sphere({0, -100.5, -1}, 100);

    list.add(obj[0]);
    list.add(obj[1]);

    for (int x = 0; x < WIDTH; x++) {
        for (int y = 0; y < HEIGHT; y++) {
            float u = (float)x / WIDTH;
            float v = (float)y / HEIGHT;
            Ray r(origin, lowerLeftCorner + u * horizonal + v * vertical);
            paint(d, x, y, paint(r, list), 1.0f);
        }
    }

    delete obj[0];
    delete obj[1];
    svpng(f, WIDTH, HEIGHT, d, 1);
    fclose(f);
}