Noise.h

Go to the documentation of this file.

 
// Noise.h
 
// Declares the cNoise, cCubicNoise and cPerlinNoise classes for generating noise
 
#pragma once
 
typedef float NOISE_DATATYPE;
 
#include "../Vector3.h"
#include "OctavedNoise.h"
#include "RidgedNoise.h"
 
 
 
 
 
class cNoise
{
public:
    cNoise(int a_Seed);
    cNoise(const cNoise & a_Noise);
 
    // The following functions, if not marked INLINE, are about 20 % slower
    inline NOISE_DATATYPE IntNoise1D(int a_X) const;
    inline NOISE_DATATYPE IntNoise2D(int a_X, int a_Y) const;
    inline NOISE_DATATYPE IntNoise3D(int a_X, int a_Y, int a_Z) const;
    inline NOISE_DATATYPE IntNoise3D(Vector3i a_Pos) const;
 
    // Return a float number in the specified range:
    inline NOISE_DATATYPE IntNoise2DInRange(int a_X, int a_Y, float a_Min, float a_Max) const
    {
        return a_Min + std::abs(IntNoise2D(a_X, a_Y)) * (a_Max - a_Min);
    }
 
    // Note: These functions have a mod8-irregular chance - each of the mod8 remainders has different chance of occurrence. Divide by 8 to rectify.
    inline int IntNoise1DInt(int a_X) const;
    inline int IntNoise2DInt(int a_X, int a_Y) const;
    inline int IntNoise3DInt(int a_X, int a_Y, int a_Z) const;
    inline int IntNoise3DInt(Vector3i a_Pos) const;
 
    NOISE_DATATYPE LinearNoise1D(NOISE_DATATYPE a_X) const;
    NOISE_DATATYPE CosineNoise1D(NOISE_DATATYPE a_X) const;
    NOISE_DATATYPE CubicNoise1D (NOISE_DATATYPE a_X) const;
    NOISE_DATATYPE SmoothNoise1D(int a_X) const;
 
    NOISE_DATATYPE CubicNoise2D (NOISE_DATATYPE a_X, NOISE_DATATYPE a_Y) const;
 
    NOISE_DATATYPE CubicNoise3D (NOISE_DATATYPE a_X, NOISE_DATATYPE a_Y, NOISE_DATATYPE a_Z) const;
 
    void SetSeed(int a_Seed) { m_Seed = a_Seed; }
    int GetSeed(void) const { return m_Seed; }
 
    inline static NOISE_DATATYPE CubicInterpolate (NOISE_DATATYPE a_A, NOISE_DATATYPE a_B, NOISE_DATATYPE a_C, NOISE_DATATYPE a_D, NOISE_DATATYPE a_Pct);
    inline static NOISE_DATATYPE CosineInterpolate(NOISE_DATATYPE a_A, NOISE_DATATYPE a_B, NOISE_DATATYPE a_Pct);
    inline static NOISE_DATATYPE LinearInterpolate(NOISE_DATATYPE a_A, NOISE_DATATYPE a_B, NOISE_DATATYPE a_Pct);
 
private:
    int m_Seed;
} ;
 
 
 
 
 
class cCubicNoise
{
public:
    static const int MAX_SIZE = 512;
 
 
    cCubicNoise(int a_Seed);
 
 
    void Generate2D(
        NOISE_DATATYPE * a_Array,                        
        int a_SizeX, int a_SizeY,                        
        NOISE_DATATYPE a_StartX, NOISE_DATATYPE a_EndX,  
        NOISE_DATATYPE a_StartY, NOISE_DATATYPE a_EndY   
    ) const;
 
 
    void Generate3D(
        NOISE_DATATYPE * a_Array,                        
        int a_SizeX, int a_SizeY, int a_SizeZ,           
        NOISE_DATATYPE a_StartX, NOISE_DATATYPE a_EndX,  
        NOISE_DATATYPE a_StartY, NOISE_DATATYPE a_EndY,  
        NOISE_DATATYPE a_StartZ, NOISE_DATATYPE a_EndZ   
    ) const;
 
protected:
 
