gm_simplexnoise -Because I do what I want.

[release]
gm_simplexnoise

Simplex Noise is:
[release]a method for constructing an n-dimensional noise function comparable to Perlin noise (“classic” noise) but with a lower computational overhead, especially in larger dimensions. Ken Perlin designed the algorithm in 2001[1] to address the limitations of his classic noise function, especially in higher dimensions.[/release] from Wikipedia

Features:

[ul]
[li]2D,3D, and 4D Variations of Simplex Noise[/li][li]Experimental Gaussian Blur Algorithms (not 100% sure if/how they work)[/li][li]Fractal Sum, Absolute Value Fractal Sum, and Turbulent/Striped Variations of Simplex Noise[/li][/ul]

Source:


// Skip rarely used Windows API functions
#define WIN32_LEAN_AND_MEAN
 
// Headers
#include <GMLuaModule.h>
 
// Module definition
GMOD_MODULE( Init, Shutdown );
 
// Globals
ILuaInterface* g_Lua;

int gradients3d[12][3] = {{1,1,0},{-1,1,0},{1,-1,0},{-1,-1,0},
{1,0,1},{-1,0,1},{1,0,-1},{-1,0,-1},
{0,1,1},{0,-1,1},{0,1,-1},{0,-1,-1}};
int gradients4d[32][4] = {{0,1,1,1}, {0,1,1,-1}, {0,1,-1,1}, {0,1,-1,-1},
{0,-1,1,1}, {0,-1,1,-1}, {0,-1,-1,1}, {0,-1,-1,-1},
{1,0,1,1}, {1,0,1,-1}, {1,0,-1,1}, {1,0,-1,-1},
{-1,0,1,1}, {-1,0,1,-1}, {-1,0,-1,1}, {-1,0,-1,-1},
{1,1,0,1}, {1,1,0,-1}, {1,-1,0,1}, {1,-1,0,-1},
{-1,1,0,1}, {-1,1,0,-1}, {-1,-1,0,1}, {-1,-1,0,-1},
{1,1,1,0}, {1,1,-1,0}, {1,-1,1,0}, {1,-1,-1,0},
{-1,1,1,0}, {-1,1,-1,0}, {-1,-1,1,0}, {-1,-1,-1,0}};
int p[256] = {151,160,137,91,90,15,
131,13,201,95,96,53,194,233,7,225,140,36,103,30,69,142,8,99,37,240,21,10,23,
190, 6,148,247,120,234,75,0,26,197,62,94,252,219,203,117,35,11,32,57,177,33,
88,237,149,56,87,174,20,125,136,171,168, 68,175,74,165,71,134,139,48,27,166,
77,146,158,231,83,111,229,122,60,211,133,230,220,105,92,41,55,46,245,40,244,
102,143,54, 65,25,63,161, 1,216,80,73,209,76,132,187,208, 89,18,169,200,196,
135,130,116,188,159,86,164,100,109,198,173,186, 3,64,52,217,226,250,124,123,
5,202,38,147,118,126,255,82,85,212,207,206,59,227,47,16,58,17,182,189,28,42,
223,183,170,213,119,248,152, 2,44,154,163, 70,221,153,101,155,167, 43,172,9,
129,22,39,253, 19,98,108,110,79,113,224,232,178,185, 112,104,218,246,97,228,
251,34,242,193,238,210,144,12,191,179,162,241, 81,51,145,235,249,14,239,107,
49,192,214, 31,181,199,106,157,184, 84,204,176,115,121,50,45,127, 4,150,254,
138,236,205,93,222,114,67,29,24,72,243,141,128,195,78,66,215,61,156,180};

int perm[512];


int simplex[64][4] = {
{0,1,2,3},{0,1,3,2},{0,0,0,0},{0,2,3,1},{0,0,0,0},{0,0,0,0},{0,0,0,0},{1,2,3,0},
{0,2,1,3},{0,0,0,0},{0,3,1,2},{0,3,2,1},{0,0,0,0},{0,0,0,0},{0,0,0,0},{1,3,2,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{1,2,0,3},{0,0,0,0},{1,3,0,2},{0,0,0,0},{0,0,0,0},{0,0,0,0},{2,3,0,1},{2,3,1,0},
{1,0,2,3},{1,0,3,2},{0,0,0,0},{0,0,0,0},{0,0,0,0},{2,0,3,1},{0,0,0,0},{2,1,3,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{2,0,1,3},{0,0,0,0},{0,0,0,0},{0,0,0,0},{3,0,1,2},{3,0,2,1},{0,0,0,0},{3,1,2,0},
{2,1,0,3},{0,0,0,0},{0,0,0,0},{0,0,0,0},{3,1,0,2},{0,0,0,0},{3,2,0,1},{3,2,1,0}};

const double e = 2.71828182845904523536;
const double PI = 3.141592;

double Dot2D(int tbl[],double x,double y)
{
    return tbl[0]*x + tbl[1]*y; 
}

double Dot3D(int tbl[],double x,double y,double z)
{
    return tbl[0]*x + tbl[1]*y + tbl[2]*z;
}

double Dot4D(int tbl[],double x,double y,double z,double w) 
{
    return tbl[0]*x + tbl[1]*y + tbl[2]*z + tbl[3]*w;
}

float Noise2D(double xin, double yin)
{
    double n0, n1, n2; // Noise contributions from the three corners
    // Skew the input space to determine which simplex cell we're in
    double F2 = 0.5*(sqrt(3.0)-1.0);
    double s = (xin+yin)*F2; // Hairy factor for 2D
    int i = floor(xin+s);
    int j = floor(yin+s);
    double G2 = (3.0-sqrt(3.0))/6.0;
    
    double t = (i+j)*G2;
    double X0 = i-t; // Unskew the cell origin back to (x,y) space
    double Y0 = j-t;
    double x0 = xin-X0; // The x,y distances from the cell origin
    double y0 = yin-Y0;
    
    // For the 2D case, the simplex shape is an equilateral triangle.
    // Determine which simplex we are in.
    int i1, j1; // Offsets for second (middle) corner of simplex in (i,j) coords
    if(x0>y0){
        i1=1; 
        j1=0;  // lower triangle, XY order: (0,0)->(1,0)->(1,1)
    }
    else {
        i1=0;
        j1=1; // upper triangle, YX order: (0,0)->(0,1)->(1,1)
    }
    
    // A step of (1,0) in (i,j) means a step of (1-c,-c) in (x,y), and
    // a step of (0,1) in (i,j) means a step of (-c,1-c) in (x,y), where
    // c = (3-sqrt(3))/6

    double x1 = x0 - i1 + G2; // Offsets for middle corner in (x,y) unskewed coords
    double y1 = y0 - j1 + G2;
    double x2 = x0 - 1.0 + 2.0 * G2; // Offsets for last corner in (x,y) unskewed coords
    double y2 = y0 - 1.0 + 2.0 * G2;

    // Work out the hashed gradient indices of the three simplex corners
    int ii = i & 255;
    int jj = j & 255;
    int gi0 = perm[ii+perm[jj]] % 12;
    int gi1 = perm[ii+i1+perm[jj+j1]] % 12;
    int gi2 = perm[ii+1+perm[jj+1]] % 12;

    // Calculate the contribution from the three corners
    double t0 = 0.5 - x0*x0-y0*y0;
    if (t0<0){
        n0 = 0.0;
    }
    else{
        t0 = t0 * t0;
        n0 = t0 * t0 * Dot2D(gradients3d[gi0], x0, y0); // (x,y) of Gradients3D used for 2D gradient
    }
    
    double t1 = 0.5 - x1*x1-y1*y1;
    if (t1<0){
        n1 = 0.0;
    }
    else{
        t1 = t1*t1;
        n1 = t1 * t1 * Dot2D(gradients3d[gi1], x1, y1);
    }
    
    double t2 = 0.5 - x2*x2-y2*y2;
    if (t2<0){
        n2 = 0.0;
    }
    else{
        t2 = t2*t2;
        n2 = t2 * t2 * Dot2D(gradients3d[gi2], x2, y2);
    }
    
    // Add contributions from each corner to get the final noise value.
    // The result is scaled to return values in the localerval [-1,1].
    float ret = (70.0 * (n0 + n1 + n2));

    return ret;
}

float Noise3D(double xin, double yin,double zin)
{
    double n0, n1, n2, n3; // Noise contributions from the four corners
    
    // Skew the input space to determine which simplex cell we're in
    double F3 = 1.0/3.0;
    double s = (xin+yin+zin)*F3; // Very nice and simple skew factor for 3D
    int i = floor(xin+s);
    int j = floor(yin+s);
    int k = floor(zin+s);
    
    double G3 = 1.0/6.0; // Very nice and simple unskew factor, too
    double t = (i+j+k)*G3;
    
    double X0 = i-t; // Unskew the cell origin back to (x,y,z) space
    double Y0 = j-t;
    double Z0 = k-t;
    
    double x0 = xin-X0; // The x,y,z distances from the cell origin
    double y0 = yin-Y0;
    double z0 = zin-Z0;
    
    // For the 3D case, the simplex shape is a slightly irregular tetrahedron.
    // Determine which simplex we are in.
    int i1, j1, k1; // Offsets for second corner of simplex in (i,j,k) coords
    int i2, j2, k2; // Offsets for third corner of simplex in (i,j,k) coords
    
    if (x0>=y0){
        if (y0>=z0){
            i1=1; j1=0; k1=0; i2=1; j2=1; k2=0; // X Y Z order
        }
        else if (x0>=z0){
            i1=1; j1=0; k1=0; i2=1; j2=0; k2=1; // X Z Y order
        }
        else{
            i1=0; j1=0; k1=1; i2=1; j2=0; k2=1;  // Z X Y order
        }
    }
    else{ // x0<y0
        if (y0<z0){
            i1=0; j1=0; k1=1; i2=0; j2=1; k2=1; // Z Y X order
        }
        else if (x0<z0){
            i1=0; j1=1; k1=0; i2=0; j2=1; k2=1; // Y Z X order
        }
        else{ 
            i1=0; j1=1; k1=0; i2=1; j2=1; k2=0; // Y X Z order
        }
    }
    
    // A step of (1,0,0) in (i,j,k) means a step of (1-c,-c,-c) in (x,y,z),
    // a step of (0,1,0) in (i,j,k) means a step of (-c,1-c,-c) in (x,y,z), and
    // a step of (0,0,1) in (i,j,k) means a step of (-c,-c,1-c) in (x,y,z), where
    // c = 1/6.
    
    double x1 = x0 - i1 + G3; // Offsets for second corner in (x,y,z) coords
    double y1 = y0 - j1 + G3;
    double z1 = z0 - k1 + G3;
    
    double x2 = x0 - i2 + 2.0*G3; // Offsets for third corner in (x,y,z) coords
    double y2 = y0 - j2 + 2.0*G3;
    double z2 = z0 - k2 + 2.0*G3;
    
    double x3 = x0 - 1.0 + 3.0*G3; // Offsets for last corner in (x,y,z) coords
    double y3 = y0 - 1.0 + 3.0*G3;
    double z3 = z0 - 1.0 + 3.0*G3;
    
    // Work out the hashed gradient indices of the four simplex corners
    int ii = i & 255;
    int jj = j & 255;
    int kk = k & 255;
    
    int gi0 = perm[ii+perm[jj+perm[kk]]] % 12;
    int gi1 = perm[ii+i1+perm[jj+j1+perm[kk+k1]]] % 12;
    int gi2 = perm[ii+i2+perm[jj+j2+perm[kk+k2]]] % 12;
    int gi3 = perm[ii+1+perm[jj+1+perm[kk+1]]] % 12;
    
    // Calculate the contribution from the four corners
    double t0 = 0.6 - x0*x0 - y0*y0 - z0*z0;
    
    if (t0<0){
        n0 = 0.0;
    }
    else {
        t0 = t0*t0;
        n0 = t0 * t0 * Dot3D(gradients3d[gi0], x0, y0, z0);
    }
    
    double t1 = 0.6 - x1*x1 - y1*y1 - z1*z1;
    
    if (t1<0){ 
        n1 = 0.0;
    }
    else{
        t1 = t1*t1;
        n1 = t1 * t1 * Dot3D(gradients3d[gi1], x1, y1, z1);
    }
    
    double t2 = 0.6 - x2*x2 - y2*y2 - z2*z2;
    
    if (t2<0){
        n2 = 0.0;
    }
    else{
        t2 = t2*t2;
        n2 = t2 * t2 * Dot3D(gradients3d[gi2], x2, y2, z2);
    }
    
    double t3 = 0.6 - x3*x3 - y3*y3 - z3*z3;
    
    if (t3<0){
        n3 = 0.0;
    }
    else{
        t3 = t3*t3;
        n3 = t3 * t3 * Dot3D(gradients3d[gi3], x3, y3, z3);
    }
    
    
    // Add contributions from each corner to get the final noise value.
    // The result is scaled to stay just inside [-1,1]
    float retval = 32.0*(n0 + n1 + n2 + n3);
    
    return retval;
}

float Noise4D(double x,double y,double z,double w)
{
    // The skewing and unskewing factors are hairy again for the 4D case
    double F4 = (sqrt(5.0)-1.0)/4.0;
    double G4 = (5.0-sqrt(5.0))/20.0;
    double n0, n1, n2, n3, n4; // Noise contributions from the five corners
    // Skew the (x,y,z,w) space to determine which cell of 24 simplices we're in
    double s = (x + y + z + w) * F4; // Factor for 4D skewing
    int i = floor(x + s);
    int j = floor(y + s);
    int k = floor(z + s);
    int l = floor(w + s);
    double t = (i + j + k + l) * G4; // Factor for 4D unskewing
    double X0 = i - t; // Unskew the cell origin back to (x,y,z,w) space
    double Y0 = j - t;
    double Z0 = k - t;
    double W0 = l - t;
    double x0 = x - X0; // The x,y,z,w distances from the cell origin
    double y0 = y - Y0;
    double z0 = z - Z0;
    double w0 = w - W0;
    // For the 4D case, the simplex is a 4D shape I won't even try to describe.
    // To find out which of the 24 possible simplices we're in, we need to
    // determine the magnitude ordering of x0, y0, z0 and w0.
    // The method below is a good way of finding the ordering of x,y,z,w and
    // then find the correct traversal order for the simplex we’re in.
    // First, six pair-wise comparisons are performed between each possible pair
    // of the four coordinates, and the results are used to add up binary bits
    // for an localeger index.
    int c1 = (x0 > y0) ? 32 : 1;
    int c2 = (x0 > z0) ? 16 : 1;
    int c3 = (y0 > z0) ? 8 : 1;
    int c4 = (x0 > w0) ? 4 : 1;
    int c5 = (y0 > w0) ? 2 : 1;
    int c6 = (z0 > w0) ? 1 : 1;
    int c = c1 + c2 + c3 + c4 + c5 + c6;
    int i1, j1, k1, l1; // The localeger offsets for the second simplex corner
    int i2, j2, k2, l2; // The localeger offsets for the third simplex corner
    int i3, j3, k3, l3; // The localeger offsets for the fourth simplex corner
    
    // simplex[c] is a 4-vector with the numbers 0, 1, 2 and 3 in some order.
    // Many values of c will never occur, since e.g. x>y>z>w makes x<z, y<w and x<w
    // impossible. Only the 24 indices which have non-zero entries make any sense.
    // We use a thresholding to set the coordinates in turn from the largest magnitude.
    // The number 3 in the "simplex" array is at the position of the largest coordinate.
    
    i1 = simplex[c][1]>=3 ? 1 : 0;
    j1 = simplex[c][2]>=3 ? 1 : 0;
    k1 = simplex[c][3]>=3 ? 1 : 0;
    l1 = simplex[c][4]>=3 ? 1 : 0;
    // The number 2 in the "simplex" array is at the second largest co:dinate.
    i2 = simplex[c][1]>=2 ? 1 : 0;
    j2 = simplex[c][2]>=2 ? 1 : 0;
    k2 = simplex[c][3]>=2 ? 1 : 0;
    l2 = simplex[c][4]>=2 ? 1 : 0;
    // The number 1 in the "simplex" array is at the second smallest co:dinate.
    i3 = simplex[c][1]>=1 ? 1 : 0;
    j3 = simplex[c][2]>=1 ? 1 : 0;
    k3 = simplex[c][3]>=1 ? 1 : 0;
    l3 = simplex[c][4]>=1 ? 1 : 0;
    // The fifth corner has all coordinate offsets = 1, so no need to look that up.
    double x1 = x0 - i1 + G4; // Offsets for second corner in (x,y,z,w) coords
    double y1 = y0 - j1 + G4;
    double z1 = z0 - k1 + G4;
    double w1 = w0 - l1 + G4;
    double x2 = x0 - i2 + 2.0*G4; // Offsets for third corner in (x,y,z,w) coords
    double y2 = y0 - j2 + 2.0*G4;
    double z2 = z0 - k2 + 2.0*G4;
    double w2 = w0 - l2 + 2.0*G4;
    double x3 = x0 - i3 + 3.0*G4; // Offsets for fourth corner in (x,y,z,w) coords
    double y3 = y0 - j3 + 3.0*G4;
    double z3 = z0 - k3 + 3.0*G4;
    double w3 = w0 - l3 + 3.0*G4;
    double x4 = x0 - 1.0 + 4.0*G4; // Offsets for last corner in (x,y,z,w) coords
    double y4 = y0 - 1.0 + 4.0*G4;
    double z4 = z0 - 1.0 + 4.0*G4;
    double w4 = w0 - 1.0 + 4.0*G4;
    
    // Work out the hashed gradient indices of the five simplex corners
    int ii = i & 255;
    int jj = j & 255;
    int kk = k & 255;
    int ll = l & 255;
    int gi0 = perm[ii+perm[jj+perm[kk+perm[ll]]]] % 32;
    int gi1 = perm[ii+i1+perm[jj+j1+perm[kk+k1+perm[ll+l1]]]] % 32;
    int gi2 = perm[ii+i2+perm[jj+j2+perm[kk+k2+perm[ll+l2]]]] % 32;
    int gi3 = perm[ii+i3+perm[jj+j3+perm[kk+k3+perm[ll+l3]]]] % 32;
    int gi4 = perm[ii+1+perm[jj+1+perm[kk+1+perm[ll+1]]]] % 32;
    
    
    // Calculate the contribution from the five corners
    double t0 = 0.6 - x0*x0 - y0*y0 - z0*z0 - w0*w0;
    if (t0<0){
        n0 = 0.0;
    }
    else{
        t0 = t0*t0;
        n0 = t0 * t0 * Dot4D(gradients4d[gi0], x0, y0, z0, w0);
    }
    
    double t1 = 0.6 - x1*x1 - y1*y1 - z1*z1 - w1*w1;
    if (t1<0){
        n1 = 0.0;
    }
    else{
        t1 = t1*t1;
        n1 = t1 * t1 * Dot4D(gradients4d[gi1], x1, y1, z1, w1);
    }
    
    double t2 = 0.6 - x2*x2 - y2*y2 - z2*z2 - w2*w2;
    if (t2<0){
        n2 = 0.0;
    }
    else{
        t2 = t2*t2;
        n2 = t2 * t2 * Dot4D(gradients4d[gi2], x2, y2, z2, w2);
    }
    
    double t3 = 0.6 - x3*x3 - y3*y3 - z3*z3 - w3*w3;
    if (t3<0){
        n3 = 0.0;
    }
    else {
        t3 = t3*t3;
        n3 = t3 * t3 * Dot4D(gradients4d[gi3], x3, y3, z3, w3);
    }
    
    double t4 = 0.6 - x4*x4 - y4*y4 - z4*z4 - w4*w4;
    if (t4<0){
        n4 = 0.0;
    }
    else{
        t4 = t4*t4;
        n4 = t4 * t4 * Dot4D(gradients4d[gi4], x4, y4, z4, w4);
    }
    
    // Sum up and scale the result to cover the range [-1,1]
    
    float retval = 27.0 * (n0 + n1 + n2 + n3 + n4);
    
    return retval;
}

LUA_FUNCTION( LNoise2D )
{
    g_Lua->CheckType( 1, GLua::TYPE_NUMBER );
    g_Lua->CheckType( 2, GLua::TYPE_NUMBER );
 
    double xin = g_Lua->GetNumber( 1 );
    double yin = g_Lua->GetNumber( 2 );

    g_Lua->Push(float (Noise2D(xin,yin)));
    return 1;
}

LUA_FUNCTION( LNoise3D )
{
    g_Lua->CheckType( 1, GLua::TYPE_NUMBER );
    g_Lua->CheckType( 2, GLua::TYPE_NUMBER );
    g_Lua->CheckType( 3, GLua::TYPE_NUMBER );
 
    double xin = g_Lua->GetNumber( 1 );
    double yin = g_Lua->GetNumber( 2 );
    double zin = g_Lua->GetNumber( 3 );

    g_Lua->Push(float (Noise3D(xin,yin,zin)));
    return 1;
}

LUA_FUNCTION( LNoise4D )
{
    g_Lua->CheckType( 1, GLua::TYPE_NUMBER );
    g_Lua->CheckType( 2, GLua::TYPE_NUMBER );
    g_Lua->CheckType( 3, GLua::TYPE_NUMBER );
    g_Lua->CheckType( 4, GLua::TYPE_NUMBER );
 
    double xin = g_Lua->GetNumber( 1 );
    double yin = g_Lua->GetNumber( 2 );
    double zin = g_Lua->GetNumber( 3 );
    double win = g_Lua->GetNumber( 4 );

    g_Lua->Push(float (Noise4D(xin,yin,zin,win)));
    return 1;
}

LUA_FUNCTION( GBlur2D )
{
    g_Lua->CheckType( 1, GLua::TYPE_NUMBER );
    g_Lua->CheckType( 2, GLua::TYPE_NUMBER );
    g_Lua->CheckType( 3, GLua::TYPE_NUMBER );

    float x = g_Lua->GetNumber( 1 );
    float y = g_Lua->GetNumber( 2 );
    float stdDev = g_Lua->GetNumber( 3 );

    float pwr = ((pow(float (x),int (2))+pow(float (y),int (2)))/(2*pow(float (stdDev),int (2))))*-1;
    float ret = pow(float ((1/(2*PI*pow(stdDev,2)))*e),float (pwr));

    g_Lua->Push(float (ret));
    return 1;
}


LUA_FUNCTION( GBlur1D )
{
    g_Lua->CheckType( 1, GLua::TYPE_NUMBER );
    g_Lua->CheckType( 2, GLua::TYPE_NUMBER );

    float x = g_Lua->GetNumber( 1 );
    float stdDev = g_Lua->GetNumber( 2 );

    float pwr = (pow(float (x),int (2))/(2*pow(float (stdDev),int (2))))*-1;
    float ret = pow(float ((1/(sqrt(2*PI)*stdDev))*e), float(pwr));

    g_Lua->Push(float (ret));
    return 1;
}

LUA_FUNCTION( FractalSum2DNoise )
{
    g_Lua->CheckType( 1, GLua::TYPE_NUMBER );
    g_Lua->CheckType( 2, GLua::TYPE_NUMBER );
    g_Lua->CheckType( 3, GLua::TYPE_NUMBER );

    float x = g_Lua->GetNumber( 1 );
    float y = g_Lua->GetNumber( 2 );
    float itier = g_Lua->GetNumber( 3 );

    float ret = Noise2D(x,y);

    for (int i = 0 ; i < itier ; i++){
        float num = pow(2,itier);
        ret = ret + (i/num)*(Noise2D(x*(num/i),y*(num/i)));
    }
    g_Lua->Push(float (ret));
    return 1;
}

LUA_FUNCTION( FractalSumAbs2DNoise )
{
    g_Lua->CheckType( 1, GLua::TYPE_NUMBER );
    g_Lua->CheckType( 2, GLua::TYPE_NUMBER );
    g_Lua->CheckType( 3, GLua::TYPE_NUMBER );

    float x = g_Lua->GetNumber( 1 );
    float y = g_Lua->GetNumber( 2 );
    float itier = g_Lua->GetNumber( 3 );

    float ret = abs(Noise2D(x,y));

    for (int i = 0 ; i < itier ; i++){
        float num = pow(2,itier);
        ret = ret + (i/num)*abs(Noise2D(x*(num/i),y*(num/i)));
    }
    g_Lua->Push(float (ret));
    return 1;
}

LUA_FUNCTION( Turbulent2DNoise )
{
    g_Lua->CheckType( 1, GLua::TYPE_NUMBER );
    g_Lua->CheckType( 2, GLua::TYPE_NUMBER );
    g_Lua->CheckType( 3, GLua::TYPE_NUMBER );

    float x = g_Lua->GetNumber( 1 );
    float y = g_Lua->GetNumber( 2 );
    float itier = g_Lua->GetNumber( 3 );

    float ret = abs(Noise2D(x,y));

    for (int i = 0 ; i < itier ; i++){
        float num = pow(2,itier);
        ret = ret + (i/num)*abs(Noise2D(x*(num/i),y*(num/i)));
    }
    g_Lua->Push(float (sin(x+ret)));
    return 1;
}

LUA_FUNCTION( FractalSum3DNoise )
{
    g_Lua->CheckType( 1, GLua::TYPE_NUMBER );
    g_Lua->CheckType( 2, GLua::TYPE_NUMBER );
    g_Lua->CheckType( 3, GLua::TYPE_NUMBER );
    g_Lua->CheckType( 4, GLua::TYPE_NUMBER );

    float x = g_Lua->GetNumber( 1 );
    float y = g_Lua->GetNumber( 2 );
    float z = g_Lua->GetNumber( 3 );
    float itier = g_Lua->GetNumber( 4 );

    float ret = Noise3D(x,y,z);

    for (int i = 0 ; i < itier ; i++){
        float num = pow(2,itier);
        ret = ret + (i/num)*(Noise3D(x*(num/i),y*(num/i),z*(num/i)));
    }
    g_Lua->Push(float (ret));
    return 1;
}

LUA_FUNCTION( FractalSumAbs3DNoise )
{
    g_Lua->CheckType( 1, GLua::TYPE_NUMBER );
    g_Lua->CheckType( 2, GLua::TYPE_NUMBER );
    g_Lua->CheckType( 3, GLua::TYPE_NUMBER );
    g_Lua->CheckType( 4, GLua::TYPE_NUMBER );

    float x = g_Lua->GetNumber( 1 );
    float y = g_Lua->GetNumber( 2 );
    float z = g_Lua->GetNumber( 3 );
    float itier = g_Lua->GetNumber( 4 );

    float ret = abs(Noise3D(x,y,z));

    for (int i = 0 ; i < itier ; i++){
        float num = pow(2,itier);
        ret = ret + (i/num)*abs(Noise3D(x*(num/i),y*(num/i),z*(num/i)));
    }
    g_Lua->Push(float (ret));
    return 1;
}

LUA_FUNCTION( Turbulent3DNoise )
{
    g_Lua->CheckType( 1, GLua::TYPE_NUMBER );
    g_Lua->CheckType( 2, GLua::TYPE_NUMBER );
    g_Lua->CheckType( 3, GLua::TYPE_NUMBER );
    g_Lua->CheckType( 4, GLua::TYPE_NUMBER );

    float x = g_Lua->GetNumber( 1 );
    float y = g_Lua->GetNumber( 2 );
    float z = g_Lua->GetNumber( 3 );
    float itier = g_Lua->GetNumber( 4 );

    float ret = abs(Noise3D(x,y,z));

    for (int i = 0 ; i < itier ; i++){
        float num = pow(2,itier);
        ret = ret + (i/num)*abs(Noise3D(x*(num/i),y*(num/i),z*(num/i)));
    }
    g_Lua->Push(float (sin(x+ret)));
    return 1;
}

LUA_FUNCTION( FractalSum4DNoise )
{
    g_Lua->CheckType( 1, GLua::TYPE_NUMBER );
    g_Lua->CheckType( 2, GLua::TYPE_NUMBER );
    g_Lua->CheckType( 3, GLua::TYPE_NUMBER );
    g_Lua->CheckType( 4, GLua::TYPE_NUMBER );
    g_Lua->CheckType( 5, GLua::TYPE_NUMBER );

    float x = g_Lua->GetNumber( 1 );
    float y = g_Lua->GetNumber( 2 );
    float z = g_Lua->GetNumber( 3 );
    float w = g_Lua->GetNumber( 4 );
    float itier = g_Lua->GetNumber( 5 );

    float ret = Noise4D(x,y,z,w);

    for (int i = 0 ; i < itier ; i++){
        float num = pow(2,itier);
        ret = ret + (i/num)*(Noise4D(x*(num/i),y*(num/i),z*(num/i),w*(num/i)));
    }
    g_Lua->Push(float (ret));
    return 1;
}

LUA_FUNCTION( FractalSumAbs4DNoise )
{
    g_Lua->CheckType( 1, GLua::TYPE_NUMBER );
    g_Lua->CheckType( 2, GLua::TYPE_NUMBER );
    g_Lua->CheckType( 3, GLua::TYPE_NUMBER );
    g_Lua->CheckType( 4, GLua::TYPE_NUMBER );
    g_Lua->CheckType( 5, GLua::TYPE_NUMBER );

    float x = g_Lua->GetNumber( 1 );
    float y = g_Lua->GetNumber( 2 );
    float z = g_Lua->GetNumber( 3 );
    float w = g_Lua->GetNumber( 4 );
    float itier = g_Lua->GetNumber( 5 );

    float ret = abs(Noise4D(x,y,z,w));

    for (int i = 0 ; i < itier ; i++){
        float num = pow(2,itier);
        ret = ret + (i/num)*abs(Noise4D(x*(num/i),y*(num/i),z*(num/i),w*(num/i)));
    }
    g_Lua->Push(float (ret));
    return 1;
}

LUA_FUNCTION( Turbulent4DNoise )
{
    g_Lua->CheckType( 1, GLua::TYPE_NUMBER );
    g_Lua->CheckType( 2, GLua::TYPE_NUMBER );
    g_Lua->CheckType( 3, GLua::TYPE_NUMBER );
    g_Lua->CheckType( 4, GLua::TYPE_NUMBER );
    g_Lua->CheckType( 5, GLua::TYPE_NUMBER );

    float x = g_Lua->GetNumber( 1 );
    float y = g_Lua->GetNumber( 2 );
    float z = g_Lua->GetNumber( 3 );
    float w = g_Lua->GetNumber( 4 );
    float itier = g_Lua->GetNumber( 5 );

    float ret = abs(Noise4D(x,y,z,w));

    for (int i = 0 ; i < itier ; i++){
        float num = pow(2,itier);
        ret = ret + (i/num)*abs(Noise4D(x*(num/i),y*(num/i),z*(num/i),w*(num/i)));
    }
    g_Lua->Push(float (sin(x+ret)));
    return 1;
}
 
// Initialization
int Init( lua_State *L )
{
    g_Lua = Lua();

    for (int i = 0 ; i < 255 ; i++) {
        perm* = p*;
        perm[i+256] = p*;
    }

    g_Lua->NewGlobalTable( "simplexnoise" );
    ILuaObject* simplexnoise = g_Lua->GetGlobal( "simplexnoise" );
        simplexnoise->SetMember( "Noise2D", LNoise2D );
        simplexnoise->SetMember( "Noise3D", LNoise3D );
        simplexnoise->SetMember( "Noise4D", LNoise4D );
        simplexnoise->SetMember( "GBlur1D", GBlur1D );
        simplexnoise->SetMember( "GBlur2D", GBlur2D );
        simplexnoise->SetMember( "FractalSum2DNoise", FractalSum2DNoise );
        simplexnoise->SetMember( "FractalSum3DNoise", FractalSum3DNoise );
        simplexnoise->SetMember( "FractalSum4DNoise", FractalSum4DNoise );
        simplexnoise->SetMember( "FractalSumAbs2DNoise", FractalSumAbs2DNoise );
        simplexnoise->SetMember( "FractalSumAbs3DNoise", FractalSumAbs3DNoise );
        simplexnoise->SetMember( "FractalSumAbs4DNoise", FractalSumAbs4DNoise );
        simplexnoise->SetMember( "Turbulent2DNoise", Turbulent2DNoise );
        simplexnoise->SetMember( "Turbulent3DNoise", Turbulent3DNoise );
        simplexnoise->SetMember( "Turbulent4DNoise", Turbulent4DNoise );
    simplexnoise->UnReference();

    return 0;
}
 
 
// Shutdown
int Shutdown( lua_State *L )
{
    return 0;
}

Example Code:
[lua]require(“simplexnoise”)

concommand.Add(“Noise2DTest”,function(ply,cmd,arg)
local SimNoiseTbl = {}
local scl = arg[1] or 1
for x=1,256 do
if not SimNoiseTbl then SimNoiseTbl = {} end
for y=1,256 do
SimNoiseTbl[y] = simplexnoise.Noise2D(x/(256scl),y/(256scl))
end
end
hook.Add(“HUDPaint”,“ImmaTestMahNoise”,function()
for x=1,256 do
for y=1,256 do
local v = (SimNoiseTbl[y]+1)/2 --normalize to 0-1 range
surface.SetDrawColor(v255, v255, v*255, 255)
surface.DrawRect(x-1,y-1,1,1)
end
end
end)
end)

concommand.Add(“FractalNoise2DTest”,function(ply,cmd,arg)
local SimNoiseTbl = {}
local scl = arg[1] or 1
local i = arg[2] or 3
for x=1,256 do
if not SimNoiseTbl then SimNoiseTbl = {} end
for y=1,256 do
SimNoiseTbl[y] = simplexnoise.FractalSum2DNoise(x/(256scl),y/(256scl),i)
end
end
hook.Add(“HUDPaint”,“ImmaTestMahNoise”,function()
for x=1,256 do
for y=1,256 do
local v = (SimNoiseTbl[y]+1)/2 --normalize to 0-1 range
surface.SetDrawColor(v255, v255, v*255, 255)
surface.DrawRect(x-1,y-1,1,1)
end
end
end)
end)

concommand.Add(“Noise3DTest”,function(ply,cmd,arg)
local SimNoiseTbl = {}
local scl = arg[1] or 1
for x=1,256 do
if not SimNoiseTbl then SimNoiseTbl = {} end
for y=1,256 do
if not SimNoiseTbl[y] then SimNoiseTbl[y] = {} end
for t=1,20 do
SimNoiseTbl[y][t] = simplexnoise.Noise3D(x/(256scl),y/(256scl),t)
end
end
end
hook.Add(“HUDPaint”,“ImmaTestMahNoise”,function()
for x=1,256 do
for y=1,256 do
local t = math.floor(CurTime()%20)+1
local v = (SimNoiseTbl[y][t]+1)/2 --normalize to 0-1 range
surface.SetDrawColor(v255, v255, v*255, 255)
surface.DrawRect(x-1,y-1,1,1)
end
end
end)
end)[/lua](Only tests a few of the functions)

Available Functions:

[ul]
[li]simplexnoise.Noise2D(x,y)[/li][li]simplexnoise.Noise3D(x,y,z)[/li][li]simplexnoise.Noise4D(x,y,z,w)[/li][li]simplexnoise.GBlur1D(x,stdDev)[/li][li]simplexnoise.GBlur2D(x,y,stdDev)[/li][li]simplexnoise.FractalSum2DNoise(x,y,iterations)[/li][li]simplexnoise.FractalSum3DNoise(x,y,z,iterations)[/li][li]simplexnoise.FractalSum4DNoise(x,y,z,w,iterations)[/li][li]simplexnoise.FractalSumAbs2DNoise(x,y,iterations)[/li][li]simplexnoise.FractalSumAbs3DNoise(x,y,z,iterations)[/li][li]simplexnoise.FractalSumAbs4DNoise(x,y,z,w,iterations)[/li][li]simplexnoise.Turbulent2DNoise(x,y,iterations)[/li][li]simplexnoise.Turbulent3DNoise(x,y,z,iterations)[/li][li]simplexnoise.Turbulent4DNoise(x,y,z,w,iterations)[/li][/ul]

Download (Windows): http://dl.dropbox.com/u/99862/dlls/gm_simplexnoise.dll
[/release]

For the record: This is my first C++ Module, it may be poorly coded, so I would like some suggestions for improvement.
PS: Yes, this is a translation from lua for the lua module (which was, in turn, a translation from Java) i wrote to do the same thing awhile ago. It didn’t work in gmod (well) because it was too slow, this fixes that.

I came into this thread expecting something to do with baconbot

Would you believe I was about to request a continuous noise generator module?

Awesome!

This could be pretty useful for procedural texture generation. Make it render clouds now!

god yes

This is the ugliest brilliant code I’ve ever seen in c++.

I’m not sure 100% what this does but all the maths seem to be in line although I do instantly notice some issues with the coding where it’s all crammed together and a lot more precision is given to e than PI even though you’re using a double precision and then only using 6 digits after the decimal point.

Predictable noise can have it’s ups and downs.

I couldn’t be bothered to find pi to a more precise number, and am too much of a dilettante in C to know if a double variation of pi was stored as a constant somewhere already…

But, ah… “ugliest brilliant”?
I don’t get it.

you could google pi :smiley:


(User was banned for this post ("Dump Bump" - Craptasket))