on a quest for GPU Perlin noise

Hi unitiverse citizens. I have very basic shader knowledge, and I wish to elaborate procedural patterns, volumetric textures, using organic colours from real textures, to make a big dynamic pattern generation system etc.

for most applications any 1-D noise function (CG based) would be fine, I need an irregular function. and 2d, 3d noise function would be wonderful also.

This thread is here to list CG sources and projects that I will try to run in Unity, until I manage to see a 1st CG noise texture on a material. Any help would be welcome because I am absolutely clueless about shader lab.


here are 2 different versions of GPU Perlin written in CG:

http://scrawkblog.com/2013/03/05/perlin-noise-pulgin-for-unity/ ...this code is a mix of Perlin calculations on permutation indexes passed from JavaScript every frame AFAIK, I ran it and the scene was blank.
WAIT a moment! Edit-have just discovered the front page of this blog is amazing and there is a different Perlin project on it from the improved Perlin source made by an epic games guy:
http://scrawkblog.com/2013/05/18/gpu-gems-to-unity-improved-perlin-noise/

http://www.sci.utah.edu/~leenak/IndStudy_reportfall/Perlin Noise on GPU.html this is a very interesting page using advanced Perlin in CG, it seems a bit advanced to convert to unity.

this is a code for 3d simplex running on GPU entirely, I have taken the simplex noise function from that source and told it to display colours, it compiles and runs without any bugs but an invisible bug is causing the shader to return NaN purple base texture.
http://johannes.gotlen.se/blog/

