Show Posts

This section allows you to view all posts made by this member. Note that you can only see posts made in areas you currently have access to.


Messages - Phlashlite

Pages: [1] 2 3 4
1
Programs / Re: Putting it together, Rolling Clouds
« on: February 28, 2022, 01:02:56 am »
Quote from: johnno56 on February 27, 2022, 02:52:16 pm
Cool... Graveyard and some creepy music... hey...  Nicely done!

Thanks!... I'm still working on it though.  I have the speed turned up in order to see the cloud progression.  If you turn it down to something approching realistic, you can afford to turn up the iteration setting and get some really detailed clouds.  This thing has so many knobs to turn, that I could mess with it all night!... I haven't even got to adding the alpha channel and colors, or the 3rd noise dimension.

@bplus Here is the latest iteration.  I think its better. :)

Code: QB64: [Select]
  1. _TITLE "Rolling Clouds 1.0"
  2.  
  3. ' Ported to QB64 by: Phlashlite, February 20, 2022
  4. '
  5. '          Resource: Simplex noise demystified
  6. '            Author: Stefan Gustavson, Link”ping University, Sweden (stegu@itn.liu.se), 2005-03-22
  7. '               URL: https://weber.itn.liu.se/~stegu/simplexnoise/simplexnoise.pdf
  8. '
  9. '          Resource: Working with Simplex Noise
  10. '            Author: Christian Maher
  11. '               URL: https://cmaher.github.io/posts/working-with-simplex-noise/
  12. '
  13. '          Resource: FLRMAP - simple floormapper with diagram and explanation.
  14. '         Developer: Toshi Horie March 2001
  15. '          Based on: Floormapper Ecliptorial and Qasir's constant-z optimization explanation.
  16. '
  17. '
  18. ' Simplex noise is a method for constructing an n-dimensional noise function comparable to
  19. ' Perlin noise ("classic" noise) but with fewer directional artifacts and, in higher dimensions, a lower computational overhead. Ken Perlin designed the algorithm in 2001[1] to address the limitations of his classic noise function, especially in higher dimensions.
  20. ' The advantages of simplex noise over Perlin noise:
  21. '
  22. ' - Simplex noise has a lower computational complexity and requires fewer multiplications.
  23. ' - Simplex noise scales to higher dimensions (4D, 5D and up) with much less computational
  24. '   cost, the complexity is for dimensions instead of the of classic Noise.
  25. ' - Simplex noise has no noticeable directional artifacts.
  26. ' - Simplex noise has a well-defined and continuous gradient everywhere that can be computed
  27. '   quite cheaply.
  28. ' - Simplex noise is easy to implement in hardware
  29. '
  30. ' ~Wikipedia
  31. ' https://en.wikipedia.org/wiki/Simplex_noise#:~:text=Simplex%20noise%20is%20a%20method,dimensions%2C%20a%20lower%20computational%20overhead.
  32.  
  33.  
  34. DEFDBL A-Z
  35.  
  36. '==============================================================================
  37.  
  38. g3: 'gradient
  39. DATA 1,1,0
  40. DATA -1,1,0
  41. DATA 1,-1,0
  42. DATA -1,-1,0
  43. DATA 1,0,1
  44. DATA -1,0,1
  45. DATA 1,0,-1
  46. DATA -1,0,-1
  47. DATA 0,1,1
  48. DATA 0,-1,1
  49. DATA 0,1,-1
  50. DATA 0,-1,-1
  51.  
  52. TYPE TriBit 'data structure to hold gradient data
  53.     x AS INTEGER
  54.     y AS INTEGER
  55.     z AS INTEGER
  57. DIM SHARED grad3(12) AS TriBit
  58.  
  60. FOR g& = 0 TO 11
  61.     READ grad3(g&).x
  62.     READ grad3(g&).y
  63.     READ grad3(g&).z
  64. NEXT g&
  65.  
  66. '______________________________________________________________________________
  67.  
  68. p: 'permutation table
  69. DATA 151,160,137,091,090,015,131,013,201,095,096,053,194,233,007,225,140,036,103,030
  70. DATA 069,142,008,099,037,240,021,010,023,190,006,148,247,120,234,075,000,026,197,062
  71. DATA 094,252,219,203,117,035,011,032,057,177,033,088,237,149,056,087,174,020,125,136
  72. DATA 171,168,068,175,074,165,071,134,139,048,027,166,077,146,158,231,083,111,229,122
  73. DATA 060,211,133,230,220,105,092,041,055,046,245,040,244,102,143,054,065,025,063,161
  74. DATA 001,216,080,073,209,076,132,187,208,089,018,169,200,196,135,130,116,188,159,086
  75. DATA 164,100,109,198,173,186,003,064,052,217,226,250,124,123,005,202,038,147,118,126
  76. DATA 255,082,085,212,207,206,059,227,047,016,058,017,182,189,028,042,223,183,170,213
  77. DATA 119,248,152,002,044,154,163,070,221,153,101,155,167,043,172,009,129,022,039,253
  78. DATA 019,098,108,110,079,113,224,232,178,185,112,104,218,246,097,228,251,034,242,193
  79. DATA 238,210,144,012,191,179,162,241,081,051,145,235,249,014,239,107,049,192,214,031
  80. DATA 181,199,106,157,184,084,204,176,115,121,050,045,127,004,150,254,138,236,205,093
  81. DATA 222,114,067,029,024,072,243,141,128,195,078,066,215,061,156,180
  82. DATA 151,160,137,091,090,015,131,013,201,095,096,053,194,233,007,225,140,036,103,030
  83. DATA 069,142,008,099,037,240,021,010,023,190,006,148,247,120,234,075,000,026,197,062
  84. DATA 094,252,219,203,117,035,011,032,057,177,033,088,237,149,056,087,174,020,125,136
  85. DATA 171,168,068,175,074,165,071,134,139,048,027,166,077,146,158,231,083,111,229,122
  86. DATA 060,211,133,230,220,105,092,041,055,046,245,040,244,102,143,054,065,025,063,161
  87. DATA 001,216,080,073,209,076,132,187,208,089,018,169,200,196,135,130,116,188,159,086
  88. DATA 164,100,109,198,173,186,003,064,052,217,226,250,124,123,005,202,038,147,118,126
  89. DATA 255,082,085,212,207,206,059,227,047,016,058,017,182,189,028,042,223,183,170,213
  90. DATA 119,248,152,002,044,154,163,070,221,153,101,155,167,043,172,009,129,022,039,253
  91. DATA 019,098,108,110,079,113,224,232,178,185,112,104,218,246,097,228,251,034,242,193
  92. DATA 238,210,144,012,191,179,162,241,081,051,145,235,249,014,239,107,049,192,214,031
  93. DATA 181,199,106,157,184,084,204,176,115,121,050,045,127,004,150,254,138,236,205,093
  94. DATA 222,114,067,029,024,072,243,141,128,195,078,066,215,061,156,180
  95.  
  96. 'To remove the need for index wrapping, double the permutation table length
  98. DIM SHARED perm(512) AS INTEGER
  99.  
  101. FOR i& = 0 TO 511
  102.     READ p(i&)
  103.     perm(i&) = p(i&) AND 255
  105.  
  106. '==============================================================================
  107.  
  108. CONST WDTH = 800
  109. CONST HGHT = 600
  110. CONST COLORMODE = 32
  111.  
  112. '2D simplex noise. From: "Simplex noise demystified"___________________________
  113. CONST F2 = .5 * (SQR(3) - 1)
  114. CONST G2 = (3 - SQR(3)) / 6
  115. CONST G2x2 = G2 * 2
  116.  
  117. 'Settings for noise and brownian motion. From: "Working with Simplex Noise"____
  118. CONST SCALE = .009 '       Noise SCALE
  119. CONST ITERATIONS = 7 '     Affects the noise layers (octaves)
  120. CONST PERSISTENCE = 0.5 '  Amount each octave contributes to the noise structure
  121. CONST LOW = 25 '           Low end of point luminance
  122. CONST HIGH = 167 '         High end of luminance
  123. CONST SPEED = 1 '        Cloud (scroll) speed
  124.  
  125. 'From: FLRMAP__________________________________________________________________
  126. CONST H = 6 '              Height of PoV @ the plane of the "Y" axis
  127. CONST DPTH = .618 * HGHT ' Depth of the "Z" axis
  128. CONST HLV = -499 '         Horizontal Line between sky and GP
  129. CONST GP = 0 '             Ground Plane
  130.  
  131. DIM lut(HLV TO GP)
  132. DIM HF(HLV TO GP)
  133. DIM D(HLV TO GP)
  134. DIM Texture&(WDTH, HGHT)
  135.  
  136. HFV = -(WDTH * .7)
  137. FOR y& = HLV TO GP
  138.     lut(y&) = H / (H - y&)
  139.     HF(y&) = HFV * lut(y&)
  140.     D(y&) = DPTH * lut(y&)
  142. HL = 450
  143. vofs = 250
  144. '==============================================================================
  145. SCREEN _NEWIMAGE(WDTH, HGHT, COLORMODE)
  146.  
  148.     vofs = vofs + SPEED
  149.     FOR y& = HLV TO GP
  150.  
  151.         v = vofs + D(y&)
  152.         u = HF(y&)
  153.         du = lut(y&)
  154.  
  155.         FOR x& = 0 TO WDTH - 1
  156.  
  157.             'Load the texture array with noise
  158.             gs& = INT(map(sumOcatave(ITERATIONS, u, v + HL, PERSISTENCE, SCALE), -1, 1, LOW, HIGH))
  159.  
  160.             'Grayscale pallette
  161.             c& = _RGB(gs&, gs&, gs&)
  162.  
  163.             'Draw the screen
  164.             PSET (x&, y& + HL), c&
  165.  
  166.             u = u + du
  167.         NEXT
  168.     NEXT
  169.     _DISPLAY
  170.     '_LIMIT 30
  172. '==============================================================================
  173.  
  174.  
  175. FUNCTION noise2D (xin, yin) 'From: Simplex noise demystified___________________
  176.  
  177.     '' Skew the input space to determine which simplex cell we're in
  178.     s = (xin + yin) * F2
  179.     i& = INT(xin + s)
  180.     j& = INT(yin + s)
  181.  
  182.     t = (i& + j&) * G2
  183.  
  184.     ' Unskew the cell origin back to (x,y) space
  185.     BX0 = i& - t
  186.     BY0 = j& - t
  187.  
  188.     ' The x,y distances from the cell origin
  189.     x0 = xin - BX0
  190.     y0 = yin - BY0
  191.  
  192.  
  193.     ' For the 2D case, the simplex shape is an equilateral triangle
  194.     ' Determine which simplex we are in.
  195.     ' Offsets for second (middle) corner of simplex in (i,j) coords
  196.     IF x0 > y0 THEN
  197.         i1& = 1: j1& = 0
  198.     ELSE
  199.         i1& = 0: j1& = 1
  200.     END IF
  201.  
  202.  
  203.     ' A step of (1,0) in (i,j) means a step of (1-c,-c) in (x,y), and
  204.     ' a step of (0,1) in (i,j) means a step of (-c,1-c) in (x,y), where
  205.     ' c = (3-sqrt(3))/6 which is G2
  206.     x1 = x0 - i1& + G2
  207.     y1 = y0 - j1& + G2
  208.  
  209.     ' Offsets for last corner in (x,y) unskewed coords
  210.     x2 = x0 - 1 + G2x2
  211.     y2 = y0 - 1 + G2x2
  212.  
  213.     ' Work out the hashed gradient indices of the three simplex corners
  214.     ii& = i& AND 255
  215.     jj& = j& AND 255
  216.     gi0& = perm(ii& + perm(jj&)) MOD 12
  217.     gi1& = perm(ii& + i1& + perm(jj& + j1&)) MOD 12
  218.     gi2& = perm(ii& + 1 + perm(jj& + 1)) MOD 12
  219.  
  220.  
  221.     ' Calculate the contribution from the three corners
  222.  
  223.     ' First corner
  224.     t0 = .5 - x0 * x0 - y0 * y0
  225.     IF t0 < 0 THEN
  226.         n0 = 0
  227.     ELSE
  228.         t0 = t0 * t0
  229.         n0 = t0 * t0 * DotP2(gi0&, x0, y0)
  230.     END IF
  231.  
  232.     ' Second corner
  233.     t1 = .5 - x1 * x1 - y1 * y1
  234.     IF t1 < 0 THEN
  235.         n1 = 0
  236.     ELSE
  237.         t1 = t1 * t1
  238.         n1 = t1 * t1 * DotP2(gi1&, x1, y1)
  239.     END IF
  240.  
  241.     ' Third corner
  242.     t2 = .5 - x2 * x2 - y2 * y2
  243.     IF t2 < 0 THEN
  244.         n2 = 0
  245.     ELSE
  246.         t2 = t2 * t2
  247.         n2 = t2 * t2 * DotP2(gi2&, x2, y2)
  248.     END IF
  249.  
  250.  
  251.     ' Add contributions from each corner to get the final noise value.
  252.     ' The result is scaled to return values in the interval [-1,1].
  253.     noise2D = 70 * (n0 + n1 + n2)
  254.  
  256.  
  257. ' From: "Working with Simplex Noise"___________________________________________
  258. FUNCTION sumOcatave (iterations, x, y, persistence, scale)
  259.  
  260.     DIM maxAmp
  261.     DIM amp
  262.     DIM freq
  263.     DIM noise
  264.  
  265.     noise = 0
  266.     maxAmp = 0
  267.     amp = 1.1
  268.     freq = scale
  269.  
  270.     ' Add successively smaller, higher-frequency terms
  271.     FOR i& = 0 TO iterations
  272.         noise = (noise2D(x * freq, y * freq) * amp) + noise
  273.         maxAmp = maxAmp + amp
  274.         amp = amp * persistence
  275.         freq = freq * 2
  276.     NEXT
  277.  
  278.     sumOcatave = noise
  280.  
  281. '2D DotProduct. From: Simplex noise demystified________________________________
  282. FUNCTION DotP2 (g&, x, y)
  283.     DotP2 = grad3(g&).x * x + grad3(g&).y * y
  285.  
  286. ' Map function I found or translated from somewhere.___________________________
  287. ' The Coding Train" guy on youtube, where I translated the rain code from
  288. ' explained it in one of his videos.
  289. FUNCTION map (value, minRange, maxRange, newMinRange, newMaxRange)
  290.     map = ((value - minRange) / (maxRange - minRange)) * (newMaxRange - newMinRange) + newMinRange
  292.  
  293.  

2
Programs / Re: Putting it together, Rolling Clouds
« on: February 27, 2022, 02:11:08 pm »
Quote from: bplus on February 27, 2022, 12:02:50 pm
I wonder if you could do pixels at front end and multi pixels groups towards back to avoid blocks of one shade tiles eg use 1 pixel to represent groups, larger and larger going towards horizon line. Just a thought, probably too much more calcs.

I had to look really hard at Toshi's code to figure out roughly how it worked.  I think it works exactly opposite of what you are proposing. LOL... but try changing the "H" CONST to 20.

Anyway, it's still a work in progress. :)

3
Programs / Re: Domain Coloring
« on: February 27, 2022, 04:20:52 am »
Very nice!

4
Programs / Re: Ray Trace a translation from SpecBAS
« on: February 27, 2022, 04:19:38 am »
AWESOME!

5
Programs / Putting it together, Rolling Clouds
« on: February 27, 2022, 04:03:16 am »
Demo of some Simplex noise generated clouds on a rolling sky.  Put together with lots of other developers' code

@bplus , It has some issues... but it is starting to come together.

~Phlashlite

