Naive.hpp

Go to the documentation of this file.

#ifndef MOBILERT_ACCELERATORS_NAIVE_HPP
#define MOBILERT_ACCELERATORS_NAIVE_HPP

#include "MobileRT/Intersection.hpp"
#include "MobileRT/Ray.hpp"
#include <vector>

namespace MobileRT {

    template<typename T>
    class Naive final {
        private:
            ::std::vector<T> primitives_ {};

        private:
            Intersection intersect(Intersection intersection);

        public:
            explicit Naive() = default;

            explicit Naive(::std::vector<T> &&primitives);

            Naive(const Naive &naive) = delete;

            Naive(Naive &&naive) noexcept = default;

            ~Naive();

            Naive &operator=(const Naive &naive) = delete;

            Naive &operator=(Naive &&naive) noexcept = default;

            Intersection trace(Intersection intersection);

            Intersection shadowTrace(Intersection intersection);

            const ::std::vector<T>& getPrimitives() const;
    };

    template<typename T>
    Naive<T>::Naive(::std::vector<T> &&primitives) :
        primitives_ {::std::move(primitives)} {
        LOG_INFO("Built Native for: ", typeid(T).name());
    }

    template<typename T>
    Naive<T>::~Naive() {
        this->primitives_.clear();
        ::std::vector<T> {}.swap(this->primitives_);
    }

    template<typename T>
    Intersection Naive<T>::intersect(Intersection intersection) {
        const float lastDist {intersection.length_};
        for (T &primitive : this->primitives_) {
            intersection = primitive.intersect(intersection);
            if (intersection.ray_.shadowTrace_ && intersection.length_ < lastDist) {
                return intersection;
            }
        }
        return intersection;
    }

    template<typename T>
    Intersection Naive<T>::trace(Intersection intersection) {
        intersection = intersect(intersection);
        return intersection;
    }

    template<typename T>
    Intersection Naive<T>::shadowTrace(Intersection intersection) {
        intersection = intersect(intersection);
        return intersection;
    }

    template<typename T>
    const ::std::vector<T>& Naive<T>::getPrimitives() const {
        return this->primitives_;
    }

}//namespace MobileRT

#endif //MOBILERT_ACCELERATORS_NAIVE_HPP