Main Class Reference

#include <Main.hpp>

Public Member Functions
void	printHelp ()
void	parseArguments (int argc, char **argv, std::string &file, bool &isDebug)
void	debug_config (const Config::Scene &cfg)
void	calculPPM (const Config::Scene &cfg, Display &display)

Detailed Description

Definition at line 13 of file Main.hpp.

Member Function Documentation

calculPPM()

void Main::calculPPM	(	const Config::Scene &	cfg,
		Display &	display )

Definition at line 85 of file main.cpp.

{
    RayTracer::Scene scene;
 
    float aspect = static_cast<float>(cfg.camera.width) / cfg.camera.height;
    float scale  = std::tan((cfg.camera.fieldOfView * 0.5f) * M_PI / 180.0f);
    Math::Vector3D bs{2.0f * scale * aspect, 0.0f, 0.0f};
    Math::Vector3D ls{0.0f, 2.0f * scale, 0.0f};
    Math::Point3D origin{
        cfg.camera.position.x - bs.x * 0.5f,
        cfg.camera.position.y - ls.y * 0.5f,
        cfg.camera.position.z - 1.0f
    };
 
    scene.setCamera(
        RayTracer::Camera(
            cfg.camera.position,
            RayTracer::Rectangle3D(origin, bs, ls)
        )
    );
 
    scene.setAmbientLight(
        std::make_unique<RayTracer::AmbientLight>(
            static_cast<float>(cfg.ambient)
        )
    );
 
    // Add lights
    for (const auto &d : cfg.directionals) {
        scene.addLight(
            std::make_unique<RayTracer::DirectionalLight>(
                d.direction,
                static_cast<float>(cfg.diffuse)
            )
        );
    }
 
    // Add point lights
    for (const auto &p : cfg.points) {
        scene.addLight(
            std::make_unique<RayTracer::PointLight>(
                p.position,
                static_cast<float>(cfg.diffuse)
            )
        );
    }
 
    for (const auto &s : cfg.spheres) {
        scene.addObject(
            std::make_shared<RayTracer::Sphere>(
                s.center,
                s.radius,
                std::make_shared<RayTracer::FlatColor>(s.color)
            )
        );
    }
 
    for (const auto &p : cfg.planes) {
        Math::Vector3D normal{0.0f, 0.0f, 0.0f};
        if (p.axis == 'X') normal.x = 1.0f;
        else if (p.axis == 'Y') normal.y = 1.0f;
        else normal.z = 1.0f;
 
        Math::Point3D pt{0.0f, 0.0f, 0.0f};
        if (p.axis == 'X') pt.x = p.position;
        else if (p.axis == 'Y') pt.y = p.position;
        else pt.z = p.position;
 
        scene.addObject(
            std::make_shared<RayTracer::Plane>(
                pt,
                normal,
                std::make_shared<RayTracer::FlatColor>(p.color)
            )
        );
    }
 
    int w = cfg.camera.width;
    int h = cfg.camera.height;
    // std::cout << "P3\n" << w << " " << h << "\n255\n";
 
    for (int y = 0; y < h; ++y) {
        for (int x = 0; x < w; ++x) {
            double u = (x + 0.5) / w;
            double v = (y + 0.5) / h;
            RayTracer::Ray ray = scene.getCamera().ray(u, v);
 
            Color finalColor(0, 0, 0);
            double closest_t = std::numeric_limits<double>::max();
            std::shared_ptr<RayTracer::IPrimitive> closestObject = nullptr;
            Math::Point3D hitPoint;
            Math::Vector3D normal;
 
            for (const auto &obj : scene.getObjects()) {
                double t;
                Math::Point3D pt;
                Math::Vector3D n;
                if (obj->intersect(ray, t, pt, n) && t < closest_t) {
                    closest_t = t;
                    closestObject = obj;
                    hitPoint = pt;
                    normal = n;
                }
            }
 
            if (closestObject) {
                // Start with ambient
                if (scene.getAmbient()) {
                    finalColor = scene.getAmbient()->illuminate(ray, *closestObject, hitPoint);
                }
                // Lighting
                for (const auto &light : scene.getLights()) {
                    if (auto *dirLight = dynamic_cast<RayTracer::DirectionalLight *>(light.get())) {
                        Math::Vector3D lightDir = dirLight->getDirection() * -1.0;
                        lightDir = lightDir / lightDir.length();
 
                        // Shadow ray
                        const double bias = 1e-4;
                        Math::Point3D shadowOrigin = hitPoint + normal * bias;
                        RayTracer::Ray shadowRay(shadowOrigin, lightDir);
                        bool shadowed = false;
 
                        for (const auto &obj : scene.getObjects()) {
                            if (obj != closestObject) {
                                double tTmp;
                                Math::Point3D tmpPt;
                                Math::Vector3D tmpN;
                                if (obj->intersect(shadowRay, tTmp, tmpPt, tmpN)) {
                                    shadowed = true;
                                    break;
                                }
                            }
                        }
                        if (!shadowed) {
                            double diff = std::max(0.0, normal.dot(lightDir));
                            Color lightColor = light->illuminate(ray, *closestObject, hitPoint);
                            finalColor.r = std::min(finalColor.r + static_cast<int>(lightColor.r * diff), 255);
                            finalColor.g = std::min(finalColor.g + static_cast<int>(lightColor.g * diff), 255);
                            finalColor.b = std::min(finalColor.b + static_cast<int>(lightColor.b * diff), 255);
                        }
 
                    } else if (auto *pLight = dynamic_cast<RayTracer::PointLight *>(light.get())) {
                        Math::Vector3D lightDir = pLight->getPosition() - hitPoint;
                        double dist = lightDir.length();
                        lightDir = lightDir / dist;
 
                        const double bias = 1e-4;
                        Math::Point3D shadowOrig = hitPoint + normal * bias;
                        RayTracer::Ray shadowRay(shadowOrig, lightDir);
                        bool inShadow = false;
                        for (const auto &obj : scene.getObjects()) {
                            if (obj != closestObject) {
                                double tTmp;
                                Math::Point3D tmpPt;
                                Math::Vector3D tmpN;
                                if (obj->intersect(shadowRay, tTmp, tmpPt, tmpN) && tTmp < dist) {
                                    inShadow = true;
                                    break;
                                }
                            }
                        }
                        if (!inShadow) {
                            double diff = std::max(0.0, normal.dot(lightDir));
                            Color c = light->illuminate(ray, *closestObject, hitPoint);
                            finalColor.r = std::min(finalColor.r + static_cast<int>(c.r * diff), 255);
                            finalColor.g = std::min(finalColor.g + static_cast<int>(c.g * diff), 255);
                            finalColor.b = std::min(finalColor.b + static_cast<int>(c.b * diff), 255);
                        }
                    }
                }
            }
 
            display.pushPixel(x, y, Display::Pixel(finalColor.r, finalColor.g, finalColor.b));
            // std::cout << pixel.toPPM() << "\n";
        }
    }
    display.notifyDone();
}

