2D / 3D / 4D optimised Perlin Noise Cg/HLSL library (cginc)

[Lex-DRL]

Hey guys.

As many of you know, HLSL’s noise() function supposed to return Perlin noise. However, it simply doesn’t work because none of GPU vendors support it in the average graphics card.
But in my currently developed shader, I absolutely needed it. So…

I’ve just finished porting the awesome simplex noise library to make it compatible with Unity’s CgFx/HLSL. Basically, it’s usual Perlin Noise we all are so familiar with. But it’s optimized to be as fast as possible to use it in real-time GPU rendering.
It doesn’t need any pre-computed arrays, textures or any other kind of external resourses.
It supports all noise generation types: by 2D, 3D and 4D vectors.

Here’s a screenshot:

And, as you might guess, I’m here not to just brag about it.
With no further words, here’s the archive:
1457748–79202–$noise-simplex.7z (4.36 KB)

It contains the cginc itself and a test shader which generates animated 3D noise in world space.
Enjoy!

Usage is as simple as possible:

• include the library:

#include "noiseSimplex.cginc"

• then, in your fragment or vertex shader, call the function:

float ns = snoise(v);

v is float vector of any dimention (2D / 3D / 4D). The returned result is float scalar in [-1,1] range.

• Due to the number of operations, you need to have shader model 3.0 at least.
  So don’t forget to add the following line right after CGPROGRAM:

#pragma target 3.0

[Lex-DRL]

Yeah, I’ve seen this blog, too. And tried “improved perlin noise” from it.

Maybe, his system is even faster then the library I posted above. But it’s also more complex. Much more.

I personally just couldn’t figure out how exactly it works.
There’s a tricky mix of shaders and scripts. As a shader writer, I was already confused by lack of any parameters in the shaders. Yes, there are example scenes which show how to apply this pairs of shader and script. But then I noticed that changing “seed” does absolutely nothing. And it’s completely unclear how exactly script interacts with shader.
That means, each time I’ll need a noise in a shader, I’ll have to ask our programmer to write some scripts for me. And even if these scripts would be pretty simple, it’s usually more difficult to explain what exactly I need. And it’s still extra work.

So yes, I believe, that guy’s noise system could be much more performance-efficient. But from production side, for my current task it just doesn’t worth it.

[reefwirrax]

Oh brilliant, you translated gustavson version on GPU? Oh nice one, yeS simplex noise is great because it’s all in one text. There is a mystery if simplex noise and improved noise are both the same function, many people think simplex is less advanced and quality readout than old perlin as it sounds like simple version, except that it is more quality readout and 2x faster. Perhaps that improved noise is a sleepy version that was rewritten on and is alledgedly faster, with the wrong name that simplex noise!!! arg! with perhaps there is “Branches, LUT sizes, memory patterns, var numbers, live variables”. Except probably your version is faster because it is all on CG and and also the only one available so far. I think the skrawc version has a code for the perlin arrays, a code for passing the arrays to the graphics, and a CG the maths, s0 5-7 different codes so it may be possible to copy it to 2 codes, i think it written by cg book writer, you can do a 20mb test if you had to for speeds. i think there is also a simplex by J gotlen for unity cg lol. people have made comparison of value noise and graident noise from libnoise, gradient noise is slower and more round. it’s pretty good after programming synthesizers because synths are all 2d noise and 3d is al 3d noise

[Dolkar]

Just noticed this… and I noticed there’s a room for optimization there. You’re not using built-in cg functions that are optimized by GPU manufacturers, but instead implementing your own…

mod289(x) = fmod(x, 289.0)
taylorInvSqrt(x) = rsqrt(x)

// GLSL: lessThan(x, y) = x < y
// HLSL: 1 - step(y, x) = x < y
s = float4(
	1 - step(0.0, p)
);
p.xyz = p.xyz + (s.xyz * 2 - 1) * s.www; 

// Which is equivalent to:
p.xyz -= sign(p.xyz) * (p.w < 0);

// float2 i1 = (x0.x > x0.y) ? float2(1.0, 0.0) : float2(0.0, 1.0);
// Lex-DRL: afaik, step() in GPU is faster than if(), so:
// step(x, y) = x <= y
int xLessEqual = step(x0.x, x0.y); // x <= y ?
int2 i1 =
	int2(1, 0) * (1 - xLessEqual) // x > y
	+ int2(0, 1) * xLessEqual // x <= y
;
float4 x12 = x0.xyxy + C.xxzz;
x12.xy -= i1;

// Actually, a simple conditional without branching is faster than that madness :)
float4 x12 = x0.xyxy + C.xxzz;
x12.xy -= (x0.x > x0.y) ? float2(1.0, 0.0) : float2(0.0, 1.0);

… and I just ran out of time, but you see what I mean…

[Lex-DRL]

reefwirrax,
one important remark: it’s not my version of noise. I only ported it from GLSL to Cg/HLSL. All the credits are in the file itself.

Dolkar,
I’m newbie in cg shading.
I have quite a significant experience in writing RenderMan shaders, but some realtime-shading approaches are still new for me. So yes, there may be a lot of room for optimization… especially considering the fact that the original (GLSL-) lib author admitted he didn’t spend too much time optimizing it.

Feel free to provide patches if you want… or, if you think it’s necessary, I can create a project on GitHub.

