Random.h

Go to the documentation of this file.

 
#pragma once
 
#include "ncengine/module/Module.h"
#include "ncengine/type/EngineId.h"
 
#include "ncmath/Vector.h"
#include "ncmath/Xoshiro256.h"
 
#include <random>
 
namespace nc
{
class Random : public Module
{
    public:
        explicit Random() noexcept
            : Random(std::random_device{}())
        {
        }
 
        explicit Random(uint64_t seed) noexcept
            : Module{NcRandomId},
              m_seed{seed},
              m_generator{m_seed},
              m_distribution{0.0f, std::nextafter(1.0f, std::numeric_limits<float>::max())}
        {
        }
 
        auto Fork() noexcept { return Random{GetU64()}; }
 
        void Seed(uint64_t seed) noexcept { *this = Random{seed}; }
 
        auto Seed() const noexcept { return m_seed; }
 
        auto GetGenerator() -> Xoshiro256ss& { return m_generator; }
 
        auto Get() noexcept -> float { return m_distribution(m_generator); }
 
        auto GetU64() noexcept -> uint64_t { return m_generator(); }
 
        auto GetVector2() noexcept -> Vector2 { return Vector2{Get(), Get()}; }
 
        auto GetVector3() noexcept -> Vector3 { return Vector3{Get(), Get(), Get()}; }
 
        auto GetVector4() noexcept -> Vector4 { return Vector4{Get(), Get(), Get(), Get()}; }
 
        auto Between(float min, float max) noexcept -> float { return Get() * (max - min) + min; }
 
        auto Between(uint64_t min, uint64_t max) noexcept -> uint64_t
        {
            auto distribution = std::uniform_int_distribution<uint64_t>{min, max};
            return distribution(m_generator);
        }
 
        auto Between(const Vector2& min, const Vector2& max) noexcept -> Vector2 { return HadamardProduct(GetVector2(), max - min) + min; }
 
        auto Between(const Vector3& min, const Vector3& max) noexcept -> Vector3 { return HadamardProduct(GetVector3(), max - min) + min; }
 
        auto Between(const Vector4& min, const Vector4& max) noexcept -> Vector4 { return HadamardProduct(GetVector4(), max - min) + min; }
 
        friend bool operator==(const Random& lhs, const Random& rhs) noexcept { return lhs.m_generator == rhs.m_generator; }
 
        friend bool operator!=(const Random& lhs, const Random& rhs) noexcept { return lhs.m_generator != rhs.m_generator; }
 
    private:
        uint64_t m_seed;
        Xoshiro256ss m_generator;
        std::uniform_real_distribution<float> m_distribution;
};
} // namespace nc