double ValueNoise::interpolatedNoise(double x, double y) {
int ix = floor(x);
int iy = floor(y);
double fx = x-ix;
double fy = y-iy;
double v1 = smoothNoise(ix, iy);
double v2 = smoothNoise(ix+1, iy);
double v3 = smoothNoise(ix, iy+1);
double v4 = smoothNoise(ix+1, iy+1);
double i1 = interpolate(v1, v2, fx);
double i2 = interpolate(v3, v4, fx);
return interpolate(i1, i2, fy);
}
//..............................................................................
float interpolatedNoise(float x, float y, int i) {
float integer_X = int(x);
float fractional_X = x - integer_X;
float integer_Y = int(y);
float fractional_Y = y - integer_Y;
float v1 = smoothNoise(integer_X, integer_Y, i);
float v2 = smoothNoise(integer_X + 1, integer_Y, i);
float v3 = smoothNoise(integer_X, integer_Y + 1, i);
float v4 = smoothNoise(integer_X + 1, integer_Y + 1, i);
float i1 = cosineInterpolate(v1, v2, fractional_X);
float i2 = cosineInterpolate(v3, v4, fractional_X);
return cosineInterpolate(i1, i2, fractional_Y);
}
double turbulence(double x, double y, double res, double **tab_noise)
{
double value;
double init_res;
value = 0.0;
init_res = res;
while (res >= 1)
{
value += smoothNoise(x / res, y / res, tab_noise) * res;
res /= 2.0;
}
return (128 * value / init_res);
}
Real32 interpolatedNoise(const Pnt2f& t, UInt32 & octave, UInt32 UInt32, bool Smoothing)
{
Real32 intX(osgFloor(t[0])), intY(osgFloor(t[1]));
Real32 fractionX = t[0] - intX;
Real32 fractionY = t[1] - intY;
Real32 i1(0.0f), i2(0.0f), returnValue(0.0f);
if(Smoothing)
{
if(UInt32 == PERLIN_INTERPOLATE_COSINE)
{
i1 = interpolateCosine(smoothNoise(intX, intY, octave),smoothNoise(intX + 1.0f, intY, octave), fractionX);
intY += 1.0f;
i2 = interpolateCosine(smoothNoise(intX, intY, octave),smoothNoise(intX + 1.0f, intY, octave), fractionX);
returnValue = interpolateCosine(i1 , i2 , fractionY);
}
else if (UInt32 == PERLIN_INTERPOLATE_LINEAR)
{
i1 = interpolateLinear(smoothNoise(intX, intY, octave),smoothNoise(intX + 1.0f, intY, octave), fractionX);
intY += 1.0f;
i2 = interpolateLinear(smoothNoise(intX, intY, octave),smoothNoise(intX + 1.0f, intY, octave), fractionX);
returnValue = interpolateLinear(i1 , i2 , fractionY);
}
} else
{
if(UInt32 == PERLIN_INTERPOLATE_COSINE)
{
i1 = interpolateCosine(getNoise(intX, intY, octave),getNoise(intX + 1.0f, intY, octave), fractionX);
intY += 1.0f;
i2 = interpolateCosine(getNoise(intX, intY, octave),getNoise(intX + 1.0f, intY, octave), fractionX);
returnValue = interpolateCosine(i1 , i2 , fractionY);
}
else if (UInt32 == PERLIN_INTERPOLATE_LINEAR)
{
i1 = interpolateLinear(getNoise(intX, intY, octave),getNoise(intX + 1.0f, intY, octave), fractionX);
intY += 1.0f;
i2 = interpolateLinear(getNoise(intX, intY, octave),getNoise(intX + 1.0f, intY, octave), fractionX);
returnValue = interpolateLinear(i1 , i2 , fractionY);
}
}
return returnValue;
}
std::vector<float> Noise::perlinNoise(std::vector<float>& baseNoise, int octaveCount, int width, int height)
{
std::vector<std::vector<float> > smoothNoises;
float persistance = 0.5f;
//generate smooth noises for each octave
for (int i = 0; i < octaveCount; i++) {
smoothNoises.push_back(smoothNoise(baseNoise, i, width, height));
}
std::vector<float> perlinNoise;
float amplitude = 1.0f;
float totalAmplitude = 0.0f;
//blend noise together
int counter = 0;
for (int octave = octaveCount - 1; octave >= 0; octave--) {
amplitude *= persistance;
totalAmplitude += amplitude;
for (int i = 0; i < width; i++) {
for (int j = 0; j < height; j++) {
perlinNoise.push_back( smoothNoises[octave][counter] * amplitude );
counter++;
}
counter++;
}
}
//normalisation
counter = 0;
for (int i = 0; i < width; i++){
for (int j = 0; j < height; j++){
perlinNoise[counter] /= totalAmplitude;
counter++;
}
counter++;
}
return perlinNoise;
}
void WorldTerrainChunk::activateLevelOfDetail(Cell& c, int lod)
{
const double nscale = 1;
const double namplitude = 0.5;
if (lod > 0) {
Node inter[3];
#define interpolate(dst, a, b) \
dst.pos = (a.pos + b.pos) * 0.5; \
dst.color = (a.color + b.color) * 0.5; \
dst.normal = (a.normal + b.normal).unit()
interpolate(inter[0], c.nodes[0], c.nodes[1]);
interpolate(inter[1], c.nodes[1], c.nodes[2]);
interpolate(inter[2], c.nodes[2], c.nodes[0]);
for (int i = 0; i < 3; i++)
inter[i].pos += inter[i].normal * smoothNoise(inter[i].pos.x * nscale, inter[i].pos.z * nscale, 8) * namplitude;
c.subcells = new (GC) Cell [4];
c.subcells[0].nodes[0] = c.nodes[0];
c.subcells[0].nodes[1] = inter[0];
c.subcells[0].nodes[2] = inter[2];
c.subcells[1].nodes[0] = inter[0];
c.subcells[1].nodes[1] = inter[1];
c.subcells[1].nodes[2] = inter[2];
c.subcells[2].nodes[0] = inter[0];
c.subcells[2].nodes[1] = c.nodes[1];
c.subcells[2].nodes[2] = inter[1];
c.subcells[3].nodes[0] = inter[2];
c.subcells[3].nodes[1] = inter[1];
c.subcells[3].nodes[2] = c.nodes[2];
for (int i = 0; i < 4; i++) {
activateLevelOfDetail(c.subcells[i], lod-1);
}
}
}
Real32 interpolatedNoise(const Pnt3f& t, UInt32 & octave, UInt32 UInt32, bool Smoothing)
{
Real32 intX(osgFloor(t[0])), intY(osgFloor(t[1])), intZ(osgFloor(t[2]));
Real32 fractionX = t[0] - intX;
Real32 fractionY = t[1] - intY;
Real32 fractionZ = t[2] - intZ;
Real32 v1,v2,v3,v4,v5,v6,v7,v8,i1,i2,i3,i4, returnValue(0.0f);
if(Smoothing)
{
v1 = smoothNoise(intX,intY,intZ,octave);
v2 = smoothNoise(intX + 1.0f,intY,intZ,octave);
v3 = smoothNoise(intX,intY + 1.0f,intZ,octave);
v4 = smoothNoise(intX + 1.0f,intY + 1.0f,intZ,octave);
v5 = smoothNoise(intX,intY,intZ + 1.0f,octave);
v6 = smoothNoise(intX + 1.0f,intY,intZ + 1.0f,octave);
v7 = smoothNoise(intX,intY + 1.0f,intZ + 1.0f,octave);
v8 = smoothNoise(intX + 1.0f,intY + 1.0f,intZ + 1.0f,octave);
if(UInt32 == PERLIN_INTERPOLATE_COSINE)
{
i1 = interpolateCosine(v1,v2,fractionX);
i2 = interpolateCosine(v3,v4,fractionX);
i3 = interpolateCosine(v5,v6,fractionX);
i4 = interpolateCosine(v7,v8,fractionX);
i1 = interpolateCosine(i1,i2,fractionY);
i2 = interpolateCosine(i3,i4,fractionY);
returnValue = interpolateCosine(i1,i2,fractionZ);
} else if (UInt32 == PERLIN_INTERPOLATE_LINEAR)
{
i1 = interpolateLinear(v1,v2,fractionX);
i2 = interpolateLinear(v3,v4,fractionX);
i3 = interpolateLinear(v5,v6,fractionX);
i4 = interpolateLinear(v7,v8,fractionX);
i1 = interpolateLinear(i1,i2,fractionY);
i2 = interpolateLinear(i3,i4,fractionY);
returnValue = interpolateLinear(i1,i2,fractionZ);
}
} else
{
v1 = getNoise(intX,intY,intZ,octave);
v2 = getNoise(intX + 1.0f,intY,intZ,octave);
v3 = getNoise(intX,intY + 1.0f,intZ,octave);
v4 = getNoise(intX + 1.0f,intY + 1.0f,intZ,octave);
v5 = getNoise(intX,intY,intZ + 1.0f,octave);
v6 = getNoise(intX + 1.0f,intY,intZ + 1.0f,octave);
v7 = getNoise(intX,intY + 1.0f,intZ + 1.0f,octave);
v8 = getNoise(intX + 1.0f,intY + 1.0f,intZ + 1.0f,octave);
if(UInt32 == PERLIN_INTERPOLATE_COSINE)
{
i1 = interpolateCosine(v1,v2,fractionX);
i2 = interpolateCosine(v3,v4,fractionX);
i3 = interpolateCosine(v5,v6,fractionX);
i4 = interpolateCosine(v7,v8,fractionX);
i1 = interpolateCosine(i1,i2,fractionY);
i2 = interpolateCosine(i3,i4,fractionY);
returnValue = interpolateCosine(i1,i2,fractionZ);
} else if (UInt32 == PERLIN_INTERPOLATE_LINEAR)
{
i1 = interpolateLinear(v1,v2,fractionX);
i2 = interpolateLinear(v3,v4,fractionX);
i3 = interpolateLinear(v5,v6,fractionX);
i4 = interpolateLinear(v7,v8,fractionX);
i1 = interpolateLinear(i1,i2,fractionY);
i2 = interpolateLinear(i3,i4,fractionY);
returnValue = interpolateLinear(i1,i2,fractionZ);
}
}
return returnValue;
}