Code: QB64: [Select]
  1.  
  2. _TITLE "Rolling Clouds 1.0"
  3. ' Ported to QB64 by: Phlashlite, February 20, 2022
  4. '
  5. '          Resource: Simplex noise demystified
  6. '            Author: Stefan Gustavson, Link”ping University, Sweden (stegu@itn.liu.se), 2005-03-22
  7. '               URL: https://weber.itn.liu.se/~stegu/simplexnoise/simplexnoise.pdf
  8. '
  9. '          Resource: Working with Simplex Noise
  10. '            Author: Christian Maher
  11. '               URL: https://cmaher.github.io/posts/working-with-simplex-noise/
  12. '
  13. '          Resource: FLRMAP - simple floormapper with diagram and explanation.
  14. '         Developer: Toshi Horie March 2001
  15. '          Based on: Floormapper Ecliptorial and Qasir's constant-z optimization explanation.
  16. '
  17. '
  18. ' Simplex noise is a method for constructing an n-dimensional noise function comparable to
  19. ' Perlin noise ("classic" noise) but with fewer directional artifacts and, in higher dimensions, a lower computational overhead. Ken Perlin designed the algorithm in 2001[1] to address the limitations of his classic noise function, especially in higher dimensions.
  20. ' The advantages of simplex noise over Perlin noise:
  21. '
  22. ' - Simplex noise has a lower computational complexity and requires fewer multiplications.
  23. ' - Simplex noise scales to higher dimensions (4D, 5D and up) with much less computational
  24. '   cost, the complexity is for dimensions instead of the of classic Noise.
  25. ' - Simplex noise has no noticeable directional artifacts.
  26. ' - Simplex noise has a well-defined and continuous gradient everywhere that can be computed
  27. '   quite cheaply.
  28. ' - Simplex noise is easy to implement in hardware
  29. '
  30. ' ~Wikipedia
  31. ' https://en.wikipedia.org/wiki/Simplex_noise#:~:text=Simplex%20noise%20is%20a%20method,dimensions%2C%20a%20lower%20computational%20overhead.
  32.  
  33.  
  34. DEFDBL A-Z
  35.  
  36. '==============================================================================
  37.  
  38. g3: 'gradient
  39. DATA 1,1,0
  40. DATA -1,1,0
  41. DATA 1,-1,0
  42. DATA -1,-1,0
  43. DATA 1,0,1
  44. DATA -1,0,1
  45. DATA 1,0,-1
  46. DATA -1,0,-1
  47. DATA 0,1,1
  48. DATA 0,-1,1
  49. DATA 0,1,-1
  50. DATA 0,-1,-1
  51.  
  52. TYPE TriBit 'data structure to hold gradient data
  53.     x AS INTEGER
  54.     y AS INTEGER
  55.     z AS INTEGER
  57. DIM SHARED grad3(12) AS TriBit
  58.  
  60. FOR g& = 0 TO 11
  61.     READ grad3(g&).x
  62.     READ grad3(g&).y
  63.     READ grad3(g&).z
  64. NEXT g&
  65.  
  66. '______________________________________________________________________________
  67.  
  68. p: 'permutation table
  69. DATA 151,160,137,091,090,015,131,013,201,095,096,053,194,233,007,225,140,036,103,030
  70. DATA 069,142,008,099,037,240,021,010,023,190,006,148,247,120,234,075,000,026,197,062
  71. DATA 094,252,219,203,117,035,011,032,057,177,033,088,237,149,056,087,174,020,125,136
  72. DATA 171,168,068,175,074,165,071,134,139,048,027,166,077,146,158,231,083,111,229,122
  73. DATA 060,211,133,230,220,105,092,041,055,046,245,040,244,102,143,054,065,025,063,161
  74. DATA 001,216,080,073,209,076,132,187,208,089,018,169,200,196,135,130,116,188,159,086
  75. DATA 164,100,109,198,173,186,003,064,052,217,226,250,124,123,005,202,038,147,118,126
  76. DATA 255,082,085,212,207,206,059,227,047,016,058,017,182,189,028,042,223,183,170,213
  77. DATA 119,248,152,002,044,154,163,070,221,153,101,155,167,043,172,009,129,022,039,253
  78. DATA 019,098,108,110,079,113,224,232,178,185,112,104,218,246,097,228,251,034,242,193
  79. DATA 238,210,144,012,191,179,162,241,081,051,145,235,249,014,239,107,049,192,214,031
  80. DATA 181,199,106,157,184,084,204,176,115,121,050,045,127,004,150,254,138,236,205,093
  81. DATA 222,114,067,029,024,072,243,141,128,195,078,066,215,061,156,180
  82. DATA 151,160,137,091,090,015,131,013,201,095,096,053,194,233,007,225,140,036,103,030
  83. DATA 069,142,008,099,037,240,021,010,023,190,006,148,247,120,234,075,000,026,197,062
  84. DATA 094,252,219,203,117,035,011,032,057,177,033,088,237,149,056,087,174,020,125,136
  85. DATA 171,168,068,175,074,165,071,134,139,048,027,166,077,146,158,231,083,111,229,122
  86. DATA 060,211,133,230,220,105,092,041,055,046,245,040,244,102,143,054,065,025,063,161
  87. DATA 001,216,080,073,209,076,132,187,208,089,018,169,200,196,135,130,116,188,159,086
  88. DATA 164,100,109,198,173,186,003,064,052,217,226,250,124,123,005,202,038,147,118,126
  89. DATA 255,082,085,212,207,206,059,227,047,016,058,017,182,189,028,042,223,183,170,213
  90. DATA 119,248,152,002,044,154,163,070,221,153,101,155,167,043,172,009,129,022,039,253
  91. DATA 019,098,108,110,079,113,224,232,178,185,112,104,218,246,097,228,251,034,242,193
  92. DATA 238,210,144,012,191,179,162,241,081,051,145,235,249,014,239,107,049,192,214,031
  93. DATA 181,199,106,157,184,084,204,176,115,121,050,045,127,004,150,254,138,236,205,093
  94. DATA 222,114,067,029,024,072,243,141,128,195,078,066,215,061,156,180
  95.  
  96. 'To remove the need for index wrapping, double the permutation table length
  98. DIM SHARED perm(512) AS INTEGER
  99.  
  101. FOR i& = 0 TO 511
  102.     READ p(i&)
  103.     perm(i&) = p(i&) AND 255
  105.  
  106. '==============================================================================
  107.  
  108. CONST WDTH = 800
  109. CONST HGHT = 600
  110. CONST COLORMODE = 32
  111.  
  112. 'From: FLRMAP__________________________________________________________________
  113. CONST H = 5 '       Height of PoV @ the plane of the "Y" axis
  114. CONST DPTH = WDTH ' Depth of the "Z" axis
  115. CONST HLV = -500 '  Horizontal Line between sky and GP
  116. CONST GP = -10 '    Ground Plane
  117.  
  118. '2D simplex noise. From: "Simplex noise demystified"___________________________
  119. CONST F2 = .5 * (SQR(3) - 1)
  120. CONST G2 = (3 - SQR(3)) / 6
  121. CONST G2x2 = G2 * 2
  122.  
  123. 'Settings for noise and brownian motion. From: "Working with Simplex Noise"____
  124. CONST SCALE = .02 '       Noise SCALE
  125. CONST ITERATIONS = 5 '    Affects the noise layers (octaves)
  126. CONST PERSISTENCE = 0.5 ' Amount each octave contributes to the noise structure
  127. CONST LOW = 0 '           Low end of point luminance
  128. CONST HIGH = 196 '        High end of luminance
  129. CONST SPEED = .20 '       Cloud (scroll) speed
  130.  
  131. DIM lut(HLV TO GP)
  132. DIM HF(HLV TO GP)
  133. DIM D(HLV TO GP)
  134. DIM Texture&(WDTH, HGHT)
  135.  
  136. HFV! = -(WDTH * .5)
  137. FOR y& = HLV TO GP
  138.     lut(y&) = H / (H - y&)
  139.     HF(y&) = HFV * lut(y&)
  140.     D(y&) = DPTH * lut(y&)
  142. HL = 500
  143.  
  144. '==============================================================================
  145. SCREEN _NEWIMAGE(WDTH, HGHT, COLORMODE)
  146.  
  148.     vofs = vofs + SPEED
  149.     FOR y& = HLV TO GP
  150.  
  151.         v = vofs + D(y&)
  152.         u = HF(y&)
  153.         du = lut(y&)
  154.  
  155.         FOR x& = 0 TO WDTH - 1
  156.  
  157.             'Load the texture array with noise
  158.             Texture&(u, v) = map(sumOcatave(ITERATIONS, u, v + HL, PERSISTENCE, SCALE), -1, 1, LOW, HIGH)
  159.  
  160.             'Grayscale pallette
  161.             c& = _RGB(Texture&(u, v), Texture&(u, v), Texture&(u, v))
  162.  
  163.             'Draw the screen
  164.             PSET (x&, y& + HL), c&
  165.  
  166.             u = u + du
  167.         NEXT
  168.     NEXT
  169.     _DISPLAY
  170.     _LIMIT 30
  172. '==============================================================================
  173.  
  174.  
  175. FUNCTION noise2D (xin, yin) 'From: Simplex noise demystified___________________
  176.  
  177.     '' Skew the input space to determine which simplex cell we're in
  178.     s = (xin + yin) * F2
  179.     i& = INT(xin + s)
  180.     j& = INT(yin + s)
  181.  
  182.     t = (i& + j&) * G2
  183.  
  184.     ' Unskew the cell origin back to (x,y) space
  185.     BX0 = i& - t
  186.     BY0 = j& - t
  187.  
  188.     ' The x,y distances from the cell origin
  189.     x0 = xin - BX0
  190.     y0 = yin - BY0
  191.  
  192.  
  193.     ' For the 2D case, the simplex shape is an equilateral triangle
  194.     ' Determine which simplex we are in.
  195.     ' Offsets for second (middle) corner of simplex in (i,j) coords
  196.     IF x0 > y0 THEN
  197.         i1& = 1: j1& = 0
  198.     ELSE
  199.         i1& = 0: j1& = 1
  200.     END IF
  201.  
  202.  
  203.     ' A step of (1,0) in (i,j) means a step of (1-c,-c) in (x,y), and
  204.     ' a step of (0,1) in (i,j) means a step of (-c,1-c) in (x,y), where
  205.     ' c = (3-sqrt(3))/6 which is G2
  206.     x1 = x0 - i1& + G2
  207.     y1 = y0 - j1& + G2
  208.  
  209.     ' Offsets for last corner in (x,y) unskewed coords
  210.     x2 = x0 - 1 + G2x2
  211.     y2 = y0 - 1 + G2x2
  212.  
  213.     ' Work out the hashed gradient indices of the three simplex corners
  214.     ii& = i& AND 255
  215.     jj& = j& AND 255
  216.     gi0& = perm(ii& + perm(jj&)) MOD 12
  217.     gi1& = perm(ii& + i1& + perm(jj& + j1&)) MOD 12
  218.     gi2& = perm(ii& + 1 + perm(jj& + 1)) MOD 12
  219.  
  220.  
  221.     ' Calculate the contribution from the three corners
  222.  
  223.     ' First corner
  224.     t0 = .5 - x0 * x0 - y0 * y0
  225.     IF t0 < 0 THEN
  226.         n0 = 0
  227.     ELSE
  228.         t0 = t0 * t0
  229.         n0 = t0 * t0 * DotP2(gi0&, x0, y0)
  230.     END IF
  231.  
  232.     ' Second corner
  233.     t1 = .5 - x1 * x1 - y1 * y1
  234.     IF t1 < 0 THEN
  235.         n1 = 0
  236.     ELSE
  237.         t1 = t1 * t1
  238.         n1 = t1 * t1 * DotP2(gi1&, x1, y1)
  239.     END IF
  240.  
  241.     ' Third corner
  242.     t2 = .5 - x2 * x2 - y2 * y2
  243.     IF t2 < 0 THEN
  244.         n2 = 0
  245.     ELSE
  246.         t2 = t2 * t2
  247.         n2 = t2 * t2 * DotP2(gi2&, x2, y2)
  248.     END IF
  249.  
  250.  
  251.     ' Add contributions from each corner to get the final noise value.
  252.     ' The result is scaled to return values in the interval [-1,1].
  253.     noise2D = 70 * (n0 + n1 + n2)
  254.  
  256.  
  257. ' From: "Working with Simplex Noise"___________________________________________
  258. FUNCTION sumOcatave (iterations, x&, y&, persistence, scale)
  259.  
  260.     DIM maxAmp
  261.     DIM amp
  262.     DIM freq
  263.     DIM noise
  264.  
  265.     noise = 0
  266.     maxAmp = 0
  267.     amp = 1
  268.     freq = scale
  269.  
  270.     ' Add successively smaller, higher-frequency terms
  271.     FOR i& = 0 TO iterations
  272.         noise = (noise2D(x& * freq, y& * freq) * amp) + noise
  273.         maxAmp = maxAmp + amp
  274.         amp = amp * persistence
  275.         freq = freq * 2
  276.     NEXT
  277.  
  278.     sumOcatave = noise
  280.  
  281. '2D DotProduct. From: Simplex noise demystified________________________________
  282. FUNCTION DotP2 (g&, x, y)
  283.     DotP2 = grad3(g&).x * x + grad3(g&).y * y
  285.  
  286. ' Map function I found or translated from somewhere.___________________________
  287. ' The Coding Train" guy on youtube, where I translated the rain code from
  288. ' explained it in one of his videos.
  289. FUNCTION map (value, minRange, maxRange, newMinRange, newMaxRange)
  290.     map = ((value - minRange) / (maxRange - minRange)) * (newMaxRange - newMinRange) + newMinRange
  292.  
  293.  

6
Programs / Re: Simplex Noise Anyone?
« on: February 25, 2022, 06:49:16 pm »
Quote from: Pete on February 25, 2022, 06:25:24 pm
Are you sure that's not a Hunter Biden painting? Because it looks like a Hunter Biden Painting.

Pete

If graphics was my thing I'd have a thingectomy.

hahaha

7
Programs / Re: Simplex Noise Anyone?
« on: February 25, 2022, 06:47:52 pm »
Quote from: bplus on February 25, 2022, 02:30:25 pm
Ha! I was wondering if that inspired this.

Well was no work for me because I just translated from Yabasic to QB64 maybe added a mod or 2, _vince saved the day by getting it to move like clouds.

Yeah... it was pretty slick.

8
Programs / Re: Simplex Noise Anyone?
« on: February 25, 2022, 02:04:44 pm »
Quote from: bplus on February 25, 2022, 01:57:54 pm
Well good job so far. I looked at Simplex and said to myself, "Nah!" So you are braver than I. :)

Are you serious?  You look at the Perlin noise algorithm for the clouds you sent me???

I had to make a flow chart to decipher the program flow!!! LOL

And Toshi was no help either!  That guy's stuff is amazing btw.

9
Programs / Re: Simplex Noise Anyone?
« on: February 25, 2022, 01:50:20 pm »

Quote
Well I guess that is what it is supposed to look like but can you use it for anything? :)

Not too useful without the some extra iterations.... but I'll work on that next... along with the 3 and 4D parts.

It's supposedly faster than Perlin and without some of the visual artifacts.

10
Programs / 2D Simplex Noise - Cleaned of all java code and unnecessary comments.
« on: February 25, 2022, 01:45:58 pm »
Code: QB64: [Select]
  1. _TITLE "Simplex noise port"
  2.  
  3. ' ported to QB64 by: Phlashlite, February 20, 2022
  4. '    from the paper: Simplex noise demystified
  5. '            author: Stefan Gustavson, Link%u201Dping University, Sweden (stegu@itn.liu.se), 2005-03-22
  6. '               URL: https://weber.itn.liu.se/~stegu/simplexnoise/simplexnoise.pdf
  7. ' - Simplex noise has a lower computational complexity and requires fewer multiplications.
  8. ' - Simplex noise scales to higher dimensions (4D, 5D and up) with much less computational
  9. '   cost, the complexity is for dimensions instead of the of classic Noise.
  10. ' - Simplex noise has no noticeable directional artifacts.
  11. ' - Simplex noise has a well-defined and continuous gradient everywhere that can be computed
  12. '   quite cheaply.
  13. ' - Simplex noise is easy to implement in hardware
  14.  
  15.  
  16. SCREEN _NEWIMAGE(800, 600, 32)
  17.  
  18. DEFDBL A-Z
  19.  
  20. g3:
  21. DATA 1,1,0
  22. DATA -1,1,0
  23. DATA 1,-1,0
  24. DATA -1,-1,0
  25. DATA 1,0,1
  26. DATA -1,0,1
  27. DATA 1,0,-1
  28. DATA -1,0,-1
  29. DATA 0,1,1
  30. DATA 0,-1,1
  31. DATA 0,1,-1
  32. DATA 0,-1,-1
  33.  
  34. TYPE TriBit
  35.     x AS INTEGER
  36.     y AS INTEGER
  37.     z AS INTEGER
  39. DIM SHARED grad3(12) AS TriBit
  40.  
  42. FOR g% = 0 TO 11
  43.  
  44.     READ grad3(g%).x
  45.     READ grad3(g%).y
  46.     READ grad3(g%).z
  47.  
  48. NEXT g%
  49.  
  50. p:
  51. DATA 151,160,137,091,090,015,131,013,201,095
  52. DATA 096,053,194,233,007,225,140,036,103,030
  53. DATA 069,142,008,099,037,240,021,010,023,190
  54. DATA 006,148,247,120,234,075,000,026,197,062
  55. DATA 094,252,219,203,117,035,011,032,057,177
  56. DATA 033,088,237,149,056,087,174,020,125,136
  57. DATA 171,168,068,175,074,165,071,134,139,048
  58. DATA 027,166,077,146,158,231,083,111,229,122
  59. DATA 060,211,133,230,220,105,092,041,055,046
  60. DATA 245,040,244,102,143,054,065,025,063,161
  61. DATA 001,216,080,073,209,076,132,187,208,089
  62. DATA 018,169,200,196,135,130,116,188,159,086
  63. DATA 164,100,109,198,173,186,003,064,052,217
  64. DATA 226,250,124,123,005,202,038,147,118,126
  65. DATA 255,082,085,212,207,206,059,227,047,016
  66. DATA 058,017,182,189,028,042,223,183,170,213
  67. DATA 119,248,152,002,044,154,163,070,221,153
  68. DATA 101,155,167,043,172,009,129,022,039,253
  69. DATA 019,098,108,110,079,113,224,232,178,185
  70. DATA 112,104,218,246,097,228,251,034,242,193
  71. DATA 238,210,144,012,191,179,162,241,081,051
  72. DATA 145,235,249,014,239,107,049,192,214,031
  73. DATA 181,199,106,157,184,084,204,176,115,121
  74. DATA 050,045,127,004,150,254,138,236,205,093
  75. DATA 222,114,067,029,024,072,243,141,128,195
  76. DATA 078,066,215,061,156,180
  77. DATA 151,160,137,091,090,015,131,013,201,095
  78. DATA 096,053,194,233,007,225,140,036,103,030
  79. DATA 069,142,008,099,037,240,021,010,023,190
  80. DATA 006,148,247,120,234,075,000,026,197,062
  81. DATA 094,252,219,203,117,035,011,032,057,177
  82. DATA 033,088,237,149,056,087,174,020,125,136
  83. DATA 171,168,068,175,074,165,071,134,139,048
  84. DATA 027,166,077,146,158,231,083,111,229,122
  85. DATA 060,211,133,230,220,105,092,041,055,046
  86. DATA 245,040,244,102,143,054,065,025,063,161
  87. DATA 001,216,080,073,209,076,132,187,208,089
  88. DATA 018,169,200,196,135,130,116,188,159,086
  89. DATA 164,100,109,198,173,186,003,064,052,217
  90. DATA 226,250,124,123,005,202,038,147,118,126
  91. DATA 255,082,085,212,207,206,059,227,047,016
  92. DATA 058,017,182,189,028,042,223,183,170,213
  93. DATA 119,248,152,002,044,154,163,070,221,153
  94. DATA 101,155,167,043,172,009,129,022,039,253
  95. DATA 019,098,108,110,079,113,224,232,178,185
  96. DATA 112,104,218,246,097,228,251,034,242,193
  97. DATA 238,210,144,012,191,179,162,241,081,051
  98. DATA 145,235,249,014,239,107,049,192,214,031
  99. DATA 181,199,106,157,184,084,204,176,115,121
  100. DATA 050,045,127,004,150,254,138,236,205,093
  101. DATA 222,114,067,029,024,072,243,141,128,195
  102. DATA 078,066,215,061,156,180
  103.  
  104.  
  105. 'To remove the need for index wrapping, double the permutation table length
  107. DIM SHARED perm(512) AS INTEGER
  108.  
  110. FOR i% = 0 TO 511
  111.  
  112.     READ p(i%)
  113.     perm(i%) = p(i%) AND 255
  114.  
  116.  
  117.  
  118. '' 2D simplex noise************************************************************
  119.  
  120. CONST F2 = .5 * (SQR(3) - 1)
  121. CONST G2 = (3 - SQR(3)) / 6
  122.  
  123. scale = .007 'Adjustable
  124.  
  125. '------------------------------------------------------------------------------
  126. FOR x% = 0 TO 800
  127.     FOR y% = 0 TO 600
  128.  
  129.         'used to grayscale input
  130.         gs% = map!(noise2D(scale * x%, scale * y%), -1, 1, 0, 255)
  131.         c& = _RGB(gs%, gs%, gs%)
  132.         PSET (x%, y%), c&
  133.  
  134.  
  135.     NEXT
  137. '------------------------------------------------------------------------------
  138.  
  139. FUNCTION noise2D (xin, yin)
  140.     DIM n0, n1, n2
  141.  
  142.     '' Skew the input space to determine which simplex cell we're in
  143.     s = (xin + yin) * F2
  144.     i% = INT(xin + s)
  145.     j% = INT(yin + s)
  146.  
  147.  
  148.  
  149.     t = (i% + j%) * G2
  150.     ' Unskew the cell origin back to (x,y) space
  151.     BX0 = i% - t
  152.     BY0 = j% - t
  153.     ' The x,y distances from the cell origin
  154.     x0 = xin - BX0
  155.     y0 = yin - BY0
  156.  
  157.  
  158.     '' For the 2D case, the simplex shape is an equilateral triangle
  159.     '' Determine which simplex we are in.
  160.     ' Offsets for second (middle) corner of simplex in (i,j) coords
  161.     DIM AS INTEGER i1, j1
  162.     IF x0 > y0 THEN
  163.         i1% = 1: j1% = 0
  164.     ELSE
  165.         i1% = 0: j1% = 1
  166.     END IF
  167.  
  168.  
  169.     '' A step of (1,0) in (i,j) means a step of (1-c,-c) in (x,y), and
  170.     '' a step of (0,1) in (i,j) means a step of (-c,1-c) in (x,y), where
  171.     '' c = (3-sqrt(3))/6 which is G2
  172.     '
  173.     x1 = x0 - i1% + G2
  174.     y1 = y0 - j1% + G2
  175.     ' Offsets for last corner in (x,y) unskewed coords
  176.     x2 = x0 - 1 + 2 * G2
  177.     y2 = y0 - 1 + 2 * G2
  178.  
  179.  
  180.     '' Work out the hashed gradient indices of the three simplex corners
  181.     ii% = i% AND 255
  182.     jj% = j% AND 255
  183.     gi0% = perm(ii% + perm(jj%)) MOD 12
  184.     gi1% = perm(ii% + i1% + perm(jj% + j1%)) MOD 12
  185.     gi2% = perm(ii% + 1 + perm(jj% + 1)) MOD 12
  186.  
  187.  
  188.     '' Calculate the contribution from the three corners
  189.     '
  190.     t0 = .5 - x0 * x0 - y0 * y0
  191.     IF t0 < 0 THEN
  192.         n0 = 0
  193.     ELSE
  194.         t0 = t0 * t0
  195.         n0 = t0 * t0 * DotP2(gi0%, x0, y0)
  196.     END IF
  197.  
  198.  
  199.     t1 = .5 - x1 * x1 - y1 * y1
  200.     IF t1 < 0 THEN
  201.         n1 = 0
  202.     ELSE
  203.         t1 = t1 * t1
  204.         n1 = t1 * t1 * DotP2(gi1%, x1, y1)
  205.     END IF
  206.  
  207.  
  208.     t2 = .5 - x2 * x2 - y2 * y2
  209.     IF t2 < 0 THEN
  210.         n2 = 0
  211.     ELSE
  212.         t2 = t2 * t2
  213.         n2 = t2 * t2 * DotP2(gi2%, x2, y2)
  214.     END IF
  215.  
  216.  
  217.     '' Add contributions from each corner to get the final noise value.
  218.     '' The result is scaled to return values in the interval [-1,1].
  219.     '
  220.     noise2D = 70 * (n0 + n1 + n2)
  221.  
  223.  
  224.  
  225. ' This method is a *lot* faster than using (int)Math.floor(x)
  226. ' private static int fastfloor(double x) {
  227. ' return x>0 ? (int)x : (int)x-1;}
  228.  
  229. ' private static double dot(int g[], double x, double y) {
  230. ' return g[0]*x + g[1]*y; }
  231. FUNCTION DotP2 (g%, x, y)
  232.     DotP2 = grad3(g%).x * x + grad3(g%).y * y
  234.  
  235. ' Map function I found or translated from somewhere.
  236. ' The Coding Train" guy on youtube, where I translated the rain code from explained it in one of his videos.
  237. FUNCTION map! (value!, minRange!, maxRange!, newMinRange!, newMaxRange!)
  238.     map! = ((value! - minRange!) / (maxRange! - minRange!)) * (newMaxRange! - newMinRange!) + newMinRange!
  240.  
  241.  

11
Programs / Re: Simplex Noise Anyone?
« on: February 25, 2022, 01:30:40 pm »
Guess all I needed was a little motivation... and luck! :)

12
Programs / Re: Simplex Noise Anyone? SOLVED!
« on: February 25, 2022, 01:26:10 pm »
I found it!

Copy paste got me!!!!

This code works now!!!

