Noise Generation Algorithms : White Noise With Shader Example

on

White Noise

Many of you may know what white noise is and how it can be used in code.
But there are a spectrum of  'Coloured Noises' as well these include ones like brown noise, pink, blue and violet noise all these have slightly different properties and can be very useful in creating different effects. More details on coloured noises can be found HERE.
Comparison of noiseless and noisy image
A lot of movies as well as video games like City Skylines use white noise to add a feeling of realism and texture to the on screen content, it's also referred to as a grain filter or overlay. It is a really subtle effect and should not be over used.
Creating white noise boils down to the random function used.
While writing C++ code or C# code we have access to good pseudo-random functions from their standard libraries... but while writing code in shaders we usually have to create our own pseudo-random number generator.
One really good way of making one is by using the frac( in Unity & HLSL ) or fract( in GLSL ) function which returns the fractional part of a number.
float random( float2 point )
{
   return frac(sin(dot(point.xy,float2(someXvalue,someYvalue)))*someFloatWithManyDecimals);
}
Why are we using this 'special arrangement' of functions to make our pseudo-random number generator?
The dot product :- gives values based on how close the directions of  2 vectors are to each other.
The sin function :- gives us value from -1.0 to 1.0 based on the input from the dot product.
The frac function :- gives us the fractional part of the entire thing, which will be our random number.
After tweaking some of these values you should be getting a pretty decent random number generator.
We will be making an effect that looks like this. It's a bit exaggerated for effect.☺.
An example of grain filter shader
First we will see what the properties of the shader are:
Properties
{
 _MainTex("Texture", 2D)="white"
 _NoiseScale("Noise Scale",Float) = 50.0
 _Strength("Noise Strength",Float) = 1.0
}
What are they? :
sampler2D _MainTex; //Texture Used
float _NoiseScale; //How big each noise block is
float _Strength; //How prevalent it is in final image
We will look at the random function used ( by me ).
float random( float2 p )
{
     return frac(sin(dot(p.xy ,float2( _Time.y,6.115)))*53.8856);
}
I have used _Time.y as a parameter to change the noise each frame.
Now the fragment shader:
fixed4 frag (v2f i) : SV_Target
{
 float2 normUV = i.uv; 
 normUV *= _NoiseScale; // Scale the coordinate system by _NoiseScale amount
 float2 ipos = floor(normUV);  // get the integer coords 
 float rand = random(ipos); // Assign a random value based on the integer coord
 fixed4 col = fixed4(rand,rand,rand,1.0);
 col = lerp( tex2D(_MainTex,i.uv),col,_Strength ); /*Interpolating between the noise and 
                                                          texture image by _Strength Value*/
 return col;
}
The entire source code of shader is HERE
If you like programming shaders make sure you check these out : Shader Tutorials
Support Bitshift Programmer by leaving a like on Bitshift Programmer Facebook Page and be updated as soon as there is a new blog post.
If you have any questions that you might have about shaders or unity development in general don't be shy and leave a message on my facebook page or down in the comments.