src/PerlinNoise.h

Go to the documentation of this file.

#ifndef PERLINNOISE_H
#define PERLINNOISE_H

#include<cmath>


class PerlinNoise
{
  public:

    PerlinNoise(const float persistence, const float frequency, const int octaves)
        :mPersistence(persistence),
          mFrequency(frequency),
          mOctaves(octaves)
        {}
    
    ~PerlinNoise()
    {
    }
    
    const float perlinNoise(float x, float y) const
    {
        float frequency = mFrequency;
        float total = 0.0;
        for (float round = 0.0f; round < mOctaves; round += 1.0f)
        {
            const float amplitude = powf(mPersistence, round);
            
            total += interpolatedNoise(x * frequency, y * frequency) * amplitude;
            frequency *= 2;
        }
        return total;
    }


    const float perlinNoise3D(float x, float y, float z) const
    {
                float frequency = mFrequency;
        float total = 0.0;
        for (float round = 0.0f; round < mOctaves; round += 1.0f)
        {
            const float amplitude = powf(mPersistence, round);
            
            total += interpolatedNoise3D(x * frequency, y * frequency, z * frequency) * amplitude;
            frequency *= 2;
        }
        return total;
    }
    
  protected:
    
  private:
    const float mPersistence;   
    const float mFrequency;     
    const int mOctaves;         


    const float noise(const int x, const int y) const
    {
        int n = x + y * 57;
        n = n<<13 ^ n;
        return ( 1.0 - ( (n * (n * n * 15731 + 789221) + 1376312589) & 0x7fffffff) / 1073741824.0); // *magic*
    }
    
    
    const float cosInterpolate(const float a, const float b, const float x) const
    {
        float f = (1 - cosf(x*M_PI)) * 0.5;
        return  a*(1-f) + b*f;
    }
    
    
    const float weightedNoise(const int x, const int y) const
    {
        const float corners = ( noise(x-1, y-1) + noise(x+1, y-1) + noise(x-1, y+1) + noise(x+1, y+1) ) / 16;
        const float sides   = ( noise(x-1, y) + noise(x+1, y) + noise(x, y-1) + noise(x, y+1) ) /  8;
        const float center  =  noise(x, y) / 4;
        return corners + sides + center;
    }
    

    const float interpolatedNoise(const float x, const float y) const
    {
        const int intX    = int(x);
        const float fracX = x - intX;
        
        const int intY    = int(y);
        const float fracY = y - intY;
        
        const float v1 = weightedNoise(intX,     intY);
        const float v2 = weightedNoise(intX + 1, intY);
        const float v3 = weightedNoise(intX,     intY + 1);
        const float v4 = weightedNoise(intX + 1, intY + 1);
        
        const float i1 = cosInterpolate(v1 , v2 , fracX);
        const float i2 = cosInterpolate(v3 , v4 , fracX);
        
        return cosInterpolate(i1 , i2 , fracY);
    }



//------------------- 3d noise

    const float noise3D(const int x, const int y, const int z) const
    {
        int n = x + y * 57 + z * 63;
        n = n<<13 ^ n;
        return ( 1.0 - ( (n * (n * n * 15731 + 789221) + 1376312589) & 0x7fffffff) / 1073741824.0); // *magic*
    }
    


    const float interpolatedNoise3D(const float x, const float y, const float z) const
    {
        
        const int intX    = int(x);
        const float fracX = x - intX;
        
        const int intY    = int(y);
        const float fracY = y - intY;
        
        const int intZ    = int(z);
        const float fracZ = z - intZ;

        const float v1 = noise3D(intX,     intY,    intZ);
        const float v2 = noise3D(intX + 1, intY,    intZ);
        const float v3 = noise3D(intX,     intY + 1,intZ);
        const float v4 = noise3D(intX + 1, intY + 1,intZ);
        

        const float w1 = noise3D(intX,     intY,    intZ + 1);
        const float w2 = noise3D(intX + 1, intY,    intZ + 1);
        const float w3 = noise3D(intX,     intY + 1,intZ + 1);
        const float w4 = noise3D(intX + 1, intY + 1,intZ + 1);
        return lerp(fracZ, lerp(fracY, lerp(fracX, v1, v2), lerp(fracX, v3, v4)),
                           lerp(fracY, lerp(fracX, w1, w2), lerp(fracX, w3, w4)));
    }
    
};  
#endif

---