Code: QB64: [Select]
  1.   '$DEBUG
  2. _TITLE "Simplex noise port"
  3.  
  4. ' ported to QB64 by: Phlashlite, February 20, 2022
  5. '    from the paper: Simplex noise demystified
  6. '            author: Stefan Gustavson, Link%u201Dping University, Sweden (stegu@itn.liu.se), 2005-03-22
  7. '               URL: https://weber.itn.liu.se/~stegu/simplexnoise/simplexnoise.pdf
  8. ' - Simplex noise has a lower computational complexity and requires fewer multiplications.
  9. ' - Simplex noise scales to higher dimensions (4D, 5D and up) with much less computational
  10. '   cost, the complexity is for dimensions instead of the of classic Noise.
  11. ' - Simplex noise has no noticeable directional artifacts.
  12. ' - Simplex noise has a well-defined and continuous gradient everywhere that can be computed
  13. '   quite cheaply.
  14. ' - Simplex noise is easy to implement in hardware
  15.  
  16.  
  17. SCREEN _NEWIMAGE(800, 600, 32)
  18.  
  19. DEFDBL A-Z
  20.  
  21. 'private static int grad3[][] = {{1,1,0},{-1,1,0},{1,-1,0},{-1,-1,0},{1,0,1},{-1,0,1},{1,0,-1},{-1,0,-1},{0,1,1},{0,-1,1},{0,1,-1},{0,-1,-1}};
  22. g3:
  23. DATA 1,1,0
  24. DATA -1,1,0
  25. DATA 1,-1,0
  26. DATA -1,-1,0
  27. DATA 1,0,1
  28. DATA -1,0,1
  29. DATA 1,0,-1
  30. DATA -1,0,-1
  31. DATA 0,1,1
  32. DATA 0,-1,1
  33. DATA 0,1,-1
  34. DATA 0,-1,-1
  35.  
  36. TYPE TriBit
  37.     x AS INTEGER
  38.     y AS INTEGER
  39.     z AS INTEGER
  41. DIM SHARED grad3(12) AS TriBit
  42.  
  44. FOR g% = 0 TO 11
  45.  
  46.     READ grad3(g%).x
  47.     READ grad3(g%).y
  48.     READ grad3(g%).z
  49.  
  50.     'PRINT grad3(g%).x, grad3(g%).y, grad3(g%).z
  51.  
  52. NEXT g%
  53.  
  54.  
  55. 'private static int p[] = {151,160,137,91,90,15,
  56. '131,13,201,95,96,53,194,233,7,225,140,36,103,30,69,142,8,99,37,240,21,10,23,
  57. '190,6,148,247,120,234,75,0,26,197,62,94,252,219,203,117,35,11,32,57,177,33,
  58. '88,237,149,56,87,174,20,125,136,171,168, 68,175,74,165,71,134,139,48,27,166,
  59. '77,146,158,231,83,111,229,122,60,211,133,230,220,105,92,41,55,46,245,40,244,
  60. '102,143,54,65,25,63,161,1,216,80,73,209,76,132,187,208,89,18,169,200,196,
  61. '135,130,116,188,159,86,164,100,109,198,173,186,3,64,52,217,226,250,124,123,
  62. '5,202,38,147,118,126,255,82,85,212,207,206,59,227,47,16,58,17,182,189,28,42,
  63. '223,183,170,213,119,248,152,2,44,154,163,70,221,153,101,155,167,43,172,9,
  64. '129,22,39,253,19,98,108,110,79,113,224,232,178,185,112,104,218,246,97,228,
  65. '251,34,242,193,238,210,144,12,191,179,162,241,81,51,145,235,249,14,239,107,
  66. '49,192,214,31,181,199,106,157,184,84,204,176,115,121,50,45,127,4,150,254,
  67. '138,236,205,93,222,114,67,29,24,72,243,141,128,195,78,66,215,61,156,180};
  68. p:
  69. DATA 151,160,137,091,090,015,131,013,201,095
  70. DATA 096,053,194,233,007,225,140,036,103,030
  71. DATA 069,142,008,099,037,240,021,010,023,190
  72. DATA 006,148,247,120,234,075,000,026,197,062
  73. DATA 094,252,219,203,117,035,011,032,057,177
  74. DATA 033,088,237,149,056,087,174,020,125,136
  75. DATA 171,168,068,175,074,165,071,134,139,048
  76. DATA 027,166,077,146,158,231,083,111,229,122
  77. DATA 060,211,133,230,220,105,092,041,055,046
  78. DATA 245,040,244,102,143,054,065,025,063,161
  79. DATA 001,216,080,073,209,076,132,187,208,089
  80. DATA 018,169,200,196,135,130,116,188,159,086
  81. DATA 164,100,109,198,173,186,003,064,052,217
  82. DATA 226,250,124,123,005,202,038,147,118,126
  83. DATA 255,082,085,212,207,206,059,227,047,016
  84. DATA 058,017,182,189,028,042,223,183,170,213
  85. DATA 119,248,152,002,044,154,163,070,221,153
  86. DATA 101,155,167,043,172,009,129,022,039,253
  87. DATA 019,098,108,110,079,113,224,232,178,185
  88. DATA 112,104,218,246,097,228,251,034,242,193
  89. DATA 238,210,144,012,191,179,162,241,081,051
  90. DATA 145,235,249,014,239,107,049,192,214,031
  91. DATA 181,199,106,157,184,084,204,176,115,121
  92. DATA 050,045,127,004,150,254,138,236,205,093
  93. DATA 222,114,067,029,024,072,243,141,128,195
  94. DATA 078,066,215,061,156,180
  95. DATA 151,160,137,091,090,015,131,013,201,095
  96. DATA 096,053,194,233,007,225,140,036,103,030
  97. DATA 069,142,008,099,037,240,021,010,023,190
  98. DATA 006,148,247,120,234,075,000,026,197,062
  99. DATA 094,252,219,203,117,035,011,032,057,177
  100. DATA 033,088,237,149,056,087,174,020,125,136
  101. DATA 171,168,068,175,074,165,071,134,139,048
  102. DATA 027,166,077,146,158,231,083,111,229,122
  103. DATA 060,211,133,230,220,105,092,041,055,046
  104. DATA 245,040,244,102,143,054,065,025,063,161
  105. DATA 001,216,080,073,209,076,132,187,208,089
  106. DATA 018,169,200,196,135,130,116,188,159,086
  107. DATA 164,100,109,198,173,186,003,064,052,217
  108. DATA 226,250,124,123,005,202,038,147,118,126
  109. DATA 255,082,085,212,207,206,059,227,047,016
  110. DATA 058,017,182,189,028,042,223,183,170,213
  111. DATA 119,248,152,002,044,154,163,070,221,153
  112. DATA 101,155,167,043,172,009,129,022,039,253
  113. DATA 019,098,108,110,079,113,224,232,178,185
  114. DATA 112,104,218,246,097,228,251,034,242,193
  115. DATA 238,210,144,012,191,179,162,241,081,051
  116. DATA 145,235,249,014,239,107,049,192,214,031
  117. DATA 181,199,106,157,184,084,204,176,115,121
  118. DATA 050,045,127,004,150,254,138,236,205,093
  119. DATA 222,114,067,029,024,072,243,141,128,195
  120. DATA 078,066,215,061,156,180
  121.  
  122.  
  123. 'To remove the need for index wrapping, double the permutation table length
  124. 'private static int perm[] = new int[512];
  126. DIM SHARED perm(512) AS INTEGER
  127.  
  128. 'static { for(int i=0; i<512; i++) perm[i]=p[i & 255]; }
  130. FOR i% = 0 TO 511
  131.     READ p(i%)
  132.     perm(i%) = p(i%) AND 255
  133.  
  134.     'PRINT perm(i%)
  136.  
  137.  
  138. '' 2D simplex noise************************************************************
  139.  
  140. ' final double F2 = 0.5*(Math.sqrt(3.0)-1.0);
  141. CONST F2 = .5 * (SQR(3) - 1)
  142. ' final double G2 = (3.0-Math.sqrt(3.0))/6.0;
  143. CONST G2 = (3 - SQR(3)) / 6
  144.  
  145. scale = .01
  146. '------------------------------------------------------------------------------
  147. FOR x% = 0 TO 800
  148.     FOR y% = 0 TO 600
  149.  
  150.         'used to grayscale input
  151.         gs% = map!(noise2D(scale * x%, scale * y%), -1, 1, 0, 255)
  152.         c& = _RGB(gs%, gs%, gs%)
  153.         PSET (x%, y%), c&
  154.  
  155.         'PRINT INT(map!(noise2D(x%, y%), -1, 1, 0, 255));
  156.         'PRINT INT((noise2D(x%, y%) + 1) / 2.0 * 255.0);
  157.  
  158.     NEXT
  160. '------------------------------------------------------------------------------
  161.  
  162.  
  163. ' public static double noise(double xin, double yin) {
  164. FUNCTION noise2D (xin, yin)
  165.     ' double n0, n1, n2;' Noise contributions from the three corners
  166.     DIM n0, n1, n2
  167.  
  168.     '' Skew the input space to determine which simplex cell we're in
  169.     ' double s = (xin+yin)*F2;' Hairy factor for 2D
  170.     s = (xin + yin) * F2
  171.     ' int i = fastfloor(xin+s);
  172.     i% = INT(xin + s)
  173.     ' int j = fastfloor(yin+s);
  174.     j% = INT(yin + s)
  175.  
  176.  
  177.     ' double t = (i+j)*G2;
  178.     t = (i% + j%) * G2
  179.     ' double X0 = i-t;' Unskew the cell origin back to (x,y) space
  180.     BX0 = i% - t
  181.     ' double Y0 = j-t;
  182.     BY0 = j% - t
  183.     ' double x0 = xin-X0;' The x,y distances from the cell origin
  184.     x0 = xin - BX0
  185.     ' double y0 = yin-Y0;
  186.     y0 = yin - BY0
  187.  
  188.  
  189.     '' For the 2D case, the simplex shape is an equilateral triangle
  190.     '' Determine which simplex we are in.
  191.     ' int i1, j1;' Offsets for second (middle) corner of simplex in (i,j) coords
  192.     DIM AS INTEGER i1, j1
  193.     ' if(x0>y0) {i1=1; j1=0;}' lower triangle, XY order: (0,0)->(1,0)->(1,1)
  194.     IF x0 > y0 THEN
  195.         i1% = 1: j1% = 0
  196.         ' else {i1=0; j1=1;}' upper triangle, YX order: (0,0)->(0,1)->(1,1)
  197.     ELSE
  198.         i1% = 0: j1% = 1
  199.     END IF
  200.  
  201.  
  202.     '' A step of (1,0) in (i,j) means a step of (1-c,-c) in (x,y), and
  203.     '' a step of (0,1) in (i,j) means a step of (-c,1-c) in (x,y), where
  204.     '' c = (3-sqrt(3))/6 which is G2
  205.     '
  206.     ' double x1 = x0 - i1 + G2;' Offsets for middle corner in (x,y) unskewed coords
  207.     x1 = x0 - i1% + G2
  208.     ' double y1 = y0 - j1 + G2;
  209.     y1 = y0 - j1% + G2
  210.     ' double x2 = x0 - 1.0 + 2.0 * G2;' Offsets for last corner in (x,y) unskewed coords
  211.     x2 = x0 - 1 + 2 * G2
  212.     ' double y2 = y0 - 1.0 + 2.0 * G2;
  213.     y2 = y0 - 1 + 2 * G2
  214.  
  215.  
  216.     '' Work out the hashed gradient indices of the three simplex corners
  217.     ' int ii = i & 255;
  218.     ii% = i% AND 255
  219.     ' int jj = j & 255;
  220.     jj% = j% AND 255
  221.     ' int gi0 = perm[ii+perm[jj]] % 12;
  222.     gi0% = perm(ii% + perm(jj%)) MOD 12
  223.     ' int gi1 = perm[ii+i1+perm[jj+j1]] % 12;
  224.     gi1% = perm(ii% + i1% + perm(jj% + j1%)) MOD 12
  225.     ' int gi2 = perm[ii+1+perm[jj+1]] % 12;
  226.     gi2% = perm(ii% + 1 + perm(jj% + 1)) MOD 12
  227.  
  228.  
  229.     '' Calculate the contribution from the three corners
  230.     '
  231.     ' double t0 = 0.5 - x0*x0-y0*y0;
  232.     t0 = .5 - x0 * x0 - y0 * y0
  233.     ' if(t0<0) n0 = 0.0;
  234.     IF t0 < 0 THEN
  235.         n0 = 0
  236.         ' else {
  237.     ELSE
  238.         ' t0 *= t0;
  239.         t0 = t0 * t0
  240.         ' n0 = t0 * t0 * dot(grad3[gi0], x0, y0);' (x,y) of grad3 used for 2D gradient
  241.         n0 = t0 * t0 * DotP2(gi0%, x0, y0)
  242.         ' }
  243.     END IF
  244.  
  245.  
  246.     ' double t1 = 0.5 - x1*x1-y1*y1;
  247.     t1 = .5 - x1 * x1 - y1 * y1
  248.     ' if(t1<0) n1 = 0.0;
  249.     IF t1 < 0 THEN
  250.         n1 = 0
  251.         ' else {
  252.     ELSE
  253.         ' t1 *= t1;
  254.         t1 = t1 * t1
  255.         ' n1 = t1 * t1 * dot(grad3[gi1], x1, y1);
  256.         n1 = t1 * t1 * DotP2(gi1%, x1, y1)
  257.         ' }
  258.     END IF
  259.  
  260.  
  261.     ' double t2 = 0.5 - x2*x2-y2*y2;
  262.     t2 = .5 - x2 * x2 - y2 * y2
  263.     ' if(t2<0) n2 = 0.0;
  264.     IF t2 < 0 THEN
  265.         n2 = 0
  266.         ' else {
  267.     ELSE
  268.         ' t2 *= t2;
  269.         t2 = t2 * t2
  270.         ' n2 = t2 * t2 * dot(grad3[gi2], x2, y2);
  271.         n2 = t2 * t2 * DotP2(gi2%, x2, y2)
  272.         ' }
  273.     END IF
  274.  
  275.  
  276.     '' Add contributions from each corner to get the final noise value.
  277.     '' The result is scaled to return values in the interval [-1,1].
  278.     '
  279.     ' return 70.0 * (n0 + n1 + n2);
  280.     noise2D = 70 * (n0 + n1 + n2)
  281.  
  282.     ' }
  283.  
  285.  
  286.  
  287. ' This method is a *lot* faster than using (int)Math.floor(x)
  288. ' private static int fastfloor(double x) {
  289. ' return x>0 ? (int)x : (int)x-1;}
  290.  
  291. ' private static double dot(int g[], double x, double y) {
  292. ' return g[0]*x + g[1]*y; }
  293. FUNCTION DotP2 (g%, x, y)
  294.     DotP2 = grad3(g%).x * x + grad3(g%).y * y
  296.  
  297. ' Map function I found or translated from somewhere.
  298. ' The Coding Train" guy on youtube, where I translated the rain code from explained it in one of his videos.
  299. FUNCTION map! (value!, minRange!, maxRange!, newMinRange!, newMaxRange!)
  300.     map! = ((value! - minRange!) / (maxRange! - minRange!)) * (newMaxRange! - newMinRange!) + newMinRange!
  302.  
  303.  
  304. ' private static double dot(int g[], double x, double y, double z, double w) {
  305. ' private static double dot(int g[], double x, double y) {
  306. ' return g[0]*x + g[1]*y; }
  307.  
  308.  
  309. ' private static double dot(int g[], double x, double y, double z) {
  310. ' return g[0]*x + g[1]*y + g[2]*z; }
  311.  
  312.  
  313. ' private static double dot(int g[], double x, double y, double z, double w) {
  314. ' return g[0]*x + g[1]*y + g[2]*z + g[3]*w; }
  315. ' return g[0]*x + g[1]*y + g[2]*z + g[3]*w; }
  316.  
  317.  
  318.  
  319. ' ******* NOTE: 3D portion below not ported yet ~Phlashlite *******
  320.  
  321.  
  322.  
  323. '' 3D simplex noise
  324. ' public static double noise(double xin, double yin, double zin) {
  325. ' double n0, n1, n2, n3;' Noise contributions from the four corners
  326.  
  327.  
  328. '' Skew the input space to determine which simplex cell we're in
  329. ' final double F3 = 1.0/3.0;
  330. ' double s = (xin+yin+zin)*F3;' Very nice and simple skew factor for 3D
  331. ' int i = fastfloor(xin+s);
  332. ' int j = fastfloor(yin+s);
  333. ' int k = fastfloor(zin+s);
  334. ' final double G3 = 1.0/6.0;' Very nice and simple unskew factor, too
  335. ' double t = (i+j+k)*G3;
  336. ' double X0 = i-t;' Unskew the cell origin back to (x,y,z) space
  337. ' double Y0 = j-t;
  338. ' double Z0 = k-t;
  339. ' double x0 = xin-X0;' The x,y,z distances from the cell origin
  340. ' double y0 = yin-Y0;
  341. ' double z0 = zin-Z0;
  342.  
  343.  
  344. '' For the 3D case, the simplex shape is a slightly irregular tetrahedron.
  345. '' Determine which simplex we are in.
  346. ' int i1, j1, k1;' Offsets for second corner of simplex in (i,j,k) coords
  347. ' int i2, j2, k2;' Offsets for third corner of simplex in (i,j,k) coords
  348. ' if(x0>=y0) {
  349. ' if(y0>=z0)
  350. ' { i1=1; j1=0; k1=0; i2=1; j2=1; k2=0; }' X Y Z order
  351. ' else if(x0>=z0) { i1=1; j1=0; k1=0; i2=1; j2=0; k2=1; }' X Z Y order
  352. ' else { i1=0; j1=0; k1=1; i2=1; j2=0; k2=1; }' Z X Y order
  353. ' }
  354. ' else {' x0<y0
  355. ' if(y0<z0) { i1=0; j1=0; k1=1; i2=0; j2=1; k2=1; }' Z Y X order
  356. ' else if(x0<z0) { i1=0; j1=1; k1=0; i2=0; j2=1; k2=1; }' Y Z X order
  357. ' else { i1=0; j1=1; k1=0; i2=1; j2=1; k2=0; }' Y X Z order
  358. ' }
  359.  
  360.  
  361. '' A step of (1,0,0) in (i,j,k) means a step of (1-c,-c,-c) in (x,y,z),
  362. '' a step of (0,1,0) in (i,j,k) means a step of (-c,1-c,-c) in (x,y,z), and
  363. '' a step of (0,0,1) in (i,j,k) means a step of (-c,-c,1-c) in (x,y,z), where
  364. '' c = 1/6.
  365. ' double x1 = x0 - i1 + G3;' Offsets for second corner in (x,y,z) coords
  366. ' double y1 = y0 - j1 + G3;
  367. ' double z1 = z0 - k1 + G3;
  368. ' double x2 = x0 - i2 + 2.0*G3;' Offsets for third corner in (x,y,z) coords
  369. ' double y2 = y0 - j2 + 2.0*G3;
  370. ' double z2 = z0 - k2 + 2.0*G3;
  371. ' double x3 = x0 - 1.0 + 3.0*G3;' Offsets for last corner in (x,y,z) coords
  372. ' double y3 = y0 - 1.0 + 3.0*G3;
  373. ' double z3 = z0 - 1.0 + 3.0*G3;
  374.  
  375.  
  376. '' Work out the hashed gradient indices of the four simplex corners
  377. ' int ii = i & 255;
  378. ' int jj = j & 255;
  379. ' int kk = k & 255;
  380. ' int gi0 = perm[ii+perm[jj+perm[kk]]] % 12;
  381. ' int gi1 = perm[ii+i1+perm[jj+j1+perm[kk+k1]]] % 12;
  382. ' int gi2 = perm[ii+i2+perm[jj+j2+perm[kk+k2]]] % 12;
  383. ' int gi3 = perm[ii+1+perm[jj+1+perm[kk+1]]] % 12;
  384.  
  385.  
  386. '' Calculate the contribution from the four corners
  387. ' double t0 = 0.6 - x0*x0 - y0*y0 - z0*z0;
  388. ' if(t0<0) n0 = 0.0;
  389. ' else {
  390. ' t0 *= t0;
  391. ' n0 = t0 * t0 * dot(grad3[gi0], x0, y0, z0);
  392. ' }
  393. ' double t1 = 0.6 - x1*x1 - y1*y1 - z1*z1;
  394. ' if(t1<0) n1 = 0.0;
  395. ' else {
  396. ' t1 *= t1;
  397. ' n1 = t1 * t1 * dot(grad3[gi1], x1, y1, z1);
  398. ' }
  399. ' double t2 = 0.6 - x2*x2 - y2*y2 - z2*z2;
  400. ' if(t2<0) n2 = 0.0;
  401. ' else {
  402. ' t2 *= t2;
  403. ' n2 = t2 * t2 * dot(grad3[gi2], x2, y2, z2);
  404. ' }
  405. ' double t3 = 0.6 - x3*x3 - y3*y3 - z3*z3;
  406. ' if(t3<0) n3 = 0.0;
  407. ' else {
  408. ' t3 *= t3;
  409. ' n3 = t3 * t3 * dot(grad3[gi3], x3, y3, z3);
  410. ' }
  411.  
  412.  
  413. '' Add contributions from each corner to get the final noise value.
  414. '' The result is scaled to stay just inside [-1,1]
  415. ' return 32.0*(n0 + n1 + n2 + n3);
  416. ' }
  417.  
  418.  
  419. '' 4D simplex noise
  420. ' double noise(double x, double y, double z, double w) {
  421.  
  422. '' The skewing and unskewing factors are hairy again for the 4D case
  423. ' final double F4 = (Math.sqrt(5.0)-1.0)/4.0;
  424. ' final double G4 = (5.0-Math.sqrt(5.0))/20.0;
  425. ' double n0, n1, n2, n3, n4;' Noise contributions from the five corners
  426.  
  427.  
  428. '' Skew the (x,y,z,w) space to determine which cell of 24 simplices we're in
  429. '  double s = (x + y + z + w) * F4;' Factor for 4D skewing
  430. ' int i = fastfloor(x + s);
  431. ' int j = fastfloor(y + s);
  432. ' int k = fastfloor(z + s);
  433. ' int l = fastfloor(w + s);
  434. ' double t = (i + j + k + l) * G4;' Factor for 4D unskewing
  435. ' double X0 = i - t;' Unskew the cell origin back to (x,y,z,w) space
  436. ' double Y0 = j - t;
  437. ' double Z0 = k - t;
  438. ' double W0 = l - t;
  439. ' double x0 = x - X0;' The x,y,z,w distances from the cell origin
  440. ' double y0 = y - Y0;
  441. ' double z0 = z - Z0;
  442. ' double w0 = w - W0;
  443.  
  444.  
  445. '' For the 4D case, the simplex is a 4D shape I won't even try to describe.
  446. '' To find out which of the 24 possible simplices we're in, we need to
  447. '' determine the magnitude ordering of x0, y0, z0 and w0.
  448. '' The method below is a good way of finding the ordering of x,y,z,w and
  449. '' then find the correct traversal order for the simplex we%u2019re in.
  450. '' First, six pair-wise comparisons are performed between each possible pair
  451. '' of the four coordinates, and the results are used to add up binary bits
  452. '' for an integer index.
  453. ' int c1 = (x0 > y0) ? 32 : 0;
  454. ' int c2 = (x0 > z0) ? 16 : 0;
  455. ' int c3 = (y0 > z0) ? 8 : 0;
  456. ' int c4 = (x0 > w0) ? 4 : 0;
  457. ' int c5 = (y0 > w0) ? 2 : 0;
  458. ' int c6 = (z0 > w0) ? 1 : 0;
  459. ' int c = c1 + c2 + c3 + c4 + c5 + c6;
  460. ' int i1, j1, k1, l1;' The integer offsets for the second simplex corner
  461. ' int i2, j2, k2, l2;' The integer offsets for the third simplex corner
  462. ' int i3, j3, k3, l3;' The integer offsets for the fourth simplex corner
  463.  
  464.  
  465. '' simplex[c] is a 4-vector with the numbers 0, 1, 2 and 3 in some order.
  466. '' Many values of c will never occur, since e.g. x>y>z>w makes x<z, y<w and x<w
  467. '' impossible. Only the 24 indices which have non-zero entries make any sense.
  468. '' We use a thresholding to set the coordinates in turn from the largest magnitude.
  469.  
  470.  
  471. '' The number 3 in the "simplex" array is at the position of the largest coordinate.
  472. ' i1 = simplex[c][0]>=3 ? 1 : 0;
  473. ' j1 = simplex[c][1]>=3 ? 1 : 0;
  474. ' k1 = simplex[c][2]>=3 ? 1 : 0;
  475. ' l1 = simplex[c][3]>=3 ? 1 : 0;
  476.  
  477.  
  478. '' The number 2 in the "simplex" array is at the second largest coordinate.
  479. ' i2 = simplex[c][0]>=2 ? 1 : 0;
  480. ' j2 = simplex[c][1]>=2 ? 1 : 0;
  481. ' k2 = simplex[c][2]>=2 ? 1 : 0;
  482. ' l2 = simplex[c][3]>=2 ? 1 : 0;
  483.  
  484.  
  485. '' The number 1 in the "simplex" array is at the second smallest coordinate.
  486. ' i3 = simplex[c][0]>=1 ? 1 : 0;
  487. ' j3 = simplex[c][1]>=1 ? 1 : 0;
  488. ' k3 = simplex[c][2]>=1 ? 1 : 0;
  489. ' l3 = simplex[c][3]>=1 ? 1 : 0;
  490.  
  491.  
  492. '' The fifth corner has all coordinate offsets = 1, so no need to look that up.
  493. ' double x1 = x0 - i1 + G4;' Offsets for second corner in (x,y,z,w) coords
  494. ' double y1 = y0 - j1 + G4;
  495. ' double z1 = z0 - k1 + G4;
  496. ' double w1 = w0 - l1 + G4;
  497. ' double x2 = x0 - i2 + 2.0*G4;' Offsets for third corner in (x,y,z,w) coords
  498. ' double y2 = y0 - j2 + 2.0*G4;
  499. ' double z2 = z0 - k2 + 2.0*G4;
  500. ' double w2 = w0 - l2 + 2.0*G4;
  501. ' double x3 = x0 - i3 + 3.0*G4;' Offsets for fourth corner in (x,y,z,w) coords
  502. ' double y3 = y0 - j3 + 3.0*G4;
  503. ' double z3 = z0 - k3 + 3.0*G4;
  504. ' double w3 = w0 - l3 + 3.0*G4;
  505. ' double x4 = x0 - 1.0 + 4.0*G4;' Offsets for last corner in (x,y,z,w) coords
  506. ' double y4 = y0 - 1.0 + 4.0*G4;
  507. ' double z4 = z0 - 1.0 + 4.0*G4;
  508. ' double w4 = w0 - 1.0 + 4.0*G4;
  509.  
  510.  
  511. '' Work out the hashed gradient indices of the five simplex corners
  512. ' int ii = i & 255;
  513. ' int jj = j & 255;
  514. ' int kk = k & 255;
  515. ' int ll = l & 255;
  516. ' int gi0 = perm[ii+perm[jj+perm[kk+perm[ll]]]] % 32;
  517. ' int gi1 = perm[ii+i1+perm[jj+j1+perm[kk+k1+perm[ll+l1]]]] % 32;
  518. ' int gi2 = perm[ii+i2+perm[jj+j2+perm[kk+k2+perm[ll+l2]]]] % 32;
  519. ' int gi3 = perm[ii+i3+perm[jj+j3+perm[kk+k3+perm[ll+l3]]]] % 32;
  520. ' int gi4 = perm[ii+1+perm[jj+1+perm[kk+1+perm[ll+1]]]] % 32;
  521.  
  522.  
  523. '' Calculate the contribution from the five corners
  524. ' double t0 = 0.6 - x0*x0 - y0*y0 - z0*z0 - w0*w0;
  525. ' if(t0<0) n0 = 0.0;
  526. ' else {
  527. ' t0 *= t0;
  528. ' n0 = t0 * t0 * dot(grad4[gi0], x0, y0, z0, w0);
  529. ' }
  530. ' double t1 = 0.6 - x1*x1 - y1*y1 - z1*z1 - w1*w1;
  531. ' if(t1<0) n1 = 0.0;
  532. ' else {
  533. ' t1 *= t1;
  534. ' n1 = t1 * t1 * dot(grad4[gi1], x1, y1, z1, w1);
  535. ' }
  536. ' double t2 = 0.6 - x2*x2 - y2*y2 - z2*z2 - w2*w2;
  537. ' if(t2<0) n2 = 0.0;
  538. ' else {
  539. ' t2 *= t2;
  540. ' n2 = t2 * t2 * dot(grad4[gi2], x2, y2, z2, w2);
  541. ' }
  542. ' double t3 = 0.6 - x3*x3 - y3*y3 - z3*z3 - w3*w3;
  543. ' if(t3<0) n3 = 0.0;
  544. ' else {
  545. ' t3 *= t3;
  546. ' n3 = t3 * t3 * dot(grad4[gi3], x3, y3, z3, w3);
  547. ' }
  548. ' double t4 = 0.6 - x4*x4 - y4*y4 - z4*z4 - w4*w4;
  549. ' if(t4<0) n4 = 0.0;
  550. ' else {
  551. ' t4 *= t4;
  552. ' n4 = t4 * t4 * dot(grad4[gi4], x4, y4, z4, w4);
  553. ' }
  554.  
  555.  
  556. '' Sum up and scale the result to cover the range [-1,1]
  557. ' return 27.0 * (n0 + n1 + n2 + n3 + n4);
  558.  
  559. 'private static int grad4[][]= {{0,1,1,1}, {0,1,1,-1}, {0,1,-1,1}, {0,1,-1,-1},
  560. '{0,-1,1,1}, {0,-1,1,-1}, {0,-1,-1,1}, {0,-1,-1,-1},
  561. '{1,0,1,1}, {1,0,1,-1}, {1,0,-1,1}, {1,0,-1,-1},
  562. '{-1,0,1,1}, {-1,0,1,-1}, {-1,0,-1,1}, {-1,0,-1,-1},
  563. '{1,1,0,1}, {1,1,0,-1}, {1,-1,0,1}, {1,-1,0,-1},
  564. '{-1,1,0,1}, {-1,1,0,-1}, {-1,-1,0,1}, {-1,-1,0,-1},
  565. '{1,1,1,0}, {1,1,-1,0}, {1,-1,1,0}, {1,-1,-1,0},
  566. '{-1,1,1,0}, {-1,1,-1,0}, {-1,-1,1,0}, {-1,-1,-1,0}};
  567.  
  568. '' A lookup table to traverse the simplex around a given point in 4D.
  569. '' Details can be found where this table is used, in the 4D noise method.
  570. ' private static int simplex[][] = {
  571. ' {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},
  572. ' {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},
  573. ' {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},
  574. ' {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},
  575. ' {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},
  576. ' {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},
  577. ' {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},
  578. ' {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}};
  579.  
  580.  
  581. '}
  582. '}
  583.  
  584.  
  585.  


