#include <PrecomputedRandom.h>

Classes
class	HemiUniformData

class	SphereBitsData

Public Member Functions
	PrecomputedRandom (const HemiUniformData data1, const SphereBitsData data2, int dataSize, uint32 seed=0xF018A4D2)

	PrecomputedRandom (int dataSize, uint32 seed=0xF018A4D2)

	~PrecomputedRandom ()

virtual uint32	bits ()

virtual float	uniform (float low, float high)

virtual float	uniform ()

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

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

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

Public Member Functions inherited from G3D::Random
	Random (uint32 seed=0xF018A4D2, bool threadsafe=true)

virtual	~Random ()

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

virtual int	integer (int min, int max)

virtual float	gaussian (float mean, float stdev)

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

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

Protected Attributes
const HemiUniformData *	m_hemiUniform

const SphereBitsData *	m_sphereBits

int	m_modMask

int	m_index

bool	m_freeData

Protected Attributes inherited from G3D::Random
Spinlock	lock

uint32 *	state

int	index

bool	m_threadsafe

Additional Inherited Members
Static Public Member Functions inherited from G3D::Random
static Random &	common ()

Protected Types inherited from G3D::Random
enum	{ N = 624, M = 397, R = 31, U = 11, S = 7, T = 15, L = 18, A = 0x9908B0DF, B = 0x9D2C5680, C = 0xEFC60000 }

Protected Member Functions inherited from G3D::Random
virtual void	generate ()

	Random (void *)

Detailed Description

Fast random numbers using a precomputed data table.

e.g., generates cosHemi about 13x faster than Random. This is useful for quickly generating seeded random numbers for reproducibility. G3D::Random takes a long time to seed; this is instantaneous (providing the precomputed data is already available.)

Not threadsafe.

Constructor & Destructor Documentation

G3D::PrecomputedRandom::PrecomputedRandom	(	const HemiUniformData *	data1,
		const SphereBitsData *	data2,
		int	dataSize,
		uint32	seed = `0xF018A4D2`
	)

  : 
  Random((void*)NULL),
  m_hemiUniform(data1),
  m_sphereBits(data2),
  m_modMask(dataSize - 1),
  m_freeData(false) {
 
  m_index = seed & m_modMask;
  alwaysAssertM(isPow2(dataSize), "dataSize must be a power of 2");
 }

Here is the call graph for this function:

G3D::PrecomputedRandom::PrecomputedRandom	(	int	dataSize,
		uint32	seed = `0xF018A4D2`
	)

Parameters

dataSize Number of random numbers that can be requested before periodicity. Must be a power of 2.

  : 
  Random((void*)NULL),
  m_hemiUniform(NULL),
  m_sphereBits(NULL),
  m_modMask(dataSize - 1),
  m_freeData(true) {
 
  alwaysAssertM(isPow2(dataSize), "dataSize must be a power of 2");
  m_index = seed & m_modMask;
 
  HemiUniformData* h;
  SphereBitsData* s;
  m_hemiUniform = h = (HemiUniformData*) System::malloc(sizeof(HemiUniformData) * dataSize);
  m_sphereBits = s = (SphereBitsData*) System::malloc(sizeof(SphereBitsData) * dataSize);
 
  Random r;
 
  for (int i = 0; i < dataSize; ++i) {
  h[i].uniform = r.uniform();
  r.cosHemi(h[i].cosHemiX, h[i].cosHemiY, h[i].cosHemiZ); 
 
  s[i].bits = r.bits();
  r.sphere(s[i].sphereX, s[i].sphereY, s[i].sphereZ); 
  }
 
 }

Here is the call graph for this function:

G3D::PrecomputedRandom::~PrecomputedRandom ( )

  {
  if (m_freeData) {
  System::free(const_cast<HemiUniformData*>(m_hemiUniform));
  System::free(const_cast<SphereBitsData*>(m_sphereBits));
  }
 }

Here is the call graph for this function:

Member Function Documentation

uint32 G3D::PrecomputedRandom::bits ( )

virtual

Each bit is random. Subclasses can choose to override just this method and the other methods will all work automatically.

Reimplemented from G3D::Random.

  {
  m_index = (m_index + 1) & m_modMask;
  return m_sphereBits[m_index].bits;
 }

void G3D::PrecomputedRandom::cosHemi	(	float &	x,
		float &	y,
		float &	z
	)

virtual

Returns 3D unit vectors distributed according to a cosine distribution about the z axis.

Reimplemented from G3D::Random.

  {
  m_index = (m_index + 1) & m_modMask;
  x = m_hemiUniform[m_index].cosHemiX;
  y = m_hemiUniform[m_index].cosHemiY;
  z = m_hemiUniform[m_index].cosHemiZ;
 }

Here is the caller graph for this function:

void G3D::PrecomputedRandom::cosPowHemi	(	const float	k,
		float &	x,
		float &	y,
		float &	z
	)

virtual

Returns 3D unit vectors distributed according to a cosine power distribution ( $\mbox{cos}^k \theta$ ) about the z-axis.

Reimplemented from G3D::Random.

  {
  // Computing a cosPowHemi costs 4 slow functions (pow, sqrt, sin,
  // cos). We can do it with two, given a cosHemi sample, basically
  // saving the cost of sin and cos and making a single 128-byte
  // memory read (for a vector) instead of two (for adjacent uniform
  // floats).
 
  // cos^1 distribution sample
  float cos1;
  cosHemi(x, y, cos1);
 
  // Fix the distribution by adjusting the cosine:
  // rnd(cos^k t) = (rnd(cos(t))^2)^(1/k)
  
  // produces cos^k distribution sample
  z = pow(cos1, 2.0f / (1.0f + k));
 
  // Rescale x and y by sqrt(1.0f - square(z)) / sqrt(x*x + y*y).
  // Add a very tiny offset to handle the (almost impossibly unlikely) case where
  // z = 1 and x^2+y^2 = 0.
  static const float eps = 0.000001f;
  const float s = sqrt((1.0f + eps - square(z)) / (square(x) + square(y) + eps));
 
  x *= s;
  y *= s;
 }

Here is the call graph for this function:

void G3D::PrecomputedRandom::sphere	(	float &	x,
		float &	y,
		float &	z
	)

virtual

Returns 3D unit vectors uniformly distributed on the sphere

Reimplemented from G3D::Random.

  {
  m_index = (m_index + 1) & m_modMask;
  x = m_sphereBits[m_index].sphereX;
  y = m_sphereBits[m_index].sphereY;
  z = m_sphereBits[m_index].sphereZ;
 }

float G3D::PrecomputedRandom::uniform	(	float	low,
		float	high
	)

virtual

Uniform random float on the range [min, max]

Reimplemented from G3D::Random.

  {
  m_index = (m_index + 1) & m_modMask;
  return low + m_hemiUniform[m_index].uniform * (high - low);
 }

float G3D::PrecomputedRandom::uniform ( )

virtual

Uniform random float on the range [0, 1]

Reimplemented from G3D::Random.

  {
  m_index = (m_index + 1) & m_modMask;
  return m_hemiUniform[m_index].uniform;
 }

Member Data Documentation

bool G3D::PrecomputedRandom::m_freeData

protected

If true, free m_hemiUniform and m_sphereBits in destructor

const HemiUniformData* G3D::PrecomputedRandom::m_hemiUniform

protected

Array of 2^n elements.

int G3D::PrecomputedRandom::m_index

protected

int G3D::PrecomputedRandom::m_modMask

protected

2^n - 1; the AND mask for computing a fast modulo

const SphereBitsData* G3D::PrecomputedRandom::m_sphereBits

protected

The documentation for this class was generated from the following files:

dep/g3dlite/include/G3D/PrecomputedRandom.h
dep/g3dlite/source/PrecomputedRandom.cpp

Classes

Public Member Functions

Protected Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation