Advertisement
Guest User

Untitled

a guest
Apr 20th, 2019
110
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 15.36 KB | None | 0 0
  1. // Check other page for Noise function
  2. const float PI = 3.141592653589793238462643383279;
  3. const float seed0 = 0.0;
  4.  
  5. // Rotations to hide some symmetry/bias, 4D rotations as the rotation must be applied to the
  6. // points in 4D space to maintain seamlessness, rotations are arbitrary
  7. // Matrices from here, only XZ and ZU are used here but any combination should work
  8. const mat4 rot0 = mat4(
  9. cos(0.77), 0, -cos(0.77), 0,
  10. 0, 1, 0, 0,
  11. sin(0.77), 0, cos(0.77), 0,
  12. 0, 0, 0, 1);
  13. const mat4 rot1 = mat4(
  14. 1, 0, 0, 0,
  15. 0, 1, 0, 0,
  16. 0, 0, cos(-0.23), -sin(-0.23),
  17. 0, 0, sin(-0.23), cos(-0.23));
  18.  
  19. const int A = 0, // Billow
  20. B = 1, // Terrace
  21. C = 2, // Mountains/Ridged
  22. D = 3; // FBM
  23.  
  24. struct Biome
  25. {
  26. float bias, scale;
  27. };
  28. Biome biomes[4] = Biome[4](
  29. Biome(0.0, 0.5),
  30. Biome(-0.25, 1.0),
  31. Biome(0.0, 1.0),
  32. Biome(-0.25, 0.75)
  33. );
  34.  
  35. struct BiomeSquare
  36. {
  37. int biomes[4];
  38. float t0, t1;
  39. float m0, m1;
  40. };
  41. //const int numBiomeSquare = 1;
  42. BiomeSquare biomeSquare[1] = BiomeSquare[1](
  43. BiomeSquare(int[4](A, B, C, D), 0.0, 1.0, 0.0, 1.0)
  44. );
  45.  
  46. int findBiomes(float temp, float moisture)
  47. {
  48. for(int i = 0; i < 1; i++)
  49. {
  50. if((temp >= biomeSquare[i].t0 && temp <= biomeSquare[i].t1)
  51. && (moisture > biomeSquare[i].m0 && moisture <= biomeSquare[i].m1))
  52. {
  53. return i;
  54. }
  55. }
  56. }
  57.  
  58. float InterpQuinticFunc(float t) { return t*t*t*(t*(t * 6.0 - 15.0) + 10.0); }
  59. float Lerp(float a, float b, float t) { return a + t * (b -a); }
  60.  
  61. float shiftRange(float v)
  62. {
  63. return (v*0.5)+0.5;
  64. }
  65. vec3 shiftRange(vec3 v)
  66. {
  67. return (v*0.5)+0.5;
  68. }
  69. float unshiftRange(float v)
  70. {
  71. return (v-0.5)*2.0;
  72. }
  73.  
  74. vec2 grad4to2(vec4 grad, float r, float theta, float phi)
  75. {
  76. return vec2(
  77. (-r * grad.x * sin(theta)) + (r * grad.y * cos(theta))
  78. , (-r * grad.z * sin(phi)) + (r * grad.w * cos(phi))
  79. );
  80. }
  81.  
  82. // Have a non-gradient returning version of snoise!
  83. float basicFbm(in vec2 x, float r, int octaves, float lac, float gain, float seed)
  84. {
  85. float v = 0.0, amp = 1.0;
  86. vec4 gradDummy;
  87.  
  88. float theta = (x.x) * 2.0 * PI;
  89. float phi = (x.y) * 2.0 * PI;
  90.  
  91. for(int i = 0; i < octaves; i++)
  92. {
  93. vec4 p4 = vec4(
  94. (r * cos(theta))
  95. , (r * sin(theta))
  96. , (r * cos(phi))
  97. , (r * sin(phi))
  98. );
  99. p4 *= rot0;
  100. p4 *= rot1;
  101. v += amp * snoise(p4, gradDummy, seed);
  102. amp *= gain;
  103. r *= lac;
  104. }
  105.  
  106. return v;
  107. }
  108.  
  109. vec4 basicFbm4(vec2 x, float r, int octaves, float lac, float gain)
  110. {
  111. vec4 v = vec4(0.0); float amp = 1.0;
  112. vec4 gradDummy;
  113.  
  114. float theta = (x.x) * 2.0 * PI;
  115. float phi = (x.y) * 2.0 * PI;
  116.  
  117. for(int i = 0; i < octaves; i++)
  118. {
  119. vec4 p4 = vec4(
  120. (r * cos(theta))
  121. , (r * sin(theta))
  122. , (r * cos(phi))
  123. , (r * sin(phi))
  124. );
  125. p4 *= rot0;
  126. p4 *= rot1;
  127. v += amp * vec4( snoise(p4 + vec4( 0.1, 1.4, -5.2, 0.87), gradDummy, seed0)
  128. , snoise(p4 + vec4( 2.4, -6.4, 3.4, 1.85), gradDummy, seed0)
  129. , snoise(p4 + vec4( 2.7, -2.0, 5.9, 1.3 ), gradDummy, seed0)
  130. , snoise(p4 + vec4(-3.3, -2.0, 1.7, -3.0 ), gradDummy, seed0));
  131. amp *= gain;
  132. r *= lac;
  133. }
  134.  
  135. return v;
  136. }
  137.  
  138. float terrain_fbm( in vec2 x, in vec4 pOffsets, in float r)
  139. {
  140. float lac = 2.0, v = 0.0, amp = 1.0;
  141. vec2 dsum = vec2(0.0);
  142.  
  143. float theta = (x.x) * 2.0 * PI;
  144. float phi = (x.y) * 2.0 * PI;
  145.  
  146. for( int i=0; i<6; i++ )
  147. {
  148. vec4 p4 = pOffsets + vec4(
  149. (r * cos(theta))
  150. , (r * sin(theta))
  151. , (r * cos(phi))
  152. , (r * sin(phi))
  153. );
  154. p4 *= rot0;
  155. p4 *= rot1;
  156. vec4 grad = vec4(0.0);
  157. float n = snoise(p4, grad, seed0);
  158. dsum += grad4to2(grad, r, theta, phi)*(0.5/r);
  159. v += amp*n/(1.0+dot(dsum,dsum));
  160. amp *= 0.65;
  161. r *= lac;
  162. }
  163. amp = 0.25;
  164. for( int i=0; i<5; i++ )
  165. {
  166. vec4 p4 = pOffsets + vec4(
  167. (r * cos(theta))
  168. , (r * sin(theta))
  169. , (r * cos(phi))
  170. , (r * sin(phi))
  171. );
  172. p4 *= rot0;
  173. p4 *= rot1;
  174. vec4 grad = vec4(0.0);
  175. float n = snoise(p4, grad, seed0)*0.15;
  176. dsum += grad4to2(grad, r, theta, phi)*(0.5/r);
  177. v += amp*n;
  178. amp *= 0.25;
  179. r *= lac;
  180. }
  181.  
  182. return v;
  183. }
  184.  
  185. float terrain_ridged( in vec2 x, in vec4 pOffsets, in float r)
  186. {
  187. float lac = 2.0, v = 0.0, amp = 1.0;
  188. vec2 dsum = vec2(0.0);
  189.  
  190. float theta = (x.x) * 2.0 * PI;
  191. float phi = (x.y) * 2.0 * PI;
  192.  
  193. for( int i=0; i<5; i++ )
  194. {
  195. vec4 p4 = pOffsets + vec4(
  196. (r * cos(theta))
  197. , (r * sin(theta))
  198. , (r * cos(phi))
  199. , (r * sin(phi))
  200. );
  201. p4 *= rot0;
  202. p4 *= rot1;
  203. vec4 grad = vec4(0.0);
  204. float n = (2.0 * pow(1.0 - abs(snoise(p4, grad, seed0)), 4.0)-1.0);
  205. dsum += grad4to2(grad, r, theta, phi)*(0.35/r);
  206. v += amp*n/(1.0+dot(dsum,dsum));
  207. amp *= 0.5;
  208. r *= lac;
  209. }
  210. r = 8.0; amp = 0.20;
  211. for( int i=0; i<5; i++ )
  212. {
  213. vec4 p4 = pOffsets + vec4(
  214. (r * cos(theta))
  215. , (r * sin(theta))
  216. , (r * cos(phi))
  217. , (r * sin(phi))
  218. );
  219. p4 *= rot0;
  220. p4 *= rot1;
  221. vec4 grad = vec4(0.0);
  222. float n = snoise(p4, grad, seed0);
  223. v += amp*n;
  224. amp *= 0.7;
  225. r *= lac;
  226. }
  227.  
  228. return v/1.5;
  229. }
  230.  
  231. float terrain_billow( in vec2 x, in vec4 pOffsets, in float r)
  232. {
  233. //x *= rot;
  234. float lac = 1.8, v = -1.0, amp = 1.0;
  235. vec2 dsum = vec2(0.0);
  236.  
  237. float theta = (x.x) * 2.0 * PI;
  238. float phi = (x.y) * 2.0 * PI;
  239.  
  240. for( int i=0; i<4; i++ )
  241. {
  242. vec4 p4 = pOffsets + vec4(
  243. (r * cos(theta))
  244. , (r * sin(theta))
  245. , (r * cos(phi))
  246. , (r * sin(phi))
  247. );
  248. p4 *= rot0;
  249. p4 *= rot1;
  250. vec4 grad = vec4(0.0);
  251.  
  252. float n = abs(snoise(p4, grad, seed0)) * 1.5;
  253. dsum += grad4to2(grad, r, theta, phi)*(0.125/r);
  254. v += amp*n/(1.0+dot(dsum,dsum));
  255. amp *= 0.6;
  256. r *= lac;
  257.  
  258. }
  259. v = clamp(v, 0.0, v);
  260. r = 4.0; amp = 0.6;
  261. for( int i=0; i<6; i++ )
  262. {
  263. vec4 p4 = pOffsets + vec4(
  264. (r * cos(theta))
  265. , (r * sin(theta))
  266. , (r * cos(phi))
  267. , (r * sin(phi))
  268. );
  269. p4 *= rot0;
  270. p4 *= rot1;
  271. vec4 grad = vec4(0.0);
  272.  
  273. float n = snoise(p4, grad, seed0);
  274. v += amp*n;
  275. amp *= 0.65;
  276. r *= lac;
  277. }
  278.  
  279. return v;
  280. }
  281.  
  282. float terrace_few( in vec2 x, in vec4 pOffsets, in float r)
  283. {
  284. float v = 0.0, amp = 1.0, lac = 1.75;
  285. float bandWidth = 0.4;
  286. vec2 dsum = vec2(0.0);
  287.  
  288. float theta = (x.x) * 2.0 * PI;
  289. float phi = (x.y) * 2.0 * PI;
  290.  
  291. for( int i=0; i<5; i++ )
  292. {
  293. vec4 p4 = pOffsets + vec4(
  294. (r * cos(theta))
  295. , (r * sin(theta))
  296. , (r * cos(phi))
  297. , (r * sin(phi))
  298. );
  299. p4 *= rot0;
  300. p4 *= rot1;
  301. vec4 grad = vec4(0.0);
  302.  
  303. float n = snoise(p4, grad, seed0);
  304. dsum += grad4to2(grad, r, theta, phi)*(0.5/r);
  305. v += amp*n/(1.0+dot(dsum,dsum));
  306. amp *= 0.55;
  307. r *= lac;
  308. }
  309. if(v > -0.66 && v < 0.8)
  310. {
  311. float k = floor(v/bandWidth);
  312. float f = (v - k*bandWidth) / bandWidth;
  313. float s = min(2.0*f, 1.0);
  314. float blend = smoothstep(-0.66, -0.33, v) * (1.0 - smoothstep(0.66, 0.8, v));
  315. v = ((k + s) * bandWidth)*blend + (v * (1.0 - blend));
  316. }
  317. r = 6.0;
  318. for( int i=0; i<4; i++ )
  319. {
  320. vec4 p4 = pOffsets + vec4(
  321. (r * cos(theta))
  322. , (r * sin(theta))
  323. , (r * cos(phi))
  324. , (r * sin(phi))
  325. );
  326. p4 *= rot0;
  327. p4 *= rot1;
  328. vec4 grad = vec4(0.0);
  329.  
  330. float n = snoise(p4, grad, seed0);
  331. v += amp*n;
  332. amp *= 0.5;
  333. r *= lac;
  334. }
  335. return v;
  336. }
  337.  
  338. float terrace_many( in vec2 x, in vec4 pOffsets, in float r)
  339. {
  340. float v = 0.0, amp = 1.0, lac = 1.75;
  341. float bandWidth = 0.25;
  342. vec2 dsum = vec2(0.0);
  343.  
  344. float theta = (x.x) * 2.0 * PI;
  345. float phi = (x.y) * 2.0 * PI;
  346.  
  347. for( int i=0; i<5; i++ )
  348. {
  349. vec4 p4 = pOffsets + vec4(
  350. (r * cos(theta))
  351. , (r * sin(theta))
  352. , (r * cos(phi))
  353. , (r * sin(phi))
  354. );
  355. p4 *= rot0;
  356. p4 *= rot1;
  357. vec4 grad = vec4(0.0);
  358.  
  359. float n = snoise(p4, grad, seed0);
  360.  
  361. dsum += grad4to2(grad, r, theta, phi)*(0.5/r);
  362. v += amp*n/(1.0+dot(dsum,dsum));
  363. amp *= 0.55;
  364. r *= lac;
  365. }
  366. if(v > -0.5 && v < 0.75)
  367. {
  368. float k = floor(v/bandWidth);
  369. float f = (v - k*bandWidth) / bandWidth;
  370. float s = min(2.0*f, 1.0);
  371. float blend = smoothstep(-0.5, -0.33, v) * (1.0 - smoothstep(0.66, 0.75, v));
  372. v = ((k + s) * bandWidth)*blend + (v * (1.0 - blend));
  373. }
  374. r = 6.0;
  375. for( int i=0; i<8; i++ )
  376. {
  377. vec4 p4 = pOffsets + vec4(
  378. (r * cos(theta))
  379. , (r * sin(theta))
  380. , (r * cos(phi))
  381. , (r * sin(phi))
  382. );
  383. p4 *= rot0;
  384. p4 *= rot1;
  385. vec4 grad = vec4(0.0);
  386.  
  387. float n = snoise(p4, grad, seed0);
  388.  
  389. dsum += grad4to2(grad, r, theta, phi)*(0.5/r);
  390. v += amp*n;
  391. amp *= 0.5;
  392. r *= lac;
  393. }
  394. return v;
  395. }
  396.  
  397. float terrace_many_warped( in vec2 x, in vec4 pOffsets, in float r)
  398. {
  399. float v = 0.0, amp = 1.0, lac = 1.75;
  400. float bandWidth = 0.25;
  401. vec2 dsum = vec2(0.0);
  402. int w1o = 4;
  403. //int w2o = 2;
  404. //int w3o = 1;
  405.  
  406. float theta = (x.x) * 2.0 * PI;
  407. float phi = (x.y) * 2.0 * PI;
  408.  
  409. for( int i=0; i<2; i++ )
  410. {
  411. vec4 p4 = pOffsets + vec4(
  412. (r * cos(theta))
  413. , (r * sin(theta))
  414. , (r * cos(phi))
  415. , (r * sin(phi))
  416. );
  417. p4 *= rot0;
  418. p4 *= rot1;
  419. vec4 grad = vec4(0.0);
  420.  
  421. vec4 warp4 = (p4 + basicFbm4(x, r, w1o, lac*0.5, 0.5));
  422. //vec4 warp4_2 = (warp4 + basicFbm4(x, r, w2o, lac, 0.5));
  423. //vec4 warp4_3 = (warp4_2 + basicFbm4(x, r, w3o, lac, 0.5));
  424.  
  425.  
  426. float n = snoise(warp4, grad, seed0);
  427.  
  428. dsum += grad4to2(grad, r, theta, phi)*(0.5/r);
  429. v += amp*n/(1.0+dot(dsum,dsum));
  430. amp *= 0.55;
  431. r *= lac;
  432. }
  433. if(v > -1.0 && v < 0.7)
  434. {
  435. float k = floor(v/bandWidth);
  436. float f = (v - k*bandWidth) / bandWidth;
  437. float s = min(2.0*f, 1.0);
  438. float blend = smoothstep(-1.0, -0.6, v) * (1.0 - smoothstep(0.6, 0.7, v));
  439. v = ((k + s) * bandWidth)*blend + (v * (1.0 - blend));
  440. }
  441. v = clamp(v, -1.0, 0.7);
  442. r = 10.0; amp = 0.05;
  443. for( int i=0; i<1; i++ )
  444. {
  445. vec4 p4 = pOffsets + vec4(
  446. (r * cos(theta))
  447. , (r * sin(theta))
  448. , (r * cos(phi))
  449. , (r * sin(phi))
  450. );
  451. p4 *= rot0;
  452. p4 *= rot1;
  453. vec4 grad = vec4(0.0);
  454.  
  455. float n = snoise(p4, grad, seed0);
  456.  
  457. dsum += grad4to2(grad, r, theta, phi)*(0.5/r);
  458. v += amp*n;
  459. amp *= 0.5;
  460. r *= lac;
  461. }
  462. return v;
  463. }
  464.  
  465. vec3 terrainBlend(in vec2 uv)
  466. {
  467. vec4 pOffsets = vec4(
  468. 123.456
  469. , -432.912
  470. , -198.023
  471. , 543.298
  472. );
  473. float terrainHeight = (basicFbm(uv, 1.0, 5, 2.2, 0.55, 24.0)); // Just basic fbm for terrain height guide
  474.  
  475. float terrainTemp;
  476. float my = mod(uv.y, 1.0);
  477. //terrainTemp = (my < 0.5) ? (my - 0.25)*4.0 : (my - 0.75)*-4.0; // Gradient centred on 0.5
  478.  
  479. terrainTemp = (my < 0.5) ? (my*2.0) : (2.0-(my*2.0)); // Gradient centred on 0.5
  480. terrainTemp *= shiftRange(basicFbm(uv, 2.0, 6, 1.75, 0.5, 24.0));
  481.  
  482. terrainTemp = unshiftRange(terrainTemp);
  483. terrainTemp -= (0.3 * terrainHeight)*smoothstep(-0.15, 0.10, terrainHeight)*(1.0 - smoothstep(0.10, 0.3, terrainHeight));
  484. terrainTemp -= (0.4 * terrainHeight)*smoothstep( 0.10, 0.25, terrainHeight)*(1.0 - smoothstep(0.45, 0.65, terrainHeight));
  485. terrainTemp -= (0.6 * terrainHeight)*smoothstep( 0.45, 0.65, terrainHeight)*(1.0 - smoothstep(0.7, 0.85, terrainHeight));
  486. terrainTemp -= (0.7 * terrainHeight)*smoothstep( 0.7, 0.85, terrainHeight);
  487. terrainTemp = shiftRange(terrainTemp);
  488. terrainTemp = terrainTemp*2.25; // Strengthen gradient around centre
  489. terrainTemp = clamp(terrainTemp, 0.0, 1.0);
  490.  
  491. float terrainMoisture = shiftRange(basicFbm(uv, 2.0, 4, 2.0, 0.5, 12.0));
  492. terrainMoisture += 1.0 - smoothstep(-1.0, -0.1, terrainHeight);
  493. terrainMoisture = clamp(terrainMoisture, 0.0, 1.0);
  494.  
  495. // Calculate biomes & respective weights
  496. //int biome = findBiomes(terrainTemp, terrainMoisture);
  497. float tBlend, mBlend;
  498. //tBlend = InterpQuinticFunc(terrainTemp - biomeSquare[biome].t0);
  499. //mBlend = InterpQuinticFunc(terrainMoisture - biomeSquare[biome].t1);
  500. tBlend = InterpQuinticFunc(terrainTemp);
  501. mBlend = InterpQuinticFunc(terrainMoisture);
  502.  
  503. // Sample four nearest biomes
  504. float values[4];
  505. //for(int i = 0; i < 4; i++)
  506. //{
  507. // switch(biomeSquare[biome].biomes[i])
  508. // {
  509. // case A: values[i] = terrain_billow(uv, pOffsets);
  510. // case B: values[i] = terrace_many(uv, pOffsets);
  511. // case C: values[i] = terrain_ridged(uv, pOffsets);
  512. // case D: values[i] = terrain_fbm(uv, pOffsets);
  513. // default: values[i] = 0.0;
  514. // }
  515. //}
  516.  
  517. values[0] = terrain_billow(uv, pOffsets, 3.0) * 0.5;
  518. values[1] = (terrace_few(uv, pOffsets, 2.5) - 0.25);
  519. values[2] = terrain_ridged(uv, pOffsets, 3.0);
  520. values[3] = (terrain_fbm(uv, pOffsets, 2.0) - 0.25) * 0.75;
  521.  
  522. // Calculate new height map
  523. float heightmap = Lerp( Lerp(values[0], values[1], tBlend)
  524. ,Lerp(values[2], values[3], tBlend), mBlend);
  525.  
  526. //return vec3(terrainTemp, 0.0, 0.0);
  527. //return vec3(terrainTemp, terrainMoisture, heightmap);
  528. //return vec3(tBlend, mBlend, heightmap);
  529. //return vec3(terrainHeight, terrainHeight, terrainHeight);
  530. return vec3(heightmap, heightmap, heightmap);
  531.  
  532.  
  533. //return terrainHeight;
  534. //return terrainTemp;
  535. //return terrainMoisture;
  536. //return heightmap;
  537. //return 0.0;
  538. }
  539.  
  540. void mainImage( out vec4 fragColor, in vec2 fragCoord )
  541. {
  542. vec2 uv = (fragCoord)/iResolution.y;
  543. // Set to 1 to enable cyclic zoom in to show increased detail
  544. #if 0
  545. uv.x += sin(iTime*0.35)*0.5;
  546. uv.y += cos(iTime*0.35)*0.5;
  547. uv = uv*((sin(iTime*0.25)*0.5 + 0.5) + 0.125);
  548. #else
  549. uv *= 1.125;
  550. //uv *= 0.5;
  551. uv.y -= 0.06;
  552. uv.x -= iTime*0.1;
  553. #endif
  554. vec4 pOffsets = vec4(
  555. 123.456
  556. , -432.912
  557. , -198.023
  558. , 543.298
  559. ); //pOffsets += iTime * 0.1;
  560.  
  561. //float v = basicFbm(uv, 1.0, 7, 1.55, 0.6);
  562. //float v = terrainBlend(uv);
  563. //v = shiftRange(v);
  564. vec3 v= terrainBlend(uv);
  565. v = shiftRange(v);
  566. //v.z = 0.0;
  567.  
  568. // Output to screen
  569. if((mod(uv.x, 1.0025) <= 1.0 || mod(uv.x, 1.0025) >= 1.0025)
  570. && (mod(uv.y, 1.0025) <= 1.0 || mod(uv.y, 1.0025) >= 1.0025)) fragColor = vec4(v, 1.0);
  571. else fragColor = vec4(1.0, 0.0, 1.0, 1.0);
  572.  
  573. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement