paysages : Factorizing noise random pool (WIP).

git-svn-id: https://subversion.assembla.com/svn/thunderk/paysages@273 b1fd45b6-86a6-48da-8261-f70d1f35bdcc
This commit is contained in:
Michaël Lemaire 2012-02-27 15:25:12 +00:00 committed by ThunderK
parent 58605687e2
commit 418fe54b26
7 changed files with 149 additions and 131 deletions

View file

@ -45,7 +45,7 @@ void cloudsSave(FILE* f, CloudsDefinition* definition)
toolsSaveDouble(f, &layer->ycenter); toolsSaveDouble(f, &layer->ycenter);
toolsSaveDouble(f, &layer->ymin); toolsSaveDouble(f, &layer->ymin);
toolsSaveDouble(f, &layer->ymax); toolsSaveDouble(f, &layer->ymax);
noiseSave(f, layer->noise); noiseSaveGenerator(f, layer->noise);
materialSave(f, &layer->material); materialSave(f, &layer->material);
toolsSaveDouble(f, &layer->transparencydepth); toolsSaveDouble(f, &layer->transparencydepth);
toolsSaveDouble(f, &layer->lighttraversal); toolsSaveDouble(f, &layer->lighttraversal);
@ -73,7 +73,7 @@ void cloudsLoad(FILE* f, CloudsDefinition* definition)
toolsLoadDouble(f, &layer->ycenter); toolsLoadDouble(f, &layer->ycenter);
toolsLoadDouble(f, &layer->ymin); toolsLoadDouble(f, &layer->ymin);
toolsLoadDouble(f, &layer->ymax); toolsLoadDouble(f, &layer->ymax);
noiseLoad(f, layer->noise); noiseLoadGenerator(f, layer->noise);
materialLoad(f, &layer->material); materialLoad(f, &layer->material);
toolsLoadDouble(f, &layer->transparencydepth); toolsLoadDouble(f, &layer->transparencydepth);
toolsLoadDouble(f, &layer->lighttraversal); toolsLoadDouble(f, &layer->lighttraversal);

View file

