Random.h

Go to the documentation of this file.

#ifndef G3D_Random_h
#define G3D_Random_h

#include "G3D/platform.h"
#include "G3D/g3dmath.h"
#include "G3D/GMutex.h"

namespace G3D {

class Random {
protected:

 enum {
 N = 624,
 M = 397,
 R = 31,
 U = 11,
 S = 7,
 T = 15,
 L = 18,
 A = 0x9908B0DF,
 B = 0x9D2C5680,
 C = 0xEFC60000};

 Spinlock lock;

 uint32* state;

 int index;

 bool m_threadsafe;

 virtual void generate();

 Random(void*);


private:

 Random& operator=(const Random&) {
 alwaysAssertM(false,
 "There is no copy constructor or assignment operator for Random because you "
 "probably didn't actually want to copy the state--it would "
 "be slow and duplicate the state of a pseudo-random sequence. Maybe you could "
 "provide arguments to a member variable in the constructor, "
 "or pass the Random by reference?");
 return *this;
 }

 Random(const Random& r) {
 *this = r;
 }

public:

 Random(uint32 seed = 0xF018A4D2, bool threadsafe = true);

 virtual ~Random();

 virtual void reset(uint32 seed = 0xF018A4D2, bool threadsafe = true);

 virtual uint32 bits();

 virtual int integer(int min, int max);

 virtual inline float uniform(float low, float high) {
 // We could compute the ratio in double precision here for
 // about 1.5x slower performance and slightly better
 // precision.
 return low + (high - low) * ((float)bits() / (float)0xFFFFFFFFUL);
 }

 virtual inline float uniform() {
 // We could compute the ratio in double precision here for
 // about 1.5x slower performance and slightly better
 // precision.
 const float norm = 1.0f / (float)0xFFFFFFFFUL;
 return (float)bits() * norm;
 }

 virtual float gaussian(float mean, float stdev);

 virtual void cosHemi(float& x, float& y, float& z);

 virtual void cosSphere(float& x, float& y, float& z);

 virtual void cosPowHemi(const float k, float& x, float& y, float& z);

 virtual void hemi(float& x, float& y, float& z);

 virtual void sphere(float& x, float& y, float& z);

 static Random& common();
};

}

#endif