SHARE
TWEET

Untitled

a guest Apr 21st, 2017 53 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. public double naturalGeneration(double x, double y, double z, double w) {
  2.  
  3.         double n0, n1, n2, n3, n4; // Noise contributions from the five corners
  4.         // Skew the (x,y,z,w) space to determine which cell of 24 simplices we're in
  5.         double s = (x + y + z + w) * F4; // Factor for 4D skewing
  6.         int i = fastfloor(x + s);
  7.         int j = fastfloor(y + s);
  8.         int k = fastfloor(z + s);
  9.         int l = fastfloor(w + s);
  10.         double t = (i + j + k + l) * G4; // Factor for 4D unskewing
  11.         double X0 = i - t; // Unskew the cell origin back to (x,y,z,w) space
  12.         double Y0 = j - t;
  13.         double Z0 = k - t;
  14.         double W0 = l - t;
  15.         double x0 = x - X0;  // The x,y,z,w distances from the cell origin
  16.         double y0 = y - Y0;
  17.         double z0 = z - Z0;
  18.         double w0 = w - W0;
  19.         // For the 4D case, the simplex is a 4D shape I won't even try to describe.
  20.         // To find out which of the 24 possible simplices we're in, we need to
  21.         // determine the magnitude ordering of x0, y0, z0 and w0.
  22.         // Six pair-wise comparisons are performed between each possible pair
  23.         // of the four coordinates, and the results are used to rank the numbers.
  24.         int rankx = 0;
  25.         int ranky = 0;
  26.         int rankz = 0;
  27.         int rankw = 0;
  28.         if(x0 > y0) rankx++; else ranky++;
  29.         if(x0 > z0) rankx++; else rankz++;
  30.         if(x0 > w0) rankx++; else rankw++;
  31.         if(y0 > z0) ranky++; else rankz++;
  32.         if(y0 > w0) ranky++; else rankw++;
  33.         if(z0 > w0) rankz++; else rankw++;
  34.         int i1, j1, k1, l1; // The integer offsets for the second simplex corner
  35.         int i2, j2, k2, l2; // The integer offsets for the third simplex corner
  36.         int i3, j3, k3, l3; // The integer offsets for the fourth simplex corner
  37.         // simplex[c] is a 4-vector with the numbers 0, 1, 2 and 3 in some order.
  38.         // Many values of c will never occur, since e.g. x>y>z>w makes x<z, y<w and x<w
  39.         // impossible. Only the 24 indices which have non-zero entries make any sense.
  40.         // We use a thresholding to set the coordinates in turn from the largest magnitude.
  41.         // Rank 3 denotes the largest coordinate.
  42.         i1 = rankx >= 3 ? 1 : 0;
  43.         j1 = ranky >= 3 ? 1 : 0;
  44.         k1 = rankz >= 3 ? 1 : 0;
  45.         l1 = rankw >= 3 ? 1 : 0;
  46.         // Rank 2 denotes the second largest coordinate.
  47.         i2 = rankx >= 2 ? 1 : 0;
  48.         j2 = ranky >= 2 ? 1 : 0;
  49.         k2 = rankz >= 2 ? 1 : 0;
  50.         l2 = rankw >= 2 ? 1 : 0;
  51.         // Rank 1 denotes the second smallest coordinate.
  52.         i3 = rankx >= 1 ? 1 : 0;
  53.         j3 = ranky >= 1 ? 1 : 0;
  54.         k3 = rankz >= 1 ? 1 : 0;
  55.         l3 = rankw >= 1 ? 1 : 0;
  56.         // The fifth corner has all coordinate offsets = 1, so no need to compute that.
  57.         double x1 = x0 - i1 + G4; // Offsets for second corner in (x,y,z,w) coords
  58.         double y1 = y0 - j1 + G4;
  59.         double z1 = z0 - k1 + G4;
  60.         double w1 = w0 - l1 + G4;
  61.         double x2 = x0 - i2 + 2.0*G4; // Offsets for third corner in (x,y,z,w) coords
  62.         double y2 = y0 - j2 + 2.0*G4;
  63.         double z2 = z0 - k2 + 2.0*G4;
  64.         double w2 = w0 - l2 + 2.0*G4;
  65.         double x3 = x0 - i3 + 3.0*G4; // Offsets for fourth corner in (x,y,z,w) coords
  66.         double y3 = y0 - j3 + 3.0*G4;
  67.         double z3 = z0 - k3 + 3.0*G4;
  68.         double w3 = w0 - l3 + 3.0*G4;
  69.         double x4 = x0 - 1.0 + 4.0*G4; // Offsets for last corner in (x,y,z,w) coords
  70.         double y4 = y0 - 1.0 + 4.0*G4;
  71.         double z4 = z0 - 1.0 + 4.0*G4;
  72.         double w4 = w0 - 1.0 + 4.0*G4;
  73.         // Work out the hashed gradient indices of the five simplex corners
  74.         int ii = i & 255;
  75.         int jj = j & 255;
  76.         int kk = k & 255;
  77.         int ll = l & 255;
  78.         int gi0 = perm[ii+perm[jj+perm[kk+perm[ll]]]] % 32;
  79.         int gi1 = perm[ii+i1+perm[jj+j1+perm[kk+k1+perm[ll+l1]]]] % 32;
  80.         int gi2 = perm[ii+i2+perm[jj+j2+perm[kk+k2+perm[ll+l2]]]] % 32;
  81.         int gi3 = perm[ii+i3+perm[jj+j3+perm[kk+k3+perm[ll+l3]]]] % 32;
  82.         int gi4 = perm[ii+1+perm[jj+1+perm[kk+1+perm[ll+1]]]] % 32;
  83.         // Calculate the contribution from the five corners
  84.         double t0 = 0.6 - x0*x0 - y0*y0 - z0*z0 - w0*w0;
  85.         if(t0<0) n0 = 0.0;
  86.         else {
  87.             t0 *= t0;
  88.             n0 = t0 * t0 * dot(grad4[gi0], x0, y0, z0, w0);
  89.         }
  90.         double t1 = 0.6 - x1*x1 - y1*y1 - z1*z1 - w1*w1;
  91.         if(t1<0) n1 = 0.0;
  92.         else {
  93.             t1 *= t1;
  94.             n1 = t1 * t1 * dot(grad4[gi1], x1, y1, z1, w1);
  95.         }
  96.         double t2 = 0.6 - x2*x2 - y2*y2 - z2*z2 - w2*w2;
  97.         if(t2<0) n2 = 0.0;
  98.         else {
  99.             t2 *= t2;
  100.             n2 = t2 * t2 * dot(grad4[gi2], x2, y2, z2, w2);
  101.         }
  102.         double t3 = 0.6 - x3*x3 - y3*y3 - z3*z3 - w3*w3;
  103.         if(t3<0) n3 = 0.0;
  104.         else {
  105.             t3 *= t3;
  106.             n3 = t3 * t3 * dot(grad4[gi3], x3, y3, z3, w3);
  107.         }
  108.         double t4 = 0.6 - x4*x4 - y4*y4 - z4*z4 - w4*w4;
  109.         if(t4<0) n4 = 0.0;
  110.         else {
  111.             t4 *= t4;
  112.             n4 = t4 * t4 * dot(grad4[gi4], x4, y4, z4, w4);
  113.         }
  114.         // Sum up and scale the result to cover the range [-1,1]
  115.         return 27.0 * (n0 + n1 + n2 + n3 + n4);
  116.     }
RAW Paste Data
Top