home *** CD-ROM | disk | FTP | other *** search
/ Collection of Hack-Phreak Scene Programs / cleanhpvac.zip / cleanhpvac / FAQSYS18.ZIP / FAQS.DAT / PERLIN.C < prev    next >
C/C++ Source or Header  |  1996-02-23  |  4KB  |  248 lines
  1. #include <stdlib.h>
  2. #include <stdio.h>
  3. #include <math.h>
  4.  
  5. float bias(float a, float b)
  6. {
  7.     return pow(a, log(b) / log(0.5));
  8. }
  9.  
  10. float gain(float a, float b)
  11. {
  12.     float p = log(1. - b) / log(0.5);
  13.  
  14.     if (a < .001)
  15.         return 0.;
  16.     else if (a > .999)
  17.         return 1.;
  18.     if (a < 0.5)
  19.         return pow(2 * a, p) / 2;
  20.     else
  21.         return 1. - pow(2 * (1. - a), p) / 2;
  22. }
  23.  
  24. float noise1(float arg);
  25. float noise2(float vec[]);
  26. float noise3(float vec[]);
  27.  
  28. float noise(float vec[], int len)
  29. {
  30.     switch (len) {
  31.     case 0:
  32.         return 0.;
  33.     case 1:
  34.         return noise1(vec[0]);
  35.     case 2:
  36.         return noise2(vec);
  37.     default:
  38.         return noise3(vec);
  39.     }
  40. }
  41.  
  42. float turbulence(float *v, float freq)
  43. {
  44.     float t, vec[3];
  45.  
  46.     for (t = 0. ; freq >= 1. ; freq /= 2) {
  47.         vec[0] = freq * v[0];
  48.         vec[1] = freq * v[1];
  49.         vec[2] = freq * v[2];
  50.         t += fabs(noise3(vec)) / freq;
  51.     }
  52.     return t;
  53. }
  54.  
  55. /* noise functions over 1, 2, and 3 dimensions */
  56.  
  57. #define B 0x100
  58. #define BM 0xff
  59.  
  60. #define N 0x1000
  61. #define NP 12   /* 2^N */
  62. #define NM 0xfff
  63.  
  64. static p[B + B + 2];
  65. static float g3[B + B + 2][3];
  66. static float g2[B + B + 2][2];
  67. static float g1[B + B + 2];
  68. static start = 1;
  69.  
  70. static void init(void);
  71.  
  72. #define s_curve(t) ( t * t * (3. - 2. * t) )
  73.  
  74. #define lerp(t, a, b) ( a + t * (b - a) )
  75.  
  76. #define setup(i,b0,b1,r0,r1)\
  77.     t = vec[i] + N;\
  78.     b0 = ((int)t) & BM;\
  79.     b1 = (b0+1) & BM;\
  80.     r0 = t - (int)t;\
  81.     r1 = r0 - 1.;
  82.  
  83. float noise1(float arg)
  84. {
  85.     int bx0, bx1;
  86.     float rx0, rx1, sx, t, u, v, vec[1];
  87.  
  88.     vec[0] = arg;
  89.     if (start) {
  90.         start = 0;
  91.         init();
  92.     }
  93.  
  94.     setup(0, bx0,bx1, rx0,rx1);
  95.  
  96.     sx = s_curve(rx0);
  97.  
  98.     u = rx0 * g1[ p[ bx0 ] ];
  99.     v = rx1 * g1[ p[ bx1 ] ];
  100.  
  101.     return lerp(sx, u, v);
  102. }
  103.  
  104. float noise2(float vec[2])
  105. {
  106.     int bx0, bx1, by0, by1, b00, b10, b01, b11;
  107.     float rx0, rx1, ry0, ry1, *q, sx, sy, a, b, t, u, v;
  108.     register i, j;
  109.  
  110.     if (start) {
  111.         start = 0;
  112.         init();
  113.     }
  114.  
  115.     setup(0, bx0,bx1, rx0,rx1);
  116.     setup(1, by0,by1, ry0,ry1);
  117.  
  118.     i = p[ bx0 ];
  119.     j = p[ bx1 ];
  120.  
  121.     b00 = p[ i + by0 ];
  122.     b10 = p[ j + by0 ];
  123.     b01 = p[ i + by1 ];
  124.     b11 = p[ j + by1 ];
  125.  
  126.     sx = s_curve(rx0);
  127.     sy = s_curve(ry0);
  128.  
  129. #define at2(rx,ry) ( rx * q[0] + ry * q[1] )
  130.  
  131.     q = g2[ b00 ] ; u = at2(rx0,ry0);
  132.     q = g2[ b10 ] ; v = at2(rx1,ry0);
  133.     a = lerp(sx, u, v);
  134.  
  135.     q = g2[ b01 ] ; u = at2(rx0,ry1);
  136.     q = g2[ b11 ] ; v = at2(rx1,ry1);
  137.     b = lerp(sx, u, v);
  138.  
  139.     return lerp(sy, a, b);
  140. }
  141.  
  142. float noise3(float vec[3])
  143. {
  144.     int bx0, bx1, by0, by1, bz0, bz1, b00, b10, b01, b11;
  145.     float rx0, rx1, ry0, ry1, rz0, rz1, *q, sy, sz, a, b, c, d, t, u, v;
  146.     register i, j;
  147.  
  148.     if (start) {
  149.         start = 0;
  150.         init();
  151.     }
  152.  
  153.     setup(0, bx0,bx1, rx0,rx1);
  154.     setup(1, by0,by1, ry0,ry1);
  155.     setup(2, bz0,bz1, rz0,rz1);
  156.  
  157.     i = p[ bx0 ];
  158.     j = p[ bx1 ];
  159.  
  160.     b00 = p[ i + by0 ];
  161.     b10 = p[ j + by0 ];
  162.     b01 = p[ i + by1 ];
  163.     b11 = p[ j + by1 ];
  164.  
  165.     t  = s_curve(rx0);
  166.     sy = s_curve(ry0);
  167.     sz = s_curve(rz0);
  168.  
  169. #define at3(rx,ry,rz) ( rx * q[0] + ry * q[1] + rz * q[2] )
  170.  
  171.     q = g3[ b00 + bz0 ] ; u = at3(rx0,ry0,rz0);
  172.     q = g3[ b10 + bz0 ] ; v = at3(rx1,ry0,rz0);
  173.     a = lerp(t, u, v);
  174.  
  175.     q = g3[ b01 + bz0 ] ; u = at3(rx0,ry1,rz0);
  176.     q = g3[ b11 + bz0 ] ; v = at3(rx1,ry1,rz0);
  177.     b = lerp(t, u, v);
  178.  
  179.     c = lerp(sy, a, b);
  180.  
  181.     q = g3[ b00 + bz1 ] ; u = at3(rx0,ry0,rz1);
  182.     q = g3[ b10 + bz1 ] ; v = at3(rx1,ry0,rz1);
  183.     a = lerp(t, u, v);
  184.  
  185.     q = g3[ b01 + bz1 ] ; u = at3(rx0,ry1,rz1);
  186.     q = g3[ b11 + bz1 ] ; v = at3(rx1,ry1,rz1);
  187.     b = lerp(t, u, v);
  188.  
  189.     d = lerp(sy, a, b);
  190.  
  191.     return lerp(sz, c, d);
  192. }
  193.  
  194. static void normalize2(float v[2])
  195. {
  196.     float s;
  197.  
  198.     s = sqrt(v[0] * v[0] + v[1] * v[1]);
  199.     v[0] = v[0] / s;
  200.     v[1] = v[1] / s;
  201. }
  202.  
  203. static void normalize3(float v[3])
  204. {
  205.     float s;
  206.  
  207.     s = sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
  208.     v[0] = v[0] / s;
  209.     v[1] = v[1] / s;
  210.     v[2] = v[2] / s;
  211. }
  212.  
  213. static void init(void)
  214. {
  215.     int i, j, k;
  216.  
  217.     for (i = 0 ; i < B ; i++) {
  218.         p[i] = i;
  219.  
  220.         g1[i] = (float)((random() % (B + B)) - B) / B;
  221.  
  222.         for (j = 0 ; j < 2 ; j++)
  223.             g2[i][j] = (float)((random() % (B + B)) - B) / B;
  224.         normalize2(g2[i]);
  225.  
  226.         for (j = 0 ; j < 3 ; j++)
  227.             g3[i][j] = (float)((random() % (B + B)) - B) / B;
  228.         normalize3(g3[i]);
  229.     }
  230.  
  231.     while (--i) {
  232.         k = p[i];
  233.         p[i] = p[j = random() % B];
  234.         p[j] = k;
  235.     }
  236.  
  237.     for (i = 0 ; i < B + 2 ; i++) {
  238.         p[B + i] = p[i];
  239.         g1[B + i] = g1[i];
  240.         for (j = 0 ; j < 2 ; j++)
  241.             g2[B + i][j] = g2[i][j];
  242.         for (j = 0 ; j < 3 ; j++)
  243.             g3[B + i][j] = g3[i][j];
  244.     }
  245. }
  246.  
  247.  
  248.