***  had an extra "+j1"  ***
 ' int gi0 = perm[ii+perm[jj]] % 12;
    gi0% = perm(ii + perm(jj + j1)) MOD 12

13
Programs / Re: Simplex Noise Anyone?
« on: February 25, 2022, 12:59:08 pm »
Okay... So, I have found some obvious stuff... and it is looking closer.

Code: QB64: [Select]
  1. '$DEBUG
  2. _TITLE "Simplex noise port"
  3.  
  4. ' ported to QB64 by: Phlashlite, February 20, 2022
  5. '    from the paper: Simplex noise demystified
  6. '            author: Stefan Gustavson, Link%u201Dping University, Sweden (stegu@itn.liu.se), 2005-03-22
  7. '               URL: https://weber.itn.liu.se/~stegu/simplexnoise/simplexnoise.pdf
  8. ' - Simplex noise has a lower computational complexity and requires fewer multiplications.
  9. ' - Simplex noise scales to higher dimensions (4D, 5D and up) with much less computational
  10. '   cost, the complexity is for dimensions instead of the of classic Noise.
  11. ' - Simplex noise has no noticeable directional artifacts.
  12. ' - Simplex noise has a well-defined and continuous gradient everywhere that can be computed
  13. '   quite cheaply.
  14. ' - Simplex noise is easy to implement in hardware
  15.  
  16.  
  17. SCREEN _NEWIMAGE(800, 600, 32)
  18.  
  19. DEFDBL A-Z
  20.  
  21. 'private static int grad3[][] = {{1,1,0},{-1,1,0},{1,-1,0},{-1,-1,0},{1,0,1},{-1,0,1},{1,0,-1},{-1,0,-1},{0,1,1},{0,-1,1},{0,1,-1},{0,-1,-1}};
  22. g3:
  23. DATA 1,1,0
  24. DATA -1,1,0
  25. DATA 1,-1,0
  26. DATA -1,-1,0
  27. DATA 1,0,1
  28. DATA -1,0,1
  29. DATA 1,0,-1
  30. DATA -1,0,-1
  31. DATA 0,1,1
  32. DATA 0,-1,1
  33. DATA 0,1,-1
  34. DATA 0,-1,-1
  35.  
  36. TYPE TriBit
  37.     x AS INTEGER
  38.     y AS INTEGER
  39.     z AS INTEGER
  41. DIM SHARED grad3(12) AS TriBit
  42.  
  44. FOR g% = 0 TO 11
  45.  
  46.     READ grad3(g%).x
  47.     READ grad3(g%).y
  48.     READ grad3(g%).z
  49.  
  50.     'PRINT grad3(g%).x, grad3(g%).y, grad3(g%).z
  51.  
  52. NEXT g%
  53.  
  54.  
  55. 'private static int p[] = {151,160,137,91,90,15,
  56. '131,13,201,95,96,53,194,233,7,225,140,36,103,30,69,142,8,99,37,240,21,10,23,
  57. '190,6,148,247,120,234,75,0,26,197,62,94,252,219,203,117,35,11,32,57,177,33,
  58. '88,237,149,56,87,174,20,125,136,171,168, 68,175,74,165,71,134,139,48,27,166,
  59. '77,146,158,231,83,111,229,122,60,211,133,230,220,105,92,41,55,46,245,40,244,
  60. '102,143,54,65,25,63,161,1,216,80,73,209,76,132,187,208,89,18,169,200,196,
  61. '135,130,116,188,159,86,164,100,109,198,173,186,3,64,52,217,226,250,124,123,
  62. '5,202,38,147,118,126,255,82,85,212,207,206,59,227,47,16,58,17,182,189,28,42,
  63. '223,183,170,213,119,248,152,2,44,154,163,70,221,153,101,155,167,43,172,9,
  64. '129,22,39,253,19,98,108,110,79,113,224,232,178,185,112,104,218,246,97,228,
  65. '251,34,242,193,238,210,144,12,191,179,162,241,81,51,145,235,249,14,239,107,
  66. '49,192,214,31,181,199,106,157,184,84,204,176,115,121,50,45,127,4,150,254,
  67. '138,236,205,93,222,114,67,29,24,72,243,141,128,195,78,66,215,61,156,180};
  68. p:
  69. DATA 151,160,137,091,090,015,131,013,201,095
  70. DATA 096,053,194,233,007,225,140,036,103,030
  71. DATA 069,142,008,099,037,240,021,010,023,190
  72. DATA 006,148,247,120,234,075,000,026,197,062
  73. DATA 094,252,219,203,117,035,011,032,057,177
  74. DATA 033,088,237,149,056,087,174,020,125,136
  75. DATA 171,168,068,175,074,165,071,134,139,048
  76. DATA 027,166,077,146,158,231,083,111,229,122
  77. DATA 060,211,133,230,220,105,092,041,055,046
  78. DATA 245,040,244,102,143,054,065,025,063,161
  79. DATA 001,216,080,073,209,076,132,187,208,089
  80. DATA 018,169,200,196,135,130,116,188,159,086
  81. DATA 164,100,109,198,173,186,003,064,052,217
  82. DATA 226,250,124,123,005,202,038,147,118,126
  83. DATA 255,082,085,212,207,206,059,227,047,016
  84. DATA 058,017,182,189,028,042,223,183,170,213
  85. DATA 119,248,152,002,044,154,163,070,221,153
  86. DATA 101,155,167,043,172,009,129,022,039,253
  87. DATA 019,098,108,110,079,113,224,232,178,185
  88. DATA 112,104,218,246,097,228,251,034,242,193
  89. DATA 238,210,144,012,191,179,162,241,081,051
  90. DATA 145,235,249,014,239,107,049,192,214,031
  91. DATA 181,199,106,157,184,084,204,176,115,121
  92. DATA 050,045,127,004,150,254,138,236,205,093
  93. DATA 222,114,067,029,024,072,243,141,128,195
  94. DATA 078,066,215,061,156,180
  95. DATA 151,160,137,091,090,015,131,013,201,095
  96. DATA 096,053,194,233,007,225,140,036,103,030
  97. DATA 069,142,008,099,037,240,021,010,023,190
  98. DATA 006,148,247,120,234,075,000,026,197,062
  99. DATA 094,252,219,203,117,035,011,032,057,177
  100. DATA 033,088,237,149,056,087,174,020,125,136
  101. DATA 171,168,068,175,074,165,071,134,139,048
  102. DATA 027,166,077,146,158,231,083,111,229,122
  103. DATA 060,211,133,230,220,105,092,041,055,046
  104. DATA 245,040,244,102,143,054,065,025,063,161
  105. DATA 001,216,080,073,209,076,132,187,208,089
  106. DATA 018,169,200,196,135,130,116,188,159,086
  107. DATA 164,100,109,198,173,186,003,064,052,217
  108. DATA 226,250,124,123,005,202,038,147,118,126
  109. DATA 255,082,085,212,207,206,059,227,047,016
  110. DATA 058,017,182,189,028,042,223,183,170,213
  111. DATA 119,248,152,002,044,154,163,070,221,153
  112. DATA 101,155,167,043,172,009,129,022,039,253
  113. DATA 019,098,108,110,079,113,224,232,178,185
  114. DATA 112,104,218,246,097,228,251,034,242,193
  115. DATA 238,210,144,012,191,179,162,241,081,051
  116. DATA 145,235,249,014,239,107,049,192,214,031
  117. DATA 181,199,106,157,184,084,204,176,115,121
  118. DATA 050,045,127,004,150,254,138,236,205,093
  119. DATA 222,114,067,029,024,072,243,141,128,195
  120. DATA 078,066,215,061,156,180
  121.  
  122.  
  123. 'To remove the need for index wrapping, double the permutation table length
  124. 'private static int perm[] = new int[512];
  126. DIM SHARED perm(512) AS INTEGER
  127.  
  128. 'static { for(int i=0; i<512; i++) perm[i]=p[i & 255]; }
  130. FOR i% = 0 TO 511
  131.     READ p(i%)
  132.     perm(i%) = p(i%) AND 255
  133.  
  134.     'PRINT perm(i%)
  136.  
  137.  
  138. '' 2D simplex noise************************************************************
  139.  
  140. ' final double F2 = 0.5*(Math.sqrt(3.0)-1.0);
  141. CONST F2 = .5 * (SQR(3) - 1)
  142. ' final double G2 = (3.0-Math.sqrt(3.0))/6.0;
  143. CONST G2 = (3 - SQR(3)) / 6
  144.  
  145. scale = .01
  146. '------------------------------------------------------------------------------
  147. FOR x% = 0 TO 800
  148.     FOR y% = 0 TO 600
  149.  
  150.         gs% = map!(noise2D(scale * x%, scale * y%), -1, 1, 0, 255)
  151.         c& = _RGB(gs%, gs%, gs%)
  152.         PSET (x%, y%), c&
  153.  
  154.         'PRINT INT(map!(noise2D(x%, y%), -1, 1, 0, 255));
  155.         'PRINT INT((noise2D(x%, y%) + 1) / 2.0 * 255.0);
  156.  
  157.     NEXT
  159. '------------------------------------------------------------------------------
  160.  
  161.  
  162. ' public static double noise(double xin, double yin) {
  163. FUNCTION noise2D (xin, yin)
  164.     ' double n0, n1, n2;' Noise contributions from the three corners
  165.     DIM n0, n1, n2
  166.  
  167.     '' Skew the input space to determine which simplex cell we're in
  168.     ' double s = (xin+yin)*F2;' Hairy factor for 2D
  169.     s = (xin + yin) * F2
  170.     ' int i = fastfloor(xin+s);
  171.     i% = INT(xin + s)
  172.     ' int j = fastfloor(yin+s);
  173.     j% = INT(yin + s)
  174.  
  175.  
  176.     ' double t = (i+j)*G2;
  177.     t = (i% + j%) * G2
  178.     ' double X0 = i-t;' Unskew the cell origin back to (x,y) space
  179.     BX0 = i% - t
  180.     ' double Y0 = j-t;
  181.     BY0 = j% - t
  182.     ' double x0 = xin-X0;' The x,y distances from the cell origin
  183.     x0 = xin - BX0
  184.     ' double y0 = yin-Y0;
  185.     y0 = yin - BY0
  186.  
  187.  
  188.     '' For the 2D case, the simplex shape is an equilateral triangle
  189.     '' Determine which simplex we are in.
  190.     ' int i1, j1;' Offsets for second (middle) corner of simplex in (i,j) coords
  191.     DIM AS INTEGER i1, j1
  192.     ' if(x0>y0) {i1=1; j1=0;}' lower triangle, XY order: (0,0)->(1,0)->(1,1)
  193.     IF x0 > y0 THEN
  194.         i1 = 1: j1 = 0
  195.         ' else {i1=0; j1=1;}' upper triangle, YX order: (0,0)->(0,1)->(1,1)
  196.     ELSE
  197.         i1 = 0: j1 = 1
  198.     END IF
  199.  
  200.  
  201.     '' A step of (1,0) in (i,j) means a step of (1-c,-c) in (x,y), and
  202.     '' a step of (0,1) in (i,j) means a step of (-c,1-c) in (x,y), where
  203.     '' c = (3-sqrt(3))/6 which is G2
  204.     '
  205.     ' double x1 = x0 - i1 + G2;' Offsets for middle corner in (x,y) unskewed coords
  206.     x1 = x0 - i1 + G2
  207.     ' double y1 = y0 - j1 + G2;
  208.     y1 = y0 - j1 + G2
  209.     ' double x2 = x0 - 1.0 + 2.0 * G2;' Offsets for last corner in (x,y) unskewed coords
  210.     x2 = x0 - 1 + 2 * G2
  211.     ' double y2 = y0 - 1.0 + 2.0 * G2;
  212.     y2 = y0 - 1 + 2 * G2
  213.  
  214.  
  215.     '' Work out the hashed gradient indices of the three simplex corners
  216.     ' int ii = i & 255;
  217.     ii% = i% AND 255
  218.     ' int jj = j & 255;
  219.     jj% = j% AND 255
  220.     ' int gi0 = perm[ii+perm[jj]] % 12;
  221.     gi0% = perm(ii% + perm(jj% + j1)) MOD 12
  222.     ' int gi1 = perm[ii+i1+perm[jj+j1]] % 12;
  223.     gi1% = perm(ii% + i1% + perm(jj% + j1)) MOD 12
  224.     ' int gi2 = perm[ii+1+perm[jj+1]] % 12;
  225.     gi2% = perm(ii% + 1 + perm(jj% + 1)) MOD 12
  226.  
  227.  
  228.     '' Calculate the contribution from the three corners
  229.     '
  230.     ' double t0 = 0.5 - x0*x0-y0*y0;
  231.     t0 = .5 - x0 * x0 - y0 * y0
  232.     ' if(t0<0) n0 = 0.0;
  233.     IF t0 < 0 THEN
  234.         n0 = 0
  235.         ' else {
  236.     ELSE
  237.         ' t0 *= t0;
  238.         t0 = t0 * t0
  239.         ' n0 = t0 * t0 * dot(grad3[gi0], x0, y0);' (x,y) of grad3 used for 2D gradient
  240.         n0 = t0 * t0 * DotP2(gi0%, x0, y0)
  241.         ' }
  242.     END IF
  243.  
  244.  
  245.     ' double t1 = 0.5 - x1*x1-y1*y1;
  246.     t1 = .5 - x1 * x1 - y1 * y1
  247.     ' if(t1<0) n1 = 0.0;
  248.     IF t1 < 0 THEN
  249.         n1 = 0
  250.         ' else {
  251.     ELSE
  252.         ' t1 *= t1;
  253.         t1 = t1 * t1
  254.         ' n1 = t1 * t1 * dot(grad3[gi1], x1, y1);
  255.         n1 = t1 * t1 * DotP2(gi1%, x1, y1)
  256.         ' }
  257.     END IF
  258.  
  259.  
  260.     ' double t2 = 0.5 - x2*x2-y2*y2;
  261.     t2 = .5 - x2 * x2 - y2 * y2
  262.     ' if(t2<0) n2 = 0.0;
  263.     IF t2 < 0 THEN
  264.         n2 = 0
  265.         ' else {
  266.     ELSE
  267.         ' t2 *= t2;
  268.         t2 = t2 * t2
  269.         ' n2 = t2 * t2 * dot(grad3[gi2], x2, y2);
  270.         n2 = t2 * t2 * DotP2(gi2%, x2, y2)
  271.         ' }
  272.     END IF
  273.  
  274.  
  275.     '' Add contributions from each corner to get the final noise value.
  276.     '' The result is scaled to return values in the interval [-1,1].
  277.     '
  278.     ' return 70.0 * (n0 + n1 + n2);
  279.     noise2D = 70 * (n0 + n1 + n2)
  280.  
  281.     ' }
  282.  
  284.  
  285.  
  286. ' This method is a *lot* faster than using (int)Math.floor(x)
  287. ' private static int fastfloor(double x) {
  288. ' return x>0 ? (int)x : (int)x-1;}
  289.  
  290. ' private static double dot(int g[], double x, double y) {
  291. ' return g[0]*x + g[1]*y; }
  292. FUNCTION DotP2 (g%, x, y)
  293.     DotP2 = grad3(g%).x * x + grad3(g%).y * y
  295.  
  296. ' Map function I found or translated from somewhere.
  297. ' The Coding Train" guy on youtube, where I translated the rain code from explained it in one of his videos.
  298. FUNCTION map! (value!, minRange!, maxRange!, newMinRange!, newMaxRange!)
  299.     map! = ((value! - minRange!) / (maxRange! - minRange!)) * (newMaxRange! - newMinRange!) + newMinRange!
  301.  
  302.  
  303. ' private static double dot(int g[], double x, double y, double z, double w) {
  304. ' private static double dot(int g[], double x, double y) {
  305. ' return g[0]*x + g[1]*y; }
  306.  
  307.  
  308. ' private static double dot(int g[], double x, double y, double z) {
  309. ' return g[0]*x + g[1]*y + g[2]*z; }
  310.  
  311.  
  312. ' private static double dot(int g[], double x, double y, double z, double w) {
  313. ' return g[0]*x + g[1]*y + g[2]*z + g[3]*w; }
  314. ' return g[0]*x + g[1]*y + g[2]*z + g[3]*w; }
  315.  
  316.  
  317.  
  318. ' ******* NOTE: 3D portion below not ported yet ~Phlashlite *******
  319.  
  320.  
  321.  
  322. '' 3D simplex noise
  323. ' public static double noise(double xin, double yin, double zin) {
  324. ' double n0, n1, n2, n3;' Noise contributions from the four corners
  325.  
  326.  
  327. '' Skew the input space to determine which simplex cell we're in
  328. ' final double F3 = 1.0/3.0;
  329. ' double s = (xin+yin+zin)*F3;' Very nice and simple skew factor for 3D
  330. ' int i = fastfloor(xin+s);
  331. ' int j = fastfloor(yin+s);
  332. ' int k = fastfloor(zin+s);
  333. ' final double G3 = 1.0/6.0;' Very nice and simple unskew factor, too
  334. ' double t = (i+j+k)*G3;
  335. ' double X0 = i-t;' Unskew the cell origin back to (x,y,z) space
  336. ' double Y0 = j-t;
  337. ' double Z0 = k-t;
  338. ' double x0 = xin-X0;' The x,y,z distances from the cell origin
  339. ' double y0 = yin-Y0;
  340. ' double z0 = zin-Z0;
  341.  
  342.  
  343. '' For the 3D case, the simplex shape is a slightly irregular tetrahedron.
  344. '' Determine which simplex we are in.
  345. ' int i1, j1, k1;' Offsets for second corner of simplex in (i,j,k) coords
  346. ' int i2, j2, k2;' Offsets for third corner of simplex in (i,j,k) coords
  347. ' if(x0>=y0) {
  348. ' if(y0>=z0)
  349. ' { i1=1; j1=0; k1=0; i2=1; j2=1; k2=0; }' X Y Z order
  350. ' else if(x0>=z0) { i1=1; j1=0; k1=0; i2=1; j2=0; k2=1; }' X Z Y order
  351. ' else { i1=0; j1=0; k1=1; i2=1; j2=0; k2=1; }' Z X Y order
  352. ' }
  353. ' else {' x0<y0
  354. ' if(y0<z0) { i1=0; j1=0; k1=1; i2=0; j2=1; k2=1; }' Z Y X order
  355. ' else if(x0<z0) { i1=0; j1=1; k1=0; i2=0; j2=1; k2=1; }' Y Z X order
  356. ' else { i1=0; j1=1; k1=0; i2=1; j2=1; k2=0; }' Y X Z order
  357. ' }
  358.  
  359.  
  360. '' A step of (1,0,0) in (i,j,k) means a step of (1-c,-c,-c) in (x,y,z),
  361. '' a step of (0,1,0) in (i,j,k) means a step of (-c,1-c,-c) in (x,y,z), and
  362. '' a step of (0,0,1) in (i,j,k) means a step of (-c,-c,1-c) in (x,y,z), where
  363. '' c = 1/6.
  364. ' double x1 = x0 - i1 + G3;' Offsets for second corner in (x,y,z) coords
  365. ' double y1 = y0 - j1 + G3;
  366. ' double z1 = z0 - k1 + G3;
  367. ' double x2 = x0 - i2 + 2.0*G3;' Offsets for third corner in (x,y,z) coords
  368. ' double y2 = y0 - j2 + 2.0*G3;
  369. ' double z2 = z0 - k2 + 2.0*G3;
  370. ' double x3 = x0 - 1.0 + 3.0*G3;' Offsets for last corner in (x,y,z) coords
  371. ' double y3 = y0 - 1.0 + 3.0*G3;
  372. ' double z3 = z0 - 1.0 + 3.0*G3;
  373.  
  374.  
  375. '' Work out the hashed gradient indices of the four simplex corners
  376. ' int ii = i & 255;
  377. ' int jj = j & 255;
  378. ' int kk = k & 255;
  379. ' int gi0 = perm[ii+perm[jj+perm[kk]]] % 12;
  380. ' int gi1 = perm[ii+i1+perm[jj+j1+perm[kk+k1]]] % 12;
  381. ' int gi2 = perm[ii+i2+perm[jj+j2+perm[kk+k2]]] % 12;
  382. ' int gi3 = perm[ii+1+perm[jj+1+perm[kk+1]]] % 12;
  383.  
  384.  
  385. '' Calculate the contribution from the four corners
  386. ' double t0 = 0.6 - x0*x0 - y0*y0 - z0*z0;
  387. ' if(t0<0) n0 = 0.0;
  388. ' else {
  389. ' t0 *= t0;
  390. ' n0 = t0 * t0 * dot(grad3[gi0], x0, y0, z0);
  391. ' }
  392. ' double t1 = 0.6 - x1*x1 - y1*y1 - z1*z1;
  393. ' if(t1<0) n1 = 0.0;
  394. ' else {
  395. ' t1 *= t1;
  396. ' n1 = t1 * t1 * dot(grad3[gi1], x1, y1, z1);
  397. ' }
  398. ' double t2 = 0.6 - x2*x2 - y2*y2 - z2*z2;
  399. ' if(t2<0) n2 = 0.0;
  400. ' else {
  401. ' t2 *= t2;
  402. ' n2 = t2 * t2 * dot(grad3[gi2], x2, y2, z2);
  403. ' }
  404. ' double t3 = 0.6 - x3*x3 - y3*y3 - z3*z3;
  405. ' if(t3<0) n3 = 0.0;
  406. ' else {
  407. ' t3 *= t3;
  408. ' n3 = t3 * t3 * dot(grad3[gi3], x3, y3, z3);
  409. ' }
  410.  
  411.  
  412. '' Add contributions from each corner to get the final noise value.
  413. '' The result is scaled to stay just inside [-1,1]
  414. ' return 32.0*(n0 + n1 + n2 + n3);
  415. ' }
  416.  
  417.  
  418. '' 4D simplex noise
  419. ' double noise(double x, double y, double z, double w) {
  420.  
  421. '' The skewing and unskewing factors are hairy again for the 4D case
  422. ' final double F4 = (Math.sqrt(5.0)-1.0)/4.0;
  423. ' final double G4 = (5.0-Math.sqrt(5.0))/20.0;
  424. ' double n0, n1, n2, n3, n4;' Noise contributions from the five corners
  425.  
  426.  
  427. '' Skew the (x,y,z,w) space to determine which cell of 24 simplices we're in
  428. '  double s = (x + y + z + w) * F4;' Factor for 4D skewing
  429. ' int i = fastfloor(x + s);
  430. ' int j = fastfloor(y + s);
  431. ' int k = fastfloor(z + s);
  432. ' int l = fastfloor(w + s);
  433. ' double t = (i + j + k + l) * G4;' Factor for 4D unskewing
  434. ' double X0 = i - t;' Unskew the cell origin back to (x,y,z,w) space
  435. ' double Y0 = j - t;
  436. ' double Z0 = k - t;
  437. ' double W0 = l - t;
  438. ' double x0 = x - X0;' The x,y,z,w distances from the cell origin
  439. ' double y0 = y - Y0;
  440. ' double z0 = z - Z0;
  441. ' double w0 = w - W0;
  442.  
  443.  
  444. '' For the 4D case, the simplex is a 4D shape I won't even try to describe.
  445. '' To find out which of the 24 possible simplices we're in, we need to
  446. '' determine the magnitude ordering of x0, y0, z0 and w0.
  447. '' The method below is a good way of finding the ordering of x,y,z,w and
  448. '' then find the correct traversal order for the simplex we%u2019re in.
  449. '' First, six pair-wise comparisons are performed between each possible pair
  450. '' of the four coordinates, and the results are used to add up binary bits
  451. '' for an integer index.
  452. ' int c1 = (x0 > y0) ? 32 : 0;
  453. ' int c2 = (x0 > z0) ? 16 : 0;
  454. ' int c3 = (y0 > z0) ? 8 : 0;
  455. ' int c4 = (x0 > w0) ? 4 : 0;
  456. ' int c5 = (y0 > w0) ? 2 : 0;
  457. ' int c6 = (z0 > w0) ? 1 : 0;
  458. ' int c = c1 + c2 + c3 + c4 + c5 + c6;
  459. ' int i1, j1, k1, l1;' The integer offsets for the second simplex corner
  460. ' int i2, j2, k2, l2;' The integer offsets for the third simplex corner
  461. ' int i3, j3, k3, l3;' The integer offsets for the fourth simplex corner
  462.  
  463.  
  464. '' simplex[c] is a 4-vector with the numbers 0, 1, 2 and 3 in some order.
  465. '' Many values of c will never occur, since e.g. x>y>z>w makes x<z, y<w and x<w
  466. '' impossible. Only the 24 indices which have non-zero entries make any sense.
  467. '' We use a thresholding to set the coordinates in turn from the largest magnitude.
  468.  
  469.  
  470. '' The number 3 in the "simplex" array is at the position of the largest coordinate.
  471. ' i1 = simplex[c][0]>=3 ? 1 : 0;
  472. ' j1 = simplex[c][1]>=3 ? 1 : 0;
  473. ' k1 = simplex[c][2]>=3 ? 1 : 0;
  474. ' l1 = simplex[c][3]>=3 ? 1 : 0;
  475.  
  476.  
  477. '' The number 2 in the "simplex" array is at the second largest coordinate.
  478. ' i2 = simplex[c][0]>=2 ? 1 : 0;
  479. ' j2 = simplex[c][1]>=2 ? 1 : 0;
  480. ' k2 = simplex[c][2]>=2 ? 1 : 0;
  481. ' l2 = simplex[c][3]>=2 ? 1 : 0;
  482.  
  483.  
  484. '' The number 1 in the "simplex" array is at the second smallest coordinate.
  485. ' i3 = simplex[c][0]>=1 ? 1 : 0;
  486. ' j3 = simplex[c][1]>=1 ? 1 : 0;
  487. ' k3 = simplex[c][2]>=1 ? 1 : 0;
  488. ' l3 = simplex[c][3]>=1 ? 1 : 0;
  489.  
  490.  
  491. '' The fifth corner has all coordinate offsets = 1, so no need to look that up.
  492. ' double x1 = x0 - i1 + G4;' Offsets for second corner in (x,y,z,w) coords
  493. ' double y1 = y0 - j1 + G4;
  494. ' double z1 = z0 - k1 + G4;
  495. ' double w1 = w0 - l1 + G4;
  496. ' double x2 = x0 - i2 + 2.0*G4;' Offsets for third corner in (x,y,z,w) coords
  497. ' double y2 = y0 - j2 + 2.0*G4;
  498. ' double z2 = z0 - k2 + 2.0*G4;
  499. ' double w2 = w0 - l2 + 2.0*G4;
  500. ' double x3 = x0 - i3 + 3.0*G4;' Offsets for fourth corner in (x,y,z,w) coords
  501. ' double y3 = y0 - j3 + 3.0*G4;
  502. ' double z3 = z0 - k3 + 3.0*G4;
  503. ' double w3 = w0 - l3 + 3.0*G4;
  504. ' double x4 = x0 - 1.0 + 4.0*G4;' Offsets for last corner in (x,y,z,w) coords
  505. ' double y4 = y0 - 1.0 + 4.0*G4;
  506. ' double z4 = z0 - 1.0 + 4.0*G4;
  507. ' double w4 = w0 - 1.0 + 4.0*G4;
  508.  
  509.  
  510. '' Work out the hashed gradient indices of the five simplex corners
  511. ' int ii = i & 255;
  512. ' int jj = j & 255;
  513. ' int kk = k & 255;
  514. ' int ll = l & 255;
  515. ' int gi0 = perm[ii+perm[jj+perm[kk+perm[ll]]]] % 32;
  516. ' int gi1 = perm[ii+i1+perm[jj+j1+perm[kk+k1+perm[ll+l1]]]] % 32;
  517. ' int gi2 = perm[ii+i2+perm[jj+j2+perm[kk+k2+perm[ll+l2]]]] % 32;
  518. ' int gi3 = perm[ii+i3+perm[jj+j3+perm[kk+k3+perm[ll+l3]]]] % 32;
  519. ' int gi4 = perm[ii+1+perm[jj+1+perm[kk+1+perm[ll+1]]]] % 32;
  520.  
  521.  
  522. '' Calculate the contribution from the five corners
  523. ' double t0 = 0.6 - x0*x0 - y0*y0 - z0*z0 - w0*w0;
  524. ' if(t0<0) n0 = 0.0;
  525. ' else {
  526. ' t0 *= t0;
  527. ' n0 = t0 * t0 * dot(grad4[gi0], x0, y0, z0, w0);
  528. ' }
  529. ' double t1 = 0.6 - x1*x1 - y1*y1 - z1*z1 - w1*w1;
  530. ' if(t1<0) n1 = 0.0;
  531. ' else {
  532. ' t1 *= t1;
  533. ' n1 = t1 * t1 * dot(grad4[gi1], x1, y1, z1, w1);
  534. ' }
  535. ' double t2 = 0.6 - x2*x2 - y2*y2 - z2*z2 - w2*w2;
  536. ' if(t2<0) n2 = 0.0;
  537. ' else {
  538. ' t2 *= t2;
  539. ' n2 = t2 * t2 * dot(grad4[gi2], x2, y2, z2, w2);
  540. ' }
  541. ' double t3 = 0.6 - x3*x3 - y3*y3 - z3*z3 - w3*w3;
  542. ' if(t3<0) n3 = 0.0;
  543. ' else {
  544. ' t3 *= t3;
  545. ' n3 = t3 * t3 * dot(grad4[gi3], x3, y3, z3, w3);
  546. ' }
  547. ' double t4 = 0.6 - x4*x4 - y4*y4 - z4*z4 - w4*w4;
  548. ' if(t4<0) n4 = 0.0;
  549. ' else {
  550. ' t4 *= t4;
  551. ' n4 = t4 * t4 * dot(grad4[gi4], x4, y4, z4, w4);
  552. ' }
  553.  
  554.  
  555. '' Sum up and scale the result to cover the range [-1,1]
  556. ' return 27.0 * (n0 + n1 + n2 + n3 + n4);
  557.  
  558. 'private static int grad4[][]= {{0,1,1,1}, {0,1,1,-1}, {0,1,-1,1}, {0,1,-1,-1},
  559. '{0,-1,1,1}, {0,-1,1,-1}, {0,-1,-1,1}, {0,-1,-1,-1},
  560. '{1,0,1,1}, {1,0,1,-1}, {1,0,-1,1}, {1,0,-1,-1},
  561. '{-1,0,1,1}, {-1,0,1,-1}, {-1,0,-1,1}, {-1,0,-1,-1},
  562. '{1,1,0,1}, {1,1,0,-1}, {1,-1,0,1}, {1,-1,0,-1},
  563. '{-1,1,0,1}, {-1,1,0,-1}, {-1,-1,0,1}, {-1,-1,0,-1},
  564. '{1,1,1,0}, {1,1,-1,0}, {1,-1,1,0}, {1,-1,-1,0},
  565. '{-1,1,1,0}, {-1,1,-1,0}, {-1,-1,1,0}, {-1,-1,-1,0}};
  566.  
  567. '' A lookup table to traverse the simplex around a given point in 4D.
  568. '' Details can be found where this table is used, in the 4D noise method.
  569. ' private static int simplex[][] = {
  570. ' {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},
  571. ' {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},
  572. ' {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},
  573. ' {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},
  574. ' {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},
  575. ' {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},
  576. ' {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},
  577. ' {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}};
  578.  
  579.  
  580. '}
  581. '}
  582.  
  583.  
  584.  

