Muto::Random Namespace Reference

Functions
bool	Bool1 (float trueChance)
unsigned char	Char ()
float	Float1 ()
glm::vec2	Float2 ()
glm::vec3	Float3 ()
glm::vec4	Float4 ()
std::mt19937 &	GetRNG ()
std::string	HexString (size_t length)
float	RangeF1 (float min, float max)
float	RangeF1_Inclusive (float min, float max)
glm::vec2	RangeF2 (const glm::vec2 &minRange, const glm::vec2 &maxRange)
glm::vec2	RangeF2 (float min, float max)
glm::vec2	RangeF2 (float min1, float max1, float min2, float max2)
glm::vec3	RangeF3 (const glm::vec2 &range1, const glm::vec2 &range2, const glm::vec2 &range3)
glm::vec3	RangeF3 (float min, float max)
glm::vec3	RangeF3 (float min1, float max1, float min2, float max2, float min3, float max3)
glm::vec4	RangeF4 (float min, float max)
void	Seed (uint32_t seed)
std::string	String (size_t length)
uint32_t	UInt1 (uint32_t max)
std::string	UUID ()

Function Documentation

Bool1()

bool Muto::Random::Bool1 ( float  trueChance )

inline

                                            {
            MU_PROFILE_FUNCTION();
            std::uniform_real_distribution<float> dist(0.0f, 1.0f);
            return dist(GetRNG()) < trueChance;
        }

References GetRNG().

Char()

unsigned char Muto::Random::Char ( )

inline

                                    {
            MU_PROFILE_FUNCTION();
            std::uniform_int_distribution<int> dist(0, 255);
            return static_cast<unsigned char>(dist(GetRNG()));
        }

References GetRNG().

Float1()

float Muto::Random::Float1 ( )

inline

                              {
            MU_PROFILE_FUNCTION();
            static thread_local std::uniform_real_distribution<float> dist(0.0f, 1.0f);
            return dist(GetRNG());
        }

References GetRNG().

Referenced by Muto::ParticleSystem::Emit(), and Muto::ParticleSystem::ResetParticle().

Float2()

glm::vec2 Muto::Random::Float2 ( )

inline

                                {
            return glm::vec2{ Float1(), Float1() };
        }

Float3()

glm::vec3 Muto::Random::Float3 ( )

inline

                                {
            return glm::vec3{ Float1(), Float1(), Float1() };
        }

Float4()

glm::vec4 Muto::Random::Float4 ( )

inline

                                {
            return glm::vec4{ Float1(), Float1(), Float1(), Float1() };
        }

GetRNG()

std::mt19937 & Muto::Random::GetRNG ( )

inline

                                    {
            static thread_local std::mt19937 rng{ std::random_device{}() };
            return rng;
        }

Referenced by Bool1(), Char(), Float1(), RangeF1(), RangeF1_Inclusive(), Seed(), and UInt1().

HexString()

std::string Muto::Random::HexString ( size_t  length )

inline

                                                  {
            MU_PROFILE_FUNCTION();
            const char charset[] =
                "0123456789"
                "ABCDEF";
            const size_t max_index = (sizeof(charset) - 1);
            std::string str(length, 0);
            for (size_t i = 0; i < length; ++i) {
                str[i] = charset[UInt1(static_cast<uint32_t>(max_index))];
            }
            return str;
        }

References UInt1().

Referenced by UUID().

RangeF1()

float Muto::Random::RangeF1 ( float  min, float  max  )

inline

                                                   {
            MU_PROFILE_FUNCTION();
            if (min > max) std::swap(min, max);
            std::uniform_real_distribution<float> dist(min, max);
            return dist(GetRNG());
        }

References GetRNG().

RangeF1_Inclusive()

float Muto::Random::RangeF1_Inclusive ( float  min, float  max  )

inline

                                                             {
            if (min > max) std::swap(min, max);
            float upper = std::nextafter(max, std::numeric_limits<float>::infinity());
            std::uniform_real_distribution<float> dist(min, upper);
            return dist(GetRNG());
        }

References GetRNG().

RangeF2() [1/3]

glm::vec2 Muto::Random::RangeF2 ( const glm::vec2 &  minRange, const glm::vec2 &  maxRange  )

inline

                                                                                 {
            return glm::vec2{ RangeF1(minRange.x, maxRange.x), RangeF1(minRange.y, maxRange.y) };
        }

RangeF2() [2/3]

glm::vec2 Muto::Random::RangeF2 ( float  min, float  max  )

inline

                                                     {
            return glm::vec2{ RangeF1(min, max), RangeF1(min, max) };
        }

RangeF2() [3/3]

glm::vec2 Muto::Random::RangeF2 ( float  min1, float  max1, float  min2, float  max2  )

inline

                                                                               {
            return glm::vec2{ RangeF1(min1, max1), RangeF1(min2, max2) };
        }

RangeF3() [1/3]

glm::vec3 Muto::Random::RangeF3 ( const glm::vec2 &  range1, const glm::vec2 &  range2, const glm::vec2 &  range3  )

inline

                                                                                                    {
            return glm::vec3{ RangeF1(range1.x, range1.y), RangeF1(range2.x, range2.y), RangeF1(range3.x, range3.y) };
        }

RangeF3() [2/3]

glm::vec3 Muto::Random::RangeF3 ( float  min, float  max  )

inline

                                                     {
            return glm::vec3{ RangeF1(min, max), RangeF1(min, max), RangeF1(min, max) };
        }

RangeF3() [3/3]

glm::vec3 Muto::Random::RangeF3 ( float  min1, float  max1, float  min2, float  max2, float  min3, float  max3  )

inline

                                                                                                       {
            return glm::vec3{ RangeF1(min1, max1), RangeF1(min2, max2), RangeF1(min3, max3) };
        }

RangeF4()

glm::vec4 Muto::Random::RangeF4 ( float  min, float  max  )

inline

                                                     {
            return glm::vec4{ RangeF1(min, max), RangeF1(min, max), RangeF1(min, max), RangeF1(min, max) };
        }

Seed()

void Muto::Random::Seed ( uint32_t  seed )

inline

                                        {
            GetRNG().seed(seed);
        }

References GetRNG().

String()

std::string Muto::Random::String ( size_t  length )

inline

                                               {
            MU_PROFILE_FUNCTION();
            const char charset[] =
                "0123456789"
                "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
                "abcdefghijklmnopqrstuvwxyz";
            const size_t max_index = (sizeof(charset) - 1);
            std::string str(length, 0);
            for (size_t i = 0; i < length; ++i) {
                str[i] = charset[UInt1(static_cast<uint32_t>(max_index))];
            }
            return str;
        }

References UInt1().

UInt1()

uint32_t Muto::Random::UInt1 ( uint32_t  max )

inline

                                            {
            MU_PROFILE_FUNCTION();
            std::uniform_int_distribution<uint32_t> dist(0, max - 1);
            return dist(GetRNG());
        }

References GetRNG().

Referenced by HexString(), and String().

UUID()

std::string Muto::Random::UUID ( )

inline

                                {
            MU_PROFILE_FUNCTION();
            return HexString(8) + "-" + HexString(4) + "-" + HexString(4) + "-" + HexString(4) + "-" + HexString(12);
        }

References HexString().

Referenced by Muto::UUID::UUID().