[NavyFish]

For archival purposes, here’s the same code with Dolkar’s optimizations incorporated - with the exception of taylorInvSqrt, which to my understanding does not actually equate to rsqrt.

FWIW, on a GTX580m, conducting a compute shader which uses 30 octaves (way overkill, for the purposes of the benchmark) of simplex noise, on 36 batches of 224x224 vertices per frame (total 1.8 million verts) - I saw about 1 FPS increase with the optimizations, from 38.5 to 39.5.

#ifndef NOISE_SIMPLEX_FUNC
#define NOISE_SIMPLEX_FUNC
/*

Description:
    Array- and textureless CgFx/HLSL 2D, 3D and 4D simplex noise functions.
    a.k.a. simplified and optimized Perlin noise.
 
    The functions have very good performance
    and no dependencies on external data.
 
    2D - Very fast, very compact code.
    3D - Fast, compact code.
    4D - Reasonably fast, reasonably compact code.

------------------------------------------------------------------

Ported by:
    Lex-DRL
    I've ported the code from GLSL to CgFx/HLSL for Unity,
    added a couple more optimisations (to speed it up even further)
    and slightly reformatted the code to make it more readable.

Original GLSL functions:
    https://github.com/ashima/webgl-noise
    Credits from original glsl file are at the end of this cginc.

------------------------------------------------------------------

Usage:
 
    float ns = snoise(v);
    // v is any of: float2, float3, float4
 
    Return type is float.
    To generate 2 or more components of noise (colorful noise),
    call these functions several times with different
    constant offsets for the arguments.
    E.g.:
 
    float3 colorNs = float3(
        snoise(v),
        snoise(v + 17.0),
        snoise(v - 43.0),
    );


Remark about those offsets from the original author:
 
    People have different opinions on whether these offsets should be integers
    for the classic noise functions to match the spacing of the zeroes,
    so we have left that for you to decide for yourself.
    For most applications, the exact offsets don't really matter as long
    as they are not too small or too close to the noise lattice period
    (289 in this implementation).

*/

// 1 / 289
#define NOISE_SIMPLEX_1_DIV_289 0.00346020761245674740484429065744f


// ( x*34.0 + 1.0 )*x =
// x*x*34.0 + x
float permute(float x) {
    return fmod(
        x*x*34.0 + x,
        289.0
    );
}

float3 permute(float3 x) {
    return fmod(
        x*x*34.0 + x,
        289.0
    );
}

float4 permute(float4 x) {
    return fmod(
        x*x*34.0 + x,
        289.0
    );
}



float taylorInvSqrt(float r) {
    return 1.79284291400159 - 0.85373472095314 * r;
}

float4 taylorInvSqrt(float4 r) {
    return 1.79284291400159 - 0.85373472095314 * r;
}



float4 grad4(float j, float4 ip)
{
    const float4 ones = float4(1.0, 1.0, 1.0, -1.0);
    float4 p, s;
    p.xyz = floor( frac(j * ip.xyz) * 7.0) * ip.z - 1.0;
    p.w = 1.5 - dot( abs(p.xyz), ones.xyz );
 
    // GLSL: lessThan(x, y) = x < y
    // HLSL: 1 - step(y, x) = x < y

    //s = float4(
    //    1 - step(0.0, p)
    //);
    //p.xyz = p.xyz + (s.xyz * 2 - 1) * s.www;

    p.xyz -= sign(p.xyz) * (p.w < 0);

    return p;
}



// ----------------------------------- 2D -------------------------------------

float snoise(float2 v)
{
    const float4 C = float4(
        0.211324865405187, // (3.0-sqrt(3.0))/6.0
        0.366025403784439, // 0.5*(sqrt(3.0)-1.0)
     -0.577350269189626, // -1.0 + 2.0 * C.x
        0.024390243902439  // 1.0 / 41.0
    );
 
// First corner
    float2 i = floor( v + dot(v, C.yy) );
    float2 x0 = v - i + dot(i, C.xx);
 
// Other corners
    // float2 i1 = (x0.x > x0.y) ? float2(1.0, 0.0) : float2(0.0, 1.0);
    // Lex-DRL: afaik, step() in GPU is faster than if(), so:
    // step(x, y) = x <= y

    //int xLessEqual = step(x0.x, x0.y); // x <= y ?
    //int2 i1 =
    //    int2(1, 0) * (1 - xLessEqual) // x > y
    //    + int2(0, 1) * xLessEqual // x <= y
    //;
    //float4 x12 = x0.xyxy + C.xxzz;
    //x12.xy -= i1;

    float4 x12 = x0.xyxy + C.xxzz;
    int2 i1 = (x0.x > x0.y) ? float2(1.0, 0.0) : float2(0.0, 1.0);
    x12.xy -= i1;
 
// Permutations
    i = fmod(i,289.0); // Avoid truncation effects in permutation
    float3 p = permute(
        permute(
                i.y + float3(0.0, i1.y, 1.0 )
        ) + i.x + float3(0.0, i1.x, 1.0 )
    );
 
    float3 m = max(
        0.5 - float3(
            dot(x0, x0),
            dot(x12.xy, x12.xy),
            dot(x12.zw, x12.zw)
        ),
        0.0
    );
    m = m*m ;
    m = m*m ;
 
// Gradients: 41 points uniformly over a line, mapped onto a diamond.
// The ring size 17*17 = 289 is close to a multiple of 41 (41*7 = 287)
 
    float3 x = 2.0 * frac(p * C.www) - 1.0;
    float3 h = abs(x) - 0.5;
    float3 ox = floor(x + 0.5);
    float3 a0 = x - ox;

// Normalise gradients implicitly by scaling m
// Approximation of: m *= inversesqrt( a0*a0 + h*h );
    m *= 1.79284291400159 - 0.85373472095314 * ( a0*a0 + h*h );

// Compute final noise value at P
    float3 g;
    g.x = a0.x * x0.x + h.x * x0.y;
    g.yz = a0.yz * x12.xz + h.yz * x12.yw;
    return 130.0 * dot(m, g);
}

// ----------------------------------- 3D -------------------------------------

float snoise(float3 v)
{
    const float2 C = float2(
        0.166666666666666667, // 1/6
        0.333333333333333333  // 1/3
    );
    const float4 D = float4(0.0, 0.5, 1.0, 2.0);
 
// First corner
    float3 i = floor( v + dot(v, C.yyy) );
    float3 x0 = v - i + dot(i, C.xxx);
 
// Other corners
    float3 g = step(x0.yzx, x0.xyz);
    float3 l = 1 - g;
    float3 i1 = min(g.xyz, l.zxy);
    float3 i2 = max(g.xyz, l.zxy);
 
    float3 x1 = x0 - i1 + C.xxx;
    float3 x2 = x0 - i2 + C.yyy; // 2.0*C.x = 1/3 = C.y
    float3 x3 = x0 - D.yyy;      // -1.0+3.0*C.x = -0.5 = -D.y
 
// Permutations
    i = fmod(i,289.0);
    float4 p = permute(
        permute(
            permute(
                    i.z + float4(0.0, i1.z, i2.z, 1.0 )
            ) + i.y + float4(0.0, i1.y, i2.y, 1.0 )
        )     + i.x + float4(0.0, i1.x, i2.x, 1.0 )
    );
 
// Gradients: 7x7 points over a square, mapped onto an octahedron.
// The ring size 17*17 = 289 is close to a multiple of 49 (49*6 = 294)
    float n_ = 0.142857142857; // 1/7
    float3 ns = n_ * D.wyz - D.xzx;
 
    float4 j = p - 49.0 * floor(p * ns.z * ns.z); // mod(p,7*7)
 
    float4 x_ = floor(j * ns.z);
    float4 y_ = floor(j - 7.0 * x_ ); // mod(j,N)
 
    float4 x = x_ *ns.x + ns.yyyy;
    float4 y = y_ *ns.x + ns.yyyy;
    float4 h = 1.0 - abs(x) - abs(y);
 
    float4 b0 = float4( x.xy, y.xy );
    float4 b1 = float4( x.zw, y.zw );
 
    //float4 s0 = float4(lessThan(b0,0.0))*2.0 - 1.0;
    //float4 s1 = float4(lessThan(b1,0.0))*2.0 - 1.0;
    float4 s0 = floor(b0)*2.0 + 1.0;
    float4 s1 = floor(b1)*2.0 + 1.0;
    float4 sh = -step(h, 0.0);
 
    float4 a0 = b0.xzyw + s0.xzyw*sh.xxyy ;
    float4 a1 = b1.xzyw + s1.xzyw*sh.zzww ;
 
    float3 p0 = float3(a0.xy,h.x);
    float3 p1 = float3(a0.zw,h.y);
    float3 p2 = float3(a1.xy,h.z);
    float3 p3 = float3(a1.zw,h.w);
 
//Normalise gradients
    float4 norm = taylorInvSqrt(float4(
        dot(p0, p0),
        dot(p1, p1),
        dot(p2, p2),
        dot(p3, p3)
    ));
    p0 *= norm.x;
    p1 *= norm.y;
    p2 *= norm.z;
    p3 *= norm.w;
 
// Mix final noise value
    float4 m = max(
        0.6 - float4(
            dot(x0, x0),
            dot(x1, x1),
            dot(x2, x2),
            dot(x3, x3)
        ),
        0.0
    );
    m = m * m;
    return 42.0 * dot(
        m*m,
        float4(
            dot(p0, x0),
            dot(p1, x1),
            dot(p2, x2),
            dot(p3, x3)
        )
    );
}

// ----------------------------------- 4D -------------------------------------

