为什么我的GLSL简单噪声质量比在Java上运行的要差很多呢？

huangapple
未分类评论49阅读模式
英文:

Why is the quality of my GLSL simplex noise so much worse then the one run on Java?

问题

  1. public class SimplexNoise {
  2.   private static Grad grad3[] = {new Grad(1,1,0),new Grad(-1,1,0),new Grad(1,-1,0),new Grad(-1,-1,0),
  3.                                  new Grad(1,0,1),new Grad(-1,0,1),new Grad(1,0,-1),new Grad(-1,0,-1),
  4.                                  new Grad(0,1,1),new Grad(0,-1,1),new Grad(0,1,-1),new Grad(0,-1,-1)};
  6.   private static Grad grad4[]= {new Grad(0,1,1,1),new Grad(0,1,1,-1),new Grad(0,1,-1,1),new Grad(0,1,-1,-1),
  7.                    new Grad(0,-1,1,1),new Grad(0,-1,1,-1),new Grad(0,-1,-1,1),new Grad(0,-1,-1,-1),
  8.                    new Grad(1,0,1,1),new Grad(1,0,1,-1),new Grad(1,0,-1,1),new Grad(1,0,-1,-1),
  9.                    new Grad(-1,0,1,1),new Grad(-1,0,1,-1),new Grad(-1,0,-1,1),new Grad(-1,0,-1,-1),
  10.                    new Grad(1,1,0,1),new Grad(1,1,0,-1),new Grad(1,-1,0,1),new Grad(1,-1,0,-1),
  11.                    new Grad(-1,1,0,1),new Grad(-1,1,0,-1),new Grad(-1,-1,0,1),new Grad(-1,-1,0,-1),
  12.                    new Grad(1,1,1,0),new Grad(1,1,-1,0),new Grad(1,-1,1,0),new Grad(1,-1,-1,0),
  13.                    new Grad(-1,1,1,0),new Grad(-1,1,-1,0),new Grad(-1,-1,1,0),new Grad(-1,-1,-1,0)};
  14.   
  15.   // ... Other constants and helper functions ...
  17.   // 2D simplex noise
  18.   public static double noise(double xin, double yin) {
  19.     // Implementation details for 2D simplex noise
  20.   }
  22.   // 3D simplex noise
  23.   public static double noise(double xin, double yin, double zin) {
  24.     // Implementation details for 3D simplex noise
  25.   }
  27.   // 4D simplex noise
  28.   public static double noise(double x, double y, double z, double w) {
  29.     // Implementation details for 4D simplex noise
  30.   }
  32.   // ... Other methods ...
  34.   // Grad class and other details ...
  35. }

Please note that I have omitted some parts of the original code, such as the fastfloor function and the Grad class, to focus on the structure and the core noise generation functions. If you need the full implementation, you can combine the provided parts with the missing parts from the original code.

英文:

I've been working on an infinetly procedurally generated terrain using Simplex Noise. I've decided to improve its performance by transferring the Code for simplex noise to my compute shader. The problem was that the code I found for GLSL simplex noise performs worse then the code I found for Java simplex noise. Both of them work properly but the Java simplex noise produces terrain that looks way better and more interesting then the one in GLSL. Is there a way for me to improve the Simplex noise algorithm on my Compute shader or is it better to risk performance speed by using the Java Noise and get better results?

