Random noise functions for GLSL

Question

As the GPU driver vendors don t usually bother to implement noiseX in GLSL  I m looking for a  graphics randomization swiss army knife  utility function set  preferably optimised to use within GPU shaders  I prefer GLSL  but code any language will do for me  I m ok with translating it on my own to GLSL   Specifically  I d expect   a  Pseudo-random functions - N-dimensional  uniform distribution over  -1 1  or over  0 1   calculated from M-dimensional seed  ideally being any value  but I m OK with having the seed restrained to  say  0  1 for uniform result distribution   Something like   float random   T seed   vec2  random2  T seed   vec3  random3  T seed   vec4  random4  T seed      T being either float  vec2  vec3  vec4 - ideally    b  Continous noise like Perlin Noise - again  N-dimensional   - uniform distribution  with constrained set of values and  well  looking good  some options to configure the appearance like Perlin levels could be useful too   I d expect signatures like   float noise   T coord  TT seed   vec2  noise2  T coord  TT seed            I m not very much into random number generation theory  so I d most eagerly go for a pre-made solution  but I d also appreciate answers like  here s a very good  efficient 1D rand    and let me explain you how to make a good N-dimensional rand   on top of it

User · Accepted Answer

For very simple pseudorandom-looking stuff, I use this oneliner that I found on the internet somewhere:

float rand(vec2 co){
    return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);
}

You can also generate a noise texture using whatever PRNG you like, then upload this in the normal fashion and sample the values in your shader; I can dig up a code sample later if you'd like.

Also, check out this file for GLSL implementations of Perlin and Simplex noise, by Stefan Gustavson.

User · Answer

hash  Nowadays webGL2 0 is there so integers are available in  w GLSL  -  for quality portable hash  at similar cost than ugly float hashes  we can now use  serious  hashing techniques  IQ implemented some in https   www shadertoy com view XlXcW4  and more   E g      const uint k   1103515245U      GLIB C   const uint k   134775813U       Delphi and Turbo Pascal   const uint k   20170906U        Today s date  use three days ago s dateif you want a prime    const uint k   1664525U         Numerical Recipes  vec3 hash  uvec3 x         x     x gt  gt 8U  x yzx  k      x     x gt  gt 8U  x yzx  k      x     x gt  gt 8U  x yzx  k       return vec3 x   1 0 float 0xffffffffU

User · Answer

Gold Noise     Gold Noise   2015 dcerisano standard3d com    - based on the Golden Ratio    - uniform normalized distribution    - fastest static noise generator function  also runs at low precision   float PHI   1 61803398874989484820459      F   Golden Ratio     float gold noise in vec2 xy  in float seed          return fract tan distance xy PHI  xy  seed  xy x       See Gold Noise in your browser right now     This function has improved random distribution over the current function in  appas  answer as of Sept 9  2017     The  appas function is also incomplete  given there is no seed supplied  uv is not a seed - same for every frame   and does not work with low precision chipsets  Gold Noise runs at low precision by default  much faster

User · Answer

Do use this   highp float rand vec2 co        highp float a   12 9898      highp float b   78 233      highp float c   43758 5453      highp float dt  dot co xy  vec2 a b        highp float sn  mod dt 3 14       return fract sin sn    c       Don t use this   float rand vec2 co       return fract sin dot co xy  vec2 12 9898 78 233      43758 5453       You can find the explanation in Improvements to the canonical one-liner GLSL rand   for OpenGL ES 2 0

User · Answer

A straight  jagged version of 1d Perlin  essentially a random lfo zigzag              half  rn float xx                half x0 floor xx       half x1 x0 1      half v0   frac sin  x0  014686  31718 927 x0       half v1   frac sin  x1  014686  31718 927 x1                  return  v0  1-frac xx   v1  frac xx    2-1 sin xx       I also have found 1-2-3-4d perlin noise on shadertoy owner inigo quilez perlin tutorial website  and voronoi and so forth  he has full fast implementations and codes for them

User · Answer

Gustavson s implementation uses a 1D texture   No it doesn t  not since 2005  It s just that people insist on downloading the old version  The version that is on the link you supplied uses only 8-bit 2D textures   The new version by Ian McEwan of Ashima and myself does not use a texture  but runs at around half the speed on typical desktop platforms with lots of texture bandwidth  On mobile platforms  the textureless version might be faster because texturing is often a significant bottleneck   Our actively maintained source repository is   https   github com ashima webgl-noise  A collection of both the textureless and texture-using versions of noise is here  using only 2D textures    http   www itn liu se  stegu simplexnoise GLSL-noise-vs-noise zip  If you have any specific questions  feel free to e-mail me directly  my email address can be found in the classicnoise  glsl sources

User · Answer

