Sign in to follow this  
PhantomRonin

Perlin Noise help

Recommended Posts

PhantomRonin    131
So I want to make a game with a procedural generated map using Perlin noise but im having issues. I have read up on Perlin Noise so I know what is going on behind the scenes but when I try to implement it it just looks like incoherent garbage. So I am using the code from this link [url="http://stackoverflow.com/questions/4753055/perlin-noise-generation-for-terrain"]http://stackoverflow...ion-for-terrain[/url] . I dont know if the code I am using is funky or if I have implemented it wrong. I have tried to use code from another site and that failed also.


[source lang="cpp"]#pragma once

class PerlinNoise
{
public:

// Constructor
PerlinNoise();
PerlinNoise(double _persistence, double _frequency, double _amplitude, int _octaves, int _randomseed);

// Get Height
double GetHeight(double x, double y) const;

// Get
double Persistence() const { return persistence; }
double Frequency() const { return frequency; }
double Amplitude() const { return amplitude; }
int Octaves() const { return octaves; }
int RandomSeed() const { return randomseed; }

// Set
void Set(double _persistence, double _frequency, double _amplitude, int _octaves, int _randomseed);

void SetPersistence(double _persistence) { persistence = _persistence; }
void SetFrequency( double _frequency) { frequency = _frequency; }
void SetAmplitude( double _amplitude) { amplitude = _amplitude; }
void SetOctaves( int _octaves) { octaves = _octaves; }
void SetRandomSeed( int _randomseed) { randomseed = _randomseed; }

private:

double Total(double i, double j) const;
double GetValue(double x, double y) const;
double Interpolate(double x, double y, double a) const;
double Noise(int x, int y) const;

double persistence, frequency, amplitude;
int octaves, randomseed;
};[/source]


[source lang="cpp"]#include "PerlinNoise.h"

PerlinNoise::PerlinNoise()
{
persistence = 0;
frequency = 0;
amplitude = 0;
octaves = 0;
randomseed = 0;
}

PerlinNoise::PerlinNoise(double _persistence, double _frequency, double _amplitude, int _octaves, int _randomseed)
{
persistence = _persistence;
frequency = _frequency;
amplitude = _amplitude;
octaves = _octaves;
randomseed = 2 + _randomseed * _randomseed;
}

void PerlinNoise::Set(double _persistence, double _frequency, double _amplitude, int _octaves, int _randomseed)
{
persistence = _persistence;
frequency = _frequency;
amplitude = _amplitude;
octaves = _octaves;
randomseed = 2 + _randomseed * _randomseed;
}

double PerlinNoise::GetHeight(double x, double y) const
{
return amplitude * Total(x, y);
}

double PerlinNoise::Total(double i, double j) const
{
//properties of one octave (changing each loop)
double t = 0.0f;
double _amplitude = 1;
double freq = frequency;

for(int k = 0; k < octaves; k++)
{
t += GetValue(j * freq + randomseed, i * freq + randomseed) * _amplitude;
_amplitude *= persistence;
freq *= 2;
}

return t;
}

double PerlinNoise::GetValue(double x, double y) const
{
int Xint = (int)x;
int Yint = (int)y;
double Xfrac = x - Xint;
double Yfrac = y - Yint;

//noise values
double n01 = Noise(Xint-1, Yint-1);
double n02 = Noise(Xint+1, Yint-1);
double n03 = Noise(Xint-1, Yint+1);
double n04 = Noise(Xint+1, Yint+1);
double n05 = Noise(Xint-1, Yint);
double n06 = Noise(Xint+1, Yint);
double n07 = Noise(Xint, Yint-1);
double n08 = Noise(Xint, Yint+1);
double n09 = Noise(Xint, Yint);

double n12 = Noise(Xint+2, Yint-1);
double n14 = Noise(Xint+2, Yint+1);
double n16 = Noise(Xint+2, Yint);

double n23 = Noise(Xint-1, Yint+2);
double n24 = Noise(Xint+1, Yint+2);
double n28 = Noise(Xint, Yint+2);

double n34 = Noise(Xint+2, Yint+2);

//find the noise values of the four corners
double x0y0 = 0.0625*(n01+n02+n03+n04) + 0.125*(n05+n06+n07+n08) + 0.25*(n09);
double x1y0 = 0.0625*(n07+n12+n08+n14) + 0.125*(n09+n16+n02+n04) + 0.25*(n06);
double x0y1 = 0.0625*(n05+n06+n23+n24) + 0.125*(n03+n04+n09+n28) + 0.25*(n08);
double x1y1 = 0.0625*(n09+n16+n28+n34) + 0.125*(n08+n14+n06+n24) + 0.25*(n04);

//interpolate between those values according to the x and y fractions
double v1 = Interpolate(x0y0, x1y0, Xfrac); //interpolate in x direction (y)
double v2 = Interpolate(x0y1, x1y1, Xfrac); //interpolate in x direction (y+1)
double fin = Interpolate(v1, v2, Yfrac); //interpolate in y direction

return fin;
}

double PerlinNoise::Interpolate(double x, double y, double a) const
{
double negA = 1.0 - a;
double negASqr = negA * negA;
double fac1 = 3.0 * (negASqr) - 2.0 * (negASqr * negA);
double aSqr = a * a;
double fac2 = 3.0 * aSqr - 2.0 * (aSqr * a);

return x * fac1 + y * fac2; //add the weighted factors
}

double PerlinNoise::Noise(int x, int y) const
{
int n = x + y * 57;
n = (n << 13) ^ n;
int t = (n * (n * n * 15731 + 789221) + 1376312589) & 0x7fffffff;
return 1.0 - double(t) * 0.931322574615478515625e-9;/// 1073741824.0);
}[/source]


Those files I borrowed and this is my implementation. This is not my exact code but its the important stuff
[source lang="cpp"]float persistence = 1;
float frequency = 3;
float amplitude = 64;
int octaves = 6;
int seed = SDL_GetTicks();
PerlinNoise NoiseGenerator(persistence,frequency,amplitude,octaves,seed);



for(int x = 0; x < 64; x++)
for(int y = 0; y < 48; y++)
{
//I add 128 becuase I should get a range from roughly
//-128 to 128 so adding 128 gives me the full range of color
int a = (int)(NoiseGenerator.GetHeight(x,y) + 128);

SDL_FillRect(screen,&rect, SDL_MapRGB( fmt, a, a, a));
}


[/source]

Share this post


Link to post
Share on other sites
JTippetts    12969
The thing about Perlin noise is that at frequency=1, there is roughly 1 feature per unit. At frequency=3, in your case, you have roughly 3 features per unit. However, you are sampling an area 64x48 units in size, so you will end up with a mapping containing roughly 192x144 features, which is going to look a whole lot like white noise. You should try disconnecting your pixel size from the actual size of the area of noise that you map, if you want to get anything useful.

Share this post


Link to post
Share on other sites
PhantomRonin    131
[quote name='JTippetts' timestamp='1353386946' post='5002580']
The thing about Perlin noise is that at frequency=1, there is roughly 1 feature per unit. At frequency=3, in your case, you have roughly 3 features per unit. However, you are sampling an area 64x48 units in size, so you will end up with a mapping containing roughly 192x144 features, which is going to look a whole lot like white noise. You should try disconnecting your pixel size from the actual size of the area of noise that you map, if you want to get anything useful.
[/quote]

Thanks I think I figured it out Edited by PhantomRonin

Share this post


Link to post
Share on other sites

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now

Sign in to follow this