@ -13,17 +13,60 @@ struct NoiseGenerator
int size1; int size1;
int size2; int size2;
int size3; int size3;
double* noise;
double height_offset; double height_offset;
int level_count; int level_count;
struct NoiseLevel* levels; struct NoiseLevel* levels;
}; };
static int _noise_pool_size;
static double* _noise_pool;
static inline double _cubicInterpolate(double* p, double x) static inline double _cubicInterpolate(double* p, double x)
{ {
return p[1] + 0.5 * x * (p[2] - p[0] + x * (2.0 * p[0] - 5.0 * p[1] + 4.0 * p[2] - p[3] + x * (3.0 * (p[1] - p[2]) + p[3] - p[0]))); return p[1] + 0.5 * x * (p[2] - p[0] + x * (2.0 * p[0] - 5.0 * p[1] + 4.0 * p[2] - p[3] + x * (3.0 * (p[1] - p[2]) + p[3] - p[0])));
} }
void noiseInit()
{
int i;
_noise_pool_size = 1048576;
_noise_pool = malloc(sizeof(double) * _noise_pool_size);
for (i = 0; i < _noise_pool_size; i++)
{
_noise_pool[i] = toolsRandom() - 0.5;
}
}
void noiseQuit()
{
free(_noise_pool);
}
void noiseSave(FILE* f)
{
int i;
toolsSaveInt(f, &_noise_pool_size);
for (i = 0; i < _noise_pool_size; i++)
{
toolsSaveDouble(f, _noise_pool + i);
}
}
void noiseLoad(FILE* f)
{
int i;
toolsLoadInt(f, &_noise_pool_size);
_noise_pool = realloc(_noise_pool, sizeof(double) * _noise_pool_size);
for (i = 0; i < _noise_pool_size; i++)
{
toolsLoadDouble(f, _noise_pool + i);
}
}
NoiseGenerator* noiseCreateGenerator() NoiseGenerator* noiseCreateGenerator()
{ {
NoiseGenerator* result; NoiseGenerator* result;
@ -33,8 +76,6 @@ NoiseGenerator* noiseCreateGenerator()
result->size1 = 1; result->size1 = 1;
result->size2 = 1; result->size2 = 1;
result->size3 = 1; result->size3 = 1;
result->noise = malloc(sizeof(double));
result->noise[0] = 0.0;
result->level_count = 0; result->level_count = 0;
result->levels = malloc(sizeof(NoiseLevel)); result->levels = malloc(sizeof(NoiseLevel));
result->height_offset = 0.0; result->height_offset = 0.0;
@ -44,15 +85,13 @@ NoiseGenerator* noiseCreateGenerator()
void noiseDeleteGenerator(NoiseGenerator* generator) void noiseDeleteGenerator(NoiseGenerator* generator)
{ {
free(generator->noise);
free(generator->levels); free(generator->levels);
free(generator); free(generator);
} }
void noiseSave(FILE* f, NoiseGenerator* perlin) void noiseSaveGenerator(FILE* f, NoiseGenerator* perlin)
{ {
int x; int x;
double* it_noise;
toolsSaveInt(f, &perlin->size1); toolsSaveInt(f, &perlin->size1);
toolsSaveInt(f, &perlin->size2); toolsSaveInt(f, &perlin->size2);
@ -60,12 +99,6 @@ void noiseSave(FILE* f, NoiseGenerator* perlin)
toolsSaveDouble(f, &perlin->height_offset); toolsSaveDouble(f, &perlin->height_offset);
toolsSaveInt(f, &perlin->level_count); toolsSaveInt(f, &perlin->level_count);
it_noise = perlin->noise;
for (x = 0; x < perlin->size1; x++)
{
toolsSaveDouble(f, it_noise++);
}
for (x = 0; x < perlin->level_count; x++) for (x = 0; x < perlin->level_count; x++)
{ {
NoiseLevel* level = perlin->levels + x; NoiseLevel* level = perlin->levels + x;
@ -78,10 +111,9 @@ void noiseSave(FILE* f, NoiseGenerator* perlin)
} }
} }
void noiseLoad(FILE* f, NoiseGenerator* perlin) void noiseLoadGenerator(FILE* f, NoiseGenerator* perlin)
{ {
int x; int x;
double* it_noise;
toolsLoadInt(f, &perlin->size1); toolsLoadInt(f, &perlin->size1);
toolsLoadInt(f, &perlin->size2); toolsLoadInt(f, &perlin->size2);
@ -89,13 +121,6 @@ void noiseLoad(FILE* f, NoiseGenerator* perlin)
toolsLoadDouble(f, &perlin->height_offset); toolsLoadDouble(f, &perlin->height_offset);
toolsLoadInt(f, &perlin->level_count); toolsLoadInt(f, &perlin->level_count);
perlin->noise = realloc(perlin->noise, sizeof(double) * perlin->size1);
it_noise = perlin->noise;
for (x = 0; x < perlin->size1; x++)
{
toolsLoadDouble(f, it_noise++);
}
perlin->levels = realloc(perlin->levels, sizeof(NoiseLevel) * perlin->level_count); perlin->levels = realloc(perlin->levels, sizeof(NoiseLevel) * perlin->level_count);
for (x = 0; x < perlin->level_count; x++) for (x = 0; x < perlin->level_count; x++)
{ {
@ -117,31 +142,18 @@ void noiseCopy(NoiseGenerator* source, NoiseGenerator* destination)
destination->height_offset = source->height_offset; destination->height_offset = source->height_offset;
destination->level_count = source->level_count; destination->level_count = source->level_count;
destination->noise = realloc(destination->noise, sizeof(double) * destination->size1);
memcpy(destination->noise, source->noise, sizeof(double) * destination->size1);
destination->levels = realloc(destination->levels, sizeof(NoiseLevel) * destination->level_count); destination->levels = realloc(destination->levels, sizeof(NoiseLevel) * destination->level_count);
memcpy(destination->levels, source->levels, sizeof(NoiseLevel) * destination->level_count); memcpy(destination->levels, source->levels, sizeof(NoiseLevel) * destination->level_count);
} }
void noiseGenerateBaseNoise(NoiseGenerator* generator, int size) void noiseGenerateBaseNoise(NoiseGenerator* generator, int size)
{ {
int x;
double* it_noise;
size = (size < 1) ? 1 : size; size = (size < 1) ? 1 : size;
size = (size > 4000000) ? 4000000 : size; size = (size > 4000000) ? 4000000 : size;
generator->size1 = size; generator->size1 = size;
generator->size2 = (int)floor(sqrt((float)size)); generator->size2 = (int)floor(sqrt((float)size));
generator->size3 = (int)floor(cbrt((float)size)); generator->size3 = (int)floor(cbrt((float)size));
generator->noise = realloc(generator->noise, sizeof(double) * size);
it_noise = generator->noise;
for (x = 0; x < size; x++)
{
*(it_noise++) = toolsRandom() - 0.5;
}
} }
int noiseGetBaseSize(NoiseGenerator* generator) int noiseGetBaseSize(NoiseGenerator* generator)
@ -296,7 +308,6 @@ void noiseNormalizeHeight(NoiseGenerator* generator, double min_height, double m
static inline double _get1DRawNoiseValue(NoiseGenerator* generator, double x) static inline double _get1DRawNoiseValue(NoiseGenerator* generator, double x)
{ {
double* noise = generator->noise;
int size = generator->size1; int size = generator->size1;
int xbase = (int)floor(x); int xbase = (int)floor(x);
@ -326,10 +337,10 @@ static inline double _get1DRawNoiseValue(NoiseGenerator* generator, double x)
double buf_cubic_x[4]; double buf_cubic_x[4];
buf_cubic_x[0] = noise[x0]; buf_cubic_x[0] = _noise_pool[x0 % _noise_pool_size];
buf_cubic_x[1] = noise[x1]; buf_cubic_x[1] = _noise_pool[x1 % _noise_pool_size];
buf_cubic_x[2] = noise[x2]; buf_cubic_x[2] = _noise_pool[x2 % _noise_pool_size];
buf_cubic_x[3] = noise[x3]; buf_cubic_x[3] = _noise_pool[x3 % _noise_pool_size];
return _cubicInterpolate(buf_cubic_x, xinternal); return _cubicInterpolate(buf_cubic_x, xinternal);
} }
@ -393,7 +404,6 @@ double noiseGet1DDetail(NoiseGenerator* generator, double x, double detail)
static inline double _get2DRawNoiseValue(NoiseGenerator* generator, double x, double y) static inline double _get2DRawNoiseValue(NoiseGenerator* generator, double x, double y)
{ {
double* noise = generator->noise;
int size = generator->size2; int size = generator->size2;
int xbase = (int)floor(x); int xbase = (int)floor(x);
@ -447,28 +457,28 @@ static inline double _get2DRawNoiseValue(NoiseGenerator* generator, double x, do
double buf_cubic_x[4]; double buf_cubic_x[4];
double buf_cubic_y[4]; double buf_cubic_y[4];
buf_cubic_x[0] = noise[y0 * size + x0]; buf_cubic_x[0] = _noise_pool[(y0 * size + x0) % _noise_pool_size];
buf_cubic_x[1] = noise[y0 * size + x1]; buf_cubic_x[1] = _noise_pool[(y0 * size + x1) % _noise_pool_size];
buf_cubic_x[2] = noise[y0 * size + x2]; buf_cubic_x[2] = _noise_pool[(y0 * size + x2) % _noise_pool_size];
buf_cubic_x[3] = noise[y0 * size + x3]; buf_cubic_x[3] = _noise_pool[(y0 * size + x3) % _noise_pool_size];
buf_cubic_y[0] = _cubicInterpolate(buf_cubic_x, xinternal); buf_cubic_y[0] = _cubicInterpolate(buf_cubic_x, xinternal);
buf_cubic_x[0] = noise[y1 * size + x0]; buf_cubic_x[0] = _noise_pool[(y1 * size + x0) % _noise_pool_size];
buf_cubic_x[1] = noise[y1 * size + x1]; buf_cubic_x[1] = _noise_pool[(y1 * size + x1) % _noise_pool_size];
buf_cubic_x[2] = noise[y1 * size + x2]; buf_cubic_x[2] = _noise_pool[(y1 * size + x2) % _noise_pool_size];
buf_cubic_x[3] = noise[y1 * size + x3]; buf_cubic_x[3] = _noise_pool[(y1 * size + x3) % _noise_pool_size];
buf_cubic_y[1] = _cubicInterpolate(buf_cubic_x, xinternal); buf_cubic_y[1] = _cubicInterpolate(buf_cubic_x, xinternal);
buf_cubic_x[0] = noise[y2 * size + x0]; buf_cubic_x[0] = _noise_pool[(y2 * size + x0) % _noise_pool_size];
buf_cubic_x[1] = noise[y2 * size + x1]; buf_cubic_x[1] = _noise_pool[(y2 * size + x1) % _noise_pool_size];
buf_cubic_x[2] = noise[y2 * size + x2]; buf_cubic_x[2] = _noise_pool[(y2 * size + x2) % _noise_pool_size];
buf_cubic_x[3] = noise[y2 * size + x3]; buf_cubic_x[3] = _noise_pool[(y2 * size + x3) % _noise_pool_size];
buf_cubic_y[2] = _cubicInterpolate(buf_cubic_x, xinternal); buf_cubic_y[2] = _cubicInterpolate(buf_cubic_x, xinternal);
buf_cubic_x[0] = noise[y3 * size + x0]; buf_cubic_x[0] = _noise_pool[(y3 * size + x0) % _noise_pool_size];
buf_cubic_x[1] = noise[y3 * size + x1]; buf_cubic_x[1] = _noise_pool[(y3 * size + x1) % _noise_pool_size];
buf_cubic_x[2] = noise[y3 * size + x2]; buf_cubic_x[2] = _noise_pool[(y3 * size + x2) % _noise_pool_size];
buf_cubic_x[3] = noise[y3 * size + x3]; buf_cubic_x[3] = _noise_pool[(y3 * size + x3) % _noise_pool_size];
buf_cubic_y[3] = _cubicInterpolate(buf_cubic_x, xinternal); buf_cubic_y[3] = _cubicInterpolate(buf_cubic_x, xinternal);
return _cubicInterpolate(buf_cubic_y, yinternal); return _cubicInterpolate(buf_cubic_y, yinternal);
@ -533,7 +543,6 @@ double noiseGet2DDetail(NoiseGenerator* generator, double x, double y, double de
static inline double _get3DRawNoiseValue(NoiseGenerator* generator, double x, double y, double z) static inline double _get3DRawNoiseValue(NoiseGenerator* generator, double x, double y, double z)
{ {
double* noise = generator->noise;
int size = generator->size3; int size = generator->size3;
int xbase = (int)floor(x); int xbase = (int)floor(x);
@ -611,106 +620,106 @@ static inline double _get3DRawNoiseValue(NoiseGenerator* generator, double x, do
double buf_cubic_y[4]; double buf_cubic_y[4];
double buf_cubic_z[4]; double buf_cubic_z[4];
buf_cubic_x[0] = noise[y0 * size * size + x0 * size + z0]; buf_cubic_x[0] = _noise_pool[(y0 * size * size + x0 * size + z0) % _noise_pool_size];
buf_cubic_x[1] = noise[y0 * size * size + x1 * size + z0]; buf_cubic_x[1] = _noise_pool[(y0 * size * size + x1 * size + z0) % _noise_pool_size];
buf_cubic_x[2] = noise[y0 * size * size + x2 * size + z0]; buf_cubic_x[2] = _noise_pool[(y0 * size * size + x2 * size + z0) % _noise_pool_size];
buf_cubic_x[3] = noise[y0 * size * size + x3 * size + z0]; buf_cubic_x[3] = _noise_pool[(y0 * size * size + x3 * size + z0) % _noise_pool_size];
buf_cubic_y[0] = _cubicInterpolate(buf_cubic_x, xinternal); buf_cubic_y[0] = _cubicInterpolate(buf_cubic_x, xinternal);
buf_cubic_x[0] = noise[y1 * size * size + x0 * size + z0]; buf_cubic_x[0] = _noise_pool[(y1 * size * size + x0 * size + z0) % _noise_pool_size];
buf_cubic_x[1] = noise[y1 * size * size + x1 * size + z0]; buf_cubic_x[1] = _noise_pool[(y1 * size * size + x1 * size + z0) % _noise_pool_size];
buf_cubic_x[2] = noise[y1 * size * size + x2 * size + z0]; buf_cubic_x[2] = _noise_pool[(y1 * size * size + x2 * size + z0) % _noise_pool_size];
buf_cubic_x[3] = noise[y1 * size * size + x3 * size + z0]; buf_cubic_x[3] = _noise_pool[(y1 * size * size + x3 * size + z0) % _noise_pool_size];
buf_cubic_y[1] = _cubicInterpolate(buf_cubic_x, xinternal); buf_cubic_y[1] = _cubicInterpolate(buf_cubic_x, xinternal);
buf_cubic_x[0] = noise[y2 * size * size + x0 * size + z0]; buf_cubic_x[0] = _noise_pool[(y2 * size * size + x0 * size + z0) % _noise_pool_size];
buf_cubic_x[1] = noise[y2 * size * size + x1 * size + z0]; buf_cubic_x[1] = _noise_pool[(y2 * size * size + x1 * size + z0) % _noise_pool_size];
buf_cubic_x[2] = noise[y2 * size * size + x2 * size + z0]; buf_cubic_x[2] = _noise_pool[(y2 * size * size + x2 * size + z0) % _noise_pool_size];
buf_cubic_x[3] = noise[y2 * size * size + x3 * size + z0]; buf_cubic_x[3] = _noise_pool[(y2 * size * size + x3 * size + z0) % _noise_pool_size];
buf_cubic_y[2] = _cubicInterpolate(buf_cubic_x, xinternal); buf_cubic_y[2] = _cubicInterpolate(buf_cubic_x, xinternal);
buf_cubic_x[0] = noise[y3 * size * size + x0 * size + z0]; buf_cubic_x[0] = _noise_pool[(y3 * size * size + x0 * size + z0) % _noise_pool_size];
buf_cubic_x[1] = noise[y3 * size * size + x1 * size + z0]; buf_cubic_x[1] = _noise_pool[(y3 * size * size + x1 * size + z0) % _noise_pool_size];
buf_cubic_x[2] = noise[y3 * size * size + x2 * size + z0]; buf_cubic_x[2] = _noise_pool[(y3 * size * size + x2 * size + z0) % _noise_pool_size];
buf_cubic_x[3] = noise[y3 * size * size + x3 * size + z0]; buf_cubic_x[3] = _noise_pool[(y3 * size * size + x3 * size + z0) % _noise_pool_size];
buf_cubic_y[3] = _cubicInterpolate(buf_cubic_x, xinternal); buf_cubic_y[3] = _cubicInterpolate(buf_cubic_x, xinternal);
buf_cubic_z[0] = _cubicInterpolate(buf_cubic_y, yinternal); buf_cubic_z[0] = _cubicInterpolate(buf_cubic_y, yinternal);
buf_cubic_x[0] = noise[y0 * size * size + x0 * size + z1]; buf_cubic_x[0] = _noise_pool[(y0 * size * size + x0 * size + z1) % _noise_pool_size];
buf_cubic_x[1] = noise[y0 * size * size + x1 * size + z1]; buf_cubic_x[1] = _noise_pool[(y0 * size * size + x1 * size + z1) % _noise_pool_size];
buf_cubic_x[2] = noise[y0 * size * size + x2 * size + z1]; buf_cubic_x[2] = _noise_pool[(y0 * size * size + x2 * size + z1) % _noise_pool_size];
buf_cubic_x[3] = noise[y0 * size * size + x3 * size + z1]; buf_cubic_x[3] = _noise_pool[(y0 * size * size + x3 * size + z1) % _noise_pool_size];
buf_cubic_y[0] = _cubicInterpolate(buf_cubic_x, xinternal); buf_cubic_y[0] = _cubicInterpolate(buf_cubic_x, xinternal);
buf_cubic_x[0] = noise[y1 * size * size + x0 * size + z1]; buf_cubic_x[0] = _noise_pool[(y1 * size * size + x0 * size + z1) % _noise_pool_size];
buf_cubic_x[1] = noise[y1 * size * size + x1 * size + z1]; buf_cubic_x[1] = _noise_pool[(y1 * size * size + x1 * size + z1) % _noise_pool_size];
buf_cubic_x[2] = noise[y1 * size * size + x2 * size + z1]; buf_cubic_x[2] = _noise_pool[(y1 * size * size + x2 * size + z1) % _noise_pool_size];
buf_cubic_x[3] = noise[y1 * size * size + x3 * size + z1]; buf_cubic_x[3] = _noise_pool[(y1 * size * size + x3 * size + z1) % _noise_pool_size];
buf_cubic_y[1] = _cubicInterpolate(buf_cubic_x, xinternal); buf_cubic_y[1] = _cubicInterpolate(buf_cubic_x, xinternal);
buf_cubic_x[0] = noise[y2 * size * size + x0 * size + z1]; buf_cubic_x[0] = _noise_pool[(y2 * size * size + x0 * size + z1) % _noise_pool_size];
buf_cubic_x[1] = noise[y2 * size * size + x1 * size + z1]; buf_cubic_x[1] = _noise_pool[(y2 * size * size + x1 * size + z1) % _noise_pool_size];
buf_cubic_x[2] = noise[y2 * size * size + x2 * size + z1]; buf_cubic_x[2] = _noise_pool[(y2 * size * size + x2 * size + z1) % _noise_pool_size];
buf_cubic_x[3] = noise[y2 * size * size + x3 * size + z1]; buf_cubic_x[3] = _noise_pool[(y2 * size * size + x3 * size + z1) % _noise_pool_size];
buf_cubic_y[2] = _cubicInterpolate(buf_cubic_x, xinternal); buf_cubic_y[2] = _cubicInterpolate(buf_cubic_x, xinternal);
buf_cubic_x[0] = noise[y3 * size * size + x0 * size + z1]; buf_cubic_x[0] = _noise_pool[(y3 * size * size + x0 * size + z1) % _noise_pool_size];
buf_cubic_x[1] = noise[y3 * size * size + x1 * size + z1]; buf_cubic_x[1] = _noise_pool[(y3 * size * size + x1 * size + z1) % _noise_pool_size];
buf_cubic_x[2] = noise[y3 * size * size + x2 * size + z1]; buf_cubic_x[2] = _noise_pool[(y3 * size * size + x2 * size + z1) % _noise_pool_size];
buf_cubic_x[3] = noise[y3 * size * size + x3 * size + z1]; buf_cubic_x[3] = _noise_pool[(y3 * size * size + x3 * size + z1) % _noise_pool_size];
buf_cubic_y[3] = _cubicInterpolate(buf_cubic_x, xinternal); buf_cubic_y[3] = _cubicInterpolate(buf_cubic_x, xinternal);
buf_cubic_z[1] = _cubicInterpolate(buf_cubic_y, yinternal); buf_cubic_z[1] = _cubicInterpolate(buf_cubic_y, yinternal);
buf_cubic_x[0] = noise[y0 * size * size + x0 * size + z2]; buf_cubic_x[0] = _noise_pool[(y0 * size * size + x0 * size + z2) % _noise_pool_size];
buf_cubic_x[1] = noise[y0 * size * size + x1 * size + z2]; buf_cubic_x[1] = _noise_pool[(y0 * size * size + x1 * size + z2) % _noise_pool_size];
buf_cubic_x[2] = noise[y0 * size * size + x2 * size + z2]; buf_cubic_x[2] = _noise_pool[(y0 * size * size + x2 * size + z2) % _noise_pool_size];
buf_cubic_x[3] = noise[y0 * size * size + x3 * size + z2]; buf_cubic_x[3] = _noise_pool[(y0 * size * size + x3 * size + z2) % _noise_pool_size];
buf_cubic_y[0] = _cubicInterpolate(buf_cubic_x, xinternal); buf_cubic_y[0] = _cubicInterpolate(buf_cubic_x, xinternal);
buf_cubic_x[0] = noise[y1 * size * size + x0 * size + z2]; buf_cubic_x[0] = _noise_pool[(y1 * size * size + x0 * size + z2) % _noise_pool_size];
buf_cubic_x[1] = noise[y1 * size * size + x1 * size + z2]; buf_cubic_x[1] = _noise_pool[(y1 * size * size + x1 * size + z2) % _noise_pool_size];
buf_cubic_x[2] = noise[y1 * size * size + x2 * size + z2]; buf_cubic_x[2] = _noise_pool[(y1 * size * size + x2 * size + z2) % _noise_pool_size];
buf_cubic_x[3] = noise[y1 * size * size + x3 * size + z2]; buf_cubic_x[3] = _noise_pool[(y1 * size * size + x3 * size + z2) % _noise_pool_size];
buf_cubic_y[1] = _cubicInterpolate(buf_cubic_x, xinternal); buf_cubic_y[1] = _cubicInterpolate(buf_cubic_x, xinternal);
buf_cubic_x[0] = noise[y2 * size * size + x0 * size + z2]; buf_cubic_x[0] = _noise_pool[(y2 * size * size + x0 * size + z2) % _noise_pool_size];
buf_cubic_x[1] = noise[y2 * size * size + x1 * size + z2]; buf_cubic_x[1] = _noise_pool[(y2 * size * size + x1 * size + z2) % _noise_pool_size];
buf_cubic_x[2] = noise[y2 * size * size + x2 * size + z2]; buf_cubic_x[2] = _noise_pool[(y2 * size * size + x2 * size + z2) % _noise_pool_size];
buf_cubic_x[3] = noise[y2 * size * size + x3 * size + z2]; buf_cubic_x[3] = _noise_pool[(y2 * size * size + x3 * size + z2) % _noise_pool_size];
buf_cubic_y[2] = _cubicInterpolate(buf_cubic_x, xinternal); buf_cubic_y[2] = _cubicInterpolate(buf_cubic_x, xinternal);
buf_cubic_x[0] = noise[y3 * size * size + x0 * size + z2]; buf_cubic_x[0] = _noise_pool[(y3 * size * size + x0 * size + z2) % _noise_pool_size];
buf_cubic_x[1] = noise[y3 * size * size + x1 * size + z2]; buf_cubic_x[1] = _noise_pool[(y3 * size * size + x1 * size + z2) % _noise_pool_size];
buf_cubic_x[2] = noise[y3 * size * size + x2 * size + z2]; buf_cubic_x[2] = _noise_pool[(y3 * size * size + x2 * size + z2) % _noise_pool_size];
buf_cubic_x[3] = noise[y3 * size * size + x3 * size + z2]; buf_cubic_x[3] = _noise_pool[(y3 * size * size + x3 * size + z2) % _noise_pool_size];
buf_cubic_y[3] = _cubicInterpolate(buf_cubic_x, xinternal); buf_cubic_y[3] = _cubicInterpolate(buf_cubic_x, xinternal);
buf_cubic_z[2] = _cubicInterpolate(buf_cubic_y, yinternal); buf_cubic_z[2] = _cubicInterpolate(buf_cubic_y, yinternal);
buf_cubic_x[0] = noise[y0 * size * size + x0 * size + z3]; buf_cubic_x[0] = _noise_pool[(y0 * size * size + x0 * size + z3) % _noise_pool_size];
buf_cubic_x[1] = noise[y0 * size * size + x1 * size + z3]; buf_cubic_x[1] = _noise_pool[(y0 * size * size + x1 * size + z3) % _noise_pool_size];
buf_cubic_x[2] = noise[y0 * size * size + x2 * size + z3]; buf_cubic_x[2] = _noise_pool[(y0 * size * size + x2 * size + z3) % _noise_pool_size];
buf_cubic_x[3] = noise[y0 * size * size + x3 * size + z3]; buf_cubic_x[3] = _noise_pool[(y0 * size * size + x3 * size + z3) % _noise_pool_size];
buf_cubic_y[0] = _cubicInterpolate(buf_cubic_x, xinternal); buf_cubic_y[0] = _cubicInterpolate(buf_cubic_x, xinternal);
buf_cubic_x[0] = noise[y1 * size * size + x0 * size + z3]; buf_cubic_x[0] = _noise_pool[(y1 * size * size + x0 * size + z3) % _noise_pool_size];
buf_cubic_x[1] = noise[y1 * size * size + x1 * size + z3]; buf_cubic_x[1] = _noise_pool[(y1 * size * size + x1 * size + z3) % _noise_pool_size];
buf_cubic_x[2] = noise[y1 * size * size + x2 * size + z3]; buf_cubic_x[2] = _noise_pool[(y1 * size * size + x2 * size + z3) % _noise_pool_size];
buf_cubic_x[3] = noise[y1 * size * size + x3 * size + z3]; buf_cubic_x[3] = _noise_pool[(y1 * size * size + x3 * size + z3) % _noise_pool_size];
buf_cubic_y[1] = _cubicInterpolate(buf_cubic_x, xinternal); buf_cubic_y[1] = _cubicInterpolate(buf_cubic_x, xinternal);
buf_cubic_x[0] = noise[y2 * size * size + x0 * size + z3]; buf_cubic_x[0] = _noise_pool[(y2 * size * size + x0 * size + z3) % _noise_pool_size];
buf_cubic_x[1] = noise[y2 * size * size + x1 * size + z3]; buf_cubic_x[1] = _noise_pool[(y2 * size * size + x1 * size + z3) % _noise_pool_size];
buf_cubic_x[2] = noise[y2 * size * size + x2 * size + z3]; buf_cubic_x[2] = _noise_pool[(y2 * size * size + x2 * size + z3) % _noise_pool_size];
buf_cubic_x[3] = noise[y2 * size * size + x3 * size + z3]; buf_cubic_x[3] = _noise_pool[(y2 * size * size + x3 * size + z3) % _noise_pool_size];
buf_cubic_y[2] = _cubicInterpolate(buf_cubic_x, xinternal); buf_cubic_y[2] = _cubicInterpolate(buf_cubic_x, xinternal);
buf_cubic_x[0] = noise[y3 * size * size + x0 * size + z3]; buf_cubic_x[0] = _noise_pool[(y3 * size * size + x0 * size + z3) % _noise_pool_size];
buf_cubic_x[1] = noise[y3 * size * size + x1 * size + z3]; buf_cubic_x[1] = _noise_pool[(y3 * size * size + x1 * size + z3) % _noise_pool_size];
buf_cubic_x[2] = noise[y3 * size * size + x2 * size + z3]; buf_cubic_x[2] = _noise_pool[(y3 * size * size + x2 * size + z3) % _noise_pool_size];
buf_cubic_x[3] = noise[y3 * size * size + x3 * size + z3]; buf_cubic_x[3] = _noise_pool[(y3 * size * size + x3 * size + z3) % _noise_pool_size];
buf_cubic_y[3] = _cubicInterpolate(buf_cubic_x, xinternal); buf_cubic_y[3] = _cubicInterpolate(buf_cubic_x, xinternal);
buf_cubic_z[3] = _cubicInterpolate(buf_cubic_y, yinternal); buf_cubic_z[3] = _cubicInterpolate(buf_cubic_y, yinternal);

View file

@ -18,10 +18,15 @@ struct NoiseLevel
typedef struct NoiseLevel NoiseLevel; typedef struct NoiseLevel NoiseLevel;
typedef struct NoiseGenerator NoiseGenerator; typedef struct NoiseGenerator NoiseGenerator;
void noiseInit();
void noiseQuit();
void noiseSave(FILE* f);
void noiseLoad(FILE* f);
NoiseGenerator* noiseCreateGenerator(); NoiseGenerator* noiseCreateGenerator();
void noiseDeleteGenerator(NoiseGenerator* generator); void noiseDeleteGenerator(NoiseGenerator* generator);
void noiseSave(FILE* f, NoiseGenerator* perlin); void noiseSaveGenerator(FILE* f, NoiseGenerator* perlin);
void noiseLoad(FILE* f, NoiseGenerator* perlin); void noiseLoadGenerator(FILE* f, NoiseGenerator* perlin);
void noiseCopy(NoiseGenerator* source, NoiseGenerator* destination); void noiseCopy(NoiseGenerator* source, NoiseGenerator* destination);
void noiseGenerateBaseNoise(NoiseGenerator* generator, int size); void noiseGenerateBaseNoise(NoiseGenerator* generator, int size);
int noiseGetBaseSize(NoiseGenerator* generator); int noiseGetBaseSize(NoiseGenerator* generator);

View file

@ -17,6 +17,7 @@ WaterDefinition _water;
void sceneryInit() void sceneryInit()
{ {
noiseInit();
atmosphereInit(); atmosphereInit();
cameraInit(); cameraInit();
cloudsInit(); cloudsInit();
@ -55,12 +56,14 @@ void sceneryQuit()
terrainQuit(); terrainQuit();
texturesQuit(); texturesQuit();
waterQuit(); waterQuit();
noiseQuit();
} }
void scenerySaveToFile(char* filepath) void scenerySaveToFile(char* filepath)
{ {
FILE* f = fopen(filepath, "wb"); FILE* f = fopen(filepath, "wb");
noiseSave(f);
atmosphereSave(f, &_atmosphere); atmosphereSave(f, &_atmosphere);
cameraSave(f, &_camera); cameraSave(f, &_camera);
cloudsSave(f, &_clouds); cloudsSave(f, &_clouds);
@ -80,6 +83,7 @@ void sceneryLoadFromFile(char* filepath)
/* TODO Use intermediary definitions ? */ /* TODO Use intermediary definitions ? */
noiseLoad(f);
atmosphereLoad(f, &_atmosphere); atmosphereLoad(f, &_atmosphere);
cameraLoad(f, &_camera); cameraLoad(f, &_camera);
cloudsLoad(f, &_clouds); cloudsLoad(f, &_clouds);

View file

@ -25,7 +25,7 @@ void terrainSave(FILE* f, TerrainDefinition* definition)
{ {
int i; int i;
noiseSave(f, definition->height_noise); noiseSaveGenerator(f, definition->height_noise);
toolsSaveDouble(f, &definition->height_factor); toolsSaveDouble(f, &definition->height_factor);
toolsSaveDouble(f, &definition->scaling); toolsSaveDouble(f, &definition->scaling);
@ -41,7 +41,7 @@ void terrainLoad(FILE* f, TerrainDefinition* definition)
int i, n; int i, n;
HeightModifier* modifier; HeightModifier* modifier;
noiseLoad(f, definition->height_noise); noiseLoadGenerator(f, definition->height_noise);
toolsLoadDouble(f, &definition->height_factor); toolsLoadDouble(f, &definition->height_factor);
toolsLoadDouble(f, &definition->scaling); toolsLoadDouble(f, &definition->scaling);

View file

@ -33,7 +33,7 @@ void texturesSave(FILE* f, TexturesDefinition* definition)
for (i = 0; i < definition->nbtextures; i++) for (i = 0; i < definition->nbtextures; i++)
{ {
zoneSave(f, definition->textures[i].zone); zoneSave(f, definition->textures[i].zone);
noiseSave(f, definition->textures[i].bump_noise); noiseSaveGenerator(f, definition->textures[i].bump_noise);
colorSave(f, &definition->textures[i].color); colorSave(f, &definition->textures[i].color);
} }
} }
@ -54,7 +54,7 @@ void texturesLoad(FILE* f, TexturesDefinition* definition)
layer = definition->textures + texturesAddLayer(definition); layer = definition->textures + texturesAddLayer(definition);
zoneLoad(f, layer->zone); zoneLoad(f, layer->zone);
noiseLoad(f, layer->bump_noise); noiseLoadGenerator(f, layer->bump_noise);
colorLoad(f, &layer->color); colorLoad(f, &layer->color);
} }

View file

@ -28,7 +28,7 @@ void waterSave(FILE* f, WaterDefinition* definition)
toolsSaveDouble(f, &definition->transparency); toolsSaveDouble(f, &definition->transparency);
toolsSaveDouble(f, &definition->reflection); toolsSaveDouble(f, &definition->reflection);
toolsSaveDouble(f, &definition->lighting_depth); toolsSaveDouble(f, &definition->lighting_depth);
noiseSave(f, definition->waves_noise); noiseSaveGenerator(f, definition->waves_noise);
toolsSaveDouble(f, &definition->waves_noise_height); toolsSaveDouble(f, &definition->waves_noise_height);
toolsSaveDouble(f, &definition->waves_noise_scale); toolsSaveDouble(f, &definition->waves_noise_scale);
} }
@ -42,7 +42,7 @@ void waterLoad(FILE* f, WaterDefinition* definition)
toolsLoadDouble(f, &definition->transparency); toolsLoadDouble(f, &definition->transparency);
toolsLoadDouble(f, &definition->reflection); toolsLoadDouble(f, &definition->reflection);
toolsLoadDouble(f, &definition->lighting_depth); toolsLoadDouble(f, &definition->lighting_depth);
noiseLoad(f, definition->waves_noise); noiseLoadGenerator(f, definition->waves_noise);
toolsLoadDouble(f, &definition->waves_noise_height); toolsLoadDouble(f, &definition->waves_noise_height);
toolsLoadDouble(f, &definition->waves_noise_scale); toolsLoadDouble(f, &definition->waves_noise_scale);