Compute Shader Simplex noise Code

  1. #version 430 core
  3. layout  (local_size_x  =  10, local_size_y  =  10, local_size_z  =  10)  in;
  5. layout(std430, binding=0) buffer Pos3D{
  6.     float Position3D[];
  7. };
  8. layout(std430, binding=1) buffer Pos2D{
  9.     float Position2D[];
  10. };
  12. uniform float size;
  15. vec4 permute(vec4 x){return mod(((x*34.0)+1.0)*x, 289.0);}
  16. vec4 taylorInvSqrt(vec4 r){return 1.79284291400159 - 0.85373472095314 * r;}
  18. float snoise(vec3 v){ 
  19.   const vec2  C = vec2(1.0/6.0, 1.0/3.0) ;
  20.   const vec4  D = vec4(0.0, 0.5, 1.0, 2.0);
  22. // First corner
  23.   vec3 i  = floor(v + dot(v, C.yyy) );
  24.   vec3 x0 =   v - i + dot(i, C.xxx) ;
  26. // Other corners
  27.   vec3 g = step(x0.yzx, x0.xyz);
  28.   vec3 l = 1.0 - g;
  29.   vec3 i1 = min( g.xyz, l.zxy );
  30.   vec3 i2 = max( g.xyz, l.zxy );
  32.   //  x0 = x0 - 0. + 0.0 * C 
  33.   vec3 x1 = x0 - i1 + 1.0 * C.xxx;
  34.   vec3 x2 = x0 - i2 + 2.0 * C.xxx;
  35.   vec3 x3 = x0 - 1. + 3.0 * C.xxx;
  37. // Permutations
  38.   i = mod(i, 289.0 ); 
  39.   vec4 p = permute( permute( permute( 
  40.              i.z + vec4(0.0, i1.z, i2.z, 1.0 ))
  41.            + i.y + vec4(0.0, i1.y, i2.y, 1.0 )) 
  42.            + i.x + vec4(0.0, i1.x, i2.x, 1.0 ));
  44. // Gradients
  45. // ( N*N points uniformly over a square, mapped onto an octahedron.)
  46.   float n_ = 1.0/7.0; // N=7
  47.   vec3  ns = n_ * D.wyz - D.xzx;
  49.   vec4 j = p - 49.0 * floor(p * ns.z *ns.z);  //  mod(p,N*N)
  51.   vec4 x_ = floor(j * ns.z);
  52.   vec4 y_ = floor(j - 7.0 * x_ );    // mod(j,N)
  54.   vec4 x = x_ *ns.x + ns.yyyy;
  55.   vec4 y = y_ *ns.x + ns.yyyy;
  56.   vec4 h = 1.0 - abs(x) - abs(y);
  58.   vec4 b0 = vec4( x.xy, y.xy );
  59.   vec4 b1 = vec4( x.zw, y.zw );
  61.   vec4 s0 = floor(b0)*2.0 + 1.0;
  62.   vec4 s1 = floor(b1)*2.0 + 1.0;
  63.   vec4 sh = -step(h, vec4(0.0));
  65.   vec4 a0 = b0.xzyw + s0.xzyw*sh.xxyy ;
  66.   vec4 a1 = b1.xzyw + s1.xzyw*sh.zzww ;
  68.   vec3 p0 = vec3(a0.xy,h.x);
  69.   vec3 p1 = vec3(a0.zw,h.y);
  70.   vec3 p2 = vec3(a1.xy,h.z);
  71.   vec3 p3 = vec3(a1.zw,h.w);
  73. //Normalise gradients
  74.   vec4 norm = taylorInvSqrt(vec4(dot(p0,p0), dot(p1,p1), dot(p2, p2), dot(p3,p3)));
  75.   p0 *= norm.x;
  76.   p1 *= norm.y;
  77.   p2 *= norm.z;
  78.   p3 *= norm.w;
  80. // Mix final noise value
  81.   vec4 m = max(0.6 - vec4(dot(x0,x0), dot(x1,x1), dot(x2,x2), dot(x3,x3)), 0.0);
  82.   m = m * m;
  83.   return 42.0 * dot( m*m, vec4( dot(p0,x0), dot(p1,x1), 
  84.                                 dot(p2,x2), dot(p3,x3) ) );
  85. }
  87. vec3 permute(vec3 x) { return mod(((x*34.0)+1.0)*x, 289.0); }
  89. float snoise(vec2 v){
  90.   const vec4 C = vec4(0.211324865405187, 0.366025403784439,
  91.            -0.577350269189626, 0.024390243902439);
  92.   vec2 i  = floor(v + dot(v, C.yy) );
  93.   vec2 x0 = v -   i + dot(i, C.xx);
  94.   vec2 i1;
  95.   i1 = (x0.x > x0.y) ? vec2(1.0, 0.0) : vec2(0.0, 1.0);
  96.   vec4 x12 = x0.xyxy + C.xxzz;
  97.   x12.xy -= i1;
  98.   i = mod(i, 289.0);
  99.   vec3 p = permute( permute( i.y + vec3(0.0, i1.y, 1.0 ))
  100.   + i.x + vec3(0.0, i1.x, 1.0 ));
  101.   vec3 m = max(0.5 - vec3(dot(x0,x0), dot(x12.xy,x12.xy),
  102.     dot(x12.zw,x12.zw)), 0.0);
  103.   m = m*m ;
  104.   m = m*m ;
  105.   vec3 x = 2.0 * fract(p * C.www) - 1.0;
  106.   vec3 h = abs(x) - 0.5;
  107.   vec3 ox = floor(x + 0.5);
  108.   vec3 a0 = x - ox;
  109.   m *= 1.79284291400159 - 0.85373472095314 * ( a0*a0 + h*h );
  110.   vec3 g;
  111.   g.x  = a0.x  * x0.x  + h.x  * x0.y;
  112.   g.yz = a0.yz * x12.xz + h.yz * x12.yw;
  113.   return 130.0 * dot(m, g);
  114. }
  116. float sumOctaves(int iterations, vec3 pos, double persistance, double scale, double low, double high){
  117. 	double maxamp = 0;
  118. 	double amp = 1;
  119. 	double frequency = scale;
  120. 	double noise = 0;
  121. 	
  122. 	for(int i = 0; i<iterations; i++){
  123. 		noise += snoise(vec3(pos.x*frequency, pos.y*frequency, pos.z*frequency))*amp;
  124. 		maxamp += amp;
  125. 		amp *= persistance;
  126. 		frequency *= 2;
  127. 	}
  128. 	
  129. 	noise /= maxamp;
  130. 	
  131. 	noise = noise * (high - low) / 2 + (high + low) / 2;
  132. 	return float(noise);
  133. }
  134. float sumOctaves(int iterations, vec2 pos, double persistance, double scale, double low, double high){
  135. 	double maxamp = 0;
  136. 	double amp = 1;
  137. 	double frequency = scale;
  138. 	double noise = 0;
  139. 	
  140. 	for(int i = 0; i<iterations; i++){
  141. 		noise += snoise(vec2(pos.x*frequency, pos.y*frequency))*amp;
  142. 		maxamp += amp;
  143. 		amp *= persistance;
  144. 		frequency *= 2;
  145. 	}
  146. 	
  147. 	noise /= maxamp;
  148. 	
  149. 	noise = noise * (high - low) / 2 + (high + low) / 2;
  150. 	return float(noise);
  151. }
  153. int getPosition(vec3 v){
  154. 	return int(v.x+v.z*size+v.y*size*size);
  155. }
  156. int getPosition(vec2 v){
  157. 	return int(v.x+v.y*size);
  158. }
  159. void main(){
  160. 	if(gl_GlobalInvocationID.x < size && gl_GlobalInvocationID.y < size && gl_GlobalInvocationID.z < size){
  161. 	    Position3D[getPosition(gl_GlobalInvocationID)] = sumOctaves(4,gl_GlobalInvocationID,0.5,0.01,0,1);
  162. 	    Position2D[getPosition(gl_GlobalInvocationID.xz)] = sumOctaves(4,gl_GlobalInvocationID.xz,0.5,0.01,0,1);
  163. 	}
  164. }

