NoiseInclude.cginc 7.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293
  1. float3 mod(float3 x, float3 y)
  2. {
  3. return x - y * floor(x / y);
  4. }
  5. float4 mod(float4 x, float4 y)
  6. {
  7. return x - y * floor(x / y);
  8. }
  9. float3 mod289(float3 x)
  10. {
  11. return x - floor(x / 289.0) * 289.0;
  12. }
  13. float4 mod289(float4 x)
  14. {
  15. return x - floor(x * (1.0 / 289.0)) * 289.0;
  16. }
  17. float4 permute(float4 x)
  18. {
  19. return mod289(((x*34.0) + 1.0)*x);
  20. }
  21. float3 fade(float3 t) {
  22. return t*t*t*(t*(t*6.0 - 15.0) + 10.0);
  23. }
  24. float4 taylorInvSqrt(float4 r)
  25. {
  26. return 1.79284291400159 - 0.85373472095314 * r;
  27. }
  28. float2 fade(float2 t) {
  29. return t*t*t*(t*(t*6.0 - 15.0) + 10.0);
  30. }
  31. // Classic Perlin noise, periodic variant
  32. float penoise(float2 P, float2 rep)
  33. {
  34. float4 Pi = floor(P.xyxy) + float4(0.0, 0.0, 1.0, 1.0);
  35. float4 Pf = frac(P.xyxy) - float4(0.0, 0.0, 1.0, 1.0);
  36. Pi = mod(Pi, rep.xyxy); // To create noise with explicit period
  37. Pi = mod289(Pi); // To avoid truncation effects in permutation
  38. float4 ix = Pi.xzxz;
  39. float4 iy = Pi.yyww;
  40. float4 fx = Pf.xzxz;
  41. float4 fy = Pf.yyww;
  42. float4 i = permute(permute(ix) + iy);
  43. float4 gx = frac(i * (1.0 / 41.0)) * 2.0 - 1.0;
  44. float4 gy = abs(gx) - 0.5;
  45. float4 tx = floor(gx + 0.5);
  46. gx = gx - tx;
  47. float2 g00 = float2(gx.x, gy.x);
  48. float2 g10 = float2(gx.y, gy.y);
  49. float2 g01 = float2(gx.z, gy.z);
  50. float2 g11 = float2(gx.w, gy.w);
  51. float4 norm = taylorInvSqrt(float4(dot(g00, g00), dot(g01, g01), dot(g10, g10), dot(g11, g11)));
  52. g00 *= norm.x;
  53. g01 *= norm.y;
  54. g10 *= norm.z;
  55. g11 *= norm.w;
  56. float n00 = dot(g00, float2(fx.x, fy.x));
  57. float n10 = dot(g10, float2(fx.y, fy.y));
  58. float n01 = dot(g01, float2(fx.z, fy.z));
  59. float n11 = dot(g11, float2(fx.w, fy.w));
  60. float2 fade_xy = fade(Pf.xy);
  61. float2 n_x = lerp(float2(n00, n01), float2(n10, n11), fade_xy.x);
  62. float n_xy = lerp(n_x.x, n_x.y, fade_xy.y);
  63. return 2.3 * n_xy;
  64. }
  65. float CalculatePerlinTileing5(float2 p, float2 rep)
  66. {
  67. float2 xy = p;
  68. float amplitude_factor = 0.5;
  69. float frequency_factor = 1.0;
  70. float a = 1.0;
  71. float perlin_value = 0.0;
  72. perlin_value += a * penoise(xy, rep).r; a *= amplitude_factor; xy *= (frequency_factor + 1);
  73. perlin_value -= a * penoise(xy, rep).r; a *= amplitude_factor; xy *= (frequency_factor + 1);
  74. perlin_value -= a * penoise(xy, rep).r; a *= amplitude_factor; xy *= (frequency_factor + 1);
  75. perlin_value -= a * penoise(xy, rep).r; a *= amplitude_factor; xy *= (frequency_factor + 1);
  76. perlin_value += a * penoise(xy, rep).r;
  77. return perlin_value;
  78. }
  79. float CalculatePerlinTileing5OLD(float2 p, float2 rep)
  80. {
  81. float2 xy = p;
  82. float amplitude_factor = 0.5;
  83. float frequency_factor = 2.0;
  84. float a = 1.0;
  85. float perlin_value = 0.0;
  86. perlin_value += a * penoise(xy, rep).r; a *= amplitude_factor; xy *= (frequency_factor + 0.12);
  87. perlin_value -= a * penoise(xy, rep).r; a *= amplitude_factor; xy *= (frequency_factor + 0.03);
  88. perlin_value -= a * penoise(xy, rep).r; a *= amplitude_factor; xy *= (frequency_factor + 0.01);
  89. perlin_value -= a * penoise(xy, rep).r; a *= amplitude_factor; xy *= (frequency_factor + 0.01);
  90. perlin_value += a * penoise(xy, rep).r;
  91. return perlin_value;
  92. }
  93. float CalculatePerlinTileing(float2 p, float2 rep)
  94. {
  95. float2 xy = p;
  96. float amplitude_factor = 0.5;
  97. float frequency_factor = 1.0;
  98. float a = 1.0;
  99. float perlin_value = 0.0;
  100. perlin_value += a * penoise(xy, rep).r; a *= amplitude_factor; xy *= (frequency_factor + 1);
  101. perlin_value += a * penoise(xy, rep).r; a *= amplitude_factor; xy *= (frequency_factor + 1);
  102. perlin_value += a * penoise(xy, rep).r; a *= amplitude_factor; xy *= (frequency_factor + 2);
  103. perlin_value -= a * penoise(xy, rep).r;
  104. return perlin_value;
  105. }
  106. ///////////WORLEY
  107. float set_range(float value, float low, float high)
  108. {
  109. return saturate((value - low)/(high - low));
  110. }
  111. float dilate_perlin_worley(float p, float w, float x)
  112. {
  113. float curve = 0.75;
  114. if (x < 0.5)
  115. {
  116. x = x / 0.5;
  117. float n = p + w * x;
  118. return n * lerp(1, 0.5, pow(x, curve));
  119. }
  120. else
  121. {
  122. x = (x - 0.5) / 0.5;
  123. float n = w + p * (1.0 - x);
  124. return n * lerp(0.5, 1.0, pow(x, 1.0 / curve));
  125. }
  126. }
  127. #define UI0 1597334673
  128. #define UI1 3812015801
  129. #define UI2 uint2(UI0, UI1)
  130. #define UI3 uint3(UI0, UI1, 2798796415)
  131. #define UIF (1.0 / float(0xffffffffU))
  132. float3 hash33(float3 p)
  133. {
  134. uint3 q = uint3(int3(p)) * UI3;
  135. q = (q.x ^ q.y ^ q.z)*UI3;
  136. return -1. + 2. * float3(q) * UIF;
  137. }
  138. float2 hash22(float2 p)
  139. {
  140. uint2 q = uint2(int2(p)) * UI3.xy;
  141. q = (q.x ^ q.y)*UI3.xy;
  142. return -1. + 2. * float2(q) * UIF;
  143. }
  144. // Gradient noise by iq (modified to be tileable)
  145. float gradientNoise(float3 x, float freq)
  146. {
  147. // grid
  148. float3 p = floor(x);
  149. float3 w = frac(x);
  150. // quintic interpolant
  151. float3 u = w * w * w * (w * (w * 6. - 15.) + 10.);
  152. // gradients
  153. float3 ga = hash33(fmod(p + float3(0., 0., 0.), freq));
  154. float3 gb = hash33(fmod(p + float3(1., 0., 0.), freq));
  155. float3 gc = hash33(fmod(p + float3(0., 1., 0.), freq));
  156. float3 gd = hash33(fmod(p + float3(1., 1., 0.), freq));
  157. float3 ge = hash33(fmod(p + float3(0., 0., 1.), freq));
  158. float3 gf = hash33(fmod(p + float3(1., 0., 1.), freq));
  159. float3 gg = hash33(fmod(p + float3(0., 1., 1.), freq));
  160. float3 gh = hash33(fmod(p + float3(1., 1., 1.), freq));
  161. // projections
  162. float va = dot(ga, w - float3(0., 0., 0.));
  163. float vb = dot(gb, w - float3(1., 0., 0.));
  164. float vc = dot(gc, w - float3(0., 1., 0.));
  165. float vd = dot(gd, w - float3(1., 1., 0.));
  166. float ve = dot(ge, w - float3(0., 0., 1.));
  167. float vf = dot(gf, w - float3(1., 0., 1.));
  168. float vg = dot(gg, w - float3(0., 1., 1.));
  169. float vh = dot(gh, w - float3(1., 1., 1.));
  170. // interpolation
  171. return va +
  172. u.x * (vb - va) +
  173. u.y * (vc - va) +
  174. u.z * (ve - va) +
  175. u.x * u.y * (va - vb - vc + vd) +
  176. u.y * u.z * (va - vc - ve + vg) +
  177. u.z * u.x * (va - vb - ve + vf) +
  178. u.x * u.y * u.z * (-va + vb + vc - vd + ve - vf - vg + vh);
  179. }
  180. // Tileable 3D worley noise
  181. float worleyNoise(float3 uv, float freq)
  182. {
  183. float3 id = floor(uv);
  184. float3 p = frac(uv);
  185. float minDist = 10000.;
  186. for (float x = -1.; x <= 1.; ++x)
  187. {
  188. for(float y = -1.; y <= 1.; ++y)
  189. {
  190. for(float z = -1.; z <= 1.; ++z)
  191. {
  192. float3 offset = float3(x, y, z);
  193. float3 h = hash33(fmod(id + offset, float3(freq,freq,freq))) * .5 + .5;
  194. h += offset;
  195. float3 d = p - h;
  196. minDist = min(minDist, dot(d, d));
  197. }
  198. }
  199. }
  200. // inverted worley noise
  201. return 1. - minDist;
  202. }
  203. float worleyFbm(float3 p, float freq)
  204. {
  205. return worleyNoise(p*freq, freq) * .625 +
  206. worleyNoise(p*freq*2., freq*2.) * .25 +
  207. worleyNoise(p*freq*4., freq*4.) * .125;
  208. }
  209. float worleyNoise2D(float2 uv, float freq)
  210. {
  211. float2 id = floor(uv);
  212. float2 p = frac(uv);
  213. float minDist = 10000.;
  214. for (float x = -1.; x <= 1.; ++x)
  215. {
  216. for(float y = -1.; y <= 1.; ++y)
  217. {
  218. float2 offset = float2(x, y);
  219. float2 h = hash22(fmod(id + offset, float2(freq,freq))) * .5 + .5;
  220. h += offset;
  221. float2 d = p - h;
  222. minDist = min(minDist, dot(d, d));
  223. }
  224. }
  225. // inverted worley noise
  226. return 1. - minDist;
  227. }
  228. float worleyFbm2DFiller(float2 p, float freq)
  229. {
  230. return worleyNoise2D(p*freq, freq) * .625 + worleyNoise2D(p*freq*2., freq*2.) * .225 + worleyNoise2D(p*freq*4., freq*4.) * .125;
  231. }
  232. float worleyFbm2D(float2 p, float freq)
  233. {
  234. return worleyNoise2D(p*freq, freq) * .625 - worleyNoise2D(p*freq*2., freq*2.) * .225 + worleyNoise2D(p*freq*4., freq*4.) * .125;
  235. }
  236. float worley2(float2 p, float freq)
  237. {
  238. float fbm = worleyFbm2D(p*freq * 4, 4) * 1.2;
  239. float worl = worleyNoise2D(p*freq*2, 1) * .425 - worleyNoise2D(p*freq*2, 1) * .225;
  240. return saturate(fbm - worl);
  241. }