Utils.hpp

Go to the documentation of this file.

#ifndef MOBILERT_UTILS_UTILS_HPP
#define MOBILERT_UTILS_UTILS_HPP

#include "Utils_dependent.hpp"

#include <algorithm>
#include <array>
#include <boost/assert.hpp>
#include <chrono>
#include <cmath>
#include <glm/ext.hpp>
#include <glm/glm.hpp>

#define GLM_ENABLE_EXPERIMENTAL
#include <glm/gtx/string_cast.hpp>

#include <pcg_random.hpp>
#include <random>
#include <string>
#include <sstream>
#include <thread>
#include <vector>

namespace MobileRT {

#ifndef NDEBUG

    #define LOG_DEBUG(...) \
        ::Dependent::printDebug( \
            ::MobileRT::convertToString(::MobileRT::getFileName(__FILE__), ":", __LINE__, ": ", __VA_ARGS__) \
        )
#else

    #define LOG_DEBUG(...) do { } while (false)
#endif

#define LOG_INFO(...) \
    ::Dependent::printInfo( \
        ::MobileRT::convertToString(::MobileRT::getFileName(__FILE__), ":", __LINE__, ": ", __VA_ARGS__) \
    )

#define LOG_WARN(...) \
    ::Dependent::printWarn( \
        ::MobileRT::convertToString(::MobileRT::getFileName(__FILE__), ":", __LINE__, ": ", __VA_ARGS__) \
    )

#define LOG_ERROR(...) \
    ::Dependent::printError( \
        ::MobileRT::convertToString(::MobileRT::getFileName(__FILE__), ":", __LINE__, ": ", __VA_ARGS__) \
    )


#ifndef LOG_DEBUG
#define LOG_DEBUG(...)
#endif

#ifndef LOG_INFO
#define LOG_INFO(...)
#endif

#ifndef LOG_WARN
#define LOG_WARN(...)
#endif

#ifndef LOG_ERROR
#define LOG_ERROR(...)
#endif

    template<typename T, ::std::size_t S>
    void fillArrayWithHaltonSeq(::std::array<T, S> *values);

    template<typename T, ::std::size_t S>
    void fillArrayWithMersenneTwister(::std::array<T, S> *values);

    template<typename T, ::std::size_t S>
    void fillArrayWithPCG(::std::array<T, S> *values);

    inline ::std::string getFileName(const char *filepath);


    ::std::int32_t roundDownToMultipleOf(::std::int32_t value, ::std::int32_t multiple);

    float haltonSequence(::std::uint32_t index, ::std::uint32_t base);

    ::std::int32_t incrementalAvg(const ::glm::vec3 &sample,
                                  ::std::int32_t avg,
                                  ::std::int32_t numSample);

    template<::std::int32_t S, typename T>
    inline ::std::array<T, S> toArray(const char *values);

    ::glm::vec2 toVec2(const char *values);

    ::glm::vec3 toVec3(const char *values);

    ::glm::vec3 toVec3(const float *values);

    bool equal(float a, float b);

    bool equal(const ::glm::vec3 &vec1, const ::glm::vec3 &vec2);

    template<::std::int32_t S, typename T>
    bool isValid(const ::glm::vec<S, T> &value);

    template<::std::int32_t S, typename T>
    bool hasPositiveValue(const ::glm::vec<S, T> &value);

    bool isValid(float value);

    ::glm::vec2 normalize(const ::glm::vec2 &textureCoordinates);

    ::glm::vec3 normalize(const ::glm::vec3 &color);

    float fresnel(const ::glm::vec3 &I, const ::glm::vec3 &N, float ior);

    void checkSystemError(const char *message);

    void printFreeMemory();

    template<::std::int32_t S, typename T>
    void addToStringStream(::std::ostringstream *oss, const ::glm::vec<S, T>& parameter) {
        *oss << ::glm::to_string(parameter);
    }

    template <typename Type>
    void addToStringStream(::std::ostringstream *oss, const Type& parameter) {
        *oss << parameter;
    }

    template <typename First, typename... Args>
    void addToStringStream(::std::ostringstream *oss, const First& parameter, Args &&... args) {
        addToStringStream(oss, parameter);
        addToStringStream(oss, args...);
    }