Java Simplex Noise Code

  1. public class SimplexNoise {  /[![enter image description here][1]][1]/ Simplex noise in 2D, 3D and 4D
  2.   private static Grad grad3[] = {new Grad(1,1,0),new Grad(-1,1,0),new Grad(1,-1,0),new Grad(-1,-1,0),
  3.                                  new Grad(1,0,1),new Grad(-1,0,1),new Grad(1,0,-1),new Grad(-1,0,-1),
  4.                                  new Grad(0,1,1),new Grad(0,-1,1),new Grad(0,1,-1),new Grad(0,-1,-1)};
  6.   private static Grad grad4[]= {new Grad(0,1,1,1),new Grad(0,1,1,-1),new Grad(0,1,-1,1),new Grad(0,1,-1,-1),
  7.                    new Grad(0,-1,1,1),new Grad(0,-1,1,-1),new Grad(0,-1,-1,1),new Grad(0,-1,-1,-1),
  8.                    new Grad(1,0,1,1),new Grad(1,0,1,-1),new Grad(1,0,-1,1),new Grad(1,0,-1,-1),
  9.                    new Grad(-1,0,1,1),new Grad(-1,0,1,-1),new Grad(-1,0,-1,1),new Grad(-1,0,-1,-1),
  10.                    new Grad(1,1,0,1),new Grad(1,1,0,-1),new Grad(1,-1,0,1),new Grad(1,-1,0,-1),
  11.                    new Grad(-1,1,0,1),new Grad(-1,1,0,-1),new Grad(-1,-1,0,1),new Grad(-1,-1,0,-1),
  12.                    new Grad(1,1,1,0),new Grad(1,1,-1,0),new Grad(1,-1,1,0),new Grad(1,-1,-1,0),
  13.                    new Grad(-1,1,1,0),new Grad(-1,1,-1,0),new Grad(-1,-1,1,0),new Grad(-1,-1,-1,0)};
  15.   private static short p[] = {151,160,137,91,90,15,
  16.   131,13,201,95,96,53,194,233,7,225,140,36,103,30,69,142,8,99,37,240,21,10,23,
  17.   190, 6,148,247,120,234,75,0,26,197,62,94,252,219,203,117,35,11,32,57,177,33,
  18.   88,237,149,56,87,174,20,125,136,171,168, 68,175,74,165,71,134,139,48,27,166,
  19.   77,146,158,231,83,111,229,122,60,211,133,230,220,105,92,41,55,46,245,40,244,
  20.   102,143,54, 65,25,63,161, 1,216,80,73,209,76,132,187,208, 89,18,169,200,196,
  21.   135,130,116,188,159,86,164,100,109,198,173,186, 3,64,52,217,226,250,124,123,
  22.   5,202,38,147,118,126,255,82,85,212,207,206,59,227,47,16,58,17,182,189,28,42,
  23.   223,183,170,213,119,248,152, 2,44,154,163, 70,221,153,101,155,167, 43,172,9,
  24.   129,22,39,253, 19,98,108,110,79,113,224,232,178,185, 112,104,218,246,97,228,
  25.   251,34,242,193,238,210,144,12,191,179,162,241, 81,51,145,235,249,14,239,107,
  26.   49,192,214, 31,181,199,106,157,184, 84,204,176,115,121,50,45,127, 4,150,254,
  27.   138,236,205,93,222,114,67,29,24,72,243,141,128,195,78,66,215,61,156,180};
  28.   // To remove the need for index wrapping, double the permutation table length
  29.   private static short perm[] = new short[512];
  30.   private static short permMod12[] = new short[512];
  31.   static {
  32.     for(int i=0; i<512; i++)
  33.     {
  34.       perm[i]=p[i & 255];
  35.       permMod12[i] = (short)(perm[i] % 12);
  36.     }
  37.   }
  39.   // Skewing and unskewing factors for 2, 3, and 4 dimensions
  40.   private static final double F2 = 0.5*(Math.sqrt(3.0)-1.0);
  41.   private static final double G2 = (3.0-Math.sqrt(3.0))/6.0;
  42.   private static final double F3 = 1.0/3.0;
  43.   private static final double G3 = 1.0/6.0;
  44.   private static final double F4 = (Math.sqrt(5.0)-1.0)/4.0;
  45.   private static final double G4 = (5.0-Math.sqrt(5.0))/20.0;
  47.   // This method is a *lot* faster than using (int)Math.floor(x)
  48.   private static int fastfloor(double x) {
  49.     int xi = (int)x;
  50.     return x<xi ? xi-1 : xi;
  51.   }
  53.   private static double dot(Grad g, double x, double y) {
  54.     return g.x*x + g.y*y; }
  56.   private static double dot(Grad g, double x, double y, double z) {
  57.     return g.x*x + g.y*y + g.z*z; }
  59.   private static double dot(Grad g, double x, double y, double z, double w) {
  60.     return g.x*x + g.y*y + g.z*z + g.w*w; }
  63.   // 2D simplex noise
  64.   public static double noise(double xin, double yin) {
  65.     double n0, n1, n2; // Noise contributions from the three corners
  66.     // Skew the input space to determine which simplex cell we're in
  67.     double s = (xin+yin)*F2; // Hairy factor for 2D
  68.     int i = fastfloor(xin+s);
  69.     int j = fastfloor(yin+s);
  70.     double t = (i+j)*G2;
  71.     double X0 = i-t; // Unskew the cell origin back to (x,y) space
  72.     double Y0 = j-t;
  73.     double x0 = xin-X0; // The x,y distances from the cell origin
  74.     double y0 = yin-Y0;
  75.     // For the 2D case, the simplex shape is an equilateral triangle.
  76.     // Determine which simplex we are in.
  77.     int i1, j1; // Offsets for second (middle) corner of simplex in (i,j) coords
  78.     if(x0>y0) {i1=1; j1=0;} // lower triangle, XY order: (0,0)->(1,0)->(1,1)
  79.     else {i1=0; j1=1;}      // upper triangle, YX order: (0,0)->(0,1)->(1,1)
  80.     // A step of (1,0) in (i,j) means a step of (1-c,-c) in (x,y), and
  81.     // a step of (0,1) in (i,j) means a step of (-c,1-c) in (x,y), where
  82.     // c = (3-sqrt(3))/6
  83.     double x1 = x0 - i1 + G2; // Offsets for middle corner in (x,y) unskewed coords
  84.     double y1 = y0 - j1 + G2;
  85.     double x2 = x0 - 1.0 + 2.0 * G2; // Offsets for last corner in (x,y) unskewed coords
  86.     double y2 = y0 - 1.0 + 2.0 * G2;
  87.     // Work out the hashed gradient indices of the three simplex corners
  88.     int ii = i & 255;
  89.     int jj = j & 255;
  90.     int gi0 = permMod12[ii+perm[jj]];
  91.     int gi1 = permMod12[ii+i1+perm[jj+j1]];
  92.     int gi2 = permMod12[ii+1+perm[jj+1]];
  93.     // Calculate the contribution from the three corners
  94.     double t0 = 0.5 - x0*x0-y0*y0;
  95.     if(t0<0) n0 = 0.0;
  96.     else {
  97.       t0 *= t0;
  98.       n0 = t0 * t0 * dot(grad3[gi0], x0, y0);  // (x,y) of grad3 used for 2D gradient
  99.     }
  100.     double t1 = 0.5 - x1*x1-y1*y1;
  101.     if(t1<0) n1 = 0.0;
  102.     else {
  103.       t1 *= t1;
  104.       n1 = t1 * t1 * dot(grad3[gi1], x1, y1);
  105.     }
  106.     double t2 = 0.5 - x2*x2-y2*y2;
  107.     if(t2<0) n2 = 0.0;
  108.     else {
  109.       t2 *= t2;
  110.       n2 = t2 * t2 * dot(grad3[gi2], x2, y2);
  111.     }
  112.     // Add contributions from each corner to get the final noise value.
  113.     // The result is scaled to return values in the interval [-1,1].
  114.     return 70.0 * (n0 + n1 + n2);
  115.   }
  118.   // 3D simplex noise
  119.   public static double noise(double xin, double yin, double zin) {
  120.     double n0, n1, n2, n3; // Noise contributions from the four corners
  121.     // Skew the input space to determine which simplex cell we're in
  122.     double s = (xin+yin+zin)*F3; // Very nice and simple skew factor for 3D
  123.     int i = fastfloor(xin+s);
  124.     int j = fastfloor(yin+s);
  125.     int k = fastfloor(zin+s);
  126.     double t = (i+j+k)*G3;
  127.     double X0 = i-t; // Unskew the cell origin back to (x,y,z) space
  128.     double Y0 = j-t;
  129.     double Z0 = k-t;
  130.     double x0 = xin-X0; // The x,y,z distances from the cell origin
  131.     double y0 = yin-Y0;
  132.     double z0 = zin-Z0;
  133.     // For the 3D case, the simplex shape is a slightly irregular tetrahedron.
  134.     // Determine which simplex we are in.
  135.     int i1, j1, k1; // Offsets for second corner of simplex in (i,j,k) coords
  136.     int i2, j2, k2; // Offsets for third corner of simplex in (i,j,k) coords
  137.     if(x0>=y0) {
  138.       if(y0>=z0)
  139.         { i1=1; j1=0; k1=0; i2=1; j2=1; k2=0; } // X Y Z order
  140.         else if(x0>=z0) { i1=1; j1=0; k1=0; i2=1; j2=0; k2=1; } // X Z Y order
  141.         else { i1=0; j1=0; k1=1; i2=1; j2=0; k2=1; } // Z X Y order
  142.       }
  143.     else { // x0<y0
  144.       if(y0<z0) { i1=0; j1=0; k1=1; i2=0; j2=1; k2=1; } // Z Y X order
  145.       else if(x0<z0) { i1=0; j1=1; k1=0; i2=0; j2=1; k2=1; } // Y Z X order
  146.       else { i1=0; j1=1; k1=0; i2=1; j2=1; k2=0; } // Y X Z order
  147.     }
  148.     // A step of (1,0,0) in (i,j,k) means a step of (1-c,-c,-c) in (x,y,z),
  149.     // a step of (0,1,0) in (i,j,k) means a step of (-c,1-c,-c) in (x,y,z), and
  150.     // a step of (0,0,1) in (i,j,k) means a step of (-c,-c,1-c) in (x,y,z), where
  151.     // c = 1/6.
  152.     double x1 = x0 - i1 + G3; // Offsets for second corner in (x,y,z) coords
  153.     double y1 = y0 - j1 + G3;
  154.     double z1 = z0 - k1 + G3;
  155.     double x2 = x0 - i2 + 2.0*G3; // Offsets for third corner in (x,y,z) coords
  156.     double y2 = y0 - j2 + 2.0*G3;
  157.     double z2 = z0 - k2 + 2.0*G3;
  158.     double x3 = x0 - 1.0 + 3.0*G3; // Offsets for last corner in (x,y,z) coords
  159.     double y3 = y0 - 1.0 + 3.0*G3;
  160.     double z3 = z0 - 1.0 + 3.0*G3;
  161.     // Work out the hashed gradient indices of the four simplex corners
  162.     int ii = i & 255;
  163.     int jj = j & 255;
  164.     int kk = k & 255;
  165.     int gi0 = permMod12[ii+perm[jj+perm[kk]]];
  166.     int gi1 = permMod12[ii+i1+perm[jj+j1+perm[kk+k1]]];
  167.     int gi2 = permMod12[ii+i2+perm[jj+j2+perm[kk+k2]]];
  168.     int gi3 = permMod12[ii+1+perm[jj+1+perm[kk+1]]];
  169.     // Calculate the contribution from the four corners
  170.     double t0 = 0.6 - x0*x0 - y0*y0 - z0*z0;
  171.     if(t0<0) n0 = 0.0;
  172.     else {
  173.       t0 *= t0;
  174.       n0 = t0 * t0 * dot(grad3[gi0], x0, y0, z0);
  175.     }
  176.     double t1 = 0.6 - x1*x1 - y1*y1 - z1*z1;
  177.     if(t1<0) n1 = 0.0;
  178.     else {
  179.       t1 *= t1;
  180.       n1 = t1 * t1 * dot(grad3[gi1], x1, y1, z1);
  181.     }
  182.     double t2 = 0.6 - x2*x2 - y2*y2 - z2*z2;
  183.     if(t2<0) n2 = 0.0;
  184.     else {
  185.       t2 *= t2;
  186.       n2 = t2 * t2 * dot(grad3[gi2], x2, y2, z2);
  187.     }
  188.     double t3 = 0.6 - x3*x3 - y3*y3 - z3*z3;
  189.     if(t3<0) n3 = 0.0;
  190.     else {
  191.       t3 *= t3;
  192.       n3 = t3 * t3 * dot(grad3[gi3], x3, y3, z3);
  193.     }
  194.     // Add contributions from each corner to get the final noise value.
  195.     return 32.0*(n0 + n1 + n2 + n3);
  196.   }
  199.   // 4D simplex noise, better simplex rank ordering method 2012-03-09
  200.   public static double noise(double x, double y, double z, double w) {
  202.     double n0, n1, n2, n3, n4; // Noise contributions from the five corners
  203.     // Skew the (x,y,z,w) space to determine which cell of 24 simplices we're in
  204.     double s = (x + y + z + w) * F4; // Factor for 4D skewing
  205.     int i = fastfloor(x + s);
  206.     int j = fastfloor(y + s);
  207.     int k = fastfloor(z + s);
  208.     int l = fastfloor(w + s);
  209.     double t = (i + j + k + l) * G4; // Factor for 4D unskewing
  210.     double X0 = i - t; // Unskew the cell origin back to (x,y,z,w) space
  211.     double Y0 = j - t;
  212.     double Z0 = k - t;
  213.     double W0 = l - t;
  214.     double x0 = x - X0;  // The x,y,z,w distances from the cell origin
  215.     double y0 = y - Y0;
  216.     double z0 = z - Z0;
  217.     double w0 = w - W0;
  218.     // For the 4D case, the simplex is a 4D shape I won't even try to describe.
  219.     // To find out which of the 24 possible simplices we're in, we need to
  220.     // determine the magnitude ordering of x0, y0, z0 and w0.
  221.     // Six pair-wise comparisons are performed between each possible pair
  222.     // of the four coordinates, and the results are used to rank the numbers.
  223.     int rankx = 0;
  224.     int ranky = 0;
  225.     int rankz = 0;
  226.     int rankw = 0;
  227.     if(x0 > y0) rankx++; else ranky++;
  228.     if(x0 > z0) rankx++; else rankz++;
  229.     if(x0 > w0) rankx++; else rankw++;
  230.     if(y0 > z0) ranky++; else rankz++;
  231.     if(y0 > w0) ranky++; else rankw++;
  232.     if(z0 > w0) rankz++; else rankw++;
  233.     int i1, j1, k1, l1; // The integer offsets for the second simplex corner
  234.     int i2, j2, k2, l2; // The integer offsets for the third simplex corner
  235.     int i3, j3, k3, l3; // The integer offsets for the fourth simplex corner
  236.     // [rankx, ranky, rankz, rankw] is a 4-vector with the numbers 0, 1, 2 and 3
  237.     // in some order. We use a thresholding to set the coordinates in turn.
  238. 	// Rank 3 denotes the largest coordinate.
  239.     i1 = rankx >= 3 ? 1 : 0;
  240.     j1 = ranky >= 3 ? 1 : 0;
  241.     k1 = rankz >= 3 ? 1 : 0;
  242.     l1 = rankw >= 3 ? 1 : 0;
  243.     // Rank 2 denotes the second largest coordinate.
  244.     i2 = rankx >= 2 ? 1 : 0;
  245.     j2 = ranky >= 2 ? 1 : 0;
  246.     k2 = rankz >= 2 ? 1 : 0;
  247.     l2 = rankw >= 2 ? 1 : 0;
  248.     // Rank 1 denotes the second smallest coordinate.
  249.     i3 = rankx >= 1 ? 1 : 0;
  250.     j3 = ranky >= 1 ? 1 : 0;
  251.     k3 = rankz >= 1 ? 1 : 0;
  252.     l3 = rankw >= 1 ? 1 : 0;
  253.     // The fifth corner has all coordinate offsets = 1, so no need to compute that.
  254.     double x1 = x0 - i1 + G4; // Offsets for second corner in (x,y,z,w) coords
  255.     double y1 = y0 - j1 + G4;
  256.     double z1 = z0 - k1 + G4;
  257.     double w1 = w0 - l1 + G4;
  258.     double x2 = x0 - i2 + 2.0*G4; // Offsets for third corner in (x,y,z,w) coords
  259.     double y2 = y0 - j2 + 2.0*G4;
  260.     double z2 = z0 - k2 + 2.0*G4;
  261.     double w2 = w0 - l2 + 2.0*G4;
  262.     double x3 = x0 - i3 + 3.0*G4; // Offsets for fourth corner in (x,y,z,w) coords
  263.     double y3 = y0 - j3 + 3.0*G4;
  264.     double z3 = z0 - k3 + 3.0*G4;
  265.     double w3 = w0 - l3 + 3.0*G4;
  266.     double x4 = x0 - 1.0 + 4.0*G4; // Offsets for last corner in (x,y,z,w) coords
  267.     double y4 = y0 - 1.0 + 4.0*G4;
  268.     double z4 = z0 - 1.0 + 4.0*G4;
  269.     double w4 = w0 - 1.0 + 4.0*G4;
  270.     // Work out the hashed gradient indices of the five simplex corners
  271.     int ii = i & 255;
  272.     int jj = j & 255;
  273.     int kk = k & 255;
  274.     int ll = l & 255;
  275.     int gi0 = perm[ii+perm[jj+perm[kk+perm[ll]]]] % 32;
  276.     int gi1 = perm[ii+i1+perm[jj+j1+perm[kk+k1+perm[ll+l1]]]] % 32;
  277.     int gi2 = perm[ii+i2+perm[jj+j2+perm[kk+k2+perm[ll+l2]]]] % 32;
  278.     int gi3 = perm[ii+i3+perm[jj+j3+perm[kk+k3+perm[ll+l3]]]] % 32;
  279.     int gi4 = perm[ii+1+perm[jj+1+perm[kk+1+perm[ll+1]]]] % 32;
  280.     // Calculate the contribution from the five corners
  281.     double t0 = 0.6 - x0*x0 - y0*y0 - z0*z0 - w0*w0;
  282.     if(t0<0) n0 = 0.0;
  283.     else {
  284.       t0 *= t0;
  285.       n0 = t0 * t0 * dot(grad4[gi0], x0, y0, z0, w0);
  286.     }
  287.    double t1 = 0.6 - x1*x1 - y1*y1 - z1*z1 - w1*w1;
  288.     if(t1<0) n1 = 0.0;
  289.     else {
  290.       t1 *= t1;
  291.       n1 = t1 * t1 * dot(grad4[gi1], x1, y1, z1, w1);
  292.     }
  293.    double t2 = 0.6 - x2*x2 - y2*y2 - z2*z2 - w2*w2;
  294.     if(t2<0) n2 = 0.0;
  295.     else {
  296.       t2 *= t2;
  297.       n2 = t2 * t2 * dot(grad4[gi2], x2, y2, z2, w2);
  298.     }
  299.    double t3 = 0.6 - x3*x3 - y3*y3 - z3*z3 - w3*w3;
  300.     if(t3<0) n3 = 0.0;
  301.     else {
  302.       t3 *= t3;
  303.       n3 = t3 * t3 * dot(grad4[gi3], x3, y3, z3, w3);
  304.     }
  305.    double t4 = 0.6 - x4*x4 - y4*y4 - z4*z4 - w4*w4;
  306.     if(t4<0) n4 = 0.0;
  307.     else {
  308.       t4 *= t4;
  309.       n4 = t4 * t4 * dot(grad4[gi4], x4, y4, z4, w4);
  310.     }
  311.     // Sum up and scale the result to cover the range [-1,1]
  312.     return 27.0 * (n0 + n1 + n2 + n3 + n4);
  313.   }
  315.   // Inner class to speed upp gradient computations
  316.   // (In Java, array access is a lot slower than member access)
  317.   private static class Grad
  318.   {
  319.     double x, y, z, w;
  321.     Grad(double x, double y, double z)
  322.     {
  323.       this.x = x;
  324.       this.y = y;
  325.       this.z = z;
  326.     }
  328.     Grad(double x, double y, double z, double w)
  329.     {
  330.       this.x = x;
  331.       this.y = y;
  332.       this.z = z;
  333.       this.w = w;
  334.     }
  335.   }
  336. }

Both code is rendered using the same octave, frequency and amplitude.
Java Simplex Noise Render
为什么我的GLSL简单噪声质量比在Java上运行的要差很多呢？

GLSL Simplex Noise Render
为什么我的GLSL简单噪声质量比在Java上运行的要差很多呢？

huangapple
  • 本文由 发表于 2020年7月23日 10:34:39
  • 转载请务必保留本文链接：https://java.coder-hub.com/63046006.html
匿名

发表评论

匿名网友

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen:

确定