Skip to content

Commit 4454e96

Browse files
gam0022gam0022
committed
Create Noise.cginc
1 parent b49760a commit 4454e96

File tree

4 files changed

+185
-170
lines changed

4 files changed

+185
-170
lines changed

‎.idea/.idea.unity-demoscene/.idea/contentModel.xml

Lines changed: 1 addition & 0 deletions
Some generated files are not rendered by default. Learn more about customizing how changed files appear on GitHub.

‎Assets/Demoscene/Projects/2018-07-10-Cellular/Cellular.shader

Lines changed: 1 addition & 170 deletions
Original file line numberDiff line numberDiff line change
@@ -19,6 +19,7 @@
1919

2020
#include "UnityCG.cginc"
2121
#include "Assets/Demoscene/Shaders/Includes/PortingFromGLSL.cginc"
22+
#include "Assets/Demoscene/Shaders/Includes/Noise.cginc"
2223

2324
struct appdata
2425
{
@@ -36,176 +37,6 @@
3637
sampler2D _MainTex;
3738
float4 _MainTex_ST;
3839

39-
// https://thebookofshaders.com/edit.php#12/3d-cnoise.frag
40-
vec3 permute(vec3 x) {
41-
return mod((34.0 * x + 1.0) * x, 289.0);
42-
}
43-
44-
// Cellular noise, returning F1 and F2 in a vec2.
45-
// 3x3x3 search region for good F2 everywhere, but a lot
46-
// slower than the 2x2x2 version.
47-
// The code below is a bit scary even to its author,
48-
// but it has at least half decent performance on a
49-
// modern GPU. In any case, it beats any software
50-
// implementation of Worley noise hands down.
51-
52-
vec2 cellular(vec3 P) {
53-
#define K 0.142857142857 // 1/7
54-
#define Ko 0.428571428571 // 1/2-K/2
55-
#define K2 0.020408163265306 // 1/(7*7)
56-
#define Kz 0.166666666667 // 1/6
57-
#define Kzo 0.416666666667 // 1/2-1/6*2
58-
#define jitter 1.0 // smaller jitter gives more regular pattern
59-
60-
vec3 Pi = mod(floor(P), 289.0);
61-
vec3 Pf = fract(P) - 0.5;
62-
63-
vec3 Pfx = Pf.x + vec3(1.0, 0.0, -1.0);
64-
vec3 Pfy = Pf.y + vec3(1.0, 0.0, -1.0);
65-
vec3 Pfz = Pf.z + vec3(1.0, 0.0, -1.0);
66-
67-
vec3 p = permute(Pi.x + vec3(-1.0, 0.0, 1.0));
68-
vec3 p1 = permute(p + Pi.y - 1.0);
69-
vec3 p2 = permute(p + Pi.y);
70-
vec3 p3 = permute(p + Pi.y + 1.0);
71-
72-
vec3 p11 = permute(p1 + Pi.z - 1.0);
73-
vec3 p12 = permute(p1 + Pi.z);
74-
vec3 p13 = permute(p1 + Pi.z + 1.0);
75-
76-
vec3 p21 = permute(p2 + Pi.z - 1.0);
77-
vec3 p22 = permute(p2 + Pi.z);
78-
vec3 p23 = permute(p2 + Pi.z + 1.0);
79-
80-
vec3 p31 = permute(p3 + Pi.z - 1.0);
81-
vec3 p32 = permute(p3 + Pi.z);
82-
vec3 p33 = permute(p3 + Pi.z + 1.0);
83-
84-
vec3 ox11 = fract(p11*K) - Ko;
85-
vec3 oy11 = mod(floor(p11*K), 7.0)*K - Ko;
86-
vec3 oz11 = floor(p11*K2)*Kz - Kzo; // p11 < 289 guaranteed
87-
88-
vec3 ox12 = fract(p12*K) - Ko;
89-
vec3 oy12 = mod(floor(p12*K), 7.0)*K - Ko;
90-
vec3 oz12 = floor(p12*K2)*Kz - Kzo;
91-
92-
vec3 ox13 = fract(p13*K) - Ko;
93-
vec3 oy13 = mod(floor(p13*K), 7.0)*K - Ko;
94-
vec3 oz13 = floor(p13*K2)*Kz - Kzo;
95-
96-
vec3 ox21 = fract(p21*K) - Ko;
97-
vec3 oy21 = mod(floor(p21*K), 7.0)*K - Ko;
98-
vec3 oz21 = floor(p21*K2)*Kz - Kzo;
99-
100-
vec3 ox22 = fract(p22*K) - Ko;
101-
vec3 oy22 = mod(floor(p22*K), 7.0)*K - Ko;
102-
vec3 oz22 = floor(p22*K2)*Kz - Kzo;
103-
104-
vec3 ox23 = fract(p23*K) - Ko;
105-
vec3 oy23 = mod(floor(p23*K), 7.0)*K - Ko;
106-
vec3 oz23 = floor(p23*K2)*Kz - Kzo;
107-
108-
vec3 ox31 = fract(p31*K) - Ko;
109-
vec3 oy31 = mod(floor(p31*K), 7.0)*K - Ko;
110-
vec3 oz31 = floor(p31*K2)*Kz - Kzo;
111-
112-
vec3 ox32 = fract(p32*K) - Ko;
113-
vec3 oy32 = mod(floor(p32*K), 7.0)*K - Ko;
114-
vec3 oz32 = floor(p32*K2)*Kz - Kzo;
115-
116-
vec3 ox33 = fract(p33*K) - Ko;
117-
vec3 oy33 = mod(floor(p33*K), 7.0)*K - Ko;
118-
vec3 oz33 = floor(p33*K2)*Kz - Kzo;
119-
120-
vec3 dx11 = Pfx + jitter*ox11;
121-
vec3 dy11 = Pfy.x + jitter*oy11;
122-
vec3 dz11 = Pfz.x + jitter*oz11;
123-
124-
vec3 dx12 = Pfx + jitter*ox12;
125-
vec3 dy12 = Pfy.x + jitter*oy12;
126-
vec3 dz12 = Pfz.y + jitter*oz12;
127-
128-
vec3 dx13 = Pfx + jitter*ox13;
129-
vec3 dy13 = Pfy.x + jitter*oy13;
130-
vec3 dz13 = Pfz.z + jitter*oz13;
131-
132-
vec3 dx21 = Pfx + jitter*ox21;
133-
vec3 dy21 = Pfy.y + jitter*oy21;
134-
vec3 dz21 = Pfz.x + jitter*oz21;
135-
136-
vec3 dx22 = Pfx + jitter*ox22;
137-
vec3 dy22 = Pfy.y + jitter*oy22;
138-
vec3 dz22 = Pfz.y + jitter*oz22;
139-
140-
vec3 dx23 = Pfx + jitter*ox23;
141-
vec3 dy23 = Pfy.y + jitter*oy23;
142-
vec3 dz23 = Pfz.z + jitter*oz23;
143-
144-
vec3 dx31 = Pfx + jitter*ox31;
145-
vec3 dy31 = Pfy.z + jitter*oy31;
146-
vec3 dz31 = Pfz.x + jitter*oz31;
147-
148-
vec3 dx32 = Pfx + jitter*ox32;
149-
vec3 dy32 = Pfy.z + jitter*oy32;
150-
vec3 dz32 = Pfz.y + jitter*oz32;
151-
152-
vec3 dx33 = Pfx + jitter*ox33;
153-
vec3 dy33 = Pfy.z + jitter*oy33;
154-
vec3 dz33 = Pfz.z + jitter*oz33;
155-
156-
vec3 d11 = dx11 * dx11 + dy11 * dy11 + dz11 * dz11;
157-
vec3 d12 = dx12 * dx12 + dy12 * dy12 + dz12 * dz12;
158-
vec3 d13 = dx13 * dx13 + dy13 * dy13 + dz13 * dz13;
159-
vec3 d21 = dx21 * dx21 + dy21 * dy21 + dz21 * dz21;
160-
vec3 d22 = dx22 * dx22 + dy22 * dy22 + dz22 * dz22;
161-
vec3 d23 = dx23 * dx23 + dy23 * dy23 + dz23 * dz23;
162-
vec3 d31 = dx31 * dx31 + dy31 * dy31 + dz31 * dz31;
163-
vec3 d32 = dx32 * dx32 + dy32 * dy32 + dz32 * dz32;
164-
vec3 d33 = dx33 * dx33 + dy33 * dy33 + dz33 * dz33;
165-
166-
// Sort out the two smallest distances (F1, F2)
167-
#if 0
168-
// Cheat and sort out only F1
169-
vec3 d1 = min(min(d11,d12), d13);
170-
vec3 d2 = min(min(d21,d22), d23);
171-
vec3 d3 = min(min(d31,d32), d33);
172-
vec3 d = min(min(d1,d2), d3);
173-
d.x = min(min(d.x,d.y),d.z);
174-
return sqrt(d.xx); // F1 duplicated, no F2 computed
175-
#else
176-
// Do it right and sort out both F1 and F2
177-
vec3 d1a = min(d11, d12);
178-
d12 = max(d11, d12);
179-
d11 = min(d1a, d13); // Smallest now not in d12 or d13
180-
d13 = max(d1a, d13);
181-
d12 = min(d12, d13); // 2nd smallest now not in d13
182-
vec3 d2a = min(d21, d22);
183-
d22 = max(d21, d22);
184-
d21 = min(d2a, d23); // Smallest now not in d22 or d23
185-
d23 = max(d2a, d23);
186-
d22 = min(d22, d23); // 2nd smallest now not in d23
187-
vec3 d3a = min(d31, d32);
188-
d32 = max(d31, d32);
189-
d31 = min(d3a, d33); // Smallest now not in d32 or d33
190-
d33 = max(d3a, d33);
191-
d32 = min(d32, d33); // 2nd smallest now not in d33
192-
vec3 da = min(d11, d21);
193-
d21 = max(d11, d21);
194-
d11 = min(da, d31); // Smallest now in d11
195-
d31 = max(da, d31); // 2nd smallest now not in d31
196-
d11.xy = (d11.x < d11.y) ? d11.xy : d11.yx;
197-
d11.xz = (d11.x < d11.z) ? d11.xz : d11.zx; // d11.x now smallest
198-
d12 = min(d12, d21); // 2nd smallest now not in d21
199-
d12 = min(d12, d22); // nor in d22
200-
d12 = min(d12, d31); // nor in d31
201-
d12 = min(d12, d32); // nor in d32
202-
d11.yz = min(d11.yz,d12.xy); // nor in d12.yz
203-
d11.y = min(d11.y,d12.z); // Only two more to go
204-
d11.y = min(d11.y,d11.z); // Done! (Phew!)
205-
return sqrt(d11.xy); // F1, F2
206-
#endif
207-
}
208-
20940
v2f vert (appdata v)
21041
{
21142
v2f o;

‎Assets/Demoscene/Shaders/Includes/Noise.cginc

Lines changed: 174 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,174 @@
1+
#ifndef __NOISE__
2+
#define __NOISE__
3+
4+
// https://thebookofshaders.com/edit.php#12/3d-cnoise.frag
5+
vec3 permute(vec3 x) {
6+
return mod((34.0 * x + 1.0) * x, 289.0);
7+
}
8+
9+
// Cellular noise, returning F1 and F2 in a vec2.
10+
// 3x3x3 search region for good F2 everywhere, but a lot
11+
// slower than the 2x2x2 version.
12+
// The code below is a bit scary even to its author,
13+
// but it has at least half decent performance on a
14+
// modern GPU. In any case, it beats any software
15+
// implementation of Worley noise hands down.
16+
17+
vec2 cellular(vec3 P) {
18+
#define K 0.142857142857 // 1/7
19+
#define Ko 0.428571428571 // 1/2-K/2
20+
#define K2 0.020408163265306 // 1/(7*7)
21+
#define Kz 0.166666666667 // 1/6
22+
#define Kzo 0.416666666667 // 1/2-1/6*2
23+
#define jitter 1.0 // smaller jitter gives more regular pattern
24+
25+
vec3 Pi = mod(floor(P), 289.0);
26+
vec3 Pf = fract(P) - 0.5;
27+
28+
vec3 Pfx = Pf.x + vec3(1.0, 0.0, -1.0);
29+
vec3 Pfy = Pf.y + vec3(1.0, 0.0, -1.0);
30+
vec3 Pfz = Pf.z + vec3(1.0, 0.0, -1.0);
31+
32+
vec3 p = permute(Pi.x + vec3(-1.0, 0.0, 1.0));
33+
vec3 p1 = permute(p + Pi.y - 1.0);
34+
vec3 p2 = permute(p + Pi.y);
35+
vec3 p3 = permute(p + Pi.y + 1.0);
36+
37+
vec3 p11 = permute(p1 + Pi.z - 1.0);
38+
vec3 p12 = permute(p1 + Pi.z);
39+
vec3 p13 = permute(p1 + Pi.z + 1.0);
40+
41+
vec3 p21 = permute(p2 + Pi.z - 1.0);
42+
vec3 p22 = permute(p2 + Pi.z);
43+
vec3 p23 = permute(p2 + Pi.z + 1.0);
44+
45+
vec3 p31 = permute(p3 + Pi.z - 1.0);
46+
vec3 p32 = permute(p3 + Pi.z);
47+
vec3 p33 = permute(p3 + Pi.z + 1.0);
48+
49+
vec3 ox11 = fract(p11*K) - Ko;
50+
vec3 oy11 = mod(floor(p11*K), 7.0)*K - Ko;
51+
vec3 oz11 = floor(p11*K2)*Kz - Kzo; // p11 < 289 guaranteed
52+
53+
vec3 ox12 = fract(p12*K) - Ko;
54+
vec3 oy12 = mod(floor(p12*K), 7.0)*K - Ko;
55+
vec3 oz12 = floor(p12*K2)*Kz - Kzo;
56+
57+
vec3 ox13 = fract(p13*K) - Ko;
58+
vec3 oy13 = mod(floor(p13*K), 7.0)*K - Ko;
59+
vec3 oz13 = floor(p13*K2)*Kz - Kzo;
60+
61+
vec3 ox21 = fract(p21*K) - Ko;
62+
vec3 oy21 = mod(floor(p21*K), 7.0)*K - Ko;
63+
vec3 oz21 = floor(p21*K2)*Kz - Kzo;
64+
65+
vec3 ox22 = fract(p22*K) - Ko;
66+
vec3 oy22 = mod(floor(p22*K), 7.0)*K - Ko;
67+
vec3 oz22 = floor(p22*K2)*Kz - Kzo;
68+
69+
vec3 ox23 = fract(p23*K) - Ko;
70+
vec3 oy23 = mod(floor(p23*K), 7.0)*K - Ko;
71+
vec3 oz23 = floor(p23*K2)*Kz - Kzo;
72+
73+
vec3 ox31 = fract(p31*K) - Ko;
74+
vec3 oy31 = mod(floor(p31*K), 7.0)*K - Ko;
75+
vec3 oz31 = floor(p31*K2)*Kz - Kzo;
76+
77+
vec3 ox32 = fract(p32*K) - Ko;
78+
vec3 oy32 = mod(floor(p32*K), 7.0)*K - Ko;
79+
vec3 oz32 = floor(p32*K2)*Kz - Kzo;
80+
81+
vec3 ox33 = fract(p33*K) - Ko;
82+
vec3 oy33 = mod(floor(p33*K), 7.0)*K - Ko;
83+
vec3 oz33 = floor(p33*K2)*Kz - Kzo;
84+
85+
vec3 dx11 = Pfx + jitter*ox11;
86+
vec3 dy11 = Pfy.x + jitter*oy11;
87+
vec3 dz11 = Pfz.x + jitter*oz11;
88+
89+
vec3 dx12 = Pfx + jitter*ox12;
90+
vec3 dy12 = Pfy.x + jitter*oy12;
91+
vec3 dz12 = Pfz.y + jitter*oz12;
92+
93+
vec3 dx13 = Pfx + jitter*ox13;
94+
vec3 dy13 = Pfy.x + jitter*oy13;
95+
vec3 dz13 = Pfz.z + jitter*oz13;
96+
97+
vec3 dx21 = Pfx + jitter*ox21;
98+
vec3 dy21 = Pfy.y + jitter*oy21;
99+
vec3 dz21 = Pfz.x + jitter*oz21;
100+
101+
vec3 dx22 = Pfx + jitter*ox22;
102+
vec3 dy22 = Pfy.y + jitter*oy22;
103+
vec3 dz22 = Pfz.y + jitter*oz22;
104+
105+
vec3 dx23 = Pfx + jitter*ox23;
106+
vec3 dy23 = Pfy.y + jitter*oy23;
107+
vec3 dz23 = Pfz.z + jitter*oz23;
108+
109+
vec3 dx31 = Pfx + jitter*ox31;
110+
vec3 dy31 = Pfy.z + jitter*oy31;
111+
vec3 dz31 = Pfz.x + jitter*oz31;
112+
113+
vec3 dx32 = Pfx + jitter*ox32;
114+
vec3 dy32 = Pfy.z + jitter*oy32;
115+
vec3 dz32 = Pfz.y + jitter*oz32;
116+
117+
vec3 dx33 = Pfx + jitter*ox33;
118+
vec3 dy33 = Pfy.z + jitter*oy33;
119+
vec3 dz33 = Pfz.z + jitter*oz33;
120+
121+
vec3 d11 = dx11 * dx11 + dy11 * dy11 + dz11 * dz11;
122+
vec3 d12 = dx12 * dx12 + dy12 * dy12 + dz12 * dz12;
123+
vec3 d13 = dx13 * dx13 + dy13 * dy13 + dz13 * dz13;
124+
vec3 d21 = dx21 * dx21 + dy21 * dy21 + dz21 * dz21;
125+
vec3 d22 = dx22 * dx22 + dy22 * dy22 + dz22 * dz22;
126+
vec3 d23 = dx23 * dx23 + dy23 * dy23 + dz23 * dz23;
127+
vec3 d31 = dx31 * dx31 + dy31 * dy31 + dz31 * dz31;
128+
vec3 d32 = dx32 * dx32 + dy32 * dy32 + dz32 * dz32;
129+
vec3 d33 = dx33 * dx33 + dy33 * dy33 + dz33 * dz33;
130+
131+
// Sort out the two smallest distances (F1, F2)
132+
#if 0
133+
// Cheat and sort out only F1
134+
vec3 d1 = min(min(d11,d12), d13);
135+
vec3 d2 = min(min(d21,d22), d23);
136+
vec3 d3 = min(min(d31,d32), d33);
137+
vec3 d = min(min(d1,d2), d3);
138+
d.x = min(min(d.x,d.y),d.z);
139+
return sqrt(d.xx); // F1 duplicated, no F2 computed
140+
#else
141+
// Do it right and sort out both F1 and F2
142+
vec3 d1a = min(d11, d12);
143+
d12 = max(d11, d12);
144+
d11 = min(d1a, d13); // Smallest now not in d12 or d13
145+
d13 = max(d1a, d13);
146+
d12 = min(d12, d13); // 2nd smallest now not in d13
147+
vec3 d2a = min(d21, d22);
148+
d22 = max(d21, d22);
149+
d21 = min(d2a, d23); // Smallest now not in d22 or d23
150+
d23 = max(d2a, d23);
151+
d22 = min(d22, d23); // 2nd smallest now not in d23
152+
vec3 d3a = min(d31, d32);
153+
d32 = max(d31, d32);
154+
d31 = min(d3a, d33); // Smallest now not in d32 or d33
155+
d33 = max(d3a, d33);
156+
d32 = min(d32, d33); // 2nd smallest now not in d33
157+
vec3 da = min(d11, d21);
158+
d21 = max(d11, d21);
159+
d11 = min(da, d31); // Smallest now in d11
160+
d31 = max(da, d31); // 2nd smallest now not in d31
161+
d11.xy = (d11.x < d11.y) ? d11.xy : d11.yx;
162+
d11.xz = (d11.x < d11.z) ? d11.xz : d11.zx; // d11.x now smallest
163+
d12 = min(d12, d21); // 2nd smallest now not in d21
164+
d12 = min(d12, d22); // nor in d22
165+
d12 = min(d12, d31); // nor in d31
166+
d12 = min(d12, d32); // nor in d32
167+
d11.yz = min(d11.yz,d12.xy); // nor in d12.yz
168+
d11.y = min(d11.y,d12.z); // Only two more to go
169+
d11.y = min(d11.y,d11.z); // Done! (Phew!)
170+
return sqrt(d11.xy); // F1, F2
171+
#endif
172+
}
173+
174+
#endif

‎Assets/Demoscene/Shaders/Includes/Noise.cginc.meta

Lines changed: 9 additions & 0 deletions
Some generated files are not rendered by default. Learn more about customizing how changed files appear on GitHub.

0 commit comments

Comments
 (0)