References RayTracer::Scene::addLight(), RayTracer::Scene::addObject(), Config::Scene::ambient, Color::b, Config::Scene::camera, Config::Scene::diffuse, Config::Scene::directionals, Math::Vector3D::dot(), Config::Camera::fieldOfView, Color::g, RayTracer::Scene::getAmbient(), RayTracer::Scene::getCamera(), RayTracer::Scene::getLights(), RayTracer::Scene::getObjects(), Config::Camera::height, Math::Vector3D::length(), Display::notifyDone(), Config::Scene::planes, Config::Scene::points, Config::Camera::position, Display::pushPixel(), Color::r, RayTracer::Camera::ray(), RayTracer::Scene::setAmbientLight(), RayTracer::Scene::setCamera(), Config::Scene::spheres, Config::Camera::width, Math::Point3D::x, Math::Vector3D::x, Math::Point3D::y, and Math::Point3D::z.

debug_config()

void Main::debug_config

(

const Config::Scene &

cfg

)

Definition at line 58 of file main.cpp.

{
    std::cout << "CAMERA:\n";
    std::cout << "resolution: " << cfg.camera.width << " × " << cfg.camera.height << std::endl;
    std::cout << "position = (" << cfg.camera.position.x << ", " << cfg.camera.position.y << ", " << cfg.camera.position.z << ")\n";
    std::cout << "rotation = (" << cfg.camera.rotation.x << ", " << cfg.camera.rotation.y << ", " << cfg.camera.rotation.z << ")\n";
    std::cout << "fieldOfView = " << cfg.camera.fieldOfView << std::endl << std::endl;
 
    std::cout << "SPHERES:\n";
    for (const auto &s : cfg.spheres) {
        std::cout << "centre = (" << s.center.x << ", " << s.center.y << ", " << s.center.z << ")"
                  << "  rayon = " << s.radius
                  << "  couleur = (" << s.color.r << ", " << s.color.g << ", " << s.color.b << ")\n";
    }
 
    std::cout << "PLANES:\n";
    for (const auto &p : cfg.planes) {
        std::cout << "axe = '" << p.axis << "'"
                  << "  position = " << p.position
                  << "  couleur = (" << p.color.r << ", " << p.color.g << ", " << p.color.b << ")\n";
    }
 
    std::cout << "LIGHTS:\n";
    std::cout << "ambient = " << cfg.ambient
              << "  diffuse = " << cfg.diffuse << "\n";
}

References Config::Scene::ambient, Config::Scene::camera, Config::Scene::diffuse, Config::Camera::fieldOfView, Config::Camera::height, Config::Scene::planes, Config::Camera::position, Config::Camera::rotation, Config::Scene::spheres, Config::Camera::width, Math::Point3D::x, Math::Vector3D::x, Math::Point3D::y, Math::Vector3D::y, Math::Point3D::z, and Math::Vector3D::z.

parseArguments()

void Main::parseArguments	(	int	argc,
		char **	argv,
		std::string &	file,
		bool &	isDebug )

Definition at line 32 of file main.cpp.

{
    if (argc == 2 && std::string(argv[1]) == "unitest")
        std::exit(0);
 
    if (argc == 2 && std::string(argv[1]) == "-help") {
        printHelp();
        std::exit(0);
    }
 
    if (argc == 3 && std::string(argv[2]) == "-d") {
        file = argv[1];
        isDebug = true;
        return;
    }
 
    if (argc != 2) {
        throw RayTracerException("USAGE: ./raytracer <SCENE_FILE>");
    }
 
    file = argv[1];
    if (!is_valid_cfg(file)) {
        throw RayTracerException("Error: SCENE_FILE must have .cfg extension");
    }
}

References is_valid_cfg(), and printHelp().

printHelp()

void Main::printHelp

(

)

Definition at line 26 of file main.cpp.

{
    std::cout << "USAGE: ./raytracer <SCENE_FILE>\n";
    std::cout << "  SCENE_FILE: scene configuration\n";
}

---

The documentation for this class was generated from the following files:

• include/Main.hpp
• src/main.cpp