float snoise(float4 v)
{
    const float4 C = float4(
        0.138196601125011, // (5 - sqrt(5))/20 G4
        0.276393202250021, // 2 * G4
        0.414589803375032, // 3 * G4
     -0.447213595499958  // -1 + 4 * G4
    );

// First corner
    float4 i = floor(
        v +
        dot(
            v,
            0.309016994374947451 // (sqrt(5) - 1) / 4
        )
    );
    float4 x0 = v - i + dot(i, C.xxxx);

// Other corners

// Rank sorting originally contributed by Bill Licea-Kane, AMD (formerly ATI)
    float4 i0;
    float3 isX = step( x0.yzw, x0.xxx );
    float3 isYZ = step( x0.zww, x0.yyz );
    i0.x = isX.x + isX.y + isX.z;
    i0.yzw = 1.0 - isX;
    i0.y += isYZ.x + isYZ.y;
    i0.zw += 1.0 - isYZ.xy;
    i0.z += isYZ.z;
    i0.w += 1.0 - isYZ.z;

    // i0 now contains the unique values 0,1,2,3 in each channel
    float4 i3 = saturate(i0);
    float4 i2 = saturate(i0-1.0);
    float4 i1 = saturate(i0-2.0);

    //    x0 = x0 - 0.0 + 0.0 * C.xxxx
    //    x1 = x0 - i1  + 1.0 * C.xxxx
    //    x2 = x0 - i2  + 2.0 * C.xxxx
    //    x3 = x0 - i3  + 3.0 * C.xxxx
    //    x4 = x0 - 1.0 + 4.0 * C.xxxx
    float4 x1 = x0 - i1 + C.xxxx;
    float4 x2 = x0 - i2 + C.yyyy;
    float4 x3 = x0 - i3 + C.zzzz;
    float4 x4 = x0 + C.wwww;

// Permutations
    i = fmod(i,289.0);
    float j0 = permute(
        permute(
            permute(
                permute(i.w) + i.z
            ) + i.y
        ) + i.x
    );
    float4 j1 = permute(
        permute(
            permute(
                permute (
                    i.w + float4(i1.w, i2.w, i3.w, 1.0 )
                ) + i.z + float4(i1.z, i2.z, i3.z, 1.0 )
            ) + i.y + float4(i1.y, i2.y, i3.y, 1.0 )
        ) + i.x + float4(i1.x, i2.x, i3.x, 1.0 )
    );

// Gradients: 7x7x6 points over a cube, mapped onto a 4-cross polytope
// 7*7*6 = 294, which is close to the ring size 17*17 = 289.
    const float4 ip = float4(
        0.003401360544217687075, // 1/294
        0.020408163265306122449, // 1/49
        0.142857142857142857143, // 1/7
        0.0
    );

    float4 p0 = grad4(j0, ip);
    float4 p1 = grad4(j1.x, ip);
    float4 p2 = grad4(j1.y, ip);
    float4 p3 = grad4(j1.z, ip);
    float4 p4 = grad4(j1.w, ip);

// Normalise gradients
    float4 norm = taylorInvSqrt(float4(
        dot(p0, p0),
        dot(p1, p1),
        dot(p2, p2),
        dot(p3, p3)
    ));
    p0 *= norm.x;
    p1 *= norm.y;
    p2 *= norm.z;
    p3 *= norm.w;
    p4 *= taylorInvSqrt( dot(p4, p4) );

// Mix contributions from the five corners
    float3 m0 = max(
        0.6 - float3(
            dot(x0, x0),
            dot(x1, x1),
            dot(x2, x2)
        ),
        0.0
    );
    float2 m1 = max(
        0.6 - float2(
            dot(x3, x3),
            dot(x4, x4)
        ),
        0.0
    );
    m0 = m0 * m0;
    m1 = m1 * m1;
 
    return 49.0 * (
        dot(
            m0*m0,
            float3(
                dot(p0, x0),
                dot(p1, x1),
                dot(p2, x2)
            )
        ) + dot(
            m1*m1,
            float2(
                dot(p3, x3),
                dot(p4, x4)
            )
        )
    );
}



//                 Credits from source glsl file:
//
// Description : Array and textureless GLSL 2D/3D/4D simplex
//               noise functions.
//      Author : Ian McEwan, Ashima Arts.
//  Maintainer : ijm
//     Lastmod : 20110822 (ijm)
//     License : Copyright (C) 2011 Ashima Arts. All rights reserved.
//               Distributed under the MIT License. See LICENSE file.
//               https://github.com/ashima/webgl-noise
//
//
//           The text from LICENSE file:
//
//
// Copyright (C) 2011 by Ashima Arts (Simplex noise)
// Copyright (C) 2011 by Stefan Gustavson (Classic noise)
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
#endif

Please Note: There was a typo in the code, fixed on 7/7/2015 - if you copied this code prior to that point, it won’t compile.

[RiokuTheSlayer]

Thanks for this! I’ll definitely be using it at a later date.

[verrazuriz]

Oh i love you so so so much <3

[joergzdarsky]

Additional note to this thread, I’ve been using the latest piece of code summary from NavyFish for procedural planet generation, but noticed that based on the XYZ Input values the noise output was sometimes erroneous (sudden big value changes), which leaded in my case to strange heightmap artefacts.

I did take LEX-DRL’s original code and again applied two of the optimization hints of Dolkar (2nd and 3rd) and the artefacts were gone, the output correct. I’ve been in contact with NavyFish and we havent figured out what exactly the mistake in that latest code snippet is, however just in case you have some issues with the noise output you might want to try the fixed code below.

