Skip to content
Permalink
Browse files

Add support for the PCG32 PRNG algo (and associated script APIs)

  • Loading branch information...
kwolekr committed Mar 22, 2015
1 parent 7679396 commit 3993093f51544d4eb44efb57c973e29107ea2f7a
Showing with 407 additions and 171 deletions.
  1. +15 −1 doc/lua_api.txt
  2. +3 −7 src/mapgen.cpp
  3. +1 −1 src/mg_ore.cpp
  4. +101 −0 src/noise.cpp
  5. +46 −25 src/noise.h
  6. +165 −95 src/script/lua_api/l_noise.cpp
  7. +43 −7 src/script/lua_api/l_noise.h
  8. +1 −0 src/script/scripting_game.cpp
  9. +28 −31 src/util/numeric.cpp
  10. +4 −4 src/util/numeric.h
@@ -2515,7 +2515,8 @@ an itemstring, a table or `nil`.
Returns taken `ItemStack`.

### `PseudoRandom`
A pseudorandom number generator.
A 16-bit pseudorandom number generator.
Uses a well-known LCG algorithm introduced by K&R.

It can be created via `PseudoRandom(seed)`.

@@ -2525,6 +2526,19 @@ It can be created via `PseudoRandom(seed)`.
* `((max - min) == 32767) or ((max-min) <= 6553))` must be true
due to the simple implementation making bad distribution otherwise.

### `PcgRandom`

This comment has been minimized.

Copy link
@sfan5

sfan5 Mar 22, 2015

Shouldn't this be called PCGRandom?

A 32-bit pseudorandom number generator.
Uses PCG32, an algorithm of the permuted congruential generator family, offering very strong randomness.

It can be created via `PcgRandom(seed)` or `PcgRandom(seed, sequence)`.

#### Methods
* `next()`: return next integer random number [`-2147483648`...`2147483647`]
* `next(min, max)`: return next integer random number [`min`...`max`]
* `rand_normal_dist(min, max, num_trials=6)`: return normally distributed random number [`min`...`max`]
* This is only a rough approximation of a normal distribution with mean=(max-min)/2 and variance=1
* Increasing num_trials improves accuracy of the approximation

### `PerlinNoise`
A perlin noise generator.
It can be created via `PerlinNoise(seed, octaves, persistence, scale)`
@@ -515,14 +515,10 @@ void MapgenParams::load(const Settings &settings)
std::string seed_str;
const char *seed_name = (&settings == g_settings) ? "fixed_map_seed" : "seed";

if (settings.getNoEx(seed_name, seed_str) && !seed_str.empty()) {
if (settings.getNoEx(seed_name, seed_str) && !seed_str.empty())
seed = read_seed(seed_str.c_str());
} else {
seed = ((u64)(myrand() & 0xFFFF) << 0) |
((u64)(myrand() & 0xFFFF) << 16) |
((u64)(myrand() & 0xFFFF) << 32) |
((u64)(myrand() & 0xFFFF) << 48);
}
else
myrand_bytes(&seed, sizeof(seed));

settings.getNoEx("mg_name", mg_name);
settings.getS16NoEx("water_level", water_level);
@@ -308,7 +308,7 @@ void OreVein::generate(MMVManip *vm, int mapseed, u32 blockseed,
}

// randval ranges from -1..1
float randval = (float)pr.next() / (PSEUDORANDOM_MAX / 2) - 1.f;
float randval = (float)pr.next() / (pr.RANDOM_RANGE / 2) - 1.f;
float noiseval = contour(noise->result[index]);
float noiseval2 = contour(noise2->result[index]);
if (noiseval * noiseval2 + randval * random_factor < nthresh)
@@ -62,6 +62,107 @@ FlagDesc flagdesc_noiseparams[] = {

///////////////////////////////////////////////////////////////////////////////

PcgRandom::PcgRandom(u64 state, u64 seq)
{
seed(state, seq);
}

void PcgRandom::seed(u64 state, u64 seq)
{
m_state = 0U;
m_inc = (seq << 1u) | 1u;
next();
m_state += state;
next();
}


u32 PcgRandom::next()
{
u64 oldstate = m_state;
m_state = oldstate * 6364136223846793005ULL + m_inc;

u32 xorshifted = ((oldstate >> 18u) ^ oldstate) >> 27u;
u32 rot = oldstate >> 59u;
return (xorshifted >> rot) | (xorshifted << ((-rot) & 31));
}


u32 PcgRandom::range(u32 bound)
{
/*
If the bound is not a multiple of the RNG's range, it may cause bias,
e.g. a RNG has a range from 0 to 3 and we take want a number 0 to 2.
Using rand() % 3, the number 0 would be twice as likely to appear.
With a very large RNG range, the effect becomes less prevalent but
still present. This can be solved by modifying the range of the RNG
to become a multiple of bound by dropping values above the a threshhold.
In our example, threshhold == 4 - 3 = 1 % 3 == 1, so reject 0, thus
making the range 3 with no bias.
This loop looks dangerous, but will always terminate due to the
RNG's property of uniformity.
*/
u32 threshhold = -bound % bound;
u32 r;

while ((r = next()) < threshhold);

return r % bound;
}


s32 PcgRandom::range(s32 min, s32 max)
{
assert(max >= min);
u32 bound = max - min + 1;
return range(bound) + min;
}


void PcgRandom::bytes(void *out, size_t len)
{
u32 r;
u8 *outb = (u8 *)out;

size_t len_alignment = (uintptr_t)out % sizeof(u32);
if (len_alignment) {
r = next();
while (len_alignment--) {
*outb = r & 0xFF;
outb++;
r >>= 8;
}
}

size_t len_dwords = len / sizeof(u32);
while (len_dwords--) {
r = next();
*(u32 *)outb = next();
outb += sizeof(u32);
}

size_t len_remaining = len % sizeof(u32);
if (len_remaining) {
r = next();
while (len_remaining--) {
*outb = r & 0xFF;
outb++;
r >>= 8;
}
}
}


s32 PcgRandom::randNormalDist(s32 min, s32 max, int num_trials)
{
u32 accum = 0;
for (int i = 0; i != num_trials; i++)
accum += range(min, max);
return ((float)accum / num_trials) + 0.5f;
}

///////////////////////////////////////////////////////////////////////////////

float noise2d(int x, int y, int seed)
{
@@ -30,47 +30,67 @@
#include "irr_v3d.h"
#include "util/string.h"

#define PSEUDORANDOM_MAX 32767

extern FlagDesc flagdesc_noiseparams[];

class PseudoRandom
{
// Note: this class is not polymorphic so that its high level of
// optimizability may be preserved in the common use case
class PseudoRandom {
public:
PseudoRandom(): m_next(0)
{
}
PseudoRandom(int seed): m_next(seed)
const static u32 RANDOM_RANGE = 32767;

inline PseudoRandom(int seed=0):
m_next(seed)
{
}
void seed(int seed)

inline void seed(int seed)
{
m_next = seed;
}
// Returns 0...PSEUDORANDOM_MAX
int next()

inline int next()
{
m_next = m_next * 1103515245 + 12345;
return((unsigned)(m_next/65536) % (PSEUDORANDOM_MAX + 1));
return (unsigned)(m_next / 65536) % (RANDOM_RANGE + 1);
}
int range(int min, int max)

inline int range(int min, int max)
{
if (max-min > (PSEUDORANDOM_MAX + 1) / 10)
{
//dstream<<"WARNING: PseudoRandom::range: max > 32767"<<std::endl;
assert("Something wrong with random number" == NULL);
}
if(min > max)
{
assert("Something wrong with random number" == NULL);
//return max;
}
return (next()%(max-min+1))+min;
assert(max >= min);
/*
Here, we ensure the range is not too large relative to RANDOM_MAX,
as otherwise the effects of bias would become noticable. Unlike
PcgRandom, we cannot modify this RNG's range as it would change the
output of this RNG for reverse compatibility.
*/
assert((u32)(max - min) <= (RANDOM_RANGE + 1) / 10);

return (next() % (max - min + 1)) + min;
}

private:
int m_next;
};

class PcgRandom {
public:
const static s32 RANDOM_MIN = -0x7fffffff - 1;
const static s32 RANDOM_MAX = 0x7fffffff;
const static u32 RANDOM_RANGE = 0xffffffff;

PcgRandom(u64 state=0x853c49e6748fea9bULL, u64 seq=0xda3e39cb94b95bdbULL);
void seed(u64 state, u64 seq=0xda3e39cb94b95bdbULL);
u32 next();
u32 range(u32 bound);
s32 range(s32 min, s32 max);
void bytes(void *out, size_t len);
s32 randNormalDist(s32 min, s32 max, int num_trials=6);

private:
u64 m_state;
u64 m_inc;
};

#define NOISE_FLAG_DEFAULTS 0x01
#define NOISE_FLAG_EASED 0x02
#define NOISE_FLAG_ABSVALUE 0x04
@@ -89,7 +109,8 @@ struct NoiseParams {
float lacunarity;
u32 flags;

NoiseParams() {
NoiseParams()
{
offset = 0.0f;
scale = 1.0f;
spread = v3f(250, 250, 250);

0 comments on commit 3993093

Please sign in to comment.
You can’t perform that action at this time.