    cNoise m_Noise;
 
 
    void CalcFloorFrac(
        int a_Size,
        NOISE_DATATYPE a_Start, NOISE_DATATYPE a_End,
        int * a_Floor, NOISE_DATATYPE * a_Frac,
        int * a_Same, int & a_NumSame
    ) const;
} ;
 
 
 
 
 
class cImprovedNoise
{
public:
    cImprovedNoise(int a_Seed);
 
 
    void Generate2D(
        NOISE_DATATYPE * a_Array,                        
        int a_SizeX, int a_SizeY,                        
        NOISE_DATATYPE a_StartX, NOISE_DATATYPE a_EndX,  
        NOISE_DATATYPE a_StartY, NOISE_DATATYPE a_EndY   
    ) const;
 
 
    void Generate3D(
        NOISE_DATATYPE * a_Array,                        
        int a_SizeX, int a_SizeY, int a_SizeZ,           
        NOISE_DATATYPE a_StartX, NOISE_DATATYPE a_EndX,  
        NOISE_DATATYPE a_StartY, NOISE_DATATYPE a_EndY,  
        NOISE_DATATYPE a_StartZ, NOISE_DATATYPE a_EndZ   
    ) const;
 
    NOISE_DATATYPE GetValueAt(int a_X, int a_Y, int a_Z);
 
protected:
 
    int m_Perm[512];
 
 
    inline static NOISE_DATATYPE Fade(NOISE_DATATYPE a_T)
    {
        return a_T * a_T * a_T * (a_T * (a_T * 6 - 15) + 10);
    }
 
    inline static NOISE_DATATYPE Grad(int a_Hash, NOISE_DATATYPE a_X, NOISE_DATATYPE a_Y, NOISE_DATATYPE a_Z)
    {
        int hash = a_Hash % 16;
        NOISE_DATATYPE u = (hash < 8) ? a_X : a_Y;
        NOISE_DATATYPE v = (hash < 4) ? a_Y : (((hash == 12) || (hash == 14)) ? a_X : a_Z);
        return (((hash & 1) == 0) ? u : -u) + (((hash & 2) == 0) ? v : -v);
    }
};
 
 
 
 
 
typedef cOctavedNoise<cCubicNoise> cPerlinNoise;
typedef cOctavedNoise<cRidgedNoise<cCubicNoise>> cRidgedMultiNoise;
 
 
 
 
 
// Inline function definitions:
// These need to be in the header, otherwise linker error occur in MSVC
 
NOISE_DATATYPE cNoise::IntNoise1D(int a_X) const
{
    int x = ((a_X * m_Seed) << 13) ^ a_X;
    return (1 - static_cast<NOISE_DATATYPE>((x * (x * x * 15731 + 789221) + 1376312589) & 0x7fffffff) / 1073741824);
    // returns a float number in the range of [-1, 1]
}
 
 
 
 
 
NOISE_DATATYPE cNoise::IntNoise2D(int a_X, int a_Y) const
{
    int n = a_X + a_Y * 57 + m_Seed * 57 * 57;
    n = (n << 13) ^ n;
    return (1 - static_cast<NOISE_DATATYPE>((n * (n * n * 15731 + 789221) + 1376312589) & 0x7fffffff) / 1073741824);
    // returns a float number in the range of [-1, 1]
}
 
 
 
 
 
NOISE_DATATYPE cNoise::IntNoise3D(int a_X, int a_Y, int a_Z) const
{
    int n = a_X + a_Y * 57 + a_Z * 57 * 57 + m_Seed * 57 * 57 * 57;
    n = (n << 13) ^ n;
    return (static_cast<NOISE_DATATYPE>(1) -
        static_cast<NOISE_DATATYPE>((n * (n * n * 15731 + 789221) + 1376312589) & 0x7fffffff) / 1073741824.0f
    );
    // returns a float number in the range of [-1, 1]
}
 
 
 
 
 