#ifndef NOISE_SIMPLEX_FUNC
#define NOISE_SIMPLEX_FUNC
/*

Description:
    Array- and textureless CgFx/HLSL 2D, 3D and 4D simplex noise functions.
    a.k.a. simplified and optimized Perlin noise.
  
    The functions have very good performance
    and no dependencies on external data.
  
    2D - Very fast, very compact code.
    3D - Fast, compact code.
    4D - Reasonably fast, reasonably compact code.

------------------------------------------------------------------

Ported by:
    Lex-DRL
    I've ported the code from GLSL to CgFx/HLSL for Unity,
    added a couple more optimisations (to speed it up even further)
    and slightly reformatted the code to make it more readable.

Original GLSL functions:
    https://github.com/ashima/webgl-noise
    Credits from original glsl file are at the end of this cginc.

------------------------------------------------------------------

Usage:
  
    float ns = snoise(v);
    // v is any of: float2, float3, float4
  
    Return type is float.
    To generate 2 or more components of noise (colorful noise),
    call these functions several times with different
    constant offsets for the arguments.
    E.g.:
  
    float3 colorNs = float3(
        snoise(v),
        snoise(v + 17.0),
        snoise(v - 43.0),
    );


Remark about those offsets from the original author:
  
    People have different opinions on whether these offsets should be integers
    for the classic noise functions to match the spacing of the zeroes,
    so we have left that for you to decide for yourself.
    For most applications, the exact offsets don't really matter as long
    as they are not too small or too close to the noise lattice period
    (289 in this implementation).

*/

// 1 / 289
#define NOISE_SIMPLEX_1_DIV_289 0.00346020761245674740484429065744f

float mod289(float x) {
    return x - floor(x * NOISE_SIMPLEX_1_DIV_289) * 289.0;
}

float2 mod289(float2 x) {
    return x - floor(x * NOISE_SIMPLEX_1_DIV_289) * 289.0;
}

float3 mod289(float3 x) {
    return x - floor(x * NOISE_SIMPLEX_1_DIV_289) * 289.0;
}

float4 mod289(float4 x) {
    return x - floor(x * NOISE_SIMPLEX_1_DIV_289) * 289.0;
}


// ( x*34.0 + 1.0 )*x =
// x*x*34.0 + x
float permute(float x) {
    return mod289(
        x*x*34.0 + x
    );
}

float3 permute(float3 x) {
    return mod289(
        x*x*34.0 + x
    );
}

float4 permute(float4 x) {
    return mod289(
        x*x*34.0 + x
    );
}



float taylorInvSqrt(float r) {
    return 1.79284291400159 - 0.85373472095314 * r;
}

float4 taylorInvSqrt(float4 r) {
    return 1.79284291400159 - 0.85373472095314 * r;
}



float4 grad4(float j, float4 ip)
{
    const float4 ones = float4(1.0, 1.0, 1.0, -1.0);
    float4 p, s;
    p.xyz = floor( frac(j * ip.xyz) * 7.0) * ip.z - 1.0;
    p.w = 1.5 - dot( abs(p.xyz), ones.xyz );
  
    // GLSL: lessThan(x, y) = x < y
    // HLSL: 1 - step(y, x) = x < y
    s = float4(
        1 - step(0.0, p)
    );

    // Optimization hint Dolkar
    // p.xyz = p.xyz + (s.xyz * 2 - 1) * s.www;
    p.xyz -= sign(p.xyz) * (p.w < 0);

    return p;
}



// ----------------------------------- 2D -------------------------------------

float snoise(float2 v)
{
    const float4 C = float4(
        0.211324865405187, // (3.0-sqrt(3.0))/6.0
        0.366025403784439, // 0.5*(sqrt(3.0)-1.0)
     -0.577350269189626, // -1.0 + 2.0 * C.x
        0.024390243902439  // 1.0 / 41.0
    );
  
// First corner
    float2 i = floor( v + dot(v, C.yy) );
    float2 x0 = v - i + dot(i, C.xx);
  
// Other corners
    // float2 i1 = (x0.x > x0.y) ? float2(1.0, 0.0) : float2(0.0, 1.0);
    // Lex-DRL: afaik, step() in GPU is faster than if(), so:
    // step(x, y) = x <= y

    // Optimization hint Dolkar
    //int xLessEqual = step(x0.x, x0.y); // x <= y ?
    //int2 i1 =
    //    int2(1, 0) * (1 - xLessEqual) // x > y
    //    + int2(0, 1) * xLessEqual // x <= y
    //;
    //float4 x12 = x0.xyxy + C.xxzz;
    //x12.xy -= i1;

    float4 x12 = x0.xyxy + C.xxzz;
    int2 i1 = (x0.x > x0.y) ? float2(1.0, 0.0) : float2(0.0, 1.0);
    x12.xy -= i1;
  
// Permutations
    i = mod289(i); // Avoid truncation effects in permutation
    float3 p = permute(
        permute(
                i.y + float3(0.0, i1.y, 1.0 )
        ) + i.x + float3(0.0, i1.x, 1.0 )
    );
  
    float3 m = max(
        0.5 - float3(
            dot(x0, x0),
            dot(x12.xy, x12.xy),
            dot(x12.zw, x12.zw)
        ),
        0.0
    );
    m = m*m ;
    m = m*m ;
  
// Gradients: 41 points uniformly over a line, mapped onto a diamond.
// The ring size 17*17 = 289 is close to a multiple of 41 (41*7 = 287)
  
    float3 x = 2.0 * frac(p * C.www) - 1.0;
    float3 h = abs(x) - 0.5;
    float3 ox = floor(x + 0.5);
    float3 a0 = x - ox;

// Normalise gradients implicitly by scaling m
// Approximation of: m *= inversesqrt( a0*a0 + h*h );
    m *= 1.79284291400159 - 0.85373472095314 * ( a0*a0 + h*h );

// Compute final noise value at P
    float3 g;
    g.x = a0.x * x0.x + h.x * x0.y;
    g.yz = a0.yz * x12.xz + h.yz * x12.yw;
    return 130.0 * dot(m, g);
}

