API tools faq
paste
Guest User

Simplex.LUA

a guest
Feb 16th, 2023
177
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 18.58 KB | Source Code | 0 0
raw download clone embed print report
  1. -----------------------------------------------
  2. ---Simplex Noise
  3. -- Original Java Source: http://staffwww.itn.liu.se/~stegu/simplexnoise/simplexnoise.pdf
  4. -- Original Author: https://raw.githubusercontent.com/weswigham/simplex/master/lua/src/simplex.lua
  5. -- (most) Original comments included
  6. -----------------------------------------------
  7.  
  8. AddCSLuaFile()
  9.  
  10. local math = math
  11. local table = table
  12. local tonumber = tonumber
  13. local ipairs = ipairs
  14. local error = error
  15.  
  16. local simplex = {}
  17.  
  18. simplex.DIR_X = 0
  19. simplex.DIR_Y = 1
  20. simplex.DIR_Z = 2
  21. simplex.DIR_W = 3
  22. simplex.internalCache = false
  23.  
  24.  
  25. local Gradients3D = {{1,1,0},{-1,1,0},{1,-1,0},{-1,-1,0},
  26. {1,0,1},{-1,0,1},{1,0,-1},{-1,0,-1},
  27. {0,1,1},{0,-1,1},{0,1,-1},{0,-1,-1}};
  28. local Gradients4D = {{0,1,1,1}, {0,1,1,-1}, {0,1,-1,1}, {0,1,-1,-1},
  29. {0,-1,1,1}, {0,-1,1,-1}, {0,-1,-1,1}, {0,-1,-1,-1},
  30. {1,0,1,1}, {1,0,1,-1}, {1,0,-1,1}, {1,0,-1,-1},
  31. {-1,0,1,1}, {-1,0,1,-1}, {-1,0,-1,1}, {-1,0,-1,-1},
  32. {1,1,0,1}, {1,1,0,-1}, {1,-1,0,1}, {1,-1,0,-1},
  33. {-1,1,0,1}, {-1,1,0,-1}, {-1,-1,0,1}, {-1,-1,0,-1},
  34. {1,1,1,0}, {1,1,-1,0}, {1,-1,1,0}, {1,-1,-1,0},
  35. {-1,1,1,0}, {-1,1,-1,0}, {-1,-1,1,0}, {-1,-1,-1,0}};
  36. local p = {151,160,137,91,90,15,
  37. 131,13,201,95,96,53,194,233,7,225,140,36,103,30,69,142,8,99,37,240,21,10,23,
  38. 190, 6,148,247,120,234,75,0,26,197,62,94,252,219,203,117,35,11,32,57,177,33,
  39. 88,237,149,56,87,174,20,125,136,171,168, 68,175,74,165,71,134,139,48,27,166,
  40. 77,146,158,231,83,111,229,122,60,211,133,230,220,105,92,41,55,46,245,40,244,
  41. 102,143,54, 65,25,63,161, 1,216,80,73,209,76,132,187,208, 89,18,169,200,196,
  42. 135,130,116,188,159,86,164,100,109,198,173,186, 3,64,52,217,226,250,124,123,
  43. 5,202,38,147,118,126,255,82,85,212,207,206,59,227,47,16,58,17,182,189,28,42,
  44. 223,183,170,213,119,248,152, 2,44,154,163, 70,221,153,101,155,167, 43,172,9,
  45. 129,22,39,253, 19,98,108,110,79,113,224,232,178,185, 112,104,218,246,97,228,
  46. 251,34,242,193,238,210,144,12,191,179,162,241, 81,51,145,235,249,14,239,107,
  47. 49,192,214, 31,181,199,106,157,184, 84,204,176,115,121,50,45,127, 4,150,254,
  48. 138,236,205,93,222,114,67,29,24,72,243,141,128,195,78,66,215,61,156,180};
  49.  
  50. -- To remove the need for index wrapping, double the permutation table length
  51.  
  52. for i=1,#p do
  53. p[i-1] = p[i]
  54. p[i] = nil
  55. end
  56.  
  57. for i=1,#Gradients3D do
  58. Gradients3D[i-1] = Gradients3D[i]
  59. Gradients3D[i] = nil
  60. end
  61.  
  62. for i=1,#Gradients4D do
  63. Gradients4D[i-1] = Gradients4D[i]
  64. Gradients4D[i] = nil
  65. end
  66.  
  67. local perm = {}
  68.  
  69. for i=0,255 do
  70. perm[i] = p[i]
  71. perm[i+256] = p[i]
  72. end
  73.  
  74. -- A lookup table to traverse the sim around a given point in 4D.
  75. -- Details can be found where this table is used, in the 4D noise method.
  76.  
  77. local sim = {
  78. {0,1,2,3},{0,1,3,2},{0,0,0,0},{0,2,3,1},{0,0,0,0},{0,0,0,0},{0,0,0,0},{1,2,3,0},
  79. {0,2,1,3},{0,0,0,0},{0,3,1,2},{0,3,2,1},{0,0,0,0},{0,0,0,0},{0,0,0,0},{1,3,2,0},
  80. {0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
  81. {1,2,0,3},{0,0,0,0},{1,3,0,2},{0,0,0,0},{0,0,0,0},{0,0,0,0},{2,3,0,1},{2,3,1,0},
  82. {1,0,2,3},{1,0,3,2},{0,0,0,0},{0,0,0,0},{0,0,0,0},{2,0,3,1},{0,0,0,0},{2,1,3,0},
  83. {0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
  84. {2,0,1,3},{0,0,0,0},{0,0,0,0},{0,0,0,0},{3,0,1,2},{3,0,2,1},{0,0,0,0},{3,1,2,0},
  85. {2,1,0,3},{0,0,0,0},{0,0,0,0},{0,0,0,0},{3,1,0,2},{0,0,0,0},{3,2,0,1},{3,2,1,0}};
  86.  
  87. local function Dot2D(tbl, x, y)
  88. return tbl[1]*x + tbl[2]*y;
  89. end
  90.  
  91. local function Dot3D(tbl, x, y, z)
  92. return tbl[1]*x + tbl[2]*y + tbl[3]*z
  93. end
  94.  
  95. local function Dot4D( tbl, x,y,z,w)
  96. return tbl[1]*x + tbl[2]*y + tbl[3]*z + tbl[3]*w;
  97. end
  98.  
  99. local Prev2D = {}
  100.  
  101.  
  102. -- 2D simplex noise
  103.  
  104. function simplex.Noise2D(xin, yin)
  105. if simplex.internalCache and Prev2D[xin] and Prev2D[xin][yin] then return Prev2D[xin][yin] end
  106.  
  107. local n0, n1, n2; -- Noise contributions from the three corners
  108. -- Skew the input space to determine which simplex cell we're in
  109. local F2 = 0.5*(math.sqrt(3.0)-1.0);
  110. local s = (xin+yin)*F2; -- Hairy factor for 2D
  111. local i = math.floor(xin+s);
  112. local j = math.floor(yin+s);
  113. local G2 = (3.0-math.sqrt(3.0))/6.0;
  114.  
  115. local t = (i+j)*G2;
  116. local X0 = i-t; -- Unskew the cell origin back to (x,y) space
  117. local Y0 = j-t;
  118. local x0 = xin-X0; -- The x,y distances from the cell origin
  119. local y0 = yin-Y0;
  120.  
  121. -- For the 2D case, the simplex shape is an equilateral triangle.
  122. -- Determine which simplex we are in.
  123. local i1, j1; -- Offsets for second (middle) corner of simplex in (i,j) coords
  124. if(x0>y0) then
  125. i1=1
  126. j1=0 -- lower triangle, XY order: (0,0)->(1,0)->(1,1)
  127. else
  128. i1=0
  129. j1=1 -- upper triangle, YX order: (0,0)->(0,1)->(1,1)
  130. end
  131.  
  132. -- A step of (1,0) in (i,j) means a step of (1-c,-c) in (x,y), and
  133. -- a step of (0,1) in (i,j) means a step of (-c,1-c) in (x,y), where
  134. -- c = (3-sqrt(3))/6
  135.  
  136. local x1 = x0 - i1 + G2; -- Offsets for middle corner in (x,y) unskewed coords
  137. local y1 = y0 - j1 + G2;
  138. local x2 = x0 - 1.0 + 2.0 * G2; -- Offsets for last corner in (x,y) unskewed coords
  139. local y2 = y0 - 1.0 + 2.0 * G2;
  140.  
  141. -- Work out the hashed gradient indices of the three simplex corners
  142. local ii = bit.band(i , 255)
  143. local jj = bit.band(j , 255)
  144. local gi0 = perm[ii+perm[jj]] % 12;
  145. local gi1 = perm[ii+i1+perm[jj+j1]] % 12;
  146. local gi2 = perm[ii+1+perm[jj+1]] % 12;
  147.  
  148. -- Calculate the contribution from the three corners
  149. local t0 = 0.5 - x0*x0-y0*y0;
  150. if t0<0 then
  151. n0 = 0.0;
  152. else
  153. t0 = t0 * t0
  154. n0 = t0 * t0 * Dot2D(Gradients3D[gi0], x0, y0); -- (x,y) of Gradients3D used for 2D gradient
  155. end
  156.  
  157. local t1 = 0.5 - x1*x1-y1*y1;
  158. if (t1<0) then
  159. n1 = 0.0;
  160. else
  161. t1 = t1*t1
  162. n1 = t1 * t1 * Dot2D(Gradients3D[gi1], x1, y1);
  163. end
  164.  
  165. local t2 = 0.5 - x2*x2-y2*y2;
  166. if (t2<0) then
  167. n2 = 0.0;
  168. else
  169. t2 = t2*t2
  170. n2 = t2 * t2 * Dot2D(Gradients3D[gi2], x2, y2);
  171. end
  172.  
  173.  
  174. -- Add contributions from each corner to get the final noise value.
  175. -- The result is scaled to return values in the localerval [-1,1].
  176.  
  177. local retval = 70.0 * (n0 + n1 + n2)
  178.  
  179. if simplex.internalCache then
  180. if not Prev2D[xin] then Prev2D[xin] = {} end
  181. Prev2D[xin][yin] = retval
  182. end
  183.  
  184. return retval;
  185. end
  186.  
  187. local Prev3D = {}
  188.  
  189. -- 3D simplex noise
  190. function simplex.Noise3D(xin, yin, zin)
  191.  
  192. if simplex.internalCache and Prev3D[xin] and Prev3D[xin][yin] and Prev3D[xin][yin][zin] then return Prev3D[xin][yin][zin] end
  193.  
  194. local n0, n1, n2, n3; -- Noise contributions from the four corners
  195.  
  196. -- Skew the input space to determine which simplex cell we're in
  197. local F3 = 1.0/3.0;
  198. local s = (xin+yin+zin)*F3; -- Very nice and simple skew factor for 3D
  199. local i = math.floor(xin+s);
  200. local j = math.floor(yin+s);
  201. local k = math.floor(zin+s);
  202.  
  203. local G3 = 1.0/6.0; -- Very nice and simple unskew factor, too
  204. local t = (i+j+k)*G3;
  205.  
  206. local X0 = i-t; -- Unskew the cell origin back to (x,y,z) space
  207. local Y0 = j-t;
  208. local Z0 = k-t;
  209.  
  210. local x0 = xin-X0; -- The x,y,z distances from the cell origin
  211. local y0 = yin-Y0;
  212. local z0 = zin-Z0;
  213.  
  214. -- For the 3D case, the simplex shape is a slightly irregular tetrahedron.
  215. -- Determine which simplex we are in.
  216. local i1, j1, k1; -- Offsets for second corner of simplex in (i,j,k) coords
  217. local i2, j2, k2; -- Offsets for third corner of simplex in (i,j,k) coords
  218.  
  219. if (x0>=y0) then
  220. if (y0>=z0) then
  221. i1=1; j1=0; k1=0; i2=1; j2=1; k2=0; -- X Y Z order
  222. elseif (x0>=z0) then
  223. i1=1; j1=0; k1=0; i2=1; j2=0; k2=1; -- X Z Y order
  224. else
  225. i1=0; j1=0; k1=1; i2=1; j2=0; k2=1; -- Z X Y order
  226. end
  227. else -- x0<y0
  228. if (y0<z0) then
  229. i1=0; j1=0; k1=1; i2=0; j2=1; k2=1; -- Z Y X order
  230. elseif (x0<z0) then
  231. i1=0; j1=1; k1=0; i2=0; j2=1; k2=1; -- Y Z X order
  232. else
  233. i1=0; j1=1; k1=0; i2=1; j2=1; k2=0; -- Y X Z order
  234. end
  235. end
  236.  
  237. -- A step of (1,0,0) in (i,j,k) means a step of (1-c,-c,-c) in (x,y,z),
  238. -- a step of (0,1,0) in (i,j,k) means a step of (-c,1-c,-c) in (x,y,z), and
  239. -- a step of (0,0,1) in (i,j,k) means a step of (-c,-c,1-c) in (x,y,z), where
  240. -- c = 1/6.
  241.  
  242. local x1 = x0 - i1 + G3; -- Offsets for second corner in (x,y,z) coords
  243. local y1 = y0 - j1 + G3;
  244. local z1 = z0 - k1 + G3;
  245.  
  246. local x2 = x0 - i2 + 2.0*G3; -- Offsets for third corner in (x,y,z) coords
  247. local y2 = y0 - j2 + 2.0*G3;
  248. local z2 = z0 - k2 + 2.0*G3;
  249.  
  250. local x3 = x0 - 1.0 + 3.0*G3; -- Offsets for last corner in (x,y,z) coords
  251. local y3 = y0 - 1.0 + 3.0*G3;
  252. local z3 = z0 - 1.0 + 3.0*G3;
  253.  
  254. -- Work out the hashed gradient indices of the four simplex corners
  255. local ii = bit.band(i , 255)
  256. local jj = bit.band(j , 255)
  257. local kk = bit.band(k , 255)
  258.  
  259. local gi0 = perm[ii+perm[jj+perm[kk]]] % 12;
  260. local gi1 = perm[ii+i1+perm[jj+j1+perm[kk+k1]]] % 12;
  261. local gi2 = perm[ii+i2+perm[jj+j2+perm[kk+k2]]] % 12;
  262. local gi3 = perm[ii+1+perm[jj+1+perm[kk+1]]] % 12;
  263.  
  264. -- Calculate the contribution from the four corners
  265. local t0 = 0.5 - x0*x0 - y0*y0 - z0*z0;
  266.  
  267. if (t0<0) then
  268. n0 = 0.0;
  269. else
  270. t0 = t0*t0;
  271. n0 = t0 * t0 * Dot3D(Gradients3D[gi0], x0, y0, z0);
  272. end
  273.  
  274. local t1 = 0.5 - x1*x1 - y1*y1 - z1*z1;
  275.  
  276. if (t1<0) then
  277. n1 = 0.0;
  278. else
  279. t1 = t1*t1;
  280. n1 = t1 * t1 * Dot3D(Gradients3D[gi1], x1, y1, z1);
  281. end
  282.  
  283. local t2 = 0.5 - x2*x2 - y2*y2 - z2*z2;
  284.  
  285. if (t2<0) then
  286. n2 = 0.0;
  287. else
  288. t2 = t2*t2;
  289. n2 = t2 * t2 * Dot3D(Gradients3D[gi2], x2, y2, z2);
  290. end
  291.  
  292. local t3 = 0.5 - x3*x3 - y3*y3 - z3*z3;
  293.  
  294. if (t3<0) then
  295. n3 = 0.0;
  296. else
  297. t3 = t3*t3;
  298. n3 = t3 * t3 * Dot3D(Gradients3D[gi3], x3, y3, z3);
  299. end
  300.  
  301.  
  302. -- Add contributions from each corner to get the final noise value.
  303. -- The result is scaled to stay just inside [-1,1]
  304. local retval = 32.0*(n0 + n1 + n2 + n3)
  305.  
  306. if simplex.internalCache then
  307. if not Prev3D[xin] then Prev3D[xin] = {} end
  308. if not Prev3D[xin][yin] then Prev3D[xin][yin] = {} end
  309. Prev3D[xin][yin][zin] = retval
  310. end
  311.  
  312. return retval;
  313. end
  314.  
  315. local Prev4D = {}
  316.  
  317. -- 4D simplex noise
  318. function simplex.Noise4D(x,y,z,w)
  319.  
  320. if simplex.internalCache and Prev4D[x] and Prev4D[x][y] and Prev4D[x][y][z] and Prev4D[x][y][z][w] then return Prev4D[x][y][z][w] end
  321.  
  322. -- The skewing and unskewing factors are hairy again for the 4D case
  323. local F4 = (math.sqrt(5.0)-1.0)/4.0;
  324. local G4 = (5.0-math.sqrt(5.0))/20.0;
  325. local n0, n1, n2, n3, n4; -- Noise contributions from the five corners
  326. -- Skew the (x,y,z,w) space to determine which cell of 24 simplices we're in
  327. local s = (x + y + z + w) * F4; -- Factor for 4D skewing
  328. local i = math.floor(x + s);
  329. local j = math.floor(y + s);
  330. local k = math.floor(z + s);
  331. local l = math.floor(w + s);
  332. local t = (i + j + k + l) * G4; -- Factor for 4D unskewing
  333. local X0 = i - t; -- Unskew the cell origin back to (x,y,z,w) space
  334. local Y0 = j - t;
  335. local Z0 = k - t;
  336. local W0 = l - t;
  337. local x0 = x - X0; -- The x,y,z,w distances from the cell origin
  338. local y0 = y - Y0;
  339. local z0 = z - Z0;
  340. local w0 = w - W0;
  341. -- For the 4D case, the simplex is a 4D shape I won't even try to describe.
  342. -- To find out which of the 24 possible simplices we're in, we need to
  343. -- determine the magnitude ordering of x0, y0, z0 and w0.
  344. -- The method below is a good way of finding the ordering of x,y,z,w and
  345. -- then find the correct traversal order for the simplex were in.
  346. -- First, six pair-wise comparisons are performed between each possible pair
  347. -- of the four coordinates, and the results are used to add up binary bits
  348. -- for an localeger index.
  349. local c1 = (x0 > y0) and 32 or 1;
  350. local c2 = (x0 > z0) and 16 or 1;
  351. local c3 = (y0 > z0) and 8 or 1;
  352. local c4 = (x0 > w0) and 4 or 1;
  353. local c5 = (y0 > w0) and 2 or 1;
  354. local c6 = (z0 > w0) and 1 or 1;
  355. local c = c1 + c2 + c3 + c4 + c5 + c6;
  356. local i1, j1, k1, l1; -- The localeger offsets for the second simplex corner
  357. local i2, j2, k2, l2; -- The localeger offsets for the third simplex corner
  358. local i3, j3, k3, l3; -- The localeger offsets for the fourth simplex corner
  359.  
  360. -- sim[c] is a 4-vector with the numbers 0, 1, 2 and 3 in some order.
  361. -- Many values of c will never occur, since e.g. x>y>z>w makes x<z, y<w and x<w
  362. -- impossible. Only the 24 indices which have non-zero entries make any sense.
  363. -- We use a thresholding to set the coordinates in turn from the largest magnitude.
  364. -- The number 3 in the "sim" array is at the position of the largest coordinate.
  365.  
  366. i1 = sim[c][1]>=3 and 1 or 0;
  367. j1 = sim[c][2]>=3 and 1 or 0;
  368. k1 = sim[c][3]>=3 and 1 or 0;
  369. l1 = sim[c][4]>=3 and 1 or 0;
  370. -- The number 2 in the "sim" array is at the second largest coordinate.
  371. i2 = sim[c][1]>=2 and 1 or 0;
  372. j2 = sim[c][2]>=2 and 1 or 0;
  373. k2 = sim[c][3]>=2 and 1 or 0;
  374. l2 = sim[c][4]>=2 and 1 or 0;
  375. -- The number 1 in the "sim" array is at the second smallest coordinate.
  376. i3 = sim[c][1]>=1 and 1 or 0;
  377. j3 = sim[c][2]>=1 and 1 or 0;
  378. k3 = sim[c][3]>=1 and 1 or 0;
  379. l3 = sim[c][4]>=1 and 1 or 0;
  380. -- The fifth corner has all coordinate offsets = 1, so no need to look that up.
  381. local x1 = x0 - i1 + G4; -- Offsets for second corner in (x,y,z,w) coords
  382. local y1 = y0 - j1 + G4;
  383. local z1 = z0 - k1 + G4;
  384. local w1 = w0 - l1 + G4;
  385. local x2 = x0 - i2 + 2.0*G4; -- Offsets for third corner in (x,y,z,w) coords
  386. local y2 = y0 - j2 + 2.0*G4;
  387. local z2 = z0 - k2 + 2.0*G4;
  388. local w2 = w0 - l2 + 2.0*G4;
  389. local x3 = x0 - i3 + 3.0*G4; -- Offsets for fourth corner in (x,y,z,w) coords
  390. local y3 = y0 - j3 + 3.0*G4;
  391. local z3 = z0 - k3 + 3.0*G4;
  392. local w3 = w0 - l3 + 3.0*G4;
  393. local x4 = x0 - 1.0 + 4.0*G4; -- Offsets for last corner in (x,y,z,w) coords
  394. local y4 = y0 - 1.0 + 4.0*G4;
  395. local z4 = z0 - 1.0 + 4.0*G4;
  396. local w4 = w0 - 1.0 + 4.0*G4;
  397.  
  398. -- Work out the hashed gradient indices of the five simplex corners
  399. local ii = bit.band(i , 255)
  400. local jj = bit.band(j , 255)
  401. local kk = bit.band(k , 255)
  402. local ll = bit.band(l , 255)
  403. local gi0 = perm[ii+perm[jj+perm[kk+perm[ll]]]] % 32;
  404. local gi1 = perm[ii+i1+perm[jj+j1+perm[kk+k1+perm[ll+l1]]]] % 32;
  405. local gi2 = perm[ii+i2+perm[jj+j2+perm[kk+k2+perm[ll+l2]]]] % 32;
  406. local gi3 = perm[ii+i3+perm[jj+j3+perm[kk+k3+perm[ll+l3]]]] % 32;
  407. local gi4 = perm[ii+1+perm[jj+1+perm[kk+1+perm[ll+1]]]] % 32;
  408.  
  409.  
  410. -- Calculate the contribution from the five corners
  411. local t0 = 0.5 - x0*x0 - y0*y0 - z0*z0 - w0*w0;
  412. if (t0<0) then
  413. n0 = 0.0;
  414. else
  415. t0 = t0*t0;
  416. n0 = t0 * t0 * Dot4D(Gradients4D[gi0], x0, y0, z0, w0);
  417. end
  418.  
  419. local t1 = 0.5 - x1*x1 - y1*y1 - z1*z1 - w1*w1;
  420. if (t1<0) then
  421. n1 = 0.0;
  422. else
  423. t1 = t1*t1;
  424. n1 = t1 * t1 * Dot4D(Gradients4D[gi1], x1, y1, z1, w1);
  425. end
  426.  
  427. local t2 = 0.5 - x2*x2 - y2*y2 - z2*z2 - w2*w2;
  428. if (t2<0) then
  429. n2 = 0.0;
  430. else
  431. t2 = t2*t2;
  432. n2 = t2 * t2 * Dot4D(Gradients4D[gi2], x2, y2, z2, w2);
  433. end
  434.  
  435. local t3 = 0.5 - x3*x3 - y3*y3 - z3*z3 - w3*w3;
  436. if (t3<0) then
  437. n3 = 0.0;
  438. else
  439. t3 = t3*t3;
  440. n3 = t3 * t3 * Dot4D(Gradients4D[gi3], x3, y3, z3, w3);
  441. end
  442.  
  443. local t4 = 0.5 - x4*x4 - y4*y4 - z4*z4 - w4*w4;
  444. if (t4<0) then
  445. n4 = 0.0;
  446. else
  447. t4 = t4*t4;
  448. n4 = t4 * t4 * Dot4D(Gradients4D[gi4], x4, y4, z4, w4);
  449. end
  450.  
  451. -- Sum up and scale the result to cover the range [-1,1]
  452.  
  453. local retval = 27.0 * (n0 + n1 + n2 + n3 + n4)
  454.  
  455. if simplex.internalCache then
  456. if not Prev4D[x] then Prev4D[x] = {} end
  457. if not Prev4D[x][y] then Prev4D[x][y] = {} end
  458. if not Prev4D[x][y][z] then Prev4D[x][y][z] = {} end
  459. Prev4D[x][y][z][w] = retval
  460. end
  461.  
  462. return retval;
  463.  
  464.  
  465. end
  466.  
  467. local e = 2.71828182845904523536
  468.  
  469. local PrevBlur2D = {}
  470.  
  471. function simplex.GBlur2D(x,y,stdDev)
  472. if simplex.internalCache and PrevBlur2D[x] and PrevBlur2D[x][y] and PrevBlur2D[x][y][stdDev] then return PrevBlur2D[x][y][stdDev] end
  473. local pwr = ((x^2+y^2)/(2*(stdDev^2)))*-1
  474. local ret = (1/(2*math.pi*(stdDev^2)))*(e^pwr)
  475.  
  476. if simplex.internalCache then
  477. if not PrevBlur2D[x] then PrevBlur2D[x] = {} end
  478. if not PrevBlur2D[x][y] then PrevBlur2D[x][y] = {} end
  479. PrevBlur2D[x][y][stdDev] = ret
  480. end
  481. return ret
  482. end
  483.  
  484. local PrevBlur1D = {}
  485.  
  486. function simplex.GBlur1D(x,stdDev)
  487. if simplex.internalCache and PrevBlur1D[x] and PrevBlur1D[x][stdDev] then return PrevBlur1D[x][stdDev] end
  488. local pwr = (x^2/(2*stdDev^2))*-1
  489. local ret = (1/(math.sqrt(2*math.pi)*stdDev))*(e^pwr)
  490.  
  491. if simplex.internalCache then
  492. if not PrevBlur1D[x] then PrevBlur1D[x] = {} end
  493. PrevBlur1D[x][stdDev] = ret
  494. end
  495. return ret
  496. end
  497.  
  498. function simplex.FractalSum(func, iter, ...)
  499. local ret = func(...)
  500. for i=1,iter do
  501. local power = 2^iter
  502. local s = power/i
  503.  
  504. local scaled = {}
  505. for elem in ipairs({...}) do
  506. table.insert(scaled, elem*s)
  507. end
  508. ret = ret + (i/power)*(func(unpack(scaled)))
  509. end
  510. return ret
  511. end
  512.  
  513. function simplex.FractalSumAbs(func, iter, ...)
  514. local ret = math.abs(func(...))
  515. for i=1,iter do
  516. local power = 2^iter
  517. local s = power/i
  518.  
  519. local scaled = {}
  520. for elem in ipairs({...}) do
  521. table.insert(scaled, elem*s)
  522. end
  523. ret = ret + (i/power)*(math.abs(func(unpack(scaled))))
  524. end
  525. return ret
  526. end
  527.  
  528. function simplex.Turbulence(func, direction, iter, ...)
  529. local ret = math.abs(func(...))
  530. for i=1,iter do
  531. local power = 2^iter
  532. local s = power/i
  533.  
  534. local scaled = {}
  535. for elem in ipairs({...}) do
  536. table.insert(scaled, elem*s)
  537. end
  538. ret = ret + (i/power)*(math.abs(func(unpack(scaled))))
  539. end
  540. local args = {...}
  541. local dir_component = args[direction+1]
  542. return math.sin(dir_component+ret)
  543. end
  544.  
  545. return simplex
  546.  
  547.  
  548.  
  549.  
  550.  
  551.  
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!