Rtch/Lephisto
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[Change] Hardcoded everything to have three dimensions. [perlin noise.]

Browse Source
This commit is contained in:
Allanis 2013-07-12 19:05:39 +01:00
parent 02e8b560fa
commit 5ed5cf6b6d
2 changed files with 74 additions and 176 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

228
src/perlin.c
View File

@ -2,10 +2,6 @@
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#ifdef __SSE__
#include <xmmintrin.h>
#endif /* __SSE__ */
#include "lephisto.h" #include "lephisto.h"
#include "log.h" #include "log.h"
#include "rng.h" #include "rng.h"
@ -16,7 +12,6 @@
#define NEBULAE_Z 32 #define NEBULAE_Z 32
#define NOISE_MAX_OCTAVES 128 #define NOISE_MAX_OCTAVES 128
#define NOISE_MAX_DIMENSIONS 4
#define NOISE_DEFAULT_HURST 0.5 #define NOISE_DEFAULT_HURST 0.5
#define NOISE_DEFAULT_LACUNARITY 2. #define NOISE_DEFAULT_LACUNARITY 2.
@ -27,71 +22,40 @@ typedef void* noise_t;
/* Used internally. */ /* Used internally. */
typedef struct { typedef struct {
int ndim;
unsigned char map[256]; /* Randomized map of indexes into buffer. */ unsigned char map[256]; /* Randomized map of indexes into buffer. */
float buffer[256][NOISE_MAX_DIMENSIONS]; // Random 256 x ndim buffer. */ float buffer[256][3]; /* Random 256x3 buffer. */
/* Fractal stuff. */ /* Fractal stuff. */
float H; float H;
float lacunarity; float lacunarity;
float exponent[NOISE_MAX_OCTAVES]; float exponent[NOISE_MAX_OCTAVES];
} perling_data_t; } perlin_data_t;
static float* genNebulaeMap(const int w, const int h, const int n, float rug); static float* genNebulaeMap(const int w, const int h, const int n, float rug);
SDL_Surface* surfaceFromNebulaeMap(float* map, const int w, const int h); SDL_Surface* surfaceFromNebulaeMap(float* map, const int w, const int h);
static noise_t noise_new(int dimensions, float hurst, float lacunarity); static noise_t noise_new(float hurst, float lacunarity);
/* Basic perlin noise. */ /* Basic perlin noise. */
static float noise_get(noise_t noise, float* f); static float noise_get(noise_t noise, float* f);
/* Fractional brownian motion. */ /* Fractional brownian motion. */
/*static float noise_fbm(noise_t noise, float* f, float octaves);*/
/* Turbulence. */ /* Turbulence. */
static float noise_turbulence(noise_t noise, float* f, float octaves); static float noise_turbulence(noise_t noise, float* f, float octaves);
static void noise_delete(noise_t noise); static void noise_delete(noise_t noise);
static float lattice(perling_data_t* pdata, int ix, float fx, int iy, static float lattice(perlin_data_t* pdata, int ix, float fx, int iy,
float fy, int iz, float fz, int iw, float fw) { float fy, int iz, float fz) {
#ifdef __SSE__
(void)iw;
(void)fw;
int nindex; int nindex;
__m128 a, b, c; float value;
nindex = 0; nindex = 0;
nindex = pdata->map[(nindex + ix) & 0xFF]; nindex = pdata->map[(nindex + ix) & 0xFF];
nindex = pdata->map[(nindex + iy) & 0xFF]; nindex = pdata->map[(nindex + iy) & 0xFF];
nindex = pdata->map[(nindex + iz) & 0xFF]; nindex = pdata->map[(nindex + iz) & 0xFF];
float inp_sse1[4] __attribute__((aligned(16))) = { value = pdata->buffer[nindex][0] * fx;
pdata->buffer[nindex][0], value += pdata->buffer[nindex][1] * fy;
pdata->buffer[nindex][1], value += pdata->buffer[nindex][2] * fz;
pdata->buffer[nindex][2],
0.
};
float inp_sse2[4] __attribute__ ((aligned(16))) = {
fx, fy, fz, 0.
};
float out_sse[4] __attribute__((aligned(16)));
a = _mm_load_ps(inp_sse1);
b = _mm_load_ps(inp_sse2);
c = _mm_mul_ps(a, b);
_mm_store_ps(out_sse, c);
return out_sse[0] + out_sse[1] + out_sse[2];
#else /* __SSE__ */
int n[4] = { ix, iy, iz, iw };
float f[4] = { fx, fy, fz, fw };
int nindex = 0;
int i;
float value = 0;
for(i = 0; i < pdata->ndim; i++)
nindex = pdata->map[(nindex + n[i]) & 0xFF];
for(i = 0; i < pdata->ndim; i++)
value += pdata->buffer[nindex][i] * f[i];
return value; return value;
#endif /* __SSE__ */
} }
#define DEFAULT_SEED 0x15687436 #define DEFAULT_SEED 0x15687436
@ -101,27 +65,26 @@ static float lattice(perling_data_t* pdata, int ix, float fx, int iy,
#define FLOOR(a) ((int) a - (a < 0 && a != (int)a)) #define FLOOR(a) ((int) a - (a < 0 && a != (int)a))
#define CUBIC(a) (a * a * (3 - 2 * a)) #define CUBIC(a) (a * a * (3 - 2 * a))
static void normalize(perling_data_t* pdata, float* f) { static void normalize(float f[3]) {
float magnitude = 0; float magnitude;
int i;
for(i = 0; i < pdata->ndim; i++) magnitude = 1. / sqrtf(f[0]*f[0] + f[1]*f[1] + f[2]*f[2]);
magnitude += f[i] * f[i]; f[0] *= magnitude;
magnitude = 1 / sqrtf(magnitude); f[1] *= magnitude;
for(i = 0; i < pdata->ndim; i++) f[2] *= magnitude;
f[i] *= magnitude;
} }
static noise_t noise_new(int ndim, float hurst, float lacunarity) { static noise_t noise_new(float hurst, float lacunarity) {
perling_data_t* pdata=(perling_data_t*)calloc(sizeof(perling_data_t), 1); perlin_data_t* pdata = (perlin_data_t*)calloc(sizeof(perlin_data_t), 1);
int i, j; int i, j;
unsigned char tmp; unsigned char tmp;
float f = 1; float f = 1;
pdata->ndim = ndim;
for(i = 0; i < 256; i++) { for(i = 0; i < 256; i++) {
pdata->map[i] = (unsigned char) i; pdata->map[i] = (unsigned char)i;
for(j = 0; j < pdata->ndim; j++) pdata->buffer[i][0] = RNGF()-0.5;
pdata->buffer[i][j] = RNGF()-0.5; pdata->buffer[i][1] = RNGF()-0.5;
normalize(pdata, pdata->buffer[i]); pdata->buffer[i][2] = RNGF()-0.5;
normalize(pdata->buffer[i]);
} }
while(--i) { while(--i) {
@ -132,133 +95,68 @@ static noise_t noise_new(int ndim, float hurst, float lacunarity) {
pdata->H = hurst; pdata->H = hurst;
pdata->lacunarity = lacunarity; pdata->lacunarity = lacunarity;
for(i = 0; i < NOISE_MAX_OCTAVES; i++) { for(i = 0; i < NOISE_MAX_OCTAVES; i++) {
/*exponent[i] = powf(f, -H); */ /*exponent[i] = powf(f, -H);*/
pdata->exponent[i] = 1.0f / f; pdata->exponent[i] = 1. / f;
f *= lacunarity; f *= lacunarity;
} }
return (noise_t)pdata; return (noise_t)pdata;
} }
static float noise_get(noise_t noise, float *f ) static float noise_get(noise_t noise, float *f ) {
{ perlin_data_t* pdata = (perlin_data_t*)noise;
perling_data_t* pdata = (perling_data_t*) noise; int n[3]; /* Indexes to pass to lattice function. */
int n[NOISE_MAX_DIMENSIONS]; /* Indexes to pass to lattice function */ float r[3]; /* Remainders to pass to lattice function. */
int i; float w[3]; /* Cubic values to pass to interpolation function. */
float r[NOISE_MAX_DIMENSIONS]; /* Remainders to pass to lattice function */
float w[NOISE_MAX_DIMENSIONS]; /* Cubic values to pass to interpolation function */
float value; float value;
for(i=0; i<pdata->ndim; i++) { n[0] = FLOOR(f[0]);
n[i] = FLOOR(f[i]); n[1] = FLOOR(f[1]);
r[i] = f[i] - n[i]; n[2] = FLOOR(f[2]);
w[i] = CUBIC(r[i]);
}
switch(pdata->ndim) { r[0] = f[0] - n[0];
case 1: r[1] = f[1] - n[1];
value = LERP(lattice(pdata,n[0], r[0],0,0,0,0,0,0), r[2] = f[2] - n[2];
lattice(pdata,n[0]+1, r[0]-1,0,0,0,0,0,0),
w[0]); w[0] = CUBIC(r[0]);
break; w[1] = CUBIC(r[1]);
case 2: w[2] = CUBIC(r[2]);
value = LERP(LERP(lattice(pdata,n[0], r[0], n[1], r[1],0,0,0,0),
lattice(pdata,n[0]+1, r[0]-1, n[1], r[1],0,0,0,0), value = LERP(LERP(LERP(lattice(pdata,n[0], r[0], n[1], r[1], n[2], r[2]),
lattice(pdata,n[0]+1, r[0]-1, n[1], r[1], n[2], r[2]),
w[0]), w[0]),
LERP(lattice(pdata,n[0], r[0], n[1]+1, r[1]-1,0,0,0,0), LERP(lattice(pdata,n[0], r[0], n[1]+1, r[1]-1, n[2], r[2]),
lattice(pdata,n[0]+1, r[0]-1, n[1]+1, r[1]-1,0,0,0,0), lattice(pdata,n[0]+1, r[0]-1, n[1]+1, r[1]-1, n[2], r[2]),
w[0]),
w[1]);
break;
case 3:
value = LERP(LERP(LERP(lattice(pdata,n[0], r[0], n[1], r[1], n[2], r[2],0,0),
lattice(pdata,n[0]+1, r[0]-1, n[1], r[1], n[2], r[2],0,0),
w[0]),
LERP(lattice(pdata,n[0], r[0], n[1]+1, r[1]-1, n[2], r[2],0,0),
lattice(pdata,n[0]+1, r[0]-1, n[1]+1, r[1]-1, n[2], r[2],0,0),
w[0]), w[0]),
w[1]), w[1]),
LERP(LERP(lattice(pdata,n[0], r[0], n[1], r[1], n[2]+1, r[2]-1,0,0), LERP(LERP(lattice(pdata,n[0], r[0], n[1], r[1], n[2]+1, r[2]-1),
lattice(pdata,n[0]+1, r[0]-1, n[1], r[1], n[2]+1, r[2]-1,0,0), lattice(pdata,n[0]+1, r[0]-1, n[1], r[1], n[2]+1, r[2]-1),
w[0]), w[0]),
LERP(lattice(pdata,n[0], r[0], n[1]+1, r[1]-1, n[2]+1, r[2]-1,0,0), LERP(lattice(pdata,n[0], r[0], n[1]+1, r[1]-1, n[2]+1, r[2]-1),
lattice(pdata,n[0]+1, r[0]-1, n[1]+1, r[1]-1, n[2]+1, r[2]-1,0,0), lattice(pdata,n[0]+1, r[0]-1, n[1]+1, r[1]-1, n[2]+1, r[2]-1),
w[0]), w[0]),
w[1]), w[1]),
w[2]); w[2]);
break;
case 4:
default:
value = LERP(LERP(LERP(LERP(lattice(pdata,n[0], r[0], n[1], r[1], n[2], r[2], n[3], r[3]),
lattice(pdata,n[0]+1, r[0]-1, n[1], r[1], n[2], r[2], n[3], r[3]),
w[0]),
LERP(lattice(pdata,n[0], r[0], n[1]+1, r[1]-1, n[2], r[2], n[3], r[3]),
lattice(pdata,n[0]+1, r[0]-1, n[1]+1, r[1]-1, n[2], r[2], n[3], r[3]),
w[0]),
w[1]),
LERP(LERP(lattice(pdata,n[0], r[0], n[1], r[1], n[2]+1, r[2]-1, n[3], r[3]),
lattice(pdata,n[0]+1, r[0]-1, n[1], r[1], n[2]+1, r[2]-1, n[3], r[3]),
w[0]),
LERP(lattice(pdata,n[0], r[0], n[1]+1, r[1]-1, n[2]+1, r[2]-1,0,0),
lattice(pdata,n[0]+1, r[0]-1, n[1]+1, r[1]-1, n[2]+1, r[2]-1, n[3], r[3]),
w[0]),
w[1]),
w[2]),
LERP(LERP(LERP(lattice(pdata,n[0], r[0], n[1], r[1], n[2], r[2], n[3]+1, r[3]-1),
lattice(pdata,n[0]+1, r[0]-1, n[1], r[1], n[2], r[2], n[3]+1, r[3]-1),
w[0]),
LERP(lattice(pdata,n[0], r[0], n[1]+1, r[1]-1, n[2], r[2], n[3]+1, r[3]-1),
lattice(pdata,n[0]+1, r[0]-1, n[1]+1, r[1]-1, n[2], r[2], n[3]+1, r[3]-1),
w[0]),
w[1]),
LERP(LERP(lattice(pdata,n[0], r[0], n[1], r[1], n[2]+1, r[2]-1, n[3]+1, r[3]-1),
lattice(pdata,n[0]+1, r[0]-1, n[1], r[1], n[2]+1, r[2]-1, n[3]+1, r[3]-1),
w[0]),
LERP(lattice(pdata,n[0], r[0], n[1]+1, r[1]-1, n[2]+1, r[2]-1,0,0),
lattice(pdata,n[0]+1, r[0]-1, n[1]+1, r[1]-1, n[2]+1, r[2]-1, n[3]+1, r[3]-1),
w[0]),
w[1]),
w[2]),
w[3]);
break;
}
return CLAMP(-0.99999f, 0.99999f, value); return CLAMP(-0.99999f, 0.99999f, value);
} }
#if 0
float noise_fbm(noise_t noise, float* f, float octaves) {
float tf[NOISE_MAX_DIMENSIONS];
perling_data_t* pdata = (perling_data_t*) noise;
/* Init locals. */
float value = 0;
int i, j;
memcpy(tf, f, sizeof(float) * pdata->ndim);
/* Inner loop for spectral construction, where the fractal is build. */
for(i = 0; i < (int)octaves; i++) {
value += noise_get(noise, tf) * pdata->exponent[i];
for(j = 0; j < pdata->ndim; j++) tf[j] *= pdata->lacunarity;
}
/* Take care of remainder in octaves. */
octaves -= (int)octaves;
if(octaves > DELTA)
value += octaves * noise_get(noise, tf) * pdata->exponent[i];
return CLAMP(-0.99999f, 0.99999f, value);
}
#endif
static float noise_turbulence(noise_t noise, float* f, float octaves) { static float noise_turbulence(noise_t noise, float* f, float octaves) {
float tf[NOISE_MAX_DIMENSIONS]; float tf[3];
perling_data_t* pdata = (perling_data_t*) noise; perlin_data_t* pdata = (perlin_data_t*) noise;
/* Init locals. */ /* Init locals. */
float value = 0; float value = 0;
int i, j; int i;
memcpy(tf, f, sizeof(float) * pdata->ndim);
tf[0] = f[0];
tf[1] = f[1];
tf[2] = f[2];
/* Inner loop of spectral construction, where the fractal is built. */ /* Inner loop of spectral construction, where the fractal is built. */
for(i = 0; i < (int)octaves; i++) { for(i = 0; i < (int)octaves; i++) {
value += ABS(noise_get(noise, tf)) * pdata->exponent[i]; value += ABS(noise_get(noise, tf)) * pdata->exponent[i];
for(j = 0; j < pdata->ndim; j++) tf[j] *= pdata->lacunarity; tf[0] *= pdata->lacunarity;
tf[1] *= pdata->lacunarity;
tf[2] *= pdata->lacunarity;
} }
/* Take care of remainders in octaves. */ /* Take care of remainders in octaves. */
@ -269,7 +167,7 @@ static float noise_turbulence(noise_t noise, float* f, float octaves) {
} }
void noise_delete(noise_t noise) { void noise_delete(noise_t noise) {
free((perling_data_t*)noise); free((perlin_data_t*)noise);
} }
/* Generate a 3d nebulae map of dimensions w,h,n with ruggedness rig. */ /* Generate a 3d nebulae map of dimensions w,h,n with ruggedness rig. */
@ -290,7 +188,7 @@ static float* genNebulaeMap(const int w, const int h, const int n, float rug) {
lacunarity = NOISE_DEFAULT_LACUNARITY; lacunarity = NOISE_DEFAULT_LACUNARITY;
/* Create noiuse and data. */ /* Create noiuse and data. */
noise = noise_new(2, hurst, lacunarity); noise = noise_new(hurst, lacunarity);
nebulae = malloc(sizeof(float)*w*h*n); nebulae = malloc(sizeof(float)*w*h*n);
if(nebulae == NULL) { if(nebulae == NULL) {

2
src/plasmaf.c
View File

@ -22,7 +22,7 @@ glTexture* pf_genFractal(const int w, const int h, double rug) {
map = pf_genFractalMap(w, h, rug); map = pf_genFractalMap(w, h, rug);
sur = SDL_CreateRGBSurface(SDL_SWSURFACE, w, h, 32, RGBMASK); sur = SDL_CreateRGBSurface(SDL_SWSURFACE, w, h, 32, RGBAMASK);
pix = sur->pixels; pix = sur->pixels;
/* Convert from mapping to actual colours. */ /* Convert from mapping to actual colours. */