models3.h

#ifndef RAYMARCHING_MODELS3_H
#define RAYMARCHING_MODELS3_H
#include <cfloat>
#include <cmath>
#include <memory>
#include <Eigen/Dense>
#include <Eigen/Geometry>
#include <utility>
#include "const.h"
#include "colors.h"
#include "algebra.h"
 
namespace RayMarching {
 
    class SDFObject {
    public:
        virtual ~SDFObject() = default;
 
        [[nodiscard]] virtual double getDist(Eigen::Vector3d const &p) const = 0;
 
        [[nodiscard]] virtual color_t getColor(Eigen::Vector3d const &p) const = 0;
 
        [[nodiscard]] Line getReflection(const Line& ray) const;
    };
 
    class SDFCombination : public SDFObject {
    public:
        enum class SDFOperation {
            UNION,              
            INTERSECTION,       
            DIFFERENCE          
        };
    private:
        const std::unique_ptr<SDFObject> _left;
        const std::unique_ptr<SDFObject> _right;
        const SDFOperation _op;
    protected:
        [[nodiscard]] std::pair<double, double> getSoloDist(const Eigen::Vector3d &p) const;
    public:
        SDFCombination(std::unique_ptr<SDFObject> left, std::unique_ptr<SDFObject> right, SDFOperation op)
            : _left(std::move(left)), _right(std::move(right)), _op(op) {}
 
        ~SDFCombination() override = default;
 
        [[nodiscard]] double getDist(const Eigen::Vector3d &p) const override;
 
        [[nodiscard]] color_t getColor(const Eigen::Vector3d &p) const override;
    };
 
    class Shape : public SDFObject {
    protected:
        Eigen::Vector3d _pos;       
        color_t _color;             
    public:
        explicit Shape(color_t color = BLACK) : _pos(0), _color(color) {};
 
        [[deprecated("TransformataObject is now responsible for the translation")]] explicit Shape(Eigen::Vector3d p, color_t color = BLACK) : _pos(std::move(p)), _color(color) {};
 
        [[nodiscard]] virtual Eigen::Vector3d getPos() const { return _pos; };
 
        [[nodiscard]] color_t getColor(const Eigen::Vector3d &p) const override { return _color; }
 
        void setColor(color_t color){ _color = color; }
    };
 
    class Sphere : public Shape {
    private:
        double _radius;
    public:
        explicit Sphere(Eigen::Vector3d p, double r = 0, color_t color = BLACK) : Shape(std::move(p), color), _radius(r) {};
 
        ~Sphere() override = default;
 
        [[nodiscard]] double getDist(const Eigen::Vector3d &p) const override;
 
        [[nodiscard]] double getRadius() const { return _radius; }
    };
 
    class Cube : public Shape {
    private:
        Eigen::Vector3d _bound;
    public:
        Cube(Eigen::Vector3d p, double bound, color_t color = BLACK) : Shape(std::move(p), color), _bound(bound, bound, bound) {};
 
        ~Cube() override = default;
 
        [[nodiscard]] double getDist(const Eigen::Vector3d &p) const override;
 
        [[nodiscard]] double getBound() const { return _bound.x(); }
    };
 
    class Cylinder : public Shape {
    private:
        Eigen::Vector2d _hr;
    public:
        Cylinder(Eigen::Vector3d p, double h, double r, color_t color = BLACK) : Shape(std::move(p), color), _hr(h, r) {};
 
        ~Cylinder() override = default;
 
        [[nodiscard]] double getDist(const Eigen::Vector3d &p) const override;
    };
 
    class TransformataObject : public SDFObject {
        // TODO TransformataObject doesn't work with SDFCombination
        // Problem? Transfomata has to be applied for every primitive shape
    private:
        std::unique_ptr<SDFObject> _original;
        double _scale;
        Eigen::AngleAxisd _rotation;
        Eigen::AngleAxisd _reverseRotation;
        Eigen::Vector3d _translation;
    protected:
        void applyZeroRotation();
    public:
        TransformataObject(std::unique_ptr<SDFObject> object)
            : _original(std::move(object)), _scale(1), _rotation(), _translation(), _reverseRotation() {}
 
        ~TransformataObject() override = default;
 
 
        void rotate(double x, double y, double z);
 
        void setRotation(double x, double y, double z);
 
        void scale(double s) { _scale *= s; }
 
        void setScale(double s) { _scale = s; }
 
        [[nodiscard]] double getScale() const { return _scale; }
 
        void translate(const Eigen::Vector3d &p) { _translation += p; };
 
        void setTranslation(const Eigen::Vector3d &p) { _translation = p; }
 
        [[nodiscard]] Eigen::Vector3d getTranslation() const { return _translation; }
 
        [[nodiscard]] double getDist(const Eigen::Vector3d &p) const override;
 
        [[nodiscard]] color_t getColor(const Eigen::Vector3d &p) const override;
 
    };
}
 
#endif //RAYMARCHING_MODELS3_H