visus
/
framework-arduinoteensy-cxx20
Seguir 1
Destacar 0
Fork 0
Código Incidencias 0 Pull Requests 0 Lanzamientos 0 Wiki Actividad
PlatformIO package of the Teensy core framework compatible with GCC 10 & C++20
No puede seleccionar más de 25 temas Los temas deben comenzar con una letra o número, pueden incluir guiones ('-') y pueden tener hasta 35 caracteres de largo.
2 Commits
1 Rama
Árbol: daa7cc5a30
Ramas Etiquetas
${ item.name }
Crear rama ${ searchTerm }
desde 'daa7cc5a30'
${ noResults }
framework-arduinoteensy-cxx20/libraries/FastLED/noise.cpp

808 líneas
23KB
Original Blame Histórico 

  1. #define FASTLED_INTERNAL

  2. #include "FastLED.h"

  3. #include <string.h>

  4. 

  5. FASTLED_NAMESPACE_BEGIN

  6. 

  7. #define P(x) FL_PGM_READ_BYTE_NEAR(p + x)

  8. 

  9. FL_PROGMEM static uint8_t const p[] = { 151,160,137,91,90,15,

  10.    131,13,201,95,96,53,194,233,7,225,140,36,103,30,69,142,8,99,37,240,21,10,23,

  11.    190, 6,148,247,120,234,75,0,26,197,62,94,252,219,203,117,35,11,32,57,177,33,

  12.    88,237,149,56,87,174,20,125,136,171,168, 68,175,74,165,71,134,139,48,27,166,

  13.    77,146,158,231,83,111,229,122,60,211,133,230,220,105,92,41,55,46,245,40,244,

  14.    102,143,54, 65,25,63,161, 1,216,80,73,209,76,132,187,208, 89,18,169,200,196,

  15.    135,130,116,188,159,86,164,100,109,198,173,186, 3,64,52,217,226,250,124,123,

  16.    5,202,38,147,118,126,255,82,85,212,207,206,59,227,47,16,58,17,182,189,28,42,

  17.    223,183,170,213,119,248,152, 2,44,154,163, 70,221,153,101,155,167, 43,172,9,

  18.    129,22,39,253, 19,98,108,110,79,113,224,232,178,185, 112,104,218,246,97,228,

  19.    251,34,242,193,238,210,144,12,191,179,162,241, 81,51,145,235,249,14,239,107,

  20.    49,192,214, 31,181,199,106,157,184, 84,204,176,115,121,50,45,127, 4,150,254,

  21.    138,236,205,93,222,114,67,29,24,72,243,141,128,195,78,66,215,61,156,180,151

  22.    };

  23. 

  24. 

  25. #if FASTLED_NOISE_ALLOW_AVERAGE_TO_OVERFLOW == 1

  26. #define AVG15(U,V) (((U)+(V)) >> 1)

  27. #else

  28. // See if we should use the inlined avg15 for AVR with MUL instruction

  29. #if defined(__AVR__) && (LIB8_ATTINY == 0)

  30. #define AVG15(U,V) (avg15_inline_avr_mul((U),(V)))

  31. // inlined copy of avg15 for AVR with MUL instruction; cloned from math8.h

  32. // Forcing this inline in the 3-D 16bit noise produces a 12% speedup overall,

  33. // at a cost of just +8 bytes of net code size.

  34. static int16_t inline __attribute__((always_inline))  avg15_inline_avr_mul( int16_t i, int16_t j)

  35. {

  36.     asm volatile(

  37.                  /* first divide j by 2, throwing away lowest bit */

  38.                  "asr %B[j]          \n\t"

  39.                  "ror %A[j]          \n\t"

  40.                  /* now divide i by 2, with lowest bit going into C */

  41.                  "asr %B[i]          \n\t"

  42.                  "ror %A[i]          \n\t"

  43.                  /* add j + C to i */

  44.                  "adc %A[i], %A[j]   \n\t"

  45.                  "adc %B[i], %B[j]   \n\t"

  46.                  : [i] "+a" (i)

  47.                  : [j] "a"  (j) );

  48.     return i;

  49. }

  50. #else

  51. #define AVG15(U,V) (avg15((U),(V)))

  52. #endif

  53. #endif

  54. 

  55. // See fastled_config.h for notes on this; 

  56. // "#define FASTLED_NOISE_FIXED 1" is the correct value

  57. #if FASTLED_NOISE_FIXED == 0

  58. #define EASE8(x)  (FADE(x) )

  59. #define EASE16(x) (FADE(x) )

  60. #else

  61. #define EASE8(x)  (ease8InOutQuad(x) )

  62. #define EASE16(x) (ease16InOutQuad(x))

  63. #endif

  64. //

  65. // #define FADE_12

  66. #define FADE_16

  67. 

  68. #ifdef FADE_12

  69. #define FADE logfade12

  70. #define LERP(a,b,u) lerp15by12(a,b,u)

  71. #else

  72. #define FADE(x) scale16(x,x)

  73. #define LERP(a,b,u) lerp15by16(a,b,u)

  74. #endif

  75. static int16_t inline __attribute__((always_inline))  grad16(uint8_t hash, int16_t x, int16_t y, int16_t z) {

  76. #if 0

  77.   switch(hash & 0xF) {

  78.     case  0: return (( x) + ( y))>>1;

  79.     case  1: return ((-x) + ( y))>>1;

  80.     case  2: return (( x) + (-y))>>1;

  81.     case  3: return ((-x) + (-y))>>1;

  82.     case  4: return (( x) + ( z))>>1;

  83.     case  5: return ((-x) + ( z))>>1;

  84.     case  6: return (( x) + (-z))>>1;

  85.     case  7: return ((-x) + (-z))>>1;

  86.     case  8: return (( y) + ( z))>>1;

  87.     case  9: return ((-y) + ( z))>>1;

  88.     case 10: return (( y) + (-z))>>1;

  89.     case 11: return ((-y) + (-z))>>1;

  90.     case 12: return (( y) + ( x))>>1;

  91.     case 13: return ((-y) + ( z))>>1;

  92.     case 14: return (( y) + (-x))>>1;

  93.     case 15: return ((-y) + (-z))>>1;

  94.   }

  95. #else

  96.   hash = hash&15;

  97.   int16_t u = hash<8?x:y;

  98.   int16_t v = hash<4?y:hash==12||hash==14?x:z;

  99.   if(hash&1) { u = -u; }

  100.   if(hash&2) { v = -v; }

  101. 

  102.   return AVG15(u,v);

  103. #endif

  104. }

  105. 

  106. static int16_t inline __attribute__((always_inline)) grad16(uint8_t hash, int16_t x, int16_t y) {

  107.   hash = hash & 7;

  108.   int16_t u,v;

  109.   if(hash < 4) { u = x; v = y; } else { u = y; v = x; }

  110.   if(hash&1) { u = -u; }

  111.   if(hash&2) { v = -v; }

  112. 

  113.   return AVG15(u,v);

  114. }

  115. 

  116. static int16_t inline __attribute__((always_inline)) grad16(uint8_t hash, int16_t x) {

  117.   hash = hash & 15;

  118.   int16_t u,v;

  119.   if(hash > 8) { u=x;v=x; }

  120.   else if(hash < 4) { u=x;v=1; }

  121.   else { u=1;v=x; }

  122.   if(hash&1) { u = -u; }

  123.   if(hash&2) { v = -v; }

  124. 

  125.   return AVG15(u,v);

  126. }

  127. 

  128. // selectBasedOnHashBit performs this:

  129. //   result = (hash & (1<<bitnumber)) ? a : b

  130. // but with an AVR asm version that's smaller and quicker than C

  131. // (and probably not worth including in lib8tion)

  132. static int8_t inline __attribute__((always_inline)) selectBasedOnHashBit(uint8_t hash, uint8_t bitnumber, int8_t a, int8_t b) {

  133. 	int8_t result;

  134. #if !defined(__AVR__)

  135. 	result = (hash & (1<<bitnumber)) ? a : b;

  136. #else

  137. 	asm volatile(

  138. 		"mov %[result],%[a]          \n\t"

  139. 		"sbrs %[hash],%[bitnumber]   \n\t"

  140. 		"mov %[result],%[b]          \n\t"

  141. 		: [result] "=r" (result)

  142. 		: [hash] "r" (hash),

  143. 		  [bitnumber] "M" (bitnumber),

  144.           [a] "r" (a),

  145. 		  [b] "r" (b)

  146. 		);

  147. #endif

  148. 	return result;

  149. }

  150. 

  151. static int8_t  inline __attribute__((always_inline)) grad8(uint8_t hash, int8_t x, int8_t y, int8_t z) {

  152. #if 0

  153.   switch(hash & 0xF) {

  154.     case  0: return (( x) + ( y))>>1;

  155.     case  1: return ((-x) + ( y))>>1;

  156.     case  2: return (( x) + (-y))>>1;

  157.     case  3: return ((-x) + (-y))>>1;

  158.     case  4: return (( x) + ( z))>>1;

  159.     case  5: return ((-x) + ( z))>>1;

  160.     case  6: return (( x) + (-z))>>1;

  161.     case  7: return ((-x) + (-z))>>1;

  162.     case  8: return (( y) + ( z))>>1;

  163.     case  9: return ((-y) + ( z))>>1;

  164.     case 10: return (( y) + (-z))>>1;

  165.     case 11: return ((-y) + (-z))>>1;

  166.     case 12: return (( y) + ( x))>>1;

  167.     case 13: return ((-y) + ( z))>>1;

  168.     case 14: return (( y) + (-x))>>1;

  169.     case 15: return ((-y) + (-z))>>1;

  170.   }

  171. #else

  172. 

  173.   hash &= 0xF;

  174. 

  175.   int8_t u, v;

  176.   //u = (hash&8)?y:x;

  177.   u = selectBasedOnHashBit( hash, 3, y, x);

  178. 

  179. #if 1

  180.   v = hash<4?y:hash==12||hash==14?x:z;

  181. #else

  182.   // Verbose version for analysis; generates idenitical code.

  183.   if( hash < 4) { // 00 01 02 03

  184. 	  v = y;

  185.   } else {

  186.       if( hash==12 || hash==14) { // 0C 0E

  187. 		  v = x;

  188. 	  } else {

  189. 		  v = z; // 04 05 06 07   08 09 0A 0B   0D  0F

  190. 	  }

  191.   }

  192. #endif

  193. 

  194.   if(hash&1) { u = -u; }

  195.   if(hash&2) { v = -v; }

  196. 

  197.   return avg7(u,v);

  198. #endif

  199. }

  200. 

  201. static int8_t inline __attribute__((always_inline)) grad8(uint8_t hash, int8_t x, int8_t y)

  202. {

  203.   // since the tests below can be done bit-wise on the bottom

  204.   // three bits, there's no need to mask off the higher bits

  205.   //  hash = hash & 7;

  206. 

  207.   int8_t u,v;

  208.   if( hash & 4) {

  209. 	  u = y; v = x;

  210.   } else {

  211. 	  u = x; v = y;

  212.   }

  213. 

  214.   if(hash&1) { u = -u; }

  215.   if(hash&2) { v = -v; }

  216. 

  217.   return avg7(u,v);

  218. }

  219. 

  220. static int8_t inline __attribute__((always_inline)) grad8(uint8_t hash, int8_t x)

  221. {

  222.   // since the tests below can be done bit-wise on the bottom

  223.   // four bits, there's no need to mask off the higher bits

  224.   //	hash = hash & 15;

  225. 

  226.   int8_t u,v;

  227.   if(hash & 8) {

  228. 	  u=x; v=x;

  229.   } else {

  230. 	if(hash & 4) {

  231. 		u=1; v=x;

  232. 	} else {

  233. 		u=x; v=1;

  234. 	}

  235.   }

  236. 

  237.   if(hash&1) { u = -u; }

  238.   if(hash&2) { v = -v; }

  239. 

  240.   return avg7(u,v);

  241. }

  242. 

  243. 

  244. #ifdef FADE_12

  245. uint16_t logfade12(uint16_t val) {

  246.   return scale16(val,val)>>4;

  247. }

  248. 

  249. static int16_t inline __attribute__((always_inline)) lerp15by12( int16_t a, int16_t b, fract16 frac)

  250. {

  251.    //if(1) return (lerp(frac,a,b));

  252.     int16_t result;

  253.     if( b > a) {

  254.         uint16_t delta = b - a;

  255.         uint16_t scaled = scale16(delta,frac<<4);

  256.         result = a + scaled;

  257.      } else {

  258.         uint16_t delta = a - b;

  259.         uint16_t scaled = scale16(delta,frac<<4);

  260.       result = a - scaled;

  261.      }

  262.     return result;

  263. }

  264. #endif

  265. 

  266. static int8_t inline __attribute__((always_inline)) lerp7by8( int8_t a, int8_t b, fract8 frac)

  267. {

  268.     // int8_t delta = b - a;

  269.     // int16_t prod = (uint16_t)delta * (uint16_t)frac;

  270.     // int8_t scaled = prod >> 8;

  271.     // int8_t result = a + scaled;

  272.     // return result;

  273.     int8_t result;

  274.     if( b > a) {

  275.         uint8_t delta = b - a;

  276.         uint8_t scaled = scale8( delta, frac);

  277.         result = a + scaled;

  278.     } else {

  279.         uint8_t delta = a - b;

  280.         uint8_t scaled = scale8( delta, frac);

  281.         result = a - scaled;

  282.     }

  283.     return result;

  284. }

  285. 

  286. int16_t inoise16_raw(uint32_t x, uint32_t y, uint32_t z)

  287. {

  288.   // Find the unit cube containing the point

  289.   uint8_t X = (x>>16)&0xFF;

  290.   uint8_t Y = (y>>16)&0xFF;

  291.   uint8_t Z = (z>>16)&0xFF;

  292. 

  293.   // Hash cube corner coordinates

  294.   uint8_t A = P(X)+Y;

  295.   uint8_t AA = P(A)+Z;

  296.   uint8_t AB = P(A+1)+Z;

  297.   uint8_t B = P(X+1)+Y;

  298.   uint8_t BA = P(B) + Z;

  299.   uint8_t BB = P(B+1)+Z;

  300. 

  301.   // Get the relative position of the point in the cube

  302.   uint16_t u = x & 0xFFFF;

  303.   uint16_t v = y & 0xFFFF;

  304.   uint16_t w = z & 0xFFFF;

  305. 

  306.   // Get a signed version of the above for the grad function

  307.   int16_t xx = (u >> 1) & 0x7FFF;

  308.   int16_t yy = (v >> 1) & 0x7FFF;

  309.   int16_t zz = (w >> 1) & 0x7FFF;

  310.   uint16_t N = 0x8000L;

  311. 

  312.   u = EASE16(u); v = EASE16(v); w = EASE16(w);

  313. 

  314.   // skip the log fade adjustment for the moment, otherwise here we would

  315.   // adjust fade values for u,v,w

  316.   int16_t X1 = LERP(grad16(P(AA), xx, yy, zz), grad16(P(BA), xx - N, yy, zz), u);

  317.   int16_t X2 = LERP(grad16(P(AB), xx, yy-N, zz), grad16(P(BB), xx - N, yy - N, zz), u);

  318.   int16_t X3 = LERP(grad16(P(AA+1), xx, yy, zz-N), grad16(P(BA+1), xx - N, yy, zz-N), u);

  319.   int16_t X4 = LERP(grad16(P(AB+1), xx, yy-N, zz-N), grad16(P(BB+1), xx - N, yy - N, zz - N), u);

  320. 

  321.   int16_t Y1 = LERP(X1,X2,v);

  322.   int16_t Y2 = LERP(X3,X4,v);

  323. 

  324.   int16_t ans = LERP(Y1,Y2,w);

  325. 

  326.   return ans;

  327. }

  328. 

  329. uint16_t inoise16(uint32_t x, uint32_t y, uint32_t z) {

  330.   int32_t ans = inoise16_raw(x,y,z);

  331.   ans = ans + 19052L;

  332.   uint32_t pan = ans;

  333.   // pan = (ans * 220L) >> 7.  That's the same as:

  334.   // pan = (ans * 440L) >> 8.  And this way avoids a 7X four-byte shift-loop on AVR.

  335.   // Identical math, except for the highest bit, which we don't care about anyway,

  336.   // since we're returning the 'middle' 16 out of a 32-bit value anyway.

  337.   pan *= 440L;

  338.   return (pan>>8);

  339. 

  340.   // // return scale16by8(pan,220)<<1;

  341.   // return ((inoise16_raw(x,y,z)+19052)*220)>>7;

  342.   // return scale16by8(inoise16_raw(x,y,z)+19052,220)<<1;

  343. }

  344. 

  345. int16_t inoise16_raw(uint32_t x, uint32_t y)

  346. {

  347.   // Find the unit cube containing the point

  348.   uint8_t X = x>>16;

  349.   uint8_t Y = y>>16;

  350. 

  351.   // Hash cube corner coordinates

  352.   uint8_t A = P(X)+Y;

  353.   uint8_t AA = P(A);

  354.   uint8_t AB = P(A+1);

  355.   uint8_t B = P(X+1)+Y;

  356.   uint8_t BA = P(B);

  357.   uint8_t BB = P(B+1);

  358. 

  359.   // Get the relative position of the point in the cube

  360.   uint16_t u = x & 0xFFFF;

  361.   uint16_t v = y & 0xFFFF;

  362. 

  363.   // Get a signed version of the above for the grad function

  364.   int16_t xx = (u >> 1) & 0x7FFF;

  365.   int16_t yy = (v >> 1) & 0x7FFF;

  366.   uint16_t N = 0x8000L;

  367. 

  368.   u = EASE16(u); v = EASE16(v);

  369. 

  370.   int16_t X1 = LERP(grad16(P(AA), xx, yy), grad16(P(BA), xx - N, yy), u);

  371.   int16_t X2 = LERP(grad16(P(AB), xx, yy-N), grad16(P(BB), xx - N, yy - N), u);

  372. 

  373.   int16_t ans = LERP(X1,X2,v);

  374. 

  375.   return ans;

  376. }

  377. 

  378. uint16_t inoise16(uint32_t x, uint32_t y) {

  379.   int32_t ans = inoise16_raw(x,y);

  380.   ans = ans + 17308L;

  381.   uint32_t pan = ans;

  382.   // pan = (ans * 242L) >> 7.  That's the same as:

  383.   // pan = (ans * 484L) >> 8.  And this way avoids a 7X four-byte shift-loop on AVR.

  384.   // Identical math, except for the highest bit, which we don't care about anyway,

  385.   // since we're returning the 'middle' 16 out of a 32-bit value anyway.

  386.   pan *= 484L;

  387.   return (pan>>8);

  388.     

  389.   // return (uint32_t)(((int32_t)inoise16_raw(x,y)+(uint32_t)17308)*242)>>7;

  390.   // return scale16by8(inoise16_raw(x,y)+17308,242)<<1;

  391. }

  392. 

  393. int16_t inoise16_raw(uint32_t x)

  394. {

  395.   // Find the unit cube containing the point

  396.   uint8_t X = x>>16;

  397. 

  398.   // Hash cube corner coordinates

  399.   uint8_t A = P(X);

  400.   uint8_t AA = P(A);

  401.   uint8_t B = P(X+1);

  402.   uint8_t BA = P(B);

  403. 

  404.   // Get the relative position of the point in the cube

  405.   uint16_t u = x & 0xFFFF;

  406. 

  407.   // Get a signed version of the above for the grad function

  408.   int16_t xx = (u >> 1) & 0x7FFF;

  409.   uint16_t N = 0x8000L;

  410. 

  411.   u = EASE16(u);

  412. 

  413.   int16_t ans = LERP(grad16(P(AA), xx), grad16(P(BA), xx - N), u);

  414. 

  415.   return ans;

  416. }

  417. 

  418. uint16_t inoise16(uint32_t x) {

  419.   return ((uint32_t)((int32_t)inoise16_raw(x) + 17308L)) << 1;

  420. }

  421. 

  422. int8_t inoise8_raw(uint16_t x, uint16_t y, uint16_t z)

  423. {

  424.   // Find the unit cube containing the point

  425.   uint8_t X = x>>8;

  426.   uint8_t Y = y>>8;

  427.   uint8_t Z = z>>8;

  428. 

  429.   // Hash cube corner coordinates

  430.   uint8_t A = P(X)+Y;

  431.   uint8_t AA = P(A)+Z;

  432.   uint8_t AB = P(A+1)+Z;

  433.   uint8_t B = P(X+1)+Y;

  434.   uint8_t BA = P(B) + Z;

  435.   uint8_t BB = P(B+1)+Z;

  436. 

  437.   // Get the relative position of the point in the cube

  438.   uint8_t u = x;

  439.   uint8_t v = y;

  440.   uint8_t w = z;

  441. 

  442.   // Get a signed version of the above for the grad function

  443.   int8_t xx = ((uint8_t)(x)>>1) & 0x7F;

  444.   int8_t yy = ((uint8_t)(y)>>1) & 0x7F;

  445.   int8_t zz = ((uint8_t)(z)>>1) & 0x7F;

  446.   uint8_t N = 0x80;

  447. 

  448.   u = EASE8(u); v = EASE8(v); w = EASE8(w);

  449.     

  450.   int8_t X1 = lerp7by8(grad8(P(AA), xx, yy, zz), grad8(P(BA), xx - N, yy, zz), u);

  451.   int8_t X2 = lerp7by8(grad8(P(AB), xx, yy-N, zz), grad8(P(BB), xx - N, yy - N, zz), u);

  452.   int8_t X3 = lerp7by8(grad8(P(AA+1), xx, yy, zz-N), grad8(P(BA+1), xx - N, yy, zz-N), u);

  453.   int8_t X4 = lerp7by8(grad8(P(AB+1), xx, yy-N, zz-N), grad8(P(BB+1), xx - N, yy - N, zz - N), u);

  454. 

  455.   int8_t Y1 = lerp7by8(X1,X2,v);

  456.   int8_t Y2 = lerp7by8(X3,X4,v);

  457. 

  458.   int8_t ans = lerp7by8(Y1,Y2,w);

  459. 

  460.   return ans;

  461. }

  462. 

  463. uint8_t inoise8(uint16_t x, uint16_t y, uint16_t z) {

  464. //  return scale8(76+(inoise8_raw(x,y,z)),215)<<1;

  465.     int8_t n = inoise8_raw( x, y, z);  // -64..+64

  466.     n+= 64;                            //   0..128

  467.     uint8_t ans = qadd8( n, n);        //   0..255

  468.     return ans;

  469. }

  470. 

  471. int8_t inoise8_raw(uint16_t x, uint16_t y)

  472. {

  473.   // Find the unit cube containing the point

  474.   uint8_t X = x>>8;

  475.   uint8_t Y = y>>8;

  476. 

  477.   // Hash cube corner coordinates

  478.   uint8_t A = P(X)+Y;

  479.   uint8_t AA = P(A);

  480.   uint8_t AB = P(A+1);

  481.   uint8_t B = P(X+1)+Y;

  482.   uint8_t BA = P(B);

  483.   uint8_t BB = P(B+1);

  484. 

  485.   // Get the relative position of the point in the cube

  486.   uint8_t u = x;

  487.   uint8_t v = y;

  488. 

  489.   // Get a signed version of the above for the grad function

  490.   int8_t xx = ((uint8_t)(x)>>1) & 0x7F;

  491.   int8_t yy = ((uint8_t)(y)>>1) & 0x7F;

  492.   uint8_t N = 0x80;

  493. 

  494.   u = EASE8(u); v = EASE8(v);

  495.   

  496.   int8_t X1 = lerp7by8(grad8(P(AA), xx, yy), grad8(P(BA), xx - N, yy), u);

  497.   int8_t X2 = lerp7by8(grad8(P(AB), xx, yy-N), grad8(P(BB), xx - N, yy - N), u);

  498. 

  499.   int8_t ans = lerp7by8(X1,X2,v);

  500. 

  501.   return ans;

  502.   // return scale8((70+(ans)),234)<<1;

  503. }

  504. 

  505. 

  506. 

  507. uint8_t inoise8(uint16_t x, uint16_t y) {

  508.   //return scale8(69+inoise8_raw(x,y),237)<<1;

  509.     int8_t n = inoise8_raw( x, y);  // -64..+64

  510.     n+= 64;                         //   0..128

  511.     uint8_t ans = qadd8( n, n);     //   0..255

  512.     return ans;

  513. }

  514. 

  515. // output range = -64 .. +64

  516. int8_t inoise8_raw(uint16_t x)

  517. {

  518.   // Find the unit cube containing the point

  519.   uint8_t X = x>>8;

  520. 

  521.   // Hash cube corner coordinates

  522.   uint8_t A = P(X);

  523.   uint8_t AA = P(A);

  524.   uint8_t B = P(X+1);

  525.   uint8_t BA = P(B);

  526. 

  527.   // Get the relative position of the point in the cube

  528.   uint8_t u = x;

  529. 

  530.   // Get a signed version of the above for the grad function

  531.   int8_t xx = ((uint8_t)(x)>>1) & 0x7F;

  532.   uint8_t N = 0x80;

  533. 

  534.   u = EASE8( u);

  535.   

  536.   int8_t ans = lerp7by8(grad8(P(AA), xx), grad8(P(BA), xx - N), u);

  537. 

  538.   return ans;

  539. }

  540. 

  541. uint8_t inoise8(uint16_t x) {

  542.     int8_t n = inoise8_raw(x);    //-64..+64

  543.     n += 64;                      // 0..128

  544.     uint8_t ans = qadd8(n,n);     // 0..255

  545.     return ans;

  546. }

  547. 

  548. // struct q44 {

  549. //   uint8_t i:4;

  550. //   uint8_t f:4;

  551. //   q44(uint8_t _i, uint8_t _f) {i=_i; f=_f; }

  552. // };

  553. 

  554. // uint32_t mul44(uint32_t v, q44 mulby44) {

  555. //     return (v *mulby44.i)  + ((v * mulby44.f) >> 4);

  556. // }

  557. //

  558. // uint16_t mul44_16(uint16_t v, q44 mulby44) {

  559. //     return (v *mulby44.i)  + ((v * mulby44.f) >> 4);

  560. // }

  561. 

  562. void fill_raw_noise8(uint8_t *pData, uint8_t num_points, uint8_t octaves, uint16_t x, int scale, uint16_t time) {

  563.   uint32_t _xx = x;

  564.   uint32_t scx = scale;

  565.   for(int o = 0; o < octaves; o++) {

  566.     for(int i = 0,xx=_xx; i < num_points; i++, xx+=scx) {

  567.           pData[i] = qadd8(pData[i],inoise8(xx,time)>>o);

  568.     }

  569. 

  570.     _xx <<= 1;

  571.     scx <<= 1;

  572.   }

  573. }

  574. 

  575. void fill_raw_noise16into8(uint8_t *pData, uint8_t num_points, uint8_t octaves, uint32_t x, int scale, uint32_t time) {

  576.   uint32_t _xx = x;

  577.   uint32_t scx = scale;

  578.   for(int o = 0; o < octaves; o++) {

  579.     for(int i = 0,xx=_xx; i < num_points; i++, xx+=scx) {

  580.       uint32_t accum = (inoise16(xx,time))>>o;

  581.       accum += (pData[i]<<8);

  582.       if(accum > 65535) { accum = 65535; }

  583.       pData[i] = accum>>8;

  584.     }

  585. 

  586.     _xx <<= 1;

  587.     scx <<= 1;

  588.   }

  589. }

  590. 

  591. void fill_raw_2dnoise8(uint8_t *pData, int width, int height, uint8_t octaves, q44 freq44, fract8 amplitude, int skip, uint16_t x, int scalex, uint16_t y, int scaley, uint16_t time) {

  592.   if(octaves > 1) {

  593.     fill_raw_2dnoise8(pData, width, height, octaves-1, freq44, amplitude, skip+1, x*freq44, freq44 * scalex, y*freq44, freq44 * scaley, time);

  594.   } else {

  595.     // amplitude is always 255 on the lowest level

  596.     amplitude=255;

  597.   }

  598. 

  599.   scalex *= skip;

  600.   scaley *= skip;

  601. 

  602.   fract8 invamp = 255-amplitude;

  603.   uint16_t xx = x;

  604.   for(int i = 0; i < height; i++, y+=scaley) {

  605.     uint8_t *pRow = pData + (i*width);

  606.     xx = x;

  607.     for(int j = 0; j < width; j++, xx+=scalex) {

  608.       uint8_t noise_base = inoise8(xx,y,time);

  609.       noise_base = (0x80 & noise_base) ? (noise_base - 127) : (127 - noise_base);

  610.       noise_base = scale8(noise_base<<1,amplitude);

  611.       if(skip == 1) {

  612.         pRow[j] = scale8(pRow[j],invamp) + noise_base;

  613.       } else {

  614.         for(int ii = i; ii<(i+skip) && ii<height; ii++) {

  615.           uint8_t *pRow = pData + (ii*width);

  616.           for(int jj=j; jj<(j+skip) && jj<width; jj++) {

  617.             pRow[jj] = scale8(pRow[jj],invamp) + noise_base;

  618.           }

  619.         }

  620.       }

  621.     }

  622.   }

  623. }

  624. 

  625. void fill_raw_2dnoise8(uint8_t *pData, int width, int height, uint8_t octaves, uint16_t x, int scalex, uint16_t y, int scaley, uint16_t time) {

  626.   fill_raw_2dnoise8(pData, width, height, octaves, q44(2,0), 128, 1, x, scalex, y, scaley, time);

  627. }

  628. 

  629. void fill_raw_2dnoise16(uint16_t *pData, int width, int height, uint8_t octaves, q88 freq88, fract16 amplitude, int skip, uint32_t x, int scalex, uint32_t y, int scaley, uint32_t time) {

  630.   if(octaves > 1) {

  631.     fill_raw_2dnoise16(pData, width, height, octaves-1, freq88, amplitude, skip, x *freq88 , scalex *freq88, y * freq88, scaley * freq88, time);

  632.   } else {

  633.     // amplitude is always 255 on the lowest level

  634.     amplitude=65535;

  635.   }

  636. 

  637.   scalex *= skip;

  638.   scaley *= skip;

  639.   fract16 invamp = 65535-amplitude;

  640.   for(int i = 0; i < height; i+=skip, y+=scaley) {

  641.     uint16_t *pRow = pData + (i*width);

  642.     for(int j = 0,xx=x; j < width; j+=skip, xx+=scalex) {

  643.       uint16_t noise_base = inoise16(xx,y,time);

  644.       noise_base = (0x8000 & noise_base) ? noise_base - (32767) : 32767 - noise_base;

  645.       noise_base = scale16(noise_base<<1, amplitude);

  646.       if(skip==1) {

  647.         pRow[j] = scale16(pRow[j],invamp) + noise_base;

  648.       } else {

  649.         for(int ii = i; ii<(i+skip) && ii<height; ii++) {

  650.           uint16_t *pRow = pData + (ii*width);

  651.           for(int jj=j; jj<(j+skip) && jj<width; jj++) {

  652.             pRow[jj] = scale16(pRow[jj],invamp) + noise_base;

  653.           }

  654.         }

  655.       }

  656.     }

  657.   }

  658. }

  659. 

  660. int32_t nmin=11111110;

  661. int32_t nmax=0;

  662. 

  663. void fill_raw_2dnoise16into8(uint8_t *pData, int width, int height, uint8_t octaves, q44 freq44, fract8 amplitude, int skip, uint32_t x, int scalex, uint32_t y, int scaley, uint32_t time) {

  664.   if(octaves > 1) {

  665.     fill_raw_2dnoise16into8(pData, width, height, octaves-1, freq44, amplitude, skip+1, x*freq44, scalex *freq44, y*freq44, scaley * freq44, time);

  666.   } else {

  667.     // amplitude is always 255 on the lowest level

  668.     amplitude=255;

  669.   }

  670. 

  671.   scalex *= skip;

  672.   scaley *= skip;

  673.   uint32_t xx;

  674.   fract8 invamp = 255-amplitude;

  675.   for(int i = 0; i < height; i+=skip, y+=scaley) {

  676.     uint8_t *pRow = pData + (i*width);

  677.     xx = x;

  678.     for(int j = 0; j < width; j+=skip, xx+=scalex) {

  679.       uint16_t noise_base = inoise16(xx,y,time);

  680.       noise_base = (0x8000 & noise_base) ? noise_base - (32767) : 32767 - noise_base;

  681.       noise_base = scale8(noise_base>>7,amplitude);

  682.       if(skip==1) {

  683.         pRow[j] = qadd8(scale8(pRow[j],invamp),noise_base);

  684.       } else {

  685.         for(int ii = i; ii<(i+skip) && ii<height; ii++) {

  686.           uint8_t *pRow = pData + (ii*width);

  687.           for(int jj=j; jj<(j+skip) && jj<width; jj++) {

  688.             pRow[jj] = scale8(pRow[jj],invamp) + noise_base;

  689.           }

  690.         }

  691.       }

  692.     }

  693.   }

  694. }

  695. 

  696. void fill_raw_2dnoise16into8(uint8_t *pData, int width, int height, uint8_t octaves, uint32_t x, int scalex, uint32_t y, int scaley, uint32_t time) {

  697.   fill_raw_2dnoise16into8(pData, width, height, octaves, q44(2,0), 171, 1, x, scalex, y, scaley, time);

  698. }

  699. 

  700. void fill_noise8(CRGB *leds, int num_leds,

  701.             uint8_t octaves, uint16_t x, int scale,

  702.             uint8_t hue_octaves, uint16_t hue_x, int hue_scale,

  703.             uint16_t time) {

  704.   uint8_t V[num_leds];

  705.   uint8_t H[num_leds];

  706. 

  707.   memset(V,0,num_leds);

  708.   memset(H,0,num_leds);

  709. 

  710.   fill_raw_noise8(V,num_leds,octaves,x,scale,time);

  711.   fill_raw_noise8(H,num_leds,hue_octaves,hue_x,hue_scale,time);

  712. 

  713.   for(int i = 0; i < num_leds; i++) {

  714.     leds[i] = CHSV(H[i],255,V[i]);

  715.   }

  716. }

  717. 

  718. void fill_noise16(CRGB *leds, int num_leds,

  719.             uint8_t octaves, uint16_t x, int scale,

  720.             uint8_t hue_octaves, uint16_t hue_x, int hue_scale,

  721.             uint16_t time, uint8_t hue_shift) {

  722.   uint8_t V[num_leds];

  723.   uint8_t H[num_leds];

  724. 

  725.   memset(V,0,num_leds);

  726.   memset(H,0,num_leds);

  727. 

  728.   fill_raw_noise16into8(V,num_leds,octaves,x,scale,time);

  729.   fill_raw_noise8(H,num_leds,hue_octaves,hue_x,hue_scale,time);

  730. 

  731.   for(int i = 0; i < num_leds; i++) {

  732.     leds[i] = CHSV(H[i] + hue_shift,255,V[i]);

  733.   }

  734. }

  735. 

  736. void fill_2dnoise8(CRGB *leds, int width, int height, bool serpentine,

  737.             uint8_t octaves, uint16_t x, int xscale, uint16_t y, int yscale, uint16_t time,

  738.             uint8_t hue_octaves, uint16_t hue_x, int hue_xscale, uint16_t hue_y, uint16_t hue_yscale,uint16_t hue_time,bool blend) {

  739.   uint8_t V[height][width];

  740.   uint8_t H[height][width];

  741. 

  742.   memset(V,0,height*width);

  743.   memset(H,0,height*width);

  744. 

  745.   fill_raw_2dnoise8((uint8_t*)V,width,height,octaves,x,xscale,y,yscale,time);

  746.   fill_raw_2dnoise8((uint8_t*)H,width,height,hue_octaves,hue_x,hue_xscale,hue_y,hue_yscale,hue_time);

  747. 

  748.   int w1 = width-1;

  749.   int h1 = height-1;

  750.   for(int i = 0; i < height; i++) {

  751.     int wb = i*width;

  752.     for(int j = 0; j < width; j++) {

  753.       CRGB led(CHSV(H[h1-i][w1-j],255,V[i][j]));

  754. 

  755.       int pos = j;

  756.       if(serpentine && (i & 0x1)) {

  757.         pos = w1-j;

  758.       }

  759. 

  760.       if(blend) {

  761.         leds[wb+pos] >>= 1; leds[wb+pos] += (led>>=1);

  762.       } else {

  763.         leds[wb+pos] = led;

  764.       }

  765.     }

  766.   }

  767. }

  768. 

  769. void fill_2dnoise16(CRGB *leds, int width, int height, bool serpentine,

  770.             uint8_t octaves, uint32_t x, int xscale, uint32_t y, int yscale, uint32_t time,

  771.             uint8_t hue_octaves, uint16_t hue_x, int hue_xscale, uint16_t hue_y, uint16_t hue_yscale,uint16_t hue_time, bool blend, uint16_t hue_shift) {

  772.   uint8_t V[height][width];

  773.   uint8_t H[height][width];

  774. 

  775.   memset(V,0,height*width);

  776.   memset(H,0,height*width);

  777. 

  778.   fill_raw_2dnoise16into8((uint8_t*)V,width,height,octaves,q44(2,0),171,1,x,xscale,y,yscale,time);

  779.   // fill_raw_2dnoise16into8((uint8_t*)V,width,height,octaves,x,xscale,y,yscale,time);

  780.   // fill_raw_2dnoise8((uint8_t*)V,width,height,hue_octaves,x,xscale,y,yscale,time);

  781.   fill_raw_2dnoise8((uint8_t*)H,width,height,hue_octaves,hue_x,hue_xscale,hue_y,hue_yscale,hue_time);

  782. 

  783. 

  784.   int w1 = width-1;

  785.   int h1 = height-1;

  786.   hue_shift >>= 8;

  787. 

  788.   for(int i = 0; i < height; i++) {

  789.     int wb = i*width;

  790.     for(int j = 0; j < width; j++) {

  791.       CRGB led(CHSV(hue_shift + (H[h1-i][w1-j]),196,V[i][j]));

  792. 

  793.       int pos = j;

  794.       if(serpentine && (i & 0x1)) {

  795.         pos = w1-j;

  796.       }

  797. 

  798.       if(blend) {

  799.         leds[wb+pos] >>= 1; leds[wb+pos] += (led>>=1);

  800.       } else {

  801.         leds[wb+pos] = led;

  802.       }

  803.     }

  804.   }

  805. }

  806. 

  807. FASTLED_NAMESPACE_END