RayTracer.h

#pragma once

#include <cmath>
#include <limits>
#include <vector>

#include <embree3/rtcore.h>
#include <Euclid/Render/RenderCore.h>

namespace Euclid
{
class RayCamera : public Camera
{
public:
    struct Film
    {
        float width = 0.0f;
        float height = 0.0f;
    };

public:
    RayCamera() = default;

    RayCamera(const Vec3& position,
              const Vec3& focus,
              const Vec3& up,
              float tnear,
              float tfar);

    virtual ~RayCamera() = default;

    virtual RTCRayHit gen_ray(float s, float t) const = 0;

public:
    Film film;
};

class PerspRayCamera : public RayCamera
{
public:
    PerspRayCamera() = default;

    PerspRayCamera(const Vec3& position,
                   const Vec3& focus,
                   const Vec3& up,
                   float vfov,
                   float aspect,
                   float tnear,
                   float tfar);

    PerspRayCamera(const Vec3& position,
                   const Vec3& focus,
                   const Vec3& up,
                   float vfov,
                   unsigned width,
                   unsigned height,
                   float tnear,
                   float tfar);

    ~PerspRayCamera();

    void set_aspect(float aspect);

    void set_aspect(unsigned width, unsigned height);

    void set_fov(float vfov);

    RTCRayHit gen_ray(float s, float t) const override;
};

class OrthoRayCamera : public RayCamera
{
public:
    OrthoRayCamera() = default;

    OrthoRayCamera(const Vec3& position,
                   const Vec3& focus,
                   const Vec3& up,
                   float xextent,
                   float yextent,
                   float tnear,
                   float tfar);

    ~OrthoRayCamera();

    void set_extent(float xextent, float yextent);

    RTCRayHit gen_ray(float s, float t) const override;
};

class RayTracer
{
public:
    explicit RayTracer(int threads = 0);

    ~RayTracer();

    void attach_geometry_buffers(const std::vector<float>& positions,
                                 const std::vector<unsigned>& indices);

    void attach_color_buffer(const std::vector<float>* colors,
                             bool vertex_color = false);

    void attach_face_mask_buffer(const std::vector<uint8_t>* mask);

    void release_buffers();

    void set_material(const Material& material);

    void set_background(const Eigen::Ref<const Eigen::Array3f>& color);

    void set_background(float r, float g, float b);

    void enable_light(bool on);

    void render_shaded(std::vector<uint8_t>& pixels,
                       const RayCamera& camera,
                       int width,
                       int height,
                       bool interleaved = true);

    void render_shaded(std::vector<uint8_t>& pixels,
                       const RayCamera& camera,
                       int width,
                       int height,
                       int samples,
                       bool interleaved = true);

    void render_depth(std::vector<uint8_t>& pixels,
                      const RayCamera& camera,
                      int width,
                      int height);

    void render_depth(std::vector<float>& values,
                      const RayCamera& camera,
                      int width,
                      int height);

    void render_silhouette(std::vector<uint8_t>& pixels,
                           const RayCamera& camera,
                           int width,
                           int height);

    void render_index(std::vector<uint8_t>& pixels,
                      const RayCamera& camera,
                      int width,
                      int height,
                      bool interleaved = true);

    void render_index(std::vector<uint32_t>& indices,
                      const RayCamera& camera,
                      int width,
                      int height);

private:
    std::function<Eigen::Array3f(const RTCHit&)> _select_diffuse_color();

    Eigen::Array3f _diffuse_material(const RTCHit& hit);

    Eigen::Array3f _diffuse_face_color(const RTCHit& hit);

    Eigen::Array3f _diffuse_vertex_color(const RTCHit& hit);

private:
    Material _material;
    Eigen::Array3f _background = Eigen::Array3f::Zero();
    RTCDevice _device;
    RTCScene _scene;
    RTCGeometry _geometry;
    const std::vector<float>* _colors = nullptr;
    const std::vector<uint8_t>* _face_mask = nullptr;
    int _geom_id = -1;
    bool _vertex_color = false;
    bool _lighting = true;
};

} // namespace Euclid

#include "src/RayTracer.cpp"