I have translated one of Ken Perlin s Java implementations into GLSL and used it in a couple projects on ShaderToy   Below is the GLSL interpretation I did   int b int N  int B    return N gt  gt B  amp  1    int T     int   0x15 0x38 0x32 0x2c 0x0d 0x13 0x07 0x2a   int A     int   0 0 0    int b int i  int j  int k  int B    return T b i B  lt  lt 2   b j B  lt  lt 1   b k B       int shuffle int i  int j  int k        return b i j k 0    b j k i 1    b k i j 2    b i j k 3            b j k i 4    b k i j 5    b i j k 6    b j k i 7       float K int a  vec3 uvw  vec3 ijk        float s   float A 0  A 1  A 2   6 0      float x   uvw x - float A 0     s          y   uvw y - float A 1     s          z   uvw z - float A 2     s          t   0 6 - x   x - y   y - z   z      int h   shuffle int ijk x    A 0   int ijk y    A 1   int ijk z    A 2        A a         if  t  lt  0 0          return 0 0      int b5   h gt  gt 5  amp  1  b4   h gt  gt 4  amp  1  b3   h gt  gt 3  amp  1  b2  h gt  gt 2  amp  1  b   h  amp  3      float p   b  1 x b  2 y z  q   b  1 y b  2 z x  r   b  1 z b  2 x y      p    b5  b3   -p   p   q    b5  b4   -q   q   r    b5   b4 b3    -r   r       t    t      return 8 0   t   t    p    b  0   q r   b2  0   q   r       float noise float x  float y  float z        float s    x   y   z    3 0        vec3 ijk   vec3 int floor x s    int floor y s    int floor z s         s   float ijk x   ijk y   ijk z    6 0      vec3 uvw   vec3 x - float ijk x    s  y - float ijk y    s  z - float ijk z    s       A 0    A 1    A 2    0      int hi   uvw x  gt   uvw z   uvw x  gt   uvw y   0   1   uvw y  gt   uvw z   1   2      int lo   uvw x  lt   uvw z   uvw x  lt   uvw y   0   1   uvw y  lt   uvw z   1   2      return K hi  uvw  ijk    K 3 - hi - lo  uvw  ijk    K lo  uvw  ijk    K 0  uvw  ijk       I translated it from Appendix B from Chapter 2 of Ken Perlin s Noise Hardware at this source   https   www csee umbc edu  olano s2002c36 ch02 pdf  Here is a public shade I did on Shader Toy that uses the posted noise function   https   www shadertoy com view 3slXzM  Some other good sources I found on the subject of noise during my research include   https   thebookofshaders com 11   https   mzucker github io html perlin-noise-math-faq html  https   rmarcus info blog 2018 03 04 perlin-noise html  http   flafla2 github io 2014 08 09 perlinnoise html  https   mrl nyu edu  perlin noise   https   rmarcus info blog assets perlin perlin paper pdf  https   developer nvidia com gpugems GPUGems gpugems ch05 html  I highly recommend the book of shaders as it not only provides a great interactive explanation of noise  but other shader concepts as well   EDIT   Might be able to optimize the translated code by using some of the hardware-accelerated functions available in GLSL  Will update this post if I end up doing this

User · Answer

After the initial posting of this question in 2010  a lot has changed in the realm of good random functions and hardware support for them  Looking at the accepted answer from today s perspective  this algorithm is very bad in uniformity of the random numbers drawn from it  And the uniformity suffers a lot depending on the magnitude of the input values and visible artifacts patterns will become apparent when sampling from it for e g  ray path tracing applications  There have been many different functions  most of them integer hashing  being devised for this task  for different input and output dimensionality  most of which are being evaluated in the 2020 JCGT paper Hash Functions for GPU Rendering  Depending on your needs you could select a function from the list of proposed functions in that paper and simply from the accompanying Shadertoy  One that isn t covered in this paper but that has served me very well without any noticeably patterns on any input magnitude values is also one that I want to highlight  Other classes of algorithms use low-discrepancy sequences to draw pseudo-random numbers from  such as the Sobol squence with Owen-Nayar scrambling  Eric Heitz has done some amazing research in this area  as well with his A Low-Discrepancy Sampler that Distributes Monte Carlo Errors as a Blue Noise in Screen Space paper  Another example of this is the  so far latest  JCGT paper Practical Hash-based Owen Scrambling  which applies Owen scrambling to a different hash function  namely Laine-Karras   Yet other classes use algorithms that produce noise patterns with desirable frequency spectrums  such as blue noise  that is particularly  quot pleasing quot  to the eyes   I realize that good StackOverflow answers should provide the algorithms as source code and not as links because those can break  but there are way too many different algorithms nowadays and I intend for this answer to be a summary of known-good algorithms today

User · Answer

Just found this version of 3d noise for GPU  alledgedly it is the fastest one available    ifndef   noise hlsl   define   noise hlsl      hash based 3d value noise    function taken from https   www shadertoy com view XslGRr    Created by inigo quilez - iq 2013    License Creative Commons Attribution-NonCommercial-ShareAlike 3 0 Unported License      ported from GLSL to HLSL  float hash  float n         return frac sin n  43758 5453      float noise  float3 x            The noise function returns a value in the range -1 0f - gt  1 0f      float3 p   floor x       float3 f   frac x        f         f f  3 0-2 0 f       float n   p x   p y 57 0   113 0 p z       return lerp lerp lerp  hash n 0 0   hash n 1 0  f x                      lerp  hash n 57 0   hash n 58 0  f x  f y                  lerp lerp  hash n 113 0   hash n 114 0  f x                      lerp  hash n 170 0   hash n 171 0  f x  f y  f z       endif