I missed some integer assignments here:

"  '' Work out the hashed gradient indices of the three simplex corners
    ' int ii = i & 255;
    ii% = i AND 255
    ' int jj = j & 255;
    jj% = j AND 255
    ' int gi0 = perm[ii+perm[jj]] % 12;
    gi0% = perm(ii + perm(jj + j1)) MOD 12
    ' int gi1 = perm[ii+i1+perm[jj+j1]] % 12;
    gi1% = perm(ii + i1 + perm(jj + j1)) MOD 12
    ' int gi2 = perm[ii+1+perm[jj+1]] % 12;
    gi2% = perm(ii + 1 + perm(jj + 1)) MOD 12"

14
Programs / Simplex Noise Anyone?
« on: February 25, 2022, 12:49:00 pm »
Okay, I started trying to port a simplex noise function to QB64.  I have gotten some interesting results.  However, even though I believe the port of the function is right, I don't think I understand how to actually use it.  After working on it for several hours over several days, I am still at a loss.  If someone can enlighten me as to what I am doing wrong or not doing, I would appreciate the education.  NOTE: I have only ported the 2D section of the algorithm to this point.

Thank you!
~Phlashlite

Code: QB64: [Select]
  1. '$DEBUG
  2. _TITLE "Simplex noise port"
  3.  
  4. ' ported to QB64 by: Phlashlite, February 20, 2022
  5. '    from the paper: Simplex noise demystified
  6. '            author: Stefan Gustavson, Link”ping University, Sweden (stegu@itn.liu.se), 2005-03-22
  7. '               URL: https://weber.itn.liu.se/~stegu/simplexnoise/simplexnoise.pdf
  8. ' - Simplex noise has a lower computational complexity and requires fewer multiplications.
  9. ' - Simplex noise scales to higher dimensions (4D, 5D and up) with much less computational
  10. '   cost, the complexity is for dimensions instead of the of classic Noise.
  11. ' - Simplex noise has no noticeable directional artifacts.
  12. ' - Simplex noise has a well-defined and continuous gradient everywhere that can be computed
  13. '   quite cheaply.
  14. ' - Simplex noise is easy to implement in hardware
  15.  
  16.  
  17. SCREEN _NEWIMAGE(800, 600, 32)
  18.  
  19. DEFDBL A-Z
  20.  
  21. 'private static int grad3[][] = {{1,1,0},{-1,1,0},{1,-1,0},{-1,-1,0},{1,0,1},{-1,0,1},{1,0,-1},{-1,0,-1},{0,1,1},{0,-1,1},{0,1,-1},{0,-1,-1}};
  22. g3:
  23. DATA 1,1,0
  24. DATA -1,1,0
  25. DATA 1,-1,0
  26. DATA -1,-1,0
  27. DATA 1,0,1
  28. DATA -1,0,1
  29. DATA 1,0,-1
  30. DATA -1,0,-1
  31. DATA 0,1,1
  32. DATA 0,-1,1
  33. DATA 0,1,-1
  34. DATA 0,-1,-1
  35.  
  36. TYPE TriBit
  37.     x AS INTEGER
  38.     y AS INTEGER
  39.     z AS INTEGER
  41. DIM SHARED grad3(12) AS TriBit
  42.  
  44. FOR g% = 0 TO 11
  45.  
  46.     READ grad3(g%).x
  47.     READ grad3(g%).y
  48.     READ grad3(g%).z
  49.  
  50.     'PRINT grad3(g%).x, grad3(g%).y, grad3(g%).z
  51.  
  52. NEXT g%
  53.  
  54.  
  55. 'private static int p[] = {151,160,137,91,90,15,
  56. '131,13,201,95,96,53,194,233,7,225,140,36,103,30,69,142,8,99,37,240,21,10,23,
  57. '190,6,148,247,120,234,75,0,26,197,62,94,252,219,203,117,35,11,32,57,177,33,
  58. '88,237,149,56,87,174,20,125,136,171,168, 68,175,74,165,71,134,139,48,27,166,
  59. '77,146,158,231,83,111,229,122,60,211,133,230,220,105,92,41,55,46,245,40,244,
  60. '102,143,54,65,25,63,161,1,216,80,73,209,76,132,187,208,89,18,169,200,196,
  61. '135,130,116,188,159,86,164,100,109,198,173,186,3,64,52,217,226,250,124,123,
  62. '5,202,38,147,118,126,255,82,85,212,207,206,59,227,47,16,58,17,182,189,28,42,
  63. '223,183,170,213,119,248,152,2,44,154,163,70,221,153,101,155,167,43,172,9,
  64. '129,22,39,253,19,98,108,110,79,113,224,232,178,185,112,104,218,246,97,228,
  65. '251,34,242,193,238,210,144,12,191,179,162,241,81,51,145,235,249,14,239,107,
  66. '49,192,214,31,181,199,106,157,184,84,204,176,115,121,50,45,127,4,150,254,
  67. '138,236,205,93,222,114,67,29,24,72,243,141,128,195,78,66,215,61,156,180};
  68. p:
  69. DATA 151,160,137,091,090,015,131,013,201,095
  70. DATA 096,053,194,233,007,225,140,036,103,030
  71. DATA 069,142,008,099,037,240,021,010,023,190
  72. DATA 006,148,247,120,234,075,000,026,197,062
  73. DATA 094,252,219,203,117,035,011,032,057,177
  74. DATA 033,088,237,149,056,087,174,020,125,136
  75. DATA 171,168,068,175,074,165,071,134,139,048
  76. DATA 027,166,077,146,158,231,083,111,229,122
  77. DATA 060,211,133,230,220,105,092,041,055,046
  78. DATA 245,040,244,102,143,054,065,025,063,161
  79. DATA 001,216,080,073,209,076,132,187,208,089
  80. DATA 018,169,200,196,135,130,116,188,159,086
  81. DATA 164,100,109,198,173,186,003,064,052,217
  82. DATA 226,250,124,123,005,202,038,147,118,126
  83. DATA 255,082,085,212,207,206,059,227,047,016
  84. DATA 058,017,182,189,028,042,223,183,170,213
  85. DATA 119,248,152,002,044,154,163,070,221,153
  86. DATA 101,155,167,043,172,009,129,022,039,253
  87. DATA 019,098,108,110,079,113,224,232,178,185
  88. DATA 112,104,218,246,097,228,251,034,242,193
  89. DATA 238,210,144,012,191,179,162,241,081,051
  90. DATA 145,235,249,014,239,107,049,192,214,031
  91. DATA 181,199,106,157,184,084,204,176,115,121
  92. DATA 050,045,127,004,150,254,138,236,205,093
  93. DATA 222,114,067,029,024,072,243,141,128,195
  94. DATA 078,066,215,061,156,180
  95. DATA 151,160,137,091,090,015,131,013,201,095
  96. DATA 096,053,194,233,007,225,140,036,103,030
  97. DATA 069,142,008,099,037,240,021,010,023,190
  98. DATA 006,148,247,120,234,075,000,026,197,062
  99. DATA 094,252,219,203,117,035,011,032,057,177
  100. DATA 033,088,237,149,056,087,174,020,125,136
  101. DATA 171,168,068,175,074,165,071,134,139,048
  102. DATA 027,166,077,146,158,231,083,111,229,122
  103. DATA 060,211,133,230,220,105,092,041,055,046
  104. DATA 245,040,244,102,143,054,065,025,063,161
  105. DATA 001,216,080,073,209,076,132,187,208,089
  106. DATA 018,169,200,196,135,130,116,188,159,086
  107. DATA 164,100,109,198,173,186,003,064,052,217
  108. DATA 226,250,124,123,005,202,038,147,118,126
  109. DATA 255,082,085,212,207,206,059,227,047,016
  110. DATA 058,017,182,189,028,042,223,183,170,213
  111. DATA 119,248,152,002,044,154,163,070,221,153
  112. DATA 101,155,167,043,172,009,129,022,039,253
  113. DATA 019,098,108,110,079,113,224,232,178,185
  114. DATA 112,104,218,246,097,228,251,034,242,193
  115. DATA 238,210,144,012,191,179,162,241,081,051
  116. DATA 145,235,249,014,239,107,049,192,214,031
  117. DATA 181,199,106,157,184,084,204,176,115,121
  118. DATA 050,045,127,004,150,254,138,236,205,093
  119. DATA 222,114,067,029,024,072,243,141,128,195
  120. DATA 078,066,215,061,156,180
  121.  
  122.  
  123. 'To remove the need for index wrapping, double the permutation table length
  124. 'private static int perm[] = new int[512];
  126. DIM SHARED perm(512) AS INTEGER
  127.  
  128. 'static { for(int i=0; i<512; i++) perm[i]=p[i & 255]; }
  130. FOR i% = 0 TO 511
  131.     READ p(i%)
  132.     perm(i%) = p(i%) AND 255
  133.  
  134.     'PRINT perm(i%)
  136.  
  137.  
  138. '' 2D simplex noise************************************************************
  139.  
  140. ' final double F2 = 0.5*(Math.sqrt(3.0)-1.0);
  141. CONST F2 = .5 * (SQR(3) - 1)
  142. ' final double G2 = (3.0-Math.sqrt(3.0))/6.0;
  143. CONST G2 = (3 - SQR(3)) / 6
  144.  
  145. scale = .01
  146. '------------------------------------------------------------------------------
  147. FOR x% = 0 TO 800
  148.     FOR y% = 0 TO 600
  149.  
  150.         gs% = map!(noise2D(scale * x%, scale * y%), -1, 1, 0, 255)
  151.         c& = _RGB(gs%, gs%, gs%)
  152.         PSET (x%, y%), c&
  153.  
  154.         'PRINT INT(map!(noise2D(x%, y%), -1, 1, 0, 255));
  155.         'PRINT INT((noise2D(x%, y%) + 1) / 2.0 * 255.0);
  156.  
  157.     NEXT
  159. '------------------------------------------------------------------------------
  160.  
  161.  
  162. ' public static double noise(double xin, double yin) {
  163. FUNCTION noise2D (xin, yin)
  164.     ' double n0, n1, n2;' Noise contributions from the three corners
  165.     DIM n0, n1, n2
  166.  
  167.     '' Skew the input space to determine which simplex cell we're in
  168.     ' double s = (xin+yin)*F2;' Hairy factor for 2D
  169.     s = (xin + yin) * F2
  170.     ' int i = fastfloor(xin+s);
  171.     i% = INT(xin + s)
  172.     ' int j = fastfloor(yin+s);
  173.     j% = INT(yin + s)
  174.  
  175.  
  176.     ' double t = (i+j)*G2;
  177.     t = (i% + j%) * G2
  178.     ' double X0 = i-t;' Unskew the cell origin back to (x,y) space
  179.     BX0 = i% - t
  180.     ' double Y0 = j-t;
  181.     BY0 = j% - t
  182.     ' double x0 = xin-X0;' The x,y distances from the cell origin
  183.     x0 = xin - BX0
  184.     ' double y0 = yin-Y0;
  185.     y0 = yin - BY0
  186.  
  187.  
  188.     '' For the 2D case, the simplex shape is an equilateral triangle
  189.     '' Determine which simplex we are in.
  190.     ' int i1, j1;' Offsets for second (middle) corner of simplex in (i,j) coords
  191.     DIM AS INTEGER i1, j1
  192.     ' if(x0>y0) {i1=1; j1=0;}' lower triangle, XY order: (0,0)->(1,0)->(1,1)
  193.     IF x0 > y0 THEN
  194.         i1 = 1: j1 = 0
  195.         ' else {i1=0; j1=1;}' upper triangle, YX order: (0,0)->(0,1)->(1,1)
  196.     ELSE
  197.         i1 = 0: j1 = 1
  198.     END IF
  199.  
  200.  
  201.     '' A step of (1,0) in (i,j) means a step of (1-c,-c) in (x,y), and
  202.     '' a step of (0,1) in (i,j) means a step of (-c,1-c) in (x,y), where
  203.     '' c = (3-sqrt(3))/6 which is G2
  204.     '
  205.     ' double x1 = x0 - i1 + G2;' Offsets for middle corner in (x,y) unskewed coords
  206.     x1 = x0 - i1 + G2
  207.     ' double y1 = y0 - j1 + G2;
  208.     y1 = y0 - j1 + G2
  209.     ' double x2 = x0 - 1.0 + 2.0 * G2;' Offsets for last corner in (x,y) unskewed coords
  210.     x2 = x0 - 1 + 2 * G2
  211.     ' double y2 = y0 - 1.0 + 2.0 * G2;
  212.     y2 = y0 - 1 + 2 * G2
  213.  
  214.  
  215.     '' Work out the hashed gradient indices of the three simplex corners
  216.     ' int ii = i & 255;
  217.     ii% = i AND 255
  218.     ' int jj = j & 255;
  219.     jj% = j AND 255
  220.     ' int gi0 = perm[ii+perm[jj]] % 12;
  221.     gi0% = perm(ii + perm(jj + j1)) MOD 12
  222.     ' int gi1 = perm[ii+i1+perm[jj+j1]] % 12;
  223.     gi1% = perm(ii + i1 + perm(jj + j1)) MOD 12
  224.     ' int gi2 = perm[ii+1+perm[jj+1]] % 12;
  225.     gi2% = perm(ii + 1 + perm(jj + 1)) MOD 12
  226.  
  227.  
  228.     '' Calculate the contribution from the three corners
  229.     '
  230.     ' double t0 = 0.5 - x0*x0-y0*y0;
  231.     t0 = .5 - x0 * x0 - y0 * y0
  232.     ' if(t0<0) n0 = 0.0;
  233.     IF t0 < 0 THEN
  234.         n0 = 0
  235.         ' else {
  236.     ELSE
  237.         ' t0 *= t0;
  238.         t0 = t0 * t0
  239.         ' n0 = t0 * t0 * dot(grad3[gi0], x0, y0);' (x,y) of grad3 used for 2D gradient
  240.         n0 = t0 * t0 * DotP2(gi0%, x0, y0)
  241.         ' }
  242.     END IF
  243.  
  244.  
  245.     ' double t1 = 0.5 - x1*x1-y1*y1;
  246.     t1 = .5 - x1 * x1 - y1 * y1
  247.     ' if(t1<0) n1 = 0.0;
  248.     IF t1 < 0 THEN
  249.         n1 = 0
  250.         ' else {
  251.     ELSE
  252.         ' t1 *= t1;
  253.         t1 = t1 * t1
  254.         ' n1 = t1 * t1 * dot(grad3[gi1], x1, y1);
  255.         n1 = t1 * t1 * DotP2(gi1%, x1, y1)
  256.         ' }
  257.     END IF
  258.  
  259.  
  260.     ' double t2 = 0.5 - x2*x2-y2*y2;
  261.     t2 = .5 - x2 * x2 - y2 * y2
  262.     ' if(t2<0) n2 = 0.0;
  263.     IF t2 < 0 THEN
  264.         n2 = 0
  265.         ' else {
  266.     ELSE
  267.         ' t2 *= t2;
  268.         t2 = t2 * t2
  269.         ' n2 = t2 * t2 * dot(grad3[gi2], x2, y2);
  270.         n2 = t2 * t2 * DotP2(gi2%, x2, y2)
  271.         ' }
  272.     END IF
  273.  
  274.  
  275.     '' Add contributions from each corner to get the final noise value.
  276.     '' The result is scaled to return values in the interval [-1,1].
  277.     '
  278.     ' return 70.0 * (n0 + n1 + n2);
  279.     noise2D = 70 * (n0 + n1 + n2)
  280.  
  281.     ' }
  282.  
  284.  
  285.  
  286. ' This method is a *lot* faster than using (int)Math.floor(x)
  287. ' private static int fastfloor(double x) {
  288. ' return x>0 ? (int)x : (int)x-1;}
  289.  
  290. ' private static double dot(int g[], double x, double y) {
  291. ' return g[0]*x + g[1]*y; }
  292. FUNCTION DotP2 (g%, x, y)
  293.     DotP2 = grad3(g%).x * x + grad3(g%).y * y
  295.  
  296. ' Map function I found or translated from somewhere.
  297. ' The Coding Train" guy on youtube, where I translated the rain code from explained it in one of his videos.
  298. FUNCTION map! (value!, minRange!, maxRange!, newMinRange!, newMaxRange!)
  299.     map! = ((value! - minRange!) / (maxRange! - minRange!)) * (newMaxRange! - newMinRange!) + newMinRange!
  301.  
  302.  
  303. ' private static double dot(int g[], double x, double y, double z, double w) {
  304. ' private static double dot(int g[], double x, double y) {
  305. ' return g[0]*x + g[1]*y; }
  306.  
  307.  
  308. ' private static double dot(int g[], double x, double y, double z) {
  309. ' return g[0]*x + g[1]*y + g[2]*z; }
  310.  
  311.  
  312. ' private static double dot(int g[], double x, double y, double z, double w) {
  313. ' return g[0]*x + g[1]*y + g[2]*z + g[3]*w; }
  314. ' return g[0]*x + g[1]*y + g[2]*z + g[3]*w; }
  315.  
  316.  
  317.  
  318. ' ******* NOTE: 3D portion below not ported yet ~Phlashlite *******
  319.  
  320.  
  321.  
  322. '' 3D simplex noise
  323. ' public static double noise(double xin, double yin, double zin) {
  324. ' double n0, n1, n2, n3;' Noise contributions from the four corners
  325.  
  326.  
  327. '' Skew the input space to determine which simplex cell we're in
  328. ' final double F3 = 1.0/3.0;
  329. ' double s = (xin+yin+zin)*F3;' Very nice and simple skew factor for 3D
  330. ' int i = fastfloor(xin+s);
  331. ' int j = fastfloor(yin+s);
  332. ' int k = fastfloor(zin+s);
  333. ' final double G3 = 1.0/6.0;' Very nice and simple unskew factor, too
  334. ' double t = (i+j+k)*G3;
  335. ' double X0 = i-t;' Unskew the cell origin back to (x,y,z) space
  336. ' double Y0 = j-t;
  337. ' double Z0 = k-t;
  338. ' double x0 = xin-X0;' The x,y,z distances from the cell origin
  339. ' double y0 = yin-Y0;
  340. ' double z0 = zin-Z0;
  341.  
  342.  
  343. '' For the 3D case, the simplex shape is a slightly irregular tetrahedron.
  344. '' Determine which simplex we are in.
  345. ' int i1, j1, k1;' Offsets for second corner of simplex in (i,j,k) coords
  346. ' int i2, j2, k2;' Offsets for third corner of simplex in (i,j,k) coords
  347. ' if(x0>=y0) {
  348. ' if(y0>=z0)
  349. ' { i1=1; j1=0; k1=0; i2=1; j2=1; k2=0; }' X Y Z order
  350. ' else if(x0>=z0) { i1=1; j1=0; k1=0; i2=1; j2=0; k2=1; }' X Z Y order
  351. ' else { i1=0; j1=0; k1=1; i2=1; j2=0; k2=1; }' Z X Y order
  352. ' }
  353. ' else {' x0<y0
  354. ' if(y0<z0) { i1=0; j1=0; k1=1; i2=0; j2=1; k2=1; }' Z Y X order
  355. ' else if(x0<z0) { i1=0; j1=1; k1=0; i2=0; j2=1; k2=1; }' Y Z X order
  356. ' else { i1=0; j1=1; k1=0; i2=1; j2=1; k2=0; }' Y X Z order
  357. ' }
  358.  
  359.  
  360. '' A step of (1,0,0) in (i,j,k) means a step of (1-c,-c,-c) in (x,y,z),
  361. '' a step of (0,1,0) in (i,j,k) means a step of (-c,1-c,-c) in (x,y,z), and
  362. '' a step of (0,0,1) in (i,j,k) means a step of (-c,-c,1-c) in (x,y,z), where
  363. '' c = 1/6.
  364. ' double x1 = x0 - i1 + G3;' Offsets for second corner in (x,y,z) coords
  365. ' double y1 = y0 - j1 + G3;
  366. ' double z1 = z0 - k1 + G3;
  367. ' double x2 = x0 - i2 + 2.0*G3;' Offsets for third corner in (x,y,z) coords
  368. ' double y2 = y0 - j2 + 2.0*G3;
  369. ' double z2 = z0 - k2 + 2.0*G3;
  370. ' double x3 = x0 - 1.0 + 3.0*G3;' Offsets for last corner in (x,y,z) coords
  371. ' double y3 = y0 - 1.0 + 3.0*G3;
  372. ' double z3 = z0 - 1.0 + 3.0*G3;
  373.  
  374.  
  375. '' Work out the hashed gradient indices of the four simplex corners
  376. ' int ii = i & 255;
  377. ' int jj = j & 255;
  378. ' int kk = k & 255;
  379. ' int gi0 = perm[ii+perm[jj+perm[kk]]] % 12;
  380. ' int gi1 = perm[ii+i1+perm[jj+j1+perm[kk+k1]]] % 12;
  381. ' int gi2 = perm[ii+i2+perm[jj+j2+perm[kk+k2]]] % 12;
  382. ' int gi3 = perm[ii+1+perm[jj+1+perm[kk+1]]] % 12;
  383.  
  384.  
  385. '' Calculate the contribution from the four corners
  386. ' double t0 = 0.6 - x0*x0 - y0*y0 - z0*z0;
  387. ' if(t0<0) n0 = 0.0;
  388. ' else {
  389. ' t0 *= t0;
  390. ' n0 = t0 * t0 * dot(grad3[gi0], x0, y0, z0);
  391. ' }
  392. ' double t1 = 0.6 - x1*x1 - y1*y1 - z1*z1;
  393. ' if(t1<0) n1 = 0.0;
  394. ' else {
  395. ' t1 *= t1;
  396. ' n1 = t1 * t1 * dot(grad3[gi1], x1, y1, z1);
  397. ' }
  398. ' double t2 = 0.6 - x2*x2 - y2*y2 - z2*z2;
  399. ' if(t2<0) n2 = 0.0;
  400. ' else {
  401. ' t2 *= t2;
  402. ' n2 = t2 * t2 * dot(grad3[gi2], x2, y2, z2);
  403. ' }
  404. ' double t3 = 0.6 - x3*x3 - y3*y3 - z3*z3;
  405. ' if(t3<0) n3 = 0.0;
  406. ' else {
  407. ' t3 *= t3;
  408. ' n3 = t3 * t3 * dot(grad3[gi3], x3, y3, z3);
  409. ' }
  410.  
  411.  
  412. '' Add contributions from each corner to get the final noise value.
  413. '' The result is scaled to stay just inside [-1,1]
  414. ' return 32.0*(n0 + n1 + n2 + n3);
  415. ' }
  416.  
  417.  
  418. '' 4D simplex noise
  419. ' double noise(double x, double y, double z, double w) {
  420.  
  421. '' The skewing and unskewing factors are hairy again for the 4D case
  422. ' final double F4 = (Math.sqrt(5.0)-1.0)/4.0;
  423. ' final double G4 = (5.0-Math.sqrt(5.0))/20.0;
  424. ' double n0, n1, n2, n3, n4;' Noise contributions from the five corners
  425.  
  426.  
  427. '' Skew the (x,y,z,w) space to determine which cell of 24 simplices we're in
  428. '  double s = (x + y + z + w) * F4;' Factor for 4D skewing
  429. ' int i = fastfloor(x + s);
  430. ' int j = fastfloor(y + s);
  431. ' int k = fastfloor(z + s);
  432. ' int l = fastfloor(w + s);
  433. ' double t = (i + j + k + l) * G4;' Factor for 4D unskewing
  434. ' double X0 = i - t;' Unskew the cell origin back to (x,y,z,w) space
  435. ' double Y0 = j - t;
  436. ' double Z0 = k - t;
  437. ' double W0 = l - t;
  438. ' double x0 = x - X0;' The x,y,z,w distances from the cell origin
  439. ' double y0 = y - Y0;
  440. ' double z0 = z - Z0;
  441. ' double w0 = w - W0;
  442.  
  443.  
  444. '' For the 4D case, the simplex is a 4D shape I won't even try to describe.
  445. '' To find out which of the 24 possible simplices we're in, we need to
  446. '' determine the magnitude ordering of x0, y0, z0 and w0.
  447. '' The method below is a good way of finding the ordering of x,y,z,w and
  448. '' then find the correct traversal order for the simplex we’re in.
  449. '' First, six pair-wise comparisons are performed between each possible pair
  450. '' of the four coordinates, and the results are used to add up binary bits
  451. '' for an integer index.
  452. ' int c1 = (x0 > y0) ? 32 : 0;
  453. ' int c2 = (x0 > z0) ? 16 : 0;
  454. ' int c3 = (y0 > z0) ? 8 : 0;
  455. ' int c4 = (x0 > w0) ? 4 : 0;
  456. ' int c5 = (y0 > w0) ? 2 : 0;
  457. ' int c6 = (z0 > w0) ? 1 : 0;
  458. ' int c = c1 + c2 + c3 + c4 + c5 + c6;
  459. ' int i1, j1, k1, l1;' The integer offsets for the second simplex corner
  460. ' int i2, j2, k2, l2;' The integer offsets for the third simplex corner
  461. ' int i3, j3, k3, l3;' The integer offsets for the fourth simplex corner
  462.  
  463.  
  464. '' simplex[c] is a 4-vector with the numbers 0, 1, 2 and 3 in some order.
  465. '' Many values of c will never occur, since e.g. x>y>z>w makes x<z, y<w and x<w
  466. '' impossible. Only the 24 indices which have non-zero entries make any sense.
  467. '' We use a thresholding to set the coordinates in turn from the largest magnitude.
  468.  
  469.  
  470. '' The number 3 in the "simplex" array is at the position of the largest coordinate.
  471. ' i1 = simplex[c][0]>=3 ? 1 : 0;
  472. ' j1 = simplex[c][1]>=3 ? 1 : 0;
  473. ' k1 = simplex[c][2]>=3 ? 1 : 0;
  474. ' l1 = simplex[c][3]>=3 ? 1 : 0;
  475.  
  476.  
  477. '' The number 2 in the "simplex" array is at the second largest coordinate.
  478. ' i2 = simplex[c][0]>=2 ? 1 : 0;
  479. ' j2 = simplex[c][1]>=2 ? 1 : 0;
  480. ' k2 = simplex[c][2]>=2 ? 1 : 0;
  481. ' l2 = simplex[c][3]>=2 ? 1 : 0;
  482.  
  483.  
  484. '' The number 1 in the "simplex" array is at the second smallest coordinate.
  485. ' i3 = simplex[c][0]>=1 ? 1 : 0;
  486. ' j3 = simplex[c][1]>=1 ? 1 : 0;
  487. ' k3 = simplex[c][2]>=1 ? 1 : 0;
  488. ' l3 = simplex[c][3]>=1 ? 1 : 0;
  489.  
  490.  
  491. '' The fifth corner has all coordinate offsets = 1, so no need to look that up.
  492. ' double x1 = x0 - i1 + G4;' Offsets for second corner in (x,y,z,w) coords
  493. ' double y1 = y0 - j1 + G4;
  494. ' double z1 = z0 - k1 + G4;
  495. ' double w1 = w0 - l1 + G4;
  496. ' double x2 = x0 - i2 + 2.0*G4;' Offsets for third corner in (x,y,z,w) coords
  497. ' double y2 = y0 - j2 + 2.0*G4;
  498. ' double z2 = z0 - k2 + 2.0*G4;
  499. ' double w2 = w0 - l2 + 2.0*G4;
  500. ' double x3 = x0 - i3 + 3.0*G4;' Offsets for fourth corner in (x,y,z,w) coords
  501. ' double y3 = y0 - j3 + 3.0*G4;
  502. ' double z3 = z0 - k3 + 3.0*G4;
  503. ' double w3 = w0 - l3 + 3.0*G4;
  504. ' double x4 = x0 - 1.0 + 4.0*G4;' Offsets for last corner in (x,y,z,w) coords
  505. ' double y4 = y0 - 1.0 + 4.0*G4;
  506. ' double z4 = z0 - 1.0 + 4.0*G4;
  507. ' double w4 = w0 - 1.0 + 4.0*G4;
  508.  
  509.  
  510. '' Work out the hashed gradient indices of the five simplex corners
  511. ' int ii = i & 255;
  512. ' int jj = j & 255;
  513. ' int kk = k & 255;
  514. ' int ll = l & 255;
  515. ' int gi0 = perm[ii+perm[jj+perm[kk+perm[ll]]]] % 32;
  516. ' int gi1 = perm[ii+i1+perm[jj+j1+perm[kk+k1+perm[ll+l1]]]] % 32;
  517. ' int gi2 = perm[ii+i2+perm[jj+j2+perm[kk+k2+perm[ll+l2]]]] % 32;
  518. ' int gi3 = perm[ii+i3+perm[jj+j3+perm[kk+k3+perm[ll+l3]]]] % 32;
  519. ' int gi4 = perm[ii+1+perm[jj+1+perm[kk+1+perm[ll+1]]]] % 32;
  520.  
  521.  
  522. '' Calculate the contribution from the five corners
  523. ' double t0 = 0.6 - x0*x0 - y0*y0 - z0*z0 - w0*w0;
  524. ' if(t0<0) n0 = 0.0;
  525. ' else {
  526. ' t0 *= t0;
  527. ' n0 = t0 * t0 * dot(grad4[gi0], x0, y0, z0, w0);
  528. ' }
  529. ' double t1 = 0.6 - x1*x1 - y1*y1 - z1*z1 - w1*w1;
  530. ' if(t1<0) n1 = 0.0;
  531. ' else {
  532. ' t1 *= t1;
  533. ' n1 = t1 * t1 * dot(grad4[gi1], x1, y1, z1, w1);
  534. ' }
  535. ' double t2 = 0.6 - x2*x2 - y2*y2 - z2*z2 - w2*w2;
  536. ' if(t2<0) n2 = 0.0;
  537. ' else {
  538. ' t2 *= t2;
  539. ' n2 = t2 * t2 * dot(grad4[gi2], x2, y2, z2, w2);
  540. ' }
  541. ' double t3 = 0.6 - x3*x3 - y3*y3 - z3*z3 - w3*w3;
  542. ' if(t3<0) n3 = 0.0;
  543. ' else {
  544. ' t3 *= t3;
  545. ' n3 = t3 * t3 * dot(grad4[gi3], x3, y3, z3, w3);
  546. ' }
  547. ' double t4 = 0.6 - x4*x4 - y4*y4 - z4*z4 - w4*w4;
  548. ' if(t4<0) n4 = 0.0;
  549. ' else {
  550. ' t4 *= t4;
  551. ' n4 = t4 * t4 * dot(grad4[gi4], x4, y4, z4, w4);
  552. ' }
  553.  
  554.  
  555. '' Sum up and scale the result to cover the range [-1,1]
  556. ' return 27.0 * (n0 + n1 + n2 + n3 + n4);
  557.  
  558. 'private static int grad4[][]= {{0,1,1,1}, {0,1,1,-1}, {0,1,-1,1}, {0,1,-1,-1},
  559. '{0,-1,1,1}, {0,-1,1,-1}, {0,-1,-1,1}, {0,-1,-1,-1},
  560. '{1,0,1,1}, {1,0,1,-1}, {1,0,-1,1}, {1,0,-1,-1},
  561. '{-1,0,1,1}, {-1,0,1,-1}, {-1,0,-1,1}, {-1,0,-1,-1},
  562. '{1,1,0,1}, {1,1,0,-1}, {1,-1,0,1}, {1,-1,0,-1},
  563. '{-1,1,0,1}, {-1,1,0,-1}, {-1,-1,0,1}, {-1,-1,0,-1},
  564. '{1,1,1,0}, {1,1,-1,0}, {1,-1,1,0}, {1,-1,-1,0},
  565. '{-1,1,1,0}, {-1,1,-1,0}, {-1,-1,1,0}, {-1,-1,-1,0}};
  566.  
  567. '' A lookup table to traverse the simplex around a given point in 4D.
  568. '' Details can be found where this table is used, in the 4D noise method.
  569. ' private static int simplex[][] = {
  570. ' {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},
  571. ' {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},
  572. ' {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},
  573. ' {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},
  574. ' {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},
  575. ' {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},
  576. ' {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},
  577. ' {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}};
  578.  
  579.  
  580. '}
  581. '}
  582.  
  583.  
  584.  

15
Programs / Re: Little break to visualize prime numbers in a million real numbers.
« on: February 06, 2022, 01:23:32 pm »
Quote from: dbox on February 06, 2022, 01:10:42 pm
I think I can see Agent Smith.

That's a different program :)

Pages: [1] 2 3 4