graphics/paysages3d
1
0
Fork 0
Code Releases Activity

paysages : Factorizing noise random pool (WIP).

Browse source 
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
Show stats Download patch file Download diff file Expand all files Collapse all files

4
lib_paysages/clouds.c
View file

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

251
lib_paysages/noise.c
View file

@ -13,17 +13,60 @@ struct NoiseGenerator
int size1;
int size2;
int size3;
double* noise;
double height_offset;
int level_count;
struct NoiseLevel* levels;
};
static int _noise_pool_size;
static double* _noise_pool;
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])));
}
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* result;
@ -33,8 +76,6 @@ NoiseGenerator* noiseCreateGenerator()
result->size1 = 1;
result->size2 = 1;
result->size3 = 1;
result->noise = malloc(sizeof(double));
result->noise[0] = 0.0;
result->level_count = 0;
result->levels = malloc(sizeof(NoiseLevel));
result->height_offset = 0.0;
@ -44,15 +85,13 @@ NoiseGenerator* noiseCreateGenerator()
void noiseDeleteGenerator(NoiseGenerator* generator)
{
free(generator->noise);
free(generator->levels);
free(generator);
}
void noiseSave(FILE* f, NoiseGenerator* perlin)
void noiseSaveGenerator(FILE* f, NoiseGenerator* perlin)
{
int x;
double* it_noise;
toolsSaveInt(f, &perlin->size1);
toolsSaveInt(f, &perlin->size2);
@ -60,12 +99,6 @@ void noiseSave(FILE* f, NoiseGenerator* perlin)
toolsSaveDouble(f, &perlin->height_offset);
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++)
{
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;
double* it_noise;
toolsLoadInt(f, &perlin->size1);
toolsLoadInt(f, &perlin->size2);
@ -89,13 +121,6 @@ void noiseLoad(FILE* f, NoiseGenerator* perlin)
toolsLoadDouble(f, &perlin->height_offset);
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);
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->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);
memcpy(destination->levels, source->levels, sizeof(NoiseLevel) * destination->level_count);
}
void noiseGenerateBaseNoise(NoiseGenerator* generator, int size)
{
int x;
double* it_noise;
size = (size < 1) ? 1 : size;
size = (size > 4000000) ? 4000000 : size;
generator->size1 = size;
generator->size2 = (int)floor(sqrt((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)
@ -296,7 +308,6 @@ void noiseNormalizeHeight(NoiseGenerator* generator, double min_height, double m
static inline double _get1DRawNoiseValue(NoiseGenerator* generator, double x)
{
double* noise = generator->noise;
int size = generator->size1;
int xbase = (int)floor(x);
@ -326,10 +337,10 @@ static inline double _get1DRawNoiseValue(NoiseGenerator* generator, double x)
double buf_cubic_x[4];
buf_cubic_x[0] = noise[x0];
buf_cubic_x[1] = noise[x1];
buf_cubic_x[2] = noise[x2];
buf_cubic_x[3] = noise[x3];
buf_cubic_x[0] = _noise_pool[x0 % _noise_pool_size];
buf_cubic_x[1] = _noise_pool[x1 % _noise_pool_size];
buf_cubic_x[2] = _noise_pool[x2 % _noise_pool_size];
buf_cubic_x[3] = _noise_pool[x3 % _noise_pool_size];
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)
{
double* noise = generator->noise;
int size = generator->size2;
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_y[4];
buf_cubic_x[0] = noise[y0 * size + x0];
buf_cubic_x[1] = noise[y0 * size + x1];
buf_cubic_x[2] = noise[y0 * size + x2];
buf_cubic_x[3] = noise[y0 * size + x3];
buf_cubic_x[0] = _noise_pool[(y0 * size + x0) % _noise_pool_size];
buf_cubic_x[1] = _noise_pool[(y0 * size + x1) % _noise_pool_size];
buf_cubic_x[2] = _noise_pool[(y0 * size + x2) % _noise_pool_size];
buf_cubic_x[3] = _noise_pool[(y0 * size + x3) % _noise_pool_size];
buf_cubic_y[0] = _cubicInterpolate(buf_cubic_x, xinternal);
buf_cubic_x[0] = noise[y1 * size + x0];
buf_cubic_x[1] = noise[y1 * size + x1];
buf_cubic_x[2] = noise[y1 * size + x2];
buf_cubic_x[3] = noise[y1 * size + x3];
buf_cubic_x[0] = _noise_pool[(y1 * size + x0) % _noise_pool_size];
buf_cubic_x[1] = _noise_pool[(y1 * size + x1) % _noise_pool_size];
buf_cubic_x[2] = _noise_pool[(y1 * size + x2) % _noise_pool_size];
buf_cubic_x[3] = _noise_pool[(y1 * size + x3) % _noise_pool_size];
buf_cubic_y[1] = _cubicInterpolate(buf_cubic_x, xinternal);
buf_cubic_x[0] = noise[y2 * size + x0];
buf_cubic_x[1] = noise[y2 * size + x1];
buf_cubic_x[2] = noise[y2 * size + x2];
buf_cubic_x[3] = noise[y2 * size + x3];
buf_cubic_x[0] = _noise_pool[(y2 * size + x0) % _noise_pool_size];
buf_cubic_x[1] = _noise_pool[(y2 * size + x1) % _noise_pool_size];
buf_cubic_x[2] = _noise_pool[(y2 * size + x2) % _noise_pool_size];
buf_cubic_x[3] = _noise_pool[(y2 * size + x3) % _noise_pool_size];
buf_cubic_y[2] = _cubicInterpolate(buf_cubic_x, xinternal);
buf_cubic_x[0] = noise[y3 * size + x0];
buf_cubic_x[1] = noise[y3 * size + x1];
buf_cubic_x[2] = noise[y3 * size + x2];
buf_cubic_x[3] = noise[y3 * size + x3];
buf_cubic_x[0] = _noise_pool[(y3 * size + x0) % _noise_pool_size];
buf_cubic_x[1] = _noise_pool[(y3 * size + x1) % _noise_pool_size];
buf_cubic_x[2] = _noise_pool[(y3 * size + x2) % _noise_pool_size];
buf_cubic_x[3] = _noise_pool[(y3 * size + x3) % _noise_pool_size];
buf_cubic_y[3] = _cubicInterpolate(buf_cubic_x, xinternal);
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)
{
double* noise = generator->noise;
int size = generator->size3;
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_z[4];
buf_cubic_x[0] = noise[y0 * size * size + x0 * size + z0];
buf_cubic_x[1] = noise[y0 * size * size + x1 * size + z0];
buf_cubic_x[2] = noise[y0 * size * size + x2 * size + z0];
buf_cubic_x[3] = noise[y0 * size * size + x3 * size + z0];
buf_cubic_x[0] = _noise_pool[(y0 * size * size + x0 * size + z0) % _noise_pool_size];
buf_cubic_x[1] = _noise_pool[(y0 * size * size + x1 * size + z0) % _noise_pool_size];
buf_cubic_x[2] = _noise_pool[(y0 * size * size + x2 * size + z0) % _noise_pool_size];
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_x[0] = noise[y1 * size * size + x0 * size + z0];
buf_cubic_x[1] = noise[y1 * size * size + x1 * size + z0];
buf_cubic_x[2] = noise[y1 * size * size + x2 * size + z0];
buf_cubic_x[3] = noise[y1 * size * size + x3 * size + z0];
buf_cubic_x[0] = _noise_pool[(y1 * size * size + x0 * size + z0) % _noise_pool_size];
buf_cubic_x[1] = _noise_pool[(y1 * size * size + x1 * size + z0) % _noise_pool_size];
buf_cubic_x[2] = _noise_pool[(y1 * size * size + x2 * size + z0) % _noise_pool_size];
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_x[0] = noise[y2 * size * size + x0 * size + z0];
buf_cubic_x[1] = noise[y2 * size * size + x1 * size + z0];
buf_cubic_x[2] = noise[y2 * size * size + x2 * size + z0];
buf_cubic_x[3] = noise[y2 * size * size + x3 * size + z0];
buf_cubic_x[0] = _noise_pool[(y2 * size * size + x0 * size + z0) % _noise_pool_size];
buf_cubic_x[1] = _noise_pool[(y2 * size * size + x1 * size + z0) % _noise_pool_size];
buf_cubic_x[2] = _noise_pool[(y2 * size * size + x2 * size + z0) % _noise_pool_size];
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_x[0] = noise[y3 * size * size + x0 * size + z0];
buf_cubic_x[1] = noise[y3 * size * size + x1 * size + z0];
buf_cubic_x[2] = noise[y3 * size * size + x2 * size + z0];
buf_cubic_x[3] = noise[y3 * size * size + x3 * size + z0];
buf_cubic_x[0] = _noise_pool[(y3 * size * size + x0 * size + z0) % _noise_pool_size];
buf_cubic_x[1] = _noise_pool[(y3 * size * size + x1 * size + z0) % _noise_pool_size];
buf_cubic_x[2] = _noise_pool[(y3 * size * size + x2 * size + z0) % _noise_pool_size];
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_z[0] = _cubicInterpolate(buf_cubic_y, yinternal);
buf_cubic_x[0] = noise[y0 * size * size + x0 * size + z1];
buf_cubic_x[1] = noise[y0 * size * size + x1 * size + z1];
buf_cubic_x[2] = noise[y0 * size * size + x2 * size + z1];
buf_cubic_x[3] = noise[y0 * size * size + x3 * size + z1];
buf_cubic_x[0] = _noise_pool[(y0 * size * size + x0 * size + z1) % _noise_pool_size];
buf_cubic_x[1] = _noise_pool[(y0 * size * size + x1 * size + z1) % _noise_pool_size];
buf_cubic_x[2] = _noise_pool[(y0 * size * size + x2 * size + z1) % _noise_pool_size];
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_x[0] = noise[y1 * size * size + x0 * size + z1];
buf_cubic_x[1] = noise[y1 * size * size + x1 * size + z1];
buf_cubic_x[2] = noise[y1 * size * size + x2 * size + z1];
buf_cubic_x[3] = noise[y1 * size * size + x3 * size + z1];
buf_cubic_x[0] = _noise_pool[(y1 * size * size + x0 * size + z1) % _noise_pool_size];
buf_cubic_x[1] = _noise_pool[(y1 * size * size + x1 * size + z1) % _noise_pool_size];
buf_cubic_x[2] = _noise_pool[(y1 * size * size + x2 * size + z1) % _noise_pool_size];
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_x[0] = noise[y2 * size * size + x0 * size + z1];
buf_cubic_x[1] = noise[y2 * size * size + x1 * size + z1];
buf_cubic_x[2] = noise[y2 * size * size + x2 * size + z1];
buf_cubic_x[3] = noise[y2 * size * size + x3 * size + z1];
buf_cubic_x[0] = _noise_pool[(y2 * size * size + x0 * size + z1) % _noise_pool_size];
buf_cubic_x[1] = _noise_pool[(y2 * size * size + x1 * size + z1) % _noise_pool_size];
buf_cubic_x[2] = _noise_pool[(y2 * size * size + x2 * size + z1) % _noise_pool_size];
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_x[0] = noise[y3 * size * size + x0 * size + z1];
buf_cubic_x[1] = noise[y3 * size * size + x1 * size + z1];
buf_cubic_x[2] = noise[y3 * size * size + x2 * size + z1];
buf_cubic_x[3] = noise[y3 * size * size + x3 * size + z1];
buf_cubic_x[0] = _noise_pool[(y3 * size * size + x0 * size + z1) % _noise_pool_size];
buf_cubic_x[1] = _noise_pool[(y3 * size * size + x1 * size + z1) % _noise_pool_size];
buf_cubic_x[2] = _noise_pool[(y3 * size * size + x2 * size + z1) % _noise_pool_size];
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_z[1] = _cubicInterpolate(buf_cubic_y, yinternal);
buf_cubic_x[0] = noise[y0 * size * size + x0 * size + z2];
buf_cubic_x[1] = noise[y0 * size * size + x1 * size + z2];
buf_cubic_x[2] = noise[y0 * size * size + x2 * size + z2];
buf_cubic_x[3] = noise[y0 * size * size + x3 * size + z2];
buf_cubic_x[0] = _noise_pool[(y0 * size * size + x0 * size + z2) % _noise_pool_size];
buf_cubic_x[1] = _noise_pool[(y0 * size * size + x1 * size + z2) % _noise_pool_size];
buf_cubic_x[2] = _noise_pool[(y0 * size * size + x2 * size + z2) % _noise_pool_size];
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_x[0] = noise[y1 * size * size + x0 * size + z2];
buf_cubic_x[1] = noise[y1 * size * size + x1 * size + z2];
buf_cubic_x[2] = noise[y1 * size * size + x2 * size + z2];
buf_cubic_x[3] = noise[y1 * size * size + x3 * size + z2];
buf_cubic_x[0] = _noise_pool[(y1 * size * size + x0 * size + z2) % _noise_pool_size];
buf_cubic_x[1] = _noise_pool[(y1 * size * size + x1 * size + z2) % _noise_pool_size];
buf_cubic_x[2] = _noise_pool[(y1 * size * size + x2 * size + z2) % _noise_pool_size];
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_x[0] = noise[y2 * size * size + x0 * size + z2];
buf_cubic_x[1] = noise[y2 * size * size + x1 * size + z2];
buf_cubic_x[2] = noise[y2 * size * size + x2 * size + z2];
buf_cubic_x[3] = noise[y2 * size * size + x3 * size + z2];
buf_cubic_x[0] = _noise_pool[(y2 * size * size + x0 * size + z2) % _noise_pool_size];
buf_cubic_x[1] = _noise_pool[(y2 * size * size + x1 * size + z2) % _noise_pool_size];
buf_cubic_x[2] = _noise_pool[(y2 * size * size + x2 * size + z2) % _noise_pool_size];
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_x[0] = noise[y3 * size * size + x0 * size + z2];
buf_cubic_x[1] = noise[y3 * size * size + x1 * size + z2];
buf_cubic_x[2] = noise[y3 * size * size + x2 * size + z2];
buf_cubic_x[3] = noise[y3 * size * size + x3 * size + z2];
buf_cubic_x[0] = _noise_pool[(y3 * size * size + x0 * size + z2) % _noise_pool_size];
buf_cubic_x[1] = _noise_pool[(y3 * size * size + x1 * size + z2) % _noise_pool_size];
buf_cubic_x[2] = _noise_pool[(y3 * size * size + x2 * size + z2) % _noise_pool_size];
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_z[2] = _cubicInterpolate(buf_cubic_y, yinternal);
buf_cubic_x[0] = noise[y0 * size * size + x0 * size + z3];
buf_cubic_x[1] = noise[y0 * size * size + x1 * size + z3];
buf_cubic_x[2] = noise[y0 * size * size + x2 * size + z3];
buf_cubic_x[3] = noise[y0 * size * size + x3 * size + z3];
buf_cubic_x[0] = _noise_pool[(y0 * size * size + x0 * size + z3) % _noise_pool_size];
buf_cubic_x[1] = _noise_pool[(y0 * size * size + x1 * size + z3) % _noise_pool_size];
buf_cubic_x[2] = _noise_pool[(y0 * size * size + x2 * size + z3) % _noise_pool_size];
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_x[0] = noise[y1 * size * size + x0 * size + z3];
buf_cubic_x[1] = noise[y1 * size * size + x1 * size + z3];
buf_cubic_x[2] = noise[y1 * size * size + x2 * size + z3];
buf_cubic_x[3] = noise[y1 * size * size + x3 * size + z3];
buf_cubic_x[0] = _noise_pool[(y1 * size * size + x0 * size + z3) % _noise_pool_size];
buf_cubic_x[1] = _noise_pool[(y1 * size * size + x1 * size + z3) % _noise_pool_size];
buf_cubic_x[2] = _noise_pool[(y1 * size * size + x2 * size + z3) % _noise_pool_size];
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_x[0] = noise[y2 * size * size + x0 * size + z3];
buf_cubic_x[1] = noise[y2 * size * size + x1 * size + z3];
buf_cubic_x[2] = noise[y2 * size * size + x2 * size + z3];
buf_cubic_x[3] = noise[y2 * size * size + x3 * size + z3];
buf_cubic_x[0] = _noise_pool[(y2 * size * size + x0 * size + z3) % _noise_pool_size];
buf_cubic_x[1] = _noise_pool[(y2 * size * size + x1 * size + z3) % _noise_pool_size];
buf_cubic_x[2] = _noise_pool[(y2 * size * size + x2 * size + z3) % _noise_pool_size];
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_x[0] = noise[y3 * size * size + x0 * size + z3];
buf_cubic_x[1] = noise[y3 * size * size + x1 * size + z3];
buf_cubic_x[2] = noise[y3 * size * size + x2 * size + z3];
buf_cubic_x[3] = noise[y3 * size * size + x3 * size + z3];
buf_cubic_x[0] = _noise_pool[(y3 * size * size + x0 * size + z3) % _noise_pool_size];
buf_cubic_x[1] = _noise_pool[(y3 * size * size + x1 * size + z3) % _noise_pool_size];
buf_cubic_x[2] = _noise_pool[(y3 * size * size + x2 * size + z3) % _noise_pool_size];
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_z[3] = _cubicInterpolate(buf_cubic_y, yinternal);

9
lib_paysages/noise.h
View file

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

4
lib_paysages/scenery.c
View file

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

4
lib_paysages/terrain.c
View file

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

4
lib_paysages/textures.c
View file

@ -33,7 +33,7 @@ void texturesSave(FILE* f, TexturesDefinition* definition)
for (i = 0; i < definition->nbtextures; i++)
{
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);
}
}
@ -54,7 +54,7 @@ void texturesLoad(FILE* f, TexturesDefinition* definition)
layer = definition->textures + texturesAddLayer(definition);
zoneLoad(f, layer->zone);
noiseLoad(f, layer->bump_noise);
noiseLoadGenerator(f, layer->bump_noise);
colorLoad(f, &layer->color);
}

4
lib_paysages/water.c
View file

@ -28,7 +28,7 @@ void waterSave(FILE* f, WaterDefinition* definition)
toolsSaveDouble(f, &definition->transparency);
toolsSaveDouble(f, &definition->reflection);
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_scale);
}
@ -42,7 +42,7 @@ void waterLoad(FILE* f, WaterDefinition* definition)
toolsLoadDouble(f, &definition->transparency);
toolsLoadDouble(f, &definition->reflection);
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_scale);