Random.h

Go to the documentation of this file.

#pragma once
 
#include <random>
 
namespace Math
{
    inline std::mt19937& randomEngine()
    {
        static thread_local std::mt19937 engine( std::random_device{}() );
        return engine;
    }
 
    inline int randomInt( int min, int max )
    {
        std::uniform_int_distribution<int> distribution( min, max );
        return distribution( randomEngine() );
    }
 
    inline float randomFloat( float min, float max )
    {
        std::uniform_real_distribution<float> distribution( min, max );
        return distribution( randomEngine() );
    }
 
    inline glm::vec3 randomVectorInCone(glm::vec3 direction, float angle)
    {
        // angle is in radians.
        // direction defines the cone axis.
 
        const float len2 = glm::dot(direction, direction);
        if (len2 <= 0.000001f)
            return {0.0f, 0.0f, 1.0f};
 
        const glm::vec3 axis = glm::normalize(direction);
 
        // Replace these with your own random floats in [0, 1].
        const float u1 = randomFloat(0.0f, 1.0f);
        const float u2 = randomFloat(0.0f, 1.0f);
 
        // Uniform distribution over the cone's solid angle.
        const float cosMax = std::cos(angle);
        const float cosTheta = glm::mix(1.0f, cosMax, u1);
        const float sinTheta = std::sqrt(1.0f - cosTheta * cosTheta);
 
        const float phi = 2.0f * glm::pi<float>() * u2;
 
        // Random vector in local space, where the cone points along +Z.
        const glm::vec3 local{
            std::cos(phi) * sinTheta,
            std::sin(phi) * sinTheta,
            cosTheta
        };
 
        // Build an orthonormal basis around `axis`.
        const glm::vec3 helper =
            std::abs(axis.z) < 0.999f
            ? glm::vec3(0.0f, 0.0f, 1.0f)
            : glm::vec3(1.0f, 0.0f, 0.0f);
 
        const glm::vec3 tangent   = glm::normalize(glm::cross(helper, axis));
        const glm::vec3 bitangent = glm::cross(axis, tangent);
 
        // Transform local cone vector into world space.
        const glm::vec3 world =
            tangent   * local.x +
            bitangent * local.y +
            axis      * local.z;
 
        return glm::normalize(world);
    }
}