util.hpp

Go to the documentation of this file.

 
#ifndef TOYMAKERENGINE_UTIL_H
#define TOYMAKERENGINE_UTIL_H
 
#include <glm/glm.hpp>
 
namespace ToyMaker {
    glm::mat4 buildModelMatrix(glm::vec4 position, glm::quat orientation, glm::vec3 scale = glm::vec3{1.f, 1.f, 1.f});

    inline float squareDistance(const glm::vec3& vector) {
        return glm::dot(vector, vector);
    }

    inline bool isFinite(float number) {
        return std::isfinite(number);
    }

    inline bool isFinite(const glm::vec3& vector) {
        return isFinite(vector.x) && isFinite(vector.y) && isFinite(vector.z);
    }

    inline bool isPositiveStrict(float number) {
        return number > 0.f;
    }

    inline bool isPositiveStrict(const glm::vec3& vector) {
        return isPositiveStrict(vector.x) && isPositiveStrict(vector.y) && isPositiveStrict(vector.z);
    }

    inline bool isNumber(float number) {
        return !std::isnan(number);
    };

    inline bool isNumber(const glm::vec3& vector) {
        return isNumber(vector.x) && isNumber(vector.y) && isNumber(vector.z);
    };

    inline bool isNonNegative(float number) {
        return number >= 0.f;
    }

    inline bool isNonNegative(const glm::vec3& vector) {
        return isNonNegative(vector.x) && isNonNegative(vector.y) && isNonNegative(vector.z);
    }

    glm::quat getRotation(const glm::vec3& from, const glm::vec3& to);

    float getAngle(const glm::vec3& from, const glm::vec3& to, const glm::vec3& axis);

    glm::vec3 getOrthogonal(const glm::vec3& from);

    std::pair<glm::vec3, glm::vec3> getTangents(const glm::vec3& vector);

    bool isSensible(const glm::mat3& matrix);

    glm::mat4 getScaleMatrix(const glm::mat4& fromTransform);

    glm::mat4 getRotationMatrix(const glm::mat4& fromTransform);

    glm::mat4 getTranslationMatrix(const glm::mat4& fromTransform);

    class RangeMapperLinear {
    public:
        RangeMapperLinear(
            double inputLowerBound, double inputUpperBound,
            double outputLowerBound, double outputUpperBound
        );

        double operator() (double value) const;
    private:
        double mInputLowerBound;
        double mInputUpperBound;

        double mOutputLowerBound;

        double mOutputUpperBound;
    };
}
 
#endif