• API
• FAQ
• Tools
• Trends
• Archive
daily pastebin goal
75%
SHARE
TWEET

# Untitled

a guest Apr 21st, 2017 58 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