RenderCore.h

#pragma once

#include <Eigen/Dense>

namespace Euclid
{
class Camera
{
public:
    using Vec3 = Eigen::Vector3f;

public:
    Camera() = default;

    Camera(const Vec3& position,
           const Vec3& focus,
           const Vec3& up,
           float tnear,
           float tfar)
    {
        pos = position;
        dir = (position - focus).normalized();
        u = up.cross(dir).normalized();
        v = dir.cross(u);
        this->tnear = tnear;
        this->tfar = tfar;
    }

    virtual ~Camera();

    void lookat(const Vec3& position, const Vec3& focus, const Vec3& up)
    {
        pos = position;
        dir = (position - focus).normalized();
        u = up.cross(dir).normalized();
        v = dir.cross(u);
    }

    void set_range(float tnear, float tfar)
    {
        this->tnear = tnear;
        this->tfar = tfar;
    }

public:
    Eigen::Vector3f pos{ 0.0f, 0.0f, 0.0f };

    Eigen::Vector3f u{ 1.0f, 0.0f, 0.0f };

    Eigen::Vector3f v{ 0.0f, 1.0f, 0.0f };

    Eigen::Vector3f dir{ 0.0f, 0.0f, 1.0f };

    float tnear = 0.0f;

    float tfar = std::numeric_limits<float>::max();
};

inline Camera::~Camera() {}

struct Transform
{
    alignas(32) Eigen::Matrix4f model_matrix;

    alignas(32) Eigen::Matrix4f mvp;

    alignas(32) Eigen::Matrix4f normal_matrix;

    Transform()
    {
        model_matrix.setIdentity();
        mvp.setIdentity();
        normal_matrix.setIdentity();
    }

    Transform(const Eigen::Matrix4f& model,
              const Eigen::Matrix4f& view,
              const Eigen::Matrix4f& projection)
    {
        model_matrix = model;
        mvp = projection * view * model;
        normal_matrix = model.inverse().transpose();
    }
};

struct Material
{
    alignas(16) Eigen::Array3f ambient;

    alignas(16) Eigen::Array3f diffuse;
};

struct Light
{
    alignas(16) Eigen::Array3f position;

    alignas(16) Eigen::Array3f color;

    alignas(4) float intensity;
};

} // namespace Euclid