// ----------------------------------- 3D -------------------------------------

float snoise(float3 v)
{
    const float2 C = float2(
        0.166666666666666667, // 1/6
        0.333333333333333333  // 1/3
    );
    const float4 D = float4(0.0, 0.5, 1.0, 2.0);
  
// First corner
    float3 i = floor( v + dot(v, C.yyy) );
    float3 x0 = v - i + dot(i, C.xxx);
  
// Other corners
    float3 g = step(x0.yzx, x0.xyz);
    float3 l = 1 - g;
    float3 i1 = min(g.xyz, l.zxy);
    float3 i2 = max(g.xyz, l.zxy);
  
    float3 x1 = x0 - i1 + C.xxx;
    float3 x2 = x0 - i2 + C.yyy; // 2.0*C.x = 1/3 = C.y
    float3 x3 = x0 - D.yyy;      // -1.0+3.0*C.x = -0.5 = -D.y
  
// Permutations
    i = mod289(i);
    float4 p = permute(
        permute(
            permute(
                    i.z + float4(0.0, i1.z, i2.z, 1.0 )
            ) + i.y + float4(0.0, i1.y, i2.y, 1.0 )
        )     + i.x + float4(0.0, i1.x, i2.x, 1.0 )
    );
  
// Gradients: 7x7 points over a square, mapped onto an octahedron.
// The ring size 17*17 = 289 is close to a multiple of 49 (49*6 = 294)
    float n_ = 0.142857142857; // 1/7
    float3 ns = n_ * D.wyz - D.xzx;
  
    float4 j = p - 49.0 * floor(p * ns.z * ns.z); // mod(p,7*7)
  
    float4 x_ = floor(j * ns.z);
    float4 y_ = floor(j - 7.0 * x_ ); // mod(j,N)
  
    float4 x = x_ *ns.x + ns.yyyy;
    float4 y = y_ *ns.x + ns.yyyy;
    float4 h = 1.0 - abs(x) - abs(y);
  
    float4 b0 = float4( x.xy, y.xy );
    float4 b1 = float4( x.zw, y.zw );
  
    //float4 s0 = float4(lessThan(b0,0.0))*2.0 - 1.0;
    //float4 s1 = float4(lessThan(b1,0.0))*2.0 - 1.0;
    float4 s0 = floor(b0)*2.0 + 1.0;
    float4 s1 = floor(b1)*2.0 + 1.0;
    float4 sh = -step(h, 0.0);
  
    float4 a0 = b0.xzyw + s0.xzyw*sh.xxyy ;
    float4 a1 = b1.xzyw + s1.xzyw*sh.zzww ;
  
    float3 p0 = float3(a0.xy,h.x);
    float3 p1 = float3(a0.zw,h.y);
    float3 p2 = float3(a1.xy,h.z);
    float3 p3 = float3(a1.zw,h.w);
  
//Normalise gradients
    float4 norm = taylorInvSqrt(float4(
        dot(p0, p0),
        dot(p1, p1),
        dot(p2, p2),
        dot(p3, p3)
    ));
    p0 *= norm.x;
    p1 *= norm.y;
    p2 *= norm.z;
    p3 *= norm.w;
  
// Mix final noise value
    float4 m = max(
        0.6 - float4(
            dot(x0, x0),
            dot(x1, x1),
            dot(x2, x2),
            dot(x3, x3)
        ),
        0.0
    );
    m = m * m;
    return 42.0 * dot(
        m*m,
        float4(
            dot(p0, x0),
            dot(p1, x1),
            dot(p2, x2),
            dot(p3, x3)
        )
    );
}

// ----------------------------------- 4D -------------------------------------