NOISE_DATATYPE cNoise::IntNoise3D(Vector3i a_Pos) const
{
    return IntNoise3D(a_Pos.x, a_Pos.y, a_Pos.z);
}
 
 
 
 
 
int cNoise::IntNoise1DInt(int a_X) const
{
    int x = ((a_X * m_Seed) << 13) ^ a_X;
    return ((x * (x * x * 15731 + 789221) + 1376312589) & 0x7fffffff);
}
 
 
 
 
 
int cNoise::IntNoise2DInt(int a_X, int a_Y) const
{
    int n = a_X + a_Y * 57 + m_Seed * 57 * 57;
    n = (n << 13) ^ n;
    return ((n * (n * n * 15731 + 789221) + 1376312589) & 0x7fffffff);
}
 
 
 
 
 
int cNoise::IntNoise3DInt(int a_X, int a_Y, int a_Z) const
{
    int n = a_X + a_Y * 57 + a_Z * 57 * 57 + m_Seed * 57 * 57 * 57;
    n = (n << 13) ^ n;
    return ((n * (n * n * 15731 + 789221) + 1376312589) & 0x7fffffff);
}
 
 
 
 
 
int cNoise::IntNoise3DInt(Vector3i a_Pos) const
{
    return IntNoise3DInt(a_Pos.x, a_Pos.y, a_Pos.z);
}
 
 
 
 
 
NOISE_DATATYPE cNoise::CubicInterpolate(NOISE_DATATYPE a_A, NOISE_DATATYPE a_B, NOISE_DATATYPE a_C, NOISE_DATATYPE a_D, NOISE_DATATYPE a_Pct)
{
    NOISE_DATATYPE P = (a_D - a_C) - (a_A - a_B);
    NOISE_DATATYPE Q = (a_A - a_B) - P;
    NOISE_DATATYPE R = a_C - a_A;
    NOISE_DATATYPE S = a_B;
 
    return ((P * a_Pct + Q) * a_Pct + R) * a_Pct + S;
}
 
 
 
 
 
NOISE_DATATYPE cNoise::CosineInterpolate(NOISE_DATATYPE a_A, NOISE_DATATYPE a_B, NOISE_DATATYPE a_Pct)
{
    const NOISE_DATATYPE ft = a_Pct * static_cast<NOISE_DATATYPE>(3.1415927);
    const NOISE_DATATYPE f = static_cast<NOISE_DATATYPE>(static_cast<NOISE_DATATYPE>(1 - cos(ft)) * static_cast<NOISE_DATATYPE>(0.5));
    return  a_A * (1 - f) + a_B * f;
}
 
 
 
 
 
NOISE_DATATYPE cNoise::LinearInterpolate(NOISE_DATATYPE a_A, NOISE_DATATYPE a_B, NOISE_DATATYPE a_Pct)
{
    return  a_A * (1 - a_Pct) + a_B * a_Pct;
}
 
 
 
 
 
// Global functions:
 
extern void Debug2DNoise(const NOISE_DATATYPE * a_Array, size_t a_SizeX, size_t a_SizeY, const AString & a_FileNameBase, NOISE_DATATYPE a_Coeff = 32);
 
extern void Debug3DNoise(const NOISE_DATATYPE * a_Array, size_t a_SizeX, size_t a_SizeY, size_t a_SizeZ, const AString & a_FileNameBase, NOISE_DATATYPE a_Coeff = 32);
 
 
 
 
inline NOISE_DATATYPE Lerp(NOISE_DATATYPE a_Val1, NOISE_DATATYPE a_Val2, NOISE_DATATYPE a_Ratio)
{
    return a_Val1 + (a_Val2 - a_Val1) * a_Ratio;
}
 
 
 
 
 
inline NOISE_DATATYPE ClampedLerp(NOISE_DATATYPE a_Val1, NOISE_DATATYPE a_Val2, NOISE_DATATYPE a_Ratio)
{
    if (a_Ratio < 0)
    {
        return a_Val1;
    }
    if (a_Ratio > 1)
    {
        return a_Val2;
    }
    return Lerp(a_Val1, a_Val2, a_Ratio);
}