random.h

#pragma once
 
#include <cstdint>
 
namespace Vkm::Engine::Math {

class Rng {
    public:
        Rng() = default;

        explicit Rng(uint64_t seed, uint64_t stream = DEFAULT_STREAM) {
            this->seed(seed, stream);
        }
 
        ~Rng() = default;
 
        Rng(const Rng& other) = default;
        Rng& operator=(const Rng& other) = default;
 
        Rng(Rng && other) noexcept = default;
        Rng& operator=(Rng && other) noexcept = default;
 
    public:
        void seed(uint64_t seed, uint64_t stream = DEFAULT_STREAM) {
            m_state = 0u;
            m_inc   = (stream << 1u) | 1u;   // inc must be odd
            nextU32();
            m_state += seed;
            nextU32();
        }

        uint32_t nextU32() {
            const uint64_t old = m_state;
            m_state = old * 6364136223846793005ULL + m_inc;
            const uint32_t xorshifted = static_cast<uint32_t>(((old >> 18u) ^ old) >> 27u);
            const uint32_t rot        = static_cast<uint32_t>(old >> 59u);
            return (xorshifted >> rot) | (xorshifted << ((0u - rot) & 31u));
        }
 
        float nextFloat()                     { return (nextU32() >> 8) * (1.0f / 16777216.0f); }
        float nextFloat(float min, float max) { return min + (max - min) * nextFloat(); }
        int nextInt(int min, int max) {
            return min + static_cast<int>(boundedU32(static_cast<uint32_t>(max - min) + 1u));
        }
        bool nextBool()                       { return (nextU32() >> 31u) != 0u; }
 
    private:
        static constexpr uint64_t DEFAULT_STREAM = 0xda3e39cb94b95bdbULL;
 
    private:
        uint32_t boundedU32(uint32_t range) {
            uint32_t x = nextU32();
            uint64_t m = static_cast<uint64_t>(x) * static_cast<uint64_t>(range);
            uint32_t low = static_cast<uint32_t>(m);
            if (low < range) {
                const uint32_t threshold = (0u - range) % range;
                while (low < threshold) {
                    x   = nextU32();
                    m   = static_cast<uint64_t>(x) * static_cast<uint64_t>(range);
                    low = static_cast<uint32_t>(m);
                }
            }
            return static_cast<uint32_t>(m >> 32u);
        }
 
    private:
        uint64_t m_state = 0x853c49e6748fea9bULL;  
        uint64_t m_inc   = DEFAULT_STREAM;         
};

namespace Random {

Rng& rng();

inline float value() { return rng().nextFloat(); }

inline float range(float min, float max) { return rng().nextFloat(min, max); }

inline int range(int min, int max) { return rng().nextInt(min, max); }

inline bool boolean() { return rng().nextBool(); }
 
} // namespace Random
 
} // namespace Vkm::Engine::Math