float snoise(float4 v)
{
    const float4 C = float4(
        0.138196601125011, // (5 - sqrt(5))/20 G4
        0.276393202250021, // 2 * G4
        0.414589803375032, // 3 * G4
     -0.447213595499958  // -1 + 4 * G4
    );

// First corner
    float4 i = floor(
        v +
        dot(
            v,
            0.309016994374947451 // (sqrt(5) - 1) / 4
        )
    );
    float4 x0 = v - i + dot(i, C.xxxx);

// Other corners

// Rank sorting originally contributed by Bill Licea-Kane, AMD (formerly ATI)
    float4 i0;
    float3 isX = step( x0.yzw, x0.xxx );
    float3 isYZ = step( x0.zww, x0.yyz );
    i0.x = isX.x + isX.y + isX.z;
    i0.yzw = 1.0 - isX;
    i0.y += isYZ.x + isYZ.y;
    i0.zw += 1.0 - isYZ.xy;
    i0.z += isYZ.z;
    i0.w += 1.0 - isYZ.z;

    // i0 now contains the unique values 0,1,2,3 in each channel
    float4 i3 = saturate(i0);
    float4 i2 = saturate(i0-1.0);
    float4 i1 = saturate(i0-2.0);

    //    x0 = x0 - 0.0 + 0.0 * C.xxxx
    //    x1 = x0 - i1  + 1.0 * C.xxxx
    //    x2 = x0 - i2  + 2.0 * C.xxxx
    //    x3 = x0 - i3  + 3.0 * C.xxxx
    //    x4 = x0 - 1.0 + 4.0 * C.xxxx
    float4 x1 = x0 - i1 + C.xxxx;
    float4 x2 = x0 - i2 + C.yyyy;
    float4 x3 = x0 - i3 + C.zzzz;
    float4 x4 = x0 + C.wwww;

// Permutations
    i = mod289(i);
    float j0 = permute(
        permute(
            permute(
                permute(i.w) + i.z
            ) + i.y
        ) + i.x
    );
    float4 j1 = permute(
        permute(
            permute(
                permute (
                    i.w + float4(i1.w, i2.w, i3.w, 1.0 )
                ) + i.z + float4(i1.z, i2.z, i3.z, 1.0 )
            ) + i.y + float4(i1.y, i2.y, i3.y, 1.0 )
        ) + i.x + float4(i1.x, i2.x, i3.x, 1.0 )
    );

// Gradients: 7x7x6 points over a cube, mapped onto a 4-cross polytope
// 7*7*6 = 294, which is close to the ring size 17*17 = 289.
    const float4 ip = float4(
        0.003401360544217687075, // 1/294
        0.020408163265306122449, // 1/49
        0.142857142857142857143, // 1/7
        0.0
    );

    float4 p0 = grad4(j0, ip);
    float4 p1 = grad4(j1.x, ip);
    float4 p2 = grad4(j1.y, ip);
    float4 p3 = grad4(j1.z, ip);
    float4 p4 = grad4(j1.w, ip);

// Normalise gradients
    float4 norm = taylorInvSqrt(float4(
        dot(p0, p0),
        dot(p1, p1),
        dot(p2, p2),
        dot(p3, p3)
    ));
    p0 *= norm.x;
    p1 *= norm.y;
    p2 *= norm.z;
    p3 *= norm.w;
    p4 *= taylorInvSqrt( dot(p4, p4) );

// Mix contributions from the five corners
    float3 m0 = max(
        0.6 - float3(
            dot(x0, x0),
            dot(x1, x1),
            dot(x2, x2)
        ),
        0.0
    );
    float2 m1 = max(
        0.6 - float2(
            dot(x3, x3),
            dot(x4, x4)
        ),
        0.0
    );
    m0 = m0 * m0;
    m1 = m1 * m1;
  
    return 49.0 * (
        dot(
            m0*m0,
            float3(
                dot(p0, x0),
                dot(p1, x1),
                dot(p2, x2)
            )
        ) + dot(
            m1*m1,
            float2(
                dot(p3, x3),
                dot(p4, x4)
            )
        )
    );
}



//                 Credits from source glsl file:
//
// Description : Array and textureless GLSL 2D/3D/4D simplex
//               noise functions.
//      Author : Ian McEwan, Ashima Arts.
//  Maintainer : ijm
//     Lastmod : 20110822 (ijm)
//     License : Copyright (C) 2011 Ashima Arts. All rights reserved.
//               Distributed under the MIT License. See LICENSE file.
//               https://github.com/ashima/webgl-noise
//
//
//           The text from LICENSE file:
//
//
// Copyright (C) 2011 by Ashima Arts (Simplex noise)
// Copyright (C) 2011 by Stefan Gustavson (Classic noise)
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
#endif

[NavyFish]

Thanks, Joerg! I’m using your version now.

[JonRurka]

Just a quick question: how do I set the frequency and, more importantly, the seed?

[NavyFish]

Set the frequency by multiplying your input coordinates, I.E. snoise(float2(freqX, freqy)).

Currently I don’t think there’s a way to set the seed. You can offset your input coordinates by adding some value to them, but this only gets you so far.

Setting a new seed requires changing a permutation table - something this implementation does without. I’m slowly working on an implementation that allows you to change the seed but retains the portability of this implementation (i.e. no requirement to upload a look-up table to the GPU). It will be slightly slower than this approach, but hopefully not too bad. Once it’s working, I will share the code here!

[JoeStrout]

Just found this, and it’s great stuff. Thank you all for contributing.

Perhaps it’s a dumb question, but would it be worth including an efficient 1D implementation? I know I can just do snoise(float2(x, 0)).x, but I suspect this is working harder than it needs to.

(I need 1D noise function of the angle around a center point.)

[orangeNameAlreadyTakenSoIveGotToImprovise]

AFAIK, 1D Simplex noise gives very similar results to value noise (although usually the interpolation function is different).

If that is enough for you, you can simply use the permute function from this code to evaluate the noise amplitude at point x and point x+1, and then interpolate between these results however you like (e.g. with smoothstep).

[orangeNameAlreadyTakenSoIveGotToImprovise]

Back to topic: Does anyone have a version of the 3D noise function that also calculates the analytical derivatives? I would like to use them for bump mapping.

[jason-fisher]

@orangeNameAlreadyTakenSoIveGotToImprovise

Back to topic: Does anyone have a version of the 3D noise function that also calculates the analytical derivatives? I would like to use them for bump mapping.

I came across this blog post: http://florian-noirbent.com/blog/en/hlsl-simplex-noise-library/
It references this source, which includes an integer seed and derivatives: http://pastebin.com/BycaHKEP

[madscience2728]

@""