    template <typename... Args>
    ::std::string convertToString(Args &&... args) {
        ::std::ostringstream oss {""};
        addToStringStream(&oss, args...);
        oss << '\n';
        const ::std::string &line {oss.str()};
        return line;
    }

    ::std::string getFileName(const char *const filepath) {
        const ::std::string &filePath {filepath};
        ::std::string::size_type filePos {filePath.rfind('/')};
        if (filePos != ::std::string::npos) {
            ++filePos;
        } else {
            filePos = 0;
        }
        const ::std::string &res {filePath.substr(filePos)};
        return res;
    }

    template<typename T, ::std::size_t S>
    void fillArrayWithHaltonSeq(::std::array<T, S> *const values) {
        for (typename ::std::array<T, S>::iterator itValues {values->begin()}; itValues < values->end(); ::std::advance(itValues, 1)) {
            const ::std::uint32_t index {static_cast<::std::uint32_t> (::std::distance(values->begin(), itValues))};
            *itValues = ::MobileRT::haltonSequence(index, 2);
        }
        static ::std::random_device randomDevice {};
        static ::std::mt19937 generator {randomDevice()};
        ::std::shuffle(values->begin(), values->end(), generator);
    }

    template<typename T, ::std::size_t S>
    void fillArrayWithMersenneTwister(::std::array<T, S> *const values) {
        static ::std::uniform_real_distribution<float> uniformDist {0.0F, 1.0F};
        static ::std::random_device randomDevice {};
        static ::std::mt19937 generator {randomDevice()};
        ::std::generate(values->begin(), values->end(), []() {return uniformDist(generator);});
    }

    template<typename T, ::std::size_t S>
    void fillArrayWithPCG(::std::array<T, S> *const values) {
        static ::pcg_extras::seed_seq_from<::std::random_device> seedSource {};
        static ::pcg32 generator(seedSource);
        static ::std::uniform_real_distribution<float> uniformDist {0.0F, 1.0F};
        ::std::generate(values->begin(), values->end(), []() {return uniformDist(generator);});
    }

    template<::std::int32_t S, typename T>
    bool isValid(const ::glm::vec<S, T> &value) {
        const bool isNaN {::glm::all(::glm::isnan(value))};
        const bool isInf {::glm::all(::glm::isinf(value))};
        const bool res {!isNaN && !isInf};
        return res;
    }

    template<::std::int32_t S, typename T>
    bool hasPositiveValue(const ::glm::vec<S, T> &value) {
        return ::glm::any(::glm::greaterThan(value, ::glm::vec<S, T> {0}));
    }

    template<::std::int32_t S, typename T>
    inline ::std::array<T, S> toArray(const char *const values) {
        ::std::stringstream data {values};
        ::std::array<float, S> parsedValues {};
        for (::std::uint32_t i {0u}; i < S; ++i) {
            data >> parsedValues[i];
        }
        return parsedValues;
    }


    #ifndef NDEBUG

        #define ASSERT(condition, ...) \
        do { \
            if (!(condition)) { \
                LOG_DEBUG("Assertion '", #condition, "': ",  __VA_ARGS__); \
                BOOST_ASSERT_MSG(condition, ::MobileRT::convertToString(__VA_ARGS__).c_str()); \
            } \
        } while (false)
    #else

        #define ASSERT(condition, ...) do { } while (false)
    #endif


    namespace std {
        #if __cplusplus < 201402L

            template<typename T, typename... Args>
            ::std::unique_ptr<T> make_unique(Args &&... args) {
                return ::std::unique_ptr<T>(new T(::std::forward<Args>(args)...));
            }
        #else

            template<typename T, typename... Args>
            ::std::unique_ptr<T> make_unique(Args &&... args) {
                return ::std::make_unique<T>(::std::forward<Args>(args)...);
            }
        #endif

        /*
         * Its necessary to force a C++ version that is not set in the CMakeLists
         * because with older NDKs, it supports C++11 but this std::to_string is
         * not implemented there.
         */
        #if __cplusplus < 201703L

            template <typename T> ::std::string to_string(const T& str) {
                ::std::ostringstream stm {""};
                stm << str ;
                return stm.str() ;
            }
        #else

            template <typename T> ::std::string to_string(const T& str) {
                return ::std::to_string(str);
            }
        #endif
    }//namespace std


}//namespace MobileRT

#endif //MOBILERT_UTILS_UTILS_HPP