Attempt 3d simplex code that compiles OK and then displays nothing:
(what is the #Define F3 1.0/3.0 on line 17 ? )

Code (csharp):

1. Shader "Custom/Pattern2" {
2.     Properties {
3.  
4.     }
5.  
6.     SubShader {
7.         Pass {
8.             CGPROGRAM
9.  
10.  
11.                 #pragma vertex vert
12.                 #pragma fragment frag
13.                 #pragma target 3.0
14.                 #pragma exclude_renderers gles
15.                 #include "UnityCG.cginc"
16.                         #define F3 1.0/3.0
17.                 #define G3 1.0/6.0
18.  
19.  
20.                
21.                 //user defined variables
22.                 struct input {
23.                         float2 texcoord : TEXCOORD0;
24.                 };
25.                  struct v2f {
26.                     float4 pos : SV_POSITION;
27.                     float3 color : COLOR0;
28.                     float2 texcoord : TEXCOORD0;
29.                 };
30.  
31.                 v2f vert (appdata_base v)
32.                 {
33.                     v2f o;
34.                     o.pos = mul (UNITY_MATRIX_MVP, v.vertex);
35.                     o.color = v.normal * 0.5 + 0.5;
36.                     o.texcoord = v.texcoord;
37.                     return o;
38.                 }
39.                
40.                 float simplex3d(float xin, float yin, float zin) {  
41.                 //thanks to Stefan Gustavson, Linköping University, Sweden
42.                     const float3 grad3[12] = {
43.                         float3(1,1,0),float3(-1,1,0),float3(1,-1,0),float3(-1,-1,0),
44.                         float3(1,0,1),float3(-1,0,1),float3(1,0,-1),float3(-1,0,-1),
45.                         float3(0,1,1),float3(0,-1,1),float3(0,1,-1),float3(0,-1,-1)
46.                     };
47.                     const int perm[512] = {151,160,137,91,90,15,
48.                       131,13,201,95,96,53,194,233,7,225,140,36,103,30,69,142,8,99,37,240,21,10,23,
49.                       190,6,148,247,120,234,75,0,26,197,62,94,252,219,203,117,35,11,32,57,177,33,
50.                       88,237,149,56,87,174,20,125,136,171,168,68,175,74,165,71,134,139,48,27,166,
51.                       77,146,158,231,83,111,229,122,60,211,133,230,220,105,92,41,55,46,245,40,244,
52.                       102,143,54,65,25,63,161,1,216,80,73,209,76,132,187,208,89,18,169,200,196,
53.                       135,130,116,188,159,86,164,100,109,198,173,186,3,64,52,217,226,250,124,123,
54.                       5,202,38,147,118,126,255,82,85,212,207,206,59,227,47,16,58,17,182,189,28,42,
55.                       223,183,170,213,119,248,152,2,44,154,163,70,221,153,101,155,167,43,172,9,
56.                       129,22,39,253,19,98,108,110,79,113,224,232,178,185,112,104,218,246,97,228,
57.                       251,34,242,193,238,210,144,12,191,179,162,241,81,51,145,235,249,14,239,107,
58.                       49,192,214,31,181,199,106,157,184,84,204,176,115,121,50,45,127,4,150,254,
59.                       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,
60.                       131,13,201,95,96,53,194,233,7,225,140,36,103,30,69,142,8,99,37,240,21,10,23,
61.                       190,6,148,247,120,234,75,0,26,197,62,94,252,219,203,117,35,11,32,57,177,33,
62.                       88,237,149,56,87,174,20,125,136,171,168,68,175,74,165,71,134,139,48,27,166,
63.                       77,146,158,231,83,111,229,122,60,211,133,230,220,105,92,41,55,46,245,40,244,
64.                       102,143,54,65,25,63,161,1,216,80,73,209,76,132,187,208,89,18,169,200,196,
65.                       135,130,116,188,159,86,164,100,109,198,173,186,3,64,52,217,226,250,124,123,
66.                       5,202,38,147,118,126,255,82,85,212,207,206,59,227,47,16,58,17,182,189,28,42,
67.                       223,183,170,213,119,248,152,2,44,154,163,70,221,153,101,155,167,43,172,9,
68.                       129,22,39,253,19,98,108,110,79,113,224,232,178,185,112,104,218,246,97,228,
69.                       251,34,242,193,238,210,144,12,191,179,162,241,81,51,145,235,249,14,239,107,
70.                       49,192,214,31,181,199,106,157,184,84,204,176,115,121,50,45,127,4,150,254,
71.                       138,236,205,93,222,114,67,29,24,72,243,141,128,195,78,66,215,61,156,180
72.                     };
73.    
74.                     const int permMod12[512] = {
75.                         7,4,5,7,6,3,11,1,9,11,0,5,2,5,7,9,8,0,7,6,9,10,8,3,1,0,9,10,11,10,6,4,7,0,6,3,
76.                         0,2,5,2,10,0,3,11,9,11,11,8,9,9,9,4,9,5,8,3,6,8,5,4,3,0,8,7,2,9,11,2,7,0,3,10,5
77.                         ,2,2,3,11,3,1,2,0,7,1,2,4,9,8,5,7,10,5,4,4,6,11,6,5,1,3,5,1,0,8,1,5,4,0,7,4,5,
78.                         6,1,8,4,3,10,8,8,3,2,8,4,1,6,5,6,3,4,4,1,10,10,4,3,5,10,2,3,10,6,3,10,1,8,3,2,
79.                         11,11,11,4,10,5,2,9,4,6,7,3,2,9,11,8,8,2,8,10,7,10,5,9,5,11,11,7,4,9,9,10,3,1,7,
80.                         2,0,2,7,5,8,4,10,5,4,8,2,6,1,0,11,10,2,1,10,6,0,0,11,11,6,1,9,3,1,7,9,2,11,11,1,
81.                         0,10,7,1,7,10,1,4,0,0,8,7,1,2,9,7,4,6,2,6,8,1,9,6,6,7,5,0,0,3,9,8,3,6,6,11,1,
82.                         0,0,7,4,5,7,6,3,11,1,9,11,0,5,2,5,7,9,8,0,7,6,9,10,8,3,1,0,9,10,11,10,6,4,7,0,6,3,
83.                         0,2,5,2,10,0,3,11,9,11,11,8,9,9,9,4,9,5,8,3,6,8,5,4,3,0,8,7,2,9,11,2,7,0,3,10,5,
84.                         2,2,3,11,3,1,2,0,7,1,2,4,9,8,5,7,10,5,4,4,6,11,6,5,1,3,5,1,0,8,1,5,4,0,7,4,5,
85.                         6,1,8,4,3,10,8,8,3,2,8,4,1,6,5,6,3,4,4,1,10,10,4,3,5,10,2,3,10,6,3,10,1,8,3,2,
86.                         11,11,11,4,10,5,2,9,4,6,7,3,2,9,11,8,8,2,8,10,7,10,5,9,5,11,11,7,4,9,9,10,3,1,7,
87.                         2,0,2,7,5,8,4,10,5,4,8,2,6,1,0,11,10,2,1,10,6,0,0,11,11,6,1,9,3,1,7,9,2,11,11,1,
88.                         0,10,7,1,7,10,1,4,0,0,8,7,1,2,9,7,4,6,2,6,8,1,9,6,6,7,5,0,0,3,9,8,3,6,6,11,1,0,0
89.                     };
90.                                         float n0,n1,n2,n3; // Noise contributions from the four corners
91.                     // Skew the input space to determine which simplex cell we're in
92.                     float s = (xin+yin+zin)*F3; // Very nice and simple skew factor for 3D
93.                     int i = floor(xin+s);
94.                     int j = floor(yin+s);
95.                     int k = floor(zin+s);
96.                     float t = (i+j+k)*G3;
97.                     float X0 = i-t; // Unskew the cell origin back to (x,y,z) space
98.                     float Y0 = j-t;
99.                     float Z0 = k-t;
100.                     float x0 = xin-X0; // The x,y,z distances from the cell origin
101.                     float y0 = yin-Y0;
102.                     float z0 = zin-Z0;
103.                     // For the 3D case, the simplex shape is a slightly irregular tetrahedron.
104.                     // Determine which simplex we are in.
105.                     int i1, j1, k1; // Offsets for second corner of simplex in (i,j,k) coords
106.                     int i2, j2, k2; // Offsets for third corner of simplex in (i,j,k) coords
107.                     if(x0>=y0) {
108.                       if(y0>=z0)
109.                         { i1=1; j1=0; k1=0; i2=1; j2=1; k2=0; } // X Y Z order
110.                         else if(x0>=z0) { i1=1; j1=0; k1=0; i2=1; j2=0; k2=1; } // X Z Y order
111.                         else { i1=0; j1=0; k1=1; i2=1; j2=0; k2=1; } // Z X Y order
112.                       }
113.                     else { // x0<y0
114.                       if(y0<z0) { i1=0; j1=0; k1=1; i2=0; j2=1; k2=1; } // Z Y X order
115.                       else if(x0<z0) { i1=0; j1=1; k1=0; i2=0; j2=1; k2=1; } // Y Z X order
116.                       else { i1=0; j1=1; k1=0; i2=1; j2=1; k2=0; } // Y X Z order
117.                     }
118.                     // A step of (1,0,0) in (i,j,k) means a step of (1-c,-c,-c) in (x,y,z),
119.                     // a step of (0,1,0) in (i,j,k) means a step of (-c,1-c,-c) in (x,y,z), and
120.                     // a step of (0,0,1) in (i,j,k) means a step of (-c,-c,1-c) in (x,y,z), where
121.                     // c = 1/6.
122.                     float x1 = x0 - i1 + G3; // Offsets for second corner in (x,y,z) coords
123.                     float y1 = y0 - j1 + G3;
124.                     float z1 = z0 - k1 + G3;
125.                     float x2 = x0 - i2 + 2.0*G3; // Offsets for third corner in (x,y,z) coords
126.                     float y2 = y0 - j2 + 2.0*G3;
127.                     float z2 = z0 - k2 + 2.0*G3;
128.                     float x3 = x0 - 1.0 + 3.0*G3; // Offsets for last corner in (x,y,z) coords
129.                     float y3 = y0 - 1.0 + 3.0*G3;
130.                     float z3 = z0 - 1.0 + 3.0*G3;
131.                     // Work out the hashed gradient indices of the four simplex corners
132.                     int ii = i  255;
133.                     int jj = j  255;
134.                     int kk = k  255;
135.                     int gi0 = permMod12[ii+perm[jj+perm[kk]]];
136.                     int gi1 = permMod12[ii+i1+perm[jj+j1+perm[kk+k1]]];
137.                     int gi2 = permMod12[ii+i2+perm[jj+j2+perm[kk+k2]]];
138.                     int gi3 = permMod12[ii+1+perm[jj+1+perm[kk+1]]];
139.                     // Calculate the contribution from the four corners
140.                     float t0 = 0.6 - x0*x0 - y0*y0 - z0*z0;
141.                     if(t0<0){
142.                         n0 = 0.0;
143.                     }
144.                     else {
145.                       t0 *= t0;
146.                       n0 = t0 * t0 * dot(grad3[gi0], float3(x0, y0, z0));
147.                     }
148.                     float t1 = 0.6 - x1*x1 - y1*y1 - z1*z1;
149.                     if(t1<0){
150.                      n1 = 0.0;
151.                     } else {
152.                       t1 *= t1;
153.                       n1 = t1 * t1 * dot(grad3[gi1],float3(x1, y1, z1));
154.                     }
155.                     float t2 = 0.6 - x2*x2 - y2*y2 - z2*z2;
156.                     if(t2<0){
157.                         n2 = 0.0;
158.                     } else {
159.                       t2 *= t2;
160.                       n2 = t2 * t2 * dot(grad3[gi2],float3(x2,y2,z2));
161.                     }
162.                     float t3 = 0.6 - x3*x3 - y3*y3 - z3*z3;
163.                     if(t3<0){
164.                      n3 = 0.0;
165.                     } else {
166.                       t3 *= t3;
167.                       n3 = t3 * t3 * dot(grad3[gi3],float3( x3,y3,z3));
168.                     }
169.  
170.                    
171.                     // Add contributions from each corner to get the final noise value.
172.                     // The result is scaled to stay just inside [-1,1]
173.                     return 32.0*(n0 + n1 + n2 + n3);
174.                     //return 0;
175.                 }
176.                
177.                
178.                
179.                 // fragment function
180.                 float4 frag(input i) : COLOR {
181.                
182.                
183.                     half4 clr = half4(0.0,.0,.0,0.0);
184.                    
185.  
186.            
187.             clr = simplex3d(i.texcoord.x,i.texcoord.y,1);
188.            
189.                    
190.                     //clr.g = ht ;
191.  
192.                     return normalize(clr);
193.                 }
194.             ENDCG
195.         }
196.     }
197.  
198.     fallback "Diffuse"
199. }
200.  

 

It's a preprocessor directive that states that any occurrences of "F3" should be substituted with the value 1/3.
F3 is used in the skew calculation.

 

Do you need gpu perlin because you need animated textures? Or, is it okay to prepare them before runtime?

If you need runtime animated textures, you should check nvidia shader library and gpu gems 2 documents for clean gpu perlin noise implementation which is very easy to convert to unity.

If the latter, you should check my libnoise port which is free now. That has a visual frontend and many other useful functions.

 

Thanks, tanoshimi and aubergine, I found a working version of the GPU gems2 implementation on [link removed by mod due to site being hijacked] it displays very nicely.

I want GPU Perlin because it would be interesting to have an infinite landscape with also infinite textures, only just by passing Perlin noise through some sine functions it makes very stratified geology, and various other texture types, and then if you get lots of real organic photos and use colours from then you can have a landscape with an endless variety of strange textures and colors which really adds a certain fascination because actually one of the worst flaws of modern games is having to rely on anything tiled and repetitive based on uvs and seams if it's supposed to be chaos. also, some power texture shaders would enable gamers to very fast compose worlds made from lots of fairly simple arcade patterns with bright colours and kind of mix it all together in real-time as they are making a game, just by changing numbers and without having to deal with any files at all. And also is very good to have animated textures, it's a very fast and practical way of adding a very powerful visual thing to games.

for example, I rather not have realistic oceans, but animated cartoon oceans come in all varieties and can be very fun to walk around!

oh yes the libnoise, i love that code thanks very much.