Hi there, That’s very nice. i feel i should also mention that there is a version of improved perlin which is very efficient on gpu, you can get the code on www.scrawkblog.com

Norton gives me a site warning, and blocks the site.

[xesiomterim]

Hello

I’ve been using the snoise method for a while and I still have the issue pointed by joergzdarsky where some “random” XYZ inputs gets big value changes (even with his modified version). I tried to figure out why and… well I don’t understand anything in the code XD too much algebra for my body.

Looking in the internet I found this java implementation of a 3D perlin noise generator https://mrl.nyu.edu/~perlin/noise/
and ported it to HLSL. I let the code in there just in case someone may need it.

(I just ported it to HLSL, that’s all, I have no idea how does it works or even if you can use it in a prod game, just wanted to share it xD)

static const int permutation[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
};

static const int p[512] =
{
    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,

    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
};

float fade(float t) {
    return t * t * t * (t * (t * 6 - 15) + 10);
}

float lerp(float t, float a, float b) {
    return a + t * (b - a);
}

float grad(int hash, float x, float y, float z) {
    // CONVERT LO 4 BITS OF HASH CODE INTO 12 GRADIENT DIRECTIONS.
    int h = hash & 15;                     
    float u = h < 8 ? x : y;                
    float v = h < 4 ? y : h == 12 || h == 14 ? x : z;
    return ((h & 1) == 0 ? u : -u) + ((h & 2) == 0 ? v : -v);
}

float perlinNoise(float3 pos) {
    // FIND UNIT CUBE THAT CONTAINS POINT.
    int X = (int)floor(pos.x) & 255;
    int Y = (int)floor(pos.y) & 255;                             
    int Z = (int)floor(pos.z) & 255;
   
    // FIND RELATIVE X,Y,Z OF POINT IN CUBE.
    float x = pos.x - floor(pos.x);
    float y = pos.y - floor(pos.y);
    float z = pos.z - floor(pos.z);
   
    // COMPUTE FADE CURVES FOR EACH OF X,Y,Z.
    float u = fade(x);
    float v = fade(y);
    float w = fade(z);
   
    // HASH COORDINATES OF THE 8 CUBE CORNERS
    int A = p[X] + Y;
    int AA = p[A] + Z;
    int AB = p[A + 1] + Z;          
    int B = p[X + 1] + Y;
    int BA = p[B] + Z;
    int BB = p[B + 1] + Z;

    // AND ADD BLENDED RESULTS FROM  8 CORNERS OF CUBE
    return lerp(w, lerp(v, lerp(u, grad(p[AA], x, y, z),    // CORNER 0      
           grad(p[BA], x - 1, y, z)),                       // CORNER 1                               
           lerp(u, grad(p[AB], x, y - 1, z),                // CORNER 2                        
           grad(p[BB], x - 1, y - 1, z))),                  // CORNER 3                      
           lerp(v, lerp(u, grad(p[AA + 1], x, y, z - 1),    // CORNER 4            
           grad(p[BA + 1], x - 1, y, z - 1)),               // CORNER 5                   
           lerp(u, grad(p[AB + 1], x, y - 1, z - 1),        // CORNER 6   
           grad(p[BB + 1], x - 1, y - 1, z - 1))));         // CORNER 7
}

[gaiastellar]

hi,
I am very new to shader languages. Im using a compute shader to calculate noise, and i downloaded and #included fastnoiselite.hlsl which works great, but it doesnt include 4D noise which is what i was really looking for, so then i found yours, but for some reason the compute shader just wont recognise the .cginc file. I dont know how much difference there is between a cginc file and an HLSL file, but would it be feasible to port it to a HLSL file type so it can also work in compute shaders?

many thanks

Paul UK

[unityuserunity85496]

@xesiomterim

Hello

I’ve been using the snoise method for a while and I still have the issue pointed by joergzdarsky where some “random” XYZ inputs gets big value changes (even with his modified version). I tried to figure out why and… well I don’t understand anything in the code XD too much algebra for my body.

Looking in the internet I found this java implementation of a 3D perlin noise generator https://mrl.nyu.edu/~perlin/noise/
and ported it to HLSL. I let the code in there just in case someone may need it.

(I just ported it to HLSL, that’s all, I have no idea how does it works or even if you can use it in a prod game, just wanted to share it xD)

Looks to Work! It has some squaring and it looks like simplex noise, or its not very blobby, but I noticed some other noise also looked the same like.

Sample shader for someone to use

Shader "Unlit/noise2"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
        _TextureScalar ("texture scalar", Float) = 1
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" }
        LOD 100

        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            #include "UnityCG.cginc"
            #include "Assets/ALT_PerlinNoiseSK01.cginc"

            struct appdata
            {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
            };

            struct v2f
            {
                float2 uv : TEXCOORD0;
                float4 vertex : SV_POSITION;
            };

            sampler2D _MainTex;
            float4 _MainTex_ST;

            float _TextureScalar;

            v2f vert (appdata v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.uv = TRANSFORM_TEX(v.uv, _MainTex);
                return o;
            }

            fixed4 frag (v2f i) : SV_Target
            {
                i.uv.x += _Time * 2;
                i.uv *= _TextureScalar;
                float _p = perlinNoise(float3(i.uv.x, i.uv.y,1));
                return float4(_p,_p,_p,1);
            }
            ENDCG
        }
    }
}