User · Answer

There is also a nice implementation described here by McEwan and  StefanGustavson that looks like Perlin noise  but  does not require any setup  i e  not textures nor uniform arrays  Just add it to your shader source code and call it wherever you want    That s very handy  especially given that Gustavson s earlier implementation  which  dep linked to  uses a 1D texture  which is not supported in GLSL ES  the shader language of WebGL

User · Answer

It occurs to me that you could use a simple integer hash function and insert the result into a float s mantissa   IIRC the GLSL spec guarantees 32-bit unsigned integers and IEEE binary32 float representation so it should be perfectly portable   I gave this a try just now   The results are very good  it looks exactly like static with every input I tried  no visible patterns at all   In contrast the popular sin fract snippet has fairly pronounced diagonal lines on my GPU given the same inputs   One disadvantage is that it requires GLSL v3 30   And although it seems fast enough  I haven t empirically quantified its performance   AMD s Shader Analyzer claims 13 33 pixels per clock for the vec2 version on a HD5870   Contrast with 16 pixels per clock for the sin fract snippet   So it is certainly a little slower   Here s my implementation   I left it in various permutations of the idea to make it easier to derive your own functions from          static frag     by Spatial     05 July 2013      version 330 core  uniform float time  out vec4 fragment        A single iteration of Bob Jenkins  One-At-A-Time hashing algorithm  uint hash  uint x         x      x  lt  lt  10u        x      x  gt  gt   6u        x      x  lt  lt   3u        x      x  gt  gt  11u        x      x  lt  lt  15u        return x          Compound versions of the hashing algorithm I whipped together  uint hash  uvec2 v     return hash  v x   hash v y                               uint hash  uvec3 v     return hash  v x   hash v y    hash v z                   uint hash  uvec4 v     return hash  v x   hash v y    hash v z    hash v w             Construct a float with half-open range  0 1  using low 23 bits     All zeroes yields 0 0  all ones yields the next smallest representable value below 1 0  float floatConstruct  uint m         const uint ieeeMantissa   0x007FFFFFu     binary32 mantissa bitmask     const uint ieeeOne        0x3F800000u     1 0 in IEEE binary32      m  amp   ieeeMantissa                         Keep only mantissa bits  fractional part      m    ieeeOne                              Add fractional part to 1 0      float  f   uintBitsToFloat  m             Range  1 2      return f - 1 0                            Range  0 1          Pseudo-random value in half-open range  0 1   float random  float x     return floatConstruct hash floatBitsToUint x       float random  vec2  v     return floatConstruct hash floatBitsToUint v       float random  vec3  v     return floatConstruct hash floatBitsToUint v       float random  vec4  v     return floatConstruct hash floatBitsToUint v            void main         vec3  inputs   vec3  gl FragCoord xy  time       Spatial and temporal inputs     float rand     random  inputs                    Random per-pixel value     vec3  luma     vec3  rand                        Expand to RGB      fragment   vec4  luma  1 0          Screenshot     I inspected the screenshot in an image editing program   There are 256 colours and the average value is 127  meaning the distribution is uniform and covers the expected range

User · Answer

Please see below an example how to add white noise to the rendered texture  The solution is to use two textures  original and pure white noise  like this one  wiki white noise  private static final String VERTEX SHADER        uniform mat4 uMVPMatrix  n         uniform mat4 uMVMatrix  n         uniform mat4 uSTMatrix  n         attribute vec4 aPosition  n         attribute vec4 aTextureCoord  n         varying vec2 vTextureCoord  n         varying vec4 vInCamPosition  n         void main     n             vTextureCoord    uSTMatrix   aTextureCoord  xy  n             gl Position   uMVPMatrix   aPosition  n           n    private static final String FRAGMENT SHADER            precision mediump float  n             uniform sampler2D sTextureUnit  n             uniform sampler2D sNoiseTextureUnit  n             uniform float uNoseFactor  n             varying vec2 vTextureCoord  n             varying vec4 vInCamPosition  n             void main     n                         gl FragColor   texture2D sTextureUnit  vTextureCoord   n                         vec4 vRandChosenColor   texture2D sNoiseTextureUnit  fract vTextureCoord   uNoseFactor    n                         gl FragColor r     0 05   vRandChosenColor r   n                         gl FragColor g     0 05   vRandChosenColor g   n                         gl FragColor b     0 05   vRandChosenColor b   n               n     The fragment shared contains parameter uNoiseFactor which is updated on every rendering by main application   float noiseValue    float  mRand nextInt     1000  1000  int noiseFactorUniformHandle   GLES20 glGetUniformLocation  mProgram   sNoiseTextureUnit    GLES20 glUniform1f noiseFactorUniformHandle  noiseFactor

[random] Random / noise functions for GLSL

Examples related to random

Examples related to shader

Examples related to glsl

Examples related to